@noir-ai/cli 1.11.2 → 1.12.0-beta.1

package/dist/bin.js

@@ -1,46 +1,18 @@
 #!/usr/bin/env node
-import {
-  serve
-} from "./chunk-A5W2E3X2.js";
-import {
-  DEFAULT_UPDATE_CONFIG,
-  buildUpdateNotice,
-  runAsyncUpdateCheck
-} from "./chunk-QIVHIKYD.js";
-import "./chunk-RON2XESF.js";
-import {
-  doctor,
-  init
-} from "./chunk-CT6TYLHN.js";
-import {
-  EXIT,
-  NoirCliError,
-  accessibleMode,
-  badge,
-  c,
-  definitionList,
-  fail,
-  handleError,
-  inferExitCode,
-  info,
-  isInteractive,
-  json,
-  log,
-  requireInteractive,
-  spinner,
-  success,
-  table,
-  tip,
-  useColor,
-  warn
-} from "./chunk-I2R55ACD.js";
-
-// src/bin.ts
-import { realpathSync } from "fs";
-import { pathToFileURL } from "url";
-import { SUPPORTED_HOSTS as SUPPORTED_HOSTS2 } from "@noir-ai/adapters";
-import { NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
-import { Command, Option } from "commander";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/daemon-client.ts
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
@@ -55,8 +27,6 @@ import {
 import { createMemoryEngine } from "@noir-ai/memory";
 import { openStore } from "@noir-ai/store";
 import { WorkflowEngine } from "@noir-ai/workflow";
-var DAEMON_DOWN_HINT = "daemon not reachable \u2014 try `noir daemon start`";
-var PROBE_TIMEOUT_MS = 1500;
 function describeCause(cause) {
   if (cause instanceof Error) return `${cause.name}: ${cause.message}`;
   try {
@@ -93,8 +63,21 @@ async function probeDaemon(opts = {}) {
       return { running: false };
     }
     const body = await res.json().catch(() => null);
-    if (body?.ok !== true) {
-      if (opts.verbose) process.stderr.write("noir: daemon probe: /health body not ok\n");
+    const pidOk = typeof body?.pid === "number" && body.pid === rec.pid;
+    const expectedProject = opts.project?.id ?? (() => {
+      try {
+        return loadProjectInfo(process.cwd()).id;
+      } catch {
+        return void 0;
+      }
+    })();
+    const projectOk = expectedProject === void 0 || body?.projectId !== void 0 && body.projectId === expectedProject;
+    if (body?.ok !== true || !pidOk || !projectOk) {
+      if (opts.verbose)
+        process.stderr.write(
+          !pidOk ? "noir: daemon probe: pid missing/mismatched (foreign process on recorded port)\n" : !projectOk ? `noir: daemon probe: daemon serves a different project (${body?.projectId ?? "unknown"}); using in-process fallback
+` : "noir: daemon probe: /health body not ok\n"
+        );
       return { running: false };
     }
     return {
@@ -111,7 +94,12 @@ async function probeDaemon(opts = {}) {
   }
 }
 async function resolveDaemon(opts) {
-  const project = opts.project ?? loadProjectInfo(process.cwd());
+  let project;
+  try {
+    project = opts.project ?? loadProjectInfo(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
   const idleTimeoutSec = opts.idleTimeoutSec ?? project.config.daemon.idleTimeoutSec;
   try {
     const ensured = await ensureDaemonRunning({ project, idleTimeoutSec });
@@ -202,8 +190,22 @@ async function callDaemonTool(opts, name, args = {}) {
   return withDaemon(opts, (caller) => caller.callTool(name, args));
 }
 async function withInProcessRead(opts, fn) {
-  const project = opts.project ?? loadProjectInfo(process.cwd());
-  const store = await openStore({ projectId: project.id, root: project.root, readonly: true });
+  let project;
+  try {
+    project = opts.project ?? loadProjectInfo(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
+  let store;
+  try {
+    store = await openStore({ projectId: project.id, root: project.root, readonly: true });
+  } catch (err) {
+    fail(
+      EXIT.ERROR,
+      `could not open the store read-only: ${err instanceof Error ? err.message : String(err)}`,
+      opts
+    );
+  }
   try {
     const embedderCfg = resolveEmbedderConfig(project.config.context);
     const embed = createEmbedFn(embedderCfg).embed;
@@ -233,6 +235,368 @@ async function withInProcessRead(opts, fn) {
     });
   }
 }
+var DAEMON_DOWN_HINT, PROBE_TIMEOUT_MS;
+var init_daemon_client = __esm({
+  "src/daemon-client.ts"() {
+    "use strict";
+    init_bin();
+    DAEMON_DOWN_HINT = "daemon not reachable \u2014 try `noir daemon start`";
+    PROBE_TIMEOUT_MS = 1500;
+  }
+});
+
+// src/theme.ts
+import pc from "picocolors";
+function badge(state, label = state) {
+  const text = `${BADGE_SYMBOL[state]} ${label}`;
+  switch (state) {
+    case "ok":
+      return c.ok(text);
+    case "warn":
+      return c.warn(text);
+    case "error":
+      return c.error(text);
+    case "info":
+      return c.info(text);
+  }
+}
+function envFlagSet(name) {
+  const v = process.env[name];
+  return v !== void 0 && v !== "";
+}
+function isCiEnv() {
+  const v = process.env.CI;
+  if (v === void 0 || v === "") return false;
+  return v !== "0" && v !== "false";
+}
+function useColor() {
+  if (envFlagSet("NO_COLOR")) return false;
+  if (process.env.CLICOLOR_FORCE === "1") return true;
+  if (isCiEnv()) return false;
+  return pc.isColorSupported;
+}
+function accessibleMode() {
+  return envFlagSet("NOIR_ACCESSIBLE");
+}
+function terminalWidth() {
+  const fromEnv = process.env.COLUMNS;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    const n = Number(fromEnv);
+    if (Number.isInteger(n) && n > 0) return Math.max(n, 20);
+  }
+  const cols = process.stdout.columns;
+  if (typeof cols === "number" && cols > 0) return Math.max(cols, 20);
+  return 80;
+}
+var FORCE, c, BADGE_SYMBOL;
+var init_theme = __esm({
+  "src/theme.ts"() {
+    "use strict";
+    FORCE = pc.createColors(true);
+    c = {
+      /** Green — success / healthy. */
+      ok: (s) => useColor() ? FORCE.green(s) : s,
+      /** Yellow — degraded but usable. */
+      warn: (s) => useColor() ? FORCE.yellow(s) : s,
+      /** Red — reserved strictly for ERROR. Never a table header. */
+      error: (s) => useColor() ? FORCE.red(s) : s,
+      /** Cyan — informational / brand-neutral accent for labels. */
+      info: (s) => useColor() ? FORCE.cyan(s) : s,
+      /** Blue — the Midnight Cobalt brand role (banner / accent). */
+      accent: (s) => useColor() ? FORCE.blue(s) : s,
+      /** Dim — secondary text, table borders when color is on. */
+      dim: (s) => useColor() ? FORCE.dim(s) : s,
+      /** Bold — emphasis (table headers compose this with `info`). */
+      bold: (s) => useColor() ? FORCE.bold(s) : s,
+      /** Reverse video (SGR 7) — inverted background for the active list row. */
+      inverse: (s) => useColor() ? FORCE.inverse(s) : s
+    };
+    BADGE_SYMBOL = {
+      ok: "\u2713",
+      warn: "\u26A0",
+      error: "\u2717",
+      info: "\u2139"
+    };
+  }
+});
+
+// src/output.ts
+import Table from "cli-table3";
+import { CommanderError } from "commander";
+import ora from "ora";
+function isJsonMode(opts) {
+  return opts.json === true;
+}
+function isQuietMode(opts) {
+  return opts.quiet === true;
+}
+function isNoInput(opts = {}) {
+  return opts.noInput === true || opts.input === false;
+}
+function envFlagSet2(name) {
+  const v = process.env[name];
+  return v !== void 0 && v !== "";
+}
+function isInteractive(opts = {}) {
+  if (isJsonMode(opts) || isNoInput(opts)) return false;
+  if (isCiEnv() || envFlagSet2("NO_COLOR")) return false;
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function resolveInteractive() {
+  if (flaggedNonInteractiveCli()) return false;
+  return isInteractive();
+}
+function flaggedNonInteractiveCli() {
+  const v = process.env.NOIR_NON_INTERACTIVE;
+  return v !== void 0 && v !== "";
+}
+function json(obj) {
+  process.stdout.write(`${JSON.stringify(obj)}
+`);
+}
+function log(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${msg2}
+`);
+}
+function info(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${c.info(msg2)}
+`);
+}
+function success(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${c.ok(msg2)}
+`);
+}
+function warn(msg2, opts = {}) {
+  if (isJsonMode(opts)) return;
+  process.stderr.write(`${c.warn(msg2)}
+`);
+}
+function error(msg2, opts = {}) {
+  if (isJsonMode(opts)) return;
+  process.stderr.write(`${c.error(msg2)}
+`);
+}
+function tip(msg2, opts = {}) {
+  if (isJsonMode(opts) || opts.noTips === true) return;
+  process.stderr.write(`${c.warn(msg2)}
+`);
+}
+function table(rows, cols, opts = {}) {
+  if (isJsonMode(opts)) return;
+  if (rows.length === 0) {
+    info("(no rows)", opts);
+    return;
+  }
+  const t = new Table({
+    head: cols.map((col) => c.bold(c.info(col))),
+    // Empty arrays ⇒ cli-table3 applies NO @colors/colors wrap (neither the
+    // default red header nor a colored border). All color is ours, via theme.
+    style: { head: [], border: [] },
+    colWidths: computeColWidths(rows, cols),
+    wordWrap: true,
+    truncate: "\u2026"
+  });
+  for (const row of rows) {
+    t.push(cols.map((col) => formatCell(row[col])));
+  }
+  process.stderr.write(`${t.toString()}
+`);
+}
+function computeColWidths(rows, cols) {
+  const n = cols.length;
+  if (n === 0) return [];
+  const headerLen = cols.map((col) => col.length);
+  const natural = cols.map((col, i) => {
+    let max = Math.max(headerLen[i] ?? col.length, 3);
+    for (const row of rows) {
+      const len = formatCell(row[col]).length;
+      if (len > max) max = len;
+    }
+    return max;
+  });
+  const contentBudget = Math.max(n * 4, terminalWidth() - 3 * n - 1);
+  const naturalSum = natural.reduce((a, b) => a + b, 0);
+  if (naturalSum <= contentBudget) {
+    return natural.map((w) => w + 2);
+  }
+  const content = natural.slice();
+  let sum = naturalSum;
+  const floor = headerLen.map((h) => Math.max(h, 3));
+  while (sum > contentBudget) {
+    let idx = -1;
+    let widest = -1;
+    for (let i = 0; i < n; i++) {
+      const c2 = content[i] ?? 0;
+      const f = floor[i] ?? 3;
+      if (c2 > f && c2 > widest) {
+        widest = c2;
+        idx = i;
+      }
+    }
+    if (idx === -1) break;
+    const overshoot = sum - contentBudget;
+    const reducible = (content[idx] ?? 0) - (floor[idx] ?? 3);
+    const cut = Math.min(overshoot, reducible);
+    content[idx] = (content[idx] ?? 0) - cut;
+    sum -= cut;
+  }
+  return content.map((w) => w + 2);
+}
+function formatCell(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function definitionList(rows, opts = {}) {
+  table(
+    rows.map((r) => ({ Field: r.label, Value: formatCell(r.value) })),
+    ["Field", "Value"],
+    opts
+  );
+}
+function spinner(text = "", opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts) || !isInteractive(opts)) {
+    return new NoopSpinner();
+  }
+  return new OraSpinner(text);
+}
+function fail(exitCode, message, opts = {}) {
+  if (isJsonMode(opts)) {
+    process.stdout.write(`${JSON.stringify({ ok: false, error: { code: exitCode, message } })}
+`);
+  } else if (message.length > 0) {
+    process.stderr.write(`${message}
+`);
+  }
+  throw new CommanderError(exitCode, NOIR_ERROR_CODE, message);
+}
+function requireInteractive(opts, hint) {
+  if (!isInteractive(opts)) {
+    fail(
+      EXIT.USAGE,
+      `${hint} needs an interactive terminal, but input is disabled (non-TTY, --no-input, --json, CI, or NO_COLOR). Re-run in a TTY or supply the value as a flag.`,
+      opts
+    );
+  }
+}
+function commanderExitCode(err) {
+  switch (err.code) {
+    case "commander.helpDisplayed":
+    case "commander.versionDisplayed":
+    case "commander.version":
+      return EXIT.OK;
+    case "commander.unknownCommand":
+      return EXIT.NOT_FOUND;
+    default:
+      return EXIT.USAGE;
+  }
+}
+function inferExitCode(err) {
+  if (err instanceof NoirCliError) return err.exitCode;
+  if (err instanceof CommanderError) {
+    if (err.code.startsWith("noir.")) return err.exitCode;
+    return commanderExitCode(err);
+  }
+  return EXIT.ERROR;
+}
+function handleError(err) {
+  if (err instanceof NoirCliError) {
+    if (err.message.length > 0) process.stderr.write(`${err.message}
+`);
+  } else if (err instanceof CommanderError) {
+  } else {
+    process.stderr.write(`noir: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  process.exitCode = inferExitCode(err);
+}
+var EXIT, NoirCliError, NOIR_ERROR_CODE, NoopSpinner, OraSpinner;
+var init_output = __esm({
+  "src/output.ts"() {
+    "use strict";
+    init_theme();
+    EXIT = {
+      OK: 0,
+      ERROR: 1,
+      USAGE: 2,
+      NOT_FOUND: 3,
+      DAEMON_DOWN: 4,
+      CANCELLED: 5
+    };
+    NoirCliError = class extends Error {
+      exitCode;
+      constructor(exitCode, message) {
+        super(message);
+        this.name = "NoirCliError";
+        this.exitCode = exitCode;
+      }
+    };
+    NOIR_ERROR_CODE = "noir.error";
+    NoopSpinner = class {
+      text = "";
+      start(_text) {
+        return this;
+      }
+      stop() {
+        return this;
+      }
+      clear() {
+        return this;
+      }
+      succeed(_text) {
+      }
+      fail(_text) {
+      }
+      warn(_text) {
+      }
+      info(_text) {
+      }
+    };
+    OraSpinner = class {
+      handle;
+      constructor(initialText) {
+        this.handle = ora(initialText);
+      }
+      get text() {
+        return this.handle.text;
+      }
+      set text(value) {
+        this.handle.text = value;
+      }
+      start(text) {
+        if (text !== void 0) this.handle.text = text;
+        this.handle.start();
+        return this;
+      }
+      stop() {
+        this.handle.stop();
+        return this;
+      }
+      clear() {
+        this.handle.clear();
+        return this;
+      }
+      succeed(text) {
+        this.handle.succeed(text);
+      }
+      fail(text) {
+        this.handle.fail(text);
+      }
+      warn(text) {
+        this.handle.warn(text);
+      }
+      info(text) {
+        this.handle.info(text);
+      }
+    };
+  }
+});
 
 // src/commands/context.ts
 function parseLimit(raw, label, opts) {
@@ -349,8 +713,8 @@ async function contextIndex(opts) {
   }
   renderIndex(data, opts.paths, opts);
 }
-function renderIndex(data, paths, opts) {
-  const scope = paths && paths.length > 0 ? paths.join(", ") : ".";
+function renderIndex(data, paths3, opts) {
+  const scope = paths3 && paths3.length > 0 ? paths3.join(", ") : ".";
   const flag = data.degraded ? `  ${badge("warn", "degraded: vectors skipped")}` : "";
   log(`context index \u2014 ${scope}${flag}`, opts);
   definitionList(
@@ -398,6 +762,14 @@ function renderStatus(data, opts) {
     opts
   );
 }
+var init_context = __esm({
+  "src/commands/context.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_theme();
+  }
+});
 
 // src/commands/daemon.ts
 import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
@@ -408,23 +780,41 @@ import {
   readDaemonRecord as readDaemonRecord2,
   spawnDetachedDaemon
 } from "@noir-ai/daemon";
-var MODE = "foreground";
 function formatUptime(sec) {
   if (!Number.isFinite(sec) || sec < 0) return "unknown";
   if (sec < 60) return `${sec}s`;
   if (sec < 3600) return `${Math.floor(sec / 60)}m ${sec % 60}s`;
   return `${Math.floor(sec / 3600)}h ${Math.floor(sec % 3600 / 60)}m`;
 }
-async function isHealthy(port) {
+function resolveCallerProjectId() {
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/health`);
-    return res.status === 200;
+    return loadProjectInfo2(process.cwd()).id;
+  } catch {
+    return void 0;
+  }
+}
+async function isHealthy(port, expectedPid, expectedProjectId) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+    if (res.status !== 200) return false;
+    if (expectedPid === void 0) return true;
+    const body = await res.json();
+    if (body?.ok !== true || body.pid !== expectedPid) return false;
+    if (expectedProjectId !== void 0 && body.projectId !== expectedProjectId) return false;
+    return true;
   } catch {
     return false;
   }
 }
 async function daemonStart(opts) {
-  const project = loadProjectInfo2(process.cwd());
+  let project;
+  try {
+    project = loadProjectInfo2(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
   if (opts.detachChild === true) {
     const child = await ensureDaemonRunning2({
       project,
@@ -452,7 +842,7 @@ async function daemonStart(opts) {
   }
   if (opts.detach === true) {
     const existing = readDaemonRecord2();
-    if (existing && pidAlive2(existing.pid) && await isHealthy(existing.port)) {
+    if (existing && pidAlive2(existing.pid) && await isHealthy(existing.port, existing.pid, project.id)) {
       if (opts.json === true) {
         process.stdout.write(
           `${JSON.stringify({ ok: true, data: { mode: "detached", reused: true } })}
@@ -466,7 +856,16 @@ async function daemonStart(opts) {
       );
       return;
     }
-    const spawned = await spawnDetachedDaemon({ project });
+    let spawned;
+    try {
+      spawned = await spawnDetachedDaemon({ project });
+    } catch (err) {
+      fail(
+        EXIT.ERROR,
+        `noir daemon start --detach failed: ${err instanceof Error ? err.message : String(err)}`,
+        opts
+      );
+    }
     if (opts.json === true) {
       process.stdout.write(
         `${JSON.stringify({ ok: true, data: { mode: "detached", pid: spawned.pid, port: spawned.port } })}
@@ -478,10 +877,20 @@ async function daemonStart(opts) {
     return;
   }
   const ds = spinner("Starting Noir daemon...", opts).start();
-  const ensured = await ensureDaemonRunning2({
-    project,
-    idleTimeoutSec: project.config.daemon.idleTimeoutSec
-  });
+  let ensured;
+  try {
+    ensured = await ensureDaemonRunning2({
+      project,
+      idleTimeoutSec: project.config.daemon.idleTimeoutSec
+    });
+  } catch (err) {
+    ds.fail("Daemon failed to start");
+    fail(
+      EXIT.ERROR,
+      `noir daemon start failed: ${err instanceof Error ? err.message : String(err)}`,
+      opts
+    );
+  }
   if (ensured.started) {
     ds.succeed("Daemon started");
     if (opts.json === true) {
@@ -529,15 +938,19 @@ async function daemonStop(opts) {
   }
   const ds = spinner(`Stopping daemon (pid ${rec.pid})...`, opts).start();
   let signalled = false;
-  let errMsg;
-  try {
-    process.kill(rec.pid, "SIGTERM");
-    signalled = true;
-  } catch (err) {
-    errMsg = err instanceof Error ? err.message : String(err);
-  } finally {
-    clearDaemonRecord();
+  let errMsg2;
+  const callerProject = resolveCallerProjectId();
+  const wrongProject = rec.projectId !== void 0 && callerProject !== void 0 && rec.projectId !== callerProject;
+  const healthy = !wrongProject && pidAlive2(rec.pid) && await isHealthy(rec.port, rec.pid, rec.projectId === void 0 ? void 0 : callerProject);
+  if (healthy) {
+    try {
+      process.kill(rec.pid, "SIGTERM");
+      signalled = true;
+    } catch (err) {
+      errMsg2 = err instanceof Error ? err.message : String(err);
+    }
   }
+  if (!wrongProject) clearDaemonRecord();
   if (opts.json === true) {
     process.stdout.write(
       `${JSON.stringify({
@@ -546,7 +959,7 @@ async function daemonStop(opts) {
           running: signalled,
           stopped: signalled,
           pid: rec.pid,
-          ...errMsg !== void 0 ? { error: errMsg } : {}
+          ...errMsg2 !== void 0 ? { error: errMsg2 } : {}
         }
       })}
 `
@@ -556,8 +969,9 @@ async function daemonStop(opts) {
   if (signalled) {
     ds.succeed(`Stopped Noir daemon (pid ${rec.pid})`);
   } else {
-    ds.warn(`Daemon (pid ${rec.pid}) could not be signalled: ${errMsg}`);
-    info(`Noir daemon (pid ${rec.pid}) could not be signalled: ${errMsg}`, opts);
+    const reason = wrongProject ? "the daemon belongs to another project (left running)" : errMsg2 !== void 0 ? errMsg2 : "the recorded pid did not answer as our daemon (stale record cleared)";
+    ds.warn(`Daemon (pid ${rec.pid}) could not be signalled: ${reason}`);
+    info(`Noir daemon (pid ${rec.pid}) could not be signalled: ${reason}`, opts);
   }
 }
 async function daemonStatus(opts) {
@@ -565,6 +979,14 @@ async function daemonStatus(opts) {
   if (!rec) {
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (start with `noir daemon start`).", opts);
   }
+  const callerProject = resolveCallerProjectId();
+  if (rec.projectId !== void 0 && callerProject !== void 0 && rec.projectId !== callerProject) {
+    fail(
+      EXIT.DAEMON_DOWN,
+      "Noir daemon is not running for this project (a daemon for another project is running).",
+      opts
+    );
+  }
   if (!pidAlive2(rec.pid)) {
     clearDaemonRecord();
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
@@ -572,19 +994,22 @@ async function daemonStatus(opts) {
   const hs = spinner("Probing daemon health...", opts).start();
   let health = null;
   try {
-    const res = await fetch(`http://127.0.0.1:${rec.port}/health`);
+    const res = await fetch(`http://127.0.0.1:${rec.port}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
     if (res.status === 200) {
       health = await res.json();
     }
   } catch {
     health = null;
   }
-  if (health?.ok !== true) {
+  const pidOk = typeof health?.pid === "number" && health.pid === rec.pid;
+  if (health?.ok !== true || !pidOk) {
     hs.fail("Daemon not responding");
     clearDaemonRecord();
     fail(
       EXIT.DAEMON_DOWN,
-      "Noir daemon is not running (port unresponsive; stale record removed).",
+      health !== null && !pidOk ? "Noir daemon is not running (pid missing/mismatched \u2014 a foreign process holds the recorded port; stale record removed)." : "Noir daemon is not running (port unresponsive; stale record removed).",
       opts
     );
   }
@@ -614,19 +1039,1140 @@ async function daemonRestart(opts) {
   await daemonStop({ ...opts, json: false, quiet: true });
   await daemonStart(opts);
 }
-
-// src/commands/handoff.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import {
-  defaultHandoffBlock,
-  hostLaunchDirective,
-  resolveAdapter
-} from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo5, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
+var MODE;
+var init_daemon = __esm({
+  "src/commands/daemon.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    MODE = "foreground";
+  }
+});
+
+// src/commands/doctor.ts
+import { spawnSync } from "child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, join, relative } from "path";
+import { fileURLToPath } from "url";
+import { resolveAdapter } from "@noir-ai/adapters";
+import {
+  detectActiveMethod,
+  latestVersionFromCache,
+  loadProjectInfo as loadProjectInfo3,
+  NOIR_VERSION as NOIR_VERSION2,
+  paths,
+  readInstallRecord,
+  readUpdateCache
+} from "@noir-ai/core";
+import { CURRENT_SCAFFOLD_VERSION, readScaffoldVersion } from "@noir-ai/create";
+import { pidAlive as pidAlive3, readDaemonRecord as readDaemonRecord3 } from "@noir-ai/daemon";
+import { resolveModelConfig } from "@noir-ai/model";
+async function probeOnnx() {
+  try {
+    const spec = "onnxruntime-node";
+    await import(spec);
+    return { ok: true, reason: "loadable" };
+  } catch (e) {
+    return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+  }
+}
+function describeOnnx(o) {
+  if (o.ok) return "loadable";
+  if (/Cannot find (module|package)/i.test(o.reason)) {
+    return "not resolvable from CLI probe (best-effort)";
+  }
+  const r = o.reason.length > 60 ? `${o.reason.slice(0, 59)}\u2026` : o.reason;
+  return `probe failed: ${r}`;
+}
+function fmtUptime(sec) {
+  if (!Number.isFinite(sec) || sec < 0) return "unknown";
+  if (sec < 60) return `${sec}s`;
+  if (sec < 3600) return `${Math.floor(sec / 60)}m ${sec % 60}s`;
+  return `${Math.floor(sec / 3600)}h ${Math.floor(sec % 3600 / 60)}m`;
+}
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function checkRuntime(checks) {
+  checks.push({
+    name: "runtime",
+    status: "ok",
+    detail: `noir ${NOIR_VERSION2} \xB7 node ${process.version} \xB7 ${process.platform}`
+  });
+}
+function checkConfig(root) {
+  const configPath = paths.config(root);
+  if (!existsSync(configPath)) {
+    return {
+      project: void 0,
+      result: {
+        name: "config",
+        status: "warn",
+        detail: `no .noir/config.yml in ${root} \u2014 run \`noir init\``
+      }
+    };
+  }
+  try {
+    const project = loadProjectInfo3(root);
+    return {
+      project,
+      result: {
+        name: "config",
+        status: "ok",
+        detail: `host=${project.config.host} \xB7 mode=${project.config.mode}`
+      }
+    };
+  } catch (e) {
+    return {
+      project: void 0,
+      result: { name: "config", status: "fail", detail: `config parse error: ${msg(e)}` }
+    };
+  }
+}
+async function checkDaemon(checks) {
+  const rec = readDaemonRecord3();
+  if (!rec) {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: "not running (start with `noir daemon start`)"
+    });
+    return;
+  }
+  if (!pidAlive3(rec.pid)) {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `stale record (pid ${rec.pid} not alive)`
+    });
+    return;
+  }
+  try {
+    const res = await fetch(`http://127.0.0.1:${rec.port}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+    const body = res.status === 200 ? await res.json() : null;
+    const pidOk = typeof body?.pid === "number" && body.pid === rec.pid;
+    if (body && body.ok === true && pidOk) {
+      checks.push({
+        name: "daemon",
+        status: "ok",
+        detail: `running (pid ${rec.pid}, port ${rec.port}, up ${fmtUptime(body.uptimeSec ?? 0)})`
+      });
+      return;
+    }
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `record present but /health unreachable on port ${rec.port}`
+    });
+  } catch {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `record present but /health unreachable on port ${rec.port}`
+    });
+  }
+}
+async function checkNativeDeps(checks) {
+  const { vecAvailability } = await import("@noir-ai/store");
+  const vec = vecAvailability();
+  const onnx = await probeOnnx();
+  const vecOk = vec.ok === true;
+  const onnxOk = onnx.ok === true;
+  const status2 = vecOk ? onnxOk ? "ok" : "warn" : "fail";
+  checks.push({
+    name: "native deps",
+    status: status2,
+    detail: `better-sqlite3+sqlite-vec: ${vecOk ? "loadable" : vec.ok === false ? vec.reason : "unknown"} \xB7 onnxruntime-node: ${describeOnnx(onnx)}`
+  });
+  return { vecOk };
+}
+async function checkStore(checks, project, root) {
+  if (!project) {
+    checks.push({ name: "store", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const dbPath = paths.storeDb(root, project.id);
+  if (!existsSync(dbPath)) {
+    checks.push({
+      name: "store",
+      status: "warn",
+      detail: `not created yet \u2014 the store DB is created when the daemon first runs (\`noir daemon start\` or index content); expected at ${dbPath}`
+    });
+    return;
+  }
+  const { openStore: openStore2 } = await import("@noir-ai/store");
+  let store;
+  try {
+    store = await openStore2({ projectId: project.id, root, readonly: true });
+    checks.push({
+      name: "store",
+      status: "ok",
+      detail: `opens readonly (db: ${paths.storeDb(root, project.id)})`
+    });
+  } catch (e) {
+    checks.push({ name: "store", status: "fail", detail: `open failed: ${msg(e)}` });
+  } finally {
+    if (store) {
+      try {
+        await Promise.resolve(store.close());
+      } catch {
+      }
+    }
+  }
+}
+function checkNoirEnv(checks, root) {
+  const path = join(paths.noirDir(root), ".env");
+  let st;
+  try {
+    st = statSync(path);
+  } catch {
+    return;
+  }
+  const mode = st.mode & 511;
+  const tooOpen = (st.mode & 63) !== 0;
+  checks.push(
+    tooOpen ? {
+      name: "noir-env",
+      status: "warn",
+      detail: `${path} is ${mode.toString(8)} \u2014 readable by others; run chmod 600`
+    } : { name: "noir-env", status: "ok", detail: `${path} permissions ok (${mode.toString(8)})` }
+  );
+}
+function checkEmbedder(checks, project, vecOk) {
+  if (!project) {
+    checks.push({ name: "embedder", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const emb = project.config.context.embedder;
+  const kind = emb.kind;
+  const model = typeof emb.model === "string" && emb.model.length > 0 ? emb.model : "<unset>";
+  if (kind === "none") {
+    checks.push({
+      name: "embedder",
+      status: "ok",
+      detail: `kind=none (BM25-only) \xB7 dim=${emb.dim}`
+    });
+    return;
+  }
+  if (!vecOk) {
+    checks.push({
+      name: "embedder",
+      status: "warn",
+      detail: `${kind}/${model} (${emb.dim}-dim) configured but vec native layer unavailable \u2014 search degrades to BM25`
+    });
+    return;
+  }
+  checks.push({
+    name: "embedder",
+    status: "ok",
+    detail: `${kind}/${model} (${emb.dim}-dim) \xB7 vec backend available`
+  });
+}
+function checkProvider(checks, project) {
+  if (!project) {
+    checks.push({ name: "provider", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const resolved = resolveModelConfig(project.config.model);
+  const names = Object.keys(resolved.providers);
+  if (names.length === 0) {
+    checks.push({
+      name: "provider",
+      status: "ok",
+      detail: "none configured (offline mode; drafting degrades to templates)"
+    });
+    return;
+  }
+  const parts = [];
+  let missing = false;
+  for (const name of names) {
+    const p = resolved.providers[name];
+    if (!p) continue;
+    const key = p.hasKey ? "key present" : p.apiKeyEnv ? `missing ${p.apiKeyEnv}` : "anonymous";
+    if (!p.hasKey && p.apiKeyEnv) missing = true;
+    parts.push(`${name}/${p.model ?? "?"} (${key})`);
+  }
+  checks.push({
+    name: "provider",
+    status: missing ? "warn" : "ok",
+    detail: parts.join(" \xB7 ")
+  });
+}
+function buildInstallCheck(opts) {
+  const { method, version, latestKnown } = opts;
+  const parts = [`method=${method}`];
+  if (version) parts.push(`v${version}`);
+  const advisory = [];
+  if (method !== "native") advisory.push("native recommended");
+  if (latestKnown && version && latestKnown !== version) advisory.push("update available");
+  const status2 = advisory.length > 0 ? "warn" : "ok";
+  if (advisory.length > 0) parts.push(advisory.join(" + "));
+  return {
+    name: "install",
+    status: status2,
+    detail: parts.join(" \xB7 "),
+    method,
+    installedVersion: version,
+    latestKnown
+  };
+}
+function checkScaffoldVersion(checks, root) {
+  const onDisk = readScaffoldVersion(root);
+  const current = CURRENT_SCAFFOLD_VERSION;
+  const drift = onDisk !== null && onDisk !== current;
+  const status2 = onDisk === null || drift ? "warn" : "ok";
+  const detail = onDisk === null ? "no .noir/scaffold-version stamp (run `noir init`)" : drift ? `on-disk ${onDisk} \u2260 current ${current} (run \`noir init --upgrade\`)` : `${onDisk} (up to date)`;
+  checks.push({ name: "scaffold version", status: status2, detail });
+  return { onDisk, current, drift };
+}
+function checkRulesMdBudget(checks, root, project) {
+  if (!project) {
+    checks.push({ name: "rules budget", status: "warn", detail: "skipped \u2014 not initialized" });
+    return null;
+  }
+  const rulesPath = paths.rulesMd(root);
+  if (!existsSync(rulesPath)) {
+    checks.push({
+      name: "rules budget",
+      status: "ok",
+      detail: "no .noir/rules/RULES.md"
+    });
+    return null;
+  }
+  let content;
+  try {
+    content = readFileSync(rulesPath, "utf8");
+  } catch (e) {
+    checks.push({
+      name: "rules budget",
+      status: "warn",
+      detail: `RULES.md unreadable: ${msg(e)}`
+    });
+    return null;
+  }
+  const bytes = Buffer.byteLength(content, "utf8");
+  const lineCount = content.length === 0 ? 0 : content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+  const lengthBudgetKb = project.config.rules.lengthBudgetKb;
+  const budgetBytes = lengthBudgetKb * 1024;
+  const maxLines = 150;
+  const overBytes = bytes > budgetBytes;
+  const overLines = lineCount > maxLines;
+  const over = overBytes || overLines;
+  const status2 = over ? "warn" : "ok";
+  const kb = (n) => (n / 1024).toFixed(1);
+  const detail = over ? `OVER: ${kb(bytes)} KB / ${lengthBudgetKb} KB \xB7 ${lineCount}/${maxLines} lines \u2014 trim RULES.md (failure-backed clauses only) or raise rules.lengthBudgetKb` : `${kb(bytes)} KB / ${lengthBudgetKb} KB \xB7 ${lineCount}/${maxLines} lines (within budget)`;
+  checks.push({ name: "rules budget", status: status2, detail });
+  return {
+    onDisk: { bytes, lines: lineCount },
+    budget: { kb: lengthBudgetKb, maxLines },
+    over
+  };
+}
+function summarize(checks) {
+  let ok = 0;
+  let warnN = 0;
+  let fail2 = 0;
+  for (const c2 of checks) {
+    if (c2.status === "ok") ok++;
+    else if (c2.status === "warn") warnN++;
+    else fail2++;
+  }
+  return { ok, warn: warnN, fail: fail2 };
+}
+function checkHostArtifacts(checks, root, project) {
+  if (!project) {
+    checks.push({ name: "host artifacts", status: "warn", detail: "skipped \u2014 not initialized" });
+    return null;
+  }
+  const host = project.config.host;
+  const adapter = resolveAdapter(host);
+  const ectx = { root };
+  const expected = [];
+  const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
+  if (emitsAgentsMd) {
+    expected.push(relOr(adapter.agentsMdPath?.(ectx) ?? "AGENTS.md", root));
+  }
+  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) => !existsSync(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 });
+  return { active: host, expected, missing };
+}
+function checkNestedNoir(checks, root) {
+  const candidates = [
+    ".noir/.noir",
+    ".noir/CLAUDE.md",
+    ".noir/.mcp.json",
+    ".noir/.claude",
+    ".noir/.gitignore",
+    ".noir/.dockerignore",
+    ".noir/.npmignore",
+    ".noir/.prettierignore"
+  ];
+  const found = candidates.filter((rel) => existsSync(join(root, rel)));
+  const detected = found.length > 0;
+  checks.push({
+    name: "nested .noir",
+    status: detected ? "warn" : "ok",
+    detail: detected ? `nested Noir artifacts inside .noir/ (${found.join(", ")}) \u2014 likely from running \`noir init\` inside .noir/. Remove them; the real project is at ${root}.` : "no nested .noir/ artifacts"
+  });
+  return { detected, paths: found };
+}
+function collectDedupCandidates(root) {
+  const rels = ["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"];
+  const out = [];
+  for (const rel of rels) {
+    const abs = join(root, rel);
+    if (!existsSync(abs)) continue;
+    let text;
+    try {
+      text = readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    if (text.trim().length === 0) continue;
+    out.push({ path: rel, text });
+  }
+  return out;
+}
+async function checkSemanticDupDoctor(checks, root, project, opts = {}) {
+  if (!project) {
+    checks.push({ name: "semantic dup", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const candidates = collectDedupCandidates(root);
+  if (candidates.length < 2) {
+    checks.push({
+      name: "semantic dup",
+      status: "ok",
+      detail: `${candidates.length} candidate file(s); nothing to compare`
+    });
+    return;
+  }
+  const ctx = await import("@noir-ai/context");
+  let embed = opts.embed;
+  if (!embed) {
+    const cfg = ctx.resolveEmbedderConfig(project.config.context);
+    if (cfg.kind === "none") {
+      checks.push({
+        name: "semantic dup",
+        status: "warn",
+        detail: "embedder kind=none \u2014 set context.embedder.kind=local to enable semantic dedup"
+      });
+      return;
+    }
+    try {
+      embed = ctx.createEmbedFn(cfg).embed;
+    } catch (e) {
+      checks.push({
+        name: "semantic dup",
+        status: "warn",
+        detail: `embedder unavailable \u2014 skipped (${msg(e)})`
+      });
+      return;
+    }
+  }
+  if (!embed) return;
+  const pairs = await ctx.findSemanticDuplicates(candidates, embed, ctx.DEFAULT_DUP_THRESHOLD);
+  checks.push({
+    name: "semantic dup",
+    status: pairs.length > 0 ? "warn" : "ok",
+    detail: pairs.length === 0 ? `no near-duplicates across ${candidates.length} file(s)` : `${pairs.length} near-duplicate pair${pairs.length === 1 ? "" : "s"}: ${pairs.map((p) => `${p.a}\u2248${p.b} (${p.similarity.toFixed(2)})`).join("; ")}`
+  });
+}
+function resolveWorkspacePackagesDir() {
+  let here = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    const pkgPath = join(here, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@noir-ai/cli") {
+          const packagesDir = dirname(here);
+          if (existsSync(join(dirname(packagesDir), "pnpm-workspace.yaml"))) {
+            return packagesDir;
+          }
+          return null;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(here);
+    if (parent === here) break;
+    here = parent;
+  }
+  return null;
+}
+function npmPackDryRun(cliPkgDir) {
+  const probe = spawnSync("npm", ["--version"], { encoding: "utf8", shell: true });
+  if (probe.status !== 0 || probe.error) {
+    return { error: probe.error ? probe.error.message : "npm not on PATH" };
+  }
+  const res = spawnSync("npm", ["pack", "--dry-run"], {
+    cwd: cliPkgDir,
+    encoding: "utf8",
+    shell: true
+  });
+  if (res.status !== 0 || res.error) {
+    return { error: res.error ? res.error.message : `npm pack exited ${res.status ?? "?"}` };
+  }
+  const out = `${res.stdout ?? ""}
+${res.stderr ?? ""}`;
+  const totalMatch = out.match(/total files:\s*(\d+)/i);
+  const fileCount = totalMatch?.[1] ? Number.parseInt(totalMatch[1], 10) : null;
+  const distIncluded = /\bdist\//.test(out);
+  return { fileCount, distIncluded };
+}
+function checkPublish(checks, packagesDir, opts = {}) {
+  if (packagesDir === null) {
+    checks.push({
+      name: "publish",
+      status: "ok",
+      detail: "skipped \u2014 not a monorepo checkout (no packages/* workspace)"
+    });
+    return null;
+  }
+  let entries = [];
+  try {
+    entries = readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch (e) {
+    checks.push({
+      name: "publish",
+      status: "warn",
+      detail: `could not read ${packagesDir}: ${msg(e)}`
+    });
+    return { checked: 0, issues: [`unreadable packages dir: ${msg(e)}`] };
+  }
+  const issues = [];
+  let checked = 0;
+  let cliDir = null;
+  for (const name of entries) {
+    const pkgPath = join(packagesDir, name, "package.json");
+    if (!existsSync(pkgPath)) continue;
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    } catch (e) {
+      issues.push(`${name}/package.json: unparseable (${msg(e)})`);
+      checked++;
+      continue;
+    }
+    checked++;
+    const pkgName = typeof pkg.name === "string" ? pkg.name : "";
+    if (!pkgName.startsWith("@noir-ai/")) {
+      issues.push(`${name}/package.json: name '${pkgName}' is not @noir-ai/*`);
+    }
+    const version = typeof pkg.version === "string" ? pkg.version : "";
+    if (!SEMVER_ISH.test(version)) {
+      issues.push(`${name}/package.json: version '${version}' is not semver`);
+    }
+    if (!Array.isArray(pkg.files) || pkg.files.length === 0) {
+      issues.push(`${name}/package.json: files missing or empty`);
+    }
+    if (pkgName === "@noir-ai/cli") {
+      if (pkg.bin == null || typeof pkg.bin === "object" && Object.keys(pkg.bin).length === 0) {
+        issues.push(`${name}/package.json: bin missing (cli package must declare a bin)`);
+      }
+      cliDir = join(packagesDir, name);
+    }
+  }
+  let packNote = "";
+  if (cliDir && opts.skipNpmPack !== true) {
+    const pack = npmPackDryRun(cliDir);
+    if ("error" in pack) {
+      packNote = ` \xB7 npm pack skipped (${pack.error})`;
+    } else {
+      const count = pack.fileCount == null ? "?" : String(pack.fileCount);
+      const dist = pack.distIncluded ? "dist/ included" : "dist/ NOT in tarball";
+      packNote = ` \xB7 npm pack: ${count} files, ${dist}`;
+      if (pack.distIncluded === false) {
+        issues.push("cli npm pack --dry-run: dist/ absent from the tarball");
+      }
+    }
+  }
+  const status2 = issues.length > 0 ? "warn" : "ok";
+  const detail = issues.length === 0 ? `${checked}/${entries.length} packages publish-ready${packNote}` : `${issues.length} issue${issues.length === 1 ? "" : "s"} across ${checked} package${checked === 1 ? "" : "s"}${packNote}`;
+  checks.push({ name: "publish", status: status2, detail });
+  return { checked, issues };
+}
+function relOr(abs, root) {
+  const posix = abs.replace(/\\/g, "/");
+  if (posix.startsWith("/")) {
+    const rel = relative(root, abs).replace(/\\/g, "/");
+    if (rel.length === 0 || rel.startsWith("..") || rel.startsWith("/")) {
+      throw new Error(`doctor: host path '${abs}' is not under root '${root}'`);
+    }
+    return rel;
+  }
+  if (posix.split("/").some((seg) => seg === "..")) {
+    throw new Error(`doctor: host path '${abs}' escapes root '${root}'`);
+  }
+  return posix;
+}
+function joinRoot(root, relPath) {
+  return `${root}/${relPath}`;
+}
+function severityBadge(s) {
+  const state = s === "fail" ? "error" : s;
+  return badge(state, s.toUpperCase());
+}
+function renderHuman(payload, opts) {
+  log(
+    `noir doctor \u2014 ${payload.checks.length} check${payload.checks.length === 1 ? "" : "s"}`,
+    opts
+  );
+  table(
+    payload.checks.map((c2) => ({
+      Check: c2.name,
+      Status: severityBadge(c2.status),
+      Detail: c2.detail
+    })),
+    ["Check", "Status", "Detail"],
+    opts
+  );
+  const { ok, warn: warnN, fail: fail2 } = payload.summary;
+  if (fail2 > 0) {
+    error(
+      `${fail2} critical check${fail2 === 1 ? "" : "s"} failed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`,
+      opts
+    );
+  } else if (warnN > 0) {
+    warn(`all critical checks passed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`, opts);
+  } else {
+    success(`all ${ok} check${ok === 1 ? "" : "s"} passed`, opts);
+  }
+}
+async function doctor(opts = {}) {
+  const root = process.cwd();
+  const checks = [];
+  await checkRuntime(checks);
+  const { project, result: configResult } = checkConfig(root);
+  checks.push(configResult);
+  await checkDaemon(checks);
+  const { vecOk } = await checkNativeDeps(checks);
+  await checkStore(checks, project, root);
+  checkEmbedder(checks, project, vecOk);
+  checkProvider(checks, project);
+  checkNoirEnv(checks, root);
+  const scaffold4 = checkScaffoldVersion(checks, root);
+  const rules = checkRulesMdBudget(checks, root, project);
+  const host = checkHostArtifacts(checks, root, project);
+  checkNestedNoir(checks, root);
+  if (opts.dedup === true) {
+    await checkSemanticDupDoctor(checks, root, project);
+  }
+  const publish = checkPublish(checks, resolveWorkspacePackagesDir());
+  const installCheck = buildInstallCheck({
+    method: detectActiveMethod(),
+    version: readInstallRecord()?.version ?? null,
+    latestKnown: latestVersionFromCache(readUpdateCache(), "latest")
+  });
+  checks.push(installCheck);
+  const summary = summarize(checks);
+  const payload = {
+    noir: NOIR_VERSION2,
+    checks,
+    summary,
+    scaffold: scaffold4,
+    rules,
+    host,
+    publish,
+    install: {
+      method: installCheck.method,
+      installedVersion: installCheck.installedVersion,
+      latestKnown: installCheck.latestKnown
+    }
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: payload })}
+`);
+  } else {
+    renderHuman(payload, opts);
+  }
+  if (summary.fail > 0) {
+    throw new NoirCliError(
+      EXIT.ERROR,
+      opts.json === true ? "" : `noir doctor: ${summary.fail} critical check(s) failed`
+    );
+  }
+}
+var SEMVER_ISH;
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_theme();
+    SEMVER_ISH = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+  }
+});
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  buildMigrationPlan: () => buildMigrationPlan,
+  install: () => install,
+  installManagedNode: () => installManagedNode
+});
+import { chmodSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+import {
+  atomicWriteFile,
+  detectActiveMethod as detectActiveMethod2,
+  detectInstallMethods,
+  ensureShimExecutable,
+  loadProjectInfo as loadProjectInfo4,
+  MANAGED_NODE_VERSION,
+  NOIR_VERSION as NOIR_VERSION3,
+  noirHome,
+  provisionManagedNode,
+  readInstallRecord as readInstallRecord2,
+  runManagerCmd,
+  writeInstallRecord
+} from "@noir-ai/core";
+function semverLt(a, b) {
+  const seg = (s) => Number(s.replace(/^v/, "")) || 0;
+  const pa = a.split(".").map(seg);
+  const pb = b.split(".").map(seg);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
+function buildMigrationPlan(opts) {
+  const detected = opts.detected;
+  const shouldMigrate = detected.length > 0 && opts.currentMethod !== "native";
+  const nativeVersion = opts.targetSpec;
+  let isDowngrade = false;
+  if (opts.installedVersion && nativeVersion !== "latest" && nativeVersion !== "beta") {
+    isDowngrade = semverLt(nativeVersion, opts.installedVersion);
+  }
+  const floor = opts.minVersion ?? "1.6.0";
+  const belowMinVersion = nativeVersion !== "latest" && nativeVersion !== "beta" && semverLt(nativeVersion, floor);
+  return {
+    detected,
+    currentMethod: opts.currentMethod,
+    targetSpec: opts.targetSpec,
+    installedVersion: opts.installedVersion,
+    shouldMigrate,
+    isDowngrade,
+    belowMinVersion,
+    nativeVersion,
+    prevUninstallCmd: detected[0]?.uninstallCmd ?? null,
+    autoUninstall: false
+  };
+}
+async function installManagedNode(opts) {
+  const spec = opts.version ?? opts.channel ?? "latest";
+  const home2 = noirHome();
+  const cliDir = join2(home2, "cli");
+  const binDir = join2(home2, "bin");
+  mkdirSync(cliDir, { recursive: true });
+  mkdirSync(binDir, { recursive: true });
+  let runtime;
+  try {
+    runtime = await provisionManagedNode({
+      ...opts.provision ?? {},
+      env: opts.env
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return { ok: false, version: null, error: `managed-Node provision failed: ${reason}` };
+  }
+  if (runtime.source === "system") {
+    warn(
+      `managed-Node download failed; using system Node ${runtime.version} at ${runtime.nodeBin}.`
+    );
+  }
+  const { nodeBin, npmBin } = runtime;
+  const { code, stderr } = await runManagerCmd(
+    [npmBin, "install", "-g", `@noir-ai/cli@${spec}`, `--prefix=${cliDir}`],
+    { env: opts.env, timeoutMs: 12e4 }
+  );
+  if (code !== 0) {
+    return { ok: false, version: null, error: `npm install failed: ${stderr.slice(0, 300)}` };
+  }
+  const shim = join2(binDir, "noir");
+  const shimBody = `#!/usr/bin/env bash
+"${nodeBin}" "${join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js")}" "$@"
+`;
+  atomicWriteFile(shim, shimBody);
+  chmodSync(shim, 493);
+  ensureShimExecutable();
+  const ver = await runManagerCmd(
+    [
+      nodeBin,
+      join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js"),
+      "--version"
+    ],
+    { env: opts.env, timeoutMs: 3e4 }
+  );
+  const version = ver.code === 0 ? ver.stdout.trim() : null;
+  writeInstallRecord({
+    method: "native",
+    version: version ?? "0.0.0",
+    channel: opts.channel ?? "latest",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Reflect which runtime backs this install: the pinned managed version
+    // (e.g. '22.23.2') for managed, or 'system-<v>' for the fallback so doctor
+    // can distinguish a fallback install from a real managed one.
+    managedRuntimeVersion: runtime.source === "managed" ? MANAGED_NODE_VERSION : `system-${runtime.version}`
+  });
+  return { ok: true, version, runtimeSource: runtime.source };
+}
+async function install(opts = {}) {
+  let dismissOutcome;
+  if (opts.dismiss === true) {
+    const rec = readInstallRecord2();
+    if (!rec) {
+      dismissOutcome = { dismissed: false, version: null };
+      if (!opts.json) info("No install record found; nothing to dismiss.");
+    } else {
+      const dismissed = new Set(rec.dismissedVersions ?? []);
+      if (!dismissed.has(NOIR_VERSION3)) dismissed.add(NOIR_VERSION3);
+      writeInstallRecord({ ...rec, dismissedVersions: [...dismissed] });
+      dismissOutcome = { dismissed: true, version: NOIR_VERSION3 };
+      if (!opts.json) success(`Migration banner dismissed for ${NOIR_VERSION3}.`);
+    }
+  }
+  if (opts.dismiss === true && opts.list !== true) {
+    if (opts.json) process.stdout.write(`${JSON.stringify({ ok: true, data: dismissOutcome })}
+`);
+    return;
+  }
+  if (opts.list === true) {
+    const detected2 = await detectInstallMethods(process.env);
+    if (opts.json) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, data: { ...dismissOutcome ?? {}, detected: detected2 } })}
+`
+      );
+      return;
+    }
+    info("Detected installs:");
+    for (const d of detected2) info(`  ${d.method} (${d.version ?? "unknown"})`);
+    return;
+  }
+  const currentMethod = detectActiveMethod2();
+  const detected = await detectInstallMethods(process.env);
+  const installedRecord = readInstallRecord2();
+  let minVersion = "1.6.0";
+  try {
+    minVersion = loadProjectInfo4(process.cwd()).config.update.minVersion;
+  } catch {
+  }
+  const plan = buildMigrationPlan({
+    detected,
+    currentMethod,
+    targetSpec: opts.spec ?? "latest",
+    installedVersion: installedRecord?.version ?? null,
+    minVersion
+  });
+  if (plan.belowMinVersion) {
+    fail(
+      EXIT.USAGE,
+      `refusing install of ${plan.nativeVersion} (below minVersion ${minVersion})`,
+      opts
+    );
+  }
+  if (plan.isDowngrade) {
+    fail(
+      EXIT.USAGE,
+      `refusing downgrade to ${plan.nativeVersion} (installed ${plan.installedVersion})`,
+      opts
+    );
+  }
+  const installSpin = spinner("Installing Noir via native installer...", opts).start();
+  const result = await installManagedNode({
+    channel: plan.nativeVersion === "beta" ? "beta" : void 0,
+    version: plan.nativeVersion.startsWith("v") ? plan.nativeVersion : plan.nativeVersion === "latest" || plan.nativeVersion === "beta" ? void 0 : plan.nativeVersion,
+    env: process.env
+  });
+  if (!result.ok) {
+    installSpin.fail("Native install failed");
+    fail(EXIT.ERROR, result.error ?? "native install failed", opts);
+  }
+  installSpin.succeed(`Installed noir ${result.version}`);
+  if (plan.prevUninstallCmd && opts.uninstallPrev !== true) {
+    warn(`To finish the migration, uninstall the previous install: ${plan.prevUninstallCmd}`);
+    warn(
+      "  Or re-run with --uninstall-prev to do it now. Rollback: reinstall via the previous manager."
+    );
+  } else if (plan.prevUninstallCmd && opts.uninstallPrev === true) {
+    const { code } = await runManagerCmd(plan.prevUninstallCmd.split(" "), { env: process.env });
+    if (code === 0) success("Previous install removed.");
+    else warn("Previous install NOT removed (non-zero exit). You can remove it manually.");
+  }
+  if (opts.json === true) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, data: { version: result.version, runtimeSource: result.runtimeSource } })}
+`
+    );
+    return;
+  }
+  info(`Installed native: ${result.version}.`);
+  info("If `noir` still points at the old install, run: hash -r && which -a noir");
+  success(`noir ${result.version} installed via native. Run \`noir doctor\` to verify.`);
+}
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    "use strict";
+    init_output();
+  }
+});
+
+// src/commands/update.ts
+var update_exports = {};
+__export(update_exports, {
+  DEFAULT_UPDATE_CONFIG: () => DEFAULT_UPDATE_CONFIG,
+  buildUpdateNotice: () => buildUpdateNotice,
+  buildUpdateTarget: () => buildUpdateTarget,
+  runAsyncUpdateCheck: () => runAsyncUpdateCheck,
+  update: () => update,
+  updateAdvice: () => updateAdvice
+});
+import {
+  detectActiveMethod as detectActiveMethod3,
+  ensureShimExecutable as ensureShimExecutable2,
+  fetchLatestVersion,
+  loadProjectInfo as loadProjectInfo5,
+  readInstallRecord as readInstallRecord3,
+  readUpdateCache as readUpdateCache2,
+  runManagerCmd as runManagerCmd2,
+  shouldCheckForUpdate,
+  writeUpdateCache
+} from "@noir-ai/core";
+function buildUpdateTarget(opts) {
+  const targetSpec = opts.spec ?? opts.channel;
+  const concrete = opts.spec != null && opts.spec !== "latest" && opts.spec !== "beta" ? opts.spec : opts.latestKnown;
+  const isUpgrade = concrete != null && opts.currentVersion != null && semverGt(concrete, opts.currentVersion);
+  const floor = opts.minVersion ?? "1.6.0";
+  const belowMinVersion = concrete != null && semverLt2(concrete, floor);
+  return {
+    method: opts.method,
+    targetSpec,
+    currentVersion: opts.currentVersion,
+    latestKnown: opts.latestKnown,
+    isUpgrade,
+    belowMinVersion
+  };
+}
+function semverGt(a, b) {
+  const seg = (s) => Number(s.replace(/^v/, "")) || 0;
+  const pa = a.split(".").map(seg);
+  const pb = b.split(".").map(seg);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+function semverLt2(a, b) {
+  const seg = (s) => Number(s.replace(/^v/, "")) || 0;
+  const pa = a.split(".").map(seg);
+  const pb = b.split(".").map(seg);
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0;
+    const y = pb[i] ?? 0;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
+async function update(opts = {}) {
+  if (process.env.NOIR_DISABLE_UPDATES !== void 0) {
+    fail(
+      EXIT.USAGE,
+      "self-update is disabled (NOIR_DISABLE_UPDATES is set); update via your package manager or image rebuild.",
+      opts
+    );
+    return;
+  }
+  const method = detectActiveMethod3();
+  const rec = readInstallRecord3();
+  const currentVersion = rec?.version ?? null;
+  if (opts.check === true) {
+    const checkSpin = spinner("Checking for updates...", opts).start();
+    const latest2 = await fetchLatestVersion("latest");
+    if (latest2) {
+      checkSpin.succeed(`Latest: ${latest2} (you have ${currentVersion ?? "unknown"})`);
+      if (opts.json === true) {
+        process.stdout.write(`${JSON.stringify({ ok: true, data: { latest: latest2, currentVersion } })}
+`);
+      }
+    } else {
+      checkSpin.fail("Could not reach the registry.");
+      fail(EXIT.ERROR, "Could not reach the registry.", opts);
+    }
+    return;
+  }
+  const fetchSpin = spinner("Checking for updates...", opts).start();
+  const latest = await fetchLatestVersion("latest");
+  if (latest === null) {
+    fetchSpin.fail("Could not reach the registry.");
+    fail(EXIT.ERROR, "Could not reach the registry.", opts);
+  }
+  fetchSpin.succeed(`Latest: ${latest}`);
+  let minVersion = DEFAULT_UPDATE_CONFIG.minVersion;
+  try {
+    minVersion = loadProjectInfo5(process.cwd()).config.update.minVersion;
+  } catch {
+  }
+  const target = buildUpdateTarget({
+    method,
+    channel: "latest",
+    spec: opts.spec,
+    currentVersion,
+    latestKnown: latest,
+    minVersion
+  });
+  if (target.belowMinVersion) {
+    warn(`Target ${target.targetSpec} is below the minVersion floor (${minVersion}).`);
+    fail(
+      EXIT.USAGE,
+      `refusing update to ${target.targetSpec} (below minVersion ${minVersion})`,
+      opts
+    );
+  }
+  if (!target.isUpgrade) {
+    fetchSpin.succeed(`noir ${currentVersion} is up to date`);
+    if (opts.json === true) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, data: { version: currentVersion, upToDate: true } })}
+`
+      );
+      return;
+    }
+    info(`noir ${currentVersion} is up to date.`, opts);
+    return;
+  }
+  if (method === "native") {
+    const updateSpin = spinner(
+      `Updating to ${target.latestKnown} via native installer...`,
+      opts
+    ).start();
+    const res = await installManagedNode({
+      version: target.targetSpec === "latest" ? void 0 : target.targetSpec,
+      env: process.env
+    });
+    if (!res.ok) {
+      updateSpin.fail("Update failed");
+      fail(EXIT.ERROR, res.error ?? "update failed", opts);
+    }
+    ensureShimExecutable2();
+    updateSpin.succeed(`Updated to noir ${res.version}`);
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: { version: res.version } })}
+`);
+      return;
+    }
+    success(`Updated to ${res.version}.`);
+    return;
+  }
+  const cmd = updateCmdFor(method, target.targetSpec);
+  if (!cmd)
+    fail(EXIT.USAGE, `cannot auto-update a ${method} install; use the manager directly`, opts);
+  const mgrSpin = spinner(`Updating via ${method}...`, opts).start();
+  const { code, stderr } = await runManagerCmd2(cmd, { env: process.env });
+  if (code !== 0) {
+    mgrSpin.fail(`Update failed`);
+    fail(EXIT.ERROR, `update failed: ${stderr.slice(0, 300)}`, opts);
+  }
+  mgrSpin.succeed("Updated");
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: { version: target.targetSpec } })}
+`);
+    return;
+  }
+  success("Updated.");
+}
+function updateCmdFor(method, spec) {
+  switch (method) {
+    case "npm":
+      return ["npm", "install", "-g", `@noir-ai/cli@${spec}`];
+    case "pnpm":
+      return ["pnpm", "add", "-g", `@noir-ai/cli@${spec}`];
+    case "yarn":
+      return ["yarn", "global", "add", `@noir-ai/cli@${spec}`];
+    case "bun":
+      return ["bun", "add", "-g", `@noir-ai/cli@${spec}`];
+    case "homebrew":
+      return ["brew", "upgrade", "noir"];
+    case "scoop":
+      return ["scoop", "update", "noir"];
+    default:
+      return null;
+  }
+}
+function updateAdvice(method) {
+  switch (method) {
+    case "npm":
+      return "run `npm install -g @noir-ai/cli@latest`";
+    case "pnpm":
+      return "run `pnpm add -g @noir-ai/cli@latest`";
+    case "yarn":
+      return "run `yarn global add @noir-ai/cli@latest`";
+    case "bun":
+      return "run `bun add -g @noir-ai/cli@latest`";
+    case "homebrew":
+      return "run `brew upgrade noir`";
+    case "scoop":
+      return "run `scoop update noir`";
+    case "native":
+      return "run `noir update`";
+    default:
+      return "run `noir update`";
+  }
+}
+function buildUpdateNotice(opts) {
+  const { method, currentVersion, latestKnown } = opts;
+  if (currentVersion == null || latestKnown == null) return null;
+  if (!semverGt(latestKnown, currentVersion)) return null;
+  return { latestVersion: latestKnown, currentVersion, method, advice: updateAdvice(method) };
+}
+async function runAsyncUpdateCheck(opts) {
+  try {
+    const cache = readUpdateCache2();
+    if (!shouldCheckForUpdate({ env: opts.env, configUpdate: opts.configUpdate, cache })) return;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    const latest = await fetchLatestVersion(opts.configUpdate.channel, controller.signal);
+    clearTimeout(timer);
+    if (latest != null) {
+      writeUpdateCache({
+        lastCheckAt: (/* @__PURE__ */ new Date()).toISOString(),
+        latestVersion: latest,
+        channel: opts.configUpdate.channel
+      });
+    }
+  } catch {
+  }
+}
+var DEFAULT_UPDATE_CONFIG;
+var init_update = __esm({
+  "src/commands/update.ts"() {
+    "use strict";
+    init_output();
+    init_install();
+    DEFAULT_UPDATE_CONFIG = {
+      checkEnabled: true,
+      checkIntervalHours: 24,
+      channel: "latest",
+      minVersion: "1.6.0",
+      display: "notice"
+    };
+  }
+});
 
 // src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo3, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo6, NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
 async function tryTool(caller, name, args) {
   try {
     return await caller.callTool(name, args);
@@ -677,7 +2223,7 @@ function pickMemory(m) {
 }
 function buildPayload(project, probe, host, store, context, workflow, memory) {
   return {
-    noir: NOIR_VERSION2,
+    noir: NOIR_VERSION4,
     project: { id: project.id, name: project.name },
     host: project.config.host,
     daemon: {
@@ -725,7 +2271,7 @@ function describeMemory(m) {
   if (!m) return "unavailable (memory engine not wired)";
   return `${m.observations} observations across ${m.sessions} session${m.sessions === 1 ? "" : "s"}`;
 }
-function renderHuman(p, opts) {
+function renderHuman2(p, opts) {
   log(`noir status \u2014 ${p.project.name} (${p.project.id})`, opts);
   definitionList(
     [
@@ -745,7 +2291,12 @@ function renderHuman(p, opts) {
   }
 }
 async function gatherStatusPayload(opts) {
-  const project = loadProjectInfo3(process.cwd());
+  let project;
+  try {
+    project = loadProjectInfo6(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
   const probe = await probeDaemon(opts);
   let host = null;
   let store = null;
@@ -772,7 +2323,7 @@ async function status(opts) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo3(process.cwd());
+        const info2 = loadProjectInfo6(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -786,37 +2337,35 @@ async function status(opts) {
 `);
     return;
   }
