muonroi-cli 1.2.0

package/src/ui/slash/__tests__/discuss.test.ts

@@ -0,0 +1,101 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createRun, getActiveRunId, loadRun, setActiveRunId } from "../../../flow/run-manager.js";
+import { ensureFlowDir } from "../../../flow/scaffold.js";
+// Import handler — also triggers self-registration
+import { handleDiscussSlash } from "../discuss.js";
+import type { SlashContext } from "../registry.js";
+
+function makeCtx(cwd: string): SlashContext {
+  return {
+    cwd,
+    tenantId: "local",
+    defaultProvider: "anthropic",
+    defaultModel: "claude-sonnet-4-20250514",
+  };
+}
+
+describe("/discuss slash command", () => {
+  let tmpDir: string;
+  let flowDir: string;
+  let ctx: SlashContext;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "discuss-test-"));
+    flowDir = await ensureFlowDir(tmpDir);
+    ctx = makeCtx(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates a new run when no active run and args provided", async () => {
+    const result = await handleDiscussSlash(["build", "auth", "system"], ctx);
+    expect(result).toMatch(/^Run .+ created\. Describe your task\.$/);
+
+    // Verify run was set active
+    const activeId = await getActiveRunId(flowDir);
+    expect(activeId).not.toBeNull();
+  });
+
+  it("returns error when no active run and no args", async () => {
+    const result = await handleDiscussSlash([], ctx);
+    expect(result).toContain("No active run");
+    expect(result).toContain("/discuss");
+  });
+
+  it("adds gray area entry when active run and args provided", async () => {
+    // Create and set active run
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    const result = await handleDiscussSlash(["Should", "we", "use", "X", "or", "Y?"], ctx);
+    expect(result).toContain("G1");
+    expect(result).toContain("added");
+
+    // Verify gray-areas.md has the entry
+    const loaded = await loadRun(flowDir, run.id);
+    expect(loaded).not.toBeNull();
+    const gaContent = loaded!.grayAreas.sections.get("Gray Areas");
+    expect(gaContent).toContain("G1 [open] Should we use X or Y?");
+  });
+
+  it("increments gray area IDs on successive additions", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    await handleDiscussSlash(["First question?"], ctx);
+    const result2 = await handleDiscussSlash(["Second question?"], ctx);
+    expect(result2).toContain("G2");
+
+    const loaded = await loadRun(flowDir, run.id);
+    const gaContent = loaded!.grayAreas.sections.get("Gray Areas") ?? "";
+    expect(gaContent).toContain("G1 [open] First question?");
+    expect(gaContent).toContain("G2 [open] Second question?");
+  });
+
+  it("lists gray areas when active run and no args", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    await handleDiscussSlash(["What about X?"], ctx);
+    await handleDiscussSlash(["What about Y?"], ctx);
+
+    const result = await handleDiscussSlash([], ctx);
+    expect(result).toContain("G1");
+    expect(result).toContain("G2");
+    expect(result).toContain("What about X?");
+    expect(result).toContain("What about Y?");
+  });
+
+  it("returns 'No gray areas' when active run, no args, and no entries", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    const result = await handleDiscussSlash([], ctx);
+    expect(result).toContain("No gray areas recorded yet");
+  });
+});

package/src/ui/slash/__tests__/execute.test.ts

@@ -0,0 +1,86 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { SectionMap } from "../../../flow/parser.js";
+import { createRun, loadRun, setActiveRunId, updateRunFile } from "../../../flow/run-manager.js";
+import { ensureFlowDir } from "../../../flow/scaffold.js";
+// Import handler — also triggers self-registration
+import { handleExecuteSlash } from "../execute.js";
+import type { SlashContext } from "../registry.js";
+
+function makeCtx(cwd: string): SlashContext {
+  return {
+    cwd,
+    tenantId: "local",
+    defaultProvider: "anthropic",
+    defaultModel: "claude-sonnet-4-20250514",
+  };
+}
+
+describe("/execute slash command", () => {
+  let tmpDir: string;
+  let flowDir: string;
+  let ctx: SlashContext;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "execute-test-"));
+    flowDir = await ensureFlowDir(tmpDir);
+    ctx = makeCtx(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns error when no active run", async () => {
+    const result = await handleExecuteSlash([], ctx);
+    expect(result).toContain("No active run");
+    expect(result).toContain("/discuss");
+  });
+
+  it("returns error when no plan in roadmap.md", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    const result = await handleExecuteSlash([], ctx);
+    expect(result).toContain("No plan found");
+    expect(result).toContain("/plan");
+  });
+
+  it("reads plan from roadmap.md and returns it for execution", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    // Write plan to roadmap.md
+    const roadmap: SectionMap = {
+      preamble: "",
+      sections: new Map([["Plan", "1. Build auth\n2. Add JWT\n3. Test endpoints"]]),
+    };
+    await updateRunFile(flowDir, run.id, "roadmap.md", roadmap);
+
+    const result = await handleExecuteSlash([], ctx);
+    expect(result).toContain(`Executing run ${run.id}`);
+    expect(result).toContain("Build auth");
+    expect(result).toContain("Add JWT");
+    expect(result).toContain("Test endpoints");
+  });
+
+  it("sets state.md Status to 'executing'", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    const roadmap: SectionMap = {
+      preamble: "",
+      sections: new Map([["Plan", "Do the thing"]]),
+    };
+    await updateRunFile(flowDir, run.id, "roadmap.md", roadmap);
+
+    await handleExecuteSlash([], ctx);
+
+    // Verify state.md has Status = executing
+    const loaded = await loadRun(flowDir, run.id);
+    const status = loaded!.state.sections.get("Status");
+    expect(status).toBe("executing");
+  });
+});

