muonroi-cli 1.2.2 → 1.3.1

package/src/ui/slash/export.ts

@@ -0,0 +1,281 @@
+/**
+ * src/ui/slash/export.ts
+ *
+ * /export slash command — exports the conversation to a .txt file.
+ *
+ * Two sources of truth:
+ *   1. DB (`buildChatEntries`) — what was persisted as ModelMessages. Council
+ *      streams content via StreamChunks that never land in `messages`, so this
+ *      can come back empty even when the TUI is full of output.
+ *   2. Live TUI scrollback (`ctx.getLiveEntries`) — what the user actually
+ *      saw, including streamed council/tool/assistant chunks.
+ *
+ * The export writes BOTH (clearly labelled) when they diverge, so the user
+ * can compare what was persisted vs what was shown. When they match (typical
+ * resumed-session case), only one block is written.
+ *
+ * Self-registers on module import.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getDatabase } from "../../storage/db.js";
+import { buildChatEntries } from "../../storage/transcript.js";
+import type { ChatEntry } from "../../types/index.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+interface InteractionRow {
+  event_type: string;
+  event_subtype: string | null;
+  metadata_json: string | null;
+  created_at: string;
+}
+
+function selectInteractionTimeline(sessionId: string): InteractionRow[] {
+  try {
+    const db = getDatabase();
+    return db
+      .prepare(
+        `SELECT event_type, event_subtype, metadata_json, created_at
+         FROM interaction_logs
+         WHERE session_id = ?
+           AND event_type IN ('ui_interaction', 'routing', 'council', 'ee_injection')
+         ORDER BY created_at ASC, id ASC`,
+      )
+      .all(sessionId) as InteractionRow[];
+  } catch {
+    return [];
+  }
+}
+
+function renderInteractionTimeline(rows: readonly InteractionRow[]): string[] {
+  if (rows.length === 0) return [];
+  const lines: string[] = ["── Interaction Timeline ──", ""];
+  for (const r of rows) {
+    const ts = formatTimestamp(r.created_at);
+    const label = r.event_subtype ? `${r.event_type}.${r.event_subtype}` : r.event_type;
+    let detail = "";
+    if (r.metadata_json) {
+      try {
+        const meta = JSON.parse(r.metadata_json) as Record<string, unknown>;
+        const parts: string[] = [];
+        for (const [k, v] of Object.entries(meta)) {
+          if (v === null || v === undefined) continue;
+          // Error/diagnostic fields get a larger budget so root cause is
+          // legible directly in the timeline. Other strings stay terse.
+          const isLongField = k === "message" || k === "error" || k === "reason";
+          const cap = isLongField ? 400 : 80;
+          const vStr = typeof v === "string" ? (v.length > cap ? `${v.slice(0, cap - 3)}…` : v) : JSON.stringify(v);
+          parts.push(`${k}=${vStr}`);
+        }
+        detail = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+      } catch {
+        // Leave detail empty on bad JSON
+      }
+    }
+    lines.push(`[${ts}] ${label}${detail}`);
+  }
+  lines.push("");
+  return lines;
+}
+
+function formatTimestamp(ts: Date | string | undefined): string {
+  if (!ts) return "";
+  const d = typeof ts === "string" ? new Date(ts) : ts;
+  return d.toISOString().replace("T", " ").slice(0, 19);
+}
+
+function renderEntries(entries: readonly ChatEntry[]): string[] {
+  const lines: string[] = [];
+  for (const entry of entries) {
+    const ts = formatTimestamp(entry.timestamp);
+    switch (entry.type) {
+      case "user":
+        lines.push(`[${ts}] You:`);
+        lines.push(entry.content);
+        lines.push("");
+        break;
+      case "assistant":
+        lines.push(`[${ts}] Assistant:`);
+        lines.push(entry.content);
+        lines.push("");
+        break;
+      case "tool_result": {
+        const toolName = entry.toolCall?.function?.name ?? "unknown";
+        lines.push(`[${ts}] Tool [${toolName}]:`);
+        lines.push(entry.content);
+        lines.push("");
+        break;
+      }
+      default:
+        lines.push(`[${ts}] ${entry.type}:`);
+        lines.push(entry.content);
+        lines.push("");
+        break;
+    }
+  }
+  return lines;
+}
+
+/**
+ * Quick structural signature so we can detect whether DB and live scrollback
+ * are telling the same story without doing a full content diff. We compare
+ * total entry count and the count of each kind — if those match, the two
+ * sources almost certainly agree and we can emit a single block.
+ */
+function signature(entries: readonly ChatEntry[]): string {
+  const counts: Record<string, number> = {};
+  for (const e of entries) counts[e.type] = (counts[e.type] ?? 0) + 1;
+  return (
+    `n=${entries.length} ` +
+    Object.entries(counts)
+      .sort()
+      .map(([k, v]) => `${k}:${v}`)
+      .join(" ")
+  );
+}
+
+function formatExport(
+  dbEntries: readonly ChatEntry[],
+  liveEntries: readonly ChatEntry[],
+  timeline: readonly InteractionRow[],
+): { text: string; mode: "db_only" | "live_only" | "merged" | "synced" } {
+  const timelineBlock = renderInteractionTimeline(timeline);
+  const dbSig = signature(dbEntries);
+  const liveSig = signature(liveEntries);
+  const header: string[] = [
+    "=".repeat(72),
+    "  muonroi-cli — Chat Export",
+    "  Exported: " + formatTimestamp(new Date()),
+    `  DB entries:    ${dbEntries.length}`,
+    `  Live entries:  ${liveEntries.length}`,
+    `  Timeline rows: ${timeline.length}`,
+    "=".repeat(72),
+    "",
+  ];
+
+  // Case 1: DB and live agree — single block, source=db (canonical).
+  if (dbSig === liveSig && dbEntries.length > 0) {
+    return {
+      text: [
+        ...header,
+        "(DB and TUI scrollback match — single rendering)",
+        "",
+        ...timelineBlock,
+        ...renderEntries(dbEntries),
+        "=".repeat(72),
+        "  End of export",
+        "=".repeat(72),
+      ].join("\n"),
+      mode: "synced",
+    };
+  }
+
+  // Case 2: DB empty, live has content — common for council-only sessions
+  // where stream chunks bypass persistence. Use live as the source of truth.
+  if (dbEntries.length === 0 && liveEntries.length > 0) {
+    return {
+      text: [
+        ...header,
+        `NOTE: Database has 0 entries but TUI scrollback has ${liveEntries.length}. This usually`,
+        `means the conversation consisted of streamed chunks (council debate, tool traces)`,
+        `that render to the TUI but are not persisted as ModelMessages. Showing TUI scrollback.`,
+        "",
+        ...timelineBlock,
+        "── TUI Scrollback (in-memory) ──",
+        "",
+        ...renderEntries(liveEntries),
+        "=".repeat(72),
+        "  End of export",
+        "=".repeat(72),
+      ].join("\n"),
+      mode: "live_only",
+    };
+  }
+
+  // Case 3: Live empty, DB has content — slash invoked without TUI context
+  // (e.g., a non-interactive caller). Just render DB.
+  if (liveEntries.length === 0 && dbEntries.length > 0) {
+    return {
+      text: [
+        ...header,
+        "(Live scrollback unavailable — showing DB only)",
+        "",
+        ...timelineBlock,
+        ...renderEntries(dbEntries),
+        "=".repeat(72),
+        "  End of export",
+        "=".repeat(72),
+      ].join("\n"),
+      mode: "db_only",
+    };
+  }
+
+  // Case 4: Both have content but they disagree — emit both, side by side,
+  // so the caller can diff. This is the most useful mode for debugging why
+  // a council session "looked full" but persisted little.
+  return {
+    text: [
+      ...header,
+      `WARNING: DB and TUI scrollback disagree.`,
+      `  DB signature:    ${dbSig}`,
+      `  Live signature:  ${liveSig}`,
+      `Both renderings are included below for comparison.`,
+      "",
+      ...timelineBlock,
+      "─".repeat(72),
+      "── Section A: Persisted (DB)",
+      "─".repeat(72),
+      "",
+      ...renderEntries(dbEntries),
+      "─".repeat(72),
+      "── Section B: Live TUI Scrollback",
+      "─".repeat(72),
+      "",
+      ...renderEntries(liveEntries),
+      "=".repeat(72),
+      "  End of export",
+      "=".repeat(72),
+    ].join("\n"),
+    mode: "merged",
+  };
+}
+
+export const handleExportSlash: SlashHandler = async (_args, ctx) => {
+  const sessionId = ctx.sessionId;
+  if (!sessionId) {
+    return "No active session. Start a conversation first.";
+  }
+
+  const dbEntries = buildChatEntries(sessionId);
+  const liveEntries = ctx.getLiveEntries?.() ?? [];
+  const timeline = selectInteractionTimeline(sessionId);
+
+  if (dbEntries.length === 0 && liveEntries.length === 0 && timeline.length === 0) {
+    return "No messages in the current session to export (DB, TUI scrollback, and timeline are all empty).";
+  }
+
+  const { text, mode } = formatExport(dbEntries, liveEntries, timeline);
+
+  const fileName = `chat-export-${sessionId}.txt`;
+  const filePath = path.resolve(ctx.cwd, fileName);
+
+  try {
+    fs.writeFileSync(filePath, text, "utf-8");
+    const modeNote =
+      mode === "synced"
+        ? "DB and TUI matched"
+        : mode === "db_only"
+          ? "DB only (no TUI scrollback)"
+          : mode === "live_only"
+            ? `TUI scrollback only (DB had 0 entries; ${liveEntries.length} live)`
+            : `DB and TUI diverged — both included (db=${dbEntries.length}, live=${liveEntries.length})`;
+    return `Exported to ${filePath} (${(text.length / 1024).toFixed(1)} KB) — ${modeNote}`;
+  } catch (err) {
+    return `Failed to write export file: ${err instanceof Error ? err.message : String(err)}`;
+  }
+};
+
+// Self-register on module import
+registerSlash("export", handleExportSlash);

