muonroi-cli 1.8.0 → 1.8.3

package/dist/src/product-loop/__tests__/assumption-ledger.test.js

@@ -1,261 +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, vi } from "vitest";
-import { blockingAssumptions, extractAssumptionsFromDebate, formatUnverifiedForSprintContext, mergeAssumptions, readLedger, renderLedgerSummary, resolveAssumption, } from "../assumption-ledger.js";
-function makeAssumption(claim, confidence = "high") {
-    // The id derivation is internal; we set a stable test id via the same algorithm.
-    const normalized = claim.toLowerCase().replace(/\s+/g, " ").trim();
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        hash = ((hash << 5) - hash + normalized.charCodeAt(i)) | 0;
-    }
-    const id = `a_${Math.abs(hash).toString(36).padStart(6, "0")}`;
-    return {
-        id,
-        claim,
-        raisedBy: "Skeptic",
-        raisedAt: { phase: "research" },
-        confidence,
-        validationMethod: "manual benchmark",
-        status: "unverified",
-    };
-}
-describe("assumption-ledger (P6)", () => {
-    let flowDir;
-    const runId = "run-test";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `assumpt-test-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(flowDir, { recursive: true });
-    });
-    it("returns empty ledger when file missing", async () => {
-        const ledger = await readLedger(flowDir, runId);
-        expect(ledger.version).toBe(1);
-        expect(ledger.assumptions).toEqual([]);
-    });
-    it("merges new assumptions and persists to assumptions.json", async () => {
-        const a = makeAssumption("Spatial index lookup < 5ms for 1000 spans");
-        const ledger = await mergeAssumptions(flowDir, runId, [a]);
-        expect(ledger.assumptions.length).toBe(1);
-        const file = path.join(flowDir, "runs", runId, "assumptions.json");
-        const persisted = JSON.parse(await fs.readFile(file, "utf8"));
-        expect(persisted.version).toBe(1);
-        expect(persisted.assumptions[0].claim).toBe(a.claim);
-    });
-    it("merge is idempotent on identical claims", async () => {
-        const a1 = makeAssumption("Same claim text");
-        const a2 = makeAssumption("Same claim text");
-        await mergeAssumptions(flowDir, runId, [a1]);
-        const ledger = await mergeAssumptions(flowDir, runId, [a2]);
-        expect(ledger.assumptions.length).toBe(1);
-    });
-    it("merge does not overwrite earlier raisedAt or status", async () => {
-        const a = makeAssumption("Performance budget assumption");
-        await mergeAssumptions(flowDir, runId, [a]);
-        await resolveAssumption({
-            flowDir,
-            runId,
-            id: a.id,
-            status: "validated",
-            evidence: "benchmark.test.ts:42 PASS",
-            sprintN: 2,
-            reason: "validated by benchmark",
-        });
-        // Second merge of same claim should not reset the validated status.
-        const merged = await mergeAssumptions(flowDir, runId, [makeAssumption("Performance budget assumption")]);
-        const target = merged.assumptions.find((x) => x.id === a.id);
-        expect(target?.status).toBe("validated");
-        expect(target?.evidence).toBe("benchmark.test.ts:42 PASS");
-    });
-    it("blockingAssumptions filters to high+unverified only", () => {
-        const high = makeAssumption("Critical claim", "high");
-        const medium = makeAssumption("Important claim", "medium");
-        const validatedHigh = { ...makeAssumption("Already validated", "high"), status: "validated" };
-        const blockers = blockingAssumptions({
-            version: 1,
-            assumptions: [high, medium, validatedHigh],
-        });
-        expect(blockers.length).toBe(1);
-        expect(blockers[0].claim).toBe("Critical claim");
-    });
-    it("formatUnverifiedForSprintContext lists assumptions by confidence tag", () => {
-        const high = makeAssumption("Critical perf claim", "high");
-        const med = makeAssumption("Section-level claim", "medium");
-        const validated = { ...makeAssumption("Done already", "high"), status: "validated" };
-        const out = formatUnverifiedForSprintContext({
-            version: 1,
-            assumptions: [high, med, validated],
-        });
-        expect(out).toContain("[CRITICAL]");
-        expect(out).toContain("[IMPORTANT]");
-        expect(out).toContain("Critical perf claim");
-        expect(out).toContain("Section-level claim");
-        expect(out).not.toContain("Done already");
-    });
-    it("formatUnverifiedForSprintContext returns empty when nothing unverified", () => {
-        const validated = { ...makeAssumption("All good", "high"), status: "validated" };
-        expect(formatUnverifiedForSprintContext({ version: 1, assumptions: [validated] })).toBe("");
-    });
-    it("renderLedgerSummary counts by status", () => {
-        const a = makeAssumption("a", "high");
-        const b = { ...makeAssumption("b", "medium"), status: "validated" };
-        const c = { ...makeAssumption("c", "low"), status: "refuted" };
-        const summary = renderLedgerSummary({ version: 1, assumptions: [a, b, c] });
-        expect(summary).toContain("Total: 3");
-        expect(summary).toContain("unverified=1");
-        expect(summary).toContain("validated=1");
-        expect(summary).toContain("refuted=1");
-    });
-    it("resolveAssumption updates status and resolvedAt", async () => {
-        const a = makeAssumption("Resolvable claim");
-        await mergeAssumptions(flowDir, runId, [a]);
-        const ledger = await resolveAssumption({
-            flowDir,
-            runId,
-            id: a.id,
-            status: "refuted",
-            evidence: "test.ts:10 FAIL",
-            sprintN: 3,
-            reason: "benchmark showed 50ms not 5ms",
-        });
-        const target = ledger.assumptions[0];
-        expect(target.status).toBe("refuted");
-        expect(target.evidence).toBe("test.ts:10 FAIL");
-        expect(target.resolvedAt?.sprint).toBe(3);
-    });
-    it("resolveAssumption is a no-op for unknown id", async () => {
-        const a = makeAssumption("Existing");
-        await mergeAssumptions(flowDir, runId, [a]);
-        const ledger = await resolveAssumption({
-            flowDir,
-            runId,
-            id: "a_nonexistent",
-            status: "validated",
-            sprintN: 1,
-            reason: "test",
-        });
-        expect(ledger.assumptions[0].status).toBe("unverified");
-    });
-    it("extractAssumptionsFromDebate parses valid JSON array", async () => {
-        const llm = {
-            generate: vi.fn().mockResolvedValue(JSON.stringify([
-                {
-                    claim: "Provider API stays under 500ms p95",
-                    raisedBy: "Architect",
-                    confidence: "high",
-                    validationMethod: "load test with k6",
-                },
-                {
-                    claim: "Cache hit rate > 80% for repeated queries",
-                    raisedBy: "Cost-Controller",
-                    confidence: "medium",
-                    validationMethod: "production telemetry sample",
-                },
-            ])),
-            debate: vi.fn(),
-            research: vi.fn(),
-            generateObject: vi.fn(),
-        };
-        const debateState = {
-            spec: { problemStatement: "", constraints: [], successCriteria: [], scope: "", rawQA: [], resolved: {} },
-            exchangeLogs: new Map(),
-            runningSummary: "summary",
-            roundCount: 2,
-            active: [],
-            archive: [
-                {
-                    round: 1,
-                    role: "research",
-                    model: "m",
-                    stanceName: "Architect",
-                    excerpt: "API perf will be fine",
-                    length: 20,
-                },
-            ],
-        };
-        const result = await extractAssumptionsFromDebate({
-            debateState,
-            leaderModelId: "leader",
-            llm,
-            phase: "research",
-        });
-        expect(result.length).toBe(2);
-        expect(result[0].claim).toContain("500ms");
-        expect(result[0].confidence).toBe("high");
-        expect(result[0].status).toBe("unverified");
-        expect(result[1].confidence).toBe("medium");
-    });
-    it("extractAssumptionsFromDebate handles malformed JSON gracefully", async () => {
-        const llm = {
-            generate: vi.fn().mockResolvedValue("not json at all"),
-            debate: vi.fn(),
-            research: vi.fn(),
-            generateObject: vi.fn(),
-        };
-        const debateState = {
-            spec: { problemStatement: "", constraints: [], successCriteria: [], scope: "", rawQA: [], resolved: {} },
-            exchangeLogs: new Map(),
-            runningSummary: "",
-            roundCount: 0,
-            active: [],
-            archive: [],
-        };
-        const result = await extractAssumptionsFromDebate({
-            debateState,
-            leaderModelId: "leader",
-            llm,
-            phase: "research",
-        });
-        expect(result).toEqual([]);
-    });
-    it("extractAssumptionsFromDebate strips markdown code fences", async () => {
-        const llm = {
-            generate: vi
-                .fn()
-                .mockResolvedValue('```json\n[{"claim":"test","raisedBy":"Skeptic","confidence":"low","validationMethod":"none"}]\n```'),
-            debate: vi.fn(),
-            research: vi.fn(),
-            generateObject: vi.fn(),
-        };
-        const debateState = {
-            spec: { problemStatement: "", constraints: [], successCriteria: [], scope: "", rawQA: [], resolved: {} },
-            exchangeLogs: new Map(),
-            runningSummary: "",
-            roundCount: 0,
-            active: [],
-            archive: [],
-        };
-        const result = await extractAssumptionsFromDebate({
-            debateState,
-            leaderModelId: "leader",
-            llm,
-            phase: "research",
-        });
-        expect(result.length).toBe(1);
-        expect(result[0].claim).toBe("test");
-    });
-    it("extractAssumptionsFromDebate returns [] when LLM throws", async () => {
-        const llm = {
-            generate: vi.fn().mockRejectedValue(new Error("upstream")),
-            debate: vi.fn(),
-            research: vi.fn(),
-            generateObject: vi.fn(),
-        };
-        const debateState = {
-            spec: { problemStatement: "", constraints: [], successCriteria: [], scope: "", rawQA: [], resolved: {} },
-            exchangeLogs: new Map(),
-            runningSummary: "",
-            roundCount: 0,
-            active: [],
-            archive: [],
-        };
-        const result = await extractAssumptionsFromDebate({
-            debateState,
-            leaderModelId: "leader",
-            llm,
-            phase: "research",
-        });
-        expect(result).toEqual([]);
-    });
-});
-//# sourceMappingURL=assumption-ledger.test.js.map

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

@@ -1,10 +0,0 @@
-/**
- * backlog-builder.test.ts — P6 unit tests for buildBacklog.
- *
- * Tests:
- *  A: 3-feature plan → 3 items with correct v1/v2 distribution.
- *  B: acceptance_criteria matching — "login" criterion attaches to login item.
- *  C: effort estimation routes through pickCouncilTaskModel("effort_estimate", ...).
- *  D: derivedFromClarifyId is deterministic for the same spec.
- */
-export {};

package/dist/src/product-loop/__tests__/backlog-builder.test.js

@@ -1,175 +0,0 @@
-/**
- * backlog-builder.test.ts — P6 unit tests for buildBacklog.
- *
- * Tests:
- *  A: 3-feature plan → 3 items with correct v1/v2 distribution.
- *  B: acceptance_criteria matching — "login" criterion attaches to login item.
- *  C: effort estimation routes through pickCouncilTaskModel("effort_estimate", ...).
- *  D: derivedFromClarifyId is deterministic for the same spec.
- */
-import { describe, expect, it, vi } from "vitest";
-// Mock pickCouncilTaskModel to capture the task tag.
-vi.mock("../../council/leader.js", () => ({
-    pickCouncilTaskModel: vi.fn((_task, leaderModelId) => leaderModelId),
-}));
-import { pickCouncilTaskModel } from "../../council/leader.js";
-import { buildBacklog } from "../backlog-builder.js";
-function makeSpec() {
-    return {
-        problemStatement: "Build a simple todo app",
-        constraints: ["must run offline"],
-        successCriteria: ["user can create tasks"],
-        scope: "web app",
-        rawQA: [],
-    };
-}
-function makePlan() {
-    return {
-        entities: [
-            { name: "task", fields: "id:uuid, title:string, done:boolean" },
-            { name: "user", fields: "id:uuid, email:string" },
-        ],
-        endpoints: [
-            { method: "POST", path: "/tasks", auth_required: true },
-            { method: "GET", path: "/users/me", auth_required: true },
-        ],
-        acceptance_criteria: [
-            "user can log in with email/password",
-            "user can create a task with a title",
-            "user can mark a task as done",
-        ],
-        mvp_definition: [
-            { feature: "login", included_in_v1: "yes", reason: "Core auth" },
-            { feature: "task management", included_in_v1: "yes", reason: "Primary value" },
-            { feature: "multi-tenant", included_in_v1: "no", reason: "Out of scope for v1" },
-        ],
-    };
-}
-function makeLlm(effortResponse = "[1, 3, 5]") {
-    return {
-        generate: vi.fn(async (_model, _system, _prompt) => effortResponse),
-        research: vi.fn(async () => ""),
-        debate: vi.fn(async () => ({ text: "", toolCalls: [] })),
-    };
-}
-describe("buildBacklog (P6)", () => {
-    it("Test A: produces 3 BacklogItems with correct v1/v2 distribution", async () => {
-        const backlog = await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo-app",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm: makeLlm(),
-            leaderModelId: "leader-model",
-            costAware: true,
-        });
-        expect(backlog.items).toHaveLength(3);
-        const v1Items = backlog.items.filter((i) => i.mvp_priority === "v1");
-        const v2Items = backlog.items.filter((i) => i.mvp_priority === "v2");
-        expect(v1Items).toHaveLength(2); // login + task management
-        expect(v2Items).toHaveLength(1); // multi-tenant
-        expect(v2Items[0].title).toBe("multi-tenant");
-        expect(v2Items[0].deferral_reason).toBe("Out of scope for v1");
-    });
-    it("Test B: acceptance criteria matching — 'login' criterion attaches to login item", async () => {
-        const backlog = await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo-app",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm: makeLlm(),
-            leaderModelId: "leader-model",
-            costAware: true,
-        });
-        const loginItem = backlog.items.find((i) => i.title === "login");
-        expect(loginItem).toBeDefined();
-        // "user can log in with email/password" should match "login" keyword
-        expect(loginItem.acceptance_criteria.some((c) => c.includes("log in"))).toBe(true);
-    });
-    it("Test C: effort estimation calls pickCouncilTaskModel with task='effort_estimate'", async () => {
-        // Clear prior calls so we can assert on calls from this test only.
-        pickCouncilTaskModel.mockClear();
-        const llm = makeLlm();
-        await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo-app",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm,
-            leaderModelId: "my-leader-model",
-            costAware: true,
-        });
-        const calls = pickCouncilTaskModel.mock.calls;
-        const effortCall = calls.find((c) => c[0] === "effort_estimate");
-        expect(effortCall).toBeDefined();
-        expect(effortCall[1]).toBe("my-leader-model");
-    });
-    it("Test D: derivedFromClarifyId is deterministic for the same spec", async () => {
-        const spec = makeSpec();
-        const plan = makePlan();
-        const a = await buildBacklog({
-            runId: "run-a",
-            productSlug: "todo",
-            spec,
-            implementationPlan: plan,
-            llm: makeLlm(),
-            leaderModelId: "m",
-            costAware: false,
-        });
-        const b = await buildBacklog({
-            runId: "run-b",
-            productSlug: "todo",
-            spec,
-            implementationPlan: plan,
-            llm: makeLlm(),
-            leaderModelId: "m",
-            costAware: false,
-        });
-        expect(a.derivedFromClarifyId).toBe(b.derivedFromClarifyId);
-        expect(a.derivedFromClarifyId).toHaveLength(16);
-    });
-    it("effortPoints are parsed from LLM response", async () => {
-        const backlog = await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm: makeLlm("[1, 3, 5]"),
-            leaderModelId: "m",
-            costAware: true,
-        });
-        // 3 items: effort 1, 3, 5 respectively
-        expect(backlog.items[0].effortPoints).toBe(1);
-        expect(backlog.items[1].effortPoints).toBe(3);
-        expect(backlog.items[2].effortPoints).toBe(5);
-    });
-    it("defaults effortPoints to 3 when LLM response is unparseable", async () => {
-        const backlog = await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm: makeLlm("invalid json here"),
-            leaderModelId: "m",
-            costAware: true,
-        });
-        for (const item of backlog.items) {
-            expect(item.effortPoints).toBe(3);
-        }
-    });
-    it("status defaults to 'backlog' for all items", async () => {
-        const backlog = await buildBacklog({
-            runId: "run-1",
-            productSlug: "todo",
-            spec: makeSpec(),
-            implementationPlan: makePlan(),
-            llm: makeLlm(),
-            leaderModelId: "m",
-            costAware: false,
-        });
-        for (const item of backlog.items) {
-            expect(item.status).toBe("backlog");
-        }
-    });
-});
-//# sourceMappingURL=backlog-builder.test.js.map

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

@@ -1,4 +0,0 @@
-/**
- * backlog-store.test.ts — P6 unit tests for read/write/update on backlog.json.
- */
-export {};

package/dist/src/product-loop/__tests__/backlog-store.test.js

@@ -1,96 +0,0 @@
-/**
- * backlog-store.test.ts — P6 unit tests for read/write/update on backlog.json.
- */
-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 { readBacklog, updateBacklogItem, writeBacklog } from "../backlog-store.js";
-function makeItem(overrides = {}) {
-    return {
-        id: "item-001",
-        title: "Login feature",
-        description: "Allow users to log in",
-        acceptance_criteria: ["user can log in with email/password"],
-        entities: [],
-        endpoints: [],
-        mvp_priority: "v1",
-        status: "backlog",
-        effortPoints: 3,
-        createdAtUtc: "2026-01-01T00:00:00.000Z",
-        updatedAtUtc: "2026-01-01T00:00:00.000Z",
-        ...overrides,
-    };
-}
-function makeBacklog(overrides = {}) {
-    return {
-        runId: "run-test",
-        productSlug: "my-app",
-        items: [makeItem()],
-        derivedFromClarifyId: "abc123def456abcd",
-        createdAtUtc: "2026-01-01T00:00:00.000Z",
-        ...overrides,
-    };
-}
-describe("backlog-store (P6)", () => {
-    let flowDir;
-    const runId = "run-test";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `backlog-test-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(flowDir, { recursive: true });
-    });
-    it("returns null when backlog.json does not exist", async () => {
-        const result = await readBacklog(flowDir, runId);
-        expect(result).toBeNull();
-    });
-    it("write + read round-trip preserves all fields", async () => {
-        const backlog = makeBacklog();
-        await writeBacklog(flowDir, runId, backlog);
-        const read = await readBacklog(flowDir, runId);
-        expect(read).not.toBeNull();
-        expect(read.runId).toBe("run-test");
-        expect(read.productSlug).toBe("my-app");
-        expect(read.items).toHaveLength(1);
-        expect(read.items[0].title).toBe("Login feature");
-        expect(read.derivedFromClarifyId).toBe("abc123def456abcd");
-    });
-    it("writes to correct path: .planning/runs/<runId>/backlog.json", async () => {
-        const backlog = makeBacklog();
-        await writeBacklog(flowDir, runId, backlog);
-        const expectedPath = path.join(flowDir, "runs", runId, "backlog.json");
-        const stat = await fs.stat(expectedPath);
-        expect(stat.isFile()).toBe(true);
-    });
-    it("updateBacklogItem patches the item and updates updatedAtUtc", async () => {
-        const backlog = makeBacklog();
-        const before = backlog.items[0].updatedAtUtc;
-        await writeBacklog(flowDir, runId, backlog);
-        // Slight delay to ensure timestamp changes
-        await new Promise((r) => setTimeout(r, 5));
-        const updated = await updateBacklogItem(flowDir, runId, "item-001", {
-            status: "in_sprint",
-            assigned_sprint: "sprint-1",
-        });
-        expect(updated.items[0].status).toBe("in_sprint");
-        expect(updated.items[0].assigned_sprint).toBe("sprint-1");
-        // updatedAtUtc must be refreshed
-        expect(updated.items[0].updatedAtUtc).not.toBe(before);
-        // Other fields unchanged
-        expect(updated.items[0].title).toBe("Login feature");
-        expect(updated.items[0].effortPoints).toBe(3);
-    });
-    it("updateBacklogItem persists the patch to disk", async () => {
-        await writeBacklog(flowDir, runId, makeBacklog());
-        await updateBacklogItem(flowDir, runId, "item-001", { status: "done" });
-        const read = await readBacklog(flowDir, runId);
-        expect(read.items[0].status).toBe("done");
-    });
-    it("updateBacklogItem throws when backlog.json is missing", async () => {
-        await expect(updateBacklogItem(flowDir, runId, "item-001", { status: "done" })).rejects.toThrow(/backlog.json not found/);
-    });
-    it("updateBacklogItem throws when item id is not found", async () => {
-        await writeBacklog(flowDir, runId, makeBacklog());
-        await expect(updateBacklogItem(flowDir, runId, "nonexistent-id", { status: "done" })).rejects.toThrow(/not found in backlog/);
-    });
-});
-//# sourceMappingURL=backlog-store.test.js.map

package/dist/src/product-loop/__tests__/cb2-retry-bonus.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Tests for P3.7 — CB-2 oscillation retry bonus.
- *
- * The bonus logic lives in sprint-runner.ts (option b approach):
- *   - When CB-2 halts AND any signature has count >= 3 AND retry not used → skip halt, mark used.
- *   - When CB-2 halts AND retry already used → halt as normal.
- *   - When CB-2 halts AND no signatures pushed → halt as normal.
- *
- * These tests exercise the CB2_oscillation function and the _resetCb2RetryUsed
- * helper together with loadVerifyFailureSignatures state to validate all three
- * branches deterministically without spawning a full sprint.
- */
-export {};