-  renderHuman(payload, opts);
+  renderHuman2(payload, opts);
 }
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_theme();
+    init_update();
+  }
+});
 
 // src/commands/task.ts
-import { spawnSync } from "child_process";
-import { createHash } from "crypto";
-import { loadProjectInfo as loadProjectInfo4, nextArtifactSequence } from "@noir-ai/core";
+import { spawnSync as spawnSync2 } from "child_process";
+import { writeFileSync } from "fs";
+import { loadProjectInfo as loadProjectInfo7, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
 import {
   PHASES,
   TASK_CLASSES,
   writeChangelogStub,
   writeDecisionStub
 } from "@noir-ai/workflow";
-var PHASE_SKILL = {
-  // C3 curation (2026-08-10): intake+clarify merged into brainstorming;
-  // execute → executing-plans; verify → verifying; document → wrap.
-  intake: "noir-brainstorming",
-  clarify: "noir-brainstorming",
-  spec: "noir-spec",
-  plan: "noir-planning",
-  execute: "noir-executing-plans",
-  verify: "noir-verifying",
-  document: "noir-wrap"
-};
 function skillFor(phase) {
   if (typeof phase !== "string") return null;
   return PHASE_SKILL[phase] ?? null;
 }
 function writeDoneArtifacts(opts, taskId) {
   try {
-    const project = loadProjectInfo4(process.cwd());
+    const project = loadProjectInfo7(process.cwd());
     const conflict = { conflictPolicy: "preserve", interactive: false };
     writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
     const nextN = nextArtifactSequence(project.root, "adr");
@@ -861,8 +2410,8 @@ function renderStatusRow(s, opts) {
   );
   definitionList(rows, opts);
 }
-var GATE_PHASES = ["spec", "plan", "verify"];
 function nextGateAfter(phase) {
+  if (phase === "verify") return "verify";
   const cur = PHASES.indexOf(phase);
   for (const p of GATE_PHASES) {
     if (PHASES.indexOf(p) > cur) return p;
@@ -995,6 +2544,9 @@ async function taskAdvance(opts) {
   if (typeof opts.force === "string" && opts.force.length > 0) {
     args.force = { reason: opts.force };
   }
+  if (opts.skip === true) {
+    args.skip = true;
+  }
   const res = await callDaemonTool(
     opts,
     "workflow_advance",
@@ -1048,11 +2600,6 @@ async function taskResume(opts) {
   const res = await callDaemonTool(opts, "workflow_resume", args);
   if (res.resumable !== true) {
     const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "nothing to resume";
-    if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: false, resumable: false, error: detail })}
-`);
-      return;
-    }
     fail(EXIT.ERROR, `task resume: ${detail}`, opts);
   }
   if (typeof opts.prompt === "string" && opts.prompt.length > 0) {
@@ -1122,7 +2669,7 @@ async function taskAbandon(opts) {
 }
 function runCheck(cmd) {
   try {
-    const buf = spawnSync("sh", ["-c", cmd], {
+    const buf = spawnSync2("sh", ["-c", cmd], {
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf8"
     });
@@ -1132,14 +2679,19 @@ function runCheck(cmd) {
     const status2 = buf.status;
     return {
       exitCode: typeof status2 === "number" ? status2 : 1,
-      digest: createHash("sha256").update(out).digest("hex")
+      digest: sha256Hex(out)
     };
   } catch {
-    return { exitCode: 1, digest: createHash("sha256").update("").digest("hex") };
+    return { exitCode: 1, digest: sha256Hex("") };
   }
 }
 async function taskVerify(opts) {
-  const project = loadProjectInfo4(process.cwd());
+  let project;
+  try {
+    project = loadProjectInfo7(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
   const cfgChecks = project.config.workflow?.gate?.verify?.checks ?? [];
   const all = cfgChecks.map((c2) => ({
     name: c2.name,
@@ -1161,7 +2713,7 @@ async function taskVerify(opts) {
   if (checks.length === 0) {
     fail(
       EXIT.USAGE,
-      "task verify: no verify checks configured (set workflow.gate.verify.checks in noir.config)",
+      "task verify: no verify checks configured (set workflow.gate.verify.checks in .noir/config.yml)",
       opts
     );
   }
@@ -1186,17 +2738,40 @@ async function taskVerify(opts) {
   const res = await callDaemonTool(opts, "workflow_advance", { evidence });
   if (res.ok === true) {
     if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: true, data: res, evidence })}
+      process.stdout.write(`${JSON.stringify({ ok: true, data: { ...res, evidence } })}
 `);
       return;
     }
-    success(`verify \u2014 ${evidence.summary} \u2192 gate approved`, opts);
+    const landed = res.state;
+    if (landed === "done") {
+      success(`verify \u2014 ${evidence.summary} \u2192 gate approved`, opts);
+    } else {
+      info(
+        `verify \u2014 ${evidence.summary} \u2192 advanced to ${landed} (the verify gate fires at \`done\`; run \`noir task verify\` again when there)`,
+        opts
+      );
+    }
     renderStatusRow(res, opts);
     return;
   }
+  const detail = res.error ?? res.pendingGate?.reason ?? "verify failed";
   if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ evidence, ...res })}
