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

package/dist/tui/index.js

@@ -1,3446 +1,25 @@
 import {
-  DEFAULT_UPDATE_CONFIG,
-  buildUpdateNotice,
-  runAsyncUpdateCheck
-} from "./chunk-NLK6UNIA.js";
-import "./chunk-QF6777NJ.js";
+  buildPaletteCommandsForTui,
+  describeContext,
+  describeDaemon,
+  describeMemory,
+  describeStore,
+  describeWorkflow,
+  gatherStatusPayload,
+  isDestructive,
+  resolveSections
+} from "./chunk-J77RHAWG.js";
+import "./chunk-2RK6AFZQ.js";
 import {
-  doctor,
-  init
-} from "./chunk-F6XRS72N.js";
-import {
-  EXIT,
-  NoirCliError,
-  accessibleMode,
-  badge,
-  c,
-  contentWidth,
-  definitionList,
-  divider,
-  fail,
-  handleError,
-  info,
-  isInteractive,
-  json,
-  log,
-  requireInteractive,
-  spinner,
-  success,
-  table,
-  tip,
-  useColor,
-  warn
-} from "./chunk-R5YX44UL.js";
-
-// src/tui/index.tsx
-import { loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
-import { render } from "ink";
-
-// 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";
-
-// src/daemon-client.ts
-import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-import { ContextEngine, createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
-import { loadProjectInfo, NOIR_VERSION } from "@noir-ai/core";
-import {
-  ensureDaemonRunning,
-  pidAlive,
-  readDaemonRecord,
-  resolveGateConfig
-} from "@noir-ai/daemon";
-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 {
-    return JSON.stringify(cause);
-  } catch {
-    return String(cause);
-  }
-}
-function failDaemonDown(opts, cause) {
-  if (opts.verbose) {
-    process.stderr.write(`noir: daemon transport detail: ${describeCause(cause)}
-`);
-  }
-  fail(EXIT.DAEMON_DOWN, DAEMON_DOWN_HINT, opts);
-}
-async function probeDaemon(opts = {}) {
-  const rec = readDaemonRecord();
-  if (!rec) {
-    if (opts.verbose) process.stderr.write("noir: daemon probe: no daemon record\n");
-    return { running: false };
-  }
-  if (!pidAlive(rec.pid)) {
-    if (opts.verbose) process.stderr.write(`noir: daemon probe: pid ${rec.pid} not alive
-`);
-    return { running: false };
-  }
-  try {
-    const res = await fetch(`http://127.0.0.1:${rec.port}/health`, {
-      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
-    });
-    if (!res.ok) {
-      if (opts.verbose) process.stderr.write(`noir: daemon probe: /health \u2192 HTTP ${res.status}
-`);
-      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");
-      return { running: false };
-    }
-    return {
-      running: true,
-      pid: typeof body.pid === "number" ? body.pid : rec.pid,
-      port: rec.port,
-      uptimeSec: typeof body.uptimeSec === "number" ? body.uptimeSec : void 0
-    };
-  } catch (err) {
-    if (opts.verbose)
-      process.stderr.write(`noir: daemon probe: unreachable (${describeCause(err)})
-`);
-    return { running: false };
-  }
-}
-async function resolveDaemon(opts) {
-  const project = opts.project ?? loadProjectInfo(process.cwd());
-  const idleTimeoutSec = opts.idleTimeoutSec ?? project.config.daemon.idleTimeoutSec;
-  try {
-    const ensured = await ensureDaemonRunning({ project, idleTimeoutSec });
-    return { url: ensured.url, stop: ensured.stop };
-  } catch (err) {
-    failDaemonDown(opts, err);
-  }
-}
-async function connectClient(client, url, opts) {
-  try {
-    await client.connect(new StreamableHTTPClientTransport(new URL(url)));
-  } catch (err) {
-    failDaemonDown(opts, err);
-  }
-}
-async function callToolParse(client, opts, name, args) {
-  const result = await client.callTool({ name, arguments: args }).catch((err) => failDaemonDown(opts, err));
-  const block = result.content?.[0];
-  if (block?.type !== "text" || typeof block.text !== "string") {
-    failDaemonDown(opts, new Error(`tool '${name}' returned no text content`));
-  }
-  const text = block.text;
-  try {
-    return JSON.parse(text);
-  } catch (err) {
-    failDaemonDown(opts, err);
-  }
-}
-function buildCaller(client, opts) {
-  return {
-    callTool: (name, args = {}) => callToolParse(client, opts, name, args),
-    listTools: async () => {
-      const res = await client.listTools().catch((err) => failDaemonDown(opts, err));
-      const tools = res?.tools;
-      if (!Array.isArray(tools)) return [];
-      const names = [];
-      for (const t of tools) {
-        const name = t?.name;
-        if (typeof name === "string") names.push(name);
-      }
-      return names;
-    }
-  };
-}
-async function withDaemon(opts, fn) {
-  const { url, stop } = await resolveDaemon(opts);
-  let client;
-  try {
-    client = new Client(
-      { name: "noir-cli", version: NOIR_VERSION },
-      { versionNegotiation: { mode: "auto" } }
-    );
-    const connected = client;
-    await connectClient(connected, url, opts);
-    return await fn(buildCaller(connected, opts));
-  } finally {
-    if (client) {
-      await client.close().catch(() => {
-      });
-    }
-    await stop().catch(() => {
-    });
-  }
-}
-async function withRunningDaemon(opts, fn, probe) {
-  const p = probe ?? await probeDaemon(opts);
-  if (!p.running) return null;
-  const url = `http://127.0.0.1:${p.port}/mcp`;
-  let client;
-  try {
-    client = new Client(
-      { name: "noir-cli", version: NOIR_VERSION },
-      { versionNegotiation: { mode: "auto" } }
-    );
-    const connected = client;
-    await connected.connect(new StreamableHTTPClientTransport(new URL(url)));
-    return await fn(buildCaller(connected, opts));
-  } catch {
-    return null;
-  } finally {
-    if (client) {
-      await client.close().catch(() => {
-      });
-    }
-  }
-}
-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 });
-  try {
-    const embedderCfg = resolveEmbedderConfig(project.config.context);
-    const embed = createEmbedFn(embedderCfg).embed;
-    const context = new ContextEngine({
-      store,
-      root: project.root,
-      projectId: project.id,
-      embedderCfg,
-      storeDegraded: true
-    });
-    const memory = createMemoryEngine({
-      store,
-      root: project.root,
-      projectId: project.id,
-      embed,
-      storeDegraded: true
-    });
-    const workflow = new WorkflowEngine(
-      store,
-      project.root,
-      project.id,
-      resolveGateConfig(project.config)
-    );
-    return await fn({ context, memory, workflow });
-  } finally {
-    await store.close().catch(() => {
-    });
-  }
-}
-
-// src/commands/context.ts
-function parseLimit(raw, label, opts) {
-  if (raw === void 0) return void 0;
-  const n = Number(raw);
-  if (!Number.isInteger(n) || n <= 0) {
-    fail(EXIT.USAGE, `${label}: --limit must be a positive integer (got '${raw}')`, opts);
-  }
-  return n;
-}
-function failTool(label, envelope, opts) {
-  const detail = envelope.error ?? envelope.reason ?? "unknown failure";
-  fail(EXIT.ERROR, `${label}: ${detail}`, opts);
-}
-function toHit(raw) {
-  const h = raw ?? {};
-  return {
-    path: typeof h.path === "string" ? h.path : "<unknown>",
-    score: typeof h.score === "number" ? h.score : 0,
-    snippet: typeof h.snippet === "string" ? h.snippet : "",
-    source: typeof h.source === "string" ? h.source : ""
-  };
-}
-async function contextSearch(opts) {
-  const limit = parseLimit(opts.limit, "context search", opts);
-  let probe;
-  try {
-    probe = await probeDaemon(opts);
-  } catch {
-    probe = { running: true };
-  }
-  if (!probe.running) {
-    await withInProcessRead(opts, async (engines) => {
-      const result = await engines.context.search(opts.query, {
-        ...limit === void 0 ? {} : { limit }
-      });
-      const data2 = {
-        query: opts.query,
-        hits: result.results.map((h) => ({
-          path: h.path,
-          score: h.score,
-          snippet: h.snippet,
-          source: h.source
-        })),
-        consumedTokens: result.consumedTokens,
-        truncated: result.truncated,
-        degraded: result.degraded,
-        mode: result.mode
-      };
-      if (opts.json === true) {
-        process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
-`);
-        return;
-      }
-      renderSearch(data2, opts);
-    });
-    return;
-  }
-  const res = await callDaemonTool(opts, "context_search", {
-    query: opts.query,
-    ...limit === void 0 ? {} : { limit }
-  });
-  if (res.ok !== true) failTool("context search", res, opts);
-  const data = {
-    query: opts.query,
-    hits: Array.isArray(res.results) ? res.results.map(toHit) : [],
-    consumedTokens: typeof res.consumedTokens === "number" ? res.consumedTokens : 0,
-    truncated: res.truncated === true,
-    degraded: res.degraded === true,
-    mode: typeof res.mode === "string" ? res.mode : "unknown"
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  renderSearch(data, opts);
-}
-function renderSearch(data, opts) {
-  const flag = data.degraded ? `  ${badge("warn", "degraded: BM25-only")}` : "";
-  const trunc = data.truncated ? " (budget hit \u2014 results truncated)" : "";
-  log(
-    `context search \u2014 ${data.hits.length} hit${data.hits.length === 1 ? "" : "s"} \xB7 ${data.mode} \xB7 ${data.consumedTokens} tokens${flag}${trunc}`,
-    opts
-  );
-  table(
-    data.hits.map((h, i) => ({
-      "#": i + 1,
-      Path: h.path,
-      Score: h.score.toFixed(4),
-      Snippet: h.snippet
-    })),
-    ["#", "Path", "Score", "Snippet"],
-    opts
-  );
-}
-async function contextIndex(opts) {
-  const args = opts.paths && opts.paths.length > 0 ? { paths: opts.paths } : {};
-  if (opts.force === true) args.force = true;
-  const res = await callDaemonTool(opts, "context_index", args);
-  if (res.ok !== true) failTool("context index", res, opts);
-  const data = {
-    indexed: typeof res.indexed === "number" ? res.indexed : 0,
-    skipped: typeof res.skipped === "number" ? res.skipped : 0,
-    deleted: typeof res.deleted === "number" ? res.deleted : 0,
-    failed: typeof res.failed === "number" ? res.failed : 0,
-    totalChunks: typeof res.totalChunks === "number" ? res.totalChunks : 0,
-    degraded: res.degraded === true
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  renderIndex(data, opts.paths, opts);
-}
-function renderIndex(data, paths, opts) {
-  const scope = paths && paths.length > 0 ? paths.join(", ") : ".";
-  const flag = data.degraded ? `  ${badge("warn", "degraded: vectors skipped")}` : "";
-  log(`context index \u2014 ${scope}${flag}`, opts);
-  definitionList(
-    [
-      { label: "Indexed (new)", value: data.indexed },
-      { label: "Skipped (unchanged)", value: data.skipped },
-      { label: "Deleted (removed)", value: data.deleted },
-      { label: "Failed", value: data.failed },
-      { label: "Total chunks", value: data.totalChunks }
-    ],
-    opts
-  );
-  if (data.failed > 0) {
-    info(`${data.failed} file(s) could not be indexed (binary / IO / encoding).`, opts);
-  }
-}
-async function contextStatus(opts) {
-  const res = await callDaemonTool(opts, "context_status");
-  if (res.ok !== true) failTool("context status", res, opts);
-  const data = res;
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  renderStatus(data, opts);
-}
-function describeEmbedder(e) {
-  if (!e || e.kind === "none") return "none (BM25-only)";
-  const model = typeof e.model === "string" && e.model.length > 0 ? e.model : "<unset>";
-  return `${e.kind} \xB7 ${model} (${e.dim}-dim)`;
-}
-function renderStatus(data, opts) {
-  const flag = data.degraded ? `  ${badge("warn", "degraded")}` : "";
-  log(`context status \u2014 ${data.projectId}${flag}`, opts);
-  definitionList(
-    [
-      { label: "Project", value: data.projectId },
-      { label: "Docs", value: data.docCount },
-      { label: "Vectors", value: data.vecCount },
-      { label: "Indexed files", value: data.indexedFiles },
-      { label: "Embedder", value: describeEmbedder(data.embedder) },
-      { label: "Degraded", value: data.degraded ? "yes" : "no" }
-    ],
-    opts
-  );
-}
-
-// src/commands/daemon.ts
-import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
-import {
-  clearDaemonRecord,
-  ensureDaemonRunning as ensureDaemonRunning2,
-  pidAlive as pidAlive2,
-  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) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/health`);
-    return res.status === 200;
-  } catch {
-    return false;
-  }
-}
-async function daemonStart(opts) {
-  const project = loadProjectInfo2(process.cwd());
-  if (opts.detachChild === true) {
-    const child = await ensureDaemonRunning2({
-      project,
-      idleTimeoutSec: project.config.daemon.idleTimeoutSec
-    });
-    if (child.started) {
-      if (opts.json === true) {
-        process.stdout.write(`${JSON.stringify({ ok: true, data: { mode: "detached" } })}
-`);
-        return;
-      }
-      info("noir daemon: detached foreground. Ctrl+C to stop.", opts);
-      log(`Noir daemon listening at ${child.url}`, opts);
-      return;
-    }
-    if (opts.json === true) {
-      process.stdout.write(
-        `${JSON.stringify({ ok: true, data: { mode: "detached", reused: true } })}
-`
-      );
-      return;
-    }
-    info("Noir daemon already running; detached child exiting.", opts);
-    return;
-  }
-  if (opts.detach === true) {
-    const existing = readDaemonRecord2();
-    if (existing && pidAlive2(existing.pid) && await isHealthy(existing.port)) {
-      if (opts.json === true) {
-        process.stdout.write(
-          `${JSON.stringify({ ok: true, data: { mode: "detached", reused: true } })}
-`
-        );
-        return;
-      }
-      info(
-        `Noir daemon already running at http://127.0.0.1:${existing.port}/mcp (detach not needed).`,
-        opts
-      );
-      return;
-    }
-    const spawned = await spawnDetachedDaemon({ project });
-    if (opts.json === true) {
-      process.stdout.write(
-        `${JSON.stringify({ ok: true, data: { mode: "detached", pid: spawned.pid, port: spawned.port } })}
-`
-      );
-      return;
-    }
-    info(`Noir daemon started in the background (pid ${spawned.pid}, port ${spawned.port}).`, opts);
-    return;
-  }
-  const ds = spinner("Starting Noir daemon...", opts).start();
-  const ensured = await ensureDaemonRunning2({
-    project,
-    idleTimeoutSec: project.config.daemon.idleTimeoutSec
-  });
-  if (ensured.started) {
-    ds.succeed("Daemon started");
-    if (opts.json === true) {
-      process.stdout.write(
-        `${JSON.stringify({
-          ok: true,
-          data: {
-            url: ensured.url,
-            port: ensured.port,
-            pid: process.pid,
-            mode: MODE,
-            reused: false
-          }
-        })}
-`
-      );
-      return;
-    }
-    info("noir daemon: foreground mode. Ctrl+C to stop.", opts);
-    log(`Noir daemon listening at ${ensured.url}`, opts);
-    return;
-  }
-  ds.succeed("Daemon already running");
-  if (opts.json === true) {
-    process.stdout.write(
-      `${JSON.stringify({ ok: true, data: { url: ensured.url, port: ensured.port, reused: true } })}
-`
-    );
-    return;
-  }
-  log(`Noir daemon already running at ${ensured.url}`, opts);
-}
-async function daemonStop(opts) {
-  const rec = readDaemonRecord2();
-  if (!rec) {
-    if (opts.json === true) {
-      process.stdout.write(
-        `${JSON.stringify({ ok: true, data: { running: false, stopped: false } })}
-`
-      );
-      return;
-    }
-    info("No Noir daemon is running.", opts);
-    return;
-  }
-  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();
-  }
-  if (opts.json === true) {
-    process.stdout.write(
-      `${JSON.stringify({
-        ok: true,
-        data: {
-          running: signalled,
-          stopped: signalled,
-          pid: rec.pid,
-          ...errMsg !== void 0 ? { error: errMsg } : {}
-        }
-      })}
-`
-    );
-    return;
-  }
-  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);
-  }
-}
-async function daemonStatus(opts) {
-  const rec = readDaemonRecord2();
-  if (!rec) {
-    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (start with `noir daemon start`).", opts);
-  }
-  if (!pidAlive2(rec.pid)) {
-    clearDaemonRecord();
-    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", 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`);
-    if (res.status === 200) {
-      health = await res.json();
-    }
-  } catch {
-    health = null;
-  }
-  if (health?.ok !== true) {
-    hs.fail("Daemon not responding");
-    clearDaemonRecord();
-    fail(
-      EXIT.DAEMON_DOWN,
-      "Noir daemon is not running (port unresponsive; stale record removed).",
-      opts
-    );
-  }
-  hs.succeed("Daemon healthy");
-  const uptimeSec = typeof health?.uptimeSec === "number" ? health.uptimeSec : Math.max(0, Math.floor((Date.now() - rec.startedAt) / 1e3));
-  const data = {
-    running: true,
-    pid: rec.pid,
-    port: rec.port,
-    startedAt: rec.startedAt,
-    uptimeSec,
-    // Honest ownership: the detached child writes `mode:'detached'`; anything
-    // else (legacy record, foreground start) reports 'foreground'.
-    mode: rec.mode ?? MODE
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(
-    `Noir daemon: running (pid ${data.pid}, port ${data.port}, up ${formatUptime(uptimeSec)}, ${data.mode})`,
-    opts
-  );
-}
-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";
-
-// src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo3, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
-async function tryTool(caller, name, args) {
-  try {
-    return await caller.callTool(name, args);
-  } catch {
-    return null;
-  }
-}
-function pickStore(s) {
-  if (s?.ok !== true) return null;
-  return {
-    docCount: s.docCount,
-    vecCount: s.vecCount,
-    dbPath: s.dbPath,
-    degraded: s.degraded === true
-  };
-}
-function describeEmbedder2(e) {
-  if (!e || e.kind === "none") return "none (BM25-only)";
-  const model = typeof e.model === "string" && e.model.length > 0 ? e.model : "<unset>";
-  return `${e.kind} \xB7 ${model} (${e.dim}-dim)`;
-}
-function pickContext(c2) {
-  if (c2?.ok !== true) return null;
-  return {
-    docCount: c2.docCount,
-    vecCount: c2.vecCount,
-    indexedFiles: c2.indexedFiles,
-    embedder: describeEmbedder2(c2.embedder),
-    degraded: c2.degraded === true
-  };
-}
-function pickWorkflow(w) {
-  if (w?.ok !== true) return null;
-  return {
-    taskId: w.taskId,
-    phase: w.phase,
-    state: w.state,
-    mode: w.mode,
-    nextGate: w.nextGate,
-    degraded: w.degraded === true
-  };
-}
-function pickMemory(m) {
-  if (m?.ok !== true || !Array.isArray(m.sessions)) return null;
-  let observations = 0;
-  for (const s of m.sessions) observations += s.count;
-  return { sessions: m.sessions.length, observations };
-}
-function buildPayload(project, probe, host, store, context, workflow, memory) {
-  return {
-    noir: NOIR_VERSION2,
-    project: { id: project.id, name: project.name },
-    host: project.config.host,
-    daemon: {
-      running: probe.running,
-      ...probe.pid !== void 0 ? { pid: probe.pid } : {},
-      ...probe.uptimeSec !== void 0 ? { uptimeSec: probe.uptimeSec } : {},
-      ...host && typeof host.transport === "string" ? { transport: host.transport } : {}
-    },
-    store: pickStore(store),
-    context: pickContext(context),
-    workflow: pickWorkflow(workflow),
-    memory: pickMemory(memory)
-  };
-}
-function formatDuration(sec) {
-  if (typeof sec !== "number" || 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 describeDaemon(d) {
-  if (!d.running) return "not running (start with `noir daemon start`)";
-  const pid = typeof d.pid === "number" ? `pid ${d.pid}` : "pid unknown";
-  const up = typeof d.uptimeSec === "number" ? `, up ${formatDuration(d.uptimeSec)}` : "";
-  const transport = typeof d.transport === "string" ? `, ${d.transport}` : "";
-  return `running (${pid}${up}${transport})`;
-}
-function describeStore(s) {
-  if (!s) return "unavailable (store engine not wired)";
-  const flag = s.degraded ? `  ${badge("warn", "degraded: read-only")}` : "";
-  return `${s.docCount} docs / ${s.vecCount} vecs${flag}`;
-}
-function describeContext(c2) {
-  if (!c2) return "unavailable (context engine not wired)";
-  const flag = c2.degraded ? `  ${badge("warn", "degraded")}` : "";
-  return `${c2.docCount} docs, ${c2.vecCount} vecs, ${c2.indexedFiles} files \xB7 embedder ${c2.embedder}${flag}`;
-}
-function describeWorkflow(w) {
-  if (!w) return "no active task";
-  const gate = w.nextGate ? ` \u2192 next gate: ${w.nextGate}` : "";
-  const flag = w.degraded ? `  ${badge("warn", "degraded")}` : "";
-  return `${w.phase} (${w.state}, ${w.mode}) \xB7 task ${w.taskId}${gate}${flag}`;
-}
-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) {
-  log(`noir status \u2014 ${p.project.name} (${p.project.id})`, opts);
-  definitionList(
-    [
-      { label: "Project", value: `${p.project.name} (${p.project.id})` },
-      { label: "Host", value: p.host },
-      { label: "Noir", value: p.noir },
-      { label: "Daemon", value: describeDaemon(p.daemon) },
-      { label: "Store", value: describeStore(p.store) },
-      { label: "Context", value: describeContext(p.context) },
-      { label: "Workflow", value: describeWorkflow(p.workflow) },
-      { label: "Memory", value: describeMemory(p.memory) }
-    ],
-    opts
-  );
-  if (p.workflow && p.workflow.state !== "done" && p.workflow.state !== "abandoned") {
-    tip("resume: `noir task resume`", opts);
-  }
-}
-async function gatherStatusPayload(opts) {
-  const project = loadProjectInfo3(process.cwd());
-  const probe = await probeDaemon(opts);
-  let host = null;
-  let store = null;
-  let context = null;
-  let workflow = null;
-  let memory = null;
-  if (probe.running) {
-    await withRunningDaemon(
-      opts,
-      async (caller) => {
-        host = await tryTool(caller, "host_status");
-        store = await tryTool(caller, "store_status");
-        context = await tryTool(caller, "context_status");
-        workflow = await tryTool(caller, "workflow_status");
-        memory = await tryTool(caller, "memory_sessions");
-      },
-      probe
-    );
-  }
-  return buildPayload(project, probe, host, store, context, workflow, memory);
-}
-async function status(opts) {
-  void runAsyncUpdateCheck({
-    env: process.env,
-    configUpdate: (() => {
-      try {
-        const info2 = loadProjectInfo3(process.cwd());
-        return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
-      } catch {
-        return DEFAULT_UPDATE_CONFIG;
-      }
-    })(),
-    quiet: opts.json === true || opts.quiet === true || !process.stdout.isTTY
-  });
-  const payload = await gatherStatusPayload(opts);
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: payload })}
-`);
-    return;
-  }
-  renderHuman(payload, opts);
-}
-
-// src/commands/task.ts
-import { spawnSync } from "child_process";
-import { createHash } from "crypto";
-import { loadProjectInfo as loadProjectInfo4, nextArtifactSequence } 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 conflict = { conflictPolicy: "preserve", interactive: false };
-    writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
-    const nextN = nextArtifactSequence(project.root, "adr");
-    writeDecisionStub(project.root, nextN, taskId, void 0, conflict);
-  } catch {
-    tip("document-phase artifacts could not be written (use --no-artifacts to skip)", opts);
-  }
-}
-async function fetchStatus(opts, taskId) {
-  const args = typeof taskId === "string" && taskId.length > 0 ? { taskId } : {};
-  const res = await callDaemonTool(
-    opts,
-    "workflow_status",
-    args
-  );
-  if (res.ok === true) return res;
-  const detail = res.error ?? "task not found";
-  fail(EXIT.NOT_FOUND, `task: ${detail}`, opts);
-}
-function formatStamp(ms) {
-  if (typeof ms !== "number" || ms <= 0) return "-";
-  return new Date(ms).toISOString().replace("T", " ").replace(/\..*$/, "Z");
-}
-function renderStatusRow(s, opts) {
-  const flag = s.degraded === true ? `  ${badge("warn", "degraded")}` : "";
-  log(`task status \u2014 ${s.taskId}${flag}`, opts);
-  const rows = [
-    { label: "Task", value: s.taskId },
-    { label: "Phase", value: s.phase },
-    { label: "State", value: s.state },
-    { label: "Mode", value: s.mode }
-  ];
-  if (typeof s.taskClass === "string" && s.taskClass.length > 0) {
-    rows.push({ label: "Class", value: s.taskClass });
-  }
-  if (typeof s.blockReason === "string" && s.blockReason.length > 0) {
-    rows.push({ label: "Block reason", value: s.blockReason });
-  }
-  rows.push(
-    { label: "Next gate", value: s.nextGate ?? "\u2014" },
-    { label: "Updated", value: formatStamp(s.updatedAt) }
-  );
-  definitionList(rows, opts);
-}
-var GATE_PHASES = ["spec", "plan", "verify"];
-function nextGateAfter(phase) {
-  const cur = PHASES.indexOf(phase);
-  for (const p of GATE_PHASES) {
-    if (PHASES.indexOf(p) > cur) return p;
-  }
-  return null;
-}
-async function taskStatus(opts) {
-  let probe;
-  try {
-    probe = await probeDaemon(opts);
-  } catch {
-    probe = { running: true };
-  }
-  if (!probe.running) {
-    const s2 = await withInProcessRead(opts, async (engines) => {
-      const id = typeof opts.id === "string" && opts.id.length > 0 ? opts.id : null;
-      const taskId = id ?? engines.workflow.activeTaskId();
-      if (!taskId) fail(EXIT.NOT_FOUND, "task: no active task", opts);
-      const task = engines.workflow.status(taskId);
-      if (!task) fail(EXIT.NOT_FOUND, `task: unknown task '${taskId}'`, opts);
-      const stopped = task.state === "blocked" || task.state === "abandoned";
-      return {
-        ok: true,
-        taskId: task.taskId,
-        phase: task.phase,
-        state: task.state,
-        mode: task.mode,
-        nextGate: stopped ? null : nextGateAfter(task.phase),
-        history: task.history,
-        updatedAt: task.updatedAt,
-        degraded: true
-      };
-    });
-    if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: true, data: s2 })}
-`);
-      return;
-    }
-    renderStatusRow(s2, opts);
-    return;
-  }
-  const s = await fetchStatus(opts, opts.id);
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: s })}
-`);
-    return;
-  }
-  renderStatusRow(s, opts);
-}
-async function taskNext(opts) {
-  const s = await fetchStatus(opts);
-  const suggestion = skillFor(s.phase);
-  const nextSkill = skillFor(s.nextGate);
-  const data = {
-    taskId: s.taskId,
-    phase: s.phase,
-    state: s.state,
-    mode: s.mode,
-    nextGate: s.nextGate,
-    suggestion,
-    nextSkill,
-    degraded: s.degraded === true
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  const flag = data.degraded ? `  ${badge("warn", "degraded")}` : "";
-  log(`task next \u2014 ${s.taskId} \xB7 phase ${s.phase} (${s.state}, ${s.mode})${flag}`, opts);
-  if (s.nextGate) {
-    info(`next gate: ${s.nextGate}`, opts);
-  } else {
-    info("no further gate ahead (past verify, or stopped).", opts);
-  }
-  if (suggestion) info(`skill for current phase (${s.phase}): ${suggestion}`, opts);
-  if (nextSkill) info(`skill for next gate (${s.nextGate}): ${nextSkill}`, opts);
-  if (!suggestion && !nextSkill) {
-    info("run `noir skills list` to see applicable skills.", opts);
-  }
-}
-async function taskNew(opts) {
-  let mode;
-  if (opts.mode !== void 0) {
-    if (opts.mode !== "full" && opts.mode !== "quick") {
-      fail(EXIT.USAGE, `task new: invalid mode '${opts.mode}' (expected 'full' or 'quick')`, opts);
-    }
-    mode = opts.mode;
-  }
-  let taskClass;
-  if (opts.taskClass !== void 0) {
-    if (!TASK_CLASSES.includes(opts.taskClass)) {
-      fail(
-        EXIT.USAGE,
-        `task new: invalid class '${opts.taskClass}' (expected one of: ${TASK_CLASSES.join(", ")})`,
-        opts
-      );
-    }
-    taskClass = opts.taskClass;
-  }
-  const res = await callDaemonTool(
-    opts,
-    "workflow_start",
-    {
-      taskId: opts.slug,
-      slug: opts.slug,
-      ...mode === void 0 ? {} : { mode },
-      ...taskClass === void 0 ? {} : { taskClass }
-    }
-  );
-  if (res.ok !== true) {
-    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "start failed";
-    fail(EXIT.ERROR, `task new --slug ${opts.slug}: ${detail}`, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  renderStatusRow(res, opts);
-}
-async function taskAdvance(opts) {
-  const args = {};
-  if (typeof opts.to === "string" && opts.to.length > 0) {
-    if (!Object.keys(PHASE_SKILL).includes(opts.to)) {
-      fail(EXIT.USAGE, `task advance: invalid phase '${opts.to}'`, opts);
-    }
-    args.to = opts.to;
-  }
-  if (typeof opts.force === "string" && opts.force.length > 0) {
-    args.force = { reason: opts.force };
-  }
-  const res = await callDaemonTool(
-    opts,
-    "workflow_advance",
-    args
-  );
-  if (res.ok !== true) {
-    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "advance failed";
-    fail(EXIT.ERROR, `task advance: ${detail}`, opts);
-  }
-  if (res.state === "done" && opts.noArtifacts !== true) {
-    writeDoneArtifacts(opts, res.taskId);
-  }
-  if (typeof opts.to === "string" && opts.to === "verify") {
-    tip("run `noir handoff` for a ready-to-paste host prompt", opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  renderStatusRow(res, opts);
-}
-function renderResumeBriefing(r, opts) {
-  const flag = r.degraded === true ? `  ${badge("warn", "degraded")}` : "";
-  log(`resume \u2014 ${r.taskId} (${r.state}, ${r.mode})${flag}`, opts);
-  const rows = [
-    { label: "Task", value: String(r.taskId) },
-    { label: "Phase", value: String(r.phase) },
-    { label: "State", value: String(r.state) },
-    { label: "Mode", value: String(r.mode) }
-  ];
-  if (typeof r.taskClass === "string" && r.taskClass.length > 0) {
-    rows.push({ label: "Class", value: r.taskClass });
-  }
-  if (typeof r.blockReason === "string" && r.blockReason.length > 0) {
-    rows.push({ label: "Block reason", value: r.blockReason });
-  }
-  rows.push({ label: "Next gate", value: r.nextGate ?? "\u2014" });
-  definitionList(rows, opts);
-  const suggestion = skillFor(r.phase ?? null);
-  if (suggestion) info(`skill for current phase (${r.phase}): ${suggestion}`, opts);
-  if (r.state === "blocked") {
-    info("resume a blocked task with: noir task advance --to <phase>", opts);
-  }
-}
-async function taskResume(opts) {
-  const args = {};
-  if (typeof opts.id === "string" && opts.id.length > 0) {
-    args.taskId = opts.id;
-  }
-  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) {
-    info(`resume prompt: ${opts.prompt}`, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  renderResumeBriefing(res, opts);
-}
-async function taskBlock(opts) {
-  if (typeof opts.reason !== "string" || opts.reason.trim().length === 0) {
-    fail(EXIT.USAGE, "task block: a non-empty <reason> is required", opts);
-  }
-  const args = { reason: opts.reason };
-  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
-  const res = await callDaemonTool(
-    opts,
-    "workflow_block",
-    args
-  );
-  if (res.ok !== true) {
-    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "block failed";
-    fail(EXIT.ERROR, `task block: ${detail}`, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  renderStatusRow(res, opts);
-}
-async function taskAbandon(opts) {
-  if (isInteractive(opts)) {
-    const clack = await import("@clack/prompts");
-    const confirm = await clack.confirm({
-      message: "Abandon this task? This is terminal and cannot be undone.",
-      initialValue: false
-    });
-    if (clack.isCancel(confirm)) {
-      clack.cancel("Cancelled.");
-      fail(EXIT.CANCELLED, "cancelled", opts);
-    }
-    if (confirm !== true) {
-      fail(EXIT.CANCELLED, "abandon cancelled", opts);
-    }
-  }
-  const args = {};
-  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
-  const res = await callDaemonTool(
-    opts,
-    "workflow_abandon",
-    args
-  );
-  if (res.ok !== true) {
-    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "abandon failed";
-    fail(EXIT.ERROR, `task abandon: ${detail}`, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  renderStatusRow(res, opts);
-}
-function runCheck(cmd) {
-  try {
-    const buf = spawnSync("sh", ["-c", cmd], {
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8"
-    });
-    let out = "";
-    if (buf.stdout) out += buf.stdout.toString();
-    if (buf.stderr) out += buf.stderr.toString();
-    const status2 = buf.status;
-    return {
-      exitCode: typeof status2 === "number" ? status2 : 1,
-      digest: createHash("sha256").update(out).digest("hex")
-    };
-  } catch {
-    return { exitCode: 1, digest: createHash("sha256").update("").digest("hex") };
-  }
-}
-async function taskVerify(opts) {
-  const project = loadProjectInfo4(process.cwd());
-  const cfgChecks = project.config.workflow?.gate?.verify?.checks ?? [];
-  const all = cfgChecks.map((c2) => ({
-    name: c2.name,
-    command: c2.command,
-    tier: c2.tier ?? "hard"
-  }));
-  let checks = all;
-  if (opts.check && opts.check.length > 0) {
-    const want = new Set(opts.check);
-    checks = all.filter((c2) => want.has(c2.name));
-    if (checks.length === 0) {
-      fail(
-        EXIT.USAGE,
-        `task verify: no configured checks match --check ${[...want].join(",")}`,
-        opts
-      );
-    }
-  }
-  if (checks.length === 0) {
-    fail(
-      EXIT.USAGE,
-      "task verify: no verify checks configured (set workflow.gate.verify.checks in noir.config)",
-      opts
-    );
-  }
-  const ranAt = Date.now();
-  const evidence = {
-    ranAt,
-    checks: checks.map((c2) => {
-      const r = runCheck(c2.command);
-      return {
-        name: c2.name,
-        exitCode: r.exitCode,
-        outputDigest: r.digest,
-        command: c2.command,
-        tier: c2.tier
-      };
-    }),
-    summary: ""
-  };
-  const passed = evidence.checks.filter((c2) => c2.exitCode === 0).length;
-  const failed = evidence.checks.length - passed;
-  evidence.summary = `${passed} passed, ${failed} failed`;
-  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 })}
-`);
-      return;
-    }
-    success(`verify \u2014 ${evidence.summary} \u2192 gate approved`, opts);
-    renderStatusRow(res, opts);
-    return;
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ evidence, ...res })}
-`);
-    return;
-  }
-  if (res.pendingGate) {
-    warn(`verify gate: ${res.pendingGate.reason} (${evidence.summary})`, opts);
-    const recovery = res.recovery ?? ["retry", "force", "skip", "block"];
-    info(
-      `recovery: ${recovery.map(
-        (r) => r === "retry" ? "`noir task verify`" : r === "force" ? "`noir task advance --force <reason>`" : r === "skip" ? "`noir task advance --skip`" : r === "block" ? "`noir task block <reason>`" : `\`${r}\``
-      ).join(" | ")}`,
-      opts
-    );
-  } else {
-    fail(EXIT.ERROR, `task verify: ${res.error ?? "verify failed"}`, opts);
-  }
-}
-async function taskResearch(opts) {
-  const s = await fetchStatus(opts, opts.id);
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: s })}
-`);
-    return;
-  }
-  renderStatusRow(s, opts);
-  info("research findings are recorded via `noir task research record` (list + record)", opts);
-}
-async function taskResearchRecord(opts) {
-  const TYPES = ["assumption", "discovery", "decision", "grounding-fact"];
-  if (!TYPES.includes(opts.type)) {
-    fail(
-      EXIT.USAGE,
-      `task research record: invalid type '${opts.type}' (expected one of: ${TYPES.join(", ")})`,
-      opts
-    );
-  }
-  const args = { type: opts.type, text: opts.text };
-  if (typeof opts.source === "string" && opts.source.length > 0) args.source = opts.source;
-  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
-  const res = await callDaemonTool(opts, "workflow_research_record", args);
-  if (res.ok !== true) {
-    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "record failed";
-    fail(EXIT.ERROR, `task research record: ${detail}`, opts);
-  }
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
-`);
-    return;
-  }
-  success(
-    `research recorded \u2192 ${opts.type}: ${opts.text.slice(0, 80)}${opts.text.length > 80 ? "\u2026" : ""}`,
-    opts
-  );
-}
-async function taskDecompose(opts) {
-  const cap = opts.capability.trim();
-  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)`,
-    slices: [
-      {
-        id: "s1-walking-skeleton",
-        title: "Walking skeleton \u2014 thinnest end-to-end",
-        type: "feature",
-        rationale: `The first slice for capability ${cap}.`,
-        scopeIn: "End-to-end path linking the main architecture.",
-        scopeOut: "Polish, edge cases, full coverage.",
-        dependsOn: [],
-        files: { create: [], modify: [], preserve: [] },
-        acceptance: [`verify acceptance criteria for capability ${cap}`],
-        doD: ["pnpm test", "pnpm typecheck"],
-        rollbackPlan: { procedure: "revert the slice commit", verifyCommand: "pnpm test" }
-      }
-    ],
-    status: { "s1-walking-skeleton": "planned" }
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data: plan })}
-`);
-    return;
-  }
-  log(`decompose \u2014 ${cap}`, opts);
-  for (const s of plan.slices) {
-    info(`${s.id}: ${s.title} (${s.type}) \u2014 rationale: ${s.rationale}`, opts);
-  }
-  tip("each piece enters the existing clarify\u2192spec\u2192plan\u2192execute\u2192verify\u2192document workflow", opts);
-}
-
-// src/commands/handoff.ts
-var SEED_LIMIT = 5;
-function heading(name, id) {
-  return `# Noir handoff \u2014 ${name} (${id})`;
-}
-function renderMarkdown(p) {
-  const lines = [];
-  lines.push(heading(p.project.name, p.project.id));
-  lines.push("");
-  if (p.task) {
-    const gate = p.task.nextGate ?? "\u2014";
-    lines.push(`**Phase:** ${p.task.phase} \u2014 next gate: ${gate}`);
-  } else {
-    lines.push("**Phase:** no active task");
-  }
-  lines.push("");
-  lines.push("## Open host");
-  lines.push(p.directive);
-  lines.push("");
-  lines.push("## Next step");
-  if (p.task?.nextSkill) {
-    lines.push(`Run \`${p.task.nextSkill}\` \u2014 the host's next gate skill.`);
-  } else {
-    lines.push("No further gate ahead (past verify, or no active task).");
-  }
-  lines.push("");
-  lines.push("## Extracted context (seed)");
-  if (p.contextSeed && p.contextSeed.length > 0) {
-    for (const h of p.contextSeed) {
-      lines.push(`- \`${h.path}\` (score ${h.score.toFixed(4)})`);
-      const snip = h.snippet.trim();
-      if (snip.length > 0) lines.push(`  > ${snip.replace(/\n/g, "\n  > ")}`);
-    }
-  } else if (p.degraded.embedderMissing) {
-    lines.push(
-      "_Embedder unavailable \u2014 degraded to BM25-only or no hits. Start `noir daemon start` for live context._"
-    );
-  } else {
-    lines.push("_No context hits (or daemon down). Start `noir daemon start` for live context._");
-  }
-  lines.push("");
-  lines.push("## Extracted memory (seed)");
-  if (p.memorySeed && p.memorySeed.length > 0) {
-    for (const m of p.memorySeed) {
-      lines.push(`- \`${m.id}\` \u2014 ${m.summary}`);
-    }
-  } else {
-    lines.push(
-      "_No memory observations (or daemon down). Start `noir daemon start` for live memory._"
-    );
-  }
-  lines.push("");
-  lines.push("## Live data \u2014 call these from the host (already wired via the host MCP config)");
-  lines.push("- `noir.workflow_status` \xB7 `noir.context_search` \xB7 `noir.memory_recall`");
-  if (p.degraded.daemonDown) {
-    lines.push("");
-    lines.push("> **Note:** daemon not running \u2014 start `noir daemon start` for live task/memory.");
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function toContextHit(raw) {
-  const h = raw ?? {};
-  return {
-    path: typeof h.path === "string" ? h.path : "<unknown>",
-    score: typeof h.score === "number" ? h.score : 0,
-    snippet: typeof h.snippet === "string" ? h.snippet : ""
-  };
-}
-function observationSummary(raw) {
-  const obs = raw.observation;
-  if (obs && typeof obs === "object") {
-    const content = obs.content;
-    if (typeof content === "string" && content.length > 0) {
-      return content.length > 160 ? `${content.slice(0, 157)}\u2026` : content;
-    }
-    const type = obs.type;
-    if (typeof type === "string") return `(${type})`;
-  }
-  return "";
-}
-function toMemoryHit(raw) {
-  const h = raw ?? {};
-  return {
-    id: typeof h.id === "string" ? h.id : "<unknown>",
-    summary: observationSummary(h)
-  };
-}
-function toHostPayload(p) {
-  return {
-    project: p.project,
-    host: p.host,
-    task: p.task
-  };
-}
-function resolveDirective(root, p) {
-  const ctx = { root };
-  const adapter = resolveAdapter(p.host);
-  const hostPayload = toHostPayload(p);
-  if (typeof adapter.emitHandoff === "function") {
-    return adapter.emitHandoff(ctx, hostPayload);
-  }
-  return defaultHandoffBlock(ctx, hostPayload);
-}
-function handoffFilePath(root, taskId, projectId) {
-  const id = typeof taskId === "string" && taskId.length > 0 ? taskId : projectId;
-  return resolveArtifactPath(root, "handoff", { taskId: id });
-}
-async function extractSeeds(opts, probe, query) {
-  if (!probe.running) return { context: null, memory: null };
-  let context = null;
-  let memory = null;
-  await withRunningDaemon(
-    opts,
-    async (caller) => {
-      const ctxRes = await tryTool(caller, "context_search", {
-        query,
-        limit: SEED_LIMIT
-      });
-      if (ctxRes && ctxRes.ok !== false && Array.isArray(ctxRes.results)) {
-        context = ctxRes.results.slice(0, SEED_LIMIT).map(toContextHit).filter((h) => h.path !== "<unknown>" || h.snippet.length > 0);
-      }
-      const memRes = await tryTool(caller, "memory_recall", {
-        query,
-        limit: SEED_LIMIT
-      });
-      if (memRes && memRes.ok !== false && Array.isArray(memRes.results)) {
-        memory = memRes.results.slice(0, SEED_LIMIT).map(toMemoryHit).filter((h) => h.summary.length > 0);
-      }
-    },
-    probe
-  );
-  return { context, memory };
-}
-async function probeOnly(opts) {
-  return probeDaemon(opts);
-}
-async function handoff(opts) {
-  const project = loadProjectInfo5(process.cwd());
-  const host = project.config.host;
-  const snapshot = await gatherStatusPayload(opts);
-  const probe = await probeOnly(opts);
-  const task = snapshot.workflow ? {
-    taskId: snapshot.workflow.taskId,
-    phase: snapshot.workflow.phase,
-    nextGate: snapshot.workflow.nextGate,
-    nextSkill: skillFor(snapshot.workflow.nextGate) ?? skillFor(snapshot.workflow.phase)
-  } : null;
-  const query = task?.taskId ?? project.name;
-  const { context, memory } = await extractSeeds(opts, probe, query);
-  const full = {
-    project: { id: project.id, name: project.name },
-    host,
-    directive: "",
-    // filled after the host payload is assembled (below)
-    task,
-    contextSeed: context,
-    memorySeed: memory,
-    degraded: {
-      daemonDown: !probe.running,
-      embedderMissing: context === null && probe.running
-    }
-  };
-  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 path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync(join(project.root, NOIR_DIR, "handoff"), { recursive: true });
-    writeFileSync(path, md, "utf8");
-    info(`handoff written to ${path}`, opts);
-    return;
-  }
-  process.stdout.write(md);
-}
-
-// 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";
-
-// 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();
-  if (width < 50) {
-    return colorOn ? `${c.accent("\u25C6")} noir` : "\u25C6 noir";
-  }
-  const block = NOIR_BLOCK.join("\n");
-  if (!colorOn) return block;
-  if (accessibleMode()) {
-    return block.split("\n").map((line) => c.accent(line)).join("\n");
-  }
-  return NOIR_GRADIENT.multiline(block);
-}
-function shouldShowBanner(opts) {
-  if (opts.quiet === true || opts.json === true) return false;
-  const v = process.env.NOIR_NO_BANNER;
-  if (v !== void 0 && v !== "") return false;
-  return true;
-}
-
-// 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;
-    return prefix.every((tok, i) => argv[i] === tok);
-  });
-}
-function capitalizeFirst(s) {
-  if (s.length === 0) return s;
-  return `${s[0]?.toUpperCase() ?? ""}${s.slice(1)}`;
-}
-function hasAction(cmd) {
-  return cmd._actionHandler != null;
-}
-function collectLeaves(cmd, path, out) {
-  const children = cmd.commands;
-  const isLeaf = hasAction(cmd) && children.length === 0;
-  if (isLeaf) {
-    const argv = path;
-    const id = argv.join(" ");
-    const description = cmd.description() || argv.join(" ");
-    out.push({
-      id,
-      label: argv.map(capitalizeFirst).join(": "),
-      argv,
-      description,
-      category: argv[0] ?? "",
-      keywords: argv,
-      destructive: isDestructive(argv)
-    });
-    return;
-  }
-  for (const child of children) {
-    collectLeaves(child, [...path, child.name()], out);
-  }
-}
-function buildPaletteCommands(program2) {
-  const out = [];
-  collectLeaves(program2, [], out);
-  return out;
-}
-
-// 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 = [];
-  for (const section of HOME_SECTIONS) {
-    const items = [];
-    for (const action of section.items) {
-      const entry = byId.get(action.id);
-      if (!entry) continue;
-      items.push({
-        ...action,
-        // Resolve the dispatch argv from the registry (never hand-written).
-        dispatch: action.dispatch ?? [...entry.argv]
-      });
-    }
-    if (items.length === 0) continue;
-    out.push({ ...section, items });
-  }
-  return out;
-}
-
-// src/commands/home.ts
-function tryProject() {
-  try {
-    const info2 = loadProjectInfo6(process.cwd());
-    return { id: info2.id, name: info2.name, host: info2.config.host };
-  } catch {
-    return null;
-  }
-}
-function shouldShowMigrationBanner(rec, currentVersion) {
-  if (rec.method === "native") return false;
-  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);
-    return;
-  }
-  if (opts.json === true) {
-    await deps.dispatch(["status", "--json"]);
-    return;
-  }
-  await deps.dispatch(["status"]);
-}
-async function pickSection(clack, sections, opts) {
-  const result = await clack.select({
-    message: "What would you like to do?",
-    options: [
-      ...sections.map((s) => ({
-        value: s.id,
-        label: s.label,
-        hint: s.hint
-      })),
-      { value: "exit", label: "Exit", hint: "leave the home menu" }
-    ]
-  });
-  if (clack.isCancel(result)) {
-    clack.cancel("Cancelled.");
-    fail(EXIT.CANCELLED, "cancelled", opts);
-  }
-  return result;
-}
-async function pickAction(clack, section, sections, opts) {
-  const idx = sections.findIndex((s) => s.id === section.id);
-  const hasPrev = idx > 0;
-  const hasNext = idx !== -1 && idx < sections.length - 1;
-  const result = await clack.select({
-    message: section.label,
-    initialValue: section.items[0]?.id,
-    options: [
-      ...section.items.map((a) => ({
-        value: a.id,
-        label: a.label,
-        hint: a.hint
-      })),
-      // Navigation options so the user can move across sections without
-      // re-entering the section picker (the "lancar" navigation requirement).
-      ...hasPrev ? [{ value: "prev", label: "\u2190 Prev section", hint: sections[idx - 1]?.label }] : [],
-      ...hasNext ? [{ value: "next", label: "\u2192 Next section", hint: sections[idx + 1]?.label }] : [],
-      { value: "back", label: "\u2191 Back to sections", hint: "return to the section picker" }
-    ]
-  });
-  if (clack.isCancel(result)) {
-    clack.cancel("Back to the home menu.");
-    return "back";
-  }
-  if (opts.verbose) {
-    process.stderr.write(`noir: home: section '${section.id}' selected
-`);
-  }
-  return result;
-}
-async function collectArg(clack, action, opts) {
-  if (!action.needsArg) return null;
-  const value = await clack.text({
-    message: action.needsArg.prompt,
-    placeholder: action.needsArg.placeholder,
-    validate: (v) => !v || v.trim().length === 0 ? "Please enter a value." : void 0
-  });
-  if (clack.isCancel(value)) {
-    clack.cancel("Cancelled.");
-    fail(EXIT.CANCELLED, "cancelled", opts);
-  }
-  return String(value);
-}
-async function argvForAction(clack, action, opts) {
-  const base = action.dispatch ?? [action.id];
-  let argv = [...base];
-  if (action.needsArg) {
-    const arg = await collectArg(clack, action, opts);
-    if (arg === null) return null;
-    argv = [...base, arg];
-  }
-  if (action.destructive || isDestructive(argv)) {
-    const confirmed = await clack.confirm({
-      message: `Run \`noir ${argv.join(" ")}\`? This may modify project files / the store.`,
-      initialValue: false
-    });
-    if (clack.isCancel(confirmed) || !confirmed) return null;
-  }
-  return argv;
-}
-async function runGroupedMenu(clack, opts, deps, sections) {
-  let currentSection = null;
-  while (true) {
-    if (currentSection === null) {
-      const picked = await pickSection(clack, sections, opts);
-      if (clack.isCancel(picked) || picked === "exit") {
-        clack.outro("bye");
-        return;
-      }
-      const idx = sections.findIndex((s) => s.id === picked);
-      if (idx === -1) {
-        continue;
-      }
-      currentSection = idx;
-      continue;
-    }
-    const section = sections[currentSection];
-    if (!section) {
-      currentSection = null;
-      continue;
-    }
-    const chosen = await pickAction(clack, section, sections, opts);
-    if (clack.isCancel(chosen)) {
-      currentSection = null;
-      continue;
-    }
-    switch (chosen) {
-      case "back": {
-        currentSection = null;
-        continue;
-      }
-      case "next": {
-        currentSection = (currentSection + 1) % sections.length;
-        continue;
-      }
-      case "prev": {
-        currentSection = (currentSection - 1 + sections.length) % sections.length;
-        continue;
-      }
-      default: {
-        const action = section.items.find((a) => a.id === chosen);
-        if (!action) {
-          currentSection = null;
-          continue;
-        }
-        const argv = await argvForAction(clack, action, opts);
-        if (argv === null) {
-          continue;
-        }
-        await deps.dispatch(argv);
-        clack.outro("done");
-        return;
-      }
-    }
-  }
-}
-async function runMenu(opts, deps) {
-  const clack = await import("@clack/prompts");
-  const project = tryProject();
-  void runAsyncUpdateCheck({
-    env: process.env,
-    configUpdate: (() => {
-      try {
-        const info2 = loadProjectInfo6(process.cwd());
-        return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
-      } catch {
-        return DEFAULT_UPDATE_CONFIG;
-      }
-    })(),
-    quiet: opts.json === true || opts.quiet === true || !process.stdout.isTTY
-  });
-  if (shouldShowBanner(opts)) {
-    const host = project?.host ?? "claude";
-    process.stderr.write(
-      `
-${renderBanner()}
-${NOIR_TAGLINE}
-
-${hostLaunchDirective2(host)}
-${COMMANDS_HINT}
-
-`
-    );
-  }
-  const rec = readInstallRecord();
-  if (rec && shouldShowMigrationBanner(rec, NOIR_VERSION3)) {
-    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).
-
-`
-    );
-  }
-  const updateNotice = buildUpdateNotice({
-    method: detectActiveMethod(),
-    currentVersion: NOIR_VERSION3,
-    latestKnown: latestVersionFromCache(readUpdateCache(), "latest")
-  });
-  if (updateNotice) {
-    process.stderr.write(
-      `
-  ${c.warn(`noir ${updateNotice.latestVersion} is available`)} (you have ${updateNotice.currentVersion}) \u2014 ${updateNotice.advice}.
-
-`
-    );
-  }
-  clack.intro(project ? `noir \u2014 ${project.name}` : "noir");
-  const sections = await resolveSections(deps.commands ?? []);
-  await runGroupedMenu(clack, opts, deps, sections);
-}
-
-// src/commands/memory.ts
-function parseLimit2(raw, label, opts) {
-  if (raw === void 0) return void 0;
-  const n = Number(raw);
-  if (!Number.isInteger(n) || n <= 0) {
-    fail(EXIT.USAGE, `${label}: --limit must be a positive integer (got '${raw}')`, opts);
-  }
-  return n;
-}
-function splitCsv(raw) {
-  if (raw === void 0) return void 0;
-  const out = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  return out.length > 0 ? out : void 0;
-}
-function toHit2(raw) {
-  const h = raw ?? {};
-  const arr = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
-  return {
-    id: typeof h.id === "string" ? h.id : "",
-    type: typeof h.type === "string" ? h.type : "",
-    score: typeof h.score === "number" ? h.score : 0,
-    content: typeof h.content === "string" ? h.content : "",
-    concepts: arr(h.concepts),
-    files: arr(h.files),
-    ts: typeof h.ts === "number" ? h.ts : 0,
-    importance: typeof h.importance === "number" ? h.importance : 0,
-    source: typeof h.source === "string" ? h.source : ""
-  };
-}
-function failTool2(label, envelope, opts) {
-  const detail = envelope.error ?? envelope.reason ?? "unknown failure";
-  fail(EXIT.ERROR, `${label}: ${detail}`, opts);
-}
-function stamp(ts) {
-  if (typeof ts !== "number" || ts <= 0) return "-";
-  return new Date(ts).toISOString().replace("T", " ").replace(/\..*$/, "Z");
-}
-async function memoryRecall(opts) {
-  const limit = parseLimit2(opts.limit, "memory recall", opts);
-  let probe;
-  try {
-    probe = await probeDaemon(opts);
-  } catch {
-    probe = { running: true };
-  }
-  if (!probe.running) {
-    await withInProcessRead(opts, async (engines) => {
-      const result = await engines.memory.recall(opts.query, {
-        ...limit === void 0 ? {} : { limit }
-      });
-      const data2 = { query: opts.query, hits: result, degraded: false };
-      if (opts.json === true) {
-        process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
-`);
-        return;
-      }
-      renderRecall(data2.query, result, data2.degraded, opts);
-    });
-    return;
-  }
-  const res = await callDaemonTool(opts, "memory_recall", {
-    query: opts.query,
-    ...limit === void 0 ? {} : { limit }
-  });
-  if (res.ok !== true) failTool2("memory recall", res, opts);
-  const hits = Array.isArray(res.results) ? res.results.map(toHit2) : [];
-  const data = { query: opts.query, hits, degraded: res.degraded === true };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  renderRecall(data.query, hits, data.degraded, opts);
-}
-function renderRecall(query, hits, degraded, opts) {
-  const flag = degraded ? `  ${badge("warn", "degraded: BM25-only")}` : "";
-  log(
-    `memory recall \u2014 ${hits.length} hit${hits.length === 1 ? "" : "s"} for '${query}'${flag}`,
-    opts
-  );
-  if (hits.length === 0) {
-    info("(no memories matched)", opts);
-    return;
-  }
-  for (let i = 0; i < hits.length; i++) {
-    const h = hits[i];
-    if (h === void 0) continue;
-    const head = `[${i + 1}] ${h.type} \xB7 score ${h.score.toFixed(4)} \xB7 importance ${h.importance.toFixed(2)} \xB7 ${h.id}`;
-    log(head, opts);
-    if (h.files.length > 0) log(`    files: ${h.files.join(", ")}`, opts);
-    if (h.concepts.length > 0) log(`    tags: ${h.concepts.join(", ")}`, opts);
-    log(`    ${h.content}`, opts);
-  }
-}
-async function memorySave(opts) {
-  const content = await resolveContent(opts);
-  const files = splitCsv(opts.files);
-  const args = { content };
-  if (typeof opts.type === "string" && opts.type.length > 0) args.type = opts.type;
-  if (files !== void 0) args.files = files;
-  const res = await callDaemonTool(opts, "memory_save", args);
-  if (res.ok !== true) failTool2("memory save", res, opts);
-  const id = typeof res.id === "string" ? res.id : "";
-  const observation = res.observation ?? {};
-  const data = { id, observation };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(`Saved memory ${id}.`, opts);
-  renderObservation(observation, opts);
-}
-async function resolveContent(opts) {
-  if (typeof opts.content === "string" && opts.content.length > 0) return opts.content;
-  if (!isInteractive(opts)) {
-    fail(
-      EXIT.USAGE,
-      "memory save requires --content <text> (or re-run in an interactive terminal to be prompted)",
-      opts
-    );
-  }
-  const clack = await import("@clack/prompts");
-  const value = await clack.text({
-    message: "Memory to save:",
-    placeholder: "the insight / decision / pattern to remember",
-    validate: (v) => !v || v.trim().length === 0 ? "content cannot be empty" : void 0
-  });
-  if (clack.isCancel(value)) {
-    clack.cancel("Cancelled.");
-    fail(EXIT.CANCELLED, "cancelled", opts);
-  }
-  return String(value);
-}
-function renderObservation(obs, opts) {
-  const rows = [];
-  for (const key of ["id", "type", "importance", "ts", "source", "project", "sessionId"]) {
-    if (obs[key] !== void 0) rows.push({ label: key, value: obs[key] });
-  }
-  if (rows.length > 0) definitionList(rows, opts);
-  const content = obs.content;
-  if (typeof content === "string") log(`
-${content}`, opts);
-}
-async function memorySessions(opts) {
-  let probe;
-  try {
-    probe = await probeDaemon(opts);
-  } catch {
-    probe = { running: true };
-  }
-  if (!probe.running) {
-    await withInProcessRead(opts, async (engines) => {
-      const raw = engines.memory.sessions();
-      const sessions2 = raw.map((s) => ({
-        id: s.id,
-        count: s.count,
-        lastTs: s.lastTs
-      }));
-      const data2 = { sessions: sessions2 };
-      if (opts.json === true) {
-        process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
-`);
-        return;
-      }
-      renderSessions(sessions2, opts);
-    });
-    return;
-  }
-  const res = await callDaemonTool(opts, "memory_sessions");
-  if (res.ok !== true) failTool2("memory sessions", res, opts);
-  const sessions = Array.isArray(res.sessions) ? res.sessions.map((raw) => {
-    const s = raw ?? {};
-    return {
-      id: typeof s.id === "string" ? s.id : "",
-      count: typeof s.count === "number" ? s.count : 0,
-      lastTs: typeof s.lastTs === "number" ? s.lastTs : 0
-    };
-  }) : [];
-  const data = { sessions };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  renderSessions(sessions, opts);
-}
-function renderSessions(sessions, opts) {
-  log(`memory sessions \u2014 ${sessions.length} session${sessions.length === 1 ? "" : "s"}`, opts);
-  table(
-    sessions.map((s) => ({ Session: s.id, Observations: s.count, "Last seen": stamp(s.lastTs) })),
-    ["Session", "Observations", "Last seen"],
-    opts
-  );
-}
-async function memoryForget(opts) {
-  if (opts.ids.length === 0) {
-    fail(EXIT.USAGE, "memory forget requires at least one <id>", opts);
-  }
-  const res = await callDaemonTool(opts, "memory_forget", {
-    ids: opts.ids
-  });
-  if (res.ok !== true) failTool2("memory forget", res, opts);
-  const deleted = typeof res.deleted === "number" ? res.deleted : 0;
-  const data = { deleted, ids: opts.ids };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(`Forgot ${deleted} observation${deleted === 1 ? "" : "s"}.`, opts);
-}
-async function memoryConsolidate(opts) {
-  const exposed = await withDaemon(opts, async (caller) => caller.listTools());
-  if (!exposed.includes("memory_consolidate")) {
-    fail(
-      EXIT.ERROR,
-      "memory consolidate: the daemon does not expose the memory_consolidate tool. Enable it in .noir/config under memory.consolidation (enabled: true + a provider + model), then restart the daemon.",
-      opts
-    );
-  }
-  const types = splitCsv(opts.types);
-  const limit = parseLimit2(opts.limit, "memory consolidate", opts);
-  const args = {};
-  if (types !== void 0) args.types = types;
-  if (limit !== void 0) args.limit = limit;
-  const res = await callDaemonTool(
-    opts,
-    "memory_consolidate",
-    args
-  );
-  if (res.ok === true) {
-    const lessons = Array.isArray(res.lessons) ? res.lessons : [];
-    const from = Array.isArray(res.from) ? res.from : [];
-    const data = { lessons, from };
-    if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-      return;
-    }
-    log(
-      `Consolidated ${lessons.length} lesson${lessons.length === 1 ? "" : "s"} from ${from.length} observation${from.length === 1 ? "" : "s"}.`,
-      opts
-    );
-    for (let i = 0; i < lessons.length; i++) {
-      const l = lessons[i];
-      if (l === void 0) continue;
-      const obs = l ?? {};
-      const id = typeof obs.id === "string" ? obs.id : `<lesson ${i + 1}>`;
-      const content = typeof obs.content === "string" ? obs.content : "";
-      log(`- ${id}: ${content}`, opts);
-    }
-    return;
-  }
-  const env = res;
-  const reason = (typeof env.reason === "string" ? env.reason : void 0) ?? (typeof env.error === "string" ? env.error : void 0) ?? "unknown";
-  const logged = env.logged === true || env.degraded === true;
-  const suffix = logged ? " (logged)" : "";
-  fail(EXIT.ERROR, `memory consolidate did not run: ${reason}${suffix}`, opts);
-}
-
-// src/commands/release.ts
-import { execSync, spawnSync as spawnSync2 } from "child_process";
-function describe(step, who) {
-  const m = {
-    preflight: "check clean tree, on develop, HEAD pushed, gate green, no version collision",
-    bump: "run bump-version.mjs + update CHANGELOG + roadmap docs",
-    gate: "re-run the full gate (lint/build/typecheck/test/docs:validate)",
-    commit: "commit chore(release) + push develop",
-    "ci-develop": "wait for CI on develop \u2192 green",
-    "beta-tag": "pnpm release:tag \u2192 beta tag + push",
-    "human-approve-beta": "approve the release workflow publish job in GitHub Actions",
-    "merge-main": "merge develop \u2192 main (fast-forward) + push",
-    "ci-main": "wait for CI on main \u2192 green",
-    "stable-tag": "pnpm release:tag \u2192 stable tag + push",
-    "human-approve-stable": "approve the release workflow publish job in GitHub Actions (again)",
-    "dist-bump": "update Homebrew (packaging/homebrew/noir.rb) + Scoop (packaging/scoop/noir.json) from npm",
-    sync: "merge main \u2192 develop + verify both branches at same SHA"
-  };
-  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);
-    for (const s of ALL) {
-      const who = s.startsWith("human-approve") ? "human" : "noir";
-      info(`${s}: ${describe(s, who)}`, opts);
-    }
-    tip('full release flow documented in CLAUDE.md "Patch release flow (beta \u2192 stable)"', opts);
-    return;
-  }
-  const version = opts.version?.trim();
-  if (!version) {
-    fail(EXIT.USAGE, "release: <version> is required (e.g. noir release 1.10.0)", opts);
-  }
-  const channel = opts.channel === "stable" ? "stable" : "beta";
-  log(`noir release ${version} (${channel} channel)`, opts);
-  try {
-    info(`[1/13] preflight: ${describe("preflight", "noir")}`, opts);
-    execSync("git diff --quiet", { encoding: "utf8" });
-    const branch = execSync("git branch --show-current", { encoding: "utf8" }).trim();
-    if (branch !== "develop") fail(EXIT.ERROR, "release: must be on develop", opts);
-    const status2 = execSync("git status --porcelain", { encoding: "utf8" }).trim();
-    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], {
-      encoding: "utf8",
-      stdio: "inherit"
-    });
-    success(`bump: \u2713 version ${version}`, opts);
-    info(`[3/13] gate: ${describe("gate", "noir")}`, opts);
-    execSync("pnpm lint && pnpm build && pnpm typecheck && pnpm test && pnpm docs:validate", {
-      encoding: "utf8",
-      stdio: "inherit"
-    });
-    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`], {
-      encoding: "utf8",
-      stdio: "inherit"
-    });
-    execSync("git push origin develop", { encoding: "utf8" });
-    success("commit: \u2713 pushed to develop", opts);
-    info(`[5/13] ci-develop: waiting for CI on develop\u2026`, opts);
-    info(`[6/13] beta-tag: ${describe("beta-tag", "noir")}`, opts);
-    tip("after CI green: run `pnpm release:tag` and push the beta tag", opts);
-    warn(`[7/13] ${describe("human-approve-beta", "human")}`, opts);
-    tip("open GitHub Actions \u2192 approve the publish job, then continue", opts);
-    tip("after approval: verify `npm view @noir-ai/cli dist-tags beta` = beta version", opts);
-    info("remaining steps (merge\u2192stable\u2192dist\u2192sync): see CLAUDE.md", opts);
-    for (const s of ALL.slice(7)) {
-      const who = s.startsWith("human-approve") ? "human" : "noir";
-      info(`  ${s}: ${describe(s, who)}`, opts);
-    }
-    success(`release ${version}: preflight\u2192bump\u2192gate\u2192commit done. Resume after approval.`, opts);
-  } catch (err) {
-    fail(EXIT.ERROR, `release failed: ${err instanceof Error ? err.message : String(err)}`, opts);
-  }
-}
-
-// 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/orchestrator.ts
-import { spawn } from "child_process";
-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;
-  return { binary, flags: HOST_FLAGS[host] };
-}
-function asObj(v) {
-  return typeof v === "object" && v !== null ? v : null;
-}
-function str(v) {
-  return typeof v === "string" ? v : void 0;
-}
-function num(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
-}
-function usageFrom(v) {
-  const o = asObj(v);
-  if (!o) return void 0;
-  const input = num(o.input_tokens);
-  const output = num(o.output_tokens);
-  const cache = num(o.cache_read_input_tokens) ?? num(o.cache_creation_input_tokens);
-  if (input === void 0 && output === void 0 && cache === void 0) return void 0;
-  return { inputTokens: input, outputTokens: output, cacheReadTokens: cache };
-}
-function messageText(message) {
-  if (!message) return void 0;
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    const parts = content.map((block) => {
-      const b = asObj(block);
-      return b && typeof b.text === "string" ? b.text : null;
-    }).filter((t) => t !== null);
-    if (parts.length > 0) return parts.join("");
-  }
-  return void 0;
-}
-function parseStreamLine(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return null;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-}
-function normalizeStreamEvent(raw) {
-  const r = asObj(raw);
-  if (!r) return null;
-  const type = r.type;
-  if (type === "system") {
-    if (r.subtype === "init") {
-      return { kind: "init", sessionId: str(r.session_id), model: str(r.model) };
-    }
-    return { kind: "other" };
-  }
-  if (type === "assistant") {
-    const message = asObj(r.message);
-    return {
-      kind: "assistant",
-      messageId: message ? str(message.id) : void 0,
-      text: messageText(message),
-      usage: message ? usageFrom(message.usage) : void 0
-    };
-  }
-  if (type === "result") {
-    return {
-      kind: "result",
-      isError: r.is_error === true,
-      durationMs: num(r.duration_ms),
-      numTurns: num(r.num_turns),
-      totalCostUsd: num(r.total_cost_usd),
-      usage: usageFrom(r.usage)
-    };
-  }
-  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"]
-    });
-    const reducer = new UsageReducer();
-    let eventCount = 0;
-    let stderrBuf = "";
-    child.on("error", (err) => reject(err));
-    const rl = createInterface({ input: child.stdout });
-    rl.on("line", (line) => {
-      opts.onLine?.(line);
-      const raw = parseStreamLine(line);
-      if (raw === null) return;
-      const event = normalizeStreamEvent(raw);
-      if (event === null) return;
-      eventCount += 1;
-      reducer.add(event);
-      opts.onEvent?.(event);
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderrBuf += chunk;
-    });
-    child.on("close", (code) => {
-      resolve({ exitCode: code ?? 0, usage: reducer.snapshot(), eventCount, stderr: stderrBuf });
-    });
-  });
-}
-
-// src/commands/run.ts
-function formatUsage(u) {
-  const cost = u.totalCostUsd > 0 ? ` $${u.totalCostUsd.toFixed(2)}` : "";
-  const turns = u.numTurns > 0 ? ` \xB7 ${u.numTurns} turns` : "";
-  return `${u.inputTokens.toLocaleString()} in / ${u.outputTokens.toLocaleString()} out${cost}${turns}`;
-}
-function streamEvent(event, opts) {
-  if (opts.json === true) return;
-  if (event.kind === "assistant" && event.text && event.text.length > 0) {
-    process.stdout.write(event.text);
-  }
-}
-async function run(prompt, opts) {
-  const host = opts.host ?? "claude";
-  if (!SUPPORTED_HOSTS.includes(host)) {
-    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 transcriptLines = [];
-  try {
-    const result = await runHost({
-      host,
-      prompt,
-      customBinary: opts.command,
-      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
-    );
-  }
-}
-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`);
-  try {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync2(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`);
-  } catch {
-    return "(not persisted)";
-  }
-  return file;
-}
-
-// src/commands/skills.ts
-import { claudeAdapter } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo7 } 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;
-  return name.replace(/^noir-/, "") || "general";
-}
-function toRow(s, kind = "builtin") {
-  const description = typeof s.frontmatter.description === "string" ? s.frontmatter.description : "";
-  const status2 = s.skillMd.includes("> **Stub:**") ? "stub" : "full";
-  const category = s.frontmatter.metadata?.category?.trim() || categoryOf(s.name);
-  return { name: s.name, category, description, kind, status: status2 };
-}
-function truncate(text, max) {
-  if (text.length <= max) return text;
-  const slice = text.slice(0, Math.max(0, max - 1));
-  const boundary = slice.lastIndexOf(" ");
-  const head = boundary > 0 ? slice.slice(0, boundary) : slice;
-  return `${head.trimEnd()}\u2026`;
-}
-async function skillsList(opts) {
-  let builtins;
-  let integrations;
-  try {
-    const all = discoverAll();
-    builtins = all.builtins;
-    integrations = all.integrations;
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills list: could not discover skills (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
-  }
-  const rows = [
-    ...builtins.map((b) => toRow(b, "builtin")),
-    ...integrations.map((i) => toRow(i, "integration"))
-  ];
-  const data = { count: rows.length, skills: rows };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  const intCount = integrations.length;
-  const banner = intCount > 0 ? `noir skills \u2014 ${rows.length} skill${rows.length === 1 ? "" : "s"} (${builtins.length} builtin, ${intCount} integration${intCount === 1 ? "" : "s"})` : `noir skills \u2014 ${rows.length} builtin skill${rows.length === 1 ? "" : "s"}`;
-  log(banner, opts);
-  table(
-    rows.map((r) => ({
-      Skill: r.name,
-      Kind: r.kind,
-      Category: r.category,
-      Status: r.status,
-      Description: truncate(r.description, 80)
-    })),
-    ["Skill", "Kind", "Category", "Status", "Description"],
-    opts
-  );
-}
-async function skillsSync(opts) {
-  const root = process.cwd();
-  const project = loadProjectInfo7(root);
-  if (!claudeAdapter.skillsDir) {
-    const data2 = {
-      emitted: [],
-      references: 0,
-      host: project.config.host,
-      reason: "no-skill-emitter"
-    };
-    if (opts.json === true) {
-      process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
-`);
-      return;
-    }
-    info("This host has no skill emitter; nothing to sync.", opts);
-    return;
-  }
-  const dir = claudeAdapter.skillsDir({ root });
-  const summary = await emitSkillsToDir(dir);
-  const pruned = summary.pruned ?? [];
-  const data = {
-    emitted: summary.emitted,
-    references: summary.references,
-    dir,
-    pruned
-  };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(
-    `Synced ${summary.emitted.length} Noir skill${summary.emitted.length === 1 ? "" : "s"} to ${dir}.`,
-    opts
-  );
-  if (pruned.length > 0) {
-    warn(
-      `Pruned ${pruned.length} stale noir-* skill dir${pruned.length === 1 ? "" : "s"}: ${pruned.join(", ")}`,
-      opts
-    );
-  }
-}
-async function skillsLint(opts) {
-  let skills;
-  try {
-    const all = discoverAll();
-    skills = [...all.builtins, ...all.integrations].map(lintSkill);
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills lint: could not lint skills (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
-  }
-  const errored = skills.filter((s) => s.errors.length > 0);
-  const warned = skills.filter((s) => s.warnings.length > 0 && s.errors.length === 0);
-  const data = { count: skills.length, errored: errored.length, skills };
-  if (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 {
-    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);
-    }
-  }
-}
-async function skillsRegistry(opts) {
-  let reg;
-  try {
-    reg = buildRegistry();
-  } catch (err) {
-    fail(
-      EXIT.ERROR,
-      `skills registry: could not build registry (${err instanceof Error ? err.message : String(err)})`,
-      opts
-    );
-  }
-  const data = { count: reg.length, skills: reg };
-  if (opts.json === true) {
-    process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-    return;
-  }
-  log(`noir skills registry \u2014 ${reg.length} skills.`, opts);
-  table(
-    reg.map((r) => ({
-      Skill: r.name,
-      Kind: r.kind,
-      Category: r.category,
-      Version: r.version,
-      Status: r.status,
-      Refs: String(r.referenceCount),
-      Lines: String(r.lines)
-    })),
-    ["Skill", "Kind", "Category", "Version", "Status", "Refs", "Lines"],
-    opts
-  );
-}
-
-// src/serve.ts
-import { loadProjectInfo as loadProjectInfo8 } from "@noir-ai/core";
-import { ensureDaemonRunning as ensureDaemonRunning3, startStdioServer } from "@noir-ai/daemon";
-async function serve(opts) {
-  const project = loadProjectInfo8(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 });
-  }
-}
+  c,
+  contentWidth,
+  divider,
+  useColor
+} from "./chunk-ESZTOQEC.js";
 
-// src/bin.ts
-function buildPaletteCommandsForTui() {
-  return buildPaletteCommands(createProgram());
-}
-function actionGlobals(args) {
-  const last = args[args.length - 1];
-  return last?.optsWithGlobals() ?? {};
-}
-function trailingCmd(args) {
-  const last = args[args.length - 1];
-  if (!(last instanceof Command)) {
-    throw new NoirCliError(
-      EXIT.ERROR,
-      "internal: commander action callback received no trailing Command"
-    );
-  }
-  return last;
-}
-function toCliOptions(g) {
-  return {
-    json: g.json === true,
-    quiet: g.quiet === true,
-    verbose: g.verbose === true,
-    input: g.input !== false,
-    // TUI policy — additive only. `--tui`/`--no-tui` land on `tui`
-    // (true/false; absent when neither flag is given). Spread conditionally so
-    // the default-args case (no flag) does NOT add a `tui` key — keeps the
-    // exact-shape assertions in bin.test.ts green.
-    ...g.tui === true || g.tui === false ? { tui: g.tui === true } : {},
-    // `--no-tips` is stored under `tips` (default true; flag ⇒ false). Map to
-    // the additive `noTips` spelling used by CliOptions + `tip()`.
-    ...g.tips === false ? { noTips: true } : {}
-  };
-}
-function toStatusOptions(g) {
-  return {
-    json: g.json === true,
-    quiet: g.quiet === true,
-    verbose: g.verbose === true,
-    input: g.input !== false
-  };
-}
-function parseHost(raw) {
-  if (raw === void 0) return void 0;
-  return raw;
-}
-var DEPRECATIONS = [];
-function commandPath(cmd) {
-  const path = [];
-  let c2 = cmd;
-  while (c2 !== null) {
-    path.unshift(c2.name());
-    c2 = c2.parent;
-  }
-  return path;
-}
-function emitDeprecationHintsFor(cmd, opts) {
-  if (DEPRECATIONS.length === 0) return;
-  const rel = commandPath(cmd).slice(1);
-  for (const d of DEPRECATIONS) {
-    if (d.oldArgv.every((a, i) => rel[i] === a)) {
-      tip(
-        `\`noir ${d.oldArgv.join(" ")}\` is deprecated since v${d.since}; use \`noir ${d.newArgv.join(" ")}\`.`,
-        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(
-    new Option("--tui", "prefer the interactive home menu for bare `noir` (advisory; TTY-only)")
-  ).addOption(
-    new Option(
-      "--no-tui",
-      "route bare `noir` to the non-interactive `status` path even in a TTY"
-    )
-  ).addOption(new Option("--no-tips", "suppress redirect / deprecation hints on stderr")).exitOverride((err) => {
-    throw err;
-  }).configureOutput({
-    // Stream discipline: --help/--version → stdout (conventional; users pipe
-    // them), errors → stderr. --json data is emitted by command actions via
-    // process.stdout directly, NOT by commander's writeOut, so routing help/
-    // version to stdout does not conflict with --json payloads.
-    writeOut: (str2) => process.stdout.write(str2),
-    writeErr: (str2) => process.stderr.write(str2)
-  });
-  program2.hook("preAction", (_thisCmd, actionCmd) => {
-    const opts = actionCmd.optsWithGlobals();
-    const cwd = opts.cwd;
-    if (typeof cwd === "string" && cwd.length > 0) {
-      try {
-        process.chdir(cwd);
-      } catch (err) {
-        throw new NoirCliError(
-          EXIT.USAGE,
-          `--cwd: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    const nonInteractive = opts.json === true || opts.input === false;
-    if (nonInteractive) process.env.NOIR_NON_INTERACTIVE = "1";
-    else delete process.env.NOIR_NON_INTERACTIVE;
-    emitDeprecationHintsFor(actionCmd, toCliOptions(opts));
-  });
-  program2.command("init").description("scaffold Noir in the current project (.noir/, .mcp.json, CLAUDE.md, skills)").option("--transport <transport>", "stdio | streamable-http (default: stdio)", "stdio").option("--url <url>", "streamable-http daemon URL (localhost only)").option(
-    "--upgrade",
-    "run scaffold migrations before re-emitting (re-run on an existing project)"
-  ).option("--force", "re-scaffold even if already initialized (bypasses the already-init no-op)").option("--dry-run", "report planned writes without writing anything").option("--preview", "alias for --dry-run").addOption(
-    // S10: target host. Defaults to `'claude'` (the regression anchor). The
-    // chosen host is forwarded to scaffold() + skills emission via
-    // resolveAdapter. The choice list mirrors `SUPPORTED_HOSTS` so a new host
-    // lands here automatically; commander rejects anything else as usage=2.
-    new Option(
-      "--host <id>",
-      "target agentic CLI (default: claude) \u2014 drives host-side emission"
-    ).choices(SUPPORTED_HOSTS2)
-  ).action(
-    async (opts, cmd) => {
-      const transport = opts.transport === "streamable-http" ? "streamable-http" : "stdio";
-      const upgrade = opts.upgrade === true;
-      const force = opts.force === true;
-      const host = parseHost(opts.host);
-      const dryRun = opts.dryRun === true || opts.preview === true;
-      const result = await init(process.cwd(), {
-        transport,
-        url: opts.url,
-        ...upgrade ? { upgrade } : {},
-        ...force ? { force } : {},
-        ...host !== void 0 ? { host } : {},
-        ...dryRun ? { dryRun } : {}
-      });
-      if (cmd.optsWithGlobals().json === true && result !== void 0) {
-        json({ ok: true, data: result });
-      }
-    }
-  );
-  program2.command("create [dir]").description("bootstrap the Noir AI layer in a new or empty directory").option("--transport <transport>", "stdio | streamable-http (default: stdio)", "stdio").option("--url <url>", "streamable-http daemon URL (localhost only)").option("--force", "re-scaffold even if already initialized (bypasses the already-init no-op)").option("--dry-run", "report planned writes without writing anything").option("--preview", "alias for --dry-run").addOption(
-    new Option(
-      "--host <id>",
-      "target agentic CLI (default: claude) \u2014 drives host-side emission"
-    ).choices(SUPPORTED_HOSTS2)
-  ).action(
-    async (dir, opts, cmd) => {
-      const transport = opts.transport === "streamable-http" ? "streamable-http" : "stdio";
-      const force = opts.force === true;
-      const host = parseHost(opts.host);
-      const dryRun = opts.dryRun === true || opts.preview === true;
-      const { create } = await import("./create-WKFVM237.js");
-      const result = await create(dir, {
-        transport,
-        url: opts.url,
-        ...force ? { force } : {},
-        ...host !== void 0 ? { host } : {},
-        ...dryRun ? { dryRun } : {}
-      });
-      if (cmd.optsWithGlobals().json === true && result !== void 0) {
-        json({ ok: true, data: result });
-      }
-    }
-  );
-  program2.command("sync").description(
-    "re-emit Noir managed files (.mcp.json, CLAUDE.md blocks, NOIR.md brief, ignores) + skills"
-  ).option(
-    "--force",
-    "overwrite differing regenerated files without prompting (bypasses the conflict menu)"
-  ).option(
-    "--merge",
-    "three-way merge managed regions (default since 1.3.0; flag kept for compatibility)"
-  ).option("--dry-run", "report planned writes without writing anything").option("--preview", "alias for --dry-run").addOption(
-    // Opt OUT of managed-region merge (restore strip-replace). Commander
-    // stores `--no-merge-regions` under `mergeRegions` (default true; flag →
-    // false). Bare `noir sync` keeps the merge default (true).
-    new Option(
-      "--no-merge-regions",
-      "strip-replace managed regions (discard hand-edits inside <!-- noir:* --> markers)"
-    )
-  ).addOption(
-    // S10: optional `--host` override. When omitted, sync reads host from
-    // `.noir/config.yml` (whatever `noir init --host <id>` persisted). The
-    // override is rarely needed — documented as advanced.
-    new Option(
-      "--host <id>",
-      "override the configured host (advanced; default reads .noir/config.yml)"
-    ).choices(SUPPORTED_HOSTS2)
-  ).action(
-    async (opts, cmd) => {
-      const { sync } = await import("./sync-DUWJAF7Z.js");
-      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(), {
-        ...host !== void 0 ? { host } : {},
-        ...force ? { force } : {},
-        ...merge ? { merge } : {},
-        ...noMergeRegions ? { mergeManagedRegions: false } : {},
-        ...dryRun ? { dryRun } : {}
-      });
-      if (cmd.optsWithGlobals().json === true) {
-        json({ ok: true, data: result });
-      }
-    }
-  );
-  const mcpCmd = program2.command("mcp").description("MCP server control");
-  mcpCmd.command("serve").description("run the Noir MCP server (stdio, or via the shared daemon)").option("--stdio", "force the stdio transport").action(async (opts) => {
-    await serve({ stdio: opts.stdio === true });
-  });
-  mcpCmd.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir mcp serve [--stdio]");
-  });
-  const daemonGrp = program2.command("daemon").description("control the Noir daemon");
-  daemonGrp.command("start").description("start the Noir daemon (foreground, or background with --detach)").option("--detach", "run the daemon in the background and exit").addOption(
-    new Option("--_detached-child", "reserved: detached daemon child (internal)").hideHelp()
-  ).action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const detach = g.detach === true;
-    const detachChild = g._detachedChild === true;
-    await daemonStart({
-      ...toCliOptions(g),
-      ...detach ? { detach } : {},
-      ...detachChild ? { detachChild } : {}
-    });
-  });
-  daemonGrp.command("stop").description("stop the Noir daemon").action(async (...args) => {
-    await daemonStop(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  daemonGrp.command("status").description("report daemon pid/uptime/mode (exit 4 if not running)").action(async (...args) => {
-    await daemonStatus(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  daemonGrp.command("restart").description("stop then start the daemon").action(async (...args) => {
-    await daemonRestart(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  daemonGrp.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir daemon start|stop|status|restart");
-  });
-  program2.command("doctor").description("environment + project health").option(
-    "--dedup",
-    "scan host-context + .noir/ docs for semantic near-duplicates (loads the local embedder)"
-  ).action(async (...args) => {
-    const g = actionGlobals(args);
-    const dedup = trailingCmd(args).opts().dedup === true;
-    await doctor({ ...toCliOptions(g), ...dedup ? { dedup: true } : {} });
-  });
-  program2.command("status").description("project + daemon + workflow + store snapshot").action(async (...args) => {
-    await status(toStatusOptions(actionGlobals(args)));
-  });
-  const contextGrp = program2.command("context").description("context engine");
-  contextGrp.command("search").description("hybrid search over the indexed context").argument("<query>", "search query").option("--limit <n>", "max results", "10").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const query = typeof args[0] === "string" ? args[0] : "";
-    const limit = typeof g.limit === "string" ? g.limit : void 0;
-    await contextSearch({
-      ...toCliOptions(g),
-      query,
-      ...limit === void 0 ? {} : { limit }
-    });
-  });
-  contextGrp.command("index").description("(re)index project files into the context store").option(
-    "--path <p>",
-    "path to index (repeatable)",
-    (val, acc) => [...acc, val],
-    []
-  ).option("--force", "force a full reindex (drop all chunks+vectors, re-index from scratch)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const rawPaths = Array.isArray(g.path) ? g.path.filter((p) => typeof p === "string") : [];
-    const force = g.force === true;
-    await contextIndex({
-      ...toCliOptions(g),
-      ...rawPaths.length === 0 ? {} : { paths: rawPaths },
-      ...force ? { force } : {}
-    });
-  });
-  contextGrp.command("status").description("index freshness + counts").action(async (...args) => {
-    await contextStatus(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  contextGrp.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir context search|index|status");
-  });
-  const memoryGrp = program2.command("memory").description("memory engine");
-  memoryGrp.command("recall").description("recall memories for a query").argument("<query>", "recall query").option("--limit <n>", "max results", "10").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const query = typeof args[0] === "string" ? args[0] : "";
-    const limit = typeof g.limit === "string" ? g.limit : void 0;
-    await memoryRecall({
-      ...toCliOptions(g),
-      query,
-      ...limit === void 0 ? {} : { limit }
-    });
-  });
-  memoryGrp.command("save").description("save an observation to long-term memory").option("--content <text>", "memory content (prompted interactively if omitted)").option(
-    "--type <type>",
-    "observation type (pattern | preference | architecture | bug | workflow | fact | decision)"
-  ).option("--files <files>", "comma-separated related file paths").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const content = typeof g.content === "string" ? g.content : void 0;
-    const type = typeof g.type === "string" ? g.type : void 0;
-    const files = typeof g.files === "string" ? g.files : void 0;
-    await memorySave({
-      ...toCliOptions(g),
-      ...content === void 0 ? {} : { content },
-      ...type === void 0 ? {} : { type },
-      ...files === void 0 ? {} : { files }
-    });
-  });
-  memoryGrp.command("sessions").description("list recent memory sessions").action(async (...args) => {
-    await memorySessions(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  memoryGrp.command("forget").description("delete one or more memories by id").argument("<ids...>", "observation id(s)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const rawIds = Array.isArray(args[0]) ? args[0] : [];
-    const ids = rawIds.filter((x) => typeof x === "string");
-    await memoryForget({ ...toCliOptions(g), ids });
-  });
-  memoryGrp.command("consolidate").description("consolidate memories into a derived lesson (provider-explicit)").option("--types <types>", "comma-separated observation types to consolidate").option("--limit <n>", "cap on candidate observations").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const types = typeof g.types === "string" ? g.types : void 0;
-    const limit = typeof g.limit === "string" ? g.limit : void 0;
-    await memoryConsolidate({
-      ...toCliOptions(g),
-      ...types === void 0 ? {} : { types },
-      ...limit === void 0 ? {} : { limit }
-    });
-  });
-  memoryGrp.action(() => {
-    throw new NoirCliError(
-      EXIT.USAGE,
-      "Usage: noir memory recall|save|sessions|forget|consolidate"
-    );
-  });
-  const skillsGrp = program2.command("skills").description("builtin skills");
-  skillsGrp.command("list").description("list installed Noir skills").action(async (...args) => {
-    await skillsList(toCliOptions(actionGlobals(args)));
-  });
-  skillsGrp.command("sync").description("re-emit skills to the host skills dir").action(async (...args) => {
-    await skillsSync(toCliOptions(actionGlobals(args)));
-  });
-  skillsGrp.command("lint").description("structural quality gate over the shipped pack").action(async (...args) => {
-    await skillsLint(toCliOptions(actionGlobals(args)));
-  });
-  skillsGrp.command("registry").description("emit the runtime-derived skill registry").action(async (...args) => {
-    await skillsRegistry(toCliOptions(actionGlobals(args)));
-  });
-  skillsGrp.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir skills list|sync|lint|registry");
-  });
-  const taskGrp = program2.command("task").description("workflow task control");
-  taskGrp.command("new").description("start a new workflow task").requiredOption("--slug <slug>", "task slug").option("--mode <mode>", "full | quick").option(
-    "--class <taskClass>",
-    "task class (feature/epic/enhancement/bugfix/spike/quick-task/refactor) \u2014 drives the PRD gate"
-  ).action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const slug = typeof g.slug === "string" ? g.slug : "";
-    const mode = typeof g.mode === "string" ? g.mode : void 0;
-    const taskClass = typeof g.class === "string" ? g.class : void 0;
-    await taskNew({
-      ...toCliOptions(g),
-      slug,
-      ...mode === void 0 ? {} : { mode },
-      ...taskClass === void 0 ? {} : { taskClass }
-    });
-  });
-  taskGrp.command("status").description("active (or named) task status").argument("[id]", "task id (defaults to active)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const first = args[0];
-    const id = typeof first === "string" ? first : void 0;
-    await taskStatus({
-      ...toCliOptions(g),
-      ...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) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const to = typeof g.to === "string" ? g.to : void 0;
-    const force = typeof g.force === "string" ? g.force : void 0;
-    await taskAdvance({
-      ...toCliOptions(g),
-      ...to === void 0 ? {} : { to },
-      ...force === void 0 ? {} : { force },
-      ...g.artifacts === false ? { noArtifacts: true } : {}
-    });
-  });
-  taskGrp.command("next").description("suggest the next phase + applicable skill").action(async (...args) => {
-    await taskNext(toCliOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  taskGrp.command("decompose").description("decompose a capability into an implementation plan").argument("<capability>", "capability id").option("--out <path>", "output path for the plan JSON").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const capability = typeof args[0] === "string" ? args[0] : "";
-    await taskDecompose({
-      ...toCliOptions(g),
-      capability,
-      ...typeof g.out === "string" && g.out.length > 0 ? { out: g.out } : {}
-    });
-  });
-  taskGrp.command("verify").description("run configured verify checks and submit evidence to the verify gate").option(
-    "--check <name>",
-    "restrict to a named check (repeatable)",
-    (val, acc) => [...acc, val],
-    []
-  ).action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const check = Array.isArray(g.check) ? g.check : void 0;
-    await taskVerify({
-      ...toCliOptions(g),
-      ...check === void 0 || check.length === 0 ? {} : { check }
-    });
-  });
-  taskGrp.command("research").description("list research findings for the active (or named) task").argument("[id]", "task id (defaults to active)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const first = args[0];
-    const id = typeof first === "string" ? first : void 0;
-    await taskResearch({
-      ...toCliOptions(g),
-      ...id === void 0 ? {} : { id }
-    });
-  });
-  taskGrp.command("research-record").description("record a research finding for the active (or named) task").requiredOption("--type <type>", "assumption | discovery | decision | grounding-fact").requiredOption("--text <text>", "finding text (capped)").option("--source <ref>", "evidence/citation (required unless grounding-fact)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    await taskResearchRecord({
-      ...toCliOptions(g),
-      type: String(g.type ?? ""),
-      text: String(g.text ?? ""),
-      ...typeof g.source === "string" && g.source.length > 0 ? { source: g.source } : {},
-      ...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) => {
-    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 }
-    });
-  });
-  taskGrp.command("block").description("mark the active (or named) task blocked with a reason").argument("<reason>", "why the task is stuck (non-empty)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const reason = typeof args[0] === "string" ? args[0] : "";
-    const task = typeof g.task === "string" ? g.task : void 0;
-    await taskBlock({
-      ...toCliOptions(g),
-      reason,
-      ...task === void 0 ? {} : { task }
-    });
-  });
-  taskGrp.command("abandon").description("abandon the active (or named) task (terminal, confirmed)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    const task = typeof g.task === "string" ? g.task : void 0;
-    await taskAbandon({
-      ...toCliOptions(g),
-      ...task === void 0 ? {} : { task }
-    });
-  });
-  taskGrp.action(() => {
-    throw new NoirCliError(
-      EXIT.USAGE,
-      "Usage: noir task new|status|advance|next|verify|research|research-record|resume|block|abandon"
-    );
-  });
-  const installCmd = program2.command("install").description(
-    "install Noir via the native managed-Node path (or migrate from another install method)"
-  ).option("--list", "list detected install methods").option("--uninstall-prev", "after a successful migrate, uninstall the previous install method").option(
-    "--dismiss",
-    "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-JR6ZXNYA.js");
-      const cli = cmd.optsWithGlobals();
-      await install({
-        ...cli,
-        spec,
-        list: opts.list === true,
-        uninstallPrev: opts.uninstallPrev === true,
-        dismiss: opts.dismiss === true
-      });
-    }
-  );
-  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-PGAM6OVL.js");
-    const cli = cmd.optsWithGlobals();
-    await update({ ...cli, spec, check: opts.check === true });
-  });
-  function buildHandoffOptions(g) {
-    return { ...toCliOptions(g), ...g.write === true ? { write: true } : {} };
-  }
-  program2.command("handoff").description("emit a ready-to-paste host handoff prompt").option("--write", "persist to .noir/handoff/HO-<NNNN>-<id>.md (gitignored)").action(async (...args) => {
-    await handoff(buildHandoffOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  program2.command("wrap").description("session-end alias for `noir handoff`").option("--write", "persist to .noir/handoff/HO-<NNNN>-<id>.md (gitignored)").action(async (...args) => {
-    await handoff(buildHandoffOptions(trailingCmd(args).optsWithGlobals()));
-  });
-  program2.command("release").description("guided release orchestrator over the patch-release flow").argument("[version]", "target version, e.g. 1.10.0").option("--channel <channel>", "beta (default) | stable").option("--dry-run", "print the checklist without executing any steps").action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const g = cmd.optsWithGlobals();
-    await release({
-      ...toCliOptions(g),
-      ...typeof args[0] === "string" && args[0].length > 0 ? { version: args[0] } : {},
-      ...typeof g.channel === "string" && g.channel.length > 0 ? { channel: g.channel } : {},
-      ...g.dryRun === true ? { dryRun: true } : {}
-    });
-  });
-  program2.command("tui").description("interactive Ink dashboard (host \xB7 phase \xB7 daemon + /command dispatch)").action(async (...args) => {
-    const g = actionGlobals(args);
-    const opts = toCliOptions(g);
-    requireInteractive(opts, "`noir tui`");
-    const tuiUrl = new URL("./tui/index.js", import.meta.url).href;
-    process.env.NODE_ENV ||= "production";
-    const { runTui: runTui2 } = await import(
-      /* @vite-ignore */
-      tuiUrl
-    );
-    const dispatch = async (argv) => {
-      const sub = createProgram();
-      try {
-        await sub.parseAsync([...argv], { from: "user" });
-      } catch (err) {
-        handleError(err);
-      }
-    };
-    await runTui2(opts, dispatch);
-  });
-  program2.command("palette").description("fuzzy command palette \u2014 run any noir command (Ink)").action(async (...args) => {
-    const g = actionGlobals(args);
-    const opts = toCliOptions(g);
-    requireInteractive(opts, "`noir palette`");
-    const tuiUrl = new URL("./tui/index.js", import.meta.url).href;
-    process.env.NODE_ENV ||= "production";
-    const { runPalette: runPalette2 } = await import(
-      /* @vite-ignore */
-      tuiUrl
-    );
-    const dispatch = async (argv) => {
-      const sub = createProgram();
-      try {
-        await sub.parseAsync([...argv], { from: "user" });
-      } catch (err) {
-        handleError(err);
-      }
-    };
-    await runPalette2(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) => {
-    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 } : {}
-    };
-    await run(prompt, opts);
-  });
-  program2.action(async (...args) => {
-    const cmd = trailingCmd(args);
-    const leftovers = cmd.args;
-    if (leftovers.length > 0) {
-      fail(
-        EXIT.NOT_FOUND,
-        `unknown command '${leftovers[0]}' (no such subcommand). Run \`noir --help\` for the list.`,
-        toCliOptions(cmd.optsWithGlobals())
-      );
-    }
-    await home(toCliOptions(actionGlobals(args)), homeDeps);
-  });
-  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" });
-  } catch (err) {
-    handleError(err);
-  }
-  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;
-  }
-})();
-if (isMainModule) {
-  void run2(process.argv.slice(2));
-}
+// src/tui/index.tsx
+import { loadProjectInfo } from "@noir-ai/core";
+import { render } from "ink";
 
 // src/tui/App.tsx
 import { Box as Box5, Text as Text8, useApp, useInput } from "ink";
@@ -3634,7 +213,18 @@ import { jsx as jsx5 } from "react/jsx-runtime";
 function Panel({ children, maxWidth }) {
   const full = contentWidth() + 4;
   const width = maxWidth != null ? Math.min(full, maxWidth) : full;
-  return /* @__PURE__ */ jsx5(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, width, children });
+  const borderColor = useColor() ? "gray" : void 0;
+  return /* @__PURE__ */ jsx5(
+    Box2,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      width,
+      children
+    }
+  );
 }
 
 // src/tui/overlays/ConfirmOverlay.tsx
