muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/progress-snapshot.test.js

@@ -1,152 +0,0 @@
-/**
- * src/product-loop/__tests__/progress-snapshot.test.ts
- *
- * Unit tests for computeProgressSnapshot() and renderSnapshotMarkdown().
- * Uses temp directories for backlog/sprint files. Mocks getDatabase so
- * no real SQLite DB is needed.
- */
-import { mkdtemp, rm } from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { writeBacklog } from "../backlog-store.js";
-import { writeSprintPlan } from "../sprint-store.js";
-// ─── Mock DB ──────────────────────────────────────────────────────────────────
-// Default: no sprint_stage rows
-const mockDbGet = vi.fn().mockReturnValue(undefined);
-const mockDbPrepare = vi.fn().mockReturnValue({ get: mockDbGet });
-vi.mock("../../storage/db.js", () => ({
-    getDatabase: vi.fn(() => ({ prepare: mockDbPrepare })),
-}));
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await mkdtemp(path.join(os.tmpdir(), "progress-snapshot-test-"));
-    mockDbGet.mockReturnValue(undefined); // reset to "no rows"
-});
-afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-function makeItem(overrides) {
-    const now = new Date().toISOString();
-    return {
-        title: overrides.id,
-        description: "",
-        acceptance_criteria: ["crit-1", "crit-2"],
-        entities: [],
-        endpoints: [],
-        mvp_priority: "v1",
-        status: "backlog",
-        effortPoints: 3,
-        createdAtUtc: now,
-        updatedAtUtc: now,
-        ...overrides,
-    };
-}
-function makeBacklog(items) {
-    return {
-        runId: "run-1",
-        productSlug: "test-product",
-        items,
-        derivedFromClarifyId: "abc",
-        createdAtUtc: new Date().toISOString(),
-    };
-}
-function makeSprint(overrides) {
-    return {
-        goal: `Goal for ${overrides.id}`,
-        itemIds: [],
-        status: "planned",
-        ...overrides,
-    };
-}
-function makeSprintPlan(sprints, activeSprintId) {
-    return {
-        runId: "run-1",
-        sprints,
-        activeSprintId,
-        createdAtUtc: new Date().toISOString(),
-    };
-}
-describe("computeProgressSnapshot", () => {
-    it("empty workspace returns all-zero snapshot without crashing", async () => {
-        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
-        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "prod" });
-        expect(snap.backlogTotal).toBe(0);
-        expect(snap.backlogV1Count).toBe(0);
-        expect(snap.sprintTotal).toBe(0);
-        expect(snap.activeSprintNumber).toBeNull();
-        expect(snap.activeSprintPercentDone).toBe(0);
-        expect(snap.activeSprintItems).toHaveLength(0);
-        expect(snap.blockers).toHaveLength(0);
-        expect(snap.workerCurrentStage).toBeNull();
-    });
-    it("9 items / 3 sprints / 3 items done in active sprint → percentDone = 100", async () => {
-        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
-        const items = [
-            makeItem({ id: "i1", status: "done", assigned_sprint: "sprint-1" }),
-            makeItem({ id: "i2", status: "done", assigned_sprint: "sprint-1" }),
-            makeItem({ id: "i3", status: "done", assigned_sprint: "sprint-1" }),
-            makeItem({ id: "i4", status: "backlog", assigned_sprint: "sprint-2" }),
-            makeItem({ id: "i5", status: "backlog", assigned_sprint: "sprint-2" }),
-            makeItem({ id: "i6", status: "backlog", assigned_sprint: "sprint-2" }),
-            makeItem({ id: "i7", status: "backlog", assigned_sprint: "sprint-3" }),
-            makeItem({ id: "i8", status: "backlog", assigned_sprint: "sprint-3" }),
-            makeItem({ id: "i9", status: "backlog", assigned_sprint: "sprint-3" }),
-        ];
-        const backlog = makeBacklog(items);
-        await writeBacklog(tmpDir, "run-1", backlog);
-        const sprints = [
-            makeSprint({ id: "sprint-1", number: 1, status: "active", itemIds: ["i1", "i2", "i3"] }),
-            makeSprint({ id: "sprint-2", number: 2, status: "planned", itemIds: ["i4", "i5", "i6"] }),
-            makeSprint({ id: "sprint-3", number: 3, status: "planned", itemIds: ["i7", "i8", "i9"] }),
-        ];
-        const plan = makeSprintPlan(sprints, "sprint-1");
-        await writeSprintPlan(tmpDir, "run-1", plan);
-        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
-        expect(snap.sprintTotal).toBe(3);
-        expect(snap.activeSprintNumber).toBe(1);
-        expect(snap.activeSprintPercentDone).toBe(100);
-        expect(snap.activeSprintItems).toHaveLength(3);
-    });
-    it("workerCurrentStage parsed from interaction_logs", async () => {
-        mockDbGet.mockReturnValue({
-            metadata_json: JSON.stringify({ sprintIndex: 2, stage: "planning" }),
-            created_at: "2026-05-21T10:00:00.000Z",
-        });
-        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
-        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "prod" });
-        expect(snap.workerCurrentStage).toBe("Sprint 2 — Planning");
-        expect(snap.workerLastEventUtc).toBe("2026-05-21T10:00:00.000Z");
-    });
-    it("blockers detected for blocked items in active sprint", async () => {
-        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
-        const items = [
-            makeItem({ id: "b1", status: "blocked", assigned_sprint: "sprint-1", blockers: ["b2"] }),
-            makeItem({ id: "b2", status: "backlog", assigned_sprint: "sprint-1" }),
-        ];
-        const backlog = makeBacklog(items);
-        await writeBacklog(tmpDir, "run-1", backlog);
-        const sprints = [makeSprint({ id: "sprint-1", number: 1, status: "active", itemIds: ["b1", "b2"] })];
-        const plan = makeSprintPlan(sprints, "sprint-1");
-        await writeSprintPlan(tmpDir, "run-1", plan);
-        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
-        expect(snap.blockers).toHaveLength(1);
-        expect(snap.blockers[0].itemId).toBe("b1");
-        expect(snap.blockers[0].reason).toContain("blocked by b2");
-    });
-    it("no active sprint → activeSprintNumber is null", async () => {
-        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
-        const items = [makeItem({ id: "x", status: "in_sprint", assigned_sprint: "sprint-1" })];
-        const backlog = makeBacklog(items);
-        await writeBacklog(tmpDir, "run-1", backlog);
-        const sprints = [makeSprint({ id: "sprint-1", number: 1, status: "planned", itemIds: ["x"] })];
-        const plan = makeSprintPlan(sprints); // no activeSprintId
-        await writeSprintPlan(tmpDir, "run-1", plan);
-        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
-        expect(snap.activeSprintNumber).toBeNull();
-        expect(snap.activeSprintGoal).toBeNull();
-        expect(snap.activeSprintItems).toHaveLength(0);
-    });
-});
-//# sourceMappingURL=progress-snapshot.test.js.map

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

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

package/dist/src/product-loop/__tests__/reality-anchor.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { evidenceLooksValid, wrapSynthesisWithEvidence } from "../reality-anchor.js";
-describe("evidenceLooksValid", () => {
-    it("should accept file:line format", () => {
-        expect(evidenceLooksValid("src/sync.ts:42")).toBe(true);
-        expect(evidenceLooksValid("app.py:10")).toBe(true);
-    });
-    it("should accept test/describe format", () => {
-        expect(evidenceLooksValid("test('handles empty input')")).toBe(true);
-        expect(evidenceLooksValid('describe("auth flow")')).toBe(true);
-    });
-    it("should accept commit sha (7-40 hex)", () => {
-        expect(evidenceLooksValid("abcdef1234567")).toBe(true);
-        expect(evidenceLooksValid("1234567890abcdef1234567890abcdef12345678")).toBe(true);
-    });
-    it("should accept benchmark format", () => {
-        expect(evidenceLooksValid("p95: 240ms")).toBe(true);
-        expect(evidenceLooksValid("throughput = 5000")).toBe(true);
-        expect(evidenceLooksValid("lighthouse 98")).toBe(true);
-    });
-    it("should accept HTTP test format", () => {
-        expect(evidenceLooksValid("GET /api/users → 200")).toBe(true);
-        expect(evidenceLooksValid("POST /auth/login → 201")).toBe(true);
-    });
-    it("should reject free-form prose with no anchors", () => {
-        expect(evidenceLooksValid("we wrote some tests and they passed")).toBe(false);
-        expect(evidenceLooksValid("I checked the code and it looks good")).toBe(false);
-    });
-    it("should reject empty string", () => {
-        expect(evidenceLooksValid("")).toBe(false);
-        expect(evidenceLooksValid("   ")).toBe(false);
-    });
-});
-describe("wrapSynthesisWithEvidence", () => {
-    it("should annotate criteria correctly", () => {
-        const criteria = [
-            { id: "C1", status: "met", evidence: "src/main.ts:10" },
-            { id: "C2", status: "partial", evidence: "invalid evidence" },
-            { id: "C3", status: "unmet" },
-            { id: "C4", status: "met" }, // missing evidence
-        ];
-        const wrapped = wrapSynthesisWithEvidence(criteria);
-        expect(wrapped[0].evidenceValid).toBe(true);
-        expect(wrapped[1].evidenceValid).toBe(false);
-        expect(wrapped[2].evidenceValid).toBe(true); // unmet is always true-valid
-        expect(wrapped[3].evidenceValid).toBe(false);
-    });
-});
-//# sourceMappingURL=reality-anchor.test.js.map

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

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

package/dist/src/product-loop/__tests__/repo-audit.test.js

@@ -1,97 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { additionalPrefills, auditAsContextBlock, auditRepo, formatAuditSummary } from "../repo-audit.js";
-async function makeFixture(layout) {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "audit-"));
-    for (const [rel, content] of Object.entries(layout)) {
-        const full = path.join(root, rel);
-        await fs.mkdir(path.dirname(full), { recursive: true });
-        await fs.writeFile(full, content, "utf-8");
-    }
-    return root;
-}
-describe("auditRepo", () => {
-    let cwd;
-    afterEach(async () => {
-        if (cwd)
-            await fs.rm(cwd, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("returns greenfield mode for empty cwd", async () => {
-        cwd = await makeFixture({});
-        const a = await auditRepo(cwd);
-        expect(a.hasProject).toBe(false);
-        expect(a.mode).toBe("greenfield");
-        expect(formatAuditSummary(a)).toBeNull();
-    });
-    it("flags upgrade-existing when src+tests+README all present", async () => {
-        cwd = await makeFixture({
-            "README.md": "# My Project\n\nA cool tool.\n\n## Usage\n",
-            "package.json": JSON.stringify({
-                name: "my-tool",
-                version: "0.1.0",
-                description: "A cool tool",
-                devDependencies: { vitest: "1.0.0" },
-            }),
-            "src/index.ts": "export const a = 1;",
-            "src/foo.ts": "export const b = 2;",
-            "src/bar.ts": "export const c = 3;",
-            "tests/foo.test.ts": "test('x', () => {});",
-            "vitest.config.ts": "export default {};",
-        });
-        const a = await auditRepo(cwd);
-        expect(a.hasProject).toBe(true);
-        expect(a.mode).toBe("upgrade-existing");
-        expect(a.srcFileCount).toBeGreaterThanOrEqual(3);
-        expect(a.testFileCount).toBeGreaterThanOrEqual(1);
-        expect(a.testFramework).toBe("vitest");
-        expect(a.hasCoverageConfig).toBe(true);
-        expect(a.packageMeta?.name).toBe("my-tool");
-        expect(a.readmeExcerpt).toContain("cool tool");
-        expect(a.readmeSections).toContain("Usage");
-    });
-    it("classifies scratch-dir when only src exists without tests/docs", async () => {
-        cwd = await makeFixture({
-            "src/index.ts": "console.log('hi');",
-        });
-        const a = await auditRepo(cwd);
-        expect(a.hasProject).toBe(true);
-        expect(a.mode).toBe("scratch-dir");
-    });
-    it("additionalPrefills surfaces persona+core-features for upgrade-existing", async () => {
-        cwd = await makeFixture({
-            "README.md": "# X\n\nLib.\n",
-            "package.json": JSON.stringify({ devDependencies: { vitest: "1.0.0" } }),
-            "src/a.ts": "",
-            "src/b.ts": "",
-            "src/c.ts": "",
-            "tests/a.test.ts": "",
-            "vitest.config.ts": "",
-            "docs/README.md": "",
-        });
-        const a = await auditRepo(cwd);
-        const prefills = additionalPrefills(a);
-        expect(prefills.get("persona")).toMatch(/developers/i);
-        expect(prefills.get("core-features")).toMatch(/upgrade in place/i);
-        expect(prefills.get("success-metric")).toMatch(/vitest/);
-    });
-    it("auditAsContextBlock includes pkg meta and recent-context fields", async () => {
-        cwd = await makeFixture({
-            "README.md": "# Foo\n\nReadme paragraph.\n",
-            "package.json": JSON.stringify({ name: "foo", version: "1.2.3", description: "the foo" }),
-            "src/a.ts": "",
-        });
-        const a = await auditRepo(cwd);
-        const block = auditAsContextBlock(a);
-        expect(block).toContain("Repository audit");
-        expect(block).toContain("foo@1.2.3");
-        expect(block).toContain("Readme paragraph");
-    });
-    it("auditAsContextBlock returns greenfield notice when no project", async () => {
-        cwd = await makeFixture({});
-        const a = await auditRepo(cwd);
-        expect(auditAsContextBlock(a)).toMatch(/greenfield/i);
-    });
-});
-//# sourceMappingURL=repo-audit.test.js.map

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

@@ -1,9 +0,0 @@
-/**
- * Tests for `buildRepoBrief` — the existing-project replacement for the
- * Muonroi vendor preamble in discovery leader prompts. Covers:
- *  - basic shape from a TS-ish temp repo
- *  - missing pieces (no README, no package.json) degrade gracefully
- *  - rationaleCitesBrief gate accepts cited and rejects uncited rationales
- *  - hard cap respected on large READMEs
- */
-export {};

package/dist/src/product-loop/__tests__/repo-brief.test.js

@@ -1,132 +0,0 @@
-/**
- * Tests for `buildRepoBrief` — the existing-project replacement for the
- * Muonroi vendor preamble in discovery leader prompts. Covers:
- *  - basic shape from a TS-ish temp repo
- *  - missing pieces (no README, no package.json) degrade gracefully
- *  - rationaleCitesBrief gate accepts cited and rejects uncited rationales
- *  - hard cap respected on large READMEs
- */
-import * 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 { buildRepoBrief, rationaleCitesBrief } from "../repo-brief.js";
-function makeDetection(over = {}) {
-    return {
-        isGitRepo: false,
-        hasCommitHistory: false,
-        srcFileCount: 10,
-        manifests: [],
-        languages: ["TypeScript"],
-        frameworks: [],
-        classification: "existing",
-        ...over,
-    };
-}
-describe("buildRepoBrief", () => {
-    let tmp;
-    beforeEach(() => {
-        tmp = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-repo-brief-"));
-    });
-    afterEach(() => {
-        fs.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("includes package.json name, scripts, deps when present", async () => {
-        fs.writeFileSync(path.join(tmp, "package.json"), JSON.stringify({
-            name: "@muonroi/test-pkg",
-            description: "Test pkg for repo-brief",
-            scripts: { build: "tsc", test: "vitest" },
-            dependencies: { ai: "^1.0.0", vitest: "^4.0.0" },
-        }));
-        const brief = await buildRepoBrief(tmp, makeDetection());
-        expect(brief.markdown).toContain("@muonroi/test-pkg");
-        expect(brief.markdown).toContain("Test pkg for repo-brief");
-        expect(brief.markdown).toContain("`build`");
-        expect(brief.markdown).toContain("`ai`");
-        expect(brief.citableTokens).toContain("@muonroi/test-pkg");
-        expect(brief.citableTokens).toContain("build");
-        expect(brief.citableTokens).toContain("ai");
-    });
-    it("walks top-level dirs to depth 2 and skips ignored dirs", async () => {
-        fs.mkdirSync(path.join(tmp, "src", "components"), { recursive: true });
-        fs.mkdirSync(path.join(tmp, "src", "hooks"), { recursive: true });
-        fs.mkdirSync(path.join(tmp, "node_modules", "foo"), { recursive: true });
-        fs.mkdirSync(path.join(tmp, ".git"), { recursive: true });
-        fs.mkdirSync(path.join(tmp, "tests"), { recursive: true });
-        const brief = await buildRepoBrief(tmp, makeDetection());
-        expect(brief.markdown).toContain("`src/`");
-        expect(brief.markdown).toContain("`components/`");
-        expect(brief.markdown).toContain("`hooks/`");
-        expect(brief.markdown).toContain("`tests/`");
-        expect(brief.markdown).not.toContain("node_modules");
-        expect(brief.markdown).not.toContain(".git");
-        expect(brief.citableTokens).toContain("src");
-        expect(brief.citableTokens).toContain("src/components");
-    });
-    it("includes README head and truncates with ellipsis", async () => {
-        const big = "X".repeat(900);
-        fs.writeFileSync(path.join(tmp, "README.md"), `# Title\n\n${big}`);
-        const brief = await buildRepoBrief(tmp, makeDetection());
-        expect(brief.markdown).toContain("README head:");
-        expect(brief.markdown).toContain("# Title");
-        expect(brief.markdown).toContain("…");
-    });
-    it("includes manifests + languages + frameworks from detection", async () => {
-        const brief = await buildRepoBrief(tmp, makeDetection({
-            languages: ["TypeScript", "Rust"],
-            frameworks: ["react", "vite"],
-            manifests: [
-                {
-                    file: path.join(tmp, "package.json"),
-                    type: "package.json",
-                    weight: 1,
-                    inferredLang: "TypeScript",
-                    inferredFrameworks: ["react"],
-                },
-            ],
-        }));
-        expect(brief.markdown).toContain("TypeScript, Rust");
-        expect(brief.markdown).toContain("react, vite");
-        expect(brief.markdown).toContain("package.json");
-        expect(brief.citableTokens).toContain("react");
-        expect(brief.citableTokens).toContain("package.json");
-    });
-    it("degrades gracefully when nothing is present (empty dir)", async () => {
-        const brief = await buildRepoBrief(tmp, makeDetection({ languages: [], srcFileCount: 0 }));
-        expect(brief.markdown).toContain("Repo brief");
-        expect(brief.markdown).toContain("Rationales for ANY recommendation MUST cite");
-        // citableTokens may still be empty for an empty dir — acceptable.
-        expect(Array.isArray(brief.citableTokens)).toBe(true);
-    });
-    it("caps total markdown length at 1200 chars", async () => {
-        fs.writeFileSync(path.join(tmp, "README.md"), "Z".repeat(5000));
-        fs.writeFileSync(path.join(tmp, "package.json"), JSON.stringify({
-            name: "x",
-            scripts: Object.fromEntries(Array.from({ length: 30 }, (_, i) => [`s${i}`, `cmd${i}`])),
-            dependencies: Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`dep${i}`, "1"])),
-        }));
-        const brief = await buildRepoBrief(tmp, makeDetection());
-        expect(brief.markdown.length).toBeLessThanOrEqual(1200);
-    });
-});
-describe("rationaleCitesBrief", () => {
-    const briefStub = {
-        markdown: "(unused)",
-        citableTokens: ["src", "package.json", "discovery-recommender.ts", "build"],
-    };
-    it("returns true when rationale contains any token (case-insensitive)", () => {
-        expect(rationaleCitesBrief("Reuses `src/foo.ts` to avoid duplication", briefStub)).toBe(true);
-        expect(rationaleCitesBrief("Extends the existing BUILD script", briefStub)).toBe(true);
-    });
-    it("returns false when rationale is generic / cites nothing in brief", () => {
-        expect(rationaleCitesBrief("Industry standard for SaaS apps", briefStub)).toBe(false);
-        expect(rationaleCitesBrief("Best for performance and simplicity", briefStub)).toBe(false);
-    });
-    it("returns true when brief has no citable tokens (no expectations to enforce)", () => {
-        expect(rationaleCitesBrief("anything", { markdown: "", citableTokens: [] })).toBe(true);
-    });
-    it("returns true when brief is undefined", () => {
-        expect(rationaleCitesBrief("anything", undefined)).toBe(true);
-    });
-});
-//# sourceMappingURL=repo-brief.test.js.map

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

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

package/dist/src/product-loop/__tests__/role-memory.test.js

@@ -1,56 +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 { appendRoleMemory, readRoleMemory } from "../role-memory.js";
-describe("role-memory management", () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = path.join(os.tmpdir(), `gsd-test-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(tempDir, { recursive: true });
-    });
-    it("appends and reads back small blocks", async () => {
-        const runId = "run-123";
-        const slot = "PO";
-        await appendRoleMemory(tempDir, runId, slot, 1, "Initial requirements");
-        await appendRoleMemory(tempDir, runId, slot, 2, "Refined requirements");
-        const content = await readRoleMemory(tempDir, runId, slot);
-        expect(content).toContain("### Sprint 1");
-        expect(content).toContain("Initial requirements");
-        expect(content).toContain("### Sprint 2");
-        expect(content).toContain("Refined requirements");
-    });
-    it("truncates oldest blocks when exceeding 2KB", async () => {
-        const runId = "run-cap";
-        const slot = "Architect";
-        // Each block is ~100 bytes
-        const largeBlock = "X".repeat(100);
-        for (let i = 1; i <= 30; i++) {
-            await appendRoleMemory(tempDir, runId, slot, i, `Block ${i}: ${largeBlock}`);
-        }
-        const content = await readRoleMemory(tempDir, runId, slot);
-        expect(content.length).toBeLessThanOrEqual(2048);
-        // Sprint 1 should definitely be gone
-        expect(content).not.toContain("### Sprint 1\n");
-        // Latest sprint should be there
-        expect(content).toContain("### Sprint 30\n");
-        // Verify it starts with a "### Sprint" line (boundary preserved)
-        expect(content.trim().startsWith("### Sprint")).toBe(true);
-    });
-    it("returns empty string for missing slot", async () => {
-        const content = await readRoleMemory(tempDir, "none", "PO");
-        expect(content).toBe("");
-    });
-    it("handles concurrent appends to different slots", async () => {
-        const runId = "run-parallel";
-        await Promise.all([
-            appendRoleMemory(tempDir, runId, "PO", 1, "PO content"),
-            appendRoleMemory(tempDir, runId, "Customer", 1, "Customer content"),
-            appendRoleMemory(tempDir, runId, "Tester", 1, "Tester content"),
-        ]);
-        expect(await readRoleMemory(tempDir, runId, "PO")).toContain("PO content");
-        expect(await readRoleMemory(tempDir, runId, "Customer")).toContain("Customer content");
-        expect(await readRoleMemory(tempDir, runId, "Tester")).toContain("Tester content");
-    });
-});
-//# sourceMappingURL=role-memory.test.js.map

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

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