@@ -231,7 +231,8 @@
 
     lines.forEach((line, index) => {
       const lineNumber = index + 1;
-      const codeOnly = withoutQuotedText(line);
+      // A word starting with # begins a comment that runs to the end of the line.
+      const codeOnly = withoutQuotedText(line).replace(/(^|\s)#.*$/, "$1");
       if (/(^|\s)\.\.\.(?=\s|$)/.test(codeOnly)) {
         diagnostics.push({
           severity: "error",
 
@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+
+// Runs the real Blocks block definitions, code generator and workspace checks
+// in a headless Blockly workspace (no browser page).
+const require = createRequire(import.meta.url);
+const toolingDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const repositoryDirectory = path.resolve(toolingDirectory, "..");
+const Blockly = require(path.join(toolingDirectory, "node_modules", "blockly"));
+const core = require(path.join(toolingDirectory, "shared", "ser-language-core.js"));
+const { SER_TRUTH_TABLE } = require(
+  path.join(repositoryDirectory, "VS Code Extension", "out", "ser_method_info.js")
+);
+const editorSource = fs.readFileSync(
+  path.join(toolingDirectory, "visual-editor", "src", "editor.js"),
+  "utf8"
+);
+
+function sliceBetween(source, startMarker, endMarker) {
+  const start = startMarker ? source.indexOf(startMarker) : 0;
+  const end = source.indexOf(endMarker);
+  assert.ok(start >= 0 && end > start, `editor.js no longer contains ${startMarker || "its start"}…${endMarker}`);
+  return source.slice(start, end);
+}
+
+function createHeadlessEditor() {
+  const definitions = sliceBetween(editorSource, null, "  function shadow(");
+  const checks = sliceBetween(editorSource, "  function entryAncestor(", "  function renderDiagnostics(");
+  const context = { Blockly, SER_TRUTH_TABLE, SERLanguageCore: core, console };
+  vm.createContext(context);
+  vm.runInContext(
+    `${definitions}
+    const workspace = new Blockly.Workspace();
+    globalThis.workspace = workspace;
+    globalThis.generator = serGenerator;
+    ${checks}
+    globalThis.check = workspaceDiagnostics;
+    })();`,
+    context
+  );
+  return context;
+}
+
+function addRoot(editor, type, y, message, fields = {}) {
+  const root = editor.workspace.newBlock(type);
+  for (const [name, value] of Object.entries(fields)) root.setFieldValue(value, name);
+  root.moveBy(0, y);
+  const action = editor.workspace.newBlock("ser_broadcast");
+  const text = editor.workspace.newBlock("ser_text");
+  text.setFieldValue(message, "TEXT");
+  action.getInput("MESSAGE").connection.connect(text.outputConnection);
+  const target = editor.workspace.newBlock("ser_target");
+  action.getInput("TARGET").connection.connect(target.outputConnection);
+  const duration = editor.workspace.newBlock("ser_duration");
+  action.getInput("DURATION").connection.connect(duration.outputConnection);
+  root.getInput("DO").connection.connect(action.previousConnection);
+  return root;
+}
+
+function diagnosticsFor(editor) {
+  const code = editor.generator.workspaceToCode(editor.workspace).trimEnd();
+  // Copy out of the sandbox so assertions compare plain arrays from this realm.
+  return JSON.parse(JSON.stringify(editor.check(code)));
+}
+
+function errorCodes(diagnostics) {
+  return diagnostics.filter(item => item.severity === "error").map(item => item.code);
+}
+
+test("blocks a manual start mixed with an event start, in either order", () => {
+  // C01: placed first, SER rejects the file; placed last, the manual actions run on the event.
+  for (const manualFirst of [true, false]) {
+    const editor = createHeadlessEditor();
+    addRoot(editor, "ser_when_manual", manualFirst ? 0 : 400, "manual");
+    addRoot(editor, "ser_when_event", 200, "event", { EVENT: "RoundStarted" });
+
+    const diagnostics = diagnosticsFor(editor);
+    assert.deepEqual(errorCodes(diagnostics), ["mixed-manual-entry"]);
+    assert.match(
+      diagnostics.find(item => item.code === "mixed-manual-entry").message,
+      /separate script/
+    );
+  }
+});
+
+test("blocks a manual start mixed with a command start", () => {
+  const editor = createHeadlessEditor();
+  addRoot(editor, "ser_when_command", 0, "command", { COMMAND: "heal" });
+  addRoot(editor, "ser_when_manual", 200, "manual");
+
+  assert.deepEqual(errorCodes(diagnosticsFor(editor)), ["mixed-manual-entry"]);
+});
+
+test("blocks more than one manual start", () => {
+  const editor = createHeadlessEditor();
+  addRoot(editor, "ser_when_manual", 0, "first");
+  addRoot(editor, "ser_when_manual", 200, "second");
+
+  const diagnostics = diagnosticsFor(editor);
+  assert.deepEqual(errorCodes(diagnostics), ["multiple-manual-entries"]);
+  assert.match(
+    diagnostics.find(item => item.code === "multiple-manual-entries").message,
+    /separate script/
+  );
+});
+
+test("still allows one manual start, and several event or command starts", () => {
+  const manual = createHeadlessEditor();
+  addRoot(manual, "ser_when_manual", 0, "manual");
+  assert.deepEqual(errorCodes(diagnosticsFor(manual)), []);
+
+  // SER splits a file into one part per event or command start.
+  const flagged = createHeadlessEditor();
+  addRoot(flagged, "ser_when_event", 0, "event", { EVENT: "RoundStarted" });
+  addRoot(flagged, "ser_when_command", 200, "command", { COMMAND: "heal" });
+  assert.deepEqual(errorCodes(diagnosticsFor(flagged)), []);
+});
@@ -60,3 +60,75 @@ test("tracks the active method argument after tilde-escaped quotes", () => {
   assert.equal(context.methodName, "Notify");
   assert.equal(context.activeArgument, 3);
 });
+
+const shippedManifest = require(
+  path.join(repositoryDirectory, "VS Code Extension", "out", "ser-language.json")
+);
+
+test("counts only arguments before the cursor when it sits in whitespace", () => {
+  // A18: editing `SetRole @all  ClassD` with the cursor before ClassD asks for the role.
+  const line = "SetRole @all  ClassD";
+  const cursor = line.indexOf("ClassD") - 1;
+  const context = editorLogic.getMethodCallContext(line, cursor, shippedManifest.methods);
+
+  assert.equal(context.methodName, "SetRole");
+  assert.equal(context.activeArgument, 1);
+  assert.equal(shippedManifest.methods.SetRole.arguments[context.activeArgument].name, "newRole");
+
+  const trailing = "SetRole @all ";
+  assert.equal(
+    editorLogic.getMethodCallContext(trailing, trailing.length, shippedManifest.methods).activeArgument,
+    1
+  );
+});
+
+test("resolves the method inside text interpolation", () => {
+  // A19: `{ToDuration 3 }` inside quoted text is its own method call.
+  const line = 'Print "Delay: {ToDuration 3 }"';
+  const context = editorLogic.getMethodCallContext(
+    line,
+    line.indexOf("}"),
+    shippedManifest.methods
+  );
+
+  assert.equal(context.methodName, "ToDuration");
+  assert.equal(context.activeArgument, 1);
+  assert.equal(shippedManifest.methods.ToDuration.arguments[1].name, "unit");
+});
+
+test("resolves interpolation while the closing quote is not typed yet", () => {
+  const line = 'Print "Delay: {ToDuration 3 ';
+  const context = editorLogic.getMethodCallContext(line, line.length, shippedManifest.methods);
+
+  assert.equal(context.methodName, "ToDuration");
+  assert.equal(context.activeArgument, 1);
+});
+
+test("keeps tilde-escaped interpolation braces as plain text for method context", () => {
+  const line = 'Print "literal ~{ToDuration 3 }"';
+  const context = editorLogic.getMethodCallContext(
+    line,
+    line.indexOf("}"),
+    shippedManifest.methods
+  );
+
+  assert.equal(context.methodName, "Print");
+  assert.equal(context.activeArgument, 0);
+});
+
+test("handles quoted text nested inside an interpolation", () => {
+  const methods = {
+    Print: { arguments: [{ syntax: "\"text\"" }] },
+    Join: { arguments: [{ syntax: "\"first\"" }, { syntax: "\"second\"" }] }
+  };
+  const line = 'Print "a {Join "x}" } b"';
+  const cursor = line.lastIndexOf("}");
+  const context = editorLogic.getMethodCallContext(line, cursor, methods);
+
+  assert.equal(context.methodName, "Join");
+  assert.equal(context.activeArgument, 1);
+  assert.deepEqual(
+    editorLogic.tokenizeSerExpression(line).map(token => token.text),
+    ["Print", '"a {Join "x}" } b"']
+  );
+});
@@ -111,3 +111,15 @@ test("warns when a forever loop has no wait", () => {
   const diagnostics = core.validateGeneratedCode("forever\nPrint \"busy\"\nend\n");
   assert.ok(diagnostics.some(item => item.code === "forever-without-wait"));
 });
+
+test("does not treat ellipses in comments as missing inputs", () => {
+  // A20: comment lines are valid SER and must not get a block-input error.
+  assert.deepEqual(core.validateGeneratedCode('# ...\nPrint "hello"'), []);
+  assert.deepEqual(core.validateGeneratedCode('    # todo ...\nPrint "hello"'), []);
+  assert.deepEqual(core.validateGeneratedCode('Print "hello" # ...'), []);
+  assert.equal(
+    core.validateGeneratedCode('# note\nBroadcast @all ... "hi"')
+      .filter(item => item.code === "missing-value").map(item => item.line).join(),
+    "2"
+  );
+});
@@ -952,6 +952,26 @@
       });
     }
 
+    // SER can split one file into several event or command parts, but a
+    // manual part has no start line of its own. Placed above them, SER rejects
+    // the file; placed below, its actions join the part above it.
+    const manualEntries = entries.filter(entry => entry.type === "ser_when_manual");
+    if (manualEntries.length > 1) {
+      diagnostics.push({
+        severity: "error",
+        code: "multiple-manual-entries",
+        message: "A script can have only one “when I run this script manually” block. " +
+          "Put all its actions in one block, or save each one as a separate script."
+      });
+    } else if (manualEntries.length === 1 && entries.length > 1) {
+      diagnostics.push({
+        severity: "error",
+        code: "mixed-manual-entry",
+        message: "“When I run this script manually” can't share a script with an event or command. " +
+          "Save the manual part as a separate script."
+      });
+    }
+
     for (const entry of entries) {
       if (!entry.getInputTargetBlock("DO")) {
         diagnostics.push({
@@ -1530,12 +1550,14 @@
 
   elements.download.addEventListener("click", () => {
     if (elements.download.disabled) return;
-    downloadText(
-      safeFilename(elements.scriptName.value, "ser"),
-      elements.codeOutput.value,
-      "text/plain;charset=utf-8"
-    );
-    showToast("Downloaded. Put it in the SER script directory, then run serrun or serreload.");
+    const filename = safeFilename(elements.scriptName.value, "ser");
+    downloadText(filename, elements.codeOutput.value, "text/plain;charset=utf-8");
+    // Event and command scripts only start working after serreload picks them up.
+    const isManualScript = workspace.getAllBlocks(false)
+      .every(block => !ENTRY_TYPES.has(block.type) || block.type === "ser_when_manual");
+    showToast(isManualScript
+      ? `Downloaded. Put it in the SER script directory, then run serrun ${filename.replace(/\.ser$/, "")}.`
+      : "Downloaded. Put it in the SER script directory, then run serreload.");
   });
 
   elements.scriptName.addEventListener("input", scheduleAutosave);
 
@@ -88,7 +88,8 @@ <h2>Try it on your server</h2>
         <ol>
           <li>Put the file in the SER script directory shown by <code>serhelp start</code>.</li>
           <li>If your host blocks <code>.ser</code>, rename it to <code>.txt</code>.</li>
-          <li>For a new manual script, run <code>serrun name</code>. For edits, run <code>serreload</code>.</li>
+          <li>For a new event or command script, run <code>serreload</code>. Then make the event happen or type the command.</li>
+          <li>For a new manual script, run <code>serrun name</code>. After editing any script, run <code>serreload</code>.</li>
           <li>Use <code>serstatus</code> if it does not run.</li>
         </ol>
         <p>Blocks teaches common tasks. The text editor and VS Code extension expose the full language.</p>