muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/typed-artifacts.test.js

@@ -1,222 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { appendDecisions, appendRisks, deriveTasksFromSpec, parseDecisionsJson, parseRisksJson, readCriteriaSnapshot, readRisks, readTasks, syncCriteriaSnapshot, updateTaskStatus, writeTasks, } from "../typed-artifacts.js";
-function makeSpec(overrides = {}) {
-    return {
-        idea: "Test idea",
-        persona: "Test user",
-        mvp: ["feature A", "feature B"],
-        phase2: ["feature C"],
-        architecture: "test",
-        ioContract: "test",
-        folderStructure: "test",
-        sprintEstimate: 2,
-        costEstimate: 20,
-        createdAt: new Date(),
-        ...overrides,
-    };
-}
-describe("typed-artifacts (P8)", () => {
-    let flowDir;
-    const runId = "run-test";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `typed-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(flowDir, { recursive: true });
-    });
-    describe("deriveTasksFromSpec", () => {
-        it("creates one task per mvp + phase2 feature with stable ids", () => {
-            const tasks = deriveTasksFromSpec(makeSpec());
-            expect(tasks.length).toBe(3);
-            expect(tasks[0].id).toBe("t_mvp_01");
-            expect(tasks[1].id).toBe("t_mvp_02");
-            expect(tasks[2].id).toBe("t_p2_01");
-            expect(tasks[0].title).toBe("feature A");
-            expect(tasks[2].source).toBe("phase2");
-        });
-        it("links mvp tasks in sequence and phase2 onto last mvp", () => {
-            const tasks = deriveTasksFromSpec(makeSpec());
-            expect(tasks[0].dependencies).toEqual([]);
-            expect(tasks[1].dependencies).toEqual(["t_mvp_01"]);
-            expect(tasks[2].dependencies).toEqual(["t_mvp_02"]);
-        });
-        it("handles empty mvp+phase2 gracefully", () => {
-            const tasks = deriveTasksFromSpec(makeSpec({ mvp: [], phase2: [] }));
-            expect(tasks).toEqual([]);
-        });
-        it("re-derivation is idempotent in id space", () => {
-            const t1 = deriveTasksFromSpec(makeSpec());
-            const t2 = deriveTasksFromSpec(makeSpec());
-            expect(t1.map((t) => t.id)).toEqual(t2.map((t) => t.id));
-        });
-    });
-    describe("tasks IO", () => {
-        it("writes and reads tasks.json with version envelope", async () => {
-            const tasks = deriveTasksFromSpec(makeSpec());
-            await writeTasks(flowDir, runId, tasks);
-            const file = path.join(flowDir, "runs", runId, "tasks.json");
-            const raw = JSON.parse(await fs.readFile(file, "utf8"));
-            expect(raw.version).toBe(1);
-            expect(raw.items.length).toBe(3);
-            const read = await readTasks(flowDir, runId);
-            expect(read.length).toBe(3);
-        });
-        it("returns empty array when file missing", async () => {
-            const tasks = await readTasks(flowDir, "never-existed");
-            expect(tasks).toEqual([]);
-        });
-        it("updateTaskStatus mutates only the target task", async () => {
-            const tasks = deriveTasksFromSpec(makeSpec());
-            await writeTasks(flowDir, runId, tasks);
-            await updateTaskStatus(flowDir, runId, "t_mvp_01", "done");
-            const updated = await readTasks(flowDir, runId);
-            const done = updated.find((t) => t.id === "t_mvp_01");
-            const pending = updated.find((t) => t.id === "t_mvp_02");
-            expect(done?.status).toBe("done");
-            expect(pending?.status).toBe("pending");
-        });
-        it("updateTaskStatus is a no-op for missing id", async () => {
-            const tasks = deriveTasksFromSpec(makeSpec());
-            await writeTasks(flowDir, runId, tasks);
-            await updateTaskStatus(flowDir, runId, "t_nonexistent", "done");
-            const updated = await readTasks(flowDir, runId);
-            expect(updated.every((t) => t.status === "pending")).toBe(true);
-        });
-    });
-    describe("decisions IO", () => {
-        it("appendDecisions dedupes by id", async () => {
-            const d = {
-                id: "d_test",
-                question: "Sync or async?",
-                choice: "Sync",
-                alternatives: ["Async"],
-                rationale: "simpler",
-                reversibility: "moderate",
-                madeAt: { phase: "scoping" },
-            };
-            await appendDecisions(flowDir, runId, [d]);
-            const merged = await appendDecisions(flowDir, runId, [d]);
-            expect(merged.length).toBe(1);
-        });
-        it("appendDecisions does not overwrite existing entries", async () => {
-            const d1 = {
-                id: "d_same",
-                question: "Same question",
-                choice: "Choice A",
-                alternatives: [],
-                rationale: "first",
-                reversibility: "easy",
-                madeAt: { phase: "research" },
-            };
-            const d2 = {
-                ...d1,
-                choice: "Choice B (changed)",
-                rationale: "second",
-            };
-            await appendDecisions(flowDir, runId, [d1]);
-            const merged = await appendDecisions(flowDir, runId, [d2]);
-            expect(merged.length).toBe(1);
-            expect(merged[0].choice).toBe("Choice A");
-        });
-    });
-    describe("risks IO", () => {
-        it("appendRisks persists with version envelope", async () => {
-            const r = {
-                id: "r_test",
-                description: "API may rate-limit",
-                likelihood: "high",
-                impact: "medium",
-                mitigation: "exponential backoff + retry",
-                owner: "Implementer",
-                status: "open",
-            };
-            await appendRisks(flowDir, runId, [r]);
-            const read = await readRisks(flowDir, runId);
-            expect(read.length).toBe(1);
-            expect(read[0].likelihood).toBe("high");
-        });
-    });
-    describe("criteria snapshot", () => {
-        it("syncCriteriaSnapshot mirrors all fields", async () => {
-            const criteria = [
-                { id: "c1", status: "met", evidence: "test.ts:10 PASS", sprint: 1 },
-                { id: "c2", status: "unmet" },
-            ];
-            await syncCriteriaSnapshot(flowDir, runId, criteria);
-            const snap = await readCriteriaSnapshot(flowDir, runId);
-            expect(snap.length).toBe(2);
-            expect(snap[0].evidence).toBe("test.ts:10 PASS");
-            expect(snap[1].evidence).toBeUndefined();
-        });
-    });
-    describe("parseDecisionsJson", () => {
-        it("parses well-formed array", () => {
-            const raw = JSON.stringify([
-                {
-                    question: "Framework?",
-                    choice: "React",
-                    alternatives: ["Vue", "Svelte"],
-                    rationale: "team familiarity",
-                    reversibility: "hard",
-                },
-            ]);
-            const out = parseDecisionsJson(raw);
-            expect(out.length).toBe(1);
-            expect(out[0].choice).toBe("React");
-            expect(out[0].reversibility).toBe("hard");
-            expect(out[0].id.startsWith("d_")).toBe(true);
-        });
-        it("strips markdown code fences", () => {
-            const raw = '```json\n[{"question":"Q","choice":"C"}]\n```';
-            const out = parseDecisionsJson(raw);
-            expect(out.length).toBe(1);
-        });
-        it("defaults reversibility to moderate on invalid value", () => {
-            const raw = JSON.stringify([{ question: "Q", choice: "C", reversibility: "unknown" }]);
-            const out = parseDecisionsJson(raw);
-            expect(out[0].reversibility).toBe("moderate");
-        });
-        it("returns [] on parse failure", () => {
-            expect(parseDecisionsJson("not json")).toEqual([]);
-            expect(parseDecisionsJson("{}")).toEqual([]);
-        });
-        it("skips entries missing required fields", () => {
-            const raw = JSON.stringify([
-                { question: "Q1", choice: "C1" },
-                { question: "Q2" }, // missing choice
-                { choice: "C3" }, // missing question
-            ]);
-            const out = parseDecisionsJson(raw);
-            expect(out.length).toBe(1);
-            expect(out[0].question).toBe("Q1");
-        });
-    });
-    describe("parseRisksJson", () => {
-        it("parses with likelihood and impact normalization", () => {
-            const raw = JSON.stringify([
-                {
-                    description: "Provider may go down",
-                    likelihood: "high",
-                    impact: "high",
-                    mitigation: "fallback provider",
-                    owner: "Implementer",
-                },
-            ]);
-            const out = parseRisksJson(raw);
-            expect(out.length).toBe(1);
-            expect(out[0].likelihood).toBe("high");
-            expect(out[0].status).toBe("open");
-        });
-        it("defaults likelihood/impact to medium when invalid", () => {
-            const raw = JSON.stringify([{ description: "Some risk", likelihood: "bad", impact: "worse" }]);
-            const out = parseRisksJson(raw);
-            expect(out[0].likelihood).toBe("medium");
-            expect(out[0].impact).toBe("medium");
-        });
-        it("returns [] on malformed input", () => {
-            expect(parseRisksJson("```")).toEqual([]);
-        });
-    });
-});
-//# sourceMappingURL=typed-artifacts.test.js.map