-`);
+    process.stdout.write(
+      `${JSON.stringify({
+        ok: false,
+        error: { code: EXIT.ERROR, message: `task verify: ${detail}` },
+        // S9 `{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: {
+          ...res.pendingGate !== void 0 ? { pendingGate: res.pendingGate } : {},
+          ...res.recovery !== void 0 ? { recovery: res.recovery } : {},
+          evidence
+        }
+      })}
+`
+    );
+    process.exitCode = EXIT.ERROR;
     return;
   }
   if (res.pendingGate) {
@@ -1208,9 +2783,8 @@ async function taskVerify(opts) {
       ).join(" | ")}`,
       opts
     );
-  } else {
-    fail(EXIT.ERROR, `task verify: ${res.error ?? "verify failed"}`, opts);
   }
+  fail(EXIT.ERROR, `task verify: ${detail}`, opts);
 }
 async function taskResearch(opts) {
   const s = await fetchStatus(opts, opts.id);
@@ -1254,7 +2828,7 @@ async function taskDecompose(opts) {
   if (cap.length === 0) fail(EXIT.USAGE, "task decompose: <capability-id> is required", opts);
   const plan = {
     capabilityId: cap,
-    intent: `Capability ${cap} \u2014 details TBD (run with a provider for an LLM-drafted plan)`,
+    intent: `Capability ${cap} \u2014 offline template (run with a provider for an LLM-drafted plan)`,
     slices: [
       {
         id: "s1-walking-skeleton",
@@ -1272,6 +2846,19 @@ async function taskDecompose(opts) {
     ],
     status: { "s1-walking-skeleton": "planned" }
   };
+  if (typeof opts.out === "string" && opts.out.length > 0) {
+    try {
+      writeFileSync(opts.out, `${JSON.stringify(plan, null, 2)}
+`, "utf8");
+    } catch (err) {
+      fail(
+        EXIT.ERROR,
+        `task decompose: could not write ${opts.out}: ${err instanceof Error ? err.message : String(err)}`,
+        opts
+      );
+    }
+    if (opts.json !== true) info(`wrote plan to ${opts.out}`, opts);
+  }
   if (opts.json === true) {
     process.stdout.write(`${JSON.stringify({ ok: true, data: plan })}
 `);
@@ -1283,9 +2870,37 @@ async function taskDecompose(opts) {
   }
   tip("each piece enters the existing clarify\u2192spec\u2192plan\u2192execute\u2192verify\u2192document workflow", opts);
 }
+var PHASE_SKILL, GATE_PHASES;
+var init_task = __esm({
+  "src/commands/task.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_theme();
+    PHASE_SKILL = {
+      // C3 curation (2026-08-10): intake+clarify merged into brainstorming;
+      // execute → executing-plans; verify → verifying; document → wrap.
+      intake: "noir-brainstorming",
+      clarify: "noir-brainstorming",
+      spec: "noir-spec",
+      plan: "noir-planning",
+      execute: "noir-executing-plans",
+      verify: "noir-verifying",
+      document: "noir-wrap"
+    };
+    GATE_PHASES = ["spec", "plan", "verify"];
+  }
+});
 
 // src/commands/handoff.ts
-var SEED_LIMIT = 5;
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+import {
+  defaultHandoffBlock,
+  hostLaunchDirective,
+  resolveAdapter as resolveAdapter2
+} from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo8, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
 function heading(name, id) {
   return `# Noir handoff \u2014 ${name} (${id})`;
 }
@@ -1381,7 +2996,7 @@ function toHostPayload(p) {
 }
 function resolveDirective(root, p) {
   const ctx = { root };
-  const adapter = resolveAdapter(p.host);
+  const adapter = resolveAdapter2(p.host);
   const hostPayload = toHostPayload(p);
   if (typeof adapter.emitHandoff === "function") {
     return adapter.emitHandoff(ctx, hostPayload);
@@ -1422,7 +3037,12 @@ async function probeOnly(opts) {
   return probeDaemon(opts);
 }
 async function handoff(opts) {
-  const project = loadProjectInfo5(process.cwd());
+  let project;
+  try {
+    project = loadProjectInfo8(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
   const host = project.config.host;
   const snapshot = await gatherStatusPayload(opts);
   const probe = await probeOnly(opts);
@@ -1448,45 +3068,34 @@ async function handoff(opts) {
     }
   };
   full.directive = resolveDirective(project.root, full);
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: full })}
-`);
-    return;
-  }
-  const md = renderMarkdown(full);
   if (opts.write === true) {
+    const md = renderMarkdown(full);
     const path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync(join(project.root, NOIR_DIR, "handoff"), { recursive: true });
-    writeFileSync(path, md, "utf8");
+    mkdirSync2(join3(project.root, NOIR_DIR, "handoff"), { recursive: true });
+    writeFileSync2(path, md, "utf8");
     info(`handoff written to ${path}`, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: full })}
+`);
     return;
   }
-  process.stdout.write(md);
+  if (opts.write !== true) process.stdout.write(renderMarkdown(full));
 }
-
-// src/commands/home.ts
-import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
-import {
-  detectActiveMethod,
-  latestVersionFromCache,
-  loadProjectInfo as loadProjectInfo6,
-  NOIR_VERSION as NOIR_VERSION3,
-  readInstallRecord,
-  readUpdateCache
-} from "@noir-ai/core";
+var SEED_LIMIT;
+var init_handoff = __esm({
+  "src/commands/handoff.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_status();
+    init_task();
+    SEED_LIMIT = 5;
+  }
+});
 
 // src/banner.ts
 import gradient from "gradient-string";