package/src/ui/slash/ideal.ts

@@ -0,0 +1,254 @@
+/**
+ * src/ui/slash/ideal.ts
+ *
+ * `/ideal` — Product Ideal Loop slash command (Phase 13).
+ *
+ * Subcommands:
+ *   /ideal "<idea>"          start a new product run (default)
+ *   /ideal status            list active runs
+ *   /ideal status <runId>    detail of one run
+ *   /ideal resume <runId>    resume halted/crashed run
+ *   /ideal abort  <runId>    hard kill
+ *   /ideal ship   <runId>    force user-approval gate (skip if Cond #1-#4 pass)
+ *
+ * Flags (all optional):
+ *   --max-cost       <usd>   default 50,  range 1..1000
+ *   --max-sprints    <n>     default 8,   range 1..20
+ *   --done-threshold <0..1>  default 0.9, range 0.7..1.0   (clamped, warning emitted)
+ *   --stack          <text>  free-form stack hint
+ *
+ * Internal-only env hatch (intentionally not registered with commander so it
+ * does not appear in --help):
+ *   MUONROI_DEV=1  -> enables --no-customer-debate at the done-gate.
+ *
+ * Wire format: returns the sentinel string `__PRODUCT_LOOP__\n<json>` which
+ * app.tsx parses and dispatches to orchestrator.runProductLoopV1, mirroring
+ * the existing __COUNCIL__ pattern in src/ui/slash/council.ts.
+ */
+
+import { Command, InvalidArgumentError } from "commander";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export interface IdealFlags {
+  maxCost: number;
+  maxSprints: number;
+  doneThreshold: number;
+  stack?: string;
+  /** Set internally when MUONROI_DEV=1; never accepted as a CLI flag. */
+  noCustomerDebate?: boolean;
+  /** P5: --no-prior-context skips cross-run workspace memory injection. */
+  noPriorContext?: boolean;
+  /** P2.7: --force-council always runs full council debate even for low-complexity ideas. */
+  forceCouncil?: boolean;
+}
+
+export type IdealSubcommand = "start" | "status" | "resume" | "abort" | "ship" | "help";
+
+export interface IdealParseResult {
+  subcommand: IdealSubcommand;
+  idea?: string;
+  runId?: string;
+  flags: IdealFlags;
+  warnings: string[];
+}
+
+const DEFAULTS: IdealFlags = {
+  maxCost: 50,
+  maxSprints: 8,
+  doneThreshold: 0.9,
+};
+
+const HELP_TEXT = [
+  "/ideal — Product Ideal Loop",
+  "",
+  "Subcommands:",
+  '  /ideal "<idea>"           Start a new product run',
+  "  /ideal status [runId]    List active runs (or detail one)",
+  "  /ideal resume <runId>    Resume a halted / crashed run",
+  "  /ideal abort  <runId>    Hard-kill a run",
+  "  /ideal ship   <runId>    Force user-approval gate (skip Cond #1-#4 if passing)",
+  "",
+  "Flags (start only):",
+  "  --max-cost       <usd>   default 50,  range 1..1000",
+  "  --max-sprints    <n>     default 8,   range 1..20",
+  "  --done-threshold <0..1>  default 0.9, range 0.7..1.0 (clamped)",
+  "  --stack          <hint>  free-form stack description",
+  "  --no-prior-context       skip cross-run workspace memory (greenfield)",
+  "  --force-council          always run full council debate even for low-complexity ideas",
+].join("\n");
+
+function parseIntInRange(min: number, max: number) {
+  return (raw: string): number => {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < min || n > max) {
+      throw new InvalidArgumentError(`must be an integer in [${min}, ${max}]`);
+    }
+    return n;
+  };
+}
+
+function parseFloatInRange(min: number, max: number) {
+  return (raw: string): number => {
+    const n = Number.parseFloat(raw);
+    if (!Number.isFinite(n) || n < min || n > max) {
+      throw new InvalidArgumentError(`must be a number in [${min}, ${max}]`);
+    }
+    return n;
+  };
+}
+
+/**
+ * Pure parser — exported so tests can exercise it without wiring through the
+ * SlashHandler signature (which depends on a SlashContext).
+ */
+export function parseIdealArgs(args: string[]): IdealParseResult {
+  const warnings: string[] = [];
+
+  // Internal dev escape hatch: NOT registered with commander.
+  // Intentionally not surfaced in --help.
+  const noCustomerDebate = process.env.MUONROI_DEV === "1" || undefined;
+
+  // No args at all -> help.
+  if (args.length === 0) {
+    return { subcommand: "help", flags: { ...DEFAULTS, noCustomerDebate }, warnings };
+  }
+
+  // Detect non-start subcommands by first token (subcommand keywords are reserved).
+  const RESERVED = new Set(["status", "resume", "abort", "ship", "help", "--help", "-h"]);
+  const head = args[0]!;
+
+  if (RESERVED.has(head)) {
+    if (head === "help" || head === "--help" || head === "-h") {
+      return { subcommand: "help", flags: { ...DEFAULTS, noCustomerDebate }, warnings };
+    }
+    const sub = head as IdealSubcommand;
+    const runId = args[1];
+    return {
+      subcommand: sub,
+      runId,
+      flags: { ...DEFAULTS, noCustomerDebate },
+      warnings,
+    };
+  }
+
+  // Otherwise: start. Build a fresh commander program scoped to this invocation.
+  const program = new Command();
+  program
+    .name("ideal")
+    .description("Start a new product run")
+    .argument("[idea...]", "free-form product idea")
+    .option("--max-cost <usd>", "max cost in USD (1..1000)", parseIntInRange(1, 1000), DEFAULTS.maxCost)
+    .option("--max-sprints <n>", "max sprints (1..20)", parseIntInRange(1, 20), DEFAULTS.maxSprints)
+    .option(
+      "--done-threshold <ratio>",
+      "done threshold (0.7..1.0)",
+      (raw: string) => {
+        // Soft-clamp + warn rather than throw so a typo doesn't abort the workflow.
+        const n = Number.parseFloat(raw);
+        if (!Number.isFinite(n)) {
+          throw new InvalidArgumentError("must be a number");
+        }
+        if (n < 0.7) {
+          warnings.push(`--done-threshold ${n} below 0.7 — clamped to 0.7`);
+          return 0.7;
+        }
+        if (n > 1.0) {
+          warnings.push(`--done-threshold ${n} above 1.0 — clamped to 1.0`);
+          return 1.0;
+        }
+        return n;
+      },
+      DEFAULTS.doneThreshold,
+    )
+    .option("--stack <text>", "tech stack hint")
+    .option("--no-prior-context", "skip cross-run workspace memory (greenfield start)")
+    .option("--force-council", "always run full council debate even for low-complexity ideas")
+    .exitOverride(); // never call process.exit on parse error
+
+  // commander expects a leading argv with [node, script, ...args]; we synthesize.
+  let parsed: ReturnType<typeof program.parse>;
+  try {
+    parsed = program.parse(args, { from: "user" });
+  } catch (err: any) {
+    // Surface parse error as help-with-error so the slash handler returns text
+    // rather than crashing the host process.
+    return {
+      subcommand: "help",
+      flags: { ...DEFAULTS, noCustomerDebate },
+      warnings: [`error: ${err?.message ?? String(err)}`],
+    };
+  }
+
+  const opts = parsed.opts() as {
+    maxCost: number;
+    maxSprints: number;
+    doneThreshold: number;
+    stack?: string;
+    /** Commander emits priorContext=false when user passes --no-prior-context. */
+    priorContext?: boolean;
+    forceCouncil?: boolean;
+  };
+  const ideaParts = (parsed.args as string[]) ?? [];
+  const idea = ideaParts
+    .join(" ")
+    .trim()
+    .replace(/^["']|["']$/g, "");
+
+  if (!idea) {
+    return {
+      subcommand: "help",
+      flags: { ...DEFAULTS, noCustomerDebate },
+      warnings: ["error: idea is required"],
+    };
+  }
+
+  return {
+    subcommand: "start",
+    idea,
+    flags: {
+      maxCost: opts.maxCost,
+      maxSprints: opts.maxSprints,
+      doneThreshold: opts.doneThreshold,
+      stack: opts.stack,
+      noCustomerDebate,
+      noPriorContext: opts.priorContext === false ? true : undefined,
+      forceCouncil: opts.forceCouncil === true ? true : undefined,
+    },
+    warnings,
+  };
+}
+
+/**
+ * Slash handler. Returns a sentinel string parseable by app.tsx, OR a help/error
+ * string when no orchestrator dispatch is appropriate.
+ */
+export const handleIdealSlash: SlashHandler = async (args) => {
+  const result = parseIdealArgs(args);
+
+  if (result.subcommand === "help") {
+    const warnings = result.warnings.length ? `\n\n${result.warnings.join("\n")}` : "";
+    return `${HELP_TEXT}${warnings}`;
+  }
+
+  // Status/abort/resume/ship without a runId: status is allowed (lists), the rest are not.
+  if (result.subcommand !== "start" && result.subcommand !== "status" && !result.runId) {
+    return `error: /ideal ${result.subcommand} requires a runId\n\n${HELP_TEXT}`;
+  }
+
+  const payload = {
+    subcommand: result.subcommand,
+    idea: result.idea,
+    runId: result.runId,
+    flags: result.flags,
+  };
+  const warningPrefix = result.warnings.length ? `${result.warnings.join("\n")}\n` : "";
+  return `${warningPrefix}__PRODUCT_LOOP__\n${JSON.stringify(payload)}`;
+};
+
+/** Returned for --help introspection in tests. */
+export function getIdealHelpText(): string {
+  return HELP_TEXT;
+}
+
+registerSlash("ideal", handleIdealSlash);

package/src/ui/slash/menu-items.ts

@@ -0,0 +1,106 @@
+/**
+ * Slash command autocomplete menu — single source of truth.
+ *
+ * Extracted from app.tsx so:
+ *  1. Tests can verify drift between this list and the runtime registry
+ *     without importing the full Ink/React UI module.
+ *  2. New slash commands have ONE place to register their menu entry.
+ *
+ * Built-in commands (exit, help, clear, compact, mcp, agents, sandbox, wallet,
+ * models, sessions, commit-*, review, verify, skills, btw, update, debug-*,
+ * ee-*) are NOT in the runtime registry — they are handled by legacy switch
+ * statements in app.tsx and live here as the only definition.
+ *
+ * Registry-backed commands (route, plan, execute, discuss, expand, optimize,
+ * debug, council, cost, ee, pin, ideal) MUST appear here too — the parity
+ * test in __tests__/menu-parity.test.ts enforces this.
+ */
+
+export interface SlashMenuItem {
+  id: string;
+  label: string;
+  description: string;
+  /**
+   * When true the command is still routable (typed in full + Enter still works,
+   * parity test still passes) but does NOT appear in the autocomplete dropdown
+   * or `/help` listing. Use to declutter the splash for commands that exist
+   * but are not part of the current "primary surface".
+   */
+  hidden?: boolean;
+}
+
+/**
+ * Visible-by-default commands shown in the autocomplete dropdown.
+ * Curated set per product decision (2026-05-21): keep only the primary
+ * surface (exit, providers, compact, clear, ideal, council). Everything
+ * else is `hidden: true` and still works when typed in full.
+ *
+ * To promote a hidden command back into the dropdown, remove `hidden: true`.
+ * To add a new command, append here AND register its handler via
+ * `registerSlash` (parity test enforces this).
+ */
+export const SLASH_MENU_ITEMS: SlashMenuItem[] = [
+  // ── Primary surface ────────────────────────────────────────────────────
+  { id: "exit", label: "exit", description: "Quit the CLI" },
+  { id: "providers", label: "providers", description: "Manage providers + API keys (enable/disable, set default)" },
+  { id: "compact", label: "compact", description: "Compact conversation context" },
+  { id: "clear", label: "clear", description: "Clear conversation and start fresh" },
+  { id: "ideal", label: "ideal", description: "Product Ideal Loop — autonomous build from idea to ship" },
+  { id: "council", label: "council", description: "Multi-model adversarial debate" },
+  // ── Hidden (still functional when typed in full) ───────────────────────
+  { id: "help", label: "help", description: "Show available commands", hidden: true },
+  { id: "config", label: "config", description: "Open provider and council configuration", hidden: true },
+  { id: "remote-control", label: "remote-control", description: "Remote control", hidden: true },
+  { id: "agents", label: "agents", description: "Manage custom sub-agents", hidden: true },
+  { id: "schedule", label: "schedule", description: "View scheduled runs", hidden: true },
+  { id: "mcp", label: "mcp", description: "Manage MCP servers", hidden: true },
+  { id: "sandbox", label: "sandbox", description: "Select shell sandbox mode", hidden: true },
+  { id: "wallet", label: "wallet", description: "Wallet and payment settings", hidden: true },
+  { id: "models", label: "models", description: "Alias of /providers", hidden: true },
+  { id: "new", label: "new session", description: "Start a new session", hidden: true },
+  { id: "sessions", label: "sessions", description: "List recent sessions to resume", hidden: true },
+  { id: "commit-push", label: "commit & push", description: "Commit and push", hidden: true },
+  { id: "commit-pr", label: "commit & pr", description: "Commit and open PR", hidden: true },
+  { id: "review", label: "review", description: "Review recent changes", hidden: true },
+  { id: "verify", label: "verify", description: "Run local verification", hidden: true },
+  { id: "skills", label: "skills", description: "Manage skills", hidden: true },
+  { id: "btw", label: "btw", description: "Ask a side question without interrupting", hidden: true },
+  { id: "update", label: "update", description: "Update muonroi-cli to the latest version", hidden: true },
+  { id: "cost", label: "cost", description: "Show session cost breakdown", hidden: true },
+  { id: "ee", label: "ee", description: "Experience Engine status and controls", hidden: true },
+  { id: "route", label: "route", description: "Show current model routing info", hidden: true },
+  { id: "plan", label: "plan", description: "Show active GSD plan", hidden: true },
+  { id: "execute", label: "execute", description: "Execute active GSD plan", hidden: true },
+  { id: "discuss", label: "discuss", description: "Discuss phase gray areas", hidden: true },
+  { id: "expand", label: "expand", description: "Expand last compacted context", hidden: true },
+  { id: "optimize", label: "optimize", description: "Optimize prompt for token savings", hidden: true },
+  { id: "debug", label: "debug", description: "Toggle debug trace mode", hidden: true },
+  { id: "debug-on", label: "debug on", description: "Enable pipeline debug tracing", hidden: true },
+  { id: "debug-off", label: "debug off", description: "Disable pipeline debug tracing", hidden: true },
+  { id: "debug-status", label: "debug status", description: "Show session debug summary", hidden: true },
+  { id: "debug-last", label: "debug last", description: "Show last recorded trace", hidden: true },
+  {
+    id: "council-inspect",
+    label: "council inspect",
+    description: "Inspect a past council debate by session ID",
+    hidden: true,
+  },
+  { id: "pin", label: "pin", description: "Pin a user message so it survives compaction", hidden: true },
+  { id: "unpin", label: "unpin", description: "Remove a pinned message by sequence number", hidden: true },
+  { id: "pins", label: "pins", description: "List currently pinned message sequences", hidden: true },
+  { id: "ee-stats", label: "ee stats", description: "Knowledge base statistics", hidden: true },
+  { id: "ee-gates", label: "ee gates", description: "Quality gate checklist", hidden: true },
+  { id: "ee-evolve", label: "ee evolve", description: "Trigger EE evolution cycle", hidden: true },
+  { id: "ee-user", label: "ee user", description: "Current EE user identity", hidden: true },
+  { id: "ee-search", label: "ee search", description: "Semantic search across knowledge base", hidden: true },
+  { id: "ee-timeline", label: "ee timeline", description: "Principle evolution for a topic", hidden: true },
+  { id: "ee-graph", label: "ee graph", description: "Principle relationship graph", hidden: true },
+  { id: "ee-route", label: "ee route", description: "Route task to workflow", hidden: true },
+  { id: "ee-context-on", label: "ee-context on", description: "Enable BB-aware EE context injection", hidden: true },
+  { id: "ee-context-off", label: "ee-context off", description: "Disable BB-aware EE context injection", hidden: true },
+  { id: "ee-context-status", label: "ee-context status", description: "Show current BB-context setting", hidden: true },
+  { id: "export", label: "export", description: "Export entire conversation to a .txt file", hidden: true },
+];
+
+/** Items shown in the splash autocomplete + /help listing. */
+export const VISIBLE_SLASH_MENU_ITEMS: SlashMenuItem[] = SLASH_MENU_ITEMS.filter((m) => !m.hidden);

package/src/ui/slash/optimize.ts

@@ -25,7 +25,7 @@ function formatPilTable(ctx: PipelineContext): string {
   let metricsBlock = "";
   if (ctx.metrics) {
     const m = ctx.metrics;
-    metricsBlock = `\n\nMetrics:\n  total pipeline: ${m.totalMs}ms\n  input chars: ${m.inputChars}\n  output chars: ${m.outputChars}\n  est. tokens saved: ${m.estimatedTokensSaved}\n  layer timings:\n${m.layerTimings.map((t) => `    ${t.name.padEnd(28)} ${t.ms}ms`).join("\n")}`;
+    metricsBlock = `\n\nMetrics:\n  total pipeline: ${m.totalMs}ms\n  input chars: ${m.inputChars}\n  output chars: ${m.outputChars}\n  L6 suffix input cost: ${m.suffixInstructionTokens} tok\n  layer timings:\n${m.layerTimings.map((t) => `    ${t.name.padEnd(28)} ${t.ms}ms`).join("\n")}`;
   }
 
   const outputMode = `Output mode: ${getLastOutputMode()}`;