package/src/ui/slash/__tests__/expand.test.ts

@@ -0,0 +1,86 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { SlashContext } from "../registry.js";
+
+// Import to trigger self-registration
+import "../expand.js";
+
+import { dispatchSlash } from "../registry.js";
+
+let tmpDir: string;
+
+const makeCtx = (cwd: string): SlashContext => ({
+  cwd,
+  tenantId: "local",
+  defaultProvider: "anthropic",
+  defaultModel: "claude-3-5-sonnet-latest",
+});
+
+describe("handleExpandSlash", () => {
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "expand-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns message when no history files exist", async () => {
+    // Create empty history dir
+    const flowDir = path.join(tmpDir, ".muonroi-flow");
+    await fs.mkdir(path.join(flowDir, "history"), { recursive: true });
+
+    const result = await dispatchSlash("expand", [], makeCtx(tmpDir));
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Nothing to expand");
+  });
+
+  it("returns message when no flow dir exists", async () => {
+    const result = await dispatchSlash("expand", [], makeCtx(tmpDir));
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Nothing to expand");
+  });
+
+  it("restores from latest history file (sorted by filename)", async () => {
+    const flowDir = path.join(tmpDir, ".muonroi-flow");
+    const historyDir = path.join(flowDir, "history");
+    await fs.mkdir(historyDir, { recursive: true });
+
+    // Create two snapshots — older and newer
+    await fs.writeFile(path.join(historyDir, "2026-04-29T10-00-00-000Z.md"), "Old snapshot content", "utf8");
+    await fs.writeFile(path.join(historyDir, "2026-04-30T10-00-00-000Z.md"), "Latest snapshot content", "utf8");
+
+    const result = await dispatchSlash("expand", [], makeCtx(tmpDir));
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("__EXPAND__");
+    expect(result).toContain("Latest snapshot content");
+  });
+
+  it("deletes snapshot file after restore (no double-expand)", async () => {
+    const flowDir = path.join(tmpDir, ".muonroi-flow");
+    const historyDir = path.join(flowDir, "history");
+    await fs.mkdir(historyDir, { recursive: true });
+
+    await fs.writeFile(path.join(historyDir, "2026-04-30T12-00-00-000Z.md"), "Snapshot to delete", "utf8");
+
+    await dispatchSlash("expand", [], makeCtx(tmpDir));
+
+    // Verify file was deleted
+    const remaining = await fs.readdir(historyDir);
+    expect(remaining).toHaveLength(0);
+  });
+
+  it("returns restored content length summary", async () => {
+    const flowDir = path.join(tmpDir, ".muonroi-flow");
+    const historyDir = path.join(flowDir, "history");
+    await fs.mkdir(historyDir, { recursive: true });
+
+    const content = "Restored content here";
+    await fs.writeFile(path.join(historyDir, "2026-04-30T14-00-00-000Z.md"), content, "utf8");
+
+    const result = await dispatchSlash("expand", [], makeCtx(tmpDir));
+    expect(result).toContain("Restored from");
+  });
+});

package/src/ui/slash/__tests__/optimize.test.ts