@@ -3878,15 +468,16 @@ function buildPaletteRows(input) {
 // src/tui/palette/Palette.tsx
 import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var PALETTE_WIDTH = 64;
+var ROW_TEXT_WIDTH = PALETTE_WIDTH - 6;
 var LABEL_WIDTH = 26;
-var HINT_WIDTH = 34;
+var HINT_WIDTH = ROW_TEXT_WIDTH - LABEL_WIDTH;
 function wrap(text, width) {
   const words = text.split(/\s+/).filter((w) => w.length > 0);
   const lines = [];
   let cur = "";
   for (const w of words) {
     if (cur.length === 0) cur = w;
-    else if ((cur + " " + w).length <= width) cur = `${cur} ${w}`;
+    else if (`${cur} ${w}`.length <= width) cur = `${cur} ${w}`;
     else {
       lines.push(cur);
       cur = w;
@@ -3953,8 +544,8 @@ function Palette({ corpus, query, active, rows }) {
         ] }) }, row.key)
       );
     }
-    if (isActive && row.argv && row.secondary) {
-      const detailLines = wrap(row.secondary, PALETTE_WIDTH - 12);
+    if (isActive && row.secondary && (row.argv || corpus === "help")) {
+      const detailLines = wrap(row.secondary, ROW_TEXT_WIDTH - 4);
       for (let di = 0; di < detailLines.length; di++) {
         const line = detailLines[di] ?? "";
         const prefix2 = di === 0 ? "  \u21B3 " : "    ";
@@ -4081,7 +672,7 @@ function App({
     if (pending === null) return;
     const argv = pending;
     let active = true;
-    const run3 = async () => {
+    const run = async () => {
       const captured = await captureProcessOutput(() => deps.dispatch(argv));
       if (!active) return;
       const combined = `${captured.stdout}${captured.stderr}`;
@@ -4094,7 +685,7 @@ function App({
       setPending(null);
       setScrollOffset(0);
     };
-    void run3();
+    void run();
     return () => {
       active = false;
     };
@@ -4361,18 +952,18 @@ function App({
 }
 
 // src/tui/palette/history.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
 import { homedir } from "os";
-import { join as join3 } from "path";
+import { join } from "path";
 import { atomicWriteFile } from "@noir-ai/core";
 var MAX_ENTRIES = 50;
 var TUI_HISTORY_DISABLE_ENV = "NOIR_DISABLE_TUI_HISTORY";
 var testHome = null;
 function homeDir() {
-  return testHome ?? join3(homedir(), ".noir");
+  return testHome ?? join(homedir(), ".noir");
 }
 function historyFile(projectId) {
-  return join3(homeDir(), projectId, "tui-history.json");
+  return join(homeDir(), projectId, "tui-history.json");
 }
 function isHistoryEnabled() {
   const v = process.env[TUI_HISTORY_DISABLE_ENV];
@@ -4407,8 +998,8 @@ function recordRecent(projectId, argv) {
   const current = loadRecent(projectId).filter((e) => e.id !== entry.id);
   const next = [entry, ...current].slice(0, MAX_ENTRIES);
   try {
-    const dir = join3(homeDir(), projectId);
-    mkdirSync3(dir, { recursive: true });
+    const dir = join(homeDir(), projectId);
+    mkdirSync(dir, { recursive: true });
     atomicWriteFile(historyFile(projectId), `${JSON.stringify(next, null, 2)}
 `);
   } catch {
@@ -4443,7 +1034,7 @@ async function runPalette(opts, dispatch) {
 async function buildTuiDeps(opts, dispatch) {
   let projectId = null;
   try {
-    projectId = loadProjectInfo9(process.cwd()).id;
+    projectId = loadProjectInfo(process.cwd()).id;
   } catch {
     projectId = null;
   }