muonroi-cli 1.2.0

package/src/ui/slash/cost.ts

@@ -0,0 +1,59 @@
+/**
+ * src/ui/slash/cost.ts
+ *
+ * /cost slash command handler (USAGE-08).
+ * Prints current status-bar contents: model, tier, tokens, USD/session, USD/month.
+ * Reads directly from statusBarStore.getState() — works even without an active run.
+ *
+ * Self-registers on module import.
+ */
+
+import { getDefaultEEClient } from "../../ee/intercept.js";
+import { healthDetailed } from "../../ee/health.js";
+import { statusBarStore } from "../status-bar/store.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleCostSlash: SlashHandler = async (_args, _ctx) => {
+  const s = statusBarStore.getState();
+  const lines = [
+    `Provider: ${s.provider || "(none)"}`,
+    `Model:    ${s.model || "(none)"}`,
+    `Tier:     ${s.tier}`,
+    `Tokens:   ${s.in_tokens} in / ${s.out_tokens} out`,
+    `Session:  $${s.session_usd.toFixed(4)}`,
+    `Month:    $${s.month_usd.toFixed(4)} / $${s.cap_usd.toFixed(2)} (${s.current_pct.toFixed(1)}%)`,
+  ];
+
+  // EE health + activity pulse
+  try {
+    const h = await healthDetailed();
+    const modeLabel = h.mode === "thin-client" ? "Thin Client → VPS" : "Local";
+    const statusIcon = h.ok ? "✓" : "✗";
+    lines.push("");
+    lines.push("**EE Health**");
+    lines.push(`  ${statusIcon} Mode: ${modeLabel}  |  Circuit: ${h.circuit}  |  Server: ${h.components.server.ok ? "UP" : `DOWN (${h.components.server.status})`}`);
+    if (h.components.gates) {
+      lines.push(`  Gates: ${h.components.gates.ok ? "UP" : `DOWN (${h.components.gates.status})`}`);
+    }
+  } catch {
+    lines.push("");
+    lines.push("**EE Health**");
+    lines.push("  ✗ Unreachable");
+  }
+
+  try {
+    const ee = await getDefaultEEClient().stats();
+    if (ee) {
+      lines.push("**EE Activity**");
+      lines.push(`  Intercepts: ${ee.totalIntercepts}  |  Suggestions: ${ee.suggestions}  |  Lessons: ${ee.lessonsStored ?? 0}`);
+    }
+  } catch {
+    // EE unreachable — silently skip
+  }
+
+  return lines.join("\n");
+};
+
+// Self-register on module import
+registerSlash("cost", handleCostSlash);

package/src/ui/slash/council.ts

@@ -0,0 +1,27 @@
+import { getRoleModels } from "../../utils/settings.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleCouncilSlash: SlashHandler = async (args, ctx) => {
+  let rounds: number | undefined;
+  const firstArg = args[0];
+  if (firstArg && /^\d+$/.test(firstArg)) {
+    rounds = Math.max(1, Math.min(5, parseInt(firstArg, 10)));
+    args = args.slice(1);
+  }
+
+  const topic = args.join(" ") || ctx.lastPrompt || "";
+  if (!topic) {
+    return "/council [rounds] <topic> — multi-model adversarial debate\nExample: /council 3 REST vs gRPC for our microservices";
+  }
+
+  const roles = getRoleModels();
+  if (Object.keys(roles).length === 0) {
+    return "/council: no roleModels configured. Add to ~/.muonroi-cli/user-settings.json:\n" +
+      '  "roleModels": { "leader": "claude-sonnet-4-6", "implement": "deepseek-chat", "verify": "gpt-4o", "research": "grok-3" }';
+  }
+
+  return `__COUNCIL__\n${rounds ?? ""}\n${topic}`;
+};
+
+registerSlash("council", handleCouncilSlash);

package/src/ui/slash/debug.ts

