@noir-ai/cli 1.14.0 → 1.15.0

package/dist/tui/{chunk-6LO4LXEH.js → chunk-5KWETEMF.js}

@@ -2,7 +2,7 @@ import {
   DEFAULT_UPDATE_CONFIG,
   buildUpdateNotice,
   runAsyncUpdateCheck
-} from "./chunk-2RK6AFZQ.js";
+} from "./chunk-TPNJEN4B.js";
 import {
   EXIT,
   NoirCliError,
@@ -12,6 +12,7 @@ import {
   definitionList,
   error,
   fail,
+  failAndExit,
   handleError,
   info,
   isInteractive,
@@ -25,7 +26,7 @@ import {
   tip,
   useColor,
   warn
-} from "./chunk-ESZTOQEC.js";
+} from "./chunk-KETMM3BA.js";
 
 // src/commands/status.ts
 import { loadProjectInfo as loadProjectInfo14, NOIR_VERSION as NOIR_VERSION5 } from "@noir-ai/core";
@@ -174,8 +175,8 @@ async function contextIndex(opts) {
   }
   renderIndex(data, opts.paths, opts);
 }
-function renderIndex(data, paths2, opts) {
-  const scope = paths2 && paths2.length > 0 ? paths2.join(", ") : ".";
+function renderIndex(data, paths4, opts) {
+  const scope = paths4 && paths4.length > 0 ? paths4.join(", ") : ".";
   const flag = data.degraded ? `  ${badge("warn", "degraded: vectors skipped")}` : "";
   log(`context index \u2014 ${scope}${flag}`, opts);
   definitionList(
@@ -870,7 +871,13 @@ import {
   readInstallRecord,
   readUpdateCache
 } 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 pidAlive3, readProjectDaemonRecord as readProjectDaemonRecord2 } from "@noir-ai/daemon";
 import { resolveModelConfig } from "@noir-ai/model";
 async function probeOnnx() {
@@ -1117,9 +1124,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({
@@ -1155,6 +1163,23 @@ function checkScaffoldVersion(checks, root) {
   checks.push({ name: "scaffold version", status: status2, detail });
   return { onDisk, current, drift };
 }
+function checkSeedDrift(checks, root) {
+  const seedPath = join2(root, ".noir", ".env.example");
+  let bytes;
+  try {
+    bytes = readFileSync2(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" });
@@ -1490,6 +1515,7 @@ async function doctor(opts = {}) {
   checkProvider(checks, project, noirEnv.sources);
   checkNoirEnv(checks, root, noirEnv);
   const scaffold2 = checkScaffoldVersion(checks, root);
+  checkSeedDrift(checks, root);
   const rules = checkRulesMdBudget(checks, root, project);
   const host = checkHostArtifacts(checks, root, project);
   checkNestedNoir(checks, root);
@@ -1542,6 +1568,9 @@ var CURATED_AMBIENT_KEYS = [
   "COHERE_API_KEY",
   "OLLAMA_BASE_URL",
   "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "API_TIMEOUT_MS",
   "NOIR_PROFILE"
 ];
 var ambientBaseline;
@@ -1597,12 +1626,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
@@ -1610,10 +1639,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
@@ -1641,7 +1670,7 @@ import {
   writeDecisionStub
 } from "@noir-ai/workflow";
 var 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",
@@ -2053,7 +2082,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: {
@@ -2416,6 +2445,14 @@ function isDestructive(argv) {
     return prefix.every((tok, i) => argv[i] === tok);
   });
 }
+function runPromptFrom(argv) {
+  if (argv[0] !== "run") return null;
+  const rest = argv.slice(1);
+  if (rest.length === 0) return null;
+  if (rest.some((token) => token.startsWith("-"))) return null;
+  const prompt = rest.join(" ").trim();
+  return prompt.length > 0 ? prompt : null;
+}
 function capitalizeFirst(s) {
   if (s.length === 0) return s;
   return `${s[0]?.toUpperCase() ?? ""}${s.slice(1)}`;
@@ -2423,6 +2460,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;
@@ -2437,7 +2478,8 @@ function collectLeaves(cmd, path, out) {
       description,
       category: argv[0] ?? "",
       keywords: argv,
-      destructive: isDestructive(argv)
+      destructive: isDestructive(argv),
+      needsArg: requiredArgLabel(cmd)
     });
     return;
   }
@@ -2503,7 +2545,15 @@ var HOME_SECTIONS = [
         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",
@@ -2527,8 +2577,21 @@ var HOME_SECTIONS = [
   {
     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",
@@ -3362,16 +3425,19 @@ async function release(opts) {
 }
 
 // src/commands/run.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
 import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
-import { loadNoirEnv as loadNoirEnv3, NOIR_DIR as NOIR_DIR2, parseConfig } from "@noir-ai/core";
+import { isDeniedEnvKey as isDeniedEnvKey2, loadNoirEnv as loadNoirEnv3, NOIR_DIR as NOIR_DIR2, parseConfig, paths as paths2 } from "@noir-ai/core";
 
 // src/orchestrator.ts
 import { spawn as spawn2 } from "child_process";
 import { constants } from "os";
 import { createInterface } from "readline";
 
+// src/run-timing.ts
+var INTERRUPT_GRACE_MS = 5e3;
+
 // src/shell-bridge.ts
 import { spawn } from "child_process";
 import { basename } from "path";
@@ -3419,7 +3485,7 @@ var PROBE_SCRIPTS = {
 function probeCommand(name, shell, opts) {
   const kind = shellKind(shell);
   const timeoutMs = opts.timeoutMs ?? PROBE_TIMEOUT_MS2;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const script = kind ? PROBE_SCRIPTS[kind] : "";
     const flags = kind ? PROBE_FLAGS[kind] : "-lic";
     const probeArgs = kind === "fish" ? [name] : ["noirbridge", name];
@@ -3442,15 +3508,15 @@ function probeCommand(name, shell, opts) {
         } catch {
         }
       }
-      resolve({ stdout, timedOut: true });
+      resolve2({ stdout, timedOut: true });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve({ stdout, timedOut: false });
+      resolve2({ stdout, timedOut: false });
     });
     child.on("close", () => {
       clearTimeout(timer);
-      resolve({ stdout, timedOut: false });
+      resolve2({ stdout, timedOut: false });
     });
   });
 }
@@ -3506,7 +3572,7 @@ var HOST_BINARY = {
   // emits AGENTS.md — a file host, not a spawnable CLI
 };
 var 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"],
@@ -3539,18 +3605,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();
@@ -3569,15 +3640,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).
@@ -3586,6 +3656,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 {
@@ -3597,7 +3681,29 @@ 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" };
 }
 var UsageReducer = class {
   maxByMessage = /* @__PURE__ */ new Map();
@@ -3607,27 +3713,29 @@ var UsageReducer = class {
   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() {
@@ -3639,6 +3747,12 @@ var UsageReducer = class {
     };
   }
 };
+function signalChild(child, signal) {
+  if (child.pid === void 0) return;
+  child.kill(signal);
+}
+var BRIDGE_POLITE_RESEND_MS = 250;
+var BRIDGE_POLITE_WINDOW_MS = INTERRUPT_GRACE_MS;
 function runHost(opts) {
   const spec = resolveHostRun(opts.host, opts.customBinary);
   if (!spec) {
@@ -3653,12 +3767,13 @@ function runHost(opts) {
     false
   );
 }
-function spawnAndConsume(binary, args, opts, shellRun) {
-  return new Promise((resolve, reject) => {
+function spawnAndConsume(binary, args, opts, shellRun, bridged = false) {
+  return new Promise((resolve2, 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 = "";
@@ -3666,10 +3781,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, resolve, reject, err);
+        void shellFallback(binary, args, opts, resolve2, reject, err);
         return;
       }
       reject(err);
@@ -3696,31 +3841,32 @@ 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;
-      resolve({
-        exitCode: killed ? 128 + (signalNumber(signal) ?? 0) : code ?? 0,
+      const killed = code === null && signal2 != null;
+      resolve2({
+        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, resolve, reject, originalErr) {
+async function shellFallback(binary, args, opts, resolve2, reject, originalErr) {
   try {
     const res = await resolveCommandViaShell(binary, { env: opts.env ?? process.env });
     if (res.kind === "path") {
-      resolve(await spawnAndConsume(res.path, args, opts, true));
+      resolve2(await spawnAndConsume(res.path, args, opts, true));
       return;
     }
     if (res.kind === "alias" || res.kind === "function") {
       const bridge = buildBridgeArgs(binary, args, res.shell);
-      resolve(await spawnAndConsume(bridge.binary, bridge.args, opts, true));
+      resolve2(await spawnAndConsume(bridge.binary, bridge.args, opts, true, true));
       return;
     }
   } catch {
@@ -3728,8 +3874,339 @@ async function shellFallback(binary, args, opts, resolve, reject, originalErr) {
   reject(originalErr);
 }
 
+// src/run-actions.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { resolve } from "path";
+import { CommanderError } from "commander";
+var CAPTURE_EVENT = "capture";
+var RESEARCH_SOURCE = "noir run";
+var RESEARCH_TEXT_LIMIT = 220;
+var ACTION_LABEL = {
+  memory: "Saving to memory",
+  research: "Recording the finding",
+  handoff: "Writing the handoff",
+  resume: "Continuing the session",
+  save: "Writing the file",
+  dismiss: "Dismissing"
+};
+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 CommanderError || 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, "-");
+}
+
+// src/run-interrupt.ts
+import { constants as constants2 } from "os";
+var INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
+function exitCodeForSignal(signal) {
+  return 128 + (constants2.signals[signal] ?? 0);
+}
+function interruptedNotice(transcript) {
+  return `interrupted \xB7 transcript: ${transcript}`;
+}
+var 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 loadProjectInfo9 } from "@noir-ai/core";
+import { isDeniedEnvKey, loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
 function loadRunConfig(root) {
   try {
     return loadProjectInfo9(root).config;
@@ -3764,6 +4241,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 }
@@ -3779,6 +4264,183 @@ function listProfiles(config) {
   }));
 }
 
+// src/run-status.ts
+var HOST_STDERR_TAIL_LINES = 20;
+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`;
+}
+var 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);
+  }
+};
+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");
+}
+
 // src/commands/run.ts
 var CREDENTIAL_ENV_VARS = [
   "ANTHROPIC_API_KEY",
@@ -3804,13 +4466,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);
@@ -3829,7 +4502,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 (!existsSync3(join4(root, NOIR_DIR2, ".env"))) {
     log(
@@ -3838,6 +4511,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({
@@ -3847,28 +4551,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) {
@@ -3881,26 +4618,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 = paths2.transcriptsDir(root);
   const file = join4(dir, `${host}-${ts}.jsonl`);
   try {
     mkdirSync2(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)";
   }
@@ -3908,252 +4678,35 @@ function writeTranscript(host, lines) {
 }
 
 // src/commands/skills.ts
-import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
-  emitSkillsToDir,
+  emitSkillsToDir as emitSkillsToDir2,
   lintSkill
 } from "@noir-ai/skills";
-var 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"
-};
-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`;
+
+// src/init.ts
+import { existsSync as existsSync4 } from "fs";
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo10, paths as paths3 } from "@noir-ai/core";
+import { scaffold } from "@noir-ai/create";
+import {
+  emitSkillsToDir
+} from "@noir-ai/skills";
+
+// src/conflict.ts
+import {
+  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
-    );
-  }
-  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 = loadProjectInfo10(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 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
-  );
-}
-
-// src/init.ts
-import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
-import { scaffold } from "@noir-ai/create";
-import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
-
-// 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" };
+function buildConflictOpts(input = {}) {
+  if (input.force === true) {
+    return { conflictPolicy: "overwrite" };
   }
   if (input.interactive === false) {
     return { conflictPolicy: "preserve" };
@@ -4245,7 +4798,7 @@ function labelFor(resolution) {
 }
 
 // src/dedup-write.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync5 } from "fs";
 import { join as join5 } from "path";
 import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
 var HOST_CONTEXT_RELS = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"]);
@@ -4399,14 +4952,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 = readFileSync4(join5(root, matchedRel), "utf8");
-      writeFileSync4(
+      writeFileSync5(
         join5(root, matchedRel),
         `${existing}
 
@@ -4445,7 +4998,7 @@ function loadCache(root) {
 function saveCache(root, cache) {
   try {
     mkdirSync3(join5(root, ".noir"), { recursive: true });
-    writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
+    writeFileSync5(cachePath(root), JSON.stringify(cache), "utf8");
   } catch {
   }
 }
@@ -4467,16 +5020,16 @@ function safeRead(abs) {
   }
 }
 function withTimeout(p, ms) {
-  return new Promise((resolve) => {
-    const t = setTimeout(() => resolve(void 0), ms);
+  return new Promise((resolve2) => {
+    const t = setTimeout(() => resolve2(void 0), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve(v);
+        resolve2(v);
       },
       () => {
         clearTimeout(t);
-        resolve(void 0);
+        resolve2(void 0);
       }
     );
   });
@@ -4488,7 +5041,7 @@ function errMsg(e) {
 // src/init.ts
 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;
@@ -4509,15 +5062,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 = loadProjectInfo11(root);
+    projectInfo = loadProjectInfo10(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}).
 `
@@ -4527,6 +5094,19 @@ async function init(root, opts) {
   );
   return res;
 }
+function resolveInitHost(root, opts) {
+  if (opts.host !== void 0) return opts.host;
+  if (!existsSync4(paths3.config(root))) return "claude";
+  try {
+    return loadProjectInfo10(root).config.host;
+  } catch {
+    process.stderr.write(
+      `Could not read the configured host from ${paths3.config(root)}; using 'claude'.
+`
+    );
+    return "claude";
+  }
+}
 function reportPlannedWrites(res) {
   log("Dry run \u2014 no files were written.");
   if (res.written.length > 0) {
@@ -4536,6 +5116,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}`);
@@ -4546,12 +5130,12 @@ function reportPlannedWrites(res) {
   }
 }
 async function emitHostSkills(root, host, conflictOpts, interactive) {
-  const adapter = resolveAdapter5(host);
+  const adapter = resolveAdapter4(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 = {
@@ -4563,12 +5147,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) {
@@ -4593,6 +5185,235 @@ function assertLocalhostUrl(raw) {
   }
 }
 
+// src/commands/skills.ts
+var 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"
+};
+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 = loadProjectInfo11(root);
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
+  const adapter = resolveAdapter5(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
+  );
+}
+
 // src/serve.ts
 import { applyNoirEnv, loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
 import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
@@ -4734,13 +5555,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) => {
@@ -4773,7 +5596,7 @@ function createProgram() {
       const force = opts.force === true;
       const host = parseHost(opts.host);
       const dryRun = opts.dryRun === true || opts.preview === true;
-      const { create } = await import("./create-FD4E626Z.js");
+      const { create } = await import("./create-6KDIFPUL.js");
       const result = await create(dir, {
         transport,
         url: opts.url,
@@ -4803,7 +5626,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(
@@ -4812,7 +5635,7 @@ function createProgram() {
     ).choices(SUPPORTED_HOSTS2)
   ).action(
     async (opts, cmd) => {
-      const { sync } = await import("./sync-N633SQSS.js");
+      const { sync } = await import("./sync-AII5WCRO.js");
       const host = parseHost(opts.host);
       const force = opts.force === true;
       const merge = opts.merge === true;
@@ -5198,7 +6021,7 @@ function createProgram() {
     "dismiss the migration banner for the current version (persists in install.json)"
   ).argument("[spec]", "channel ('latest'|'beta') or exact version (default: latest)").action(
     async (spec, opts, cmd) => {
-      const { install } = await import("./install-YGTUSLRO.js");
+      const { install } = await import("./install-KA35ONQP.js");
       const cli = cmd.optsWithGlobals();
       await install({
         ...cli,
@@ -5211,7 +6034,7 @@ function createProgram() {
   );
   installCmd.alias("migrate");
   program2.command("update").description("update Noir to the latest version via the active install method").option("--check", "check for a new version without changing anything").argument("[spec]", "channel ('latest'|'beta') or exact version (default: latest)").action(async (spec, opts, cmd) => {
-    const { update } = await import("./update-LET5BWOU.js");
+    const { update } = await import("./update-XGKJ4KBR.js");
     const cli = cmd.optsWithGlobals();
     await update({ ...cli, spec, check: opts.check === true });
   });
@@ -5328,7 +6151,7 @@ var homeDeps = {
     }
   },
   // 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())
 };
@@ -5902,11 +6725,27 @@ export {
   describeMemory,
   gatherStatusPayload,
   isDestructive,
+  runPromptFrom,
   resolveSections,
+  INTERRUPT_GRACE_MS,
+  parseStreamLine,
+  normalizeStreamEvent,
+  UsageReducer,
+  runHost,
+  postRunActions,
+  performPostRunAction,
+  interruptedNotice,
+  RunInterrupt,
+  loadRunConfig,
+  resolveRunProfile,
+  humanizeElapsed,
+  mergeEnv,
+  writeTranscript,
   buildConflictOpts,
   checkWritePathDedup,
   reportPlannedWrites,
+  preservedStaleLine,
   assertTransportUrl,
   buildPaletteCommandsForTui
 };
-//# sourceMappingURL=chunk-6LO4LXEH.js.map
+//# sourceMappingURL=chunk-5KWETEMF.js.map