package/dist/src/product-loop/__tests__/types.test.d.ts

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

package/dist/src/product-loop/__tests__/types.test.js

@@ -1,79 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-describe("product-loop types", () => {
-    it("should have correct WorkflowKind", () => {
-        const _w = "product";
-        const _t = "task";
-        // @ts-expect-error
-        const _i = "invalid";
-    });
-    it("should have correct RoleSlot values", () => {
-        const _roles = ["PO", "Architect", "Implementer", "Tester", "Reviewer", "Customer"];
-        expectTypeOf().toMatchTypeOf();
-    });
-    it("should have correct DoneCondition values", () => {
-        const _conditions = [
-            "engineering_floor",
-            "evidence_regex",
-            "weighted_score",
-            "assumption_ledger",
-            "customer_debate",
-            "user_approval",
-        ];
-        expectTypeOf().toMatchTypeOf();
-    });
-    it("should have correct ProductSpec shape", () => {
-        const _spec = {
-            idea: "test",
-            persona: "test",
-            mvp: ["feat1"],
-            phase2: ["feat2"],
-            architecture: "test",
-            ioContract: "test",
-            folderStructure: "test",
-            sprintEstimate: 1,
-            costEstimate: 10,
-            createdAt: new Date(),
-        };
-    });
-    it("should have correct IterationState shape", () => {
-        const _state = {
-            sprintN: 1,
-            stage: "judge",
-            scoreBefore: 0.1,
-            scoreAfter: 0.2,
-            criteriaMet: 1,
-            criteriaPartial: 2,
-            criteriaUnmet: 3,
-            costUsd: 0.5,
-            lastVerifyResult: "PASS",
-        };
-    });
-    it("should have correct DoneVerdict shape", () => {
-        const _verdict = {
-            pass: true,
-            score: 0.95,
-        };
-    });
-    it("should have correct ProductRunManifest shape", () => {
-        const _manifest = {
-            idea: "test",
-            capUsd: 50,
-            maxSprints: 8,
-            doneThreshold: 0.9,
-            createdAt: new Date(),
-        };
-    });
-    it("should have correct ProductStatusCardData shape", () => {
-        const _data = {
-            sprintN: 1,
-            totalSprints: 8,
-            costSpent: 5,
-            costCap: 50,
-            criteriaMet: 1,
-            criteriaPartial: 2,
-            criteriaUnmet: 3,
-            currentStage: "implement",
-        };
-    });
-});
-//# sourceMappingURL=types.test.js.map

