@noir-ai/cli 1.7.4 → 1.8.0-beta.1

package/dist/tui/index.js

@@ -4,11 +4,9 @@ import {
 } from "./chunk-FQCYGUCG.js";
 import "./chunk-X2CROVY6.js";
 import {
+  doctor,
   init
-} from "./chunk-KBM2UXAC.js";
-import {
-  doctor
-} from "./chunk-MGRKJMHG.js";
+} from "./chunk-XFBZ5X3B.js";
 import {
   EXIT,
   NoirCliError,
@@ -32,23 +30,198 @@ import {
 } from "./chunk-A2Q74DOV.js";
 
 // src/tui/index.tsx
+import { loadProjectInfo as loadProjectInfo8 } from "@noir-ai/core";
 import { render } from "ink";
 
-// src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo7, NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
-
-// src/daemon-client.ts
-import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-import { loadProjectInfo as loadProjectInfo6, NOIR_VERSION as NOIR_VERSION3 } 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 as NOIR_VERSION2 } from "@noir-ai/core";
+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 } 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);
+    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;
@@ -73,6 +246,39 @@ function toHit(raw) {
 }
 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 }
@@ -112,13 +318,8 @@ function renderSearch(data, 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 } : {};
+  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 = {
@@ -187,12 +388,13 @@ function renderStatus(data, opts) {
 }
 
 // src/commands/daemon.ts
-import { loadProjectInfo } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
 import {
   clearDaemonRecord,
-  ensureDaemonRunning,
-  pidAlive,
-  readDaemonRecord
+  ensureDaemonRunning as ensureDaemonRunning2,
+  pidAlive as pidAlive2,
+  readDaemonRecord as readDaemonRecord2,
+  spawnDetachedDaemon
 } from "@noir-ai/daemon";
 var MODE = "foreground";
 function formatUptime(sec) {
@@ -201,13 +403,70 @@ function formatUptime(sec) {
   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) {
-    fail(EXIT.USAGE, "not implemented (tracked: v1.x)", opts);
+    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 project = loadProjectInfo(process.cwd());
-  const ensured = await ensureDaemonRunning({
+  const ensured = await ensureDaemonRunning2({
     project,
     idleTimeoutSec: project.config.daemon.idleTimeoutSec
   });
@@ -229,7 +488,7 @@ async function daemonStart(opts) {
       );
       return;
     }
-    info("noir daemon: foreground mode (backgrounding deferred to v1.x). Ctrl+C to stop.", opts);
+    info("noir daemon: foreground mode. Ctrl+C to stop.", opts);
     log(`Noir daemon listening at ${ensured.url}`, opts);
     return;
   }
@@ -244,7 +503,7 @@ async function daemonStart(opts) {
   log(`Noir daemon already running at ${ensured.url}`, opts);
 }
 async function daemonStop(opts) {
-  const rec = readDaemonRecord();
+  const rec = readDaemonRecord2();
   if (!rec) {
     if (opts.json === true) {
       process.stdout.write(
@@ -290,11 +549,11 @@ async function daemonStop(opts) {
   }
 }
 async function daemonStatus(opts) {
-  const rec = readDaemonRecord();
+  const rec = readDaemonRecord2();
   if (!rec) {
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (start with `noir daemon start`).", opts);
   }
-  if (!pidAlive(rec.pid)) {
+  if (!pidAlive2(rec.pid)) {
     clearDaemonRecord();
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
   }
@@ -325,7 +584,9 @@ async function daemonStatus(opts) {
     port: rec.port,
     startedAt: rec.startedAt,
     uptimeSec,
-    mode: MODE
+    // 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 })}
@@ -350,40 +611,202 @@ import {
   hostLaunchDirective,
   resolveAdapter
 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo2, NOIR_DIR } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo4, 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;
+// 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;
+  }
 }
-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 pickStore(s) {
+  if (s?.ok !== true) return null;
+  return {
+    docCount: s.docCount,
+    vecCount: s.vecCount,
+    dbPath: s.dbPath,
+    degraded: s.degraded === true
+  };
 }
-function formatStamp(ms) {
-  if (typeof ms !== "number" || ms <= 0) return "-";
-  return new Date(ms).toISOString().replace("T", " ").replace(/\..*$/, "Z");
+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 renderStatusRow(s, opts) {
-  const flag = s.degraded === true ? `  ${badge("warn", "degraded")}` : "";
-  log(`task status \u2014 ${s.taskId}${flag}`, opts);
+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
+  );
+}
+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 { PHASES } from "@noir-ai/workflow";
+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 },
@@ -396,7 +819,49 @@ function renderStatusRow(s, opts) {
     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 })}
@@ -634,7 +1099,7 @@ async function probeOnly(opts) {
   return probeDaemon(opts);
 }
 async function handoff(opts) {
-  const project = loadProjectInfo2(process.cwd());
+  const project = loadProjectInfo4(process.cwd());
   const host = project.config.host;
   const snapshot = await gatherStatusPayload(opts);
   const probe = await probeOnly(opts);
@@ -679,8 +1144,8 @@ async function handoff(opts) {
 // src/commands/home.ts
 import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
 import {
-  loadProjectInfo as loadProjectInfo3,
-  NOIR_VERSION,
+  loadProjectInfo as loadProjectInfo5,
+  NOIR_VERSION as NOIR_VERSION3,
   readInstallRecord
 } from "@noir-ai/core";
 
@@ -719,7 +1184,7 @@ function shouldShowBanner(opts) {
 // src/commands/home.ts
 function tryProject() {
   try {
-    const info2 = loadProjectInfo3(process.cwd());
+    const info2 = loadProjectInfo5(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -749,7 +1214,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo3(process.cwd());
+        const info2 = loadProjectInfo5(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -771,7 +1236,7 @@ ${COMMANDS_HINT}
     );
   }
   const rec = readInstallRecord();
-  if (rec && shouldShowMigrationBanner(rec, NOIR_VERSION)) {
+  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).
@@ -877,6 +1342,27 @@ function stamp(ts) {
 }
 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 }
@@ -962,6 +1448,30 @@ function renderObservation(obs, opts) {
 ${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) => {
@@ -978,6 +1488,9 @@ async function memorySessions(opts) {
 `);
     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) })),
@@ -1053,7 +1566,7 @@ async function memoryConsolidate(opts) {
 
 // src/commands/skills.ts
 import { claudeAdapter } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo4 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo6 } from "@noir-ai/core";
 import {
   discoverAll,
   emitSkillsToDir
@@ -1147,7 +1660,7 @@ async function skillsList(opts) {
 }
 async function skillsSync(opts) {
   const root = process.cwd();
-  const project = loadProjectInfo4(root);
+  const project = loadProjectInfo6(root);
   if (!claudeAdapter.skillsDir) {
     const data2 = {
       emitted: [],
@@ -1190,16 +1703,16 @@ async function skillsSync(opts) {
 }
 
 // src/serve.ts
-import { loadProjectInfo as loadProjectInfo5 } from "@noir-ai/core";
-import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
+import { loadProjectInfo as loadProjectInfo7 } from "@noir-ai/core";
+import { ensureDaemonRunning as ensureDaemonRunning3, startStdioServer } from "@noir-ai/daemon";
 async function serve(opts) {
-  const project = loadProjectInfo5(process.cwd());
+  const project = loadProjectInfo7(process.cwd());
   if (opts.stdio) {
     await startStdioServer({ project, transport: "stdio", daemon: false });
     return;
   }
   try {
-    const { url } = await ensureDaemonRunning2({
+    const { url } = await ensureDaemonRunning3({
       project,
       idleTimeoutSec: project.config.daemon.idleTimeoutSec
     });
@@ -1216,7 +1729,70 @@ async function serve(opts) {
   }
 }
 
+// src/tui/commands/registry.ts
+var DESTRUCTIVE_PREFIXES = [
+  ["context", "index"],
+  ["context", "forget"],
+  ["memory", "save"],
+  ["memory", "forget"],
+  ["memory", "consolidate"],
+  ["task", "new"],
+  ["task", "advance"],
+  ["skills", "sync"],
+  ["daemon", "start"],
+  ["daemon", "stop"],
+  ["daemon", "restart"],
+  ["init"],
+  ["create"],
+  ["sync"],
+  ["install"],
+  ["update"]
+];
+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/bin.ts
+function buildPaletteCommandsForTui() {
+  return buildPaletteCommands(createProgram());
+}
 function actionGlobals(args) {
   const last = args[args.length - 1];
   return last?.optsWithGlobals() ?? {};
@@ -1283,7 +1859,7 @@ function emitDeprecationHintsFor(cmd, opts) {
 }
 function createProgram() {
   const program2 = new Command();
-  program2.name("noir").description("Noir \u2014 discipline, context, and memory layer for agentic CLIs.").version(NOIR_VERSION2, "-v, --version").addOption(new Option("--json", "emit machine-readable JSON to stdout")).addOption(new Option("--no-input", "never prompt; error if input is required")).addOption(new Option("--quiet", "suppress non-essential diagnostics")).addOption(new Option("--verbose", "show additional diagnostic detail")).addOption(new Option("--cwd <path>", "run as if started in <path>")).addOption(
+  program2.name("noir").description("Noir \u2014 discipline, context, and memory layer for agentic CLIs.").version(NOIR_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(
@@ -1321,7 +1897,7 @@ function createProgram() {
   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(
+  ).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
@@ -1336,19 +1912,21 @@ function createProgram() {
       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 } : {}
+        ...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)").addOption(
+  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"
@@ -1358,12 +1936,14 @@ function createProgram() {
       const transport = opts.transport === "streamable-http" ? "streamable-http" : "stdio";
       const force = opts.force === true;
       const host = parseHost(opts.host);
-      const { create } = await import("./create-DH2VPDVS.js");
+      const dryRun = opts.dryRun === true || opts.preview === true;
+      const { create } = await import("./create-Z5HEBB7K.js");
       const result = await create(dir, {
         transport,
         url: opts.url,
         ...force ? { force } : {},
-        ...host !== void 0 ? { host } : {}
+        ...host !== void 0 ? { host } : {},
+        ...dryRun ? { dryRun } : {}
       });
       if (cmd.optsWithGlobals().json === true && result !== void 0) {
         json({ ok: true, data: result });
@@ -1378,7 +1958,7 @@ function createProgram() {
   ).option(
     "--merge",
     "three-way merge managed regions (default since 1.3.0; flag kept for compatibility)"
-  ).addOption(
+  ).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).
@@ -1396,16 +1976,18 @@ function createProgram() {
     ).choices(SUPPORTED_HOSTS)
   ).action(
     async (opts, cmd) => {
-      const { sync } = await import("./sync-DT4JKXZK.js");
+      const { sync } = await import("./sync-5M2UEOKW.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(), {
+      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 } : {}
+        ...noMergeRegions ? { mergeManagedRegions: false } : {},
+        ...dryRun ? { dryRun } : {}
       });
       if (cmd.optsWithGlobals().json === true) {
         json({ ok: true, data: result });
@@ -1420,11 +2002,18 @@ function createProgram() {
     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) => {
+  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;
-    await daemonStart({ ...toCliOptions(g), ...detach ? { detach } : {} });
+    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()));
@@ -1466,7 +2055,7 @@ function createProgram() {
     "path to index (repeatable)",
     (val, acc) => [...acc, val],
     []
-  ).option("--force", "ignore content-hash caching (recognized; not yet honored)").action(async (...args) => {
+  ).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") : [];
@@ -1685,332 +2274,27 @@ 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);
+// src/tui/App.tsx
+import { Box as Box2, Text as Text8, useApp, useInput as useInput2 } from "ink";
+import { useEffect, useState as useState3 } 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") });
   }
-}
-function failDaemonDown(opts, cause) {
-  if (opts.verbose) {
-    process.stderr.write(`noir: daemon transport detail: ${describeCause(cause)}
-`);
+  if (buffer.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { children: c.dim("type a /command (e.g. /status, /sync, /task next), or q to quit") });
   }
-  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_VERSION3 },
-      { 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_VERSION3 },
-      { 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_VERSION4,
-    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) {
-  void runAsyncUpdateCheck({
-    env: process.env,
-    configUpdate: (() => {
-      try {
-        const info2 = loadProjectInfo7(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/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") })
-  ] });
+  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
@@ -2046,7 +2330,9 @@ 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") });
+  return /* @__PURE__ */ jsx2(Text2, { children: c.dim(
+    "? help \xB7 q/Esc quit \xB7 \u2191/\u2193 scroll \xB7 Enter run \xB7 Ctrl+K palette \xB7 Ctrl+F find \xB7 Ctrl+C exit"
+  ) });
 }
 
 // src/tui/format.ts
@@ -2077,24 +2363,70 @@ function Header({ tagline }) {
   ] });
 }
 
+// src/tui/hooks/useInputBuffer.ts
+import { useRef, useState } from "react";
+function useInputBuffer() {
+  const [buffer, setBuffer] = useState("");
+  const historyRef = useRef([]);
+  const cursorRef = useRef(-1);
+  function pushHistory(text) {
+    if (text.length === 0) return;
+    const history = historyRef.current;
+    if (history.length > 0 && history[0] === text) return;
+    historyRef.current = [text, ...history];
+  }
+  function recall(dir) {
+    const history = historyRef.current;
+    if (history.length === 0) return null;
+    let cursor = cursorRef.current;
+    if (dir === "up") {
+      cursor = cursor === -1 ? 0 : Math.min(cursor + 1, history.length - 1);
+    } else {
+      cursor = cursor === -1 ? -1 : cursor - 1;
+    }
+    cursorRef.current = cursor;
+    return cursor === -1 ? null : history[cursor] ?? null;
+  }
+  function clear() {
+    setBuffer(() => "");
+    cursorRef.current = -1;
+  }
+  return { buffer, setBuffer, pushHistory, recall, clear };
+}
+
 // 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) {
+function toRows(visible, baseIndex) {
   const rows = [];
   const seen = /* @__PURE__ */ new Map();
-  for (const text of visible) {
+  for (let i = 0; i < visible.length; i++) {
+    const text = visible[i] ?? "";
     const n = (seen.get(text) ?? 0) + 1;
     seen.set(text, n);
-    rows.push({ key: n === 1 ? text || "_blank" : `${text || "_blank"}#${n}`, text });
+    rows.push({
+      key: n === 1 ? text || "_blank" : `${text || "_blank"}#${n}`,
+      text,
+      index: baseIndex + i
+    });
   }
   return rows;
 }
+function highlightFirst(text, query) {
+  if (query.length === 0) return text;
+  const idx = text.toLowerCase().indexOf(query.toLowerCase());
+  if (idx < 0) return text;
+  return `${text.slice(0, idx)}${c.bold(text.slice(idx, idx + query.length))}${text.slice(
+    idx + query.length
+  )}`;
+}
 function OutputPane({
   lines,
   scrollOffset,
   height = 12,
-  title
+  title,
+  highlightQuery,
+  activeLine
 }) {
   const width = terminalWidth();
   if (lines.length === 0) {
@@ -2102,25 +2434,260 @@ function OutputPane({
   }
   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));
+  const rows = toRows(lines.slice(offset, offset + height), offset);
   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))
+    rows.map((row) => {
+      const truncated = row.text.length > width ? `${row.text.slice(0, Math.max(1, width - 1))}\u2026` : row.text;
+      let body = truncated;
+      if (activeLine !== void 0 && row.index === activeLine) {
+        body = c.accent(truncated);
+      } else if (highlightQuery !== void 0 && highlightQuery.length > 0) {
+        body = highlightFirst(truncated, highlightQuery);
+      }
+      return /* @__PURE__ */ jsx4(Text4, { children: body }, row.key);
+    })
   ] });
 }
 
-// src/tui/StatusBar.tsx
+// src/tui/overlays/ConfirmOverlay.tsx
 import { Text as Text5 } from "ink";
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ConfirmOverlay({ argv }) {
+  return /* @__PURE__ */ jsxs4(Text5, { children: [
+    c.warn(`! run /${argv.join(" ")}? (y/N)`),
+    /* @__PURE__ */ jsx5(Text5, { children: c.dim("  [y approve \xB7 n/Esc back to palette]") })
+  ] });
+}
+
+// src/tui/overlays/SearchMode.ts
+function computeMatches(lines, query) {
+  if (query.length === 0) return [];
+  const needle = query.toLowerCase();
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    if ((lines[i] ?? "").toLowerCase().includes(needle)) out.push(i);
+  }
+  return out;
+}
+
+// src/tui/palette/fuzzyMatch.ts
+var WEIGHTS = {
+  label: 1,
+  keyword: 0.7,
+  description: 0.5
+};
+var LABEL_TIE_BONUS = 50;
+function fuzzyScore(query, text) {
+  if (query.length === 0) return { score: 0, indices: [] };
+  const q = query.toLowerCase();
+  const t = text.toLowerCase();
+  const indices = [];
+  let score = 0;
+  let prevMatchedIndex = -1;
+  let qi = 0;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) {
+      indices.push(ti);
+      const consecutive = prevMatchedIndex !== -1 && ti === prevMatchedIndex + 1;
+      if (consecutive) score += 8;
+      if (ti < q.length) score += 4;
+      if (prevMatchedIndex !== -1) {
+        const skipped = ti - prevMatchedIndex - 1;
+        if (skipped > 0) score -= 0.1 * skipped;
+      }
+      prevMatchedIndex = ti;
+      qi++;
+    }
+  }
+  if (qi < q.length) return null;
+  return { score, indices };
+}
+function matchCommand(query, item) {
+  if (query.length === 0) {
+    return { item, score: 0, matchedIndices: [] };
+  }
+  const best = {
+    score: Number.NEGATIVE_INFINITY,
+    indices: []
+  };
+  let matched = false;
+  const consider = (score, indices) => {
+    if (!matched || score > best.score) {
+      best.score = score;
+      best.indices = indices;
+      matched = true;
+    }
+  };
+  const labelHit = fuzzyScore(query, item.label);
+  if (labelHit) {
+    consider(labelHit.score * WEIGHTS.label + LABEL_TIE_BONUS, labelHit.indices);
+  }
+  if (item.keywords) {
+    let bestKw = null;
+    for (const kw of item.keywords) {
+      const kwHit = fuzzyScore(query, kw);
+      if (kwHit && (bestKw === null || kwHit.score > bestKw.score)) bestKw = kwHit;
+    }
+    if (bestKw) {
+      consider(bestKw.score * WEIGHTS.keyword, bestKw.indices);
+    }
+  }
+  if (item.description) {
+    const descHit = fuzzyScore(query, item.description);
+    if (descHit) {
+      consider(descHit.score * WEIGHTS.description, descHit.indices);
+    }
+  }
+  if (!matched) return null;
+  return { item, score: best.score, matchedIndices: best.indices };
+}
+
+// src/tui/palette/matcher.ts
+var handRolledMatcher = {
+  search(query, items, limit) {
+    if (query.length === 0) {
+      return items.slice(0, Math.max(0, limit)).map((item) => ({
+        item,
+        score: 0,
+        matchedIndices: []
+      }));
+    }
+    const matched = [];
+    for (const item of items) {
+      const m = matchCommand(query, item);
+      if (m) matched.push(m);
+    }
+    matched.sort((a, b) => b.score - a.score);
+    return matched.slice(0, Math.max(0, limit));
+  }
+};
+
+// src/tui/palette/Palette.tsx
+import { Box, Text as Text6, useInput } from "ink";
+import { useState as useState2 } from "react";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var VISIBLE_ROWS = 10;
+var MATCH_LIMIT = 20;
+function rankPalette(query, matcher, commands, recent) {
+  if (query.length === 0) {
+    const recents = recentDeduped(recent, commands);
+    const recentIds = new Set(recents.map((r) => r.id));
+    const rest = commands.filter((cmd) => !recentIds.has(cmd.id));
+    return [
+      ...recents.map((cmd) => ({ cmd, indices: [] })),
+      ...rest.map((cmd) => ({ cmd, indices: [] }))
+    ];
+  }
+  return matcher.search(query, commands, MATCH_LIMIT).map((m) => ({
+    cmd: m.item,
+    indices: m.matchedIndices
+  }));
+}
+function highlight(label, matchedIndices) {
+  const set = new Set(matchedIndices);
+  const chars = [];
+  for (let i = 0; i < label.length; i++) {
+    const ch = label[i] ?? "";
+    chars.push(set.has(i) ? /* @__PURE__ */ jsx6(Text6, { children: c.accent(ch) }, i) : /* @__PURE__ */ jsx6(Text6, { children: ch }, i));
+  }
+  return /* @__PURE__ */ jsx6(Fragment2, { children: chars });
+}
+function Palette({
+  commands,
+  matcher,
+  recent,
+  onSelect,
+  onClose
+}) {
+  const [query, setQuery] = useState2("");
+  const [activeIndex, setActiveIndex] = useState2(0);
+  const ranked = rankPalette(query, matcher, commands, recent);
+  const visible = ranked.slice(0, VISIBLE_ROWS);
+  const active = Math.min(Math.max(activeIndex, 0), Math.max(0, visible.length - 1));
+  const recents = recentDeduped(recent, commands);
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      const hit = visible[active];
+      if (hit) onSelect(hit.cmd);
+      return;
+    }
+    if (key.upArrow) {
+      setActiveIndex((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setActiveIndex((i) => i + 1);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setActiveIndex(0);
+      return;
+    }
+    if (key.ctrl) return;
+    if (input.length > 0) {
+      setQuery((q) => q + input);
+      setActiveIndex(0);
+    }
+  });
+  const rows = [
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      c.bold("\u25B8 palette "),
+      /* @__PURE__ */ jsx6(Text6, { children: c.dim(`search (${visible.length} shown)`) })
+    ] }, "header"),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      c.dim("> "),
+      query,
+      /* @__PURE__ */ jsx6(Text6, { children: c.dim("\u258C") })
+    ] }, "query")
+  ];
+  let lastCategory = null;
+  for (const { cmd, indices } of visible) {
+    const isRecent = recents.some((r) => r.id === cmd.id);
+    if (query.length === 0) {
+      if (isRecent && lastCategory !== "recent") {
+        rows.push(/* @__PURE__ */ jsx6(Text6, { children: c.dim("\u2500\u2500 recent \u2500\u2500") }, "cat:recent"));
+        lastCategory = "recent";
+      } else if (!isRecent && cmd.category !== lastCategory) {
+        rows.push(/* @__PURE__ */ jsx6(Text6, { children: c.dim(`\u2500\u2500 ${cmd.category} \u2500\u2500`) }, `cat:${cmd.category}`));
+        lastCategory = cmd.category;
+      }
+    }
+    const prefix = cmd.id === visible[active]?.cmd.id ? "\u25B8 " : "  ";
+    rows.push(
+      /* @__PURE__ */ jsxs5(Text6, { children: [
+        isRecent && query.length === 0 ? /* @__PURE__ */ jsx6(Text6, { children: c.dim("\u21BA ") }) : null,
+        prefix,
+        highlight(cmd.label, indices),
+        /* @__PURE__ */ jsx6(Text6, { children: c.dim(`  ${cmd.description}`) })
+      ] }, cmd.id)
+    );
+  }
+  rows.push(/* @__PURE__ */ jsx6(Text6, { children: c.dim("\u2191/\u2193 navigate \xB7 Enter run \xB7 Esc close") }, "footer"));
+  return /* @__PURE__ */ jsx6(Box, { flexDirection: "column", children: rows.map((row) => row) });
+}
+function recentDeduped(recent, commands) {
+  const known = new Set(commands.map((cmd) => cmd.id));
+  return recent.filter((cmd) => known.has(cmd.id));
+}
+
+// src/tui/StatusBar.tsx
+import { Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function Cell({
   label,
   value,
   accent
 }) {
-  return /* @__PURE__ */ jsxs4(Text5, { children: [
-    /* @__PURE__ */ jsx5(Text5, { children: c.dim(`${label}:`) }),
+  return /* @__PURE__ */ jsxs6(Text7, { children: [
+    /* @__PURE__ */ jsx7(Text7, { children: c.dim(`${label}:`) }),
     " ",
-    /* @__PURE__ */ jsx5(Text5, { children: accent ? c.accent(value) : value })
+    /* @__PURE__ */ jsx7(Text7, { children: accent ? c.accent(value) : value })
   ] });
 }
 function StatusBar({ payload, loading }) {
@@ -2129,14 +2696,14 @@ function StatusBar({ payload, loading }) {
   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: [
+  return /* @__PURE__ */ jsxs6(Text7, { children: [
+    /* @__PURE__ */ jsx7(Cell, { label: "host", value: host, accent: true }),
+    /* @__PURE__ */ jsx7(Text7, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx7(Cell, { label: "mode", value: mode }),
+    /* @__PURE__ */ jsx7(Text7, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx7(Cell, { label: "phase", value: phase }),
+    /* @__PURE__ */ jsx7(Text7, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsxs6(Text7, { children: [
       c.dim("daemon:"),
       " ",
       daemonRunning ? c.ok(daemon) : c.warn(daemon)
@@ -2145,18 +2712,33 @@ function StatusBar({ payload, loading }) {
 }
 
 // src/tui/App.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs7 } 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);
+  const { buffer, setBuffer, pushHistory, recall, clear } = useInputBuffer();
+  const [mode, setMode] = useState3({ kind: "dashboard" });
+  const [payload, setPayload] = useState3(initialPayload);
+  const [loading, setLoading] = useState3(initialPayload === null);
+  const [output, setOutput] = useState3(null);
+  const [searchLines, setSearchLines] = useState3([]);
+  const [scrollOffset, setScrollOffset] = useState3(0);
+  const [help, setHelp] = useState3(false);
+  const [running, setRunning] = useState3(false);
+  const [notice, setNotice] = useState3(null);
+  const [pending, setPending] = useState3(null);
+  const [recent, setRecent] = useState3([]);
+  useEffect(() => {
+    if (!deps.loadRecent) return;
+    const loader = deps.loadRecent;
+    let cancelled = false;
+    void loader().then((entries) => {
+      if (!cancelled) setRecent(entries);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [deps.loadRecent]);
   useEffect(() => {
     if (running) return;
     let cancelled = false;
@@ -2205,7 +2787,12 @@ function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
       active = false;
     };
   }, [pending, deps]);
-  useInput((input, key) => {
+  function dispatchCmd(argv) {
+    setOutput(null);
+    setRunning(true);
+    setPending([...argv]);
+  }
+  function handleDashboardInput(input, key) {
     if (running) return;
     setNotice(null);
     if (help) {
@@ -2217,7 +2804,7 @@ function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
       return;
     }
     if (key.escape) {
-      if (buffer.length > 0) setBuffer("");
+      if (buffer.length > 0) clear();
       else if (output !== null) setOutput(null);
       else exit();
       return;
@@ -2227,14 +2814,38 @@ function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
       return;
     }
     if (key.upArrow) {
+      if (buffer === "/") {
+        const entry = recall("up");
+        if (entry !== null) {
+          setBuffer(() => entry);
+          return;
+        }
+      }
       setScrollOffset((o) => Math.max(0, o - 1));
       return;
     }
     if (key.downArrow) {
+      if (buffer === "/") {
+        const entry = recall("down");
+        if (entry !== null) {
+          setBuffer(() => entry);
+          return;
+        }
+      }
       setScrollOffset((o) => o + 1);
       return;
     }
-    if (key.ctrl) return;
+    if (key.ctrl) {
+      if (input === "k") {
+        openPalette();
+        return;
+      }
+      if (input === "f" && output !== null) {
+        openSearch();
+        return;
+      }
+      return;
+    }
     if (input.length === 1) {
       if (buffer.length === 0) {
         if (input === "q") {
@@ -2252,11 +2863,108 @@ function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
     if (input.length > 1) {
       setBuffer((b) => b + input);
     }
+  }
+  function openPalette() {
+    setMode({ kind: "palette" });
+    setNotice(null);
+  }
+  function openSearch() {
+    if (output === null) return;
+    setSearchLines(output.lines);
+    setMode({ kind: "search", query: "", matches: [], active: -1 });
+    setNotice(null);
+  }
+  function handlePaletteSelect(cmd) {
+    if (cmd.destructive) {
+      setMode({ kind: "confirm", argv: [...cmd.argv] });
+      return;
+    }
+    dispatchCmd([...cmd.argv]);
+    void recordRuns([...cmd.argv]);
+    setMode({ kind: "dashboard" });
+  }
+  function handleConfirmApprove() {
+    if (mode.kind !== "confirm") return;
+    dispatchCmd([...mode.argv]);
+    void recordRuns([...mode.argv]);
+    setMode({ kind: "dashboard" });
+  }
+  function handleConfirmDecline() {
+    setMode({ kind: "palette" });
+  }
+  function recordRuns(argv) {
+    const recorder = deps.record;
+    if (recorder) void recorder(argv);
+  }
+  function handleConfirmInput(input, key) {
+    if (key.escape || input === "n" || input === "N") {
+      handleConfirmDecline();
+      return;
+    }
+    if (input === "y" || input === "Y") {
+      handleConfirmApprove();
+      return;
+    }
+  }
+  function handleSearchInput(input, key) {
+    if (mode.kind !== "search") return;
+    if (key.escape) {
+      setMode({ kind: "dashboard" });
+      return;
+    }
+    if (key.backspace || key.delete) {
+      const nextQuery = mode.query.slice(0, -1);
+      setMode(searchFor(nextQuery));
+      return;
+    }
+    if (key.ctrl) return;
+    if (key.return) {
+      advanceActive(1);
+      return;
+    }
+    if (input === "n" && mode.matches.length > 0) {
+      advanceActive(1);
+      return;
+    }
+    if (input === "N" && mode.matches.length > 0) {
+      advanceActive(-1);
+      return;
+    }
+    if (input.length > 0) {
+      setMode(searchFor(mode.query + input));
+    }
+  }
+  function searchFor(query) {
+    const matches = computeMatches(searchLines, query);
+    return { kind: "search", query, matches, active: matches.length > 0 ? 0 : -1 };
+  }
+  function advanceActive(delta) {
+    if (mode.kind !== "search") return;
+    const n = mode.matches.length;
+    if (n === 0) return;
+    const next = (mode.active + delta + n) % n;
+    setMode({ ...mode, active: next });
+  }
+  useInput2((input, key) => {
+    switch (mode.kind) {
+      case "dashboard":
+        handleDashboardInput(input, key);
+        return;
+      case "palette":
+        return;
+      // Palette renders its own useInput; no App-level keys here
+      case "confirm":
+        handleConfirmInput(input, key);
+        return;
+      case "search":
+        handleSearchInput(input, key);
+        return;
+    }
   });
   function submit() {
     const text = buffer;
     if (text.length === 0) return;
-    setBuffer("");
+    clear();
     if (!text.startsWith("/")) {
       setNotice("type a /command to run it (bare text is just a hint)");
       return;
@@ -2266,52 +2974,160 @@ function App({ deps, initialPayload = null, refreshMs = 5e3 }) {
       setNotice("empty /command");
       return;
     }
-    setOutput(null);
-    setRunning(true);
-    setPending(argv);
+    pushHistory(text);
+    dispatchCmd(argv);
+    void recordRuns(argv);
   }
   if (help) {
-    return /* @__PURE__ */ jsx6(Help, {});
+    return /* @__PURE__ */ jsx8(Help, {});
+  }
+  if (mode.kind === "palette") {
+    return /* @__PURE__ */ jsxs7(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { tagline: "palette" }),
+      /* @__PURE__ */ jsx8(
+        Palette,
+        {
+          commands: deps.commands ?? [],
+          matcher: deps.matcher ?? handRolledMatcher,
+          recent,
+          onSelect: handlePaletteSelect,
+          onClose: () => setMode({ kind: "dashboard" })
+        }
+      ),
+      /* @__PURE__ */ jsx8(Footer, { running: false })
+    ] });
+  }
+  if (mode.kind === "confirm") {
+    return /* @__PURE__ */ jsxs7(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { tagline: "confirm" }),
+      /* @__PURE__ */ jsx8(ConfirmOverlay, { argv: mode.argv }),
+      /* @__PURE__ */ jsx8(Footer, { running: false })
+    ] });
+  }
+  if (mode.kind === "search") {
+    const activeLine = mode.active >= 0 ? mode.matches[mode.active] : void 0;
+    const matchCount = mode.matches.length;
+    return /* @__PURE__ */ jsxs7(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { tagline: "search" }),
+      /* @__PURE__ */ jsx8(
+        OutputPane,
+        {
+          lines: searchLines,
+          scrollOffset,
+          title: output?.title,
+          highlightQuery: mode.query,
+          activeLine
+        }
+      ),
+      /* @__PURE__ */ jsxs7(Text8, { children: [
+        c.dim("search: "),
+        mode.query.length > 0 ? mode.query : c.dim("(type to filter output)"),
+        /* @__PURE__ */ jsx8(Text8, { children: c.dim(" \u258C") })
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { children: c.dim(
+        matchCount === 0 ? "no matches \xB7 Esc exit" : `${mode.active + 1}/${matchCount} matches \xB7 n/Enter next \xB7 N prev \xB7 Esc exit`
+      ) }),
+      /* @__PURE__ */ jsx8(Footer, { running: false })
+    ] });
   }
   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 })
+  return /* @__PURE__ */ jsxs7(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Header, { tagline: "dashboard" }),
+    /* @__PURE__ */ jsx8(StatusBar, { payload, loading }),
+    /* @__PURE__ */ jsx8(OutputPane, { lines: paneLines, scrollOffset, title: paneTitle }),
+    /* @__PURE__ */ jsx8(CommandInput, { buffer, running }),
+    notice !== null ? /* @__PURE__ */ jsx8(Text8, { children: c.dim(notice) }) : null,
+    /* @__PURE__ */ jsx8(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(
+  return /* @__PURE__ */ jsxs7(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Header, { tagline: "help" }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.bold("Keybindings") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  /&lt;command&gt;  run a Noir sub-command (e.g. /status, /sync, /task next)") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Enter       run the typed /command") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Esc         back: clear input \u2192 dismiss output \u2192 quit") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  q           quit (when the input is empty)") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  \u2191 / \u2193       scroll the output pane") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  ?           toggle this help") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Ctrl+K      open the command palette") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Ctrl+F      find in the dispatched output pane") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  n / N       next / previous match in search (Enter = next)") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  y / n       approve / decline a destructive command prompt") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Ctrl+C      force exit") }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.bold("Commands") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Dispatched through the same routing as `noir` at the prompt.") }),
+    /* @__PURE__ */ jsx8(Text8, { 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") })
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  Commands that need their own interactive prompts (e.g. a /sync with a") }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("  conflict) are best run directly \u2014 exit first with q.") }),
+    /* @__PURE__ */ jsx8(Text8, { children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { children: c.dim("press ? / Esc / q to close this help") })
   ] });
 }
 
+// src/tui/palette/history.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } 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 ?? join2(homedir(), ".noir");
+}
+function historyFile(projectId) {
+  return join2(homeDir(), projectId, "tui-history.json");
+}
+function isHistoryEnabled() {
+  const v = process.env[TUI_HISTORY_DISABLE_ENV];
+  return v === void 0 || v === "";
+}
+function loadRecent(projectId) {
+  if (!isHistoryEnabled()) return [];
+  const file = historyFile(projectId);
+  try {
+    if (!existsSync(file)) return [];
+    const raw = readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const entries = [];
+    for (const item of parsed) {
+      if (typeof item !== "object" || item === null) continue;
+      const argv = item.argv;
+      const id = item.id;
+      if (!Array.isArray(argv) || typeof id !== "string") continue;
+      if (!argv.every((tok) => typeof tok === "string")) continue;
+      entries.push({ argv, id });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function recordRecent(projectId, argv) {
+  if (argv.length === 0) return;
+  if (!isHistoryEnabled()) return;
+  const entry = { argv, id: argv.join(" ") };
+  const current = loadRecent(projectId).filter((e) => e.id !== entry.id);
+  const next = [entry, ...current].slice(0, MAX_ENTRIES);
+  try {
+    const dir = join2(homeDir(), projectId);
+    mkdirSync2(dir, { recursive: true });
+    atomicWriteFile(historyFile(projectId), `${JSON.stringify(next, null, 2)}
+`);
+  } catch {
+  }
+}
+
 // src/tui/index.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 function defaultFetchStatus(opts) {
   return async () => {
     try {
@@ -2322,11 +3138,30 @@ function defaultFetchStatus(opts) {
   };
 }
 async function runTui(opts, dispatch) {
+  let projectId = null;
+  try {
+    projectId = loadProjectInfo8(process.cwd()).id;
+  } catch {
+    projectId = null;
+  }
   const deps = {
     dispatch,
-    fetchStatus: defaultFetchStatus(opts)
+    fetchStatus: defaultFetchStatus(opts),
+    // The palette source, derived from a fresh commander program at launch (B3).
+    commands: buildPaletteCommandsForTui(),
+    // C3 — persistent recent commands (projectId-keyed). recordRecent is async
+    // only to match the TuiDeps seam; it never rejects.
+    record: (argv) => {
+      if (projectId) recordRecent(projectId, argv);
+      return Promise.resolve();
+    },
+    loadRecent: async () => {
+      if (!projectId) return [];
+      const byId = new Map(deps.commands?.map((c2) => [c2.id, c2]) ?? []);
+      return loadRecent(projectId).map((e) => byId.get(e.id)).filter((c2) => c2 !== void 0);
+    }
   };
-  const instance = render(/* @__PURE__ */ jsx7(App, { deps }));
+  const instance = render(/* @__PURE__ */ jsx9(App, { deps }));
   await instance.waitUntilExit();
 }
 export {