@@ -0,0 +1,155 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { PipelineContext } from "../../../pil/index.js";
+import type { SlashContext } from "../registry.js";
+
+// Mock the PIL module before importing optimize
+vi.mock("../../../pil/index.js", () => {
+  return {
+    getPilLastResult: vi.fn(),
+    runPipeline: vi.fn(),
+  };
+});
+
+import { getPilLastResult, runPipeline } from "../../../pil/index.js";
+
+// Import to trigger self-registration
+import "../optimize.js";
+
+import { dispatchSlash } from "../registry.js";
+
+const makeCtx = (): SlashContext => ({
+  cwd: "/tmp",
+  tenantId: "local",
+  defaultProvider: "anthropic",
+  defaultModel: "claude-sonnet-4-20250514",
+});
+
+const makePipelineContext = (): PipelineContext => ({
+  raw: "fix this bug",
+  enriched: "Please fix this bug in the code.",
+  taskType: "debug",
+  domain: "typescript",
+  confidence: 0.85,
+  outputStyle: "concise",
+  tokenBudget: 500,
+  metrics: {
+    totalMs: 3,
+    layerTimings: [
+      { name: "layer1-intent", ms: 1 },
+      { name: "layer2-personality", ms: 0 },
+      { name: "layer3-ee-injection", ms: 0 },
+      { name: "layer4-gsd-structuring", ms: 0 },
+      { name: "layer5-context-enrichment", ms: 0 },
+      { name: "layer6-output", ms: 1 },
+    ],
+    inputChars: 12,
+    outputChars: 31,
+    estimatedTokensSaved: 20,
+    enrichmentTokensAdded: 5,
+  },
+  layers: [
+    { name: "layer1-task-detect", applied: true, delta: "+task_type=debug" },
+    { name: "layer2-domain-inject", applied: true, delta: "+domain=typescript" },
+    { name: "layer3-context-compress", applied: false, delta: null },
+    { name: "layer4-principle-inject", applied: true, delta: "+2 principles" },
+    { name: "layer5-constraint-inject", applied: false, delta: null },
+    { name: "layer6-output-format", applied: true, delta: "+output_format" },
+  ],
+});
+
+describe("handleOptimizeSlash", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("Test 1: no-arg form with populated store returns Enriched prompt header", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+
+    const result = await dispatchSlash("optimize", [], makeCtx());
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Enriched prompt:");
+  });
+
+  it("Test 2: no-arg form with populated store returns 6 layer rows", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+
+    const result = await dispatchSlash("optimize", [], makeCtx());
+    expect(result).toBeTypeOf("string");
+
+    // Count layer rows: each layer appears as a line with padded name
+    const lines = (result as string).split("\n");
+    const layerLines = lines.filter((l) => l.includes("applied=yes") || l.includes("applied=no"));
+    expect(layerLines).toHaveLength(6);
+  });
+
+  it("Test 3: no-arg form with empty store returns help message containing no prompt processed yet", async () => {
+    vi.mocked(getPilLastResult).mockReturnValue(null);
+
+    const result = await dispatchSlash("optimize", [], makeCtx());
+    expect(result).toBeTypeOf("string");
+    expect((result as string).toLowerCase()).toContain("no prompt processed yet");
+  });
+
+  it("Test 4: arg form runs runPipeline on given string and returns layer table", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(runPipeline).mockResolvedValue(ctx);
+
+    const result = await dispatchSlash("optimize", ["fix", "this", "bug"], makeCtx());
+    expect(runPipeline).toHaveBeenCalledWith("fix this bug");
+    expect(result).toBeTypeOf("string");
+    expect(result).toContain("Layer breakdown:");
+  });
+
+  it("Test 5: layer table row format has name padded to 28 chars and applied=yes/no", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+
+    const result = (await dispatchSlash("optimize", [], makeCtx())) as string;
+    const lines = result.split("\n");
+    const layerLines = lines.filter((l) => l.includes("applied=yes") || l.includes("applied=no"));
+
+    // Each line starts with 2 spaces then name padded to 28 chars
+    for (const line of layerLines) {
+      // Strip leading 2 spaces
+      const content = line.slice(2);
+      // First 28 chars should be name padded
+      const namePart = content.slice(0, 28);
+      expect(namePart).toHaveLength(28);
+      // Should contain applied=yes or applied=no (with trailing space)
+      expect(line).toMatch(/applied=(yes|no )/);
+    }
+  });
+
+  it("Test 6: output contains Output style line", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+    const result = (await dispatchSlash("optimize", [], makeCtx())) as string;
+    expect(result).toContain("Output style: concise");
+  });
+
+  it("Test 7: output contains Metrics section with timing", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+    const result = (await dispatchSlash("optimize", [], makeCtx())) as string;
+    expect(result).toContain("Metrics:");
+    expect(result).toContain("total pipeline:");
+    expect(result).toContain("est. tokens saved:");
+    expect(result).toContain("layer timings:");
+  });
+
+  it("Test 8: handler is async SlashHandler returning string", async () => {
+    const ctx = makePipelineContext();
+    vi.mocked(getPilLastResult).mockReturnValue(ctx);
+
+    const { handleOptimizeSlash } = await import("../optimize.js");
+    const result = handleOptimizeSlash([], makeCtx());
+
+    // Should return a Promise (async)
+    expect(result).toBeInstanceOf(Promise);
+    const resolved = await result;
+    expect(typeof resolved).toBe("string");
+    expect(resolved).not.toBeNull();
+  });
+});

