@noir-ai/cli 1.14.0 → 1.15.0-beta.1

package/dist/index.js

@@ -235,16 +235,36 @@ function spinner(text = "", opts = {}) {
   }
   return new OraSpinner(text);
 }
+function failureEnvelope(exitCode, message) {
+  return `${JSON.stringify({ ok: false, error: { code: exitCode, message } })}
+`;
+}
 function fail(exitCode, message, opts = {}) {
   if (isJsonMode(opts)) {
-    process.stdout.write(`${JSON.stringify({ ok: false, error: { code: exitCode, message } })}
-`);
+    process.stdout.write(failureEnvelope(exitCode, message));
   } else if (message.length > 0) {
     process.stderr.write(`${message}
 `);
   }
   throw new CommanderError(exitCode, NOIR_ERROR_CODE, message);
 }
+function failAndExit(exitCode, message, opts = {}) {
+  process.exitCode = exitCode;
+  const jsonMode = isJsonMode(opts);
+  const text = jsonMode ? failureEnvelope(exitCode, message) : message.length > 0 ? `${message}
+` : "";
+  if (text.length === 0) {
+    process.exit(exitCode);
+  }
+  let left = false;
+  const leave = () => {
+    if (left) return;
+    left = true;
+    process.exit(exitCode);
+  };
+  (jsonMode ? process.stdout : process.stderr).write(text, leave);
+  setTimeout(leave, EXIT_FLUSH_MS);
+}
 function requireInteractive(opts, hint) {
   if (!isInteractive(opts)) {
     fail(
@@ -285,7 +305,7 @@ function handleError(err) {
   }
   process.exitCode = inferExitCode(err);
 }
-var EXIT, NoirCliError, NOIR_ERROR_CODE, NoopSpinner, OraSpinner;
+var EXIT, NoirCliError, NOIR_ERROR_CODE, NoopSpinner, OraSpinner, EXIT_FLUSH_MS;
 var init_output = __esm({
   "src/output.ts"() {
     "use strict";
@@ -364,6 +384,7 @@ var init_output = __esm({
         this.handle.info(text);
       }
     };
+    EXIT_FLUSH_MS = 250;
   }
 });
 
@@ -482,8 +503,8 @@ async function contextIndex(opts) {
   }
   renderIndex(data, opts.paths, opts);
 }
-function renderIndex(data, paths3, opts) {
-  const scope = paths3 && paths3.length > 0 ? paths3.join(", ") : ".";
+function renderIndex(data, paths5, opts) {
+  const scope = paths5 && paths5.length > 0 ? paths5.join(", ") : ".";
   const flag = data.degraded ? `  ${badge("warn", "degraded: vectors skipped")}` : "";
   log(`context index \u2014 ${scope}${flag}`, opts);
   definitionList(
@@ -1242,12 +1263,12 @@ function describeSource(row) {
   return row.shadowed === true ? ".noir/.env (shadows environment)" : ".noir/.env";
 }
 async function env(opts = {}) {
-  const report = resolveEnv(process.cwd(), ambientBaseline ?? process.env);
+  const report2 = resolveEnv(process.cwd(), ambientBaseline ?? process.env);
   if (opts.json === true) {
-    json({ ok: true, data: { vars: report.vars, warnings: report.warnings } });
+    json({ ok: true, data: { vars: report2.vars, warnings: report2.warnings } });
     return;
   }
-  if (report.vars.length === 0) {
+  if (report2.vars.length === 0) {
     info(
       "nothing to report \u2014 .noir/.env defines no keys in effect and no Noir-relevant environment variable is set",
       opts
@@ -1255,10 +1276,10 @@ async function env(opts = {}) {
     return;
   }
   table(
-    report.vars.map((row) => ({
+    report2.vars.map((row) => ({
       KEY: row.key,
       SOURCE: describeSource(row),
-      VALUE: report.shapes[row.key] ?? ""
+      VALUE: report2.shapes[row.key] ?? ""
     })),
     ["KEY", "SOURCE", "VALUE"],
     opts
@@ -1276,6 +1297,9 @@ var init_env = __esm({
       "COHERE_API_KEY",
       "OLLAMA_BASE_URL",
       "ANTHROPIC_API_KEY",
+      "ANTHROPIC_AUTH_TOKEN",
+      "ANTHROPIC_BASE_URL",
+      "API_TIMEOUT_MS",
       "NOIR_PROFILE"
     ];
     SHORT_VALUE_MAX = 8;
@@ -2330,7 +2354,7 @@ async function taskVerify(opts) {
       `${JSON.stringify({
         ok: false,
         error: { code: EXIT.ERROR, message: `task verify: ${detail}` },
-        // S9 `{ok:false, error}` + a payload — recovery context + evidence nest
+        // `{ok:false, error}` + a payload — recovery context + evidence nest
         // under `data`, not as top-level siblings (same envelope shape as the
         // success path; consumers read `data` for the full picture).
         data: {
@@ -2448,7 +2472,7 @@ var init_task = __esm({
     init_output();
     init_theme();
     PHASE_SKILL = {
-      // C3 curation (2026-08-10): intake+clarify merged into brainstorming;
+      // Skill curation: intake+clarify merged into brainstorming;
       // execute → executing-plans; verify → verifying; document → wrap.
       intake: "noir-brainstorming",
       clarify: "noir-brainstorming",
@@ -2717,6 +2741,10 @@ function capitalizeFirst(s) {
 function hasAction(cmd) {
   return cmd._actionHandler != null;
 }
+function requiredArgLabel(cmd) {
+  const required = cmd.registeredArguments.find((arg) => arg.required);
+  return required?.name();
+}
 function collectLeaves(cmd, path, out) {
   const children = cmd.commands;
   const isLeaf = hasAction(cmd) && children.length === 0;
@@ -2731,7 +2759,8 @@ function collectLeaves(cmd, path, out) {
       description,
       category: argv[0] ?? "",
       keywords: argv,
-      destructive: isDestructive(argv)
+      destructive: isDestructive(argv),
+      needsArg: requiredArgLabel(cmd)
     });
     return;
   }
@@ -2844,7 +2873,15 @@ var init_sections = __esm({
             label: "Save memory",
             hint: "save an observation \xB7 \u26A0 destructive",
             destructive: true,
-            needsArg: { prompt: "Memory content:", placeholder: "what you want to remember" }
+            // The value travels as `--content <text>` (memory save declares no
+            // positional), so the flag rides in the dispatch prefix and the
+            // collected value is appended after it.
+            dispatch: ["memory", "save", "--content"],
+            needsArg: {
+              label: "content",
+              prompt: "Memory content:",
+              placeholder: "what you want to remember"
+            }
           },
           {
             id: "memory sessions",
@@ -2868,8 +2905,21 @@ var init_sections = __esm({
       {
         id: "workflow",
         label: "Workflow",
-        hint: "next \xB7 status \xB7 advance \xB7 handoff \xB7 wrap",
+        hint: "run \xB7 next \xB7 status \xB7 advance \xB7 handoff \xB7 wrap",
         items: [
+          {
+            id: "run",
+            label: "Ask the host",
+            hint: "ask the host agent a question \xB7 \u26A0 destructive",
+            destructive: true,
+            // The prompt is not a required argument (the command also takes flags
+            // like --list-profiles), so the palette only learns to ask for it here.
+            needsArg: {
+              label: "prompt",
+              prompt: "Prompt for the host:",
+              placeholder: "e.g. summarise the auth flow"
+            }
+          },
           {
             id: "task next",
             label: "Next task",
@@ -3721,6 +3771,15 @@ var init_release = __esm({
   }
 });
 
+// src/run-timing.ts
+var INTERRUPT_GRACE_MS;
+var init_run_timing = __esm({
+  "src/run-timing.ts"() {
+    "use strict";
+    INTERRUPT_GRACE_MS = 5e3;
+  }
+});
+
 // src/shell-bridge.ts
 import { spawn } from "child_process";
 import { basename } from "path";
@@ -3755,7 +3814,7 @@ function shellKind(shell) {
 function probeCommand(name, shell, opts) {
   const kind = shellKind(shell);
   const timeoutMs = opts.timeoutMs ?? PROBE_TIMEOUT_MS2;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const script = kind ? PROBE_SCRIPTS[kind] : "";
     const flags = kind ? PROBE_FLAGS[kind] : "-lic";
     const probeArgs = kind === "fish" ? [name] : ["noirbridge", name];
@@ -3778,15 +3837,15 @@ function probeCommand(name, shell, opts) {
         } catch {
         }
       }
-      resolve2({ stdout, timedOut: true });
+      resolve3({ stdout, timedOut: true });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve2({ stdout, timedOut: false });
+      resolve3({ stdout, timedOut: false });
     });
     child.on("close", () => {
       clearTimeout(timer);
-      resolve2({ stdout, timedOut: false });
+      resolve3({ stdout, timedOut: false });
     });
   });
 }
@@ -3882,18 +3941,23 @@ function usageFrom(v) {
   if (input === void 0 && output === void 0 && cache === void 0) return void 0;
   return { inputTokens: input, outputTokens: output, cacheReadTokens: cache };
 }
-function messageText(message) {
-  if (!message) return void 0;
+function messageContent(message) {
+  if (!message) return {};
   const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    const parts = content.map((block) => {
-      const b = asObj(block);
-      return b && typeof b.text === "string" ? b.text : null;
-    }).filter((t) => t !== null);
-    if (parts.length > 0) return parts.join("");
+  if (typeof content === "string") return { text: content };
+  if (!Array.isArray(content)) return {};
+  const parts = [];
+  const tools = [];
+  for (const block of content) {
+    const b = asObj(block);
+    if (!b) continue;
+    if (typeof b.text === "string") parts.push(b.text);
+    else if (b.type === "tool_use" && typeof b.name === "string") tools.push(b.name);
   }
-  return void 0;
+  return {
+    ...parts.length > 0 ? { text: parts.join("") } : {},
+    ...tools.length > 0 ? { tools } : {}
+  };
 }
 function parseStreamLine(line) {
   const trimmed = line.trim();
@@ -3912,15 +3976,14 @@ function normalizeStreamEvent(raw) {
     if (r.subtype === "init") {
       return { kind: "init", sessionId: str(r.session_id), model: str(r.model) };
     }
-    return { kind: "other" };
+    return { kind: "other", subtype: str(r.subtype) ?? "system" };
   }
   if (type === "assistant") {
     const message = asObj(r.message);
-    return {
-      kind: "assistant",
-      messageId: message ? str(message.id) : void 0,
-      text: messageText(message),
-      usage: message ? usageFrom(message.usage) : void 0,
+    const content = messageContent(message);
+    const messageId = message ? str(message.id) : void 0;
+    const usage = message ? usageFrom(message.usage) : void 0;
+    const error2 = {
       // An API error message is a diagnostic, not the answer — flag it so the
       // caller never streams it as assistant text (optional-when-true keeps
       // exact-shape consumers of the existing union intact).
@@ -3929,6 +3992,20 @@ function normalizeStreamEvent(raw) {
         ...typeof r.error === "string" ? { errorCategory: r.error } : {}
       } : {}
     };
+    if (content.text !== void 0) {
+      return {
+        kind: "assistant",
+        messageId,
+        text: content.text,
+        usage,
+        ...content.tools === void 0 ? {} : { tools: content.tools },
+        ...error2
+      };
+    }
+    if (content.tools !== void 0) {
+      return { kind: "tool", name: content.tools[0], messageId, usage };
+    }
+    return { kind: "assistant", messageId, usage, ...error2 };
   }
   if (type === "result") {
     return {
@@ -3940,7 +4017,33 @@ function normalizeStreamEvent(raw) {
       usage: usageFrom(r.usage)
     };
   }
-  return { kind: "other" };
+  if (type === "stream_event") {
+    return normalizeStreamEventInner(asObj(r.event));
+  }
+  return { kind: "other", ...typeof type === "string" ? { subtype: type } : {} };
+}
+function normalizeStreamEventInner(inner) {
+  if (!inner) return { kind: "other", subtype: "stream_event" };
+  const innerType = str(inner.type);
+  if (innerType === "content_block_start") {
+    const block = asObj(inner.content_block);
+    const name = block ? str(block.name) : void 0;
+    if (block && str(block.type) === "tool_use" && name !== void 0) {
+      return { kind: "tool", name };
+    }
+  }
+  if (innerType === "content_block_delta") {
+    const delta = asObj(inner.delta);
+    const text = delta ? str(delta.text) : void 0;
+    if (delta && delta.type === "text_delta" && text !== void 0) {
+      return { kind: "delta", text };
+    }
+  }
+  return { kind: "other", subtype: innerType ?? "stream_event" };
+}
+function signalChild(child, signal) {
+  if (child.pid === void 0) return;
+  child.kill(signal);
 }
 function runHost(opts) {
   const spec = resolveHostRun(opts.host, opts.customBinary);
@@ -3956,12 +4059,13 @@ function runHost(opts) {
     false
   );
 }
-function spawnAndConsume(binary, args, opts, shellRun) {
-  return new Promise((resolve2, reject) => {
+function spawnAndConsume(binary, args, opts, shellRun, bridged = false) {
+  return new Promise((resolve3, reject) => {
     const child = spawn2(binary, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       ...opts.env ? { env: opts.env } : {}
     });
+    opts.onChild?.(child);
     const reducer = new UsageReducer();
     let eventCount = 0;
     let stderrBuf = "";
@@ -3969,10 +4073,40 @@ function spawnAndConsume(binary, args, opts, shellRun) {
     let errorText;
     let errorCategory;
     let spawnError = null;
+    const { signal } = opts;
+    let resend;
+    let offersLeft = Math.ceil(BRIDGE_POLITE_WINDOW_MS / BRIDGE_POLITE_RESEND_MS);
+    const stopResend = () => {
+      if (resend === void 0) return;
+      clearTimeout(resend);
+      resend = void 0;
+    };
+    const offerAgain = () => {
+      if (offersLeft <= 0) return;
+      offersLeft -= 1;
+      resend = setTimeout(() => {
+        resend = void 0;
+        signalChild(child, "SIGTERM");
+        offerAgain();
+      }, BRIDGE_POLITE_RESEND_MS);
+    };
+    const onAbort = () => {
+      signalChild(child, "SIGTERM");
+      if (bridged) offerAgain();
+    };
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const detachAbort = () => {
+      signal?.removeEventListener("abort", onAbort);
+      stopResend();
+    };
     child.on("error", (err) => {
       spawnError = err;
+      detachAbort();
       if (!shellRun && err.code === "ENOENT") {
-        void shellFallback(binary, args, opts, resolve2, reject, err);
+        void shellFallback(binary, args, opts, resolve3, reject, err);
         return;
       }
       reject(err);
@@ -3999,41 +4133,43 @@ function spawnAndConsume(binary, args, opts, shellRun) {
     child.stderr.on("data", (chunk) => {
       stderrBuf += chunk;
     });
-    child.on("close", (code, signal) => {
+    child.on("close", (code, signal2) => {
+      detachAbort();
       if (spawnError !== null) return;
-      const killed = code === null && signal != null;
-      resolve2({
-        exitCode: killed ? 128 + (signalNumber(signal) ?? 0) : code ?? 0,
+      const killed = code === null && signal2 != null;
+      resolve3({
+        exitCode: killed ? 128 + (signalNumber(signal2) ?? 0) : code ?? 0,
         usage: reducer.snapshot(),
         eventCount,
         stderr: stderrBuf,
         isError: errored || killed,
-        errorText: killed && errorText === void 0 ? `terminated by signal ${signal}` : errorText,
+        errorText: killed && errorText === void 0 ? `terminated by signal ${signal2}` : errorText,
         errorCategory
       });
     });
   });
 }
-async function shellFallback(binary, args, opts, resolve2, reject, originalErr) {
+async function shellFallback(binary, args, opts, resolve3, reject, originalErr) {
   try {
     const res = await resolveCommandViaShell(binary, { env: opts.env ?? process.env });
     if (res.kind === "path") {
-      resolve2(await spawnAndConsume(res.path, args, opts, true));
+      resolve3(await spawnAndConsume(res.path, args, opts, true));
       return;
     }
     if (res.kind === "alias" || res.kind === "function") {
       const bridge = buildBridgeArgs(binary, args, res.shell);
-      resolve2(await spawnAndConsume(bridge.binary, bridge.args, opts, true));
+      resolve3(await spawnAndConsume(bridge.binary, bridge.args, opts, true, true));
       return;
     }
   } catch {
   }
   reject(originalErr);
 }
-var HOST_BINARY, HOST_FLAGS, UsageReducer;
+var HOST_BINARY, HOST_FLAGS, UsageReducer, BRIDGE_POLITE_RESEND_MS, BRIDGE_POLITE_WINDOW_MS;
 var init_orchestrator = __esm({
   "src/orchestrator.ts"() {
     "use strict";
+    init_run_timing();
     init_shell_bridge();
     HOST_BINARY = {
       claude: "claude",
@@ -4044,7 +4180,7 @@ var init_orchestrator = __esm({
       // emits AGENTS.md — a file host, not a spawnable CLI
     };
     HOST_FLAGS = {
-      claude: ["-p", "--output-format", "stream-json", "--verbose"],
+      claude: ["-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages"],
       gemini: ["-p", "--output-format", "stream-json"],
       opencode: ["run"],
       cursor: ["-p"],
@@ -4058,27 +4194,29 @@ var init_orchestrator = __esm({
       turns = 0;
       /** Feed one normalized event into the reducer. */
       add(event) {
-        if (event.kind === "assistant" && event.messageId && event.usage) {
-          const key = event.messageId;
-          const input = event.usage.inputTokens ?? 0;
-          const output = event.usage.outputTokens ?? 0;
-          const prev = this.maxByMessage.get(key);
-          if (!prev) {
-            this.maxByMessage.set(key, { input, output });
-            this.input += input;
-            this.output += output;
-          } else {
-            this.input += Math.max(0, input - prev.input);
-            this.output += Math.max(0, output - prev.output);
-            this.maxByMessage.set(key, {
-              input: Math.max(prev.input, input),
-              output: Math.max(prev.output, output)
-            });
-          }
-        } else if (event.kind === "result") {
+        if (event.kind === "result") {
           if (event.totalCostUsd !== void 0) this.costUsd = event.totalCostUsd;
           if (event.numTurns !== void 0) this.turns = event.numTurns;
+          return;
+        }
+        const usage = event.kind === "assistant" || event.kind === "tool" ? event.usage : void 0;
+        const key = event.kind === "assistant" || event.kind === "tool" ? event.messageId : void 0;
+        if (!key || !usage) return;
+        const input = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        const prev = this.maxByMessage.get(key);
+        if (!prev) {
+          this.maxByMessage.set(key, { input, output });
+          this.input += input;
+          this.output += output;
+          return;
         }
+        this.input += Math.max(0, input - prev.input);
+        this.output += Math.max(0, output - prev.output);
+        this.maxByMessage.set(key, {
+          input: Math.max(prev.input, input),
+          output: Math.max(prev.output, output)
+        });
       }
       /** The current accumulator snapshot. */
       snapshot() {
@@ -4090,11 +4228,362 @@ var init_orchestrator = __esm({
         };
       }
     };
+    BRIDGE_POLITE_RESEND_MS = 250;
+    BRIDGE_POLITE_WINDOW_MS = INTERRUPT_GRACE_MS;
+  }
+});
+
+// src/run-actions.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { resolve } from "path";
+import { CommanderError as CommanderError2 } from "commander";
+function postRunActions(input) {
+  const answer = input.answer.trim();
+  const canContinue = input.canContinue ?? (input.sessionId !== void 0 && input.resume !== void 0);
+  const options = [];
+  if (answer.length > 0) {
+    options.push({
+      value: "memory",
+      label: "Save answer to memory",
+      hint: "distil it into this project's memory (needs the daemon)"
+    });
+    options.push({
+      value: "research",
+      label: "Add as task research",
+      hint: "record it as a finding on the active task"
+    });
+  }
+  options.push({
+    value: "handoff",
+    label: "Write a handoff artifact",
+    hint: "snapshot the task, the next step and a seed for your host"
+  });
+  if (canContinue) {
+    options.push({
+      value: "resume",
+      label: "Continue this session",
+      hint: `ask ${input.host} a follow-up in the same session`,
+      needsValue: {
+        label: "follow-up prompt",
+        placeholder: "e.g. now write the tests for that"
+      }
+    });
+  }
+  if (answer.length > 0) {
+    options.push({
+      value: "save",
+      label: "Save answer to a file",
+      hint: "write the answer text to a path you choose",
+      needsValue: { label: "file path", placeholder: "e.g. notes/answer.md" }
+    });
+  }
+  options.push({
+    value: "dismiss",
+    label: "Dismiss",
+    hint: "nothing further \u2014 the run is already complete"
+  });
+  return options;
+}
+async function performPostRunAction(choice, input, value) {
+  const label = ACTION_LABEL[choice];
+  try {
+    switch (choice) {
+      case "memory":
+        await saveToMemory(input);
+        return { ok: true, message: "" };
+      case "research":
+        await recordAsResearch(input);
+        return { ok: true, message: "" };
+      case "handoff":
+        await writeHandoff(input);
+        return { ok: true, message: "" };
+      case "resume":
+        return await continueSession(input, value);
+      case "save":
+        return saveAnswerToFile(input, value);
+      case "dismiss":
+        return { ok: true, message: "" };
+    }
+  } catch (err) {
+    const quoted = err instanceof CommanderError2 || err instanceof NoirCliError ? void 0 : `${label}: ${err instanceof Error ? err.message : String(err)}`;
+    return {
+      ok: false,
+      message: `${label} did not complete \u2014 the run's result stands.`,
+      ...quoted === void 0 ? {} : { detail: quoted }
+    };
+  }
+}
+async function offerPostRunActions(input) {
+  if (!isInteractive(input.opts)) return;
+  const options = postRunActions(input);
+  if (options.length <= 1) return;
+  const menu = await openMenu(options);
+  if (menu === void 0) return;
+  const chosen = options.find((o) => o.value === menu.choice);
+  if (chosen === void 0) return;
+  const value = chosen.needsValue === void 0 ? void 0 : await askForValue(menu.clack, chosen, input);
+  if (chosen.needsValue !== void 0 && value === void 0) return;
+  report(await performPostRunAction(menu.choice, input, value), input.opts);
+}
+function report(outcome, opts) {
+  const caution = outcome.tone === "caution" || !outcome.ok && outcome.tone !== "confirm";
+  if (outcome.detail !== void 0) warn(outcome.detail, opts);
+  if (outcome.message.length === 0) return;
+  if (caution) warn(outcome.message, opts);
+  else success(outcome.message, opts);
+}
+async function openMenu(options) {
+  try {
+    const clack = await import("@clack/prompts");
+    const choice = await clack.select({
+      message: "The run finished. What next?",
+      initialValue: "dismiss",
+      // Spread because the prompt library takes a mutable list; the rows
+      // themselves are the shared descriptors and are never rewritten.
+      options: [...options]
+    });
+    if (clack.isCancel(choice)) return void 0;
+    return { clack, choice };
+  } catch {
+    return void 0;
+  }
+}
+async function askForValue(clack, option, input) {
+  const needs = option.needsValue;
+  if (needs === void 0) return void 0;
+  const message = option.value === "save" ? `Write the answer to a file (the raw transcript is at ${input.transcript})` : `What should ${input.host} do next?`;
+  try {
+    const written = await clack.text({ message, placeholder: needs.placeholder });
+    if (clack.isCancel(written)) return void 0;
+    return String(written ?? "");
+  } catch {
+    return void 0;
+  }
+}
+async function saveToMemory(input) {
+  await memoryCapture({
+    ...input.opts,
+    content: input.answer,
+    eventType: CAPTURE_EVENT
+  });
+}
+async function recordAsResearch(input) {
+  await taskResearchRecord({
+    ...input.opts,
+    type: "discovery",
+    text: researchText(input.answer),
+    source: RESEARCH_SOURCE
+  });
+}
+function researchText(answer) {
+  const condensed = answer.replace(/\s+/g, " ").trim();
+  if (condensed.length <= RESEARCH_TEXT_LIMIT) return condensed;
+  return `${condensed.slice(0, RESEARCH_TEXT_LIMIT - 1)}\u2026`;
+}
+async function writeHandoff(input) {
+  await handoff({ ...input.opts, write: true });
+}
+async function continueSession(input, value) {
+  const { sessionId, resume } = input;
+  if (sessionId === void 0 || resume === void 0) return { ok: true, message: "" };
+  const prompt = (value ?? "").trim();
+  if (prompt.length === 0) {
+    return {
+      ok: true,
+      tone: "caution",
+      message: "No prompt given \u2014 the session was not continued."
+    };
+  }
+  await resume(prompt, sessionId);
+  return { ok: true, message: "" };
+}
+function saveAnswerToFile(input, value) {
+  const fallback = `noir-run-${stamp2()}.md`;
+  const chosen = (value ?? "").trim();
+  const target = resolve(chosen.length > 0 ? chosen : fallback);
+  const body = input.answer.endsWith("\n") ? input.answer : `${input.answer}
+`;
+  try {
+    writeFileSync3(target, body, { mode: 384 });
+  } catch (err) {
+    return {
+      ok: false,
+      tone: "caution",
+      message: `could not write ${target}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return { ok: true, message: `Answer written to ${target}` };
+}
+function stamp2() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+var CAPTURE_EVENT, RESEARCH_SOURCE, RESEARCH_TEXT_LIMIT, ACTION_LABEL;
+var init_run_actions = __esm({
+  "src/run-actions.ts"() {
+    "use strict";
+    init_handoff();
+    init_memory();
+    init_task();
+    init_output();
+    CAPTURE_EVENT = "capture";
+    RESEARCH_SOURCE = "noir run";
+    RESEARCH_TEXT_LIMIT = 220;
+    ACTION_LABEL = {
+      memory: "Saving to memory",
+      research: "Recording the finding",
+      handoff: "Writing the handoff",
+      resume: "Continuing the session",
+      save: "Writing the file",
+      dismiss: "Dismissing"
+    };
+  }
+});
+
+// src/run-interrupt.ts
+import { constants as constants2 } from "os";
+function exitCodeForSignal(signal) {
+  return 128 + (constants2.signals[signal] ?? 0);
+}
+function interruptedNotice(transcript) {
+  return `interrupted \xB7 transcript: ${transcript}`;
+}
+var INTERRUPT_SIGNALS, RunInterrupt;
+var init_run_interrupt = __esm({
+  "src/run-interrupt.ts"() {
+    "use strict";
+    init_orchestrator();
+    init_run_timing();
+    INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
+    RunInterrupt = class {
+      graceMs;
+      exitNow;
+      controller = new AbortController();
+      /** The live child, or undefined between spawns. */
+      child;
+      /** The child the ladder already ran for — a repeat call is not a new ladder. */
+      stopping;
+      grace;
+      signalName;
+      stopRequested = false;
+      forced = false;
+      watching = false;
+      /** The installed listeners, keyed by the signal each answers. */
+      handlers = /* @__PURE__ */ new Map();
+      constructor(opts = {}) {
+        this.graceMs = opts.graceMs ?? INTERRUPT_GRACE_MS;
+        this.exitNow = opts.exitNow ?? ((code) => {
+          if (this.child !== void 0) signalChild(this.child, "SIGKILL");
+          process.exit(code);
+        });
+      }
+      /**
+       * The cancel signal for the spawn. Aborting it is what a caller holding only
+       * the signal can do; the ladder itself does not depend on it, which matters
+       * because the child a run ends up driving is not always the first one spawned.
+       */
+      get signal() {
+        return this.controller.signal;
+      }
+      /** The signal that stopped the run, or undefined when nothing did. */
+      get interruptedBy() {
+        return this.signalName;
+      }
+      /** True once a child had to be forced — it did not honour the polite signal. */
+      get escalated() {
+        return this.forced;
+      }
+      /**
+       * Hand over the child a spawn produced. Called for every spawn of one run: a
+       * command resolved through the shell bridge is its own child, and a stop that
+       * arrived before that child existed has to land on it too.
+       */
+      track(child) {
+        this.child = child;
+        child.once("exit", () => this.forget(child));
+        if (this.stopRequested) this.terminate();
+      }
+      /**
+       * Stop the host. The polite signal goes to the child itself, and a child still
+       * alive after the grace is forced. Repeat calls are the same call: the ladder
+       * runs once per child, so a keystroke held down is not a stream of signals.
+       */
+      terminate() {
+        this.stopRequested = true;
+        if (!this.controller.signal.aborted) this.controller.abort();
+        const child = this.child;
+        if (child === void 0 || child.pid === void 0 || child === this.stopping) return;
+        this.stopping = child;
+        this.clearGrace();
+        signalChild(child, "SIGTERM");
+        this.grace = setTimeout(() => {
+          this.grace = void 0;
+          if (this.child !== child) return;
+          this.forced = true;
+          signalChild(child, "SIGKILL");
+        }, this.graceMs);
+      }
+      /**
+       * Skip the grace and force the host now. The "you asked twice" path: the
+       * terminal leaves at once on a second signal, and the run screen forces and
+       * returns to the dashboard rather than holding a keystroke while the grace
+       * runs out. Does nothing when no stop is in flight.
+       */
+      forceNow() {
+        const child = this.child;
+        if (child === void 0 || child.pid === void 0 || child !== this.stopping) return false;
+        this.forced = true;
+        this.clearGrace();
+        signalChild(child, "SIGKILL");
+        return true;
+      }
+      /**
+       * Install the terminal interrupt handlers. Only a run installs these, and only
+       * for as long as it is driving the host: the process's own handling has to
+       * come back afterwards, or a later command inherits an interrupt contract with
+       * nothing left to interrupt.
+       */
+      watch() {
+        if (this.watching) return;
+        this.watching = true;
+        for (const signal of INTERRUPT_SIGNALS) {
+          const listener = () => this.onSignal(signal);
+          this.handlers.set(signal, listener);
+          process.on(signal, listener);
+        }
+      }
+      /** Put the process's own handling back, whatever the run left behind. */
+      unwatch() {
+        if (!this.watching) return;
+        this.watching = false;
+        for (const [signal, listener] of this.handlers) process.off(signal, listener);
+        this.handlers.clear();
+      }
+      onSignal(signal) {
+        if (this.signalName !== void 0) {
+          this.exitNow(exitCodeForSignal(signal));
+          return;
+        }
+        this.signalName = signal;
+        this.terminate();
+      }
+      /** The child is gone: stop tracking it and disarm its ladder. */
+      forget(child) {
+        if (this.child !== child) return;
+        this.child = void 0;
+        this.stopping = void 0;
+        this.clearGrace();
+      }
+      clearGrace() {
+        if (this.grace === void 0) return;
+        clearTimeout(this.grace);
+        this.grace = void 0;
+      }
+    };
   }
 });
 
 // src/run-profiles.ts
-import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
+import { isDeniedEnvKey, loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
 function loadRunConfig(root) {
   try {
     return loadProjectInfo11(root).config;
@@ -4129,6 +4618,14 @@ function resolveRunProfile(requested, config, env2) {
       envExpanded[k] = v === null ? void 0 : expandEnvVars(v, env2);
     }
   }
+  for (const key of Object.keys(envExpanded)) {
+    if (isDeniedEnvKey(key)) {
+      return {
+        ok: false,
+        message: `run profile "${name}" refuses process-injection key "${key}" \u2014 a profile env block in .noir/config.yml must not set ${key} (it can inject into the spawned host process). Remove "${key}" from the profile.`
+      };
+    }
+  }
   return {
     ok: true,
     profile: { binary: profile.binary, env: envExpanded, args: profile.args, profileName: name }
@@ -4149,11 +4646,195 @@ var init_run_profiles = __esm({
   }
 });
 
+// src/run-status.ts
+function humanizeElapsed(ms) {
+  const total = Math.max(0, Math.floor(ms / 1e3));
+  const seconds = total % 60;
+  const minutes = Math.floor(total / 60) % 60;
+  const hours = Math.floor(total / 3600);
+  if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+function hostStderrTail(stderr, maxLines = HOST_STDERR_TAIL_LINES) {
+  if (maxLines <= 0) return "";
+  const lines = stderr.split("\n").map((line) => line.trimEnd());
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  if (lines.length === 0) return "";
+  if (lines.length <= maxLines) return lines.join("\n");
+  const omitted = lines.length - maxLines;
+  return [`\u2026 (${omitted} earlier lines omitted)`, ...lines.slice(-maxLines)].join("\n");
+}
+var HOST_STDERR_TAIL_LINES, RunStatusLine;
+var init_run_status = __esm({
+  "src/run-status.ts"() {
+    "use strict";
+    init_orchestrator();
+    HOST_STDERR_TAIL_LINES = 20;
+    RunStatusLine = class {
+      host;
+      enabled;
+      animated;
+      sharesCursor;
+      write;
+      now;
+      /**
+       * Running token totals for the live line. This is a SECOND accumulator: the
+       * snapshot the run reports at the end is reduced independently from the full
+       * event stream, and both apply the same `max usage per message id` rule, so
+       * the number on screen and the number in the summary agree.
+       */
+      usage = new UsageReducer();
+      startedAt;
+      model;
+      streaming = false;
+      begun = false;
+      ended = false;
+      /** True while the status text is sitting on the row the cursor is currently at. */
+      onRow = false;
+      /** True when the last stdout write ended a line — the only safe moment to move the cursor. */
+      stdoutAtRowStart = true;
+      /** The text currently on the row (empty when the row is not ours). */
+      rendered = "";
+      constructor(opts) {
+        this.host = opts.host;
+        this.enabled = opts.json !== true && opts.quiet !== true;
+        this.animated = this.enabled && opts.stderrIsTty === true;
+        this.sharesCursor = opts.stdoutSharesCursor !== false;
+        this.write = opts.write ?? ((chunk) => void process.stderr.write(chunk));
+        this.now = opts.now ?? (() => performance.now());
+        this.startedAt = this.now();
+      }
+      /**
+       * Claim the row: show the seeded "waiting" state immediately, before the host
+       * has said anything, so the spawn itself is never blank. Calling this twice
+       * is a no-op.
+       */
+      begin() {
+        if (!this.enabled || this.begun) return;
+        this.begun = true;
+        this.startedAt = this.now();
+        if (this.animated) {
+          this.draw();
+          return;
+        }
+        this.write(`${this.render()}
+`);
+      }
+      /** Feed one normalized host event. Anything unrenderable is ignored. */
+      event(e) {
+        if (!this.enabled || this.ended || !this.begun) return;
+        if (e.kind === "result") {
+          this.end();
+          return;
+        }
+        if (e.kind === "init") {
+          if (e.model !== void 0) this.model = e.model;
+        } else if (e.kind === "assistant" || e.kind === "tool") {
+          this.streaming = true;
+          this.usage.add(e);
+        } else if (e.kind === "delta") {
+          this.streaming = true;
+        } else {
+          return;
+        }
+        this.draw();
+      }
+      /**
+       * Announce the chunk the caller is about to write to STDOUT — before writing
+       * it. Warning the line first lets it finish its row: the answer would
+       * otherwise start glued to the tail of the status text. It also records
+       * whether that write ended a line, which is the only moment the cursor can be
+       * moved without landing inside the answer.
+       */
+      beforeStdout(chunk) {
+        if (chunk.length === 0) return;
+        if (this.animated && this.sharesCursor && this.onRow) {
+          this.write("\n");
+          this.onRow = false;
+        }
+        this.stdoutAtRowStart = chunk.endsWith("\n");
+      }
+      /**
+       * Finish the row the host's answer left open. A failure message printed onto
+       * a half-written answer reads as part of the answer, so a caller about to
+       * report a failure asks for the row to be terminated first. A no-op unless
+       * this line is drawing on a terminal stdout also writes to and the answer
+       * stopped mid-line — the only state where the cursor is inside the answer.
+       */
+      finishRow() {
+        if (!this.animated || !this.sharesCursor || this.stdoutAtRowStart) return;
+        this.write("\n");
+        this.stdoutAtRowStart = true;
+      }
+      /**
+       * Close the line out. On a terminal the line is erased so the run summary
+       * takes its place — unless the answer has since moved the cursor off it, in
+       * which case the text stays as the record of how long the wait was. On a pipe
+       * it becomes the final marker. Safe to call twice.
+       */
+      end() {
+        if (!this.enabled || this.ended) return;
+        this.ended = true;
+        if (!this.animated) {
+          this.write(`${this.render(true)}
+`);
+          return;
+        }
+        if (!this.onRow || !this.cursorFree()) return;
+        this.write("\r\x1B[K");
+        this.rendered = "";
+        this.onRow = false;
+      }
+      /** Rewrite the current row in place, skipping no-op rewrites and unsafe moments. */
+      draw() {
+        if (!this.animated || !this.cursorFree()) return;
+        const text = this.render();
+        if (text === this.rendered) return;
+        this.write(`\r\x1B[K${text}`);
+        this.rendered = text;
+        this.onRow = true;
+      }
+      /**
+       * Whether the cursor is at the start of a row nobody else is using. On stdout
+       * that is not this terminal there is no shared cursor to disturb; when it is,
+       * only a write that ended a line leaves one free.
+       */
+      cursorFree() {
+        return !this.sharesCursor || this.stdoutAtRowStart;
+      }
+      /**
+       * `final` marks the line the run ends on: a run that never got past the spawn
+       * is over, so saying it is still waiting — directly above whatever the run
+       * reported — would be a lie.
+       */
+      render(final = false) {
+        const parts = [];
+        if (this.streaming) {
+          const u = this.usage.snapshot();
+          parts.push(
+            this.model ?? this.host,
+            this.elapsed(),
+            `\u2193${u.inputTokens.toLocaleString()}\u2191${u.outputTokens.toLocaleString()} tokens`
+          );
+          return `\u25CF ${parts.join(" \xB7 ")}`;
+        }
+        if (this.model !== void 0) return `\u25B6 ${[this.host, this.model, this.elapsed()].join(" \xB7 ")}`;
+        if (final) return `\u25B6 ${this.host} \xB7 no output after ${this.elapsed()}`;
+        return `\u25B6 ${this.host} \xB7 waiting for first event\u2026`;
+      }
+      elapsed() {
+        return humanizeElapsed(this.now() - this.startedAt);
+      }
+    };
+  }
+});
+
 // src/commands/run.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
-import { loadNoirEnv as loadNoirEnv2, NOIR_DIR as NOIR_DIR2, parseConfig } from "@noir-ai/core";
+import { isDeniedEnvKey as isDeniedEnvKey2, loadNoirEnv as loadNoirEnv2, NOIR_DIR as NOIR_DIR2, parseConfig, paths } from "@noir-ai/core";
 function credentialNote(env2, sources) {
   const named = CREDENTIAL_ENV_VARS.filter((name) => {
     const value = env2[name];
@@ -4173,13 +4854,24 @@ function formatUsage(u) {
   const turns = u.numTurns > 0 ? ` \xB7 ${u.numTurns} turns` : "";
   return `${u.inputTokens.toLocaleString()} in / ${u.outputTokens.toLocaleString()} out${cost}${turns}`;
 }
-function streamEvent(event, opts) {
-  if (opts.json === true) return;
+function answerText(event) {
   if (event.kind === "assistant" && event.text && event.text.length > 0 && event.isError !== true) {
-    process.stdout.write(event.text);
+    return event.text;
+  }
+  return void 0;
+}
+function streamEvent(event, opts, status2) {
+  if (opts.json === true) return;
+  const text = answerText(event);
+  if (text !== void 0) {
+    status2.beforeStdout(text);
+    process.stdout.write(text);
   }
 }
 async function run(prompt, opts) {
+  await runOnce(prompt, opts, void 0);
+}
+async function runOnce(prompt, opts, resumeSessionId) {
   const host = opts.host ?? "claude";
   if (!SUPPORTED_HOSTS.includes(host)) {
     fail(EXIT.USAGE, `unknown host '${host}' (supported: ${SUPPORTED_HOSTS.join(", ")})`, opts);
@@ -4198,7 +4890,7 @@ async function run(prompt, opts) {
   if (!resolved.ok) fail(EXIT.USAGE, resolved.message, opts);
   const profile = resolved.profile;
   const customBinary = opts.command ?? profile.binary;
-  const extraArgs = profile.args;
+  const extraArgs = resumeSessionId === void 0 ? profile.args : [...profile.args ?? [], "--resume", resumeSessionId];
   const env2 = profile.env ? mergeEnv(process.env, profile.env) : void 0;
   if (!existsSync2(join4(root, NOIR_DIR2, ".env"))) {
     log(
@@ -4207,6 +4899,37 @@ async function run(prompt, opts) {
     );
   }
   const transcriptLines = [];
+  const answer = [];
+  let sessionId;
+  const binary = customBinary && customBinary.length > 0 ? customBinary : host;
+  const status2 = new RunStatusLine({
+    host: binary,
+    json: opts.json,
+    quiet: opts.quiet,
+    stderrIsTty: process.stderr.isTTY === true,
+    stdoutSharesCursor: process.stdout.isTTY === true
+  });
+  status2.begin();
+  let verdictWritten = false;
+  const claimVerdict = () => {
+    if (verdictWritten) return false;
+    verdictWritten = true;
+    return true;
+  };
+  const interrupt = new RunInterrupt({
+    // A second interrupt leaves at once, and leaves the same verdict behind as
+    // the first: the run owes its consumer an envelope under --json, and this is
+    // the one path where `fail()` cannot write it (there is no caller left to
+    // catch its throw). The child is forced first, so leaving does not leave a
+    // host behind.
+    exitNow: (code) => {
+      interrupt.forceNow();
+      if (claimVerdict()) {
+        failAndExit(code, interruptedNotice(safeTranscript(host, transcriptLines)), opts);
+      }
+    }
+  });
+  interrupt.watch();
   let result;
   try {
     result = await runHost({
@@ -4216,28 +4939,61 @@ async function run(prompt, opts) {
       extraArgs,
       env: env2,
       onLine: (line) => transcriptLines.push(line),
-      onEvent: (event) => streamEvent(event, opts)
+      onEvent: (event) => {
+        if (event.kind === "init" && sessionId === void 0) sessionId = event.sessionId;
+        status2.event(event);
+        streamEvent(event, opts, status2);
+        const text = answerText(event);
+        if (text !== void 0) answer.push(text);
+      },
+      signal: interrupt.signal,
+      onChild: (child) => interrupt.track(child)
     });
   } catch (err) {
-    const binary = customBinary && customBinary.length > 0 ? customBinary : host;
+    status2.end();
+    status2.finishRow();
+    if (interrupt.interruptedBy !== void 0) {
+      if (claimVerdict()) {
+        failInterrupted(interrupt.interruptedBy, host, transcriptLines, opts);
+      }
+      return;
+    }
     const detail = err instanceof Error ? err.message : String(err);
     const enoent = err?.code === "ENOENT";
     const guidance = enoent ? ` No executable '${binary}' was found. Shell aliases and functions (e.g. from .zshrc) are invisible to noir \u2014 use an executable on PATH, an absolute path, or a launcher script such as ~/.local/bin/${binary}.` : "";
     const subject = customBinary && customBinary.length > 0 ? `custom command '${customBinary}'` : `host '${host}'`;
     fail(EXIT.ERROR, `failed to run ${subject}: ${detail}.${guidance}`, opts);
+  } finally {
+    interrupt.unwatch();
+  }
+  if (interrupt.interruptedBy !== void 0) {
+    status2.end();
+    status2.finishRow();
+    if (claimVerdict()) {
+      failInterrupted(interrupt.interruptedBy, host, transcriptLines, opts);
+    }
+    return;
   }
-  const transcript = writeTranscript(host, transcriptLines);
+  const transcript = safeTranscript(host, transcriptLines);
   const failed = result.exitCode !== 0 || result.isError;
   if (failed) {
-    const binary = customBinary && customBinary.length > 0 ? customBinary : host;
-    const reason = result.errorText && result.errorText.trim().length > 0 ? result.errorText.trim() : result.stderr.trim() || `exit code ${result.exitCode}`;
-    const isAuth = result.errorCategory === "authentication_failed" || result.errorCategory === "oauth_org_not_allowed" || /not logged|login|authenticate|invalid api key/i.test(reason);
+    status2.end();
+    status2.finishRow();
+    const stderrTail = hostStderrTail(result.stderr);
+    const reason = result.errorText && result.errorText.trim().length > 0 ? result.errorText.trim() : `exit code ${result.exitCode}`;
+    const isAuth = result.errorCategory === "authentication_failed" || result.errorCategory === "oauth_org_not_allowed" || /not logged|login|authenticate|invalid api key/i.test(`${reason}
+${stderrTail}`);
     let message = `host '${binary}' failed (exit ${result.exitCode}): ${reason}`;
     if (isAuth) {
       message += ` Open a terminal and run \`${binary} /login\` (interactive-only \u2014 it cannot run inside \`noir run\`), then retry.`;
       message += credentialNote(env2 ?? process.env, envSources);
     }
     message += ` If you use another profile, pass \`--command <binary>\` or define a run profile under run.profiles. transcript: ${transcript}`;
+    if (opts.json !== true && stderrTail.length > 0) {
+      message += `
+${binary} stderr (last ${HOST_STDERR_TAIL_LINES} lines):
+${stderrTail}`;
+    }
     fail(EXIT.ERROR, message, opts);
   }
   if (opts.json === true) {
@@ -4250,26 +5006,59 @@ async function run(prompt, opts) {
         usage: result.usage,
         numTurns: result.usage.numTurns,
         events: result.eventCount,
-        transcript
+        transcript,
+        // The answer as plain words, so a consumer does not have to reassemble
+        // it from the stream-json transcript.
+        answerText: answer.join(""),
+        ...sessionId === void 0 ? {} : { sessionId }
       }
     });
     return;
   }
+  status2.end();
   process.stdout.write("\n");
   success(`usage: ${formatUsage(result.usage)} (API-equivalent estimate, not billed)`, opts);
   log(`transcript: ${transcript}`, opts);
+  await offerPostRunActions({
+    answer: answer.join(""),
+    transcript,
+    sessionId,
+    host: binary,
+    opts,
+    // Only the first run of a session can be continued: a resumed run is
+    // itself the continuation, so the menu never nests more than one deep.
+    ...resumeSessionId === void 0 && sessionId !== void 0 ? { resume: (nextPrompt, id) => runOnce(nextPrompt, opts, id) } : {}
+  });
 }
 function mergeEnv(base, overlay) {
+  for (const key of Object.keys(overlay)) {
+    if (isDeniedEnvKey2(key)) {
+      fail(
+        EXIT.ERROR,
+        `refusing to run the host: the profile env defines process-injection key "${key}" (it can inject into the spawned host process)`
+      );
+    }
+  }
   const merged = { ...base, ...overlay };
   return Object.fromEntries(Object.entries(merged).filter(([, v]) => v !== void 0));
 }
-function writeTranscript(host, lines) {
+function failInterrupted(signal, host, lines, opts) {
+  return fail(exitCodeForSignal(signal), interruptedNotice(safeTranscript(host, lines)), opts);
+}
+function safeTranscript(host, lines) {
+  try {
+    return writeTranscript(host, lines);
+  } catch {
+    return "(not persisted)";
+  }
+}
+function writeTranscript(host, lines, root = process.cwd()) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dir = join4(process.cwd(), ".noir", "transcripts");
+  const dir = paths.transcriptsDir(root);
   const file = join4(dir, `${host}-${ts}.jsonl`);
   try {
     mkdirSync3(dir, { recursive: true, mode: 448 });
-    writeFileSync3(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
+    writeFileSync4(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
   } catch {
     return "(not persisted)";
   }
@@ -4281,7 +5070,10 @@ var init_run = __esm({
     "use strict";
     init_orchestrator();
     init_output();
+    init_run_actions();
+    init_run_interrupt();
     init_run_profiles();
+    init_run_status();
     CREDENTIAL_ENV_VARS = [
       "ANTHROPIC_API_KEY",
       "ANTHROPIC_AUTH_TOKEN",
@@ -4290,257 +5082,20 @@ var init_run = __esm({
   }
 });
 
-// src/commands/skills.ts
-import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
+// src/conflict.ts
 import {
-  buildRegistry,
-  discoverAll,
-  emitSkillsToDir,
-  lintSkill
-} from "@noir-ai/skills";
-function categoryOf(name) {
-  const mapped = CATEGORY[name];
-  if (mapped !== void 0) return mapped;
-  return name.replace(/^noir-/, "") || "general";
-}
-function toRow(s, kind = "builtin") {
-  const description = typeof s.frontmatter.description === "string" ? s.frontmatter.description : "";
-  const status2 = s.skillMd.includes("> **Stub:**") ? "stub" : "full";
-  const category = s.frontmatter.metadata?.category?.trim() || categoryOf(s.name);
-  return { name: s.name, category, description, kind, status: status2 };
-}
-function truncate(text, max) {
-  if (text.length <= max) return text;
-  const slice = text.slice(0, Math.max(0, max - 1));
-  const boundary = slice.lastIndexOf(" ");
-  const head = boundary > 0 ? slice.slice(0, boundary) : slice;
-  return `${head.trimEnd()}\u2026`;
+  lineDiff
+} from "@noir-ai/create";
+function flaggedNonInteractive() {
+  const v = process.env.NOIR_NON_INTERACTIVE;
+  return v !== void 0 && v !== "";
 }
-async function skillsList(opts) {
-  let builtins;
-  let integrations;
-  try {
-    const all = discoverAll();
-    builtins = all.builtins;
-    integrations = all.integrations;
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills list: could not discover skills (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
+function buildConflictOpts(input = {}) {
+  if (input.force === true) {
+    return { conflictPolicy: "overwrite" };
   }
-  const rows = [
-    ...builtins.map((b) => toRow(b, "builtin")),
-    ...integrations.map((i) => toRow(i, "integration"))
-  ];
-  const data = { count: rows.length, skills: rows };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  const intCount = integrations.length;
-  const banner = intCount > 0 ? `noir skills \u2014 ${rows.length} skill${rows.length === 1 ? "" : "s"} (${builtins.length} builtin, ${intCount} integration${intCount === 1 ? "" : "s"})` : `noir skills \u2014 ${rows.length} builtin skill${rows.length === 1 ? "" : "s"}`;
-  log(banner, opts);
-  table(
-    rows.map((r) => ({
-      Skill: r.name,
-      Kind: r.kind,
-      Category: r.category,
-      Status: r.status,
-      Description: truncate(r.description, 80)
-    })),
-    ["Skill", "Kind", "Category", "Status", "Description"],
-    opts
-  );
-}
-async function skillsSync(opts) {
-  const root = process.cwd();
-  let project;
-  try {
-    project = loadProjectInfo12(root);
-  } catch {
-    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
-  }
-  const adapter = resolveAdapter3(project.config.host);
-  if (!adapter.skillsDir) {
-    const data2 = {
-      emitted: [],
-      references: 0,
-      host: project.config.host,
-      reason: "no-skill-emitter"
-    };
-    if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
-`);
-      return;
-    }
-    info("This host has no skill emitter; nothing to sync.", opts);
-    return;
-  }
-  const dir = adapter.skillsDir({ root });
-  const target = project.config.host;
-  const summary = await emitSkillsToDir(dir, { target });
-  const pruned = summary.pruned ?? [];
-  const data = {
-    emitted: summary.emitted,
-    references: summary.references,
-    dir,
-    pruned
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(
-    `Synced ${summary.emitted.length} Noir skill${summary.emitted.length === 1 ? "" : "s"} to ${dir}.`,
-    opts
-  );
-  if (pruned.length > 0) {
-    warn(
-      `Pruned ${pruned.length} stale noir-* skill dir${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}`,
-      opts
-    );
-  }
-}
-async function skillsLint(opts) {
-  let skills;
-  try {
-    const all = discoverAll();
-    skills = [...all.builtins, ...all.integrations].map(lintSkill);
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills lint: could not lint skills (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
-  }
-  const errored = skills.filter((s) => s.errors.length > 0);
-  const warned = skills.filter((s) => s.warnings.length > 0 && s.errors.length === 0);
-  const data = { count: skills.length, errored: errored.length, skills };
-  if (errored.length > 0) {
-    const message = `skills lint: ${errored.length} skill${errored.length === 1 ? "" : "s"} failed validation`;
-    if (opts.json === true) {
-      process.stdout.write(
-        `${JSON.stringify({ ok: false, error: { code: EXIT.ERROR, message }, data })}
-`
-      );
-      process.exitCode = EXIT.ERROR;
-      return;
-    }
-    warn(
-      `noir skills lint \u2014 ${errored.length} skill${errored.length === 1 ? "" : "s"} FAIL validation:`,
-      opts
-    );
-    for (const s of errored) {
-      for (const e of s.errors) warn(`  ${s.name}: ${e}`, opts);
-    }
-    if (warned.length > 0) {
-      info(`  ${warned.length} skill${warned.length === 1 ? "" : "s"} carry lint warnings:`, opts);
-      for (const s of warned) {
-        for (const w of s.warnings) info(`  ${s.name}: ${w}`, opts);
-      }
-    }
-    fail(EXIT.ERROR, message, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(`noir skills lint \u2014 ${skills.length} skills, all validate clean.`, opts);
-  if (warned.length > 0) {
-    info(`  ${warned.length} skill${warned.length === 1 ? "" : "s"} carry lint warnings:`, opts);
-    for (const s of warned) {
-      for (const w of s.warnings) info(`  ${s.name}: ${w}`, opts);
-    }
-  }
-}
-async function skillsRegistry(opts) {
-  let reg;
-  try {
-    reg = buildRegistry();
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills registry: could not build registry (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
-  }
-  const data = { count: reg.length, skills: reg };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(`noir skills registry \u2014 ${reg.length} skills.`, opts);
-  table(
-    reg.map((r) => ({
-      Skill: r.name,
-      Kind: r.kind,
-      Category: r.category,
-      Version: r.version,
-      Status: r.status,
-      Refs: String(r.referenceCount),
-      Lines: String(r.lines)
-    })),
-    ["Skill", "Kind", "Category", "Version", "Status", "Refs", "Lines"],
-    opts
-  );
-}
-var CATEGORY;
-var init_skills = __esm({
-  "src/commands/skills.ts"() {
-    "use strict";
-    init_output();
-    CATEGORY = {
-      "noir-brainstorming": "discovery",
-      "noir-sync": "discovery",
-      "noir-checkpoint": "discovery",
-      "noir-exploring": "discovery",
-      "noir-spec": "spec",
-      "noir-planning": "plan",
-      "noir-prd": "plan",
-      "noir-executing-plans": "execute",
-      "noir-test-driven-development": "execute",
-      "noir-systematic-debugging": "execute",
-      "noir-subagent": "execute",
-      "noir-parallel": "execute",
-      "noir-verifying": "verify",
-      "noir-security": "verify",
-      "noir-wrap": "document",
-      "noir-readme": "document",
-      "noir-shipping": "git",
-      "noir-worktree": "git",
-      "noir-recall": "memory",
-      "noir-remember": "memory",
-      "noir-context": "context",
-      "noir-frontend": "domain",
-      "noir-backend": "domain",
-      "noir-doctor": "meta",
-      "noir-writing-skills": "meta",
-      "noir-rules": "meta"
-    };
-  }
-});
-
-// src/conflict.ts
-import {
-  lineDiff
-} from "@noir-ai/create";
-function flaggedNonInteractive() {
-  const v = process.env.NOIR_NON_INTERACTIVE;
-  return v !== void 0 && v !== "";
-}
-function buildConflictOpts(input = {}) {
-  if (input.force === true) {
-    return { conflictPolicy: "overwrite" };
-  }
-  if (input.interactive === false) {
-    return { conflictPolicy: "preserve" };
+  if (input.interactive === false) {
+    return { conflictPolicy: "preserve" };
   }
   if (input.interactive === true) {
     return { conflictPolicy: "preserve", onConflict: clackConflictResolver };
@@ -4636,7 +5191,7 @@ var init_conflict = __esm({
 });
 
 // src/dedup-write.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync5 } from "fs";
 import { join as join5 } from "path";
 import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
 async function checkWritePathDedup(root, res, opts) {
@@ -4785,14 +5340,14 @@ async function promptDedupAction(root, proposedRel, matchedRel, proposedText, si
     return "preserve";
   } else if (choice === "replace") {
     try {
-      writeFileSync4(join5(root, matchedRel), proposedText, "utf8");
+      writeFileSync5(join5(root, matchedRel), proposedText, "utf8");
     } catch {
     }
     return "replace";
   } else if (choice === "mirror") {
     try {
       const existing = readFileSync3(join5(root, matchedRel), "utf8");
-      writeFileSync4(
+      writeFileSync5(
         join5(root, matchedRel),
         `${existing}
 
@@ -4831,7 +5386,7 @@ function loadCache(root) {
 function saveCache(root, cache) {
   try {
     mkdirSync4(join5(root, ".noir"), { recursive: true });
-    writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
+    writeFileSync5(cachePath(root), JSON.stringify(cache), "utf8");
   } catch {
   }
 }
@@ -4853,16 +5408,16 @@ function safeRead(abs) {
   }
 }
 function withTimeout(p, ms) {
-  return new Promise((resolve2) => {
-    const t = setTimeout(() => resolve2(void 0), ms);
+  return new Promise((resolve3) => {
+    const t = setTimeout(() => resolve3(void 0), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve2(v);
+        resolve3(v);
       },
       () => {
         clearTimeout(t);
-        resolve2(void 0);
+        resolve3(void 0);
       }
     );
   });
@@ -4885,13 +5440,16 @@ var init_dedup_write = __esm({
 });
 
 // src/init.ts
-import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
+import { existsSync as existsSync3 } from "fs";
+import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo12, paths as paths2 } from "@noir-ai/core";
 import { scaffold } from "@noir-ai/create";
-import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
+import {
+  emitSkillsToDir
+} from "@noir-ai/skills";
 async function init(root, opts) {
   assertTransportUrl(opts);
-  const host = opts.host ?? "claude";
+  const host = resolveInitHost(root, opts);
   const interactive = resolveInteractive();
   const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
   const dryRun = opts.dryRun === true || opts.preview === true;
@@ -4912,15 +5470,29 @@ async function init(root, opts) {
     return res;
   }
   if (res.noop) return res;
-  await emitHostSkills(root, host, conflictOpts, interactive);
+  const skillSummary = await emitHostSkills(root, host, conflictOpts, interactive);
+  res.skillConflicts = skillSummary?.conflicts ?? [];
+  res.preservedSkills = skillSummary?.preserved ?? [];
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo13(root);
+    projectInfo = loadProjectInfo12(root);
   } catch {
     projectInfo = void 0;
   }
   const dedup = await checkWritePathDedup(root, res, { interactive, project: projectInfo });
   if (dedup.conflicts.length > 0) res.conflicts.push(...dedup.conflicts);
+  if (res.refreshed.length > 0) {
+    process.stderr.write(
+      `Refreshed ${res.refreshed.length} unedited doc seed(s): ${res.refreshed.join(", ")}
+`
+    );
+  }
+  if (res.migrationChanged.length > 0) {
+    process.stderr.write(
+      `Migrated ${res.migrationChanged.length} file(s): ${res.migrationChanged.join(", ")}
+`
+    );
+  }
   process.stderr.write(
     `Noir initialized in ${root} (host: ${host}, transport: ${opts.transport}).
 `
@@ -4930,6 +5502,19 @@ async function init(root, opts) {
   );
   return res;
 }
+function resolveInitHost(root, opts) {
+  if (opts.host !== void 0) return opts.host;
+  if (!existsSync3(paths2.config(root))) return "claude";
+  try {
+    return loadProjectInfo12(root).config.host;
+  } catch {
+    process.stderr.write(
+      `Could not read the configured host from ${paths2.config(root)}; using 'claude'.
+`
+    );
+    return "claude";
+  }
+}
 function reportPlannedWrites(res) {
   log("Dry run \u2014 no files were written.");
   if (res.written.length > 0) {
@@ -4939,6 +5524,10 @@ function reportPlannedWrites(res) {
       log(mode === void 0 ? `  ${p}` : `  ${p} (mode ${mode.toString(8).padStart(3, "0")})`);
     }
   }
+  if (res.refreshed.length > 0) {
+    log("Would refresh (unedited older copy):");
+    for (const p of res.refreshed) log(`  ${p}`);
+  }
   if (res.skipped.length > 0) {
     log("Would leave as-is (already present):");
     for (const p of res.skipped) log(`  ${p}`);
@@ -4949,12 +5538,12 @@ function reportPlannedWrites(res) {
   }
 }
 async function emitHostSkills(root, host, conflictOpts, interactive) {
-  const adapter = resolveAdapter4(host);
+  const adapter = resolveAdapter3(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
     process.stderr.write(`host '${host}' has no skill emitter; skipping skills
 `);
-    return;
+    return void 0;
   }
   const target = host;
   const skillOpts = {
@@ -4966,12 +5555,20 @@ async function emitHostSkills(root, host, conflictOpts, interactive) {
   if (conflictOpts.onConflict !== void 0) {
     skillOpts.onConflict = conflictOpts.onConflict;
   }
-  const summary = await emitSkillsToDir2(skillsDir, skillOpts);
+  const summary = await emitSkillsToDir(skillsDir, skillOpts);
   const relDir = skillsDir.replace(`${root}/`, "");
   process.stderr.write(
     `Emitted ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
 `
   );
+  const stale = preservedStaleLine(summary.preserved ?? []);
+  if (stale !== void 0) process.stderr.write(`${stale}
+`);
+  return summary;
+}
+function preservedStaleLine(preserved) {
+  if (preserved.length === 0) return void 0;
+  return `${preserved.length} skill(s) preserved as stale (interactive TTY required to refresh): ${preserved.join(", ")}`;
 }
 function assertTransportUrl(opts) {
   if (opts.transport === "streamable-http" && opts.url === void 0) {
@@ -5004,6 +5601,251 @@ var init_init = __esm({
   }
 });
 
+// src/commands/skills.ts
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
+import {
+  buildRegistry,
+  discoverAll,
+  emitSkillsToDir as emitSkillsToDir2,
+  lintSkill
+} from "@noir-ai/skills";
+function categoryOf(name) {
+  const mapped = CATEGORY[name];
+  if (mapped !== void 0) return mapped;
+  return name.replace(/^noir-/, "") || "general";
+}
+function toRow(s, kind = "builtin") {
+  const description = typeof s.frontmatter.description === "string" ? s.frontmatter.description : "";
+  const status2 = s.skillMd.includes("> **Stub:**") ? "stub" : "full";
+  const category = s.frontmatter.metadata?.category?.trim() || categoryOf(s.name);
+  return { name: s.name, category, description, kind, status: status2 };
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  const slice = text.slice(0, Math.max(0, max - 1));
+  const boundary = slice.lastIndexOf(" ");
+  const head = boundary > 0 ? slice.slice(0, boundary) : slice;
+  return `${head.trimEnd()}\u2026`;
+}
+async function skillsList(opts) {
+  let builtins;
+  let integrations;
+  try {
+    const all = discoverAll();
+    builtins = all.builtins;
+    integrations = all.integrations;
+  } catch (err) {
+    fail(
+      EXIT.ERROR,
+      `skills list: could not discover skills (${err instanceof Error ? err.message : String(err)})`,
+      opts
+    );
+  }
+  const rows = [
+    ...builtins.map((b) => toRow(b, "builtin")),
+    ...integrations.map((i) => toRow(i, "integration"))
+  ];
+  const data = { count: rows.length, skills: rows };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  const intCount = integrations.length;
+  const banner = intCount > 0 ? `noir skills \u2014 ${rows.length} skill${rows.length === 1 ? "" : "s"} (${builtins.length} builtin, ${intCount} integration${intCount === 1 ? "" : "s"})` : `noir skills \u2014 ${rows.length} builtin skill${rows.length === 1 ? "" : "s"}`;
+  log(banner, opts);
+  table(
+    rows.map((r) => ({
+      Skill: r.name,
+      Kind: r.kind,
+      Category: r.category,
+      Status: r.status,
+      Description: truncate(r.description, 80)
+    })),
+    ["Skill", "Kind", "Category", "Status", "Description"],
+    opts
+  );
+}
+async function skillsSync(opts) {
+  const root = process.cwd();
+  let project;
+  try {
+    project = loadProjectInfo13(root);
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
+  const adapter = resolveAdapter4(project.config.host);
+  if (!adapter.skillsDir) {
+    const data2 = {
+      emitted: [],
+      references: 0,
+      host: project.config.host,
+      reason: "no-skill-emitter"
+    };
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
+`);
+      return;
+    }
+    info("This host has no skill emitter; nothing to sync.", opts);
+    return;
+  }
+  const dir = adapter.skillsDir({ root });
+  const target = project.config.host;
+  const summary = await emitSkillsToDir2(dir, { target });
+  const pruned = summary.pruned ?? [];
+  const preserved = summary.preserved ?? [];
+  const data = {
+    emitted: summary.emitted,
+    references: summary.references,
+    dir,
+    pruned,
+    // What the count above does NOT cover: skills whose files were preserved
+    // (stale on disk, by design, in a non-interactive run). Same field `noir
+    // init --json` carries, so a consumer reads one shape from every emitter.
+    preserved
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  log(
+    `Synced ${summary.emitted.length} Noir skill${summary.emitted.length === 1 ? "" : "s"} to ${dir}.`,
+    opts
+  );
+  if (pruned.length > 0) {
+    warn(
+      `Pruned ${pruned.length} stale noir-* skill dir${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}`,
+      opts
+    );
+  }
+  const stale = preservedStaleLine(preserved);
+  if (stale !== void 0) warn(stale, opts);
+}
+async function skillsLint(opts) {
+  let skills;
+  try {
+    const all = discoverAll();
+    skills = [...all.builtins, ...all.integrations].map(lintSkill);
+  } catch (err) {
+    fail(
+      EXIT.ERROR,
+      `skills lint: could not lint skills (${err instanceof Error ? err.message : String(err)})`,
+      opts
+    );
+  }
+  const errored = skills.filter((s) => s.errors.length > 0);
+  const warned = skills.filter((s) => s.warnings.length > 0 && s.errors.length === 0);
+  const data = { count: skills.length, errored: errored.length, skills };
+  if (errored.length > 0) {
+    const message = `skills lint: ${errored.length} skill${errored.length === 1 ? "" : "s"} failed validation`;
+    if (opts.json === true) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: false, error: { code: EXIT.ERROR, message }, data })}
+`
+      );
+      process.exitCode = EXIT.ERROR;
+      return;
+    }
+    warn(
+      `noir skills lint \u2014 ${errored.length} skill${errored.length === 1 ? "" : "s"} FAIL validation:`,
+      opts
+    );
+    for (const s of errored) {
+      for (const e of s.errors) warn(`  ${s.name}: ${e}`, opts);
+    }
+    if (warned.length > 0) {
+      info(`  ${warned.length} skill${warned.length === 1 ? "" : "s"} carry lint warnings:`, opts);
+      for (const s of warned) {
+        for (const w of s.warnings) info(`  ${s.name}: ${w}`, opts);
+      }
+    }
+    fail(EXIT.ERROR, message, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  log(`noir skills lint \u2014 ${skills.length} skills, all validate clean.`, opts);
+  if (warned.length > 0) {
+    info(`  ${warned.length} skill${warned.length === 1 ? "" : "s"} carry lint warnings:`, opts);
+    for (const s of warned) {
+      for (const w of s.warnings) info(`  ${s.name}: ${w}`, opts);
+    }
+  }
+}
+async function skillsRegistry(opts) {
+  let reg;
+  try {
+    reg = buildRegistry();
+  } catch (err) {
+    fail(
+      EXIT.ERROR,
+      `skills registry: could not build registry (${err instanceof Error ? err.message : String(err)})`,
+      opts
+    );
+  }
+  const data = { count: reg.length, skills: reg };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  log(`noir skills registry \u2014 ${reg.length} skills.`, opts);
+  table(
+    reg.map((r) => ({
+      Skill: r.name,
+      Kind: r.kind,
+      Category: r.category,
+      Version: r.version,
+      Status: r.status,
+      Refs: String(r.referenceCount),
+      Lines: String(r.lines)
+    })),
+    ["Skill", "Kind", "Category", "Version", "Status", "Refs", "Lines"],
+    opts
+  );
+}
+var CATEGORY;
+var init_skills = __esm({
+  "src/commands/skills.ts"() {
+    "use strict";
+    init_init();
+    init_output();
+    CATEGORY = {
+      "noir-brainstorming": "discovery",
+      "noir-sync": "discovery",
+      "noir-checkpoint": "discovery",
+      "noir-exploring": "discovery",
+      "noir-spec": "spec",
+      "noir-planning": "plan",
+      "noir-prd": "plan",
+      "noir-executing-plans": "execute",
+      "noir-test-driven-development": "execute",
+      "noir-systematic-debugging": "execute",
+      "noir-subagent": "execute",
+      "noir-parallel": "execute",
+      "noir-verifying": "verify",
+      "noir-security": "verify",
+      "noir-wrap": "document",
+      "noir-readme": "document",
+      "noir-shipping": "git",
+      "noir-worktree": "git",
+      "noir-recall": "memory",
+      "noir-remember": "memory",
+      "noir-context": "context",
+      "noir-frontend": "domain",
+      "noir-backend": "domain",
+      "noir-doctor": "meta",
+      "noir-writing-skills": "meta",
+      "noir-rules": "meta"
+    };
+  }
+});
+
 // src/serve.ts
 import { applyNoirEnv, loadProjectInfo as loadProjectInfo14 } from "@noir-ai/core";
 import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
@@ -5043,22 +5885,21 @@ var create_exports = {};
 __export(create_exports, {
   create: () => create
 });
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
 import { loadProjectInfo as loadProjectInfo15 } from "@noir-ai/core";
 import { scaffold as scaffold2 } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir3 } from "@noir-ai/skills";
 async function create(dir, opts) {
   assertTransportUrl(opts);
-  const root = resolve(dir ?? process.cwd());
-  const host = opts.host ?? "claude";
+  const root = resolve2(dir ?? process.cwd());
   const interactive = resolveInteractive();
   const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
   const dryRun = opts.dryRun === true || opts.preview === true;
   const res = await scaffold2({
     root,
     mode: "create",
-    host,
+    ...opts.host !== void 0 ? { host: opts.host } : {},
     transport: opts.transport,
     interactive,
     ...opts.url !== void 0 ? { url: opts.url } : {},
@@ -5071,6 +5912,7 @@ async function create(dir, opts) {
     return res;
   }
   if (res.noop) return res;
+  const host = res.host;
   const adapter = resolveAdapter5(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
@@ -5093,6 +5935,9 @@ async function create(dir, opts) {
       `Emitted ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
 `
     );
+    const stale = preservedStaleLine(summary.preserved ?? []);
+    if (stale !== void 0) process.stderr.write(`${stale}
+`);
   }
   let projectInfo;
   try {
@@ -5122,9 +5967,9 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo16, paths } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo16, paths as paths3 } from "@noir-ai/core";
 import { scaffold as scaffold3 } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir4 } from "@noir-ai/skills";
 async function sync(root, opts = {}) {
@@ -5184,6 +6029,9 @@ async function sync(root, opts = {}) {
 `
       );
     }
+    const stale = preservedStaleLine(summary.preserved ?? []);
+    if (stale !== void 0) process.stderr.write(`${stale}
+`);
   }
   const dedup = await checkWritePathDedup(root, res, { interactive, project: projectInfo });
   if (dedup.conflicts.length > 0) res.conflicts.push(...dedup.conflicts);
@@ -5191,7 +6039,7 @@ async function sync(root, opts = {}) {
 }
 function resolveSyncHost(root, opts) {
   if (opts.host !== void 0) return opts.host;
-  if (!existsSync3(paths.config(root))) return "claude";
+  if (!existsSync4(paths3.config(root))) return "claude";
   try {
     return loadProjectInfo16(root).config.host;
   } catch {
@@ -5321,13 +6169,15 @@ function createProgram() {
     "--upgrade",
     "run scaffold migrations before re-emitting (re-run on an existing project)"
   ).option("--force", "re-scaffold even if already initialized (bypasses the already-init no-op)").option("--dry-run", "report planned writes without writing anything").option("--preview", "alias for --dry-run").addOption(
-    // S10: target host. Defaults to `'claude'` (the regression anchor). The
-    // chosen host is forwarded to scaffold() + skills emission via
-    // resolveAdapter. The choice list mirrors `SUPPORTED_HOSTS` so a new host
-    // lands here automatically; commander rejects anything else as usage=2.
+    // Target host. When the flag is absent the host is read from an existing
+    // `.noir/config.yml`, falling back to `'claude'` (so a fresh project is
+    // unaffected). The chosen host is forwarded to scaffold() + skills
+    // emission via resolveAdapter. The choice list mirrors `SUPPORTED_HOSTS`
+    // so a new host lands here automatically; commander rejects anything else
+    // as usage=2.
     new Option(
       "--host <id>",
-      "target agentic CLI (default: claude) \u2014 drives host-side emission"
+      "target agentic CLI (default: the host in .noir/config.yml, else claude)"
     ).choices(SUPPORTED_HOSTS2)
   ).action(
     async (opts, cmd) => {
@@ -5390,7 +6240,7 @@ function createProgram() {
       "strip-replace managed regions (discard hand-edits inside <!-- noir:* --> markers)"
     )
   ).addOption(
-    // S10: optional `--host` override. When omitted, sync reads host from
+    // Optional `--host` override. When omitted, sync reads host from
     // `.noir/config.yml` (whatever `noir init --host <id>` persisted). The
     // override is rarely needed — documented as advanced.
     new Option(
@@ -5946,7 +6796,7 @@ var init_bin = __esm({
         }
       },
       // The grouped home menu resolves its sections against the LIVE palette
-      // registry (home-consolidation S1/S2) — the same source the TUI palette
+      // registry — the same source the TUI palette
       // uses — so the menu cannot drift from the commander tree.
       commands: buildPaletteCommands(createProgram())
     };
@@ -6367,7 +7217,7 @@ var init_daemon_client = __esm({
 
 // src/commands/doctor.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
 import { dirname, join as join6, relative } from "path";
 import { fileURLToPath } from "url";
 import { resolveAdapter as resolveAdapter7 } from "@noir-ai/adapters";
@@ -6377,11 +7227,17 @@ import {
   loadNoirEnv as loadNoirEnv3,
   loadProjectInfo as loadProjectInfo18,
   NOIR_VERSION as NOIR_VERSION6,
-  paths as paths2,
+  paths as paths4,
   readInstallRecord as readInstallRecord4,
   readUpdateCache as readUpdateCache3
 } from "@noir-ai/core";
-import { CURRENT_SCAFFOLD_VERSION, readScaffoldVersion } from "@noir-ai/create";
+import {
+  CURRENT_SCAFFOLD_VERSION,
+  isStaleSeed,
+  loadTemplate,
+  readScaffoldVersion,
+  render
+} from "@noir-ai/create";
 import { pidAlive as pidAlive4, readProjectDaemonRecord as readProjectDaemonRecord3 } from "@noir-ai/daemon";
 import { resolveModelConfig as resolveModelConfig2 } from "@noir-ai/model";
 async function probeOnnx() {
@@ -6418,8 +7274,8 @@ async function checkRuntime(checks) {
   });
 }
 function checkConfig(root) {
-  const configPath = paths2.config(root);
-  if (!existsSync4(configPath)) {
+  const configPath = paths4.config(root);
+  if (!existsSync5(configPath)) {
     return {
       project: void 0,
       result: {
@@ -6518,8 +7374,8 @@ async function checkStore(checks, project, root) {
     checks.push({ name: "store", status: "warn", detail: "skipped \u2014 not initialized" });
     return;
   }
-  const dbPath = paths2.storeDb(root, project.id);
-  if (!existsSync4(dbPath)) {
+  const dbPath = paths4.storeDb(root, project.id);
+  if (!existsSync5(dbPath)) {
     checks.push({
       name: "store",
       status: "warn",
@@ -6534,7 +7390,7 @@ async function checkStore(checks, project, root) {
     checks.push({
       name: "store",
       status: "ok",
-      detail: `opens readonly (db: ${paths2.storeDb(root, project.id)})`
+      detail: `opens readonly (db: ${paths4.storeDb(root, project.id)})`
     });
   } catch (e) {
     checks.push({ name: "store", status: "fail", detail: `open failed: ${msg(e)}` });
@@ -6548,7 +7404,7 @@ async function checkStore(checks, project, root) {
   }
 }
 function checkNoirEnv(checks, root, loaded) {
-  const path = join6(paths2.noirDir(root), ".env");
+  const path = join6(paths4.noirDir(root), ".env");
   let st;
   try {
     st = statSync(path);
@@ -6627,9 +7483,10 @@ function checkProvider(checks, project, sources) {
   for (const name of names) {
     const p = resolved.providers[name];
     if (!p) continue;
-    const fromFile = p.apiKeyEnv !== void 0 && sources[p.apiKeyEnv] === "file";
-    const key = p.hasKey ? fromFile ? "key present (from .noir/.env)" : "key present" : p.apiKeyEnv ? `missing ${p.apiKeyEnv}` : "anonymous";
-    if (!p.hasKey && p.apiKeyEnv) missing = true;
+    const fromFile = p.apiKeyEnv !== void 0 && sources[p.apiKeyEnv] === "file" || p.authTokenEnv !== void 0 && sources[p.authTokenEnv] === "file";
+    const credentialName = p.apiKeyEnv ?? p.authTokenEnv;
+    const key = p.hasKey ? fromFile ? "key present (from .noir/.env)" : "key present" : credentialName ? `missing ${credentialName}` : "anonymous";
+    if (!p.hasKey && credentialName) missing = true;
     parts.push(`${name}/${p.model ?? "?"} (${key})`);
   }
   checks.push({
@@ -6665,13 +7522,30 @@ function checkScaffoldVersion(checks, root) {
   checks.push({ name: "scaffold version", status: status2, detail });
   return { onDisk, current, drift };
 }
+function checkSeedDrift(checks, root) {
+  const seedPath = join6(root, ".noir", ".env.example");
+  let bytes;
+  try {
+    bytes = readFileSync4(seedPath, "utf8");
+  } catch {
+    return;
+  }
+  const currentRender = render(loadTemplate("env.example.tmpl"), {});
+  if (isStaleSeed("envExample", bytes, currentRender)) {
+    checks.push({
+      name: "doc seed",
+      status: "warn",
+      detail: `.noir/.env.example is an unedited copy of an older Noir \u2014 run \`noir init --upgrade\` to refresh it`
+    });
+  }
+}
 function checkRulesMdBudget(checks, root, project) {
   if (!project) {
     checks.push({ name: "rules budget", status: "warn", detail: "skipped \u2014 not initialized" });
     return null;
   }
-  const rulesPath = paths2.rulesMd(root);
-  if (!existsSync4(rulesPath)) {
+  const rulesPath = paths4.rulesMd(root);
+  if (!existsSync5(rulesPath)) {
     checks.push({
       name: "rules budget",
       status: "ok",
@@ -6735,7 +7609,7 @@ function checkHostArtifacts(checks, root, project) {
   if (host === "claude") expected.push("CLAUDE.md");
   else if (host === "gemini") expected.push("GEMINI.md");
   expected.push(relOr(adapter.mcpConfigPath?.(ectx) ?? ".mcp.json", root));
-  const missing = expected.filter((p) => !existsSync4(joinRoot(root, p)));
+  const missing = expected.filter((p) => !existsSync5(joinRoot(root, p)));
   const status2 = missing.length === 0 ? "ok" : "warn";
   const detail = missing.length === 0 ? `host=${host} \xB7 all ${expected.length} primary artifacts present` : `host=${host} \xB7 missing ${missing.join(", ")} (run \`noir sync\` to restore)`;
   checks.push({ name: "host artifacts", status: status2, detail });
@@ -6752,7 +7626,7 @@ function checkNestedNoir(checks, root) {
     ".noir/.npmignore",
     ".noir/.prettierignore"
   ];
-  const found = candidates.filter((rel) => existsSync4(join6(root, rel)));
+  const found = candidates.filter((rel) => existsSync5(join6(root, rel)));
   const detected = found.length > 0;
   checks.push({
     name: "nested .noir",
@@ -6766,7 +7640,7 @@ function collectDedupCandidates(root) {
   const out = [];
   for (const rel of rels) {
     const abs = join6(root, rel);
-    if (!existsSync4(abs)) continue;
+    if (!existsSync5(abs)) continue;
     let text;
     try {
       text = readFileSync4(abs, "utf8");
@@ -6827,12 +7701,12 @@ function resolveWorkspacePackagesDir() {
   let here = dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 8; i++) {
     const pkgPath = join6(here, "package.json");
-    if (existsSync4(pkgPath)) {
+    if (existsSync5(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
         if (pkg.name === "@noir-ai/cli") {
           const packagesDir = dirname(here);
-          if (existsSync4(join6(dirname(packagesDir), "pnpm-workspace.yaml"))) {
+          if (existsSync5(join6(dirname(packagesDir), "pnpm-workspace.yaml"))) {
             return packagesDir;
           }
           return null;
@@ -6891,7 +7765,7 @@ function checkPublish(checks, packagesDir, opts = {}) {
   let cliDir = null;
   for (const name of entries) {
     const pkgPath = join6(packagesDir, name, "package.json");
-    if (!existsSync4(pkgPath)) continue;
+    if (!existsSync5(pkgPath)) continue;
     let pkg;
     try {
       pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
@@ -6999,6 +7873,7 @@ async function doctor(opts = {}) {
   checkProvider(checks, project, noirEnv.sources);
   checkNoirEnv(checks, root, noirEnv);
   const scaffold4 = checkScaffoldVersion(checks, root);
+  checkSeedDrift(checks, root);
   const rules = checkRulesMdBudget(checks, root, project);
   const host = checkHostArtifacts(checks, root, project);
   checkNestedNoir(checks, root);