muonroi-cli 1.8.0 → 1.8.3

package/dist/src/ui/slash/__tests__/cost.test.js

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { __resetStatusBarStoreForTests, statusBarStore } from "../../status-bar/store.js";
-// Import to trigger self-registration
-import "../cost.js";
-import { dispatchSlash } from "../registry.js";
-const makeCtx = () => ({
-    cwd: "/tmp",
-    tenantId: "local",
-    defaultProvider: "anthropic",
-    defaultModel: "claude-sonnet-4-20250514",
-});
-describe("handleCostSlash", () => {
-    beforeEach(() => {
-        __resetStatusBarStoreForTests();
-    });
-    it("returns formatted output with default (zeroed) store state", async () => {
-        const result = await dispatchSlash("cost", [], makeCtx());
-        expect(result).toBeTypeOf("string");
-        expect(result).toContain("Provider: (none)");
-        expect(result).toContain("Model:    (none)");
-        expect(result).toContain("Tier:     hot");
-        expect(result).toContain("0 in / 0 out");
-        expect(result).toContain("$0.0000");
-        expect(result).toContain("$0.00");
-        expect(result).toContain("0.0%");
-    });
-    it("returns formatted output with populated store state", async () => {
-        statusBarStore.setState({
-            provider: "anthropic",
-            model: "claude-sonnet-4-20250514",
-            tier: "hot",
-            in_tokens: 5000,
-            out_tokens: 1200,
-            session_usd: 0.034,
-            month_usd: 2.5,
-            cap_usd: 15,
-            current_pct: 16.7,
-        });
-        const result = await dispatchSlash("cost", [], makeCtx());
-        expect(result).toBeTypeOf("string");
-        expect(result).toContain("Provider: anthropic");
-        expect(result).toContain("Model:    claude-sonnet-4-20250514");
-        expect(result).toContain("Tier:     hot");
-        expect(result).toContain("5000 in / 1200 out");
-        expect(result).toContain("Session:  $0.0340");
-        expect(result).toContain("Month:    $2.5000 / $15.00 (16.7%)");
-    });
-    it("handleCostSlash returns a string (may be async for EE stats)", async () => {
-        const { handleCostSlash } = await import("../cost.js");
-        const result = await handleCostSlash([], makeCtx());
-        expect(typeof result).toBe("string");
-    });
-});
-//# sourceMappingURL=cost.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/slash/__tests__/discuss.test.js

@@ -1,83 +0,0 @@
-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";
-function makeCtx(cwd) {
-    return {
-        cwd,
-        tenantId: "local",
-        defaultProvider: "anthropic",
-        defaultModel: "claude-sonnet-4-20250514",
-    };
-}
-describe("/discuss slash command", () => {
-    let tmpDir;
-    let flowDir;
-    let ctx;
-    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, maxRetries: 10, retryDelay: 50 });
-    });
-    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");
-    });
-});
-//# sourceMappingURL=discuss.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/slash/__tests__/execute.test.js

@@ -1,71 +0,0 @@
-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, 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";
-function makeCtx(cwd) {
-    return {
-        cwd,
-        tenantId: "local",
-        defaultProvider: "anthropic",
-        defaultModel: "claude-sonnet-4-20250514",
-    };
-}
-describe("/execute slash command", () => {
-    let tmpDir;
-    let flowDir;
-    let ctx;
-    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, maxRetries: 10, retryDelay: 50 });
-    });
-    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 = {
-            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 = {
-            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");
-    });
-});
-//# sourceMappingURL=execute.test.js.map

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

@@ -1 +0,0 @@
-import "../expand.js";

package/dist/src/ui/slash/__tests__/expand.test.js

@@ -1,67 +0,0 @@
-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 to trigger self-registration
-import "../expand.js";
-import { dispatchSlash } from "../registry.js";
-let tmpDir;
-const makeCtx = (cwd) => ({
-    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, maxRetries: 10, retryDelay: 50 });
-    });
-    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");
-    });
-});
-//# sourceMappingURL=expand.test.js.map