package/src/ui/slash/__tests__/plan.test.ts

@@ -0,0 +1,95 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { SectionMap } from "../../../flow/parser.js";
+import { createRun, loadRun, setActiveRunId, updateRunFile } from "../../../flow/run-manager.js";
+import { ensureFlowDir } from "../../../flow/scaffold.js";
+// Import handler — also triggers self-registration
+import { handlePlanSlash } from "../plan.js";
+import type { SlashContext } from "../registry.js";
+
+function makeCtx(cwd: string): SlashContext {
+  return {
+    cwd,
+    tenantId: "local",
+    defaultProvider: "anthropic",
+    defaultModel: "claude-sonnet-4-20250514",
+  };
+}
+
+describe("/plan slash command", () => {
+  let tmpDir: string;
+  let flowDir: string;
+  let ctx: SlashContext;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "plan-test-"));
+    flowDir = await ensureFlowDir(tmpDir);
+    ctx = makeCtx(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns error when no active run", async () => {
+    const result = await handlePlanSlash(["build", "something"], ctx);
+    expect(result).toContain("No active run");
+    expect(result).toContain("/discuss");
+  });
+
+  it("blocks when unresolved gray areas exist", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    // Add open gray areas
+    const grayAreas: SectionMap = {
+      preamble: "",
+      sections: new Map([
+        ["Gray Areas", "G1 [open] Should we use X or Y?\nG2 [resolved] Token budget -> 80%\nG3 [open] What about Z?"],
+      ]),
+    };
+    await updateRunFile(flowDir, run.id, "gray-areas.md", grayAreas);
+
+    const result = await handlePlanSlash(["my plan content"], ctx);
+    expect(result).toContain("blocked");
+    expect(result).toContain("G1");
+    expect(result).toContain("G3");
+    expect(result).not.toContain("G2"); // resolved, should not appear in block list
+    expect(result).toContain("Resolution path");
+  });
+
+  it("writes plan to roadmap.md when no open gray areas", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    // All gray areas resolved
+    const grayAreas: SectionMap = {
+      preamble: "",
+      sections: new Map([["Gray Areas", "G1 [resolved] Token budget -> 80%"]]),
+    };
+    await updateRunFile(flowDir, run.id, "gray-areas.md", grayAreas);
+
+    const result = await handlePlanSlash(["Build", "auth", "system", "with", "JWT"], ctx);
+    expect(result).toContain("Plan created");
+    expect(result).toContain(run.id);
+
+    // Verify roadmap.md has plan content
+    const loaded = await loadRun(flowDir, run.id);
+    const planContent = loaded!.roadmap.sections.get("Plan");
+    expect(planContent).toContain("Build auth system with JWT");
+  });
+
+  it("writes plan when no gray areas exist at all", async () => {
+    const run = await createRun(flowDir);
+    await setActiveRunId(flowDir, run.id);
+
+    const result = await handlePlanSlash(["Simple", "plan"], ctx);
+    expect(result).toContain("Plan created");
+
+    const loaded = await loadRun(flowDir, run.id);
+    const planContent = loaded!.roadmap.sections.get("Plan");
+    expect(planContent).toContain("Simple plan");
+  });
+});

package/src/ui/slash/clear.ts