@@ -0,0 +1,153 @@
+/**
+ * /debug slash command — toggle pipeline debug tracing.
+ *
+ * When ON: each turn prints a trace showing every step from input to output:
+ *   PIL layers → Router decision → EE hooks → Model call → Token savings
+ *
+ * Usage:
+ *   /debug        — toggle on/off
+ *   /debug on     — enable
+ *   /debug off    — disable
+ *   /debug status — show current pipeline state without toggling
+ */
+
+import { statusBarStore } from "../status-bar/store.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+let debugEnabled = false;
+let turnTraces: TurnTrace[] = [];
+
+export interface PipelineStep {
+  name: string;
+  duration_ms: number;
+  input_summary: string;
+  output_summary: string;
+  tokens_saved?: number;
+}
+
+export interface TurnTrace {
+  turn_id: number;
+  timestamp: number;
+  raw_prompt: string;
+  steps: PipelineStep[];
+  model_requested: string;
+  model_used: string;
+  routed: boolean;
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cost_usd: number;
+  estimated_savings: SavingsEstimate;
+}
+
+export interface SavingsEstimate {
+  pil_tokens_saved: number;
+  cache_tokens_saved: number;
+  router_cost_saved_usd: number;
+  total_tokens_saved: number;
+  total_cost_saved_usd: number;
+}
+
+export function isDebugEnabled(): boolean {
+  return debugEnabled;
+}
+
+export function recordTurnTrace(trace: TurnTrace): void {
+  if (!debugEnabled) return;
+  turnTraces.push(trace);
+  if (turnTraces.length > 50) turnTraces.shift();
+}
+
+export function getLastTrace(): TurnTrace | null {
+  return turnTraces[turnTraces.length - 1] ?? null;
+}
+
+function formatTrace(trace: TurnTrace): string {
+  const lines: string[] = [];
+  lines.push(`┌─ Turn #${trace.turn_id} ─────────────────────────────────`);
+  lines.push(`│ Prompt: "${trace.raw_prompt.slice(0, 80)}${trace.raw_prompt.length > 80 ? "..." : ""}"`);
+  lines.push("│");
+
+  for (const step of trace.steps) {
+    const dur = step.duration_ms < 1 ? "<1ms" : `${step.duration_ms}ms`;
+    const saved = step.tokens_saved ? ` (saved ~${step.tokens_saved} tok)` : "";
+    lines.push(`│ ▸ ${step.name} [${dur}]${saved}`);
+    if (step.input_summary) lines.push(`│   in:  ${step.input_summary}`);
+    if (step.output_summary) lines.push(`│   out: ${step.output_summary}`);
+  }
+
+  lines.push("│");
+  const routeLabel = trace.routed
+    ? `${trace.model_requested} → ${trace.model_used} (routed)`
+    : trace.model_used;
+  lines.push(`│ Model: ${routeLabel}`);
+  lines.push(`│ Tokens: ↑${trace.input_tokens} ↓${trace.output_tokens}${trace.cache_read_tokens ? ` ⊚${trace.cache_read_tokens}` : ""} | Cost: $${trace.cost_usd.toFixed(4)}`);
+
+  const s = trace.estimated_savings;
+  if (s.total_tokens_saved > 0 || s.total_cost_saved_usd > 0) {
+    lines.push("│");
+    lines.push("│ ── Savings ──");
+    if (s.pil_tokens_saved > 0) lines.push(`│   PIL enrichment:  ~${s.pil_tokens_saved} tokens saved`);
+    if (s.cache_tokens_saved > 0) lines.push(`│   Cache hits:      ~${s.cache_tokens_saved} tokens saved`);
+    if (s.router_cost_saved_usd > 0) lines.push(`│   Router downgrade: ~$${s.router_cost_saved_usd.toFixed(4)} saved`);
+    lines.push(`│   Total: ~${s.total_tokens_saved} tokens, ~$${s.total_cost_saved_usd.toFixed(4)} saved`);
+  }
+
+  lines.push("└──────────────────────────────────────────────");
+  return lines.join("\n");
+}
+
+function formatSessionSummary(): string {
+  const s = statusBarStore.getState();
+  const totalSavings = turnTraces.reduce(
+    (acc, t) => ({
+      tokens: acc.tokens + t.estimated_savings.total_tokens_saved,
+      cost: acc.cost + t.estimated_savings.total_cost_saved_usd,
+    }),
+    { tokens: 0, cost: 0 },
+  );
+
+  const lines: string[] = [];
+  lines.push("── Session Pipeline Summary ──");
+  lines.push(`Turns traced: ${turnTraces.length}`);
+  lines.push(`Total tokens: ↑${s.in_tokens} ↓${s.out_tokens}`);
+  lines.push(`Session cost:  $${s.session_usd.toFixed(4)}`);
+  if (totalSavings.tokens > 0) {
+    lines.push(`Est. savings:  ~${totalSavings.tokens} tokens, ~$${totalSavings.cost.toFixed(4)}`);
+    const pct = s.session_usd > 0 ? ((totalSavings.cost / (s.session_usd + totalSavings.cost)) * 100).toFixed(1) : "0";
+    lines.push(`Efficiency:    ${pct}% cost reduction vs raw API`);
+  }
+  lines.push(`EE status:     ${s.ee_status}`);
+  return lines.join("\n");
+}
+
+export const handleDebugSlash: SlashHandler = async (args, _ctx) => {
+  const cmd = args[0]?.toLowerCase();
+
+  if (cmd === "on") {
+    debugEnabled = true;
+    return "Pipeline debug tracing: ON\nEach turn will show: PIL → Router → EE hooks → Model → Savings";
+  }
+  if (cmd === "off") {
+    debugEnabled = false;
+    return "Pipeline debug tracing: OFF";
+  }
+  if (cmd === "status") {
+    return formatSessionSummary();
+  }
+  if (cmd === "last") {
+    const last = getLastTrace();
+    if (!last) return "No traces recorded yet. Send a message with /debug on.";
+    return formatTrace(last);
+  }
+
+  // Toggle
+  debugEnabled = !debugEnabled;
+  if (debugEnabled) {
+    return "Pipeline debug tracing: ON\nEach turn will show: PIL → Router → EE hooks → Model → Savings\n\nCommands: /debug off | /debug status | /debug last";
+  }
+  return "Pipeline debug tracing: OFF";
+};
+
+registerSlash("debug", handleDebugSlash);

