muonroi-cli 1.3.4 → 1.4.1

package/dist/src/maintain/__tests__/pr-builder.test.js

@@ -0,0 +1,225 @@
+/**
+ * pr-builder.test.ts — P16 unit tests.
+ *
+ * Covers:
+ *   1. Happy path: diff + body generated, all changed files inside radius.
+ *   2. Files-outside-radius flagged in output but not blocking.
+ *   3. LLM mock returns body verbatim (no transformation by buildPr).
+ *   4. Squash gracefully degrades when marker SHA file is missing.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// ── Mocks ──────────────────────────────────────────────────────────────────
+// vi.hoisted ensures the factory variable is available when vi.mock is hoisted.
+const { mockExecFile } = vi.hoisted(() => ({ mockExecFile: vi.fn() }));
+vi.mock("node:child_process", () => ({
+    execFile: mockExecFile,
+}));
+vi.mock("../../council/leader.js", () => ({
+    pickCouncilTaskModel: vi.fn((_task, leaderId) => leaderId),
+}));
+// fs mock: readFileSync throws by default (no marker file) — tests override per case.
+vi.mock("node:fs", async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        readFileSync: vi.fn(() => {
+            throw new Error("ENOENT: no such file");
+        }),
+    };
+});
+// execFileMock is defined above as mockExecFile via vi.mock hoisting
+import * as fs from "node:fs";
+import { buildPr } from "../pr-builder.js";
+/**
+ * execFile mock that matches on full argv sequence stringified.
+ * Used for more precise multi-git-call flows.
+ */
+function setupDetailedGitMock(responses) {
+    let callIndex = 0;
+    mockExecFile.mockImplementation((_cmd, _args, _opts, cb) => {
+        const resp = responses[callIndex] ?? { stdout: "" };
+        callIndex++;
+        if (resp.fail) {
+            cb(new Error(resp.stderr ?? "git failed"), { stdout: "", stderr: resp.stderr ?? "" });
+        }
+        else {
+            cb(null, { stdout: resp.stdout ?? "", stderr: "" });
+        }
+    });
+}
+function makeLlm(returnBody = "## Summary\nTest body.") {
+    return {
+        generate: vi.fn(async () => returnBody),
+    };
+}
+function makeTask(overrides = {}) {
+    return {
+        id: "01HX1234ABCD",
+        kind: "bug",
+        title: "Fix null pointer in login handler",
+        description: "The login handler throws a null pointer when email field is empty.",
+        acceptance_criteria: ["no null pointer on empty email", "error message shown"],
+        candidateFiles: ["src/auth/login.ts"],
+        impactRadius: ["src/app.tsx", "src/middleware/auth.ts"],
+        regressionTestFiles: ["src/auth/__tests__/login.test.ts"],
+        status: "queued",
+        createdAtUtc: new Date().toISOString(),
+        updatedAtUtc: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeIntel(overrides = {}) {
+    return {
+        cwd: "/tmp/proj",
+        repoMap: "src/\n  auth/\n    login.ts",
+        repoMapSource: "generated",
+        candidateFiles: [{ path: "src/auth/login.ts", reason: "filename match", matchScore: 0.9 }],
+        impactRadius: ["src/app.tsx", "src/middleware/auth.ts"],
+        regressionTests: ["src/auth/__tests__/login.test.ts"],
+        detectedFrameworks: ["node", "react"],
+        capturedAtUtc: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    return {
+        status: "done",
+        designPlan: "1. Fix null check\n2. Add error message",
+        verifyOutput: "2 tests passed",
+        judgeScore: 0.95,
+        reviewConcerns: [],
+        ...overrides,
+    };
+}
+function makeInput(taskOverrides = {}, intelOverrides = {}, resultOverrides = {}, llmBody) {
+    return {
+        task: makeTask(taskOverrides),
+        codebaseIntel: makeIntel(intelOverrides),
+        result: makeResult(resultOverrides),
+        cwd: "/tmp/proj",
+        leaderModelId: "test-model-id",
+        costAware: true,
+        llm: makeLlm(llmBody ?? "## Summary\nTest body."),
+    };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe("buildPr — happy path (all files inside radius)", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // No marker file — readFileSync will throw (default mock).
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("returns branch, title, body, diff, changedFiles with zero filesOutsideRadius", async () => {
+        setupDetailedGitMock([
+            // status --porcelain → changed file inside radius
+            { matchArgs: ["status"], stdout: " M src/auth/login.ts\n" },
+            // diff HEAD → shows the actual diff
+            { matchArgs: ["diff"], stdout: "diff --git a/src/auth/login.ts b/src/auth/login.ts\n+null check added\n" },
+            // rev-parse --verify <branch> → fail (branch doesn't exist yet)
+            { matchArgs: ["rev-parse"], fail: true },
+        ]);
+        const input = makeInput();
+        const output = await buildPr(input);
+        expect(output.branch).toMatch(/^claude\/bug-/);
+        expect(output.title).toBe("Fix null pointer in login handler");
+        expect(output.body).toContain("Summary");
+        expect(output.diff).toContain("null check added");
+        expect(output.filesOutsideRadius).toHaveLength(0);
+        expect(output.changedFiles).toContain("src/auth/login.ts");
+    });
+});
+describe("buildPr — files outside radius flagged", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("puts unexpected files in filesOutsideRadius without blocking", async () => {
+        setupDetailedGitMock([
+            // status --porcelain → includes an unexpected file
+            { matchArgs: ["status"], stdout: " M src/auth/login.ts\n M src/unexpected/file.ts\n" },
+            // diff HEAD
+            { matchArgs: ["diff"], stdout: "diff --git a/src/unexpected/file.ts\n+something unexpected\n" },
+            // rev-parse → branch doesn't exist
+            { matchArgs: ["rev-parse"], fail: true },
+        ]);
+        const input = makeInput();
+        const output = await buildPr(input);
+        expect(output.filesOutsideRadius).toContain("src/unexpected/file.ts");
+        // The build still succeeds — no throw.
+        expect(output.branch).toBeTruthy();
+        expect(output.title).toBeTruthy();
+    });
+});
+describe("buildPr — LLM body returned verbatim", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("body in output exactly matches the LLM response without modification", async () => {
+        setupDetailedGitMock([
+            { matchArgs: ["status"], stdout: " M src/auth/login.ts\n" },
+            { matchArgs: ["diff"], stdout: "diff ...\n+change\n" },
+            { matchArgs: ["rev-parse"], fail: true },
+        ]);
+        const verbatimBody = "## Summary\nVerbatim from LLM.\n\n## What changed\n- changed the thing.";
+        const input = makeInput({}, {}, {}, verbatimBody);
+        const output = await buildPr(input);
+        expect(output.body).toBe(verbatimBody);
+    });
+});
+describe("buildPr — squash gracefully degrades when marker missing", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // readFileSync throws (default mock — simulates missing marker file).
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("still returns valid output when no marker SHA file exists (no squash attempt)", async () => {
+        // No squash means no rev-parse HEAD, no reset --soft — just status + diff + branch check.
+        setupDetailedGitMock([
+            { matchArgs: ["status"], stdout: " M src/auth/login.ts\n" },
+            { matchArgs: ["diff"], stdout: "diff --git a/src/auth/login.ts\n+fix here\n" },
+            { matchArgs: ["rev-parse"], fail: true },
+        ]);
+        const input = makeInput();
+        // Should not throw even though marker is absent.
+        const output = await buildPr(input);
+        expect(output.branch).toMatch(/^claude\/bug-/);
+        expect(output.diff).toContain("fix here");
+        expect(output.changedFiles).toContain("src/auth/login.ts");
+    });
+    it("squashes when marker file exists and commits since marker are present", async () => {
+        // Provide a marker via readFileSync mock for this test.
+        const MARKER_SHA = "abc123def456";
+        fs.readFileSync.mockReturnValueOnce(MARKER_SHA);
+        setupDetailedGitMock([
+            // squashSinceMarker: rev-parse HEAD
+            { matchArgs: ["rev-parse"], stdout: "deadbeef1234" },
+            // squashSinceMarker: log marker..HEAD
+            { matchArgs: ["log"], stdout: "deadbeef1234 some commit" },
+            // squashSinceMarker: reset --soft
+            { matchArgs: ["reset"], stdout: "" },
+            // squashSinceMarker: commit
+            { matchArgs: ["commit"], stdout: "[main deadbeef] Fix null pointer in login handler" },
+            // getChangedFiles: status --porcelain
+            { matchArgs: ["status"], stdout: " M src/auth/login.ts\n" },
+            // getChangedFiles: diff --name-only HEAD~1 HEAD (squashed=true)
+            { matchArgs: ["diff"], stdout: "src/auth/login.ts\n" },
+            // computeDiff: diff HEAD~1 HEAD (squashed=true)
+            { matchArgs: ["diff"], stdout: "diff --git a/src/auth/login.ts\n+squashed change\n" },
+            // uniqueBranchName: rev-parse --verify branch
+            { matchArgs: ["rev-parse"], fail: true },
+        ]);
+        const input = makeInput();
+        const output = await buildPr(input);
+        expect(output.diff).toContain("squashed change");
+    });
+});
+//# sourceMappingURL=pr-builder.test.js.map

