@noir-ai/cli 1.3.0-beta.6 → 1.4.0-beta.2

package/dist/tui/index.js

@@ -0,0 +1,2253 @@
+import {
+  init
+} from "./chunk-OMF7XZMN.js";
+import {
+  EXIT,
+  NoirCliError,
+  accessibleMode,
+  badge,
+  c,
+  definitionList,
+  doctor,
+  fail,
+  handleError,
+  info,
+  isInteractive,
+  json,
+  log,
+  requireInteractive,
+  table,
+  terminalWidth,
+  tip,
+  useColor,
+  warn
+} from "./chunk-YNEBQJXA.js";
+
+// src/tui/index.tsx
+import { render } from "ink";
+
+// src/commands/status.ts
+import { loadProjectInfo as loadProjectInfo7, NOIR_VERSION as NOIR_VERSION3 } from "@noir-ai/core";
+
+// src/daemon-client.ts
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { loadProjectInfo as loadProjectInfo6, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
+import { ensureDaemonRunning as ensureDaemonRunning3, pidAlive as pidAlive2, readDaemonRecord as readDaemonRecord2 } from "@noir-ai/daemon";
+
+// src/bin.ts
+import { realpathSync } from "fs";
+import { pathToFileURL } from "url";
+import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
+import { NOIR_VERSION } from "@noir-ai/core";
+import { Command, Option } from "commander";
+
+// 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);
+  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) {
+  if (opts.force === true) {
+    info(
+      "context index: --force is recognized but not yet honored (content-hash is always incremental).",
+      opts
+    );
+  }
+  const args = opts.paths && opts.paths.length > 0 ? { paths: opts.paths } : {};
+  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 } from "@noir-ai/core";
+import {
+  clearDaemonRecord,
+  ensureDaemonRunning,
+  pidAlive,
+  readDaemonRecord
+} 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 daemonStart(opts) {
+  if (opts.detach === true) {
+    fail(EXIT.USAGE, "not implemented (tracked: v1.x)", opts);
+  }
+  const project = loadProjectInfo(process.cwd());
+  const ensured = await ensureDaemonRunning({
+    project,
+    idleTimeoutSec: project.config.daemon.idleTimeoutSec
+  });
+  if (ensured.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 (backgrounding deferred to v1.x). Ctrl+C to stop.", opts);
+    log(`Noir daemon listening at ${ensured.url}`, opts);
+    return;
+  }
+  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 = readDaemonRecord();
+  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;
+  }
+  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) {
+    log(`Stopped Noir daemon (pid ${rec.pid}).`, opts);
+  } else {
+    info(`Noir daemon (pid ${rec.pid}) could not be signalled: ${errMsg}`, opts);
+  }
+}
+async function daemonStatus(opts) {
+  const rec = readDaemonRecord();
+  if (!rec) {
+    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (start with `noir daemon start`).", opts);
+  }
+  if (!pidAlive(rec.pid)) {
+    clearDaemonRecord();
+    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
+  }
+  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) {
+    clearDaemonRecord();
+    fail(
+      EXIT.DAEMON_DOWN,
+      "Noir daemon is not running (port unresponsive; stale record removed).",
+      opts
+    );
+  }
+  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,
+    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 loadProjectInfo2, NOIR_DIR } from "@noir-ai/core";
+
+// src/commands/task.ts
+var PHASE_SKILL = {
+  intake: "noir-intake",
+  clarify: "noir-clarify",
+  spec: "noir-spec",
+  plan: "noir-plan",
+  execute: "noir-execute",
+  verify: "noir-verify",
+  document: "noir-document"
+};
+function skillFor(phase) {
+  if (typeof phase !== "string") return null;
+  return PHASE_SKILL[phase] ?? null;
+}
+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);
+  definitionList(
+    [
+      { label: "Task", value: s.taskId },
+      { label: "Phase", value: s.phase },
+      { label: "State", value: s.state },
+      { label: "Mode", value: s.mode },
+      { label: "Next gate", value: s.nextGate ?? "\u2014" },
+      { label: "Updated", value: formatStamp(s.updatedAt) }
+    ],
+    opts
+  );
+}
+async function taskStatus(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);
+}
+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;
+  }
+  const res = await callDaemonTool(
+    opts,
+    "workflow_start",
+    {
+      taskId: opts.slug,
+      slug: opts.slug,
+      ...mode === void 0 ? {} : { mode }
+    }
+  );
+  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 (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);
+}
+
+// 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 join(root, NOIR_DIR, "handoff", `${id}.md`);
+}
+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 = loadProjectInfo2(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 { loadProjectInfo as loadProjectInfo3 } 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/commands/home.ts
+function tryProject() {
+  try {
+    const info2 = loadProjectInfo3(process.cwd());
+    return { id: info2.id, name: info2.name, host: info2.config.host };
+  } catch {
+    return null;
+  }
+}
+var COMMANDS_HINT = "Commands: init \xB7 create \xB7 sync \xB7 status \xB7 context \xB7 memory \xB7 skills \xB7 task \xB7 daemon \xB7 doctor";
+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 runMenu(opts, deps) {
+  const clack = await import("@clack/prompts");
+  const project = tryProject();
+  if (shouldShowBanner(opts)) {
+    const host = project?.host ?? "claude";
+    process.stderr.write(
+      `
+${renderBanner()}
+${NOIR_TAGLINE}
+
+${hostLaunchDirective2(host)}
+${COMMANDS_HINT}
+
+`
+    );
+  }
+  clack.intro(project ? `noir \u2014 ${project.name}` : "noir");
+  const choice = await clack.select({
+    message: "What would you like to do?",
+    initialValue: "status",
+    options: [
+      { value: "status", label: "Status", hint: "project + daemon + store snapshot" },
+      { value: "index", label: "Index project", hint: "(re)index files into context" },
+      { value: "recall", label: "Recall memory", hint: "search cross-session memory" },
+      { value: "next", label: "Next task", hint: "suggest next phase + skill" },
+      { value: "handoff", label: "Handoff", hint: "ready-to-paste host prompt" },
+      { value: "daemon", label: "Start daemon", hint: "foreground daemon" },
+      { value: "sync", label: "Sync skills", hint: "re-emit builtin skills" },
+      { value: "exit", label: "Exit" }
+    ]
+  });
+  if (clack.isCancel(choice)) {
+    clack.cancel("Cancelled.");
+    fail(EXIT.CANCELLED, "cancelled", opts);
+  }
+  const argv = await argvForChoice(choice, clack, opts);
+  if (argv === null) {
+    clack.outro("bye");
+    return;
+  }
+  await deps.dispatch(argv);
+  clack.outro("done");
+}
+async function argvForChoice(choice, clack, opts) {
+  switch (choice) {
+    case "status":
+      return ["status"];
+    case "index":
+      return ["context", "index"];
+    case "next":
+      return ["task", "next"];
+    case "handoff":
+      return ["handoff"];
+    case "daemon":
+      return ["daemon", "start"];
+    case "sync":
+      return ["sync"];
+    case "exit":
+      return null;
+    case "recall": {
+      const query = await clack.text({
+        message: "Recall query:",
+        placeholder: "e.g. auth flow, ContextEngine, deploy steps"
+      });
+      if (clack.isCancel(query)) {
+        clack.cancel("Cancelled.");
+        fail(EXIT.CANCELLED, "cancelled", opts);
+      }
+      return ["memory", "recall", String(query)];
+    }
+    default:
+      return null;
+  }
+}
+
+// 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);
+  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.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) {
+  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;
+  }
+  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/skills.ts
+import { claudeAdapter } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo4 } from "@noir-ai/core";
+import {
+  discoverAll,
+  emitSkillsToDir
+} from "@noir-ai/skills";
+var CATEGORY = {
+  "noir-brainstorm": "discovery",
+  "noir-intake": "discovery",
+  "noir-clarify": "discovery",
+  "noir-explore": "discovery",
+  "noir-spec": "spec",
+  "noir-plan": "plan",
+  "noir-execute": "execute",
+  "noir-tdd": "execute",
+  "noir-debug": "execute",
+  "noir-subagent": "execute",
+  "noir-parallel": "execute",
+  "noir-verify": "verify",
+  "noir-review": "verify",
+  "noir-security": "verify",
+  "noir-test": "verify",
+  "noir-document": "document",
+  "noir-readme": "document",
+  "noir-commit": "git",
+  "noir-branch": "git",
+  "noir-pr": "git",
+  "noir-worktree": "git",
+  "noir-recall": "memory",
+  "noir-remember": "memory",
+  "noir-checkpoint": "memory",
+  "noir-context": "context",
+  "noir-frontend": "domain",
+  "noir-backend": "domain",
+  "noir-doctor": "meta",
+  "noir-skill-author": "meta",
+  "noir-sync": "meta",
+  "noir-wrap": "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 : "";
+  return { name: s.name, category: categoryOf(s.name), description, kind };
+}
+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,
+      Description: truncate(r.description, 80)
+    })),
+    ["Skill", "Kind", "Category", "Description"],
+    opts
+  );
+}
+async function skillsSync(opts) {
+  const root = process.cwd();
+  const project = loadProjectInfo4(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
+    );
+  }
+}
+
+// src/serve.ts
+import { loadProjectInfo as loadProjectInfo5 } from "@noir-ai/core";
+import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
+async function serve(opts) {
+  const project = loadProjectInfo5(process.cwd());
+  if (opts.stdio) {
+    await startStdioServer({ project, transport: "stdio", daemon: false });
+    return;
+  }
+  try {
+    const { url } = await ensureDaemonRunning2({
+      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 });
+  }
+}
+
+// src/bin.ts
+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_VERSION, "-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: (str) => process.stdout.write(str),
+    writeErr: (str) => process.stderr.write(str)
+  });
+  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)").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_HOSTS)
+  ).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 result = await init(process.cwd(), {
+        transport,
+        url: opts.url,
+        ...upgrade ? { upgrade } : {},
+        ...force ? { force } : {},
+        ...host !== void 0 ? { host } : {}
+      });
+      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)").addOption(
+    new Option(
+      "--host <id>",
+      "target agentic CLI (default: claude) \u2014 drives host-side emission"
+    ).choices(SUPPORTED_HOSTS)
+  ).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 { create } = await import("./create-U2YJH5QC.js");
+      const result = await create(dir, {
+        transport,
+        url: opts.url,
+        ...force ? { force } : {},
+        ...host !== void 0 ? { host } : {}
+      });
+      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)"
+  ).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_HOSTS)
+  ).action(
+    async (opts, cmd) => {
+      const { sync } = await import("./sync-VYRXCGK4.js");
+      const host = parseHost(opts.host);
+      const force = opts.force === true;
+      const merge = opts.merge === true;
+      const noMergeRegions = opts.mergeRegions === false;
+      const result = host === void 0 && !force && !merge && !noMergeRegions ? await sync(process.cwd()) : await sync(process.cwd(), {
+        ...host !== void 0 ? { host } : {},
+        ...force ? { force } : {},
+        ...merge ? { merge } : {},
+        ...noMergeRegions ? { mergeManagedRegions: false } : {}
+      });
+      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; backgrounding deferred)").option("--detach", "run in the background (not yet implemented; exits 2)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const detach = g.detach === true;
+    await daemonStart({ ...toCliOptions(g), ...detach ? { detach } : {} });
+  });
+  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 (S6)");
+  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", "ignore content-hash caching (recognized; not yet honored)").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 (S5)");
+  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.action(() => {
+    throw new NoirCliError(EXIT.USAGE, "Usage: noir skills list|sync");
+  });
+  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").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;
+    await taskNew({
+      ...toCliOptions(g),
+      slug,
+      ...mode === void 0 ? {} : { mode }
+    });
+  });
+  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").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 }
+    });
+  });
+  taskGrp.command("next").description("suggest the next phase + applicable skill").action(async (...args) => {
+    await taskNext(toCliOptions(trailingCmd(args).optsWithGlobals()));
+  });
+  taskGrp.action(() => {
+    throw new NoirCliError(EXIT.USAGE, "Usage: noir task new|status|advance|next");
+  });
+  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/<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/<id>.md (gitignored)").action(async (...args) => {
+    await handoff(buildHandoffOptions(trailingCmd(args).optsWithGlobals()));
+  });
+  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;
+    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);
+  });
+  const homeDeps = {
+    dispatch: async (argv) => {
+      const sub = createProgram();
+      try {
+        await sub.parseAsync([...argv], { from: "user" });
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  };
+  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();
+async function run(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 run(process.argv.slice(2));
+}
+
+// src/daemon-client.ts
+var DAEMON_DOWN_HINT = "daemon not reachable \u2014 try `noir daemon start`";
+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 = readDaemonRecord2();
+  if (!rec) {
+    if (opts.verbose) process.stderr.write("noir: daemon probe: no daemon record\n");
+    return { running: false };
+  }
+  if (!pidAlive2(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`);
+    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 ?? loadProjectInfo6(process.cwd());
+  const idleTimeoutSec = opts.idleTimeoutSec ?? project.config.daemon.idleTimeoutSec;
+  try {
+    const ensured = await ensureDaemonRunning3({ 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_VERSION2 },
+      { 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_VERSION2 },
+      { 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));
+}
+
+// src/commands/status.ts
+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_VERSION3,
+    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
+  );
+}
+async function gatherStatusPayload(opts) {
+  const project = loadProjectInfo7(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) {
+  const payload = await gatherStatusPayload(opts);
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: payload })}
+`);
+    return;
+  }
+  renderHuman(payload, opts);
+}
+
+// src/tui/App.tsx
+import { Box, Text as Text6, useApp, useInput } from "ink";
+import { useEffect, useState } from "react";
+
+// src/tui/CommandInput.tsx
+import { Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function CommandInput({ buffer, running }) {
+  if (running) {
+    return /* @__PURE__ */ jsx(Text, { children: c.dim("\u2026") });
+  }
+  if (buffer.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { children: c.dim("type a /command (e.g. /status, /sync, /task next), or q to quit") });
+  }
+  const isCommand = buffer.startsWith("/");
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { children: isCommand ? c.accent("\u25B8") : c.dim("\u25B8") }),
+    " ",
+    buffer,
+    /* @__PURE__ */ jsx(Text, { children: c.dim("\u258C") })
+  ] });
+}
+
+// src/tui/capture.ts
+async function captureProcessOutput(fn) {
+  const outChunks = [];
+  const errChunks = [];
+  const origOut = process.stdout.write.bind(process.stdout);
+  const origErr = process.stderr.write.bind(process.stderr);
+  const prevExitCode = process.exitCode;
+  process.stdout.write = ((chunk) => {
+    outChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  });
+  process.stderr.write = ((chunk) => {
+    errChunks.push(typeof chunk === "string" ? chunk : String(chunk));
+    return true;
+  });
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = origOut;
+    process.stderr.write = origErr;
+  }
+  const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
+  process.exitCode = prevExitCode;
+  return { stdout: outChunks.join(""), stderr: errChunks.join(""), exitCode };
+}
+
+// src/tui/Footer.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Footer({ running }) {
+  if (running) {
+    return /* @__PURE__ */ jsx2(Text2, { children: c.dim("running\u2026 (Ctrl+C to force exit)") });
+  }
+  return /* @__PURE__ */ jsx2(Text2, { children: c.dim("? help \xB7 q/Esc quit \xB7 \u2191/\u2193 scroll \xB7 Enter run \xB7 Ctrl+C exit") });
+}
+
+// src/tui/format.ts
+function formatStatusPayload(p) {
+  if (p === null) return null;
+  return [
+    `Project: ${p.project.name} (${p.project.id})`,
+    `Host: ${p.host}`,
+    `Noir: ${p.noir}`,
+    `Daemon: ${describeDaemon(p.daemon)}`,
+    `Store: ${describeStore(p.store)}`,
+    `Context: ${describeContext(p.context)}`,
+    `Workflow: ${describeWorkflow(p.workflow)}`,
+    `Memory: ${describeMemory(p.memory)}`
+  ];
+}
+
+// src/tui/Header.tsx
+import { Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Header({ tagline }) {
+  return /* @__PURE__ */ jsxs2(Text3, { children: [
+    c.accent("\u25C6"),
+    " ",
+    c.bold("noir"),
+    " ",
+    /* @__PURE__ */ jsx3(Text3, { children: c.dim(tagline ?? "dashboard") })
+  ] });
+}
+
+// src/tui/OutputPane.tsx
+import { Text as Text4 } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function toRows(visible) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const text of visible) {
+    const n = (seen.get(text) ?? 0) + 1;
+    seen.set(text, n);
+    rows.push({ key: n === 1 ? text || "_blank" : `${text || "_blank"}#${n}`, text });
+  }
+  return rows;
+}
+function OutputPane({
+  lines,
+  scrollOffset,
+  height = 12,
+  title
+}) {
+  const width = terminalWidth();
+  if (lines.length === 0) {
+    return /* @__PURE__ */ jsx4(Text4, { children: c.dim("(no output \u2014 type a /command, or ? for help)") });
+  }
+  const maxOffset = Math.max(0, lines.length - height);
+  const offset = Math.min(Math.max(0, scrollOffset), maxOffset);
+  const rows = toRows(lines.slice(offset, offset + height));
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    title !== void 0 ? /* @__PURE__ */ jsx4(Text4, { children: c.dim(`\u2500\u2500 ${title} \u2500\u2500`) }) : null,
+    rows.map((row) => /* @__PURE__ */ jsx4(Text4, { children: row.text.length > width ? `${row.text.slice(0, Math.max(1, width - 1))}\u2026` : row.text }, row.key))
+  ] });
+}
+
+// src/tui/StatusBar.tsx
+import { Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function Cell({
+  label,
+  value,
+  accent
+}) {
+  return /* @__PURE__ */ jsxs4(Text5, { children: [
+    /* @__PURE__ */ jsx5(Text5, { children: c.dim(`${label}:`) }),
+    " ",
+    /* @__PURE__ */ jsx5(Text5, { children: accent ? c.accent(value) : value })
+  ] });
+}
+function StatusBar({ payload, loading }) {
+  const host = payload?.host ?? "\u2014";
+  const mode = payload?.workflow?.mode ?? "\u2014";
+  const phase = payload?.workflow?.phase ?? (loading ? "\u2026" : "idle");
+  const daemonRunning = payload?.daemon.running === true;
+  const daemon = payload === null && loading ? "\u2026" : daemonRunning ? "up" : "down";
+  return /* @__PURE__ */ jsxs4(Text5, { children: [
+    /* @__PURE__ */ jsx5(Cell, { label: "host", value: host, accent: true }),
+    /* @__PURE__ */ jsx5(Text5, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx5(Cell, { label: "mode", value: mode }),
+    /* @__PURE__ */ jsx5(Text5, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx5(Cell, { label: "phase", value: phase }),
+    /* @__PURE__ */ jsx5(Text5, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsxs4(Text5, { children: [
+      c.dim("daemon:"),
+      " ",
+      daemonRunning ? c.ok(daemon) : c.warn(daemon)
+    ] })
+  ] });
+}
+
+// src/tui/App.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
+  const { exit } = useApp();
+  const [buffer, setBuffer] = useState("");
+  const [payload, setPayload] = useState(initialPayload);
+  const [loading, setLoading] = useState(initialPayload === null);
+  const [output, setOutput] = useState(null);
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [help, setHelp] = useState(false);
+  const [running, setRunning] = useState(false);
+  const [notice, setNotice] = useState(null);
+  const [pending, setPending] = useState(null);
+  useEffect(() => {
+    if (running) return;
+    let cancelled = false;
+    setLoading(true);
+    void deps.fetchStatus().then((p) => {
+      if (!cancelled) {
+        setPayload(p);
+        setLoading(false);
+      }
+    }).catch(() => {
+      if (!cancelled) {
+        setPayload(null);
+        setLoading(false);
+      }
+    });
+    const id = setInterval(() => {
+      void deps.fetchStatus().then((p) => {
+        if (!cancelled) setPayload(p);
+      }).catch(() => {
+      });
+    }, refreshMs);
+    return () => {
+      cancelled = true;
+      clearInterval(id);
+    };
+  }, [running, refreshMs, deps]);
+  useEffect(() => {
+    if (pending === null) return;
+    const argv = pending;
+    let active = true;
+    const run2 = async () => {
+      const captured = await captureProcessOutput(() => deps.dispatch(argv));
+      if (!active) return;
+      const combined = `${captured.stdout}${captured.stderr}`;
+      const lines = combined.split("\n");
+      while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+      const title = `/${argv.join(" ")} \u2192 exit ${captured.exitCode}`;
+      setOutput({ title, lines });
+      setNotice(`ran /${argv.join(" ")} \u2192 exit ${captured.exitCode}`);
+      setRunning(false);
+      setPending(null);
+      setScrollOffset(0);
+    };
+    void run2();
+    return () => {
+      active = false;
+    };
+  }, [pending, deps]);
+  useInput((input, key) => {
+    if (running) return;
+    setNotice(null);
+    if (help) {
+      if (input === "?" || key.escape || input === "q") setHelp(false);
+      return;
+    }
+    if (key.return) {
+      submit();
+      return;
+    }
+    if (key.escape) {
+      if (buffer.length > 0) setBuffer("");
+      else if (output !== null) setOutput(null);
+      else exit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setBuffer((b) => b.slice(0, -1));
+      return;
+    }
+    if (key.upArrow) {
+      setScrollOffset((o) => Math.max(0, o - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setScrollOffset((o) => o + 1);
+      return;
+    }
+    if (key.ctrl) return;
+    if (input.length === 1) {
+      if (buffer.length === 0) {
+        if (input === "q") {
+          exit();
+          return;
+        }
+        if (input === "?") {
+          setHelp(true);
+          return;
+        }
+      }
+      setBuffer((b) => b + input);
+      return;
+    }
+    if (input.length > 1) {
+      setBuffer((b) => b + input);
+    }
+  });
+  function submit() {
+    const text = buffer;
+    if (text.length === 0) return;
+    setBuffer("");
+    if (!text.startsWith("/")) {
+      setNotice("type a /command to run it (bare text is just a hint)");
+      return;
+    }
+    const argv = text.slice(1).split(/\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
+    if (argv.length === 0) {
+      setNotice("empty /command");
+      return;
+    }
+    setOutput(null);
+    setRunning(true);
+    setPending(argv);
+  }
+  if (help) {
+    return /* @__PURE__ */ jsx6(Help, {});
+  }
+  const snapshotLines = formatStatusPayload(payload);
+  const paneLines = output?.lines ?? snapshotLines ?? [];
+  const paneTitle = output?.title ?? "snapshot";
+  return /* @__PURE__ */ jsxs5(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Header, { tagline: "dashboard" }),
+    /* @__PURE__ */ jsx6(StatusBar, { payload, loading }),
+    /* @__PURE__ */ jsx6(OutputPane, { lines: paneLines, scrollOffset, title: paneTitle }),
+    /* @__PURE__ */ jsx6(CommandInput, { buffer, running }),
+    notice !== null ? /* @__PURE__ */ jsx6(Text6, { children: c.dim(notice) }) : null,
+    /* @__PURE__ */ jsx6(Footer, { running })
+  ] });
+}
+function Help() {
+  return /* @__PURE__ */ jsxs5(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Header, { tagline: "help" }),
+    /* @__PURE__ */ jsx6(Text6, { children: " " }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.bold("Keybindings") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  /&lt;command&gt;  run a Noir sub-command (e.g. /status, /sync, /task next)") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  Enter       run the typed /command") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  Esc         back: clear input \u2192 dismiss output \u2192 quit") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  q           quit (when the input is empty)") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  \u2191 / \u2193       scroll the output pane") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  ?           toggle this help") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  Ctrl+C      force exit") }),
+    /* @__PURE__ */ jsx6(Text6, { children: " " }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.bold("Commands") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  Dispatched through the same routing as `noir` at the prompt.") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim(
+      "  /status /sync /doctor /context search &lt;q&gt; /task next /memory recall &lt;q&gt;"
+    ) }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  Commands that need their own interactive prompts (e.g. a /sync with a") }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("  conflict) are best run directly \u2014 exit first with q.") }),
+    /* @__PURE__ */ jsx6(Text6, { children: " " }),
+    /* @__PURE__ */ jsx6(Text6, { children: c.dim("press ? / Esc / q to close this help") })
+  ] });
+}
+
+// src/tui/index.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function defaultFetchStatus(opts) {
+  return async () => {
+    try {
+      return await gatherStatusPayload(opts);
+    } catch {
+      return null;
+    }
+  };
+}
+async function runTui(opts, dispatch) {
+  const deps = {
+    dispatch,
+    fetchStatus: defaultFetchStatus(opts)
+  };
+  const instance = render(/* @__PURE__ */ jsx7(App, { deps }));
+  await instance.waitUntilExit();
+}
+export {
+  runTui
+};
+//# sourceMappingURL=index.js.map