-var NOIR_BLOCK = [
-  "\u2588\u2588\u2588\u2557   \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
-  "\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
-  "\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
-  "\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551",
-  "\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2551",
-  "\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D"
-];
-var NOIR_GRADIENT = gradient("#2c5282", "#3b82f6", "#7dd3fc");
-var NOIR_TAGLINE = "discipline, context, and memory layer for agentic CLIs";
 function renderBanner(opts = {}) {
   const width = opts.width ?? process.stdout.columns ?? 80;
   const colorOn = opts.color !== false && useColor();
@@ -1506,26 +3115,25 @@ function shouldShowBanner(opts) {
   if (v !== void 0 && v !== "") return false;
   return true;
 }
+var NOIR_BLOCK, NOIR_GRADIENT, NOIR_TAGLINE;
+var init_banner = __esm({
+  "src/banner.ts"() {
+    "use strict";
+    init_theme();
+    NOIR_BLOCK = [
+      "\u2588\u2588\u2588\u2557   \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+      "\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+      "\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+      "\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551",
+      "\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2551",
+      "\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D"
+    ];
+    NOIR_GRADIENT = gradient("#2c5282", "#3b82f6", "#7dd3fc");
+    NOIR_TAGLINE = "discipline, context, and memory layer for agentic CLIs";
+  }
+});
 
 // src/tui/commands/registry.ts
-var DESTRUCTIVE_PREFIXES = [
-  ["context", "index"],
-  ["memory", "save"],
-  ["memory", "forget"],
-  ["memory", "consolidate"],
-  ["task", "new"],
-  ["task", "advance"],
-  ["skills", "sync"],
-  ["daemon", "start"],
-  ["daemon", "stop"],
-  ["daemon", "restart"],
-  ["init"],
-  ["create"],
-  ["sync"],
-  ["install"],
-  ["update"],
-  ["run"]
-];
 function isDestructive(argv) {
   return DESTRUCTIVE_PREFIXES.some((prefix) => {
     if (argv.length < prefix.length) return false;
@@ -1566,180 +3174,32 @@ function buildPaletteCommands(program2) {
   collectLeaves(program2, [], out);
   return out;
 }
+var DESTRUCTIVE_PREFIXES;
+var init_registry = __esm({
+  "src/tui/commands/registry.ts"() {
+    "use strict";
+    DESTRUCTIVE_PREFIXES = [
+      ["context", "index"],
+      ["memory", "save"],
+      ["memory", "forget"],
+      ["memory", "consolidate"],
+      ["task", "new"],
+      ["task", "advance"],
+      ["skills", "sync"],
+      ["daemon", "start"],
+      ["daemon", "stop"],
+      ["daemon", "restart"],
+      ["init"],
+      ["create"],
+      ["sync"],
+      ["install"],
+      ["update"],
+      ["run"]
+    ];
+  }
+});
 
 // src/tui/commands/sections.ts
-var HOME_SECTIONS = [
-  {
-    id: "status",
-    label: "Status & context",
-    hint: "snapshot \xB7 index \xB7 search \xB7 doctor",
-    items: [
-      {
-        id: "status",
-        label: "Status",
-        hint: "project + daemon + workflow + store snapshot (noir status)"
-      },
-      {
-        id: "context index",
-        label: "Index project",
-        hint: "(re)index files into context \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "context search",
-        label: "Search context",
-        hint: "hybrid search over indexed files",
-        needsArg: { prompt: "Context search query:", placeholder: "e.g. auth flow, deploy steps" }
-      },
-      {
-        id: "doctor",
-        label: "Doctor",
-        hint: "environment + project health checks"
-      },
-      {
-        id: "context status",
-        label: "Context status",
-        hint: "index freshness + counts"
-      }
-    ]
-  },
-  {
-    id: "memory",
-    label: "Memory",
-    hint: "recall \xB7 save \xB7 sessions \xB7 forget \xB7 consolidate",
-    items: [
-      {
-        id: "memory recall",
-        label: "Recall memory",
-        hint: "search cross-session memory",
-        needsArg: { prompt: "Recall query:", placeholder: "e.g. auth flow, deploy steps" }
-      },
-      {
-        id: "memory save",
-        label: "Save memory",
-        hint: "save an observation \xB7 \u26A0 destructive",
-        destructive: true,
-        needsArg: { prompt: "Memory content:", placeholder: "what you want to remember" }
-      },
-      {
-        id: "memory sessions",
-        label: "Sessions",
-        hint: "list recent memory sessions"
-      },
-      {
-        id: "memory forget",
-        label: "Forget memory",
-        hint: "forget observations by id \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "memory consolidate",
-        label: "Consolidate",
-        hint: "fold observations into lessons \xB7 \u26A0 destructive",
-        destructive: true
-      }
-    ]
-  },
-  {
-    id: "workflow",
-    label: "Workflow",
-    hint: "next \xB7 status \xB7 advance \xB7 handoff \xB7 wrap",
-    items: [
-      {
-        id: "task next",
-        label: "Next task",
-        hint: "suggest next phase + applicable skill"
-      },
-      {
-        id: "task status",
-        label: "Task status",
-        hint: "active task status"
-      },
-      {
-        id: "task advance",
-        label: "Advance task",
-        hint: "advance to next phase \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "handoff",
-        label: "Handoff",
-        hint: "ready-to-paste host prompt"
-      },
-      {
-        id: "wrap",
-        label: "Wrap (end session)",
-        hint: "session-end handoff",
-        dispatch: ["wrap", "--write"]
-      }
-    ]
-  },
-  {
-    id: "setup",
-    label: "Setup & maintenance",
-    hint: "init \xB7 create \xB7 sync \xB7 skills \xB7 install \xB7 update",
-    items: [
-      {
-        id: "init",
-        label: "Init",
-        hint: "scaffold Noir in this project \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "create",
-        label: "Create",
-        hint: "bootstrap in a new/empty dir \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "sync",
-        label: "Sync",
-        hint: "re-emit managed files + skills \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "skills list",
-        label: "Skills list",
-        hint: "list installed skills"
-      },
-      {
-        id: "skills sync",
-        label: "Sync skills",
-        hint: "re-emit builtin skills \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "update",
-        label: "Update",
-        hint: "check for a new version \xB7 \u26A0 destructive",
-        destructive: true
-      },
-      {
-        id: "install",
-        label: "Install / migrate",
-        hint: "native install / migrate \xB7 \u26A0 destructive",
-        destructive: true
-      }
-    ]
-  },
-  {
-    id: "dashboard",
-    label: "Dashboard (full-screen)",
-    hint: "noir tui \xB7 noir palette \xB7 home",
-    items: [
-      {
-        id: "tui",
-        label: "Dashboard (full-screen)",
-        hint: "live status \xB7 /command \xB7 Ctrl+K palette (noir tui)"
-      },
-      {
-        id: "palette",
-        label: "All commands (fuzzy palette)",
-        hint: "fuzzy search over every command (noir palette)"
-      }
-    ]
-  }
-];
 async function resolveSections(commands) {
   const byId = new Map(commands.map((c2) => [c2.id, c2]));
   const out = [];
@@ -1759,11 +3219,198 @@ async function resolveSections(commands) {
   }
   return out;
 }
+var HOME_SECTIONS;
+var init_sections = __esm({
+  "src/tui/commands/sections.ts"() {
+    "use strict";
+    HOME_SECTIONS = [
+      {
+        id: "status",
+        label: "Status & context",
+        hint: "snapshot \xB7 index \xB7 search \xB7 doctor",
+        items: [
+          {
+            id: "status",
+            label: "Status",
+            hint: "project + daemon + workflow + store snapshot (noir status)"
+          },
+          {
+            id: "context index",
+            label: "Index project",
+            hint: "(re)index files into context \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "context search",
+            label: "Search context",
+            hint: "hybrid search over indexed files",
+            needsArg: { prompt: "Context search query:", placeholder: "e.g. auth flow, deploy steps" }
+          },
+          {
+            id: "doctor",
+            label: "Doctor",
+            hint: "environment + project health checks"
+          },
+          {
+            id: "context status",
+            label: "Context status",
+            hint: "index freshness + counts"
+          }
+        ]
+      },
+      {
+        id: "memory",
+        label: "Memory",
+        hint: "recall \xB7 save \xB7 sessions \xB7 forget \xB7 consolidate",
+        items: [
+          {
+            id: "memory recall",
+            label: "Recall memory",
+            hint: "search cross-session memory",
+            needsArg: { prompt: "Recall query:", placeholder: "e.g. auth flow, deploy steps" }
+          },
+          {
+            id: "memory save",
+            label: "Save memory",
+            hint: "save an observation \xB7 \u26A0 destructive",
+            destructive: true,
+            needsArg: { prompt: "Memory content:", placeholder: "what you want to remember" }
+          },
+          {
+            id: "memory sessions",
+            label: "Sessions",
+            hint: "list recent memory sessions"
+          },
+          {
+            id: "memory forget",
+            label: "Forget memory",
+            hint: "forget observations by id \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "memory consolidate",
+            label: "Consolidate",
+            hint: "fold observations into lessons \xB7 \u26A0 destructive",
+            destructive: true
+          }
+        ]
+      },
+      {
+        id: "workflow",
+        label: "Workflow",
+        hint: "next \xB7 status \xB7 advance \xB7 handoff \xB7 wrap",
+        items: [
+          {
+            id: "task next",
+            label: "Next task",
+            hint: "suggest next phase + applicable skill"
+          },
+          {
+            id: "task status",
+            label: "Task status",
+            hint: "active task status"
+          },
+          {
+            id: "task advance",
+            label: "Advance task",
+            hint: "advance to next phase \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "handoff",
+            label: "Handoff",
+            hint: "ready-to-paste host prompt"
+          },
+          {
+            id: "wrap",
+            label: "Wrap (end session)",
+            hint: "session-end handoff",
+            dispatch: ["wrap", "--write"]
+          }
+        ]
+      },
+      {
+        id: "setup",
+        label: "Setup & maintenance",
+        hint: "init \xB7 create \xB7 sync \xB7 skills \xB7 install \xB7 update",
+        items: [
+          {
+            id: "init",
+            label: "Init",
+            hint: "scaffold Noir in this project \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "create",
+            label: "Create",
+            hint: "bootstrap in a new/empty dir \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "sync",
+            label: "Sync",
+            hint: "re-emit managed files + skills \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "skills list",
+            label: "Skills list",
+            hint: "list installed skills"
+          },
+          {
+            id: "skills sync",
+            label: "Sync skills",
+            hint: "re-emit builtin skills \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "update",
+            label: "Update",
+            hint: "check for a new version \xB7 \u26A0 destructive",
+            destructive: true
+          },
+          {
+            id: "install",
+            label: "Install / migrate",
+            hint: "native install / migrate \xB7 \u26A0 destructive",
+            destructive: true
+          }
+        ]
+      },
+      {
+        id: "dashboard",
+        label: "Dashboard (full-screen)",
+        hint: "noir tui \xB7 noir palette \xB7 home",
+        items: [
+          {
+            id: "tui",
+            label: "Dashboard (full-screen)",
+            hint: "live status \xB7 /command \xB7 Ctrl+K palette (noir tui)"
+          },
+          {
+            id: "palette",
+            label: "All commands (fuzzy palette)",
+            hint: "fuzzy search over every command (noir palette)"
+          }
+        ]
+      }
+    ];
+  }
+});
 
 // src/commands/home.ts
+import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
+import {
+  detectActiveMethod as detectActiveMethod4,
+  latestVersionFromCache as latestVersionFromCache2,
+  loadProjectInfo as loadProjectInfo9,
+  NOIR_VERSION as NOIR_VERSION5,
+  readInstallRecord as readInstallRecord4,
+  readUpdateCache as readUpdateCache3
+} from "@noir-ai/core";
 function tryProject() {
   try {
-    const info2 = loadProjectInfo6(process.cwd());
+    const info2 = loadProjectInfo9(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -1774,7 +3421,6 @@ function shouldShowMigrationBanner(rec, currentVersion) {
   if (rec.dismissedVersions?.includes(currentVersion)) return false;
   return true;
 }
-var COMMANDS_HINT = "Commands: status \xB7 context \xB7 memory \xB7 task \xB7 skills \xB7 daemon \xB7 doctor \xB7 install \xB7 update \xB7 tui \xB7 palette";
 async function home(opts, deps) {
   if (isInteractive(opts) && opts.tui !== false) {
     await runMenu(opts, deps);
@@ -1927,7 +3573,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo6(process.cwd());
+        const info2 = loadProjectInfo9(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -1948,8 +3594,8 @@ ${COMMANDS_HINT}
 `
     );
   }
-  const rec = readInstallRecord();
-  if (rec && shouldShowMigrationBanner(rec, NOIR_VERSION3)) {
+  const rec = readInstallRecord4();
+  if (rec && shouldShowMigrationBanner(rec, NOIR_VERSION5)) {
     process.stderr.write(
       `
   ${c.warn(`noir installed via ${rec.method}`)} \u2014 consider \`noir install\` for the native path (auto-update, no npm prefix/PATH issues). Dismiss with: \`noir install --dismiss\` (persisted per version).
@@ -1958,9 +3604,9 @@ ${COMMANDS_HINT}
     );
   }
   const updateNotice = buildUpdateNotice({
-    method: detectActiveMethod(),
-    currentVersion: NOIR_VERSION3,
-    latestKnown: latestVersionFromCache(readUpdateCache(), "latest")
+    method: detectActiveMethod4(),
+    currentVersion: NOIR_VERSION5,
+    latestKnown: latestVersionFromCache2(readUpdateCache3(), "latest")
   });
   if (updateNotice) {
     process.stderr.write(
@@ -1974,6 +3620,19 @@ ${COMMANDS_HINT}
   const sections = await resolveSections(deps.commands ?? []);
   await runGroupedMenu(clack, opts, deps, sections);
 }
+var COMMANDS_HINT;
+var init_home = __esm({
+  "src/commands/home.ts"() {
+    "use strict";
+    init_banner();
+    init_output();
+    init_theme();
+    init_registry();
+    init_sections();
+    init_update();
+    COMMANDS_HINT = "Commands: status \xB7 context \xB7 memory \xB7 task \xB7 skills \xB7 daemon \xB7 doctor \xB7 install \xB7 update \xB7 tui \xB7 palette";
+  }
+});
 
 // src/commands/memory.ts
 function parseLimit2(raw, label, opts) {
@@ -2022,16 +3681,16 @@ async function memoryRecall(opts) {
   }
   if (!probe.running) {
     await withInProcessRead(opts, async (engines) => {
-      const result = await engines.memory.recall(opts.query, {
+      const { hits: hits2, degraded, mode } = await engines.memory.recallWithMeta(opts.query, {
         ...limit === void 0 ? {} : { limit }
       });
-      const data2 = { query: opts.query, hits: result, degraded: false };
+      const data2 = { query: opts.query, hits: hits2, degraded, mode };
       if (opts.json === true) {
         process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
 `);
         return;
       }
-      renderRecall(data2.query, result, data2.degraded, opts);
+      renderRecall(data2.query, data2.hits, data2.degraded, opts);
     });
     return;
   }
@@ -2235,9 +3894,17 @@ async function memoryConsolidate(opts) {
   const suffix = logged ? " (logged)" : "";
   fail(EXIT.ERROR, `memory consolidate did not run: ${reason}${suffix}`, opts);
 }
+var init_memory = __esm({
+  "src/commands/memory.ts"() {
+    "use strict";
+    init_daemon_client();
+    init_output();
+    init_theme();
+  }
+});
 
 // src/commands/release.ts
-import { execSync, spawnSync as spawnSync2 } from "child_process";
+import { execSync, spawnSync as spawnSync3 } from "child_process";
 function describe(step, who) {
   const m = {
     preflight: "check clean tree, on develop, HEAD pushed, gate green, no version collision",
@@ -2256,21 +3923,6 @@ function describe(step, who) {
   };
   return `${m[step]} [${who}]`;
 }
-var ALL = [
-  "preflight",
-  "bump",
-  "gate",
-  "commit",
-  "ci-develop",
-  "beta-tag",
-  "human-approve-beta",
-  "merge-main",
-  "ci-main",
-  "stable-tag",
-  "human-approve-stable",
-  "dist-bump",
-  "sync"
-];
 async function release(opts) {
   if (opts.dryRun) {
     log("noir release --dry-run (no changes will be made)", opts);
@@ -2296,7 +3948,7 @@ async function release(opts) {
     if (status2) fail(EXIT.ERROR, "release: tree must be clean", opts);
     success("preflight: \u2713 clean, on develop", opts);
     info(`[2/13] bump: ${describe("bump", "noir")}`, opts);
-    spawnSync2("node", ["scripts/bump-version.mjs", version], {
+    spawnSync3("node", ["scripts/bump-version.mjs", version], {
       encoding: "utf8",
       stdio: "inherit"
     });
@@ -2308,8 +3960,8 @@ async function release(opts) {
     });
     success("gate: \u2713 full gate green", opts);
     info(`[4/13] commit/push: ${describe("commit", "noir")}`, opts);
-    spawnSync2("git", ["add", "-A"], { encoding: "utf8", stdio: "inherit" });
-    spawnSync2("git", ["commit", "-m", `chore(release): v${version} + docs sync`], {
+    spawnSync3("git", ["add", "-A"], { encoding: "utf8", stdio: "inherit" });
+    spawnSync3("git", ["commit", "-m", `chore(release): v${version} + docs sync`], {
       encoding: "utf8",
       stdio: "inherit"
     });
@@ -2331,30 +3983,163 @@ async function release(opts) {
     fail(EXIT.ERROR, `release failed: ${err instanceof Error ? err.message : String(err)}`, opts);
   }
 }
+var ALL;
+var init_release = __esm({
+  "src/commands/release.ts"() {
+    "use strict";
+    init_output();
+    ALL = [
+      "preflight",
+      "bump",
+      "gate",
+      "commit",
+      "ci-develop",
+      "beta-tag",
+      "human-approve-beta",
+      "merge-main",
+      "ci-main",
+      "stable-tag",
+      "human-approve-stable",
+      "dist-bump",
+      "sync"
+    ];
+  }
+});
 
-// src/commands/run.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
-import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
+// src/shell-bridge.ts
+import { spawn } from "child_process";
+import { basename } from "path";
+function isEligibleForShellFallback(name, opts = {}) {
+  const { env = process.env, platform = process.platform } = opts;
+  if (platform === "win32") return false;
+  if (name.length === 0 || name.includes("/") || !NAME_RE.test(name)) return false;
+  const shell = env.SHELL;
+  if (!shell || shell.length === 0) return false;
+  return SUPPORTED_SHELLS.has(basename(shell).toLowerCase());
+}
+function parseProbeOutput(stdout) {
+  let path = "";
+  let kind = "";
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("N:")) path = line.slice(2).trim();
+    else if (line.startsWith("K:")) kind = line.slice(2).trim();
+  }
+  return { path, kind };
+}
+function classifyResolution(path, kind) {
+  if (path.trim().startsWith("/")) return "path";
+  const k = kind.trim().toLowerCase();
+  if (k.includes("alias")) return "alias";
+  if (k.includes("function")) return "function";
+  return "none";
+}
+function shellKind(shell) {
+  const kind = basename(shell).toLowerCase();
+  return SUPPORTED_SHELLS.has(kind) ? kind : null;
+}
+function probeCommand(name, shell, opts) {
+  const kind = shellKind(shell);
+  const timeoutMs = opts.timeoutMs ?? PROBE_TIMEOUT_MS2;
+  return new Promise((resolve2) => {
+    const script = kind ? PROBE_SCRIPTS[kind] : "";
+    const flags = kind ? PROBE_FLAGS[kind] : "-lic";
+    const probeArgs = kind === "fish" ? [name] : ["noirbridge", name];
+    const child = spawn(shell, [flags, script, ...probeArgs], {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      // new process group so the timeout can kill rc-spawned children
+      ...opts.env ? { env: opts.env } : {}
+    });
+    let stdout = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (c2) => {
+      stdout += c2;
+    });
+    child.stderr.resume();
+    const timer = setTimeout(() => {
+      if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      resolve2({ stdout, timedOut: true });
+    }, timeoutMs);
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve2({ stdout, timedOut: false });
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      resolve2({ stdout, timedOut: false });
+    });
+  });
+}
+async function resolveCommandViaShell(name, opts = {}) {
+  const { env = process.env } = opts;
+  if (!isEligibleForShellFallback(name, opts)) return { kind: "unsupported" };
+  const shell = env.SHELL;
+  const cached = pathCache.get(`${shell}:${name}`);
+  if (cached) return { kind: "path", path: cached, shell };
+  const probe = await probeCommand(name, shell, opts);
+  if (probe.timedOut) {
+    return {
+      kind: "error",
+      message: `shell resolution timed out after ${opts.timeoutMs ?? PROBE_TIMEOUT_MS2}ms`
+    };
+  }
+  const { path, kind } = parseProbeOutput(probe.stdout);
+  const cls = classifyResolution(path, kind);
+  if (cls === "path") {
+    pathCache.set(`${shell}:${name}`, path);
+    return { kind: "path", path, shell };
+  }
+  if (cls === "alias" || cls === "function") return { kind: cls, shell };
+  return { kind: "none", shell };
+}
+function buildBridgeArgs(name, hostArgs, shell) {
+  const kind = shellKind(shell) ?? "zsh";
+  if (kind === "fish") {
+    return { binary: shell, args: ["-ic", `${name} $argv`, ...hostArgs] };
+  }
+  if (kind === "bash") {
+    return {
+      binary: shell,
+      args: [
+        "-lic",
+        `shopt -s expand_aliases; [ -r "$HOME/.bashrc" ] && . "$HOME/.bashrc" 2>/dev/null; ${name} "$@"`,
+        "noirbridge",
+        ...hostArgs
+      ]
+    };
+  }
+  return { binary: shell, args: ["-lic", `${name} "$@"`, "noirbridge", ...hostArgs] };
+}
+var PROBE_TIMEOUT_MS2, NAME_RE, SUPPORTED_SHELLS, PROBE_FLAGS, PROBE_SCRIPTS, pathCache;
+var init_shell_bridge = __esm({
+  "src/shell-bridge.ts"() {
+    "use strict";
+    PROBE_TIMEOUT_MS2 = 3e3;
+    NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+    SUPPORTED_SHELLS = /* @__PURE__ */ new Set(["zsh", "bash", "fish"]);
+    PROBE_FLAGS = {
+      zsh: "-lic",
+      bash: "-lic",
+      fish: "-ic"
+    };
+    PROBE_SCRIPTS = {
+      zsh: 'printf "\\nN:%s" "$(whence -p "$1")"; printf "\\nK:%s" "$(whence -w "$1")"',
+      bash: 'shopt -s expand_aliases; [ -r "$HOME/.bashrc" ] && . "$HOME/.bashrc" 2>/dev/null; printf "\\nN:%s" "$(type -P "$1")"; printf "\\nK:%s" "$(type -t "$1")"',
+      fish: 'printf "\\nN:%s" (type -P "$argv[1]"); printf "\\nK:%s" (type -t "$argv[1]")'
+    };
+    pathCache = /* @__PURE__ */ new Map();
+  }
+});
 
 // src/orchestrator.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
+import { constants } from "os";
 import { createInterface } from "readline";
-var HOST_BINARY = {
-  claude: "claude",
-  gemini: "gemini",
-  opencode: "opencode",
-  cursor: "cursor-agent",
-  "agents-md": null
-  // emits AGENTS.md — a file host, not a spawnable CLI
-};
-var HOST_FLAGS = {
-  claude: ["-p", "--output-format", "stream-json", "--verbose"],
-  gemini: ["-p", "--output-format", "stream-json"],
-  opencode: ["run"],
-  cursor: ["-p"],
-  "agents-md": []
-};
 function resolveHostRun(host, customBinary) {
   const binary = customBinary && customBinary.length > 0 ? customBinary : HOST_BINARY[host];
   if (!binary) return null;
@@ -2369,6 +4154,10 @@ function str(v) {
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
+function signalNumber(signal) {
+  const n = constants.signals[signal];
+  return typeof n === "number" ? n : void 0;
+}
 function usageFrom(v) {
   const o = asObj(v);
   if (!o) return void 0;
@@ -2416,7 +4205,14 @@ function normalizeStreamEvent(raw) {
       kind: "assistant",
       messageId: message ? str(message.id) : void 0,
       text: messageText(message),
-      usage: message ? usageFrom(message.usage) : void 0
+      usage: message ? usageFrom(message.usage) : void 0,
+      // 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).
+      ...r.is_api_error_message === true || typeof r.error === "string" ? {
+        isError: true,
+        ...typeof r.error === "string" ? { errorCategory: r.error } : {}
+      } : {}
     };
   }
   if (type === "result") {
@@ -2431,60 +4227,41 @@ function normalizeStreamEvent(raw) {
   }
   return { kind: "other" };
 }
-var UsageReducer = class {
-  maxByMessage = /* @__PURE__ */ new Map();
-  input = 0;
-  output = 0;
-  costUsd = 0;
-  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.totalCostUsd !== void 0) this.costUsd = event.totalCostUsd;
-      if (event.numTurns !== void 0) this.turns = event.numTurns;
-    }
-  }
-  /** The current accumulator snapshot. */
-  snapshot() {
-    return {
-      inputTokens: this.input,
-      outputTokens: this.output,
-      totalCostUsd: this.costUsd,
-      numTurns: this.turns
-    };
-  }
-};
 function runHost(opts) {
   const spec = resolveHostRun(opts.host, opts.customBinary);
-  return new Promise((resolve, reject) => {
-    if (!spec) {
-      reject(new Error(`host '${opts.host}' is not a spawnable CLI (no default command)`));
-      return;
-    }
-    const child = spawn(spec.binary, [...spec.flags, opts.prompt], {
-      stdio: ["ignore", "pipe", "pipe"]
+  if (!spec) {
+    return Promise.reject(
+      new Error(`host '${opts.host}' is not a spawnable CLI (no default command)`)
+    );
+  }
+  return spawnAndConsume(
+    spec.binary,
+    [...spec.flags, ...opts.extraArgs ?? [], opts.prompt],
+    opts,
+    false
+  );
+}
+function spawnAndConsume(binary, args, opts, shellRun) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(binary, [...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...opts.env ? { env: opts.env } : {}
     });
     const reducer = new UsageReducer();
     let eventCount = 0;
     let stderrBuf = "";
-    child.on("error", (err) => reject(err));
+    let errored = false;
+    let errorText;
+    let errorCategory;
+    let spawnError = null;
+    child.on("error", (err) => {
+      spawnError = err;
+      if (!shellRun && err.code === "ENOENT") {
+        void shellFallback(binary, args, opts, resolve2, reject, err);
+        return;
+      }
+      reject(err);
+    });
     const rl = createInterface({ input: child.stdout });
     rl.on("line", (line) => {
       opts.onLine?.(line);
@@ -2493,6 +4270,13 @@ function runHost(opts) {
       const event = normalizeStreamEvent(raw);
       if (event === null) return;
       eventCount += 1;
+      if (event.kind === "assistant" && event.isError === true) {
+        errored = true;
+        if (errorText === void 0 && event.text && event.text.length > 0) errorText = event.text;
+        if (errorCategory === void 0 && event.errorCategory) errorCategory = event.errorCategory;
+      } else if (event.kind === "result" && event.isError === true) {
+        errored = true;
+      }
       reducer.add(event);
       opts.onEvent?.(event);
     });
@@ -2500,13 +4284,161 @@ function runHost(opts) {
     child.stderr.on("data", (chunk) => {
       stderrBuf += chunk;
     });
-    child.on("close", (code) => {
-      resolve({ exitCode: code ?? 0, usage: reducer.snapshot(), eventCount, stderr: stderrBuf });
+    child.on("close", (code, signal) => {
+      if (spawnError !== null) return;
+      const killed = code === null && signal != null;
+      resolve2({
+        exitCode: killed ? 128 + (signalNumber(signal) ?? 0) : code ?? 0,
+        usage: reducer.snapshot(),
+        eventCount,
+        stderr: stderrBuf,
+        isError: errored || killed,
+        errorText: killed && errorText === void 0 ? `terminated by signal ${signal}` : errorText,
+        errorCategory
+      });
     });
   });
 }
+async function shellFallback(binary, args, opts, resolve2, 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));
+      return;
+    }
+    if (res.kind === "alias" || res.kind === "function") {
+      const bridge = buildBridgeArgs(binary, args, res.shell);
+      resolve2(await spawnAndConsume(bridge.binary, bridge.args, opts, true));
+      return;
+    }
+  } catch {
+  }
+  reject(originalErr);
+}
+var HOST_BINARY, HOST_FLAGS, UsageReducer;
+var init_orchestrator = __esm({
+  "src/orchestrator.ts"() {
+    "use strict";
+    init_shell_bridge();
+    HOST_BINARY = {
+      claude: "claude",
+      gemini: "gemini",
+      opencode: "opencode",
+      cursor: "cursor-agent",
+      "agents-md": null
+      // emits AGENTS.md — a file host, not a spawnable CLI
+    };
+    HOST_FLAGS = {
+      claude: ["-p", "--output-format", "stream-json", "--verbose"],
+      gemini: ["-p", "--output-format", "stream-json"],
+      opencode: ["run"],
+      cursor: ["-p"],
+      "agents-md": []
+    };
+    UsageReducer = class {
+      maxByMessage = /* @__PURE__ */ new Map();
+      input = 0;
+      output = 0;
+      costUsd = 0;
+      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.totalCostUsd !== void 0) this.costUsd = event.totalCostUsd;
+          if (event.numTurns !== void 0) this.turns = event.numTurns;
+        }
+      }
+      /** The current accumulator snapshot. */
+      snapshot() {
+        return {
+          inputTokens: this.input,
+          outputTokens: this.output,
+          totalCostUsd: this.costUsd,
+          numTurns: this.turns
+        };
+      }
+    };
+  }
+});
+
+// src/run-profiles.ts
+import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
+function loadRunConfig(root) {
+  try {
+    return loadProjectInfo10(root).config;
+  } catch {
+    return null;
+  }
+}
+function expandEnvVars(value, env) {
+  return value.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
+    (match, name) => env[name] !== void 0 ? env[name] : match
+  );
+}
+function resolveRunProfile(requested, config, env) {
+  const profiles = config.run?.profiles ?? {};
+  const names = Object.keys(profiles);
+  const name = requested ?? env.NOIR_PROFILE ?? config.run?.defaultProfile;
+  if (name === void 0 || name.length === 0) {
+    return { ok: true, profile: {} };
+  }
+  const profile = profiles[name];
+  if (!profile) {
+    const available = names.length > 0 ? names.join(", ") : "(none defined \u2014 add a run.profiles block to .noir/config.yml)";
+    return {
+      ok: false,
+      message: `unknown run profile "${name}" \u2014 no profile named "${name}" is defined under run.profiles in .noir/config.yml. Available: ${available}`
+    };
+  }
+  const envExpanded = {};
+  if (profile.env) {
+    for (const [k, v] of Object.entries(profile.env)) {
+      envExpanded[k] = v === null ? void 0 : expandEnvVars(v, env);
+    }
+  }
+  return {
+    ok: true,
+    profile: { binary: profile.binary, env: envExpanded, args: profile.args, profileName: name }
+  };
+}
+function listProfiles(config) {
+  const profiles = config.run?.profiles ?? {};
+  const def = config.run?.defaultProfile;
+  return Object.keys(profiles).map((name) => ({
+    NAME: name,
+    DEFAULT: name === def ? "*" : "",
+    BINARY: profiles[name]?.binary ?? ""
+  }));
+}
+var init_run_profiles = __esm({
+  "src/run-profiles.ts"() {
+    "use strict";
+  }
+});
 
 // src/commands/run.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
+import { parseConfig } from "@noir-ai/core";
 function formatUsage(u) {
   const cost = u.totalCostUsd > 0 ? ` $${u.totalCostUsd.toFixed(2)}` : "";
   const turns = u.numTurns > 0 ? ` \xB7 ${u.numTurns} turns` : "";
@@ -2514,7 +4446,7 @@ function formatUsage(u) {
 }
 function streamEvent(event, opts) {
   if (opts.json === true) return;
-  if (event.kind === "assistant" && event.text && event.text.length > 0) {
+  if (event.kind === "assistant" && event.text && event.text.length > 0 && event.isError !== true) {
     process.stdout.write(event.text);
   }
 }
@@ -2524,100 +4456,108 @@ async function run(prompt, opts) {
     fail(EXIT.USAGE, `unknown host '${host}' (supported: ${SUPPORTED_HOSTS.join(", ")})`, opts);
   }
   if (prompt.length === 0) {
-    fail(EXIT.USAGE, "a prompt is required: `noir run <prompt>`", opts);
-  }
+    const selectors = [];
+    if (opts.command) selectors.push(`--command ${opts.command}`);
+    if (opts.profile) selectors.push(`--profile ${opts.profile}`);
+    const usage = selectors.length > 0 ? `noir run ${selectors.join(" ")} <prompt>` : "noir run <prompt>";
+    fail(EXIT.USAGE, `a prompt is required: \`${usage}\``, opts);
+  }
+  const config = loadRunConfig(process.cwd()) ?? parseConfig({});
+  const resolved = resolveRunProfile(opts.profile, config, process.env);
+  if (!resolved.ok) fail(EXIT.USAGE, resolved.message, opts);
+  const profile = resolved.profile;
+  const customBinary = opts.command ?? profile.binary;
+  const extraArgs = profile.args;
+  const env = profile.env ? mergeEnv(process.env, profile.env) : void 0;
   const transcriptLines = [];
+  let result;
   try {
-    const result = await runHost({
+    result = await runHost({
       host,
       prompt,
-      customBinary: opts.command,
+      customBinary,
+      extraArgs,
+      env,
       onLine: (line) => transcriptLines.push(line),
       onEvent: (event) => streamEvent(event, opts)
     });
-    if (opts.json !== true) {
-      process.stdout.write("\n");
-    }
-    const transcript = writeTranscript(host, transcriptLines);
-    if (opts.json === true) {
-      json({
-        ok: true,
-        data: {
-          host,
-          prompt,
-          exitCode: result.exitCode,
-          usage: result.usage,
-          numTurns: result.usage.numTurns,
-          events: result.eventCount,
-          transcript
-        }
-      });
-      return;
-    }
-    if (result.exitCode !== 0) {
-      log(`host exited ${result.exitCode}`, opts);
-      if (result.stderr.length > 0) log(result.stderr.trim(), opts);
-    }
-    success(`usage: ${formatUsage(result.usage)} (API-equivalent estimate, not billed)`, opts);
-    log(`transcript: ${transcript}`, opts);
   } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `failed to run host '${host}': ${err instanceof Error ? err.message : String(err)}`,
-      opts
-    );
+    const binary = customBinary && customBinary.length > 0 ? customBinary : host;
+    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);
+  }
+  const transcript = writeTranscript(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);
+    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.`;
+      if (process.env.ANTHROPIC_API_KEY) {
+        message += ` Note: ANTHROPIC_API_KEY is set in your environment \u2014 it overrides the logged-in account in \`-p\` mode; unset it (or fix the key) if you meant to use your subscription.`;
+      }
+    }
+    message += ` If you use another profile, pass \`--command <binary>\` or define a run profile under run.profiles. transcript: ${transcript}`;
+    fail(EXIT.ERROR, message, opts);
+  }
+  if (opts.json === true) {
+    json({
+      ok: true,
+      data: {
+        host,
+        prompt,
+        exitCode: result.exitCode,
+        usage: result.usage,
+        numTurns: result.usage.numTurns,
+        events: result.eventCount,
+        transcript
+      }
+    });
+    return;
   }