package/dist/src/product-loop/__tests__/verify-failure-threshold.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * Tests for P3.3 + P3.4 + P3.6:
- *   - recordVerifyFailureAndMaybePush threshold logic
- *   - pushFailureToEE payload shape
- *   - one-shot push per signature crossing threshold
- *   - independent signatures each trigger their own push
- *   - P3.6: logInteraction called once when count crosses 3
- */
-export {};

package/dist/src/product-loop/__tests__/verify-failure-threshold.test.js

@@ -1,146 +0,0 @@
-/**
- * Tests for P3.3 + P3.4 + P3.6:
- *   - recordVerifyFailureAndMaybePush threshold logic
- *   - pushFailureToEE payload shape
- *   - one-shot push per signature crossing threshold
- *   - independent signatures each trigger their own push
- *   - P3.6: logInteraction called once when count crosses 3
- */
-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, vi } from "vitest";
-import { setDefaultEEClient } from "../../ee/intercept.js";
-import { pushFailureToEE, recordVerifyFailureAndMaybePush } from "../verify-failure-tracking.js";
-// P3.6: mock storage to capture logInteraction calls
-vi.mock("../../storage/index", () => ({
-    logInteraction: vi.fn(),
-}));
-import { logInteraction } from "../../storage/index.js";
-// ── Helpers ──────────────────────────────────────────────────────────────────
-let flowDir;
-const runId = "run-threshold-test";
-const sessionId = "test-session-id";
-const cwd = "/fake/cwd";
-const BASE_INPUT = {
-    errorMessage: "TypeError: Cannot read property 'x' of undefined\n    at doThing (src/foo.ts:42:7)",
-    verifyCommand: "bun test",
-    fileTouched: "src/foo.ts",
-};
-/** Build a minimal mock EE client that records posttool calls */
-function makeMockClient() {
-    const calls = [];
-    const client = {
-        intercept: vi.fn(),
-        posttool: vi.fn(async (payload) => {
-            calls.push(payload);
-        }),
-        routeModel: vi.fn(),
-    };
-    return { client, calls };
-}
-beforeEach(async () => {
-    flowDir = await fs.mkdtemp(path.join(os.tmpdir(), "vft-threshold-"));
-});
-afterEach(async () => {
-    // Windows ENOTEMPTY guard — see plan.test.ts:33 for rationale.
-    await fs.rm(flowDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    vi.restoreAllMocks();
-    vi.mocked(logInteraction).mockClear();
-});
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("recordVerifyFailureAndMaybePush — threshold", () => {
-    it("1. increment twice → no EE push", async () => {
-        const { client, calls } = makeMockClient();
-        setDefaultEEClient(client);
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        expect(calls).toHaveLength(0);
-    });
-    it("2. increment to 3 → exactly 1 EE push with toolName='ideal_verify_fail'", async () => {
-        const { client, calls } = makeMockClient();
-        setDefaultEEClient(client);
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        expect(calls).toHaveLength(1);
-        expect(calls[0].toolName).toBe("ideal_verify_fail");
-        expect(calls[0].toolInput.verifyCommand).toBe(BASE_INPUT.verifyCommand);
-        expect(calls[0].toolInput.signature).toMatch(/^[0-9a-f]{16}$/);
-        expect(calls[0].toolInput.count).toBe(3);
-    });
-    it("3. increment 4th time → no additional push (one-shot per threshold crossing)", async () => {
-        const { client, calls } = makeMockClient();
-        setDefaultEEClient(client);
-        for (let i = 0; i < 4; i++) {
-            await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...BASE_INPUT });
-        }
-        expect(calls).toHaveLength(1);
-    });
-    it("P3.6: logInteraction called once when count crosses 3", async () => {
-        const { client } = makeMockClient();
-        setDefaultEEClient(client);
-        // First two calls — no log
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, sessionId, cwd, ...BASE_INPUT });
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, sessionId, cwd, ...BASE_INPUT });
-        expect(vi.mocked(logInteraction)).not.toHaveBeenCalled();
-        // Third call — should log with chat session id (FK-safe)
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, sessionId, cwd, ...BASE_INPUT });
-        expect(vi.mocked(logInteraction)).toHaveBeenCalledOnce();
-        const [calledRunId, calledEventType, calledMeta] = vi.mocked(logInteraction).mock.calls[0];
-        expect(calledRunId).toBe(sessionId);
-        expect(calledEventType).toBe("ee_judge");
-        expect(calledMeta?.eventSubtype).toBe("ideal_verify_pattern");
-        expect(calledMeta?.data?.count).toBe(3);
-        expect(typeof calledMeta?.data?.signature).toBe("string");
-        // Fourth call — no additional log (one-shot)
-        await recordVerifyFailureAndMaybePush({ flowDir, runId, sessionId, cwd, ...BASE_INPUT });
-        expect(vi.mocked(logInteraction)).toHaveBeenCalledOnce();
-    });
-    it("4. two different signatures both reach 3 → 2 pushes", async () => {
-        const { client, calls } = makeMockClient();
-        setDefaultEEClient(client);
-        const inputA = { ...BASE_INPUT, fileTouched: "src/foo.ts" };
-        const inputB = { ...BASE_INPUT, fileTouched: "src/bar.ts" };
-        // Interleave two different signatures
-        for (let i = 0; i < 3; i++) {
-            await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...inputA });
-            await recordVerifyFailureAndMaybePush({ flowDir, runId, cwd, ...inputB });
-        }
-        expect(calls).toHaveLength(2);
-        const toolNames = calls.map((c) => c.toolName);
-        expect(toolNames).toEqual(["ideal_verify_fail", "ideal_verify_fail"]);
-        // The two pushes must carry different signatures
-        const sigs = calls.map((c) => c.toolInput.signature);
-        expect(sigs[0]).not.toBe(sigs[1]);
-    });
-});
-describe("pushFailureToEE — payload shape", () => {
-    it("5. calls posttool with correct shape and outcome.success=false", async () => {
-        const { client, calls } = makeMockClient();
-        setDefaultEEClient(client);
-        await pushFailureToEE({
-            signature: "abc123def456ab12",
-            count: 3,
-            lastError: "Test failed: expected 1 but got 2",
-            fileTouched: "src/utils.ts",
-            verifyCommand: "bun test --run",
-            runId: "run-push-test",
-            cwd,
-        });
-        expect(calls).toHaveLength(1);
-        const payload = calls[0];
-        expect(payload.toolName).toBe("ideal_verify_fail");
-        expect(payload.outcome.success).toBe(false);
-        expect(payload.cwd).toBe(cwd);
-        expect(payload.tenantId).toBeDefined();
-        expect(payload.scope).toBeDefined();
-        expect(payload.scope.kind).toMatch(/^(global|repo|branch|ecosystem)$/);
-        const input = payload.toolInput;
-        expect(input.signature).toBe("abc123def456ab12");
-        expect(input.count).toBe(3);
-        expect(input.fileTouched).toBe("src/utils.ts");
-        expect(input.verifyCommand).toBe("bun test --run");
-    });
-});
-//# sourceMappingURL=verify-failure-threshold.test.js.map