@@ -0,0 +1,89 @@
+/**
+ * /clear slash command handler.
+ *
+ * Relocks current state from .muonroi-flow/ artifacts and discards
+ * chat context. Returns __CLEAR__ signal with relock summary for
+ * the orchestrator to inject as system context.
+ *
+ * Self-registers on module import.
+ */
+
+import * as path from "node:path";
+import { getDefaultEEClient, getLastSurfacedState } from "../../ee/intercept.js";
+import { getTenantId } from "../../ee/tenant.js";
+import { readArtifact } from "../../flow/artifact-io.js";
+import { getActiveRunId, loadRun } from "../../flow/run-manager.js";
+import { FLOW_DIR_NAME } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleClearSlash: SlashHandler = async (_args, ctx) => {
+  const flowDir = path.join(ctx.cwd, FLOW_DIR_NAME);
+
+  // Check for active run
+  const runId = await getActiveRunId(flowDir);
+  if (!runId) {
+    return "No active run. Nothing to relock from. Start with /discuss to create a run.";
+  }
+
+  // Load run state
+  const run = await loadRun(flowDir, runId);
+
+  // Read decisions.md
+  const decisionsMap = await readArtifact(flowDir, "decisions.md");
+  let decisionsCount = 0;
+  if (decisionsMap) {
+    for (const [, content] of decisionsMap.sections) {
+      // Count bullet points as entries
+      const bullets = content.split("\n").filter((l) => l.trim().startsWith("-"));
+      decisionsCount += bullets.length;
+    }
+  }
+
+  // Count gray areas
+  let grayOpen = 0;
+  let grayTotal = 0;
+  if (run?.grayAreas) {
+    for (const [heading, content] of run.grayAreas.sections) {
+      const items = content.split("\n").filter((l) => l.trim().length > 0);
+      grayTotal += items.length;
+      if (heading.toLowerCase().includes("open")) {
+        grayOpen += items.length;
+      }
+    }
+  }
+
+  // Get run status from state.md Resume Digest
+  const resumeDigest = run?.state.sections.get("Resume Digest") ?? "unknown";
+  const statusLine = resumeDigest.split("\n")[0]?.trim() || "active";
+
+  // Read roadmap presence
+  const roadmap = await readArtifact(flowDir, "roadmap.md");
+  const hasRoadmap = roadmap && roadmap.sections.size > 0 ? "present" : "absent";
+
+  // Build relock summary
+  const summary = [
+    `Relocked from ${FLOW_DIR_NAME}/ artifacts.`,
+    `Active run: ${runId}`,
+    `Status: ${statusLine}`,
+    `Decisions: ${decisionsCount} entries in decisions.md`,
+    `Plan: ${hasRoadmap} from roadmap.md`,
+    `Gray areas: ${grayOpen} open / ${grayTotal} total`,
+  ].join("\n");
+
+  // Fire-and-forget: notify EE that surfaced suggestions are going stale due to clear
+  const { surfacedIds, timestamp } = getLastSurfacedState();
+  if (surfacedIds.length > 0) {
+    getDefaultEEClient()
+      .promptStale({
+        state: { surfacedIds, timestamp },
+        nextPromptMeta: { trigger: "clear", cwd: ctx.cwd, tenantId: getTenantId() },
+      })
+      .catch(() => {});
+  }
+
+  return `__CLEAR__\n${summary}`;
+};
+
+// Self-register on module import
+registerSlash("clear", handleClearSlash);

package/src/ui/slash/compact.ts

@@ -0,0 +1,46 @@
+/**
+ * /compact slash command handler.
+ *
+ * Validates preconditions (flow dir + active run), then returns
+ * __COMPACT__ signal for the orchestrator to perform actual compaction
+ * (it has access to this.messages which slash handlers do not).
+ *
+ * Self-registers on module import.
+ */
+
+import * as path from "node:path";
+import { getDefaultEEClient, getLastSurfacedState } from "../../ee/intercept.js";
+import { getTenantId } from "../../ee/tenant.js";
+import { getActiveRunId } from "../../flow/run-manager.js";
+import { FLOW_DIR_NAME } from "../../flow/scaffold.js";
+import type { SlashHandler } from "./registry.js";
+import { registerSlash } from "./registry.js";
+
+export const handleCompactSlash: SlashHandler = async (_args, ctx) => {
+  const flowDir = path.join(ctx.cwd, FLOW_DIR_NAME);
+
+  // Check for active run
+  const runId = await getActiveRunId(flowDir);
+  if (!runId) {
+    return "No active run. Nothing to compact. Start with /discuss to create a run.";
+  }
+
+  // Fire-and-forget: notify EE that surfaced suggestions are going stale due to compact
+  const { surfacedIds, timestamp } = getLastSurfacedState();
+  if (surfacedIds.length > 0) {
+    getDefaultEEClient()
+      .promptStale({
+        state: { surfacedIds, timestamp },
+        nextPromptMeta: { trigger: "compact", cwd: ctx.cwd, tenantId: getTenantId() },
+      })
+      .catch(() => {});
+  }
+
+  // Return signal for orchestrator to perform compaction
+  // The orchestrator intercepts __COMPACT__ and calls deliberateCompact()
+  // with its own this.messages and this.systemPrompt
+  return `__COMPACT__\nRun: ${runId}\nReady for two-pass compaction.`;
+};
+
+// Self-register on module import
+registerSlash("compact", handleCompactSlash);