package/dist/src/ui/slash/__tests__/ideal.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/slash/__tests__/ideal.test.js

@@ -1,158 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { getIdealHelpText, handleIdealSlash, parseIdealArgs } from "../ideal.js";
-const NOOP_CTX = {
-    cwd: "/tmp",
-    tenantId: "t",
-    defaultProvider: "anthropic",
-    defaultModel: "claude",
-};
-describe("/ideal slash parser", () => {
-    const originalDev = process.env.MUONROI_DEV;
-    beforeEach(() => {
-        delete process.env.MUONROI_DEV;
-    });
-    afterEach(() => {
-        if (originalDev === undefined)
-            delete process.env.MUONROI_DEV;
-        else
-            process.env.MUONROI_DEV = originalDev;
-    });
-    it("/ideal with no args returns help", () => {
-        const r = parseIdealArgs([]);
-        expect(r.subcommand).toBe("help");
-    });
-    it('/ideal "build a CLI for X" -> start with idea set', () => {
-        const r = parseIdealArgs(["build a CLI for X"]);
-        expect(r.subcommand).toBe("start");
-        expect(r.idea).toBe("build a CLI for X");
-        expect(r.flags.maxCost).toBe(50);
-        expect(r.flags.maxSprints).toBe(8);
-        expect(r.flags.doneThreshold).toBe(0.9);
-    });
-    it("/ideal status -> subcommand=status, no runId", () => {
-        const r = parseIdealArgs(["status"]);
-        expect(r.subcommand).toBe("status");
-        expect(r.runId).toBeUndefined();
-    });
-    it("/ideal resume abc123 -> subcommand=resume, runId=abc123", () => {
-        const r = parseIdealArgs(["resume", "abc123"]);
-        expect(r.subcommand).toBe("resume");
-        expect(r.runId).toBe("abc123");
-    });
-    it("/ideal --max-cost 999 idea -> flags.maxCost=999", () => {
-        const r = parseIdealArgs(["--max-cost", "999", "todo", "app"]);
-        expect(r.subcommand).toBe("start");
-        expect(r.flags.maxCost).toBe(999);
-        expect(r.idea).toBe("todo app");
-    });
-    it("/ideal --max-cost 9999 idea -> falls back to help with range error", () => {
-        const r = parseIdealArgs(["--max-cost", "9999", "idea"]);
-        expect(r.subcommand).toBe("help");
-        expect(r.warnings.some((w) => /max-cost|1, 1000|range/i.test(w))).toBe(true);
-    });
-    it("--done-threshold below 0.7 is clamped with a warning", () => {
-        const r = parseIdealArgs(["--done-threshold", "0.5", "idea"]);
-        expect(r.flags.doneThreshold).toBe(0.7);
-        expect(r.warnings.some((w) => w.includes("clamped"))).toBe(true);
-    });
-    it("--done-threshold above 1.0 is clamped with a warning", () => {
-        const r = parseIdealArgs(["--done-threshold", "1.2", "idea"]);
-        expect(r.flags.doneThreshold).toBe(1.0);
-        expect(r.warnings.some((w) => w.includes("clamped"))).toBe(true);
-    });
-    it("MUONROI_DEV=1 enables noCustomerDebate; disabled otherwise", () => {
-        expect(parseIdealArgs(["idea"]).flags.noCustomerDebate).toBeUndefined();
-        process.env.MUONROI_DEV = "1";
-        expect(parseIdealArgs(["idea"]).flags.noCustomerDebate).toBe(true);
-    });
-    it("--no-customer-debate is NOT a registered flag (does NOT appear in --help)", () => {
-        expect(getIdealHelpText().includes("--no-customer-debate")).toBe(false);
-        expect(getIdealHelpText().includes("customer-debate")).toBe(false);
-    });
-    it("--force-council sets forceCouncil=true", () => {
-        const r = parseIdealArgs(["--force-council", "build a counter"]);
-        expect(r.subcommand).toBe("start");
-        expect(r.flags.forceCouncil).toBe(true);
-    });
-    it("without --force-council, forceCouncil is undefined", () => {
-        const r = parseIdealArgs(["build a counter"]);
-        expect(r.subcommand).toBe("start");
-        expect(r.flags.forceCouncil).toBeUndefined();
-    });
-    it("--force-council appears in --help text", () => {
-        expect(getIdealHelpText().includes("--force-council")).toBe(true);
-    });
-});
-describe("/ideal slash handler dispatch", () => {
-    it("returns __PRODUCT_LOOP__ sentinel for start", async () => {
-        const out = await handleIdealSlash(["build a markdown todo CLI"], NOOP_CTX);
-        expect(out).toContain("__PRODUCT_LOOP__");
-        const json = out.split("__PRODUCT_LOOP__\n")[1];
-        const payload = JSON.parse(json);
-        expect(payload.subcommand).toBe("start");
-        expect(payload.idea).toBe("build a markdown todo CLI");
-    });
-    it("returns __PRODUCT_LOOP__ sentinel for status (no runId)", async () => {
-        const out = await handleIdealSlash(["status"], NOOP_CTX);
-        expect(out).toContain("__PRODUCT_LOOP__");
-        const payload = JSON.parse(out.split("__PRODUCT_LOOP__\n")[1]);
-        expect(payload.subcommand).toBe("status");
-        expect(payload.runId).toBeUndefined();
-    });
-    it("refuses resume without runId", async () => {
-        const out = await handleIdealSlash(["resume"], NOOP_CTX);
-        expect(out.toLowerCase()).toContain("requires a runid");
-    });
-    it("returns help text for empty args", async () => {
-        const out = await handleIdealSlash([], NOOP_CTX);
-        expect(out).toContain("/ideal — Product Ideal Loop");
-        expect(out).toContain("--max-cost");
-    });
-    it("propagates clamp warnings into the response", async () => {
-        const out = await handleIdealSlash(["--done-threshold", "0.5", "idea"], NOOP_CTX);
-        expect(out).toContain("clamped");
-        expect(out).toContain("__PRODUCT_LOOP__");
-    });
-    // Mode C — explicit flag wiring (see .planning/MAINTAIN-MODE.md)
-    describe("Mode C flags", () => {
-        it("--maintain sets flags.mode=maintain", () => {
-            const r = parseIdealArgs(["--maintain", "fix login bug"]);
-            expect(r.subcommand).toBe("start");
-            expect(r.flags.mode).toBe("maintain");
-            expect(r.flags.ghPr).toBeUndefined();
-        });
-        it("--new sets flags.mode=new", () => {
-            const r = parseIdealArgs(["--new", "scaffold microservice"]);
-            expect(r.subcommand).toBe("start");
-            expect(r.flags.mode).toBe("new");
-        });
-        it("--maintain + --gh-pr sets both flags", () => {
-            const r = parseIdealArgs(["--maintain", "--gh-pr", "fix bug"]);
-            expect(r.flags.mode).toBe("maintain");
-            expect(r.flags.ghPr).toBe(true);
-        });
-        it("--gh-pr without --maintain emits warning + drops ghPr semantics", () => {
-            const r = parseIdealArgs(["--gh-pr", "build dashboard"]);
-            expect(r.flags.mode).toBeUndefined();
-            expect(r.flags.ghPr).toBe(true); // parsed, but warning surfaced
-            expect(r.warnings.join(" ")).toMatch(/--gh-pr.*Mode C only/);
-        });
-        it("--maintain + --new are mutually exclusive — maintain wins with a warning", () => {
-            const r = parseIdealArgs(["--maintain", "--new", "anything"]);
-            expect(r.flags.mode).toBe("maintain");
-            expect(r.warnings.join(" ")).toMatch(/--maintain and --new are mutually exclusive/);
-        });
-        it("no Mode C flags = mode undefined (auto-detect path)", () => {
-            const r = parseIdealArgs(["build app"]);
-            expect(r.flags.mode).toBeUndefined();
-            expect(r.flags.ghPr).toBeUndefined();
-        });
-        it("help text mentions --maintain / --new / --gh-pr", () => {
-            const text = getIdealHelpText();
-            expect(text).toContain("--maintain");
-            expect(text).toContain("--new");
-            expect(text).toContain("--gh-pr");
-        });
-    });
-});
-//# sourceMappingURL=ideal.test.js.map