package/src/ui/slash/discuss.ts

@@ -0,0 +1,71 @@
+/**
+ * src/ui/slash/discuss.ts
+ *
+ * /discuss slash command handler (FLOW-05).
+ * Creates runs, captures gray areas, lists them on demand.
+ *
+ * Self-registers on module import — call once from src/index.ts boot path
+ * or import in test to trigger registration.
+ */
+
+import { createRun, getActiveRunId, loadRun, setActiveRunId, updateRunFile } from "../../flow/run-manager.js";
+import { ensureFlowDir } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+/**
+ * Count existing G-entries in gray area content.
+ * Matches lines like "G1 [open] ..." or "G12 [resolved] ..."
+ */
+function countGEntries(content: string): number {
+  const matches = content.match(/^G\d+\s+\[/gm);
+  return matches ? matches.length : 0;
+}
+
+export const handleDiscussSlash: SlashHandler = async (args, ctx) => {
+  const flowDir = await ensureFlowDir(ctx.cwd);
+  const activeRunId = await getActiveRunId(flowDir);
+
+  // No active run
+  if (!activeRunId) {
+    if (args.length === 0) {
+      return "No active run. Start with: /discuss <describe your task>";
+    }
+    // Auto-create run when args provided
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+    return `Run ${run.id} created. Describe your task.`;
+  }
+
+  // Active run exists
+  const run = await loadRun(flowDir, activeRunId);
+  if (!run) {
+    return `Error: active run ${activeRunId} not found on disk.`;
+  }
+
+  if (args.length > 0) {
+    // Add a new gray area entry
+    const gaSection = run.grayAreas.sections.get("Gray Areas") ?? "";
+    const existingCount = countGEntries(gaSection);
+    const nextId = existingCount + 1;
+    const newEntry = `G${nextId} [open] ${args.join(" ")}`;
+
+    const updatedContent = gaSection ? `${gaSection}\n${newEntry}` : newEntry;
+
+    run.grayAreas.sections.set("Gray Areas", updatedContent);
+    await updateRunFile(flowDir, activeRunId, "gray-areas.md", run.grayAreas);
+
+    return `Gray area G${nextId} added to run ${activeRunId}.`;
+  }
+
+  // No args — list current gray areas
+  const gaSection = run.grayAreas.sections.get("Gray Areas") ?? "";
+  if (!gaSection.trim()) {
+    return "No gray areas recorded yet.";
+  }
+
+  return `Gray areas for run ${activeRunId}:\n\n${gaSection}`;
+};
+
+// Self-register on module import
+registerSlash("discuss", handleDiscussSlash);

package/src/ui/slash/ee.ts

@@ -0,0 +1,271 @@
+/**
+ * src/ui/slash/ee.ts
+ *
+ * /ee slash command handler (P2 Knowledge Visibility).
+ * Surfaces EE knowledge management: stats, graph, timeline, gates, evolve, share/import.
+ *
+ * Self-registers on module import.
+ */
+
+import { getDefaultEEClient } from "../../ee/intercept.js";
+import type {
+  EEStatsResponse,
+  EEGraphResponse,
+  EETimelineResponse,
+  EEGatesResponse,
+  EEEvolveResponse,
+  EEShareResponse,
+  RouteTaskResponse,
+  EESearchResponse,
+} from "../../ee/types.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+const UNREACHABLE = "**EE unreachable** — is the Experience Engine running on localhost:8082?";
+
+// ─── Formatters ──────────────────────────────────────────────────────────────
+
+function fmtStats(s: EEStatsResponse): string {
+  const lines: string[] = ["**EE Stats**", ""];
+
+  // Overview
+  lines.push("**Overview**");
+  lines.push(`  Intercepts: ${s.totalIntercepts}  |  Suggestions: ${s.suggestions}  |  Misses: ${s.misses}`);
+  if (s.mistakesDetected != null) lines.push(`  Mistakes detected: ${s.mistakesDetected}`);
+  if (s.lessonsStored != null) lines.push(`  Lessons stored: ${s.lessonsStored}`);
+  if (s.extractSessions != null) lines.push(`  Extract sessions: ${s.extractSessions}`);
+
+  // Evolution
+  if (s.evolution) {
+    const e = s.evolution;
+    lines.push("");
+    lines.push("**Evolution**");
+    lines.push(`  Promoted: ${e.promoted}  |  Demoted: ${e.demoted}  |  Abstracted: ${e.abstracted}  |  Archived: ${e.archived}`);
+  }
+
+  // Per-project
+  if (s.perProject && Object.keys(s.perProject).length > 0) {
+    lines.push("");
+    lines.push("**Per Project**");
+    for (const [proj, data] of Object.entries(s.perProject)) {
+      lines.push(`  ${proj}: ${data.intercepts} intercepts, ${data.suggestions} suggestions`);
+    }
+  }
+
+  // Routing
+  if (s.routingStats) {
+    const r = s.routingStats;
+    lines.push("");
+    lines.push("**Routing**");
+    if (r.byTier && Object.keys(r.byTier).length > 0) {
+      lines.push(`  By tier: ${Object.entries(r.byTier).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+    }
+    if (r.bySource && Object.keys(r.bySource).length > 0) {
+      lines.push(`  By source: ${Object.entries(r.bySource).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+    }
+    if (r.outcomes && Object.keys(r.outcomes).length > 0) {
+      lines.push(`  Outcomes: ${Object.entries(r.outcomes).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+    }
+  }
+
+  // Cost ledger
+  if (s.costLedger && s.costLedger.length > 0) {
+    lines.push("");
+    lines.push("**Cost Ledger** (recent)");
+    for (const row of s.costLedger.slice(-5)) {
+      const total = row.embed + row.brain + row.judge + row.extract;
+      lines.push(`  ${row.date}: $${total.toFixed(4)} (embed=$${row.embed.toFixed(4)} brain=$${row.brain.toFixed(4)} judge=$${row.judge.toFixed(4)} extract=$${row.extract.toFixed(4)})`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function fmtTimeline(r: EETimelineResponse): string {
+  if (r.timeline.length === 0) return `No timeline entries for topic "${r.topic}".`;
+
+  const lines: string[] = [`**Timeline: ${r.topic}** (${r.count} entries)`, ""];
+  for (const e of r.timeline) {
+    const tierBadge = `T${e.tier}`;
+    const superseded = e.superseded ? " ~~superseded~~" : "";
+    const confirms = e.confirmedAt.length;
+    lines.push(`- **[${tierBadge}]** ${e.trigger}${superseded}`);
+    lines.push(`  Solution: ${e.solution}`);
+    lines.push(`  Score: ${e.score} | Confirmed: ${confirms}x | ${e.createdAt}`);
+  }
+  return lines.join("\n");
+}
+
+function fmtGraph(r: EEGraphResponse): string {
+  if (r.edges.length === 0) return `No graph edges for "${r.id}".`;
+
+  const lines: string[] = [`**Graph: ${r.id}** (${r.count} edges)`, ""];
+  for (const e of r.edges) {
+    const arrow = e.direction === "outgoing" ? "→" : "←";
+    lines.push(`  ${arrow} ${e.type} ${e.target} (weight: ${e.weight.toFixed(2)})`);
+  }
+  return lines.join("\n");
+}
+
+function fmtGates(r: EEGatesResponse): string {
+  const lines: string[] = ["**Quality Gates**", ""];
+  for (const g of r.gates) {
+    const icon = g.status === "pass" ? "✓" : g.status === "fail" ? "✗" : "●";
+    lines.push(`${icon} **${g.name}** — ${g.status}`);
+    for (const c of g.checks) {
+      const ci = c.ok ? "✓" : "✗";
+      lines.push(`  ${ci} ${c.label}${c.detail ? ` (${c.detail})` : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function fmtEvolve(r: EEEvolveResponse): string {
+  if (!r.success) return "Evolve cycle failed.";
+  const lines: string[] = ["**Evolution cycle complete**"];
+  if (r.promoted != null) lines.push(`  Promoted:   ${r.promoted}`);
+  if (r.demoted != null) lines.push(`  Demoted:    ${r.demoted}`);
+  if (r.abstracted != null) lines.push(`  Abstracted: ${r.abstracted}`);
+  if (r.archived != null) lines.push(`  Archived:   ${r.archived}`);
+  return lines.join("\n");
+}
+
+function fmtShare(r: EEShareResponse): string {
+  if (!r.success) return "Share failed.";
+  return ["**Shared principle** (portable JSON):", "```json", JSON.stringify(r.shared, null, 2), "```"].join("\n");
+}
+
+function fmtRoute(r: RouteTaskResponse): string {
+  const icon = r.confidence >= 0.7 ? "✓" : r.confidence >= 0.4 ? "●" : "?";
+  const lines: string[] = [
+    `**Task Route** ${icon} (confidence: ${(r.confidence * 100).toFixed(0)}%)`,
+    "",
+    `  Route: **${r.route ?? "needs clarification"}**`,
+    `  Reason: ${r.reason}`,
+    `  Source: ${r.source}`,
+  ];
+  if (r.needs_disambiguation && r.options.length > 0) {
+    lines.push("", "**Clarify before proceeding:**");
+    for (const opt of r.options) {
+      lines.push(`  - **${opt.label}** (\`${opt.route}\`): ${opt.description}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function fmtSearch(r: EESearchResponse): string {
+  if (r.points.length === 0) return "No results found.";
+  const lines: string[] = [`**Search Results** (${r.points.length} hits)`, ""];
+  for (const p of r.points) {
+    lines.push(`- **[${p.collection}]** (score: ${p.score.toFixed(3)})`);
+    lines.push(`  ${p.text.slice(0, 200)}${p.text.length > 200 ? "..." : ""}`);
+  }
+  return lines.join("\n");
+}
+
+const HELP = [
+  "**Experience Engine (/ee)**",
+  "",
+  "Usage:",
+  "  /ee stats [7d|30d|all]   — Knowledge base statistics",
+  "  /ee timeline <topic>     — Chronological principle evolution",
+  "  /ee graph <id>           — Principle relationship graph",
+  "  /ee gates                — Quality gate checklist",
+  "  /ee evolve               — Trigger evolution cycle",
+  "  /ee share <principleId>  — Export principle as portable JSON",
+  "  /ee import <json>        — Import a shared principle",
+  "  /ee route <task>         — Route task to workflow (discuss/execute/direct)",
+  "  /ee search <query>       — Semantic search across knowledge base",
+  "  /ee user                 — Current EE user identity",
+].join("\n");
+
+// ─── Handler ─────────────────────────────────────────────────────────────────
+
+export const handleEESlash: SlashHandler = async (args, _ctx) => {
+  const sub = args[0]?.toLowerCase();
+  if (!sub) return HELP;
+
+  const client = getDefaultEEClient();
+
+  switch (sub) {
+    case "stats": {
+      const since = args[1]; // "7d" | "30d" | "all" | undefined
+      const r = await client.stats(since);
+      return r ? fmtStats(r) : UNREACHABLE;
+    }
+
+    case "timeline": {
+      const topic = args.slice(1).join(" ");
+      if (!topic) return "/ee timeline: please provide a topic — /ee timeline <topic>";
+      const r = await client.timeline(topic);
+      return r ? fmtTimeline(r) : UNREACHABLE;
+    }
+
+    case "graph": {
+      const id = args[1];
+      if (!id) return "/ee graph: please provide an id — /ee graph <id>";
+      const r = await client.graph(id);
+      return r ? fmtGraph(r) : UNREACHABLE;
+    }
+
+    case "gates": {
+      const r = await client.gates();
+      return r ? fmtGates(r) : UNREACHABLE;
+    }
+
+    case "evolve": {
+      const r = await client.evolve();
+      return r ? fmtEvolve(r) : UNREACHABLE;
+    }
+
+    case "share": {
+      const pid = args[1];
+      if (!pid) return "/ee share: please provide a principleId — /ee share <principleId>";
+      const r = await client.sharePrinciple(pid);
+      return r ? fmtShare(r) : UNREACHABLE;
+    }
+
+    case "import": {
+      const raw = args.slice(1).join(" ");
+      if (!raw) return "/ee import: please provide JSON — /ee import <json>";
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return "/ee import: invalid JSON.";
+      }
+      const r = await client.importPrinciple(parsed);
+      if (!r) return UNREACHABLE;
+      return r.success ? "Principle imported successfully." : "Import failed.";
+    }
+
+    case "route": {
+      const task = args.slice(1).join(" ");
+      if (!task) return "/ee route: please provide a task — /ee route <task description>";
+      const r = await client.routeTask({ task });
+      return r ? fmtRoute(r) : UNREACHABLE;
+    }
+
+    case "search": {
+      const query = args.slice(1).join(" ");
+      if (!query) return "/ee search: please provide a query — /ee search <query>";
+      const r = await client.search(query);
+      return r ? fmtSearch(r) : UNREACHABLE;
+    }
+
+    case "user": {
+      const r = await client.user();
+      if (!r) return UNREACHABLE;
+      return `**EE User:** ${r.user}`;
+    }
+
+    case "help":
+      return HELP;
+
+    default:
+      return `Unknown subcommand "${sub}".\n\n${HELP}`;
+  }
+};
+
+// Self-register on module import
+registerSlash("ee", handleEESlash);

package/src/ui/slash/execute.ts

@@ -0,0 +1,44 @@
+/**
+ * src/ui/slash/execute.ts
+ *
+ * /execute slash command handler (FLOW-07).
+ * Reads plan from roadmap.md, sets state to "executing", returns plan
+ * content for QC-lock execution loop.
+ *
+ * Self-registers on module import — call once from src/index.ts boot path
+ * or import in test to trigger registration.
+ */
+
+import { getActiveRunId, loadRun, updateRunFile } from "../../flow/run-manager.js";
+import { ensureFlowDir } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleExecuteSlash: SlashHandler = async (_args, ctx) => {
+  const flowDir = await ensureFlowDir(ctx.cwd);
+  const activeRunId = await getActiveRunId(flowDir);
+
+  if (!activeRunId) {
+    return "No active run. Start with /discuss.";
+  }
+
+  const run = await loadRun(flowDir, activeRunId);
+  if (!run) {
+    return `Error: active run ${activeRunId} not found on disk.`;
+  }
+
+  // Read plan from roadmap.md
+  const planContent = run.roadmap.sections.get("Plan") ?? "";
+  if (!planContent.trim()) {
+    return "No plan found. Run /plan first.";
+  }
+
+  // Update state.md: set Status to "executing"
+  run.state.sections.set("Status", "executing");
+  await updateRunFile(flowDir, activeRunId, "state.md", run.state);
+
+  return `Executing run ${activeRunId}:\n\n${planContent}`;
+};
+
+// Self-register on module import
+registerSlash("execute", handleExecuteSlash);

package/src/ui/slash/expand.ts

@@ -0,0 +1,51 @@
+/**
+ * /expand slash command handler.
+ *
+ * Restores from the latest history snapshot (created by /compact).
+ * Deletes the snapshot file after restore to prevent double-expand.
+ * Returns __EXPAND__ signal with restored content for the orchestrator.
+ *
+ * Self-registers on module import.
+ */
+
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { FLOW_DIR_NAME } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleExpandSlash: SlashHandler = async (_args, ctx) => {
+  const historyDir = path.join(ctx.cwd, FLOW_DIR_NAME, "history");
+
+  // Read history directory
+  let files: string[];
+  try {
+    files = await fs.readdir(historyDir);
+  } catch {
+    return "Nothing to expand. No compaction history found.";
+  }
+
+  // Filter to .md files and sort by name (ISO timestamp = chronological sort)
+  const snapshots = files.filter((f) => f.endsWith(".md")).sort();
+
+  if (snapshots.length === 0) {
+    return "Nothing to expand. No compaction history found.";
+  }
+
+  // Read the latest snapshot
+  const latestFile = snapshots[snapshots.length - 1];
+  const latestPath = path.join(historyDir, latestFile);
+  const content = await fs.readFile(latestPath, "utf8");
+
+  // Delete the snapshot file (prevent double-expand per Pitfall 5)
+  await fs.unlink(latestPath);
+
+  // Count lines for summary
+  const lines = content.split("\n").length;
+
+  // Return signal for orchestrator to restore messages
+  return `__EXPAND__\nRestored from ${latestFile} (${lines} lines). Previous compaction reversed.\n${content}`;
+};
+
+// Self-register on module import
+registerSlash("expand", handleExpandSlash);