package/dist/src/maintain/__tests__/repo-map.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * repo-map.test.ts — Unit tests for ensureRepoMap + generateRepoMap.
+ * Uses tmpdir for fs operations so it never touches the real workspace.
+ */
+export {};

package/dist/src/maintain/__tests__/repo-map.test.js

@@ -0,0 +1,90 @@
+/**
+ * repo-map.test.ts — Unit tests for ensureRepoMap + generateRepoMap.
+ * Uses tmpdir for fs operations so it never touches the real workspace.
+ */
+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 { ensureRepoMap, generateRepoMap } from "../repo-map.js";
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-repo-map-test-"));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+});
+// ---------------------------------------------------------------------------
+describe("ensureRepoMap", () => {
+    it("reads existing REPO_DEEP_MAP.md when present", async () => {
+        const content = "# REPO_DEEP_MAP\n> pre-existing map\n\nsrc/\n├── index.ts\n";
+        await fs.writeFile(path.join(tmpDir, "REPO_DEEP_MAP.md"), content, "utf8");
+        const result = await ensureRepoMap(tmpDir);
+        expect(result.source).toBe("existing");
+        expect(result.content).toContain("pre-existing map");
+        expect(result.path).toBe(path.join(tmpDir, "REPO_DEEP_MAP.md"));
+    });
+    it("generates and writes REPO_DEEP_MAP.md when file is missing", async () => {
+        // Create a small synthetic file tree
+        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+        await fs.writeFile(path.join(tmpDir, "src", "index.ts"), "// entry point\nexport {};", "utf8");
+        const result = await ensureRepoMap(tmpDir);
+        expect(result.source).toBe("generated");
+        // File should now exist on disk
+        const written = await fs.readFile(path.join(tmpDir, "REPO_DEEP_MAP.md"), "utf8");
+        expect(written).toContain("REPO_DEEP_MAP");
+        expect(result.content).toContain("src");
+    });
+    it("truncates long existing content to ~2000 chars", async () => {
+        const longContent = "x".repeat(5000);
+        await fs.writeFile(path.join(tmpDir, "REPO_DEEP_MAP.md"), longContent, "utf8");
+        const result = await ensureRepoMap(tmpDir);
+        // Content must be truncated
+        expect(result.content.length).toBeLessThanOrEqual(2020); // 2000 + "[... truncated]"
+        expect(result.content).toContain("[... truncated]");
+    });
+});
+// ---------------------------------------------------------------------------
+describe("generateRepoMap", () => {
+    it("skips node_modules, .git, and dist directories", async () => {
+        // Create skip-listed dirs with files
+        for (const skipDir of ["node_modules", ".git", "dist"]) {
+            await fs.mkdir(path.join(tmpDir, skipDir), { recursive: true });
+            await fs.writeFile(path.join(tmpDir, skipDir, "should-be-hidden.ts"), "// hidden", "utf8");
+        }
+        // Create a real source file
+        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+        await fs.writeFile(path.join(tmpDir, "src", "visible.ts"), "// visible", "utf8");
+        const map = await generateRepoMap(tmpDir);
+        expect(map).toContain("visible.ts");
+        expect(map).not.toContain("node_modules");
+        expect(map).not.toContain("should-be-hidden");
+        expect(map).not.toContain(".git");
+        expect(map).not.toContain("dist");
+    });
+    it("truncates output at ~2000 chars and appends truncation marker", async () => {
+        // Create many files to force truncation
+        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+        for (let i = 0; i < 60; i++) {
+            await fs.writeFile(path.join(tmpDir, "src", `file-with-long-name-${String(i).padStart(3, "0")}.ts`), "// filler", "utf8");
+        }
+        const map = await generateRepoMap(tmpDir);
+        // Should be under MAX_GENERATE_CHARS (1800) + truncation line
+        expect(map.length).toBeLessThanOrEqual(1900);
+        expect(map).toContain("truncated");
+    });
+    it("extracts top-of-file JSDoc description from TS files", async () => {
+        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+        await fs.writeFile(path.join(tmpDir, "src", "auth.ts"), `/**\n * Handles user authentication and session management.\n */\nexport {};`, "utf8");
+        const map = await generateRepoMap(tmpDir);
+        expect(map).toContain("auth.ts");
+        expect(map).toContain("Handles user authentication");
+    });
+    it("extracts top-of-file // comment description from TS files", async () => {
+        await fs.mkdir(path.join(tmpDir, "src"), { recursive: true });
+        await fs.writeFile(path.join(tmpDir, "src", "logger.ts"), `// Structured logging utilities for the CLI\nexport {};`, "utf8");
+        const map = await generateRepoMap(tmpDir);
+        expect(map).toContain("Structured logging utilities");
+    });
+});
+//# sourceMappingURL=repo-map.test.js.map