+  process.stdout.write("\n");
+  success(`usage: ${formatUsage(result.usage)} (API-equivalent estimate, not billed)`, opts);
+  log(`transcript: ${transcript}`, opts);
+}
+function mergeEnv(base, overlay) {
+  const merged = { ...base, ...overlay };
+  return Object.fromEntries(Object.entries(merged).filter(([, v]) => v !== void 0));
 }
 function writeTranscript(host, lines) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dir = join2(process.cwd(), ".noir", "transcripts");
-  const file = join2(dir, `${host}-${ts}.jsonl`);
+  const dir = join4(process.cwd(), ".noir", "transcripts");
+  const file = join4(dir, `${host}-${ts}.jsonl`);
   try {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync2(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`);
+    mkdirSync3(dir, { recursive: true, mode: 448 });
+    writeFileSync3(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
   } catch {
     return "(not persisted)";
   }
   return file;
 }
+var init_run = __esm({
+  "src/commands/run.ts"() {
+    "use strict";
+    init_orchestrator();
+    init_output();
+    init_run_profiles();
+  }
+});
 
 // src/commands/skills.ts
-import { claudeAdapter } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo7 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
   emitSkillsToDir,
   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;
@@ -2677,8 +4617,14 @@ async function skillsList(opts) {
 }
 async function skillsSync(opts) {
   const root = process.cwd();
-  const project = loadProjectInfo7(root);
-  if (!claudeAdapter.skillsDir) {
+  let project;
+  try {
+    project = loadProjectInfo11(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,
@@ -2693,8 +4639,9 @@ async function skillsSync(opts) {
     info("This host has no skill emitter; nothing to sync.", opts);
     return;
   }
-  const dir = claudeAdapter.skillsDir({ root });
-  const summary = await emitSkillsToDir(dir);
+  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,
@@ -2733,22 +4680,37 @@ async function skillsLint(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 (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: errored.length === 0, data })}
-`);
-    return;
-  }
-  if (errored.length === 0) {
-    log(`noir skills lint \u2014 ${skills.length} skills, all validate clean.`, opts);
-  } else {
+  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);
   }
