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

package/dist/bin.d.ts

@@ -2,6 +2,41 @@ import { Command } from 'commander';
 import { C as CliOptions } from './output-BNE9htEm.js';
 export { E as EXIT, N as NoirCliError, f as fail, i as inferExitCode } from './output-BNE9htEm.js';
 
+/**
+ * A palette entry projecting a leaf `noir` subcommand for the TUI palette.
+ */
+interface PaletteCommand {
+    /** Space-joined argv — the stable dispatch key (e.g. `context search`). */
+    readonly id: string;
+    /** Title-cased argv joined by `: ` for the palette's human label. */
+    readonly label: string;
+    /**
+     * The raw token path, root name excluded. This is what the palette re-dispatches
+     * (it is NOT a live reference to commander's parsed argv).
+     */
+    readonly argv: readonly string[];
+    /** One-line summary; falls back to `argv.join(' ')` when the command omits one. */
+    readonly description: string;
+    /** Top-level group the command belongs to (`argv[0]`), for palette grouping. */
+    readonly category: string;
+    /** Search keywords — currently the argv tokens, used by the palette's matcher. */
+    readonly keywords: readonly string[];
+    /**
+     * True for commands that mutate the store / workflow / host artifacts (context
+     * index/forget, memory save/forget/consolidate, task new/advance, skills sync,
+     * daemon start/stop/restart, init, create, sync, install, update). The palette
+     * uses this to require confirmation before dispatch.
+     */
+    readonly destructive: boolean;
+}
+
+/**
+ * The TUI palette source (B3). Walks a FRESH {@link createProgram} at `noir tui`
+ * launch and projects every leaf subcommand into a {@link PaletteCommand}.
+ * Defined here (not in the tui) so the palette derives from the REAL command
+ * tree without the tui graph importing the bin (which would be circular).
+ */
+declare function buildPaletteCommandsForTui(): PaletteCommand[];
 /** One entry in the {@link DEPRECATIONS} registry. */
 interface DeprecationEntry {
     /** Old command form as a path prefix, e.g. `['legacy-status']` or
@@ -15,9 +50,9 @@ interface DeprecationEntry {
 }
 /**
  * Deprecation registry. **Empty today** — no `noir` command is deprecated.
- * When adding an entry, also update `docs/deprecation.md` (and, if the old
- * form still routes, add a redirect). {@link emitDeprecationHintsFor} scans
- * this on every dispatch and emits one `tip()` per match; `--no-tips` /
+ * When adding an entry, update the CHANGELOG + `docs/reference/cli.md` (and,
+ * if the old form still routes, add a redirect). {@link emitDeprecationHintsFor}
+ * scans this on every dispatch and emits one `tip()` per match; `--no-tips` /
  * `--json` suppress the hint (see {@link tip}).
  */
 declare const DEPRECATIONS: DeprecationEntry[];
@@ -39,4 +74,4 @@ declare const program: Command;
  */
 declare function run(argv?: readonly string[]): Promise<number>;
 
-export { DEPRECATIONS, type DeprecationEntry, createProgram, emitDeprecationHintsFor, program, run };
+export { DEPRECATIONS, type DeprecationEntry, buildPaletteCommandsForTui, createProgram, emitDeprecationHintsFor, program, run };

package/dist/bin.js

@@ -8,11 +8,9 @@ import {
 } from "./chunk-JUVY6L3F.js";
 import "./chunk-L7XR7EA3.js";
 import {
+  doctor,
   init
-} from "./chunk-KQYVVGOH.js";
-import {
-  doctor
-} from "./chunk-B7OKXQKF.js";
+} from "./chunk-BM3VEJ2J.js";
 import {
   EXIT,
   NoirCliError,
@@ -44,9 +42,14 @@ 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 {
@@ -74,7 +77,9 @@ async function probeDaemon(opts = {}) {
     return { running: false };
   }
   try {
-    const res = await fetch(`http://127.0.0.1:${rec.port}/health`);
+    const res = await fetch(`http://127.0.0.1:${rec.port}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
     if (!res.ok) {
       if (opts.verbose) process.stderr.write(`noir: daemon probe: /health \u2192 HTTP ${res.status}
 `);
@@ -189,6 +194,33 @@ async function withRunningDaemon(opts, fn, probe) {
 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) {
@@ -214,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 }
@@ -253,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 = {
@@ -333,7 +393,8 @@ import {
   clearDaemonRecord,
   ensureDaemonRunning as ensureDaemonRunning2,
   pidAlive as pidAlive2,
-  readDaemonRecord as readDaemonRecord2
+  readDaemonRecord as readDaemonRecord2,
+  spawnDetachedDaemon
 } from "@noir-ai/daemon";
 var MODE = "foreground";
 function formatUptime(sec) {
@@ -342,12 +403,69 @@ 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 = loadProjectInfo2(process.cwd());
   const ensured = await ensureDaemonRunning2({
     project,
     idleTimeoutSec: project.config.daemon.idleTimeoutSec
@@ -370,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;
   }
@@ -466,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 })}
@@ -655,6 +775,7 @@ async function status(opts) {
 }
 
 // src/commands/task.ts
+import { PHASES } from "@noir-ai/workflow";
 var PHASE_SKILL = {
   intake: "noir-intake",
   clarify: "noir-clarify",
@@ -698,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 })}
@@ -1179,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 }
@@ -1264,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) => {
@@ -1280,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) })),
@@ -1491,7 +1702,70 @@ async function skillsSync(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() ?? {};
@@ -1596,7 +1870,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
@@ -1611,19 +1885,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"
@@ -1633,12 +1909,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-RHFPB5Q2.js");
+      const dryRun = opts.dryRun === true || opts.preview === true;
+      const { create } = await import("./create-UO3QTGL7.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 });
@@ -1653,7 +1931,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).
@@ -1671,16 +1949,18 @@ function createProgram() {
     ).choices(SUPPORTED_HOSTS)
   ).action(
     async (opts, cmd) => {
-      const { sync } = await import("./sync-ZGCGL3OU.js");
+      const { sync } = await import("./sync-MZETGPOJ.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 });
@@ -1695,11 +1975,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()));
@@ -1741,7 +2028,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") : [];
@@ -1963,6 +2250,7 @@ export {
   DEPRECATIONS,
   EXIT,
   NoirCliError,
+  buildPaletteCommandsForTui,
   createProgram,
   emitDeprecationHintsFor,
   fail,