muonroi-cli 1.8.1 → 1.8.4

package/dist/src/flow/__tests__/scaffold-checkpoint.test.js

@@ -1,93 +0,0 @@
-/**
- * Plan 23-fix — unit tests for scaffold-checkpoint persistence.
- */
-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 { listResumableScaffoldCheckpoints, readScaffoldCheckpoint, writeScaffoldCheckpoint, } from "../scaffold-checkpoint.js";
-let cwd;
-beforeEach(async () => {
-    cwd = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-checkpoint-"));
-});
-afterEach(async () => {
-    await fs.rm(cwd, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-const baseInputs = {
-    projectName: "todo-app",
-    feStack: "react",
-    bbTemplate: {
-        shortName: "mr-base-sln",
-        nugetId: "Muonroi.BaseTemplate",
-        version: "1.0.0-alpha.3",
-    },
-    eePackages: ["Muonroi.AspNetCore"],
-    commercial: false,
-};
-describe("scaffold-checkpoint", () => {
-    it("writes and reads a checkpoint round-trip", async () => {
-        const filePath = await writeScaffoldCheckpoint(cwd, "run-abc", {
-            status: "submitted",
-            inputs: baseInputs,
-            originalPrompt: "tạo todo app",
-        });
-        expect(filePath).toMatch(/run-abc.*scaffold-checkpoint\.json$/);
-        const loaded = await readScaffoldCheckpoint(cwd, "run-abc");
-        expect(loaded).not.toBeNull();
-        expect(loaded?.status).toBe("submitted");
-        expect(loaded?.inputs.projectName).toBe("todo-app");
-        expect(loaded?.inputs.bbTemplate?.nugetId).toBe("Muonroi.BaseTemplate");
-        expect(loaded?.runId).toBe("run-abc");
-        expect(loaded?.schemaVersion).toBe(1);
-    });
-    it("preserves createdAt across status updates", async () => {
-        await writeScaffoldCheckpoint(cwd, "run-xyz", { status: "submitted", inputs: baseInputs });
-        const first = await readScaffoldCheckpoint(cwd, "run-xyz");
-        await new Promise((r) => setTimeout(r, 10));
-        await writeScaffoldCheckpoint(cwd, "run-xyz", {
-            status: "error",
-            inputs: baseInputs,
-            errorMessage: "template not installed",
-        });
-        const second = await readScaffoldCheckpoint(cwd, "run-xyz");
-        expect(second?.createdAt).toBe(first?.createdAt);
-        expect(second?.updatedAt).not.toBe(first?.updatedAt);
-        expect(second?.status).toBe("error");
-        expect(second?.errorMessage).toBe("template not installed");
-    });
-    it("returns null for missing checkpoint", async () => {
-        expect(await readScaffoldCheckpoint(cwd, "nonexistent")).toBeNull();
-    });
-    it("returns null for corrupted JSON", async () => {
-        const dir = path.join(cwd, ".muonroi-flow", "runs", "run-bad");
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, "scaffold-checkpoint.json"), "{not valid json", "utf8");
-        expect(await readScaffoldCheckpoint(cwd, "run-bad")).toBeNull();
-    });
-    it("returns null for unknown schemaVersion (forward compat)", async () => {
-        const dir = path.join(cwd, ".muonroi-flow", "runs", "run-fut");
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(path.join(dir, "scaffold-checkpoint.json"), JSON.stringify({ schemaVersion: 99, runId: "run-fut", inputs: baseInputs }), "utf8");
-        expect(await readScaffoldCheckpoint(cwd, "run-fut")).toBeNull();
-    });
-    it("lists only non-done checkpoints, newest first", async () => {
-        await writeScaffoldCheckpoint(cwd, "run-1", { status: "submitted", inputs: baseInputs });
-        await new Promise((r) => setTimeout(r, 10));
-        await writeScaffoldCheckpoint(cwd, "run-2", { status: "error", inputs: baseInputs, errorMessage: "x" });
-        await new Promise((r) => setTimeout(r, 10));
-        await writeScaffoldCheckpoint(cwd, "run-3", {
-            status: "done",
-            inputs: baseInputs,
-            projectDir: "/tmp/todo-app",
-        });
-        const list = await listResumableScaffoldCheckpoints(cwd);
-        expect(list.length).toBe(2);
-        expect(list.map((c) => c.runId)).toEqual(["run-2", "run-1"]); // newest non-done first
-    });
-    it("listResumable returns empty array when flow dir missing", async () => {
-        const empty = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-empty-"));
-        expect(await listResumableScaffoldCheckpoints(empty)).toEqual([]);
-        await fs.rm(empty, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-});
-//# sourceMappingURL=scaffold-checkpoint.test.js.map

package/dist/src/flow/__tests__/scaffold.test.d.ts

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

package/dist/src/flow/__tests__/scaffold.test.js

@@ -1,47 +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 { ensureFlowDir, FLOW_DIR_NAME } from "../scaffold.js";
-describe("scaffold", () => {
-    let tmpDir;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "flow-scaffold-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("FLOW_DIR_NAME equals .muonroi-flow", () => {
-        expect(FLOW_DIR_NAME).toBe(".muonroi-flow");
-    });
-    it("creates .muonroi-flow/ with all required files and directories", async () => {
-        const flowDir = await ensureFlowDir(tmpDir);
-        expect(flowDir).toBe(path.join(tmpDir, ".muonroi-flow"));
-        // Check files exist
-        const roadmap = await fs.stat(path.join(flowDir, "roadmap.md"));
-        expect(roadmap.isFile()).toBe(true);
-        const state = await fs.stat(path.join(flowDir, "state.md"));
-        expect(state.isFile()).toBe(true);
-        const backlog = await fs.stat(path.join(flowDir, "backlog.md"));
-        expect(backlog.isFile()).toBe(true);
-        const decisions = await fs.stat(path.join(flowDir, "decisions.md"));
-        expect(decisions.isFile()).toBe(true);
-        // Check directories exist
-        const history = await fs.stat(path.join(flowDir, "history"));
-        expect(history.isDirectory()).toBe(true);
-        const runs = await fs.stat(path.join(flowDir, "runs"));
-        expect(runs.isDirectory()).toBe(true);
-    });
-    it("is idempotent (second call does not overwrite existing files)", async () => {
-        await ensureFlowDir(tmpDir);
-        const flowDir = path.join(tmpDir, ".muonroi-flow");
-        // Write custom content to roadmap.md
-        await fs.writeFile(path.join(flowDir, "roadmap.md"), "custom content", "utf8");
-        // Call again
-        await ensureFlowDir(tmpDir);
-        // Verify custom content preserved
-        const content = await fs.readFile(path.join(flowDir, "roadmap.md"), "utf8");
-        expect(content).toBe("custom content");
-    });
-});
-//# sourceMappingURL=scaffold.test.js.map

package/dist/src/flow/__tests__/warning-persist.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for warning-persist.ts — persistWarning appends EE hook warnings
- * to run state.md Experience Snapshot section.
- */
-export {};

package/dist/src/flow/__tests__/warning-persist.test.js

@@ -1,96 +0,0 @@
-/**
- * Tests for warning-persist.ts — persistWarning appends EE hook warnings
- * to run state.md Experience Snapshot section.
- */
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { getSection } from "../parser.js";
-import { createRun, loadRun, setActiveRunId } from "../run-manager.js";
-import { ensureFlowDir } from "../scaffold.js";
-import { persistWarning } from "../warning-persist.js";
-let tempDirs = [];
-async function makeTempDir(prefix) {
-    const dir = await mkdtemp(path.join(tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(async () => {
-    for (const d of tempDirs) {
-        await rm(d, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-    }
-    tempDirs = [];
-});
-function makeMatch(overrides) {
-    return {
-        principle_uuid: "test-uuid",
-        embedding_model_version: "v1",
-        confidence: 0.85,
-        why: "Test reason",
-        message: "Test warning message",
-        scope_label: "repo:test",
-        last_matched_at: "2026-04-30T00:00:00Z",
-        ...overrides,
-    };
-}
-describe("persistWarning", () => {
-    it("appends rendered warning to state.md Experience Snapshot section", async () => {
-        const cwd = await makeTempDir("warn-persist-");
-        const flowDir = await ensureFlowDir(cwd);
-        const run = await createRun(flowDir);
-        await setActiveRunId(flowDir, run.id);
-        const match = makeMatch({ message: "Do not force push", why: "Destroys history" });
-        await persistWarning(cwd, match);
-        const restored = await loadRun(flowDir, run.id);
-        expect(restored).not.toBeNull();
-        const snapshot = getSection(restored.state, "Experience Snapshot");
-        expect(snapshot).toContain("Do not force push");
-        expect(snapshot).toContain("Destroys history");
-    });
-    it("is a no-op when no active run exists (does not throw)", async () => {
-        const cwd = await makeTempDir("warn-no-run-");
-        await ensureFlowDir(cwd);
-        // No active run set
-        await expect(persistWarning(cwd, makeMatch())).resolves.toBeUndefined();
-    });
-    it("is a no-op when .muonroi-flow/ does not exist", async () => {
-        const cwd = await makeTempDir("warn-no-flow-");
-        await expect(persistWarning(cwd, makeMatch())).resolves.toBeUndefined();
-    });
-    it("accumulates multiple warnings (not overwrite)", async () => {
-        const cwd = await makeTempDir("warn-accum-");
-        const flowDir = await ensureFlowDir(cwd);
-        const run = await createRun(flowDir);
-        await setActiveRunId(flowDir, run.id);
-        await persistWarning(cwd, makeMatch({ message: "Warning A", principle_uuid: "uuid-a" }));
-        await persistWarning(cwd, makeMatch({ message: "Warning B", principle_uuid: "uuid-b" }));
-        await persistWarning(cwd, makeMatch({ message: "Warning C", principle_uuid: "uuid-c" }));
-        const restored = await loadRun(flowDir, run.id);
-        const snapshot = getSection(restored.state, "Experience Snapshot");
-        expect(snapshot).toContain("Warning A");
-        expect(snapshot).toContain("Warning B");
-        expect(snapshot).toContain("Warning C");
-    });
-    it("uses renderInterceptWarning format", async () => {
-        const cwd = await makeTempDir("warn-format-");
-        const flowDir = await ensureFlowDir(cwd);
-        const run = await createRun(flowDir);
-        await setActiveRunId(flowDir, run.id);
-        const match = makeMatch({
-            confidence: 0.92,
-            message: "Avoid rm -rf",
-            why: "Dangerous command",
-            scope_label: "global",
-        });
-        await persistWarning(cwd, match);
-        const restored = await loadRun(flowDir, run.id);
-        const snapshot = getSection(restored.state, "Experience Snapshot");
-        // renderInterceptWarning format: boxed 5-line warning with percentage confidence
-        expect(snapshot).toContain("92%");
-        expect(snapshot).toContain("Avoid rm -rf");
-        expect(snapshot).toContain("Dangerous command");
-        expect(snapshot).toContain("global");
-    });
-});
-//# sourceMappingURL=warning-persist.test.js.map

package/dist/src/flow/compaction/__tests__/compress.test.d.ts

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

package/dist/src/flow/compaction/__tests__/compress.test.js

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { compressChat } from "../compress.js";
-// Mock the existing compaction engine
-vi.mock("../../../orchestrator/compaction.js", () => ({
-    serializeConversation: (msgs) => {
-        // Simple serialization for tests
-        return msgs
-            .map((m) => {
-            const text = typeof m.content === "string" ? m.content : "";
-            return `[${m.role}]: ${text}`;
-        })
-            .join("\n\n");
-    },
-    estimateMessageTokens: (msg) => {
-        const text = typeof msg.content === "string" ? msg.content : "";
-        return Math.ceil(text.length / 4);
-    },
-    prepareCompaction: vi.fn().mockReturnValue(null),
-    generateCompactionSummary: vi.fn().mockResolvedValue("Compressed summary"),
-    DEFAULT_RESERVE_TOKENS: 16_384,
-    DEFAULT_KEEP_RECENT_TOKENS: 20_000,
-}));
-describe("compressChat", () => {
-    const shortMessages = [
-        { role: "user", content: "Hello" },
-        { role: "assistant", content: "Hi there" },
-    ];
-    it("returns messages unchanged when under token budget", async () => {
-        const result = await compressChat(shortMessages, "system prompt", 10000);
-        expect(result.summary).toContain("Hello");
-        expect(result.summary).toContain("Hi there");
-        expect(result.tokensAfter).toBeLessThanOrEqual(10000);
-    });
-    it("preserves <!-- preserve --> blocks verbatim in output", async () => {
-        const messages = [
-            {
-                role: "user",
-                content: "Some chat\n<!-- preserve -->\nCritical verbatim block\n<!-- /preserve -->\nMore chat",
-            },
-        ];
-        const result = await compressChat(messages, "system", 10000);
-        expect(result.summary).toContain("<!-- preserve -->");
-        expect(result.summary).toContain("Critical verbatim block");
-        expect(result.summary).toContain("<!-- /preserve -->");
-    });
-    it("returns preservedBlocks array", async () => {
-        const messages = [
-            {
-                role: "user",
-                content: "Text\n<!-- preserve -->\nBlock content\n<!-- /preserve -->\nRest",
-            },
-        ];
-        const result = await compressChat(messages, "system", 10000);
-        expect(result.preservedBlocks).toHaveLength(1);
-        expect(result.preservedBlocks[0].content).toBe("\nBlock content\n");
-    });
-    it("returns estimated tokensAfter", async () => {
-        const result = await compressChat(shortMessages, "system prompt", 10000);
-        expect(result.tokensAfter).toBeGreaterThan(0);
-        expect(typeof result.tokensAfter).toBe("number");
-    });
-});
-//# sourceMappingURL=compress.test.js.map

package/dist/src/flow/compaction/__tests__/extract.test.d.ts

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

package/dist/src/flow/compaction/__tests__/extract.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractDecisions } from "../extract.js";
-describe("extractDecisions", () => {
-    it("extracts Decision: lines from messages", () => {
-        const messages = [
-            { role: "user", content: "Decision: Use JWT for auth" },
-            { role: "assistant", content: "Understood. I'll implement JWT." },
-        ];
-        const result = extractDecisions(messages);
-        expect(result.decisions).toContain("Use JWT for auth");
-    });
-    it("extracts Decided: lines", () => {
-        const messages = [{ role: "user", content: "Decided: Go with PostgreSQL" }];
-        const result = extractDecisions(messages);
-        expect(result.decisions).toContain("Go with PostgreSQL");
-    });
-    it("extracts Fact: lines", () => {
-        const messages = [{ role: "assistant", content: "Fact: The API rate limit is 100 req/min" }];
-        const result = extractDecisions(messages);
-        expect(result.facts).toContain("The API rate limit is 100 req/min");
-    });
-    it("extracts Constraint: lines", () => {
-        const messages = [{ role: "user", content: "Constraint: Must run on Windows and Linux" }];
-        const result = extractDecisions(messages);
-        expect(result.constraints).toContain("Must run on Windows and Linux");
-    });
-    it("extracts content inside preserve blocks as decisions", () => {
-        const messages = [
-            {
-                role: "user",
-                content: "Some text\n<!-- preserve -->\nImportant preserved content\n<!-- /preserve -->\nMore text",
-            },
-        ];
-        const result = extractDecisions(messages);
-        expect(result.decisions).toContain("\nImportant preserved content\n");
-    });
-    it("returns empty arrays for empty messages", () => {
-        const result = extractDecisions([]);
-        expect(result.decisions).toEqual([]);
-        expect(result.facts).toEqual([]);
-        expect(result.constraints).toEqual([]);
-    });
-    it("returns empty arrays when no patterns match", () => {
-        const messages = [
-            { role: "user", content: "Hello, how are you?" },
-            { role: "assistant", content: "I'm doing well!" },
-        ];
-        const result = extractDecisions(messages);
-        expect(result.decisions).toEqual([]);
-        expect(result.facts).toEqual([]);
-        expect(result.constraints).toEqual([]);
-    });
-    it("extracts multiple patterns from a single message", () => {
-        const messages = [
-            {
-                role: "user",
-                content: "Decision: Use TypeScript\nFact: Project uses Bun runtime\nConstraint: No new dependencies",
-            },
-        ];
-        const result = extractDecisions(messages);
-        expect(result.decisions).toContain("Use TypeScript");
-        expect(result.facts).toContain("Project uses Bun runtime");
-        expect(result.constraints).toContain("No new dependencies");
-    });
-});
-//# sourceMappingURL=extract.test.js.map

package/dist/src/flow/compaction/__tests__/preserve.test.d.ts

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

package/dist/src/flow/compaction/__tests__/preserve.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractPreservedBlocks, PRESERVE_CLOSE, PRESERVE_OPEN, restorePreservedBlocks } from "../preserve.js";
-describe("extractPreservedBlocks", () => {
-    it("extracts single preserve block and replaces with placeholder", () => {
-        const text = `Before\n${PRESERVE_OPEN}\nKeep this verbatim\n${PRESERVE_CLOSE}\nAfter`;
-        const { cleaned, blocks } = extractPreservedBlocks(text);
-        expect(blocks).toHaveLength(1);
-        expect(blocks[0].content).toBe("\nKeep this verbatim\n");
-        expect(cleaned).toContain("__PRESERVED_0__");
-        expect(cleaned).not.toContain(PRESERVE_OPEN);
-        expect(cleaned).not.toContain("Keep this verbatim");
-        expect(cleaned).toContain("Before");
-        expect(cleaned).toContain("After");
-    });
-    it("extracts multiple preserve blocks", () => {
-        const text = `A\n${PRESERVE_OPEN}\nBlock1\n${PRESERVE_CLOSE}\nB\n${PRESERVE_OPEN}\nBlock2\n${PRESERVE_CLOSE}\nC`;
-        const { cleaned, blocks } = extractPreservedBlocks(text);
-        expect(blocks).toHaveLength(2);
-        expect(blocks[0].content).toBe("\nBlock1\n");
-        expect(blocks[1].content).toBe("\nBlock2\n");
-        expect(cleaned).toContain("__PRESERVED_0__");
-        expect(cleaned).toContain("__PRESERVED_1__");
-    });
-    it("returns empty blocks for text without markers", () => {
-        const text = "No markers here";
-        const { cleaned, blocks } = extractPreservedBlocks(text);
-        expect(blocks).toHaveLength(0);
-        expect(cleaned).toBe(text);
-    });
-    it("handles empty text", () => {
-        const { cleaned, blocks } = extractPreservedBlocks("");
-        expect(blocks).toHaveLength(0);
-        expect(cleaned).toBe("");
-    });
-    it("handles malformed markers gracefully (open without close)", () => {
-        const text = `Before\n${PRESERVE_OPEN}\nUnclosed content`;
-        const { cleaned, blocks } = extractPreservedBlocks(text);
-        // Unclosed marker is NOT extracted
-        expect(blocks).toHaveLength(0);
-        expect(cleaned).toBe(text);
-    });
-});
-describe("restorePreservedBlocks", () => {
-    it("round-trips extract + restore", () => {
-        const original = `Start\n${PRESERVE_OPEN}\nVerbatim content\n${PRESERVE_CLOSE}\nEnd`;
-        const { cleaned, blocks } = extractPreservedBlocks(original);
-        const restored = restorePreservedBlocks(cleaned, blocks);
-        expect(restored).toBe(original);
-    });
-    it("restores multiple blocks in order", () => {
-        const original = `A\n${PRESERVE_OPEN}\nFirst\n${PRESERVE_CLOSE}\nB\n${PRESERVE_OPEN}\nSecond\n${PRESERVE_CLOSE}\nC`;
-        const { cleaned, blocks } = extractPreservedBlocks(original);
-        const restored = restorePreservedBlocks(cleaned, blocks);
-        expect(restored).toBe(original);
-    });
-    it("returns text unchanged when no blocks provided", () => {
-        const text = "No placeholders here";
-        const restored = restorePreservedBlocks(text, []);
-        expect(restored).toBe(text);
-    });
-});
-//# sourceMappingURL=preserve.test.js.map

package/dist/src/gsd/__tests__/gray-areas.test.d.ts

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

package/dist/src/gsd/__tests__/gray-areas.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectGrayAreas } from "../gray-areas.js";
-describe("detectGrayAreas", () => {
-    it("returns no questions for empty input", () => {
-        expect(detectGrayAreas("").questions).toHaveLength(0);
-    });
-    it("flags scope when prompt is broad", () => {
-        const r = detectGrayAreas("rewrite everything for better performance");
-        const dims = r.questions.map((q) => q.dimension);
-        expect(dims).toContain("scope");
-    });
-    it("does not flag scope when prompt names a single file", () => {
-        const r = detectGrayAreas("rename foo to bar in src/index.ts");
-        const dims = r.questions.map((q) => q.dimension);
-        expect(dims).not.toContain("scope");
-    });
-    it("each question's first option is the recommended default", () => {
-        const r = detectGrayAreas("redo the architecture");
-        for (const q of r.questions) {
-            expect(q.options[0]).toBeTruthy();
-            expect(q.options.length).toBeGreaterThanOrEqual(2);
-        }
-    });
-    it("caps the number of questions at 4", () => {
-        const r = detectGrayAreas("do everything everywhere all at once");
-        expect(r.questions.length).toBeLessThanOrEqual(4);
-    });
-});
-//# sourceMappingURL=gray-areas.test.js.map

package/dist/src/gsd/__tests__/types.test.d.ts

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

package/dist/src/gsd/__tests__/types.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectGsdPhase, GSD_PHASES, isGsdPhase } from "../types.js";
-describe("GSD types", () => {
-    it("GSD_PHASES contains all expected phases", () => {
-        expect(GSD_PHASES).toContain("discuss");
-        expect(GSD_PHASES).toContain("plan");
-        expect(GSD_PHASES).toContain("execute");
-        expect(GSD_PHASES).toContain("verify");
-        expect(GSD_PHASES).toContain("review");
-        expect(GSD_PHASES).toContain("debug");
-        expect(GSD_PHASES.length).toBe(6);
-    });
-    it("isGsdPhase returns true for valid phases", () => {
-        expect(isGsdPhase("discuss")).toBe(true);
-        expect(isGsdPhase("plan")).toBe(true);
-        expect(isGsdPhase("execute")).toBe(true);
-        expect(isGsdPhase("verify")).toBe(true);
-        expect(isGsdPhase("review")).toBe(true);
-        expect(isGsdPhase("debug")).toBe(true);
-    });
-    it("detectGsdPhase routes fix/debug language to debug phase (session 127140a47b56)", () => {
-        // Position-based detection: when a debug keyword appears first, debug wins.
-        expect(detectGsdPhase("fix CI fail")).toBe("debug");
-        expect(detectGsdPhase("fix lỗi và check lại CI")).toBe("debug");
-        expect(detectGsdPhase("sửa bug này giúp tôi")).toBe("debug");
-        expect(detectGsdPhase("debug this crash")).toBe("debug");
-        // The exact session 127140a47b56 prompt — "fix" beats later "check".
-        expect(detectGsdPhase("action github đang run fail check và fix cho tôi")).toBe("debug");
-        // Without explicit debug keywords, "check" still falls through to verify.
-        expect(detectGsdPhase("check that this works")).toBe("verify");
-    });
-    it("isGsdPhase returns false for invalid strings", () => {
-        expect(isGsdPhase("unknown")).toBe(false);
-        expect(isGsdPhase("")).toBe(false);
-        expect(isGsdPhase("PLAN")).toBe(false);
-    });
-    it("detectGsdPhase detects plan from keywords", () => {
-        expect(detectGsdPhase("plan the implementation")).toBe("plan");
-        expect(detectGsdPhase("let's plan this feature")).toBe("plan");
-    });
-    it("detectGsdPhase detects execute from keywords", () => {
-        expect(detectGsdPhase("execute the plan now")).toBe("execute");
-        expect(detectGsdPhase("implement the feature")).toBe("execute");
-        expect(detectGsdPhase("build the component")).toBe("execute");
-    });
-    it("detectGsdPhase detects verify from keywords", () => {
-        expect(detectGsdPhase("verify the results")).toBe("verify");
-        expect(detectGsdPhase("validate that it works")).toBe("verify");
-        expect(detectGsdPhase("test the implementation")).toBe("verify");
-    });
-    it("detectGsdPhase detects review from keywords", () => {
-        expect(detectGsdPhase("review the code")).toBe("review");
-        expect(detectGsdPhase("audit the changes")).toBe("review");
-    });
-    it("detectGsdPhase detects discuss from keywords", () => {
-        expect(detectGsdPhase("discuss the approach")).toBe("discuss");
-        expect(detectGsdPhase("let's brainstorm ideas")).toBe("discuss");
-    });
-    it("detectGsdPhase returns null for no match", () => {
-        expect(detectGsdPhase("hello world")).toBeNull();
-        expect(detectGsdPhase("")).toBeNull();
-    });
-});
-describe("detectGsdPhase — ambiguity resolution", () => {
-    it("'implement the plan' returns execute (action verb wins)", () => {
-        expect(detectGsdPhase("implement the plan")).toBe("execute");
-    });
-    it("'plan the implementation' returns plan (plan appears first)", () => {
-        expect(detectGsdPhase("plan the implementation")).toBe("plan");
-    });
-    it("'discuss the plan before executing' returns discuss (discuss first)", () => {
-        expect(detectGsdPhase("discuss the plan before executing")).toBe("discuss");
-    });
-    it("'build and verify the feature' returns execute (build first)", () => {
-        expect(detectGsdPhase("build and verify the feature")).toBe("execute");
-    });
-});
-//# sourceMappingURL=types.test.js.map

package/dist/src/headless/__tests__/council-answers.test.d.ts

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