-  for (const s of errored) {
-    for (const e of s.errors) warn(`  ${s.name}: ${e}`, 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) {
@@ -2788,8 +4750,725 @@ async function skillsRegistry(opts) {
     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 === true) {
+    return { conflictPolicy: "preserve", onConflict: clackConflictResolver };
+  }
+  if (flaggedNonInteractive() || !isInteractive()) {
+    return { conflictPolicy: "preserve" };
+  }
+  return { conflictPolicy: "preserve", onConflict: clackConflictResolver };
+}
+function renderDiffPreview(ctx) {
+  const lines = lineDiff(ctx.existing, ctx.proposed);
+  if (lines.length === 0) return;
+  const out = [`noir: conflict in ${ctx.relPath}`];
+  for (const dl of lines) {
+    if (dl.type === "add") out.push(c.ok(`+ ${dl.line}`));
+    else if (dl.type === "del") out.push(c.error(`- ${dl.line}`));
+    else out.push(c.dim(`  ${dl.line}`));
+  }
+  process.stderr.write(`${out.join("\n")}
+`);
+}
+async function clackConflictResolver(ctx) {
+  renderDiffPreview(ctx);
+  const clack = await import("@clack/prompts");
+  const options = [
+    {
+      value: "replace",
+      label: "Replace",
+      hint: "overwrite with the template (discard your edits)"
+    },
+    { value: "rename", label: "Rename", hint: "keep yours as <file>.local; write the template" },
+    {
+      value: "duplicate",
+      label: "Create duplicate",
+      hint: "write template to <file>.noir; keep yours"
+    },
+    { value: "preserve", label: "Keep mine", hint: "skip; leave your file unchanged" },
+    { value: "cancel", label: "Cancel", hint: "abort the scaffold" }
+  ];
+  if (ctx.mergedWithMarkers !== void 0) {
+    options.splice(4, 0, {
+      value: "merge",
+      label: "Merge (with conflict markers)",
+      hint: "write the 3-way merge with <<<<<<< / ||||||| / ======= / >>>>>>> markers"
+    });
+  }
+  const choice = await clack.select({
+    message: `${ctx.relPath} was edited and differs from the Noir template.`,
+    initialValue: "preserve",
+    options
+  });
+  if (clack.isCancel(choice)) return "cancel";
+  const resolution = choice;
+  const mode = ctx.mode ?? "regenerate";
+  const supportsApplyToAll = mode !== "managedBlock" && mode !== "managedBlocks";
+  if (supportsApplyToAll) {
+    const remember = await clack.select({
+      message: `Apply "${labelFor(resolution)}" to all remaining conflicts this run?`,
+      initialValue: "no",
+      options: [
+        { value: "yes", label: "Yes", hint: "reuse this choice for the rest of this run" },
+        { value: "no", label: "No", hint: "prompt again for each conflict" }
+      ]
+    });
+    if (!clack.isCancel(remember) && remember === "yes") {
+      return { resolution, applyToAll: true };
+    }
+  }
+  return resolution;
+}
+function labelFor(resolution) {
+  switch (resolution) {
+    case "replace":
+      return "Replace";
+    case "rename":
+      return "Rename";
+    case "duplicate":
+      return "Create duplicate";
+    case "preserve":
+      return "Keep mine";
+    case "merge":
+      return "Merge (with conflict markers)";
+    case "cancel":
+      return "Cancel";
+  }
+}
+var init_conflict = __esm({
+  "src/conflict.ts"() {
+    "use strict";
+    init_output();
+    init_theme();
+  }
+});
+
+// src/dedup-write.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
+async function checkWritePathDedup(root, res, opts) {
+  const result = { found: [], conflicts: [] };
+  const writtenHostFiles = res.written.filter((p) => HOST_CONTEXT_RELS.has(p));
+  if (writtenHostFiles.length === 0) return result;
+  const cache = loadCache(root);
+  const embed = await resolveEmbedder(opts, cache);
+  if (embed === void 0) return result;
+  const cachedEmbed = makeCachedEmbed(cache, embed);
+  for (const proposedRel of writtenHostFiles) {
+    const proposedAbs = join5(root, proposedRel);
+    let proposedText;
+    try {
+      proposedText = readFileSync2(proposedAbs, "utf8");
+    } catch {
+      continue;
+    }
+    if (proposedText.trim().length === 0) continue;
+    const candidates = collectDedupCandidates(root).filter((c2) => c2.path !== proposedRel);
+    if (candidates.length === 0) continue;
+    const ctx = await import("@noir-ai/context");
+    const proposed = { path: proposedRel, text: proposedText };
+    let best;
+    try {
+      best = await ctx.findNearestDuplicate(
+        proposed,
+        candidates,
+        async (t) => cachedEmbed(t),
+        INFO_THRESHOLD
+      );
+    } catch (e) {
+      process.stderr.write(
+        `${c.dim(`noir: semantic-dedup skipped for ${proposedRel} (${errMsg(e)}).`)}
+`
+      );
+      continue;
+    }
+    if (best === null) continue;
+    const matchedRel = best.a === proposedRel ? best.b : best.a;
+    const sim = best.similarity;
+    result.found.push({ proposedRel, matchedRel, similarity: sim });
+    let resolution = "preserve";
+    if (sim >= ACTION_THRESHOLD) {
+      if (opts.interactive) {
+        resolution = await promptDedupAction(root, proposedRel, matchedRel, proposedText, sim);
+      } else {
+        process.stderr.write(
+          `${c.warn("noir: near-duplicate")} ${proposedRel} \u2248 ${matchedRel} (cosine ${sim.toFixed(2)}); creating anyway.
+`
+        );
+      }
+    } else {
+      process.stderr.write(
+        `${c.dim(`noir: hint  ${proposedRel} looks similar to existing ${matchedRel} (cosine ${sim.toFixed(2)}).`)}
+`
+      );
+    }
+    const matchedText = safeRead(join5(root, matchedRel));
+    result.conflicts.push({
+      path: proposedRel,
+      mode: "artifact",
+      similarity: sim,
+      existingSha: sha256Hex12(matchedText ?? ""),
+      proposedSha: sha256Hex12(proposedText),
+      resolution
+    });
+  }
+  saveCache(root, cache);
+  return result;
+}
+async function resolveEmbedder(opts, cache) {
+  const ctx = await import("@noir-ai/context");
+  let modelId;
+  if (opts.project !== void 0) {
+    const cfg = ctx.resolveEmbedderConfig(opts.project.config.context);
+    if (cfg.kind === "none") {
+      process.stderr.write(`${c.dim("noir: semantic-dedup skipped (embedder kind=none).")}
+`);
+      return void 0;
+    }
+    modelId = cfg.kind === "local" ? cfg.model ?? ctx.DEFAULT_LOCAL_MODEL : cfg.model ?? cfg.kind;
+    if (modelId !== void 0 && cache.model !== modelId) {
+      cache.model = modelId;
+      cache.entries = {};
+    }
+  }
+  if (opts.embed !== void 0) return opts.embed;
+  if (modelId === void 0) return void 0;
+  let embed;
+  try {
+    const project = opts.project;
+    if (project === void 0) return void 0;
+    const cfg = ctx.resolveEmbedderConfig(project.config.context);
+    embed = ctx.createEmbedFn(cfg).embed;
+  } catch (e) {
+    process.stderr.write(
+      `${c.dim(`noir: semantic-dedup skipped (embedder unavailable: ${errMsg(e)}).`)}
+`
+    );
+    return void 0;
+  }
+  const ping = await withTimeout(
+    embed("ping").then(() => true),
+    EMBEDDER_PING_TIMEOUT_MS
+  );
+  if (ping !== true) {
+    process.stderr.write(
+      `${c.dim("noir: semantic-dedup skipped (embedder load too slow or unavailable).")}
+`
+    );
+    return void 0;
+  }
+  return embed;
+}
+async function promptDedupAction(root, proposedRel, matchedRel, proposedText, sim) {
+  const clack = await import("@clack/prompts");
+  const choice = await clack.select({
+    message: `${proposedRel} is near-duplicate of existing ${matchedRel} (cosine ${sim.toFixed(2)}). Create anyway?`,
+    initialValue: "create",
+    options: [
+      {
+        value: "create",
+        label: "Create anyway",
+        hint: "keep the new file as-is (default)"
+      },
+      { value: "skip", label: "Skip", hint: `delete ${proposedRel}; keep ${matchedRel}` },
+      {
+        value: "replace",
+        label: "Replace existing",
+        hint: `overwrite ${matchedRel} with this content`
+      },
+      {
+        value: "mirror",
+        label: "Mirror into existing",
+        hint: `append this content to ${matchedRel}`
+      }
+    ]
+  });
+  if (clack.isCancel(choice)) return "preserve";
+  if (choice === "skip") {
+    try {
+      rmSync(join5(root, proposedRel), { force: true });
+    } catch {
+    }
+    return "preserve";
+  } else if (choice === "replace") {
+    try {
+      writeFileSync4(join5(root, matchedRel), proposedText, "utf8");
+    } catch {
+    }
+    return "replace";
+  } else if (choice === "mirror") {
+    try {
+      const existing = readFileSync2(join5(root, matchedRel), "utf8");
+      writeFileSync4(
+        join5(root, matchedRel),
+        `${existing}
+
+<!-- mirrored from ${proposedRel} -->
+${proposedText}
+`,
+        "utf8"
+      );
+    } catch {
+    }
+    return "duplicate";
+  }
+  return "preserve";
+}
+function emptyCache() {
+  return { version: DEDUP_CACHE_VERSION, model: "", entries: {} };
+}
+function cachePath(root) {
+  return join5(root, ".noir", "dedup-cache.json");
+}
+function loadCache(root) {
+  try {
+    const raw = readFileSync2(cachePath(root), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== DEDUP_CACHE_VERSION) return emptyCache();
+    if (typeof parsed.entries !== "object" || parsed.entries === null) return emptyCache();
+    return {
+      version: DEDUP_CACHE_VERSION,
+      model: typeof parsed.model === "string" ? parsed.model : "",
+      entries: parsed.entries
+    };
+  } catch {
+    return emptyCache();
+  }
+}
+function saveCache(root, cache) {
+  try {
+    mkdirSync4(join5(root, ".noir"), { recursive: true });
+    writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function makeCachedEmbed(cache, embed) {
+  return async (text) => {
+    const key = sha256Hex2(text);
+    const cached = cache.entries[key];
+    if (cached !== void 0) return Float32Array.from(cached.v);
+    const v = await embed(text);
+    cache.entries[key] = { v: Array.from(v) };
+    return v;
+  };
+}
+function safeRead(abs) {
+  try {
+    return readFileSync2(abs, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function withTimeout(p, ms) {
+  return new Promise((resolve2) => {
+    const t = setTimeout(() => resolve2(void 0), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve2(v);
+      },
+      () => {
+        clearTimeout(t);
+        resolve2(void 0);
+      }
+    );
+  });
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var HOST_CONTEXT_RELS, ACTION_THRESHOLD, INFO_THRESHOLD, EMBEDDER_PING_TIMEOUT_MS, DEDUP_CACHE_VERSION;
+var init_dedup_write = __esm({
+  "src/dedup-write.ts"() {
+    "use strict";
+    init_doctor();
+    init_theme();
+    HOST_CONTEXT_RELS = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"]);
+    ACTION_THRESHOLD = 0.95;
+    INFO_THRESHOLD = 0.85;
+    EMBEDDER_PING_TIMEOUT_MS = 5e3;
+    DEDUP_CACHE_VERSION = 1;
+  }
+});
+
+// src/init.ts
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
+import { scaffold } from "@noir-ai/create";
+import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
+async function init(root, opts) {
+  assertTransportUrl(opts);
+  const host = opts.host ?? "claude";
+  const interactive = resolveInteractive();
+  const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
+  const dryRun = opts.dryRun === true || opts.preview === true;
+  const res = await scaffold({
+    root,
+    mode: "init",
+    host,
+    transport: opts.transport,
+    interactive,
+    ...opts.url !== void 0 ? { url: opts.url } : {},
+    ...opts.upgrade === true ? { upgrade: true } : {},
+    ...opts.force === true ? { force: true } : {},
+    ...dryRun ? { dryRun: true } : {},
+    ...conflictOpts
+  });
+  if (dryRun) {
+    reportPlannedWrites(res);
+    return res;
+  }
+  if (res.noop) return res;
+  await emitHostSkills(root, host, conflictOpts, interactive);
+  let projectInfo;
+  try {
+    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);
+  process.stderr.write(
+    `Noir initialized in ${root} (host: ${host}, transport: ${opts.transport}).
+`
+  );
+  process.stderr.write(
+    "Next: run `noir` to open the home menu (or `noir status` for a snapshot).\n"
+  );
+  return res;
+}
+function reportPlannedWrites(res) {
+  log("Dry run \u2014 no files were written.");
+  if (res.written.length > 0) {
+    log("Planned writes:");
+    for (const p of res.written) log(`  ${p}`);
+  }
+  if (res.skipped.length > 0) {
+    log("Would leave as-is (already present):");
+    for (const p of res.skipped) log(`  ${p}`);
+  }
+  if (res.identical.length > 0) {
+    log("Would rewrite (byte-identical, no-op):");
+    for (const p of res.identical) log(`  ${p}`);
+  }
+}
+async function emitHostSkills(root, host, conflictOpts, interactive) {
+  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;
+  }
+  const target = host;
+  const skillOpts = {
+    includeIntegrations: true,
+    target,
+    conflictPolicy: conflictOpts.conflictPolicy,
+    interactive
+  };
+  if (conflictOpts.onConflict !== void 0) {
+    skillOpts.onConflict = conflictOpts.onConflict;
+  }
+  const summary = await emitSkillsToDir2(skillsDir, skillOpts);
+  const relDir = skillsDir.replace(`${root}/`, "");
+  process.stderr.write(
+    `Emitted ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
+`
+  );
+}
+function assertTransportUrl(opts) {
+  if (opts.transport === "streamable-http" && opts.url === void 0) {
+    throw new Error("--transport streamable-http requires --url");
+  }
+  if (opts.url !== void 0) {
+    assertLocalhostUrl(opts.url);
+  }
+}
+function assertLocalhostUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`Invalid URL: ${raw}`);
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new Error("Only http/https URLs are supported");
+  }
+  if (!["localhost", "127.0.0.1", "::1"].includes(url.hostname)) {
+    throw new Error(`Only localhost URLs are supported (got ${url.hostname})`);
+  }
+}
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_conflict();
+    init_dedup_write();
+    init_output();
+  }
+});
+
+// src/serve.ts
+import { applyNoirEnv, loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
+import { ensureDaemonRunning as ensureDaemonRunning3, startStdioServer } from "@noir-ai/daemon";
+async function serve(opts) {
+  applyNoirEnv(process.cwd());
+  const project = loadProjectInfo13(process.cwd());
+  if (opts.stdio) {
+    await startStdioServer({ project, transport: "stdio", daemon: false });
+    return;
+  }
+  try {
+    const { url } = await ensureDaemonRunning3({
+      project,
+      idleTimeoutSec: project.config.daemon.idleTimeoutSec
+    });
+    process.stderr.write(
+      `Noir daemon available at ${url}. (For HTTP clients, use this URL in .mcp.json.)
+`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `Noir daemon unavailable (${err instanceof Error ? err.message : String(err)}); falling back to stdio.
+`
+    );
+    await startStdioServer({ project, transport: "stdio", daemon: false });
+  }
+}
+var init_serve = __esm({
+  "src/serve.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/create.ts
+var create_exports = {};
+__export(create_exports, {
+  create: () => create
+});
+import { resolve } from "path";
+import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo14 } 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 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,
+    transport: opts.transport,
+    interactive,
+    ...opts.url !== void 0 ? { url: opts.url } : {},
+    ...opts.force === true ? { force: true } : {},
+    ...dryRun ? { dryRun: true } : {},
+    ...conflictOpts
+  });
+  if (dryRun) {
+    reportPlannedWrites(res);
+    return res;
+  }
+  if (res.noop) return res;
+  const adapter = resolveAdapter5(host);
+  const skillsDir = adapter.skillsDir?.({ root });
+  if (skillsDir === void 0) {
+    process.stderr.write(`host '${host}' has no skill emitter; skipping skills
+`);
+  } else {
+    const target = host;
+    const skillOpts = {
+      includeIntegrations: true,
+      target,
+      conflictPolicy: conflictOpts.conflictPolicy,
+      interactive
+    };
+    if (conflictOpts.onConflict !== void 0) {
+      skillOpts.onConflict = conflictOpts.onConflict;
+    }
+    const summary = await emitSkillsToDir3(skillsDir, skillOpts);
+    const relDir = skillsDir.replace(`${root}/`, "");
+    process.stderr.write(
+      `Emitted ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
+`
+    );
+  }
+  let projectInfo;
+  try {
+    projectInfo = loadProjectInfo14(root);
+  } catch {
+    projectInfo = void 0;
+  }
+  const dedup = await checkWritePathDedup(root, res, { interactive, project: projectInfo });
+  if (dedup.conflicts.length > 0) res.conflicts.push(...dedup.conflicts);
+  process.stderr.write(`Noir created in ${root} (host: ${host}, transport: ${opts.transport}).
+`);
+  process.stderr.write("Next: cd into the new directory, then run `noir` to open the home menu.\n");
+  return res;
+}
+var init_create = __esm({
+  "src/commands/create.ts"() {
+    "use strict";
+    init_conflict();
+    init_dedup_write();
+    init_init();
+    init_output();
+  }
+});
+
+// src/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  sync: () => sync
+});
+import { existsSync as existsSync2 } from "fs";
+import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo15, paths as paths2 } 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 = {}) {
+  const host = resolveSyncHost(root, opts);
+  const interactive = resolveInteractive();
+  const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
+  let projectInfo;
+  try {
+    projectInfo = loadProjectInfo15(root);
+  } catch {
+    projectInfo = void 0;
+  }
+  const dryRun = opts.dryRun === true || opts.preview === true;
+  const res = await scaffold3({
+    root,
+    mode: "sync",
+    host,
+    interactive,
+    ...dryRun ? { dryRun: true } : {},
+    ...conflictOpts,
+    // Merge defaults TRUE inside scaffold; only forward an explicit opt-out.
+    ...opts.mergeManagedRegions === false ? { mergeManagedRegions: false } : {}
+  });
+  if (dryRun) {
+    reportPlannedWrites(res);
+    return res;
+  }
+  if (res.written.length === 0 && res.identical.length > 0) {
+    process.stderr.write("Nothing to sync (Noir-managed files are up to date).\n");
+  }
+  const adapter = resolveAdapter6(host);
+  const skillsDir = adapter.skillsDir?.({ root });
+  if (skillsDir === void 0) {
+    process.stderr.write(`host '${host}' has no skill emitter; skipping skills
+`);
+  } else {
+    const target = host;
+    const skillOpts = {
+      includeIntegrations: true,
+      target,
+      conflictPolicy: conflictOpts.conflictPolicy,
+      interactive
+    };
+    if (conflictOpts.onConflict !== void 0) {
+      skillOpts.onConflict = conflictOpts.onConflict;
+    }
+    const summary = await emitSkillsToDir4(skillsDir, skillOpts);
+    const relDir = skillsDir.replace(`${root}/`, "");
+    process.stderr.write(
+      `Synced ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
+`
+    );
+    const pruned = summary.pruned ?? [];
+    if (pruned.length > 0) {
+      process.stderr.write(
+        `Pruned ${pruned.length} stale noir-* skill dir${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}
+`
+      );
+    }
+  }
+  const dedup = await checkWritePathDedup(root, res, { interactive, project: projectInfo });
+  if (dedup.conflicts.length > 0) res.conflicts.push(...dedup.conflicts);
+  return res;
+}
+function resolveSyncHost(root, opts) {
+  if (opts.host !== void 0) return opts.host;
+  if (!existsSync2(paths2.config(root))) return "claude";
+  try {
+    return loadProjectInfo15(root).config.host;
+  } catch {
+    return "claude";
+  }
+}
+var init_sync = __esm({
+  "src/sync.ts"() {
+    "use strict";
+    init_conflict();
+    init_dedup_write();
+    init_init();
+    init_output();
+  }
+});
 
 // src/bin.ts