package/dist/src/maintain/__tests__/task-runner.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * task-runner.test.ts — P15 unit tests.
+ *
+ * Covers:
+ *   1. Happy path: 5 phase pairs emitted in order with stable phaseIds + startedAt
+ *   2. Judge fail: yields phaseError and returns status="blocked"
+ *   3. Review with concerns: surfaces concerns in result and as final chunk
+ *   4. Missing verify recipe: returns status="failed" with clear reason
+ *   5. Edit stage failure: returns status="failed"
+ */
+export {};

package/dist/src/maintain/__tests__/task-runner.test.js

@@ -0,0 +1,281 @@
+/**
+ * task-runner.test.ts — P15 unit tests.
+ *
+ * Covers:
+ *   1. Happy path: 5 phase pairs emitted in order with stable phaseIds + startedAt
+ *   2. Judge fail: yields phaseError and returns status="blocked"
+ *   3. Review with concerns: surfaces concerns in result and as final chunk
+ *   4. Missing verify recipe: returns status="failed" with clear reason
+ *   5. Edit stage failure: returns status="failed"
+ */
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { getTestModels } from "../../__test-helpers__/catalog-fixtures.js";
+import { loadCatalog } from "../../models/registry.js";
+beforeAll(async () => {
+    await loadCatalog();
+});
+// ── Mocks ──────────────────────────────────────────────────────────────────
+vi.mock("../../verify/orchestrator.js", () => ({
+    runVerifyOrchestration: vi.fn(),
+}));
+vi.mock("../../product-loop/done-gate.js", () => ({
+    evaluateDoneGate: vi.fn(),
+}));
+vi.mock("../../council/leader.js", () => ({
+    pickCouncilTaskModel: vi.fn((_task, leaderId) => leaderId),
+}));
+import { evaluateDoneGate } from "../../product-loop/done-gate.js";
+import { runVerifyOrchestration } from "../../verify/orchestrator.js";
+import { runMaintenanceTask } from "../task-runner.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makeTask(overrides = {}) {
+    return {
+        id: "01HX1234",
+        kind: "bug",
+        title: "Fix login redirect",
+        description: "After login the user is redirected to /undefined instead of /dashboard",
+        acceptance_criteria: ["redirect to /dashboard after login", "no 404 on redirect"],
+        candidateFiles: ["src/auth/login.ts"],
+        impactRadius: ["src/app.tsx"],
+        regressionTestFiles: ["src/auth/__tests__/login.test.ts"],
+        status: "queued",
+        createdAtUtc: new Date().toISOString(),
+        updatedAtUtc: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeIntel(overrides = {}) {
+    return {
+        cwd: "/tmp/proj",
+        repoMap: "src/\n  auth/\n    login.ts\n  app.tsx",
+        repoMapSource: "generated",
+        candidateFiles: [{ path: "src/auth/login.ts", reason: "filename match", matchScore: 0.9 }],
+        impactRadius: ["src/app.tsx"],
+        regressionTests: ["src/auth/__tests__/login.test.ts"],
+        detectedFrameworks: ["node", "react"],
+        capturedAtUtc: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeCtx(overrides = {}) {
+    return {
+        runId: "run-maint-test",
+        sessionId: "sess-test",
+        cwd: "/tmp/proj",
+        llm: {
+            generate: vi.fn(async (_modelId, _system, _prompt) => "1. Fix redirect in login.ts\n2. Update router"),
+        },
+        processMessageFn: vi.fn(async function* () {
+            yield { type: "content", content: "applying fix..." };
+        }),
+        detectVerifyRecipe: vi.fn(async () => ({
+            ecosystem: "node",
+            appKind: "cli",
+            appLabel: "Test project",
+            shellInitCommands: [],
+            bootstrapCommands: [],
+            installCommands: [],
+            buildCommands: [],
+            testCommands: ["npm test"],
+            smokeKind: "none",
+            evidence: [],
+            notes: [],
+            coverage: 80,
+        })),
+        respondToPreflight: vi.fn(async () => true),
+        ...overrides,
+    };
+}
+function makeInput(ctxOverrides, taskOverrides) {
+    return {
+        task: makeTask(taskOverrides),
+        codebaseIntel: makeIntel(),
+        ctx: makeCtx(ctxOverrides),
+        leaderModelId: getTestModels().fast,
+        costAware: true,
+    };
+}
+async function drain(gen) {
+    const chunks = [];
+    let result;
+    while (true) {
+        const step = await gen.next();
+        if (step.done) {
+            result = step.value;
+            break;
+        }
+        chunks.push(step.value);
+    }
+    return { chunks, result: result };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe("runMaintenanceTask — happy path", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        runVerifyOrchestration.mockResolvedValue({
+            success: true,
+            output: "VERIFY_PASS\n2 tests passed",
+        });
+        evaluateDoneGate.mockResolvedValue({
+            pass: true,
+            score: 0.95,
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("emits 5 active+done phase pairs in order: design, edit, verify, judge, review", async () => {
+        const input = makeInput();
+        // review model returns no concerns (ok=true)
+        input.ctx.llm.generate
+            .mockResolvedValueOnce("1. Fix redirect\n2. Update router") // design
+            .mockResolvedValueOnce('{"ok": true, "concerns": []}'); // review
+        const { chunks, result } = await drain(runMaintenanceTask(input));
+        const phaseChunks = chunks.filter((c) => c.type === "council_phase");
+        const phases = phaseChunks.map((c) => c.councilPhase);
+        // Must have active+done for all 5 phases = 10 phase events
+        expect(phases.length).toBe(10);
+        const expectedPhaseIds = ["maint-design", "maint-edit", "maint-verify", "maint-judge", "maint-review"];
+        for (const id of expectedPhaseIds) {
+            const forId = phases.filter((p) => p.phaseId === id);
+            expect(forId).toHaveLength(2);
+            expect(forId[0].state).toBe("active");
+            expect(forId[1].state).toBe("done");
+            expect(typeof forId[0].startedAt).toBe("number");
+            expect(forId[0].startedAt).toBeGreaterThan(0);
+        }
+        // Verify ordering: design active must come before edit active
+        const actives = phases.filter((p) => p.state === "active").map((p) => p.phaseId);
+        expect(actives).toEqual(["maint-design", "maint-edit", "maint-verify", "maint-judge", "maint-review"]);
+        expect(result.status).toBe("done");
+        expect(result.judgeScore).toBe(0.95);
+        expect(result.designPlan).toContain("Fix redirect");
+    });
+    it("returns status=done with reviewConcerns=[] when review returns ok:true", async () => {
+        const input = makeInput();
+        input.ctx.llm.generate
+            .mockResolvedValueOnce("1. Fix redirect\n2. Update router")
+            .mockResolvedValueOnce('{"ok": true, "concerns": []}');
+        const { result } = await drain(runMaintenanceTask(input));
+        expect(result.status).toBe("done");
+        expect(result.reviewConcerns).toEqual([]);
+    });
+});
+describe("runMaintenanceTask — judge fail → blocked", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        runVerifyOrchestration.mockResolvedValue({
+            success: false,
+            output: "2 tests failed",
+            error: "AssertionError: expected /dashboard but got /undefined",
+        });
+        evaluateDoneGate.mockResolvedValue({
+            pass: false,
+            failedCondition: "engineering_floor",
+            reason: "verify_FAIL",
+            score: 0.3,
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("yields phaseError on judge phase and returns status=blocked", async () => {
+        const input = makeInput();
+        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
+        const { chunks, result } = await drain(runMaintenanceTask(input));
+        // Judge phase must emit an error chunk
+        const phaseChunks = chunks
+            .filter((c) => c.type === "council_phase")
+            .map((c) => c.councilPhase);
+        const judgeErrorChunk = phaseChunks.find((p) => p.phaseId === "maint-judge" && p.state === "error");
+        expect(judgeErrorChunk).toBeDefined();
+        expect(typeof judgeErrorChunk.errorMessage).toBe("string");
+        // No review phase emitted when judge halts
+        const reviewPhase = phaseChunks.find((p) => p.phaseId === "maint-review");
+        expect(reviewPhase).toBeUndefined();
+        expect(result.status).toBe("blocked");
+        expect(result.judgeScore).toBe(0.3);
+        expect(result.failureReason).toBeTruthy();
+    });
+});
+describe("runMaintenanceTask — review with concerns", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        runVerifyOrchestration.mockResolvedValue({
+            success: true,
+            output: "VERIFY_PASS",
+        });
+        evaluateDoneGate.mockResolvedValue({
+            pass: true,
+            score: 0.9,
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("surfaces concerns in result.reviewConcerns and emits a content chunk listing them", async () => {
+        const input = makeInput();
+        const concernsList = ["No test for null user case", "Missing error boundary for failed fetch"];
+        input.ctx.llm.generate
+            .mockResolvedValueOnce("1. Fix redirect") // design
+            .mockResolvedValueOnce(JSON.stringify({ ok: false, concerns: concernsList })); // review
+        const { chunks, result } = await drain(runMaintenanceTask(input));
+        expect(result.status).toBe("done");
+        expect(result.reviewConcerns).toEqual(concernsList);
+        const contentChunks = chunks
+            .filter((c) => c.type === "content")
+            .map((c) => c.content);
+        const reviewContent = contentChunks.find((c) => c.includes("Review Concerns"));
+        expect(reviewContent).toBeDefined();
+        expect(reviewContent).toContain("No test for null user case");
+        expect(reviewContent).toContain("Missing error boundary for failed fetch");
+    });
+});
+describe("runMaintenanceTask — missing verify recipe", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("emits phaseError on verify and returns status=failed when detectVerifyRecipe returns null", async () => {
+        const input = makeInput({
+            detectVerifyRecipe: vi.fn(async () => null),
+        });
+        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
+        const { chunks, result } = await drain(runMaintenanceTask(input));
+        const phaseChunks = chunks
+            .filter((c) => c.type === "council_phase")
+            .map((c) => c.councilPhase);
+        const verifyError = phaseChunks.find((p) => p.phaseId === "maint-verify" && p.state === "error");
+        expect(verifyError).toBeDefined();
+        expect(verifyError.errorMessage).toContain("no verify recipe");
+        expect(result.status).toBe("failed");
+        expect(result.failureReason).toContain("no verify recipe");
+        // runVerifyOrchestration should NOT have been called
+        expect(runVerifyOrchestration).not.toHaveBeenCalled();
+    });
+});
+describe("runMaintenanceTask — edit failure", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("returns status=failed when processMessageFn throws", async () => {
+        const input = makeInput({
+            processMessageFn: vi.fn(async function* () {
+                throw new Error("orchestrator exploded");
+                // biome-ignore lint/correctness/noUnreachable: needed for generator type inference
+                yield { type: "content", content: "" };
+            }),
+        });
+        input.ctx.llm.generate.mockResolvedValue("1. Fix redirect");
+        const { result } = await drain(runMaintenanceTask(input));
+        expect(result.status).toBe("failed");
+        expect(result.failureReason).toContain("orchestrator exploded");
+        expect(runVerifyOrchestration).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=task-runner.test.js.map

package/dist/src/maintain/codebase-intel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * codebase-intel.ts — P14 deterministic codebase analysis.
+ *
+ * Given a maintenance task description + cwd, produces a CodebaseIntel struct
+ * that tells the downstream P15 task-runner: which files matter, what is the
+ * impact radius, which tests cover the area, what framework is in play.
+ *
+ * NO LLM calls — pure grep/regex/heuristics. Sub-second on a 1000-file repo.
+ */
+import type { CodebaseIntel, MaintenanceTask } from "./types.js";
+export interface GatherIntelInput {
+    cwd: string;
+    task: Pick<MaintenanceTask, "title" | "description" | "kind">;
+    maxCandidates?: number;
+    maxImpactFiles?: number;
+}
+/**
+ * Main P14 entry point. Deterministic — no LLM calls.
+ */
+export declare function gatherCodebaseIntel(input: GatherIntelInput): Promise<CodebaseIntel>;
+/** Exposed for testing. */
+export declare function extractKeywords(text: string): string[];