package/dist/src/ui/slash/__tests__/menu-parity.test.d.ts

@@ -1,17 +0,0 @@
-import "../optimize.js";
-import "../discuss.js";
-import "../plan.js";
-import "../execute.js";
-import "../compact.js";
-import "../expand.js";
-import "../clear.js";
-import "../pin.js";
-import "../cost.js";
-import "../ee.js";
-import "../debug.js";
-import "../council.js";
-import "../council-inspect.js";
-import "../ideal.js";
-import "../route.js";
-import "../status.js";
-import "../ponytail.js";

package/dist/src/ui/slash/__tests__/menu-parity.test.js

@@ -1,43 +0,0 @@
-/**
- * Drift guard — every command registered at runtime via registerSlash() MUST
- * appear in SLASH_MENU_ITEMS, otherwise the autocomplete shows
- * "No commands match" even though the command works when typed in full.
- *
- * This was the failure mode for /ideal: handler registered, menu entry missing.
- */
-import { describe, expect, it } from "vitest";
-import { SLASH_MENU_ITEMS } from "../menu-items.js";
-import { listSlashCommands } from "../registry.js";
-// Trigger side-effect registration for every slash module that participates
-// in the registry. Mirrors the imports in app.tsx — keep in sync.
-import "../optimize.js";
-import "../discuss.js";
-import "../plan.js";
-import "../execute.js";
-import "../compact.js";
-import "../expand.js";
-import "../clear.js";
-import "../pin.js";
-import "../cost.js";
-import "../ee.js";
-import "../debug.js";
-import "../council.js";
-import "../council-inspect.js";
-import "../ideal.js";
-import "../route.js";
-import "../status.js";
-import "../ponytail.js";
-describe("slash menu / registry parity", () => {
-    it("every registered slash command has a menu entry", () => {
-        const menuIds = new Set(SLASH_MENU_ITEMS.map((m) => m.id));
-        const registered = listSlashCommands();
-        const missing = registered.filter((name) => !menuIds.has(name));
-        expect(missing).toEqual([]);
-    });
-    it("includes /ideal entry (regression: was silently missing)", () => {
-        const ideal = SLASH_MENU_ITEMS.find((m) => m.id === "ideal");
-        expect(ideal).toBeDefined();
-        expect(ideal?.label).toBe("ideal");
-    });
-});
-//# sourceMappingURL=menu-parity.test.js.map

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

@@ -1 +0,0 @@
-import "../optimize.js";

package/dist/src/ui/slash/__tests__/optimize.test.js

@@ -1,130 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// 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 = () => ({
-    cwd: "/tmp",
-    tenantId: "local",
-    defaultProvider: "anthropic",
-    defaultModel: "claude-sonnet-4-20250514",
-});
-const makePipelineContext = () => ({
-    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,
-        suffixInstructionTokens: 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.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.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()));
-        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()));
-        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()));
-        expect(result).toContain("Metrics:");
-        expect(result).toContain("total pipeline:");
-        expect(result).toContain("L6 suffix input cost:");
-        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();
-    });
-});
-//# sourceMappingURL=optimize.test.js.map

package/dist/src/ui/slash/__tests__/pin.test.d.ts

@@ -1 +0,0 @@
-import "../pin.js";