+import { realpathSync } from "fs";
+import { pathToFileURL } from "url";
+import { SUPPORTED_HOSTS as SUPPORTED_HOSTS2 } from "@noir-ai/adapters";
+import { applyNoirEnv as applyNoirEnv2, NOIR_VERSION as NOIR_VERSION6 } from "@noir-ai/core";
+import { Command, Option } from "commander";
 function buildPaletteCommandsForTui() {
   return buildPaletteCommands(createProgram());
 }
@@ -2828,14 +5507,14 @@ function toStatusOptions(g) {
     json: g.json === true,
     quiet: g.quiet === true,
     verbose: g.verbose === true,
-    input: g.input !== false
+    input: g.input !== false,
+    ...g.tips === false ? { noTips: true } : {}
   };
 }
 function parseHost(raw) {
   if (raw === void 0) return void 0;
   return raw;
 }
-var DEPRECATIONS = [];
 function commandPath(cmd) {
   const path = [];
   let c2 = cmd;
@@ -2859,7 +5538,7 @@ function emitDeprecationHintsFor(cmd, opts) {
 }
 function createProgram() {
   const program2 = new Command();
-  program2.name("noir").description("Noir \u2014 discipline, context, and memory layer for agentic CLIs.").version(NOIR_VERSION4, "-v, --version").addOption(new Option("--json", "emit machine-readable JSON to stdout")).addOption(new Option("--no-input", "never prompt; error if input is required")).addOption(new Option("--quiet", "suppress non-essential diagnostics")).addOption(new Option("--verbose", "show additional diagnostic detail")).addOption(new Option("--cwd <path>", "run as if started in <path>")).addOption(
+  program2.name("noir").description("Noir \u2014 discipline, context, and memory layer for agentic CLIs.").version(NOIR_VERSION6, "-v, --version").addOption(new Option("--json", "emit machine-readable JSON to stdout")).addOption(new Option("--no-input", "never prompt; error if input is required")).addOption(new Option("--quiet", "suppress non-essential diagnostics")).addOption(new Option("--verbose", "show additional diagnostic detail")).addOption(new Option("--cwd <path>", "run as if started in <path>")).addOption(
     new Option("--tui", "prefer the interactive home menu for bare `noir` (advisory; TTY-only)")
   ).addOption(
     new Option(
@@ -2889,6 +5568,7 @@ function createProgram() {
         );
       }
     }
+    applyNoirEnv2(process.cwd());
     const nonInteractive = opts.json === true || opts.input === false;
     if (nonInteractive) process.env.NOIR_NON_INTERACTIVE = "1";
     else delete process.env.NOIR_NON_INTERACTIVE;
@@ -2937,8 +5617,8 @@ 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-VK2QMXYS.js");
-      const result = await create(dir, {
+      const { create: create2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+      const result = await create2(dir, {
         transport,
         url: opts.url,
         ...force ? { force } : {},
@@ -2976,13 +5656,13 @@ function createProgram() {
     ).choices(SUPPORTED_HOSTS2)
   ).action(
     async (opts, cmd) => {
-      const { sync } = await import("./sync-VXZKODQA.js");
+      const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
       const host = parseHost(opts.host);
       const force = opts.force === true;
       const merge = opts.merge === true;
       const noMergeRegions = opts.mergeRegions === false;
       const dryRun = opts.dryRun === true || opts.preview === true;
-      const result = host === void 0 && !force && !merge && !noMergeRegions && !dryRun ? await sync(process.cwd()) : await sync(process.cwd(), {
+      const result = host === void 0 && !force && !merge && !noMergeRegions && !dryRun ? await sync2(process.cwd()) : await sync2(process.cwd(), {
         ...host !== void 0 ? { host } : {},
         ...force ? { force } : {},
         ...merge ? { merge } : {},
@@ -3170,7 +5850,7 @@ function createProgram() {
       ...id === void 0 ? {} : { id }
     });
   });
-  taskGrp.command("advance").description("advance the active task to the next phase").option("--to <phase>", "target phase").option("--force <reason>", "force the gate with a reason").option("--no-artifacts", "skip the document-phase artifact writes at done").action(async (...args) => {
+  taskGrp.command("advance").description("advance the active task to the next phase").option("--to <phase>", "target phase").option("--force <reason>", "force the gate with a reason").option("--skip", "record the landing gate as skipped (advance continues)").option("--no-artifacts", "skip the document-phase artifact writes at done").action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const to = typeof g.to === "string" ? g.to : void 0;
@@ -3179,6 +5859,7 @@ function createProgram() {
       ...toCliOptions(g),
       ...to === void 0 ? {} : { to },
       ...force === void 0 ? {} : { force },
+      ...g.skip === true ? { skip: true } : {},
       ...g.artifacts === false ? { noArtifacts: true } : {}
     });
   });
@@ -3230,17 +5911,15 @@ function createProgram() {
       ...typeof g.task === "string" && g.task.length > 0 ? { task: g.task } : {}
     });
   });
-  taskGrp.command("resume").description("resume the active (or named) in-flight/blocked task").argument("[id]", "task id (defaults to active)").option("--last", "target the active task explicitly (scripting)").option("--prompt <text>", "a continue instruction to surface in the briefing").action(async (...args) => {
+  taskGrp.command("resume").description("resume the active (or named) in-flight/blocked task").argument("[id]", "task id (defaults to active)").option("--prompt <text>", "a continue instruction to surface in the briefing").action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const first = args[0];
     const id = typeof first === "string" ? first : void 0;
-    const last = g.last === true;
     const prompt = typeof g.prompt === "string" ? g.prompt : void 0;
     await taskResume({
       ...toCliOptions(g),
       ...id === void 0 ? {} : { id },
-      ...last ? { last } : {},
       ...prompt === void 0 ? {} : { prompt }
     });
   });
@@ -3277,9 +5956,9 @@ 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-4U4UDDNE.js");
+      const { install: install2 } = await Promise.resolve().then(() => (init_install(), install_exports));
       const cli = cmd.optsWithGlobals();
-      await install({
+      await install2({
         ...cli,
         spec,
         list: opts.list === true,
@@ -3290,9 +5969,9 @@ 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-ZDAVLOXB.js");
+    const { update: update2 } = await Promise.resolve().then(() => (init_update(), update_exports));
     const cli = cmd.optsWithGlobals();
-    await update({ ...cli, spec, check: opts.check === true });
+    await update2({ ...cli, spec, check: opts.check === true });
   });
   function buildHandoffOptions(g) {
     return { ...toCliOptions(g), ...g.write === true ? { write: true } : {} };
@@ -3353,17 +6032,35 @@ function createProgram() {
     };
     await runPalette(opts, dispatch);
   });
-  program2.command("run").description("ask the host agent a question and print the answer").argument("[prompt...]", "prompt to send to the host").addOption(new Option("--host <id>", "host to drive (default claude)").choices(SUPPORTED_HOSTS2)).option("--command <binary>", "custom host binary (e.g. claude-work)").action(async (...args) => {
+  program2.command("run").description("ask the host agent a question and print the answer").argument("[prompt...]", "prompt to send to the host").addOption(new Option("--host <id>", "host to drive (default claude)").choices(SUPPORTED_HOSTS2)).option("--command <binary>", "custom host binary (e.g. claude-work)").option("--profile <name>", "use a named run profile (run.profiles in .noir/config.yml)").option("--list-profiles", "list configured run profiles and exit").action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const prompt = cmd.args.join(" ").trim();
     const opts = {
       ...toCliOptions(g),
       ...typeof g.host === "string" ? { host: g.host } : {},
-      ...typeof g.command === "string" ? { command: g.command } : {}
+      ...typeof g.command === "string" ? { command: g.command } : {},
+      ...typeof g.profile === "string" ? { profile: g.profile } : {}
     };
+    if (g.listProfiles === true) {
+      listProfilesCommand(opts);
+      return;
+    }
     await run(prompt, opts);
   });
+  function listProfilesCommand(opts) {
+    const config = loadRunConfig(process.cwd());
+    const rows = config ? listProfiles(config) : [];
+    if (opts.json === true) {
+      json({ ok: true, data: rows });
+      return;
+    }
+    if (rows.length === 0) {
+      info("(no run profiles configured \u2014 add a run.profiles block to .noir/config.yml)", opts);
+      return;
+    }
+    table(rows, ["NAME", "DEFAULT", "BINARY"], opts);
+  }
   program2.action(async (...args) => {
     const cmd = trailingCmd(args);
     const leftovers = cmd.args;
@@ -3378,21 +6075,6 @@ function createProgram() {
   });
   return program2;
 }
-var program = createProgram();
-var homeDeps = {
-  dispatch: async (argv) => {
-    const sub = createProgram();
-    try {
-      await sub.parseAsync([...argv], { from: "user" });
-    } catch (err) {
-      handleError(err);
-    }
-  },
-  // The grouped home menu resolves its sections against the LIVE palette
-  // registry (home-consolidation S1/S2) — the same source the TUI palette
-  // uses — so the menu cannot drift from the commander tree.
-  commands: buildPaletteCommands(createProgram())
-};
 async function run2(argv = []) {
   try {
     await program.parseAsync([...argv], { from: "user" });
@@ -3401,18 +6083,56 @@ async function run2(argv = []) {
   }
   return typeof process.exitCode === "number" ? process.exitCode : EXIT.OK;
 }
-var isMainModule = (() => {
-  try {
-    const entry = process.argv[1];
-    if (typeof entry !== "string" || entry.length === 0) return false;
-    return pathToFileURL(realpathSync(entry)).href === import.meta.url;
-  } catch {
-    return false;
+var DEPRECATIONS, program, homeDeps, isMainModule;
+var init_bin = __esm({
+  "src/bin.ts"() {
+    init_context();
+    init_daemon();
+    init_doctor();
+    init_handoff();
+    init_home();
+    init_memory();
+    init_release();
+    init_run();
+    init_skills();
+    init_status();
+    init_task();
+    init_init();
+    init_output();
+    init_run_profiles();
+    init_serve();
+    init_registry();
+    DEPRECATIONS = [];
+    program = createProgram();
+    homeDeps = {
+      dispatch: async (argv) => {
+        const sub = createProgram();
+        try {
+          await sub.parseAsync([...argv], { from: "user" });
+        } catch (err) {
+          handleError(err);
+        }
+      },
+      // The grouped home menu resolves its sections against the LIVE palette
+      // registry (home-consolidation S1/S2) — the same source the TUI palette
+      // uses — so the menu cannot drift from the commander tree.
+      commands: buildPaletteCommands(createProgram())
+    };
+    isMainModule = (() => {
+      try {
+        const entry = process.argv[1];
+        if (typeof entry !== "string" || entry.length === 0) return false;
+        return pathToFileURL(realpathSync(entry)).href === import.meta.url;
+      } catch {
+        return false;
+      }
+    })();
+    if (isMainModule) {
+      void run2(process.argv.slice(2));
+    }
   }
-})();
-if (isMainModule) {
-  void run2(process.argv.slice(2));
-}
+});
+init_bin();
 export {
   DEPRECATIONS,
   EXIT,