@niroai/niro 0.17.0 → 0.18.0

package/src/lib/watchDaemon.js

@@ -31,8 +31,24 @@ const color = require("./color");
  *   "pm2_install_failed"  — `npm install -g pm2` exited non-zero
  *   "daemon_install_failed" — registering niro-watch under PM2 failed
  */
-async function ensureWatchDaemon({ skipPrompts = false } = {}) {
-  if (!service.pm2Available()) {
+async function ensureWatchDaemon({ skipPrompts = false, quiet = false, heading = null } = {}) {
+  // `heading`: the line niro start printed just above. Kept only while nothing is printed under it.
+  let sameLineAs = heading && process.stdout.isTTY ? heading : null;
+  if (!service.pm2Available() && quiet && !skipPrompts && !prompt.isNonInteractive()) {
+    // `niro start`: one question, and npm's output only if it fails. macOS and Linux then need
+    // sudo once for start-on-login (pm2 startup); Windows does not (a per-user Run key).
+    const what = process.platform === "win32" ? "installs PM2" : "installs PM2 and asks for a password";
+    sameLineAs = null;
+    if (!(await prompt.confirm(`  Keep the graph in sync? (${what})`, true))) return { ok: false, reason: "declined" };
+    console.log(color.dim("  Installing PM2…"));
+    if (!service.installPm2({ quiet: true })) {
+      // Windows installs global packages into the user's own folder, so sudo is no help there.
+      const retry = process.platform === "win32" ? "npm install -g pm2" : "sudo npm install -g pm2";
+      const cause = process.platform === "win32" ? "" : " (a permission error is the usual cause)";
+      console.log(`  ${color.yellow("⚠")} PM2 install failed${cause}. Try ${color.cyan(retry)} then ${color.cyan("niro service install")}`);
+      return { ok: false, reason: "pm2_install_failed" };
+    }
+  } else if (!service.pm2Available()) {
     console.log(`\n    ${color.yellow("⚠")} PM2 is not installed. Niro uses PM2 to keep your synced folders`);
     console.log(`    up to date in the background, including after a reboot.`);
 
@@ -56,22 +72,29 @@ async function ensureWatchDaemon({ skipPrompts = false } = {}) {
     console.log(`    ${color.green("✓")} PM2 installed.`);
   }
 
-  console.log(`\n    ${color.cyan("●")}  Installing niro-watch daemon (keeps your synced folders up to date, auto-starts on login)...`);
+  if (!quiet) console.log(`\n    ${color.cyan("●")}  Installing niro-watch daemon (keeps your synced folders up to date, auto-starts on login)...`);
   try {
     // install() returns false when pm2 turns out not to be runnable after
     // all — e.g. npm installed it into a global bin dir that isn't on PATH
     // (npm exits 0 for that). Treat it as the failure it is; the old code's
     // unchecked call here is how "✓ Done." lied to customers.
-    if (!service.install()) {
-      console.log(`        ${color.yellow("⚠")} PM2 was installed but isn't runnable from this shell (its global bin`);
-      console.log(`        directory may not be on your PATH). Open a NEW terminal and run ${color.cyan("niro service install")}.`);
+    const installed = service.install({ sameLineAs });
+    if (!installed) {
+      console.log(`    ${color.yellow("⚠")} PM2 was installed but isn't runnable from this shell (its global bin`);
+      console.log(`    directory may not be on your PATH). Open a NEW terminal and run ${color.cyan("niro service install")}.`);
       return { ok: false, reason: "daemon_install_failed" };
     }
-    console.log(`        ${color.green("✓")} niro-watch is running and will start automatically on login.`);
-    return { ok: true };
+    const autostart = installed !== "no_autostart";
+    // quiet: the caller (niro start) prints its own closing line from the result.
+    if (!quiet) {
+      console.log(autostart
+        ? `    ${color.green("✓")} niro-watch is running and will start automatically on login.`
+        : `    ${color.green("✓")} niro-watch is running, but will not restart after you log out.`);
+    }
+    return { ok: true, autostart };
   } catch (err) {
-    console.log(`        ${color.yellow("⚠")} Could not install the watch daemon: ${err.message}`);
-    console.log(`        Run ${color.cyan("niro service install")} to try again, or ${color.cyan("niro watch")} to sync manually.`);
+    console.log(`    ${color.yellow("⚠")} Could not install the watch daemon: ${err.message}`);
+    console.log(`    Run ${color.cyan("niro service install")} to try again, or ${color.cyan("niro watch")} to sync manually.`);
     return { ok: false, reason: "daemon_install_failed" };
   }
 }

package/src/lib/watchState.js

@@ -67,6 +67,17 @@ function load() {
   }
 }
 
+/**
+ * A release without the cloud keeps the Niro web folder list, renamed, so nothing reads it as
+ * folders to sync any more and the note about them is shown once. Never overwrites an earlier copy.
+ */
+const WEB_FILE = path.join(DIR, "projects.web.json");
+function retireToWeb(from = FILE, to = WEB_FILE) {
+  if (!fs.existsSync(from) || fs.existsSync(to)) return false;
+  fs.renameSync(from, to);
+  return true;
+}
+
 function save(state) {
   fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
   // Atomic write: a concurrent reader (the niro-watch daemon runs in a SEPARATE
@@ -255,4 +266,4 @@ function hashFile(filePath) {
 }
 
 module.exports = { get, peek, set, update, remove, allLocal, findOverlapping, matchesBackend, hashFile,
-  mergeFileHashes, FILE };
+  mergeFileHashes, FILE, WEB_FILE, retireToWeb };

package/src/lib/windowsPaths.js

@@ -0,0 +1,67 @@
+/**
+ * Two Windows-only safeguards for the programs niro starts: they start hidden (hideWindows, below), and they are
+ * never taken from the current folder. Windows looks for a bare program name in the current folder before the PATH,
+ * so a reg.exe, git.exe or pm2.cmd sitting in a cloned repository (or wherever niro is run from) would run
+ * instead of the real one. Two runtimes do that lookup, and they need different fixes (checked on
+ * Windows Server 2022, 2026-11-11, with planted files):
+ *
+ *   - cmd.exe, which starts pm2 and npm (`shell: true`), skips the current folder when
+ *     NoDefaultCurrentDirectoryInExePath is set. `harden` sets it once for this process and
+ *     everything it starts.
+ *   - Node's own spawn without a shell (libuv) ignores that variable, so a program started that way
+ *     is named by its full path: `system32` for Windows' own tools, `gitProgram` for git.
+ */
+const path = require("path");
+
+function harden(env = process.env, platform = process.platform) {
+  if (platform !== "win32") return;
+  env.NoDefaultCurrentDirectoryInExePath = "1";
+  hideWindows(require("child_process"), platform);
+}
+
+const STARTERS = ["spawn", "spawnSync", "execFile", "execFileSync", "exec", "execSync", "fork"];
+
+/**
+ * On Windows, every program niro starts starts hidden unless the caller asks for a window (`windowsHide: false`).
+ * Under PM2 the watcher has no console of its own, so each console program it started (the engine every 30 s, git)
+ * opened a console window of its own: on a desktop, a terminal flashed open and shut every few seconds (2026-11-11;
+ * on Windows Server 2022, 6 console windows in 90 s from one folder). One switch here rather than an option at each of
+ * the 60-odd places that start a program, so a new one cannot forget it. Elsewhere nothing changes.
+ */
+function hideWindows(childProcess, platform = process.platform) {
+  if (platform !== "win32") return;
+  for (const name of STARTERS) {
+    const original = childProcess[name];
+    if (typeof original !== "function" || original.niroHidden) continue;
+    const hidden = function (...args) {
+      return original.apply(this, withWindowHidden(args));
+    };
+    hidden.niroHidden = true;
+    childProcess[name] = hidden;
+  }
+}
+
+/** The same arguments, with `windowsHide: true` in the options object (added where none was given). */
+function withWindowHidden(args) {
+  const out = [...args];
+  const at = out.findIndex((arg, i) => i > 0 && arg && typeof arg === "object" && !Array.isArray(arg));
+  if (at !== -1) {
+    if (out[at].windowsHide === undefined) out[at] = { ...out[at], windowsHide: true };
+    return out;
+  }
+  // No options: they go after the argument list when there is one, and before a trailing callback.
+  out.splice(Array.isArray(out[1]) ? 2 : 1, 0, { windowsHide: true });
+  return out;
+}
+
+/** A tool Windows ships, by full path (reg.exe, tar.exe). */
+function system32(exe, env = process.env) {
+  return path.join(env.SystemRoot || "C:\\Windows", "System32", exe);
+}
+
+/** "git" elsewhere; on Windows git.exe's full path from the PATH, or null when git is not installed. */
+function gitProgram(platform = process.platform) {
+  return platform === "win32" ? require("./engine").onThePath("git.exe") : "git";
+}
+
+module.exports = { harden, hideWindows, system32, gitProgram };

package/src/mcp/lineCheck.js

@@ -0,0 +1,382 @@
+/**
+ * The Claude Code Stop hook that makes sure the end-of-task line is not forgotten.
+ *
+ * The line reaches the developer only if the assistant calls mark_task_complete and then copies
+ * what comes back. Assistants forget one or the other. This hook runs when the assistant is about
+ * to stop, looks at the turn that just ended, and when Niro tools answered and the reply has no
+ * line, it asks the assistant, once, to finish the job.
+ *
+ * **It prints nothing to the person.** An earlier Stop hook printed the line itself and Claude Code
+ * labelled that "Stop says: ...", which read as a system warning, so it was removed
+ * (docs/usecases/task-receipt.md). This one only returns a decision; the line is still written by
+ * the assistant, in backticks, the way every other client shows it.
+ *
+ * **It always lets the assistant stop when anything goes wrong.** A missing transcript, unreadable
+ * JSON, a turn too long to find inside the tail it reads, a transcript that does not catch up with
+ * the reply, or running out of its time budget all end in silence. A forgotten line costs one line; a hook that traps an assistant costs the session.
+ *
+ * **At most once per turn.** Claude Code sets `stop_hook_active` on the stop that follows a block,
+ * and on that stop this hook only records what happened.
+ *
+ * **Which turns.** Only tools from Niro's own servers (`mcp__niro__`, `mcp__niro-local__`), never
+ * `mcp__niro-memory__`, which is a different product with a line of its own. Only calls that
+ * answered: a call that failed gives no line (the engine says "Nothing to report"), and neither do
+ * the calls that manage the session rather than answer about code. Only the main conversation:
+ * Claude Code keeps a subagent's calls in its own file (`subagents/agent-<id>.jsonl`) and hands the
+ * parent a report, so a turn where only a subagent used Niro has no call for this hook to see, and
+ * asking the parent to report work it did not do would produce a line about nothing.
+ */
+const fs = require("fs");
+
+const lineName = require("./lineName");
+
+/** The MCP server names Niro registers under. Exact, because `niro-memory` shares the prefix. */
+const NIRO_SERVERS = new Set(["niro", "niro-local"]);
+
+/**
+ * Calls that manage the session rather than answer about the developer's code. Upstream's
+ * `SessionPlumbingTools` list, which is what the server itself leaves out of the line's count.
+ */
+const PLUMBING = new Set([
+  "mark_task_complete",
+  "should_create_temp_project",
+  "select_project",
+  "get_index_status",
+  "list_projects",
+  "get_niro_usage_patterns_for_intent",
+]);
+
+const COMPLETE_TOOL = "mark_task_complete";
+
+/**
+ * A line of its own starting with the prefix, backticks allowed. `[NIRO-MEMORY]` does not match. The
+ * prefix is `[NIRO-CLI]`, `[NIRO-LOCAL]` from an engine older than 2026-11-09, or the cloud's `[NIRO]`
+ * (`lineName.js`).
+ */
+const LINE_IN_REPLY = new RegExp(`^[ \\t]*\`?(${lineName.PREFIX_SOURCE} [^\`\\n]*)\`?[ \\t]*$`, "m");
+/** The same line inside a tool answer, with the rest of it captured so it can be quoted back. */
+const LINE_IN_ANSWER = new RegExp(`^[ \\t]*(${lineName.PREFIX_SOURCE} .*)$`, "m");
+
+const GENUINE = "line";
+const ABSENT = "no-line";
+const FORGED = "forged";
+
+/** How much of the transcript's end is read, growing only when the turn starts further back. */
+const TAIL_STEPS = [256 * 1024, 2 * 1024 * 1024, 8 * 1024 * 1024];
+/** Past this the hook gives up and lets the assistant stop. It is a courtesy, not a gate. */
+const TIME_BUDGET_MS = 1500;
+/** How long to wait before reading a transcript again that has not caught up with the reply. */
+const SETTLE_POLL_MS = 40;
+
+/**
+ * How every request opens. A person sees this sentence on screen under Claude Code's own label, so
+ * it says what is happening; and the next stop recognises it in the transcript as already asked.
+ */
+const ASK_OPENING = "Niro tools answered this turn";
+
+/** The tool's own name when it belongs to a Niro server, otherwise null. */
+function niroToolName(name) {
+  if (typeof name !== "string" || !name.startsWith("mcp__")) return null;
+  const rest = name.slice("mcp__".length);
+  const split = rest.indexOf("__");
+  if (split < 0) return null;
+  return NIRO_SERVERS.has(rest.slice(0, split)) ? rest.slice(split + 2) : null;
+}
+
+/** A person's message, rather than a tool result or something Claude Code added by itself. */
+function startsTurn(entry) {
+  if (!entry || entry.type !== "user" || entry.isMeta || entry.isSidechain) return false;
+  if (entry.toolUseResult !== undefined) return false;
+  const content = entry.message && entry.message.content;
+  if (typeof content === "string") return !isStopHookFeedback(content);
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (block) => block && block.type !== "tool_result" && !isStopHookFeedback(block.text || "")
+  );
+}
+
+/** What Claude Code writes into the conversation when a Stop hook blocks: part of the same turn. */
+function isStopHookFeedback(text) {
+  return /^\s*Stop hook feedback:/i.test(text);
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => (block && typeof block.text === "string" ? block.text : "")).join("\n");
+}
+
+/** The line a mark_task_complete answer carried: plain text locally, a JSON field from the cloud. */
+function lineInAnswer(text) {
+  const plain = LINE_IN_ANSWER.exec(text);
+  if (plain) return plain[1].trim();
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed.receipt === "string" && LINE_IN_ANSWER.test(parsed.receipt)) {
+      return parsed.receipt.trim();
+    }
+  } catch {
+    // Not JSON: the answer carried no line.
+  }
+  return null;
+}
+
+/**
+ * What the turn did, from the entries after the last person's message. Null when the turn's start
+ * is not among the lines given, so a caller can read further back or give up.
+ */
+function readTurn(lines, deadline = Infinity) {
+  const entries = [];
+  let found = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (Date.now() > deadline) return null;
+    const line = lines[i];
+    if (!line) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue; // The first line of a tail is usually cut in half.
+    }
+    if (startsTurn(entry)) {
+      found = true;
+      break;
+    }
+    entries.push(entry);
+  }
+  if (!found) return null;
+  entries.reverse();
+
+  const uses = new Map();
+  const results = new Map();
+  let lastText = "";
+  let asked = false;
+  for (const entry of entries) {
+    if (entry.isSidechain) continue;
+    if (entry.type === "attachment" && JSON.stringify(entry.attachment || {}).includes(ASK_OPENING)) {
+      asked = true;
+    }
+    const content = entry.message && entry.message.content;
+    if (!Array.isArray(content)) continue;
+    if (entry.type === "assistant") {
+      const text = textOf(content.filter((b) => b && b.type === "text"));
+      if (text.trim()) lastText = text;
+      for (const block of content) {
+        if (block && block.type === "tool_use") uses.set(block.id, niroToolName(block.name));
+      }
+    } else if (entry.type === "user") {
+      for (const block of content) {
+        if (block && block.type === "tool_result") results.set(block.tool_use_id, block);
+      }
+    }
+  }
+
+  let answered = 0;
+  let completed = false;
+  let lineFromTool = null;
+  for (const [id, tool] of uses) {
+    if (tool === null) continue;
+    const result = results.get(id);
+    if (!result) continue;
+    if (tool === COMPLETE_TOOL) {
+      completed = true;
+      lineFromTool = lineInAnswer(textOf(result.content)) || lineFromTool;
+    } else if (!PLUMBING.has(tool) && !result.is_error) {
+      answered += 1;
+    }
+  }
+  return { answered, completed, lineFromTool, lastText, asked };
+}
+
+/** Read backwards in growing steps until the turn's start is in view. Null when it never is. */
+function turnFromTranscript(transcriptPath, deadline) {
+  let handle;
+  try {
+    // Only a regular file. Opening a FIFO waits for a writer, before any time budget is looked at,
+    // and held the stop until Claude Code's 5 s timeout (independent check of fb3d8cb).
+    if (!fs.statSync(transcriptPath).isFile()) return null;
+    handle = fs.openSync(transcriptPath, "r");
+    const size = fs.fstatSync(handle).size;
+    for (const step of TAIL_STEPS) {
+      const length = Math.min(step, size);
+      const buffer = Buffer.alloc(length);
+      fs.readSync(handle, buffer, 0, length, size - length);
+      const turn = readTurn(buffer.toString("utf8").split("\n"), deadline);
+      if (turn) return turn;
+      if (length === size || Date.now() > deadline) return null;
+    }
+    return null;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+  }
+}
+
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/**
+ * The turn, once the transcript has caught up with the reply; null when it does not in time.
+ *
+ * Claude Code writes the transcript behind what it hands the hook. Seen in real sessions on 2026-11-05:
+ * the reply on stdin carried the true line while mark_task_complete's result was not yet in the file,
+ * so the line read as made up, the assistant was asked for it, called the tool again, and printed
+ * "Nothing to print" under a reply that had been right. The reply is the last thing written, so once
+ * its text is in the file everything before it is too. Without a reply on stdin, as from an older
+ * version, the file is all there is.
+ */
+function settledTurn(transcriptPath, reply, deadline) {
+  for (;;) {
+    const turn = turnFromTranscript(transcriptPath, deadline);
+    if (typeof reply !== "string") return turn;
+    if (turn && turn.lastText.trim() && reply.trim().endsWith(turn.lastText.trim())) return turn;
+    if (Date.now() + SETTLE_POLL_MS >= deadline) return null;
+    sleep(SETTLE_POLL_MS);
+  }
+}
+
+/**
+ * What the assistant prints above the real line when its reply carried a made-up one. A hook cannot
+ * take back what is already on screen, so without this the person sees two lines with different
+ * numbers and nothing saying which to trust. Wording approved by Niraj on 2026-11-06.
+ */
+const CORRECTION_LABEL = "Correction: the Niro line above was not measured. The measured line is:";
+
+/** What the assistant is asked to do. Quotes the line when it already exists. */
+function reasonFor(turn, verdict = ABSENT) {
+  if (verdict === FORGED) {
+    // The label goes on a line of its own in the request, so it cannot be read as part of a sentence.
+    const said = "and the Niro line in your reply did not come from the tool";
+    if (turn.lineFromTool) {
+      return (
+        `${ASK_OPENING} ${said}: print only these two lines, the second in single backticks:\n` +
+        `${CORRECTION_LABEL}\n${turn.lineFromTool}`
+      );
+    }
+    return (
+      `${ASK_OPENING} ${said}: call mark_task_complete, then print only two lines, and do not repeat ` +
+      `your answer. The first is exactly:\n${CORRECTION_LABEL}\nThe second is the line the tool ` +
+      "returns, in single backticks. If the tool returns no line, print nothing."
+    );
+  }
+  const said = "and your reply has no Niro line";
+  if (turn.lineFromTool) {
+    return `${ASK_OPENING} ${said}: print only this, in single backticks: ${turn.lineFromTool}`;
+  }
+  return (
+    `${ASK_OPENING} ${said}: call mark_task_complete, then print only the line it returns, in ` +
+    "single backticks. Do not repeat your answer."
+  );
+}
+
+/**
+ * Whether the reply's line is the one the tool returned.
+ *
+ * Seeing a line is not enough. In real sessions on 2026-11-05 an assistant skipped the tool and wrote
+ * the line itself, invented numbers included, in 14 of 62 turns with answers: "[NIRO-LOCAL] 1 call
+ * instead of ~2 searches · ~120 tokens instead of ~900". The instructions already forbade it. A figure
+ * nobody measured, in the place a measured one goes, is worse than no line, so it counts as a miss.
+ */
+function verdictOf(reply, turn) {
+  const found = LINE_IN_REPLY.exec(reply || "");
+  if (!found) return ABSENT;
+  return turn.lineFromTool && comparable(found[1]) === comparable(turn.lineFromTool) ? GENUINE : FORGED;
+}
+
+/**
+ * The line without what copying it can harmlessly change. Seen in real replies: a stray "]" at the
+ * end, and a doubled space. Asking again over those would be noise. A word or a number that differs
+ * is not forgiven.
+ */
+function comparable(line) {
+  // The old and the new name of the local line are one line: an assistant may copy `[NIRO-LOCAL]` from an
+  // older engine's answer the bridge did not rename, and that is not a made-up line (`lineName.js`).
+  return lineName.renamed(line).replace(/\s+/g, "").replace(/[\]`.]+$/, "");
+}
+
+/**
+ * What to do about this stop. Pure, so every case is a plain test.
+ *
+ * @returns {{block: string|null, note: object|null}} `block` is the reason to continue, `note` what
+ *   to record about a turn where Niro tools answered.
+ */
+function decide(input, turn) {
+  if (!turn || turn.answered <= 0) return { block: null, note: null };
+  const reply =
+    typeof input.last_assistant_message === "string" ? input.last_assistant_message : turn.lastText;
+  const verdict = verdictOf(reply, turn);
+  const note = {
+    client_session: typeof input.session_id === "string" ? input.session_id : "",
+    niro_calls: turn.answered,
+    line: verdict,
+    after_block: Boolean(input.stop_hook_active || turn.asked),
+  };
+  if (verdict === GENUINE || note.after_block) return { block: null, note };
+  // The tool ran and said there was nothing to report, so there is no line to ask for.
+  if (turn.completed && !turn.lineFromTool) return { block: null, note: null };
+  return { block: reasonFor(turn, verdict), note };
+}
+
+/**
+ * Whether the person or the setup has switched the line off, or nobody is reading.
+ *
+ * `claude -p` and the Agent SDK hand a script the LAST message as the result. Measured on 2026-11-05:
+ * asking for the line there replaced the answer in `result` with the line, so a script got
+ * "[NIRO-LOCAL] 1 call" and lost what it asked for. Claude Code names its entry point in the
+ * environment: `cli` for a person at a terminal, `sdk-cli`, `sdk-ts` and `sdk-py` for a script.
+ */
+function switchedOff(env = process.env) {
+  if (String(env.CLAUDE_CODE_ENTRYPOINT || "").startsWith("sdk-")) return true;
+  const flag = String(env.NIRO_LOCAL_TASK_COMPLETE || "1").trim().toLowerCase();
+  if (["0", "false", "no"].includes(flag)) return true;
+  try {
+    return require("../lib/receiptStore").isDisabled();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Record the outcome in the engine's journal, without waiting for it: the assistant is not held up
+ * by bookkeeping, and an engine that is missing (a cloud install) simply records nothing.
+ */
+function noteReply(note) {
+  try {
+    const { spawn } = require("child_process");
+    const { enginePath } = require("../lib/localEngine");
+    const child = spawn(
+      enginePath(),
+      [
+        "journal",
+        "--note-reply",
+        note.client_session,
+        String(note.niro_calls),
+        note.line,
+        note.after_block ? "after-block" : "first",
+      ],
+      { detached: true, stdio: "ignore" }
+    );
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    // Bookkeeping only.
+  }
+}
+
+/** The whole hook: reads stdin, prints a decision or nothing. Never throws, never exits non-zero. */
+function run(raw, { out = process.stdout, record = noteReply, env = process.env } = {}) {
+  try {
+    const deadline = Date.now() + TIME_BUDGET_MS;
+    if (switchedOff(env)) return;
+    const input = JSON.parse(raw);
+    if (!input || typeof input.transcript_path !== "string") return;
+    const turn = settledTurn(input.transcript_path, input.last_assistant_message, deadline);
+    const { block, note } = decide(input, turn);
+    if (note) record(note);
+    if (block) out.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext: block } }));
+  } catch {
+    // Let the assistant stop.
+  }
+}
+
+module.exports = { CORRECTION_LABEL, decide, lineInAnswer, niroToolName, readTurn, reasonFor, run, settledTurn, turnFromTranscript, verdictOf };

package/src/mcp/lineName.js

@@ -0,0 +1,92 @@
+/**
+ * The name the end-of-task line opens with.
+ *
+ * The local engine's line opened with `[NIRO-LOCAL]` until 2026-11-09 and opens with `[NIRO-CLI]`
+ * from then (Niraj: "all caps"). An engine installed before that still writes the old name, and a
+ * machine can hold a newer niro-cli with an older engine for a while, so the bridge reads both
+ * names and shows only the new one: the developer sees `[NIRO-CLI]` whichever engine answered.
+ * The cloud's `[NIRO]` line is a different product's line and is never renamed.
+ *
+ * Only what is the line, or is about the line, is renamed: the `mark_task_complete` answer, the
+ * engine's end-of-turn reminder, its server instructions and the tool's description. Any other
+ * answer is passed on as it came, because a code search can return source that contains the old
+ * name as text, and changing that would show the developer a file that is not on their disk.
+ */
+
+const SHOWN = "[NIRO-CLI]";
+const OLD = "[NIRO-LOCAL]";
+
+/** The prefixes a line may open with, as a regular-expression group: `[NIRO]`, `[NIRO-LOCAL]`, `[NIRO-CLI]`. */
+const PREFIX_SOURCE = "\\[NIRO(?:-LOCAL|-CLI)?\\]";
+
+/** The old engine's reminder under answers, exactly as niro-local wrote it (receipt.py TURN_REMINDER). */
+const OLD_REMINDER = `(End of turn: call mark_task_complete, print its ${OLD} line last.)`;
+const NEW_REMINDER = `(End of turn: call mark_task_complete, print its ${SHOWN} line last.)`;
+
+/** `text` with every `[NIRO-LOCAL]` written as `[NIRO-CLI]`. For text that is about the line only. */
+function renamed(text) {
+  return typeof text === "string" ? text.split(OLD).join(SHOWN) : text;
+}
+
+/** `text` with only the old engine's end-of-turn reminder renamed, for any other answer. */
+function reminderRenamed(text) {
+  return typeof text === "string" ? text.split(OLD_REMINDER).join(NEW_REMINDER) : text;
+}
+
+/**
+ * An MCP tool answer with `rename` applied to each text block and to `structuredContent.result`, the
+ * second copy of the same text niro-local sends for a tool with an output schema. Anything else is
+ * left as it is. The same object comes back when nothing changed.
+ */
+function answerRenamed(answer, rename = renamed) {
+  if (!answer || !Array.isArray(answer.content)) return answer;
+  let changed = false;
+  const content = answer.content.map((block) => {
+    if (!block || block.type !== "text" || typeof block.text !== "string") return block;
+    const text = rename(block.text);
+    if (text === block.text) return block;
+    changed = true;
+    return { ...block, text };
+  });
+  const structured = answer.structuredContent;
+  let structuredContent = structured;
+  if (structured && typeof structured === "object" && typeof structured.result === "string") {
+    const result = rename(structured.result);
+    if (result !== structured.result) {
+      changed = true;
+      structuredContent = { ...structured, result };
+    }
+  }
+  if (!changed) return answer;
+  const out = { ...answer, content };
+  if (structuredContent !== undefined) out.structuredContent = structuredContent;
+  return out;
+}
+
+/** The engine's initialize answer with the line's name renamed in its instructions. */
+function initializeRenamed(result) {
+  if (!result || typeof result.instructions !== "string") return result;
+  const instructions = renamed(result.instructions);
+  return instructions === result.instructions ? result : { ...result, instructions };
+}
+
+/** The engine's tool list with the line's name renamed in `mark_task_complete`'s description. */
+function toolsRenamed(tools) {
+  if (!Array.isArray(tools)) return tools;
+  return tools.map((tool) =>
+    tool && tool.name === "mark_task_complete" && typeof tool.description === "string"
+      ? { ...tool, description: renamed(tool.description) }
+      : tool
+  );
+}
+
+module.exports = {
+  SHOWN,
+  OLD,
+  PREFIX_SOURCE,
+  renamed,
+  reminderRenamed,
+  answerRenamed,
+  initializeRenamed,
+  toolsRenamed,
+};