package/dist/src/product-loop/__tests__/verify-failure-tracking.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for P3.1 computeFailureSignature and P3.2 load/save VerifyFailureSignatures.
- */
-export {};

package/dist/src/product-loop/__tests__/verify-failure-tracking.test.js

@@ -1,122 +0,0 @@
-/**
- * Tests for P3.1 computeFailureSignature and P3.2 load/save VerifyFailureSignatures.
- */
-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 { computeFailureSignature, loadVerifyFailureSignatures, saveVerifyFailureSignatures, } from "../verify-failure-tracking.js";
-// ── Helpers ──────────────────────────────────────────────────────────────────
-let flowDir;
-const runId = "run-test-vfs";
-beforeEach(async () => {
-    flowDir = await fs.mkdtemp(path.join(os.tmpdir(), "vfs-test-"));
-});
-afterEach(async () => {
-    await fs.rm(flowDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-// ── P3.1: computeFailureSignature ────────────────────────────────────────────
-describe("computeFailureSignature", () => {
-    const base = {
-        errorMessage: "TypeError: Cannot read property 'x' of undefined\n    at doThing (src/foo.ts:42:7)\n    at runAll (src/bar.ts:10:3)",
-        verifyCommand: "bun test",
-        fileTouched: "src/foo.ts",
-    };
-    it("1. same inputs → same sig", () => {
-        expect(computeFailureSignature(base)).toBe(computeFailureSignature(base));
-    });
-    it("2. different error → different sig", () => {
-        const other = { ...base, errorMessage: "SyntaxError: Unexpected token" };
-        expect(computeFailureSignature(base)).not.toBe(computeFailureSignature(other));
-    });
-    it("3. different verifyCommand → different sig", () => {
-        const other = { ...base, verifyCommand: "npm test" };
-        expect(computeFailureSignature(base)).not.toBe(computeFailureSignature(other));
-    });
-    it("4. different fileTouched → different sig", () => {
-        const other = { ...base, fileTouched: "src/bar.ts" };
-        expect(computeFailureSignature(base)).not.toBe(computeFailureSignature(other));
-    });
-    it("5. error with 2 stack frames: different middle text → same sig (frames are dominant)", () => {
-        const a = {
-            ...base,
-            errorMessage: "TypeError: blah\n    at doThing (src/foo.ts:42:7)\n    at runAll (src/bar.ts:10:3)",
-        };
-        const b = {
-            ...base,
-            errorMessage: "RangeError: something completely different\n    at doThing (src/foo.ts:42:7)\n    at runAll (src/bar.ts:10:3)",
-        };
-        expect(computeFailureSignature(a)).toBe(computeFailureSignature(b));
-    });
-    it("6. error with NO stack frame → still produces a stable sig", () => {
-        const plain = {
-            ...base,
-            errorMessage: "Process exited with code 1",
-        };
-        const sig1 = computeFailureSignature(plain);
-        const sig2 = computeFailureSignature(plain);
-        expect(sig1).toBe(sig2);
-        expect(sig1).toHaveLength(16);
-        expect(sig1).toMatch(/^[0-9a-f]{16}$/);
-    });
-    it("returns exactly 16 hex chars", () => {
-        const sig = computeFailureSignature(base);
-        expect(sig).toHaveLength(16);
-        expect(sig).toMatch(/^[0-9a-f]{16}$/);
-    });
-});
-// ── P3.2: loadVerifyFailureSignatures / saveVerifyFailureSignatures ───────────
-describe("loadVerifyFailureSignatures / saveVerifyFailureSignatures", () => {
-    function makeRecord(count = 1) {
-        return {
-            count,
-            lastSeenAt: new Date().toISOString(),
-            lastError: "test error",
-            file: "src/foo.ts",
-        };
-    }
-    it("7. save then load → roundtrip preserved", { retry: 2 }, async () => {
-        const sigs = {
-            abc123: makeRecord(3),
-            def456: makeRecord(1),
-        };
-        await saveVerifyFailureSignatures(flowDir, runId, sigs);
-        const loaded = await loadVerifyFailureSignatures(flowDir, runId);
-        expect(loaded).toEqual(sigs);
-    });
-    it("8. load when state.md missing → returns {}", async () => {
-        const loaded = await loadVerifyFailureSignatures(flowDir, runId);
-        expect(loaded).toEqual({});
-    });
-    it("9. load when section corrupted (invalid JSON) → returns {} fail-open", async () => {
-        // Write a state.md with a corrupted section
-        const runDir = path.join(flowDir, "runs", runId);
-        await fs.mkdir(runDir, { recursive: true });
-        const content = "## Verify Failure Signatures\n\nnot { valid json }\n";
-        await fs.writeFile(path.join(runDir, "state.md"), content, "utf8");
-        const loaded = await loadVerifyFailureSignatures(flowDir, runId);
-        expect(loaded).toEqual({});
-    });
-    it("10. save twice updates same section, no duplication", async () => {
-        const first = { aaa: makeRecord(1) };
-        await saveVerifyFailureSignatures(flowDir, runId, first);
-        const second = { aaa: makeRecord(2), bbb: makeRecord(1) };
-        await saveVerifyFailureSignatures(flowDir, runId, second);
-        const loaded = await loadVerifyFailureSignatures(flowDir, runId);
-        expect(loaded).toEqual(second);
-        // Confirm the section appears exactly once in the raw file
-        const runDir = path.join(flowDir, "runs", runId);
-        const raw = await fs.readFile(path.join(runDir, "state.md"), "utf8");
-        const sectionMatches = raw.match(/## Verify Failure Signatures/g);
-        expect(sectionMatches).toHaveLength(1);
-    });
-    it("load when section is empty string → returns {}", async () => {
-        const runDir = path.join(flowDir, "runs", runId);
-        await fs.mkdir(runDir, { recursive: true });
-        const content = "## Verify Failure Signatures\n\n\n";
-        await fs.writeFile(path.join(runDir, "state.md"), content, "utf8");
-        const loaded = await loadVerifyFailureSignatures(flowDir, runId);
-        expect(loaded).toEqual({});
-    });
-});
-//# sourceMappingURL=verify-failure-tracking.test.js.map

package/dist/src/product-loop/__tests__/verify-result.test.d.ts

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

package/dist/src/product-loop/__tests__/verify-result.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseVerifyResult, VERIFY_CHECK_MARKER, VERIFY_FAIL_MARKER, VERIFY_PASS_MARKER } from "../verify-result.js";
-describe("parseVerifyResult", () => {
-    it("should return PASS when success is true and output has pass marker", () => {
-        const tr = {
-            success: true,
-            output: `Some logs... \n${VERIFY_PASS_MARKER}\nMore logs...`,
-        };
-        expect(parseVerifyResult(tr)).toBe("PASS");
-    });
-    it("should return PASS when success is true and output has checkmark marker", () => {
-        const tr = {
-            success: true,
-            output: `All tests passed! \n${VERIFY_CHECK_MARKER}`,
-        };
-        expect(parseVerifyResult(tr)).toBe("PASS");
-    });
-    it("should return FAIL when success is false", () => {
-        const tr = {
-            success: false,
-            output: "Tests failed miserably.",
-        };
-        expect(parseVerifyResult(tr)).toBe("FAIL");
-    });
-    it("should return FAIL when output contains fail marker even if success is true", () => {
-        const tr = {
-            success: true,
-            output: `Something went wrong but it didn't crash. \n${VERIFY_FAIL_MARKER}`,
-        };
-        expect(parseVerifyResult(tr)).toBe("FAIL");
-    });
-    it("should return ERROR when error is present", () => {
-        const tr = {
-            success: false,
-            error: "Command not found: bun",
-        };
-        expect(parseVerifyResult(tr)).toBe("ERROR");
-    });
-    it("should return UNKNOWN when success is true but no marker is found", () => {
-        const tr = {
-            success: true,
-            output: "Just some random output without markers.",
-        };
-        expect(parseVerifyResult(tr)).toBe("UNKNOWN");
-    });
-    it("should return UNKNOWN for empty result", () => {
-        const tr = {
-            success: true,
-        };
-        expect(parseVerifyResult(tr)).toBe("UNKNOWN");
-    });
-});
-//# sourceMappingURL=verify-result.test.js.map

package/dist/src/providers/__tests__/adapter-oauth-wiring.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * src/providers/__tests__/adapter-oauth-wiring.test.ts
- *
- * Integration-style tests: verify that createProviderFactoryAsync injects OAuth
- * headers when tokens are stored, and falls through to API-key path when they
- * are not.  No live network — token-store is mocked at module boundary.
- */
-export {};