@noir-ai/cli 1.0.0-beta.1

package/dist/bin.js

@@ -0,0 +1,1445 @@
+#!/usr/bin/env node
+import {
+  EXIT,
+  NoirCliError,
+  doctor,
+  fail,
+  handleError,
+  inferExitCode,
+  info,
+  init,
+  isInteractive,
+  log,
+  serve,
+  table
+} from "./chunk-UXT7YWQY.js";
+
+// src/bin.ts
+import { pathToFileURL } from "url";
+import { NOIR_VERSION as NOIR_VERSION3 } from "@noir-ai/core";
+import { Command, Option } from "commander";
+
+// src/daemon-client.ts
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { loadProjectInfo, NOIR_VERSION } from "@noir-ai/core";
+import { ensureDaemonRunning, pidAlive, readDaemonRecord } from "@noir-ai/daemon";
+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 = 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`);
+    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 || 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 || 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));
+}
+
+// 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 ? " [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 ? " [degraded: vectors skipped]" : "";
+  log(`context index \u2014 ${scope}${flag}`, opts);
+  table(
+    [
+      { Field: "Indexed (new)", Value: data.indexed },
+      { Field: "Skipped (unchanged)", Value: data.skipped },
+      { Field: "Deleted (removed)", Value: data.deleted },
+      { Field: "Failed", Value: data.failed },
+      { Field: "Total chunks", Value: data.totalChunks }
+    ],
+    ["Field", "Value"],
+    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 ? " [degraded]" : "";
+  log(`context status \u2014 ${data.projectId}${flag}`, opts);
+  table(
+    [
+      { Field: "Project", Value: data.projectId },
+      { Field: "Docs", Value: data.docCount },
+      { Field: "Vectors", Value: data.vecCount },
+      { Field: "Indexed files", Value: data.indexedFiles },
+      { Field: "Embedder", Value: describeEmbedder(data.embedder) },
+      { Field: "Degraded", Value: data.degraded ? "yes" : "no" }
+    ],
+    ["Field", "Value"],
+    opts
+  );
+}
+
+// src/commands/daemon.ts
+import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
+import {
+  clearDaemonRecord,
+  ensureDaemonRunning as ensureDaemonRunning2,
+  pidAlive as pidAlive2,
+  readDaemonRecord as readDaemonRecord2
+} 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 = loadProjectInfo2(process.cwd());
+  const ensured = await ensureDaemonRunning2({
+    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 = readDaemonRecord2();
+  if (!rec) {
+    if (opts.json === true) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, data: { running: false, stopped: false } })}
+`
+      );
+      return;
+    }
+    info("No Noir daemon is running.", opts);
+    return;
+  }
+  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 = readDaemonRecord2();
+  if (!rec) {
+    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (start with `noir daemon start`).", opts);
+  }
+  if (!pidAlive2(rec.pid)) {
+    clearDaemonRecord();
+    fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
+  }
+  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 || 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/home.ts
+import { loadProjectInfo as loadProjectInfo3 } from "@noir-ai/core";
+function tryProject() {
+  try {
+    const info2 = loadProjectInfo3(process.cwd());
+    return { id: info2.id, name: info2.name };
+  } catch {
+    return null;
+  }
+}
+async function home(opts, deps) {
+  if (isInteractive(opts)) {
+    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();
+  const banner = project ? `noir \u2014 ${project.name}` : "noir";
+  clack.intro(banner);
+  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: "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 "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 ? " [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({ Field: key, Value: obs[key] });
+  }
+  if (rows.length > 0) table(rows, ["Field", "Value"], 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 { discoverBuiltin, 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) {
+  const description = typeof s.frontmatter.description === "string" ? s.frontmatter.description : "";
+  return { name: s.name, category: categoryOf(s.name), description };
+}
+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;
+  try {
+    builtins = discoverBuiltin();
+  } catch (err) {
+    fail(
+      EXIT.ERROR,
+      `skills list: could not discover builtin skills (${err instanceof Error ? err.message : String(err)})`,
+      opts
+    );
+  }
+  const rows = builtins.map(toRow);
+  const data = { count: rows.length, skills: rows };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  log(`noir skills \u2014 ${rows.length} builtin skill${rows.length === 1 ? "" : "s"}`, opts);
+  table(
+    rows.map((r) => ({
+      Skill: r.name,
+      Category: r.category,
+      Description: truncate(r.description, 80)
+    })),
+    ["Skill", "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 data = {
+    emitted: summary.emitted,
+    references: summary.references,
+    dir
+  };
+  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
+  );
+}
+
+// src/commands/status.ts
+import { loadProjectInfo as loadProjectInfo5, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
+async function tryTool(caller, name) {
+  try {
+    return await caller.callTool(name);
+  } catch {
+    return null;
+  }
+}
+function pickStore(s) {
+  if (!s || 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(c) {
+  if (!c || c.ok !== true) return null;
+  return {
+    docCount: c.docCount,
+    vecCount: c.vecCount,
+    indexedFiles: c.indexedFiles,
+    embedder: describeEmbedder2(c.embedder),
+    degraded: c.degraded === true
+  };
+}
+function pickWorkflow(w) {
+  if (!w || 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 || 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 ? " [degraded: read-only]" : "";
+  return `${s.docCount} docs / ${s.vecCount} vecs${flag}`;
+}
+function describeContext(c) {
+  if (!c) return "unavailable (context engine not wired)";
+  const flag = c.degraded ? " [degraded]" : "";
+  return `${c.docCount} docs, ${c.vecCount} vecs, ${c.indexedFiles} files \xB7 embedder ${c.embedder}${flag}`;
+}
+function describeWorkflow(w) {
+  if (!w) return "no active task";
+  const gate = w.nextGate ? ` \u2192 next gate: ${w.nextGate}` : "";
+  const flag = w.degraded ? " [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);
+  table(
+    [
+      { Field: "Project", Value: `${p.project.name} (${p.project.id})` },
+      { Field: "Host", Value: p.host },
+      { Field: "Noir", Value: p.noir },
+      { Field: "Daemon", Value: describeDaemon(p.daemon) },
+      { Field: "Store", Value: describeStore(p.store) },
+      { Field: "Context", Value: describeContext(p.context) },
+      { Field: "Workflow", Value: describeWorkflow(p.workflow) },
+      { Field: "Memory", Value: describeMemory(p.memory) }
+    ],
+    ["Field", "Value"],
+    opts
+  );
+}
+async function status(opts) {
+  const project = loadProjectInfo5(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
+    );
+  }
+  const payload = buildPayload(project, probe, host, store, context, workflow, memory);
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: payload })}
+`);
+    return;
+  }
+  renderHuman(payload, opts);
+}
+
+// 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 ? " [degraded]" : "";
+  log(`task status \u2014 ${s.taskId}${flag}`, opts);
+  table(
+    [
+      { Field: "Task", Value: s.taskId },
+      { Field: "Phase", Value: s.phase },
+      { Field: "State", Value: s.state },
+      { Field: "Mode", Value: s.mode },
+      { Field: "Next gate", Value: s.nextGate ?? "\u2014" },
+      { Field: "Updated", Value: formatStamp(s.updatedAt) }
+    ],
+    ["Field", "Value"],
+    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 ? " [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 (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
+`);
+    return;
+  }
+  renderStatusRow(res, opts);
+}
+
+// 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
+  };
+}
+function toStatusOptions(g) {
+  return {
+    json: g.json === true,
+    quiet: g.quiet === true,
+    verbose: g.verbose === true,
+    input: g.input !== false
+  };
+}
+function createProgram() {
+  const program2 = new Command();
+  program2.name("noir").description("Noir \u2014 discipline, context, and memory layer for agentic CLIs.").version(NOIR_VERSION3, "-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>")).exitOverride((err) => {
+    throw err;
+  }).configureOutput({
+    // S9 stream discipline: data → stdout, diagnostics → stderr. Help and
+    // errors are diagnostics, so both go to stderr (keeps stdout pristine for
+    // --json payloads). commander's default error formatting is preserved.
+    writeOut: (str) => process.stderr.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)}`
+        );
+      }
+    }
+  });
+  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)").action(async (opts) => {
+    const transport = opts.transport === "streamable-http" ? "streamable-http" : "stdio";
+    await init(process.cwd(), { transport, url: opts.url });
+  });
+  program2.command("sync").description("re-emit the Noir builtin skills into the host skills dir").action(async () => {
+    const { sync } = await import("./sync-7YLRJYMR.js");
+    await sync(process.cwd());
+  });
+  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").action(async (...args) => {
+    await doctor(toCliOptions(actionGlobals(args)));
+  });
+  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 (S7)");
+  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 (S4)");
+  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");
+  });
+  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];
+    return typeof entry === "string" && entry.length > 0 ? pathToFileURL(entry).href === import.meta.url : false;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule) {
+  void run(process.argv.slice(2));
+}
+export {
+  EXIT,
+  NoirCliError,
+  createProgram,
+  fail,
+  inferExitCode,
+  program,
+  run
+};
+//# sourceMappingURL=bin.js.map