muonroi-cli 1.4.0 → 1.4.1

package/src/product-loop/__tests__/product-identity.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { productSlug } from "../product-identity.js";
-
-describe("productSlug", () => {
-  it("returns 8-char hash prefix + dash + slug suffix", () => {
-    const out = productSlug("Blog platform with auth");
-    expect(out).toMatch(/^[a-f0-9]{8}-[a-z0-9-]+$/);
-  });
-
-  it("stable: same input → same output", () => {
-    const a = productSlug("Build a chat app");
-    const b = productSlug("Build a chat app");
-    expect(a).toBe(b);
-  });
-
-  it("different inputs produce different slugs", () => {
-    expect(productSlug("idea A")).not.toBe(productSlug("idea B"));
-  });
-
-  it("total length ≤ 49 chars (8 + 1 + 40)", () => {
-    const out = productSlug("a".repeat(500));
-    expect(out.length).toBeLessThanOrEqual(49);
-  });
-
-  it("slug suffix only contains [a-z0-9-]", () => {
-    const out = productSlug("HELLO!@# WORLD ñ");
-    const suffix = out.slice(9);
-    expect(/^[a-z0-9-]*$/.test(suffix)).toBe(true);
-  });
-
-  it("whitespace-only idea still yields valid slug", () => {
-    const out = productSlug("   ");
-    expect(out).toMatch(/^[a-f0-9]{8}/);
-  });
-
-  it("Discord round-trip: name muonroi-${slug} survives Discord's lowercase+replace transform unchanged", () => {
-    const slug = productSlug("My Cool Product 2026");
-    const channelName = `muonroi-${slug}`;
-    const discordTransformed = channelName.toLowerCase().replace(/[^a-z0-9-_]/g, "-");
-    expect(channelName).toBe(discordTransformed);
-  });
-
-  it("Vietnamese with diacritics produces clean slug", () => {
-    const out = productSlug("Sản phẩm thử nghiệm");
-    expect(/^[a-f0-9]{8}-[a-z0-9-]+$/.test(out)).toBe(true);
-  });
-});

package/src/product-loop/__tests__/progress-snapshot.test.ts

@@ -1,180 +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";
-import type { Backlog, BacklogItem, Sprint, SprintPlan } from "../types.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: string;
-
-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: Partial<BacklogItem> & { id: string }): BacklogItem {
-  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: BacklogItem[]): Backlog {
-  return {
-    runId: "run-1",
-    productSlug: "test-product",
-    items,
-    derivedFromClarifyId: "abc",
-    createdAtUtc: new Date().toISOString(),
-  };
-}
-
-function makeSprint(overrides: Partial<Sprint> & { id: string; number: number }): Sprint {
-  return {
-    goal: `Goal for ${overrides.id}`,
-    itemIds: [],
-    status: "planned",
-    ...overrides,
-  };
-}
-
-function makeSprintPlan(sprints: Sprint[], activeSprintId?: string): SprintPlan {
-  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);
-  });
-});

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

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { type Criterion, 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: Criterion[] = [
-      { 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);
-  });
-});

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

@@ -1,103 +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: Record<string, string>): Promise<string> {
-  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: string;
-  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);
-  });
-});

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

@@ -1,155 +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";
-import type { ExistingProjectSignals } from "../types.js";
-
-function makeDetection(over: Partial<ExistingProjectSignals> = {}): ExistingProjectSignals {
-  return {
-    isGitRepo: false,
-    hasCommitHistory: false,
-    srcFileCount: 10,
-    manifests: [],
-    languages: ["TypeScript"],
-    frameworks: [],
-    classification: "existing",
-    ...over,
-  };
-}
-
-describe("buildRepoBrief", () => {
-  let tmp: string;
-  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);
-  });
-});

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

@@ -1,70 +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: string;
-
-  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");
-  });
-});