muonroi-cli 1.8.0 → 1.8.3

package/dist/src/ee/session-trajectory.test.js

@@ -1,120 +0,0 @@
-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 { appendTrajectoryEvent, disableTrajectoryLogging, resetTrajectoryState, rotateOldSessions, setSessionsDir, } from "./session-trajectory.js";
-let tmp;
-beforeEach(async () => {
-    tmp = await fs.mkdtemp(path.join(os.tmpdir(), "ee-traj-"));
-    setSessionsDir(tmp);
-    resetTrajectoryState();
-    disableTrajectoryLogging(false);
-});
-afterEach(async () => {
-    await fs.rm(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-});
-describe("session-trajectory / append", () => {
-    it("appends one JSONL line per event", async () => {
-        await appendTrajectoryEvent({
-            ts: new Date().toISOString(),
-            sessionId: "sess1",
-            kind: "intercept",
-            toolName: "Edit",
-            decision: "allow",
-            matchCount: 1,
-            matchIds: ["abc"],
-        });
-        await appendTrajectoryEvent({
-            ts: new Date().toISOString(),
-            sessionId: "sess1",
-            kind: "posttool",
-            toolName: "Edit",
-            success: true,
-            durationMs: 12,
-        });
-        const file = path.join(tmp, "sess1.jsonl");
-        const content = await fs.readFile(file, "utf8");
-        const lines = content.trim().split("\n");
-        expect(lines.length).toBe(2);
-        const parsed = JSON.parse(lines[0]);
-        expect(parsed.kind).toBe("intercept");
-    });
-    it("sanitizes sessionId for filesystem safety", async () => {
-        await appendTrajectoryEvent({
-            ts: new Date().toISOString(),
-            sessionId: "../../etc/passwd",
-            kind: "user_turn",
-            excerpt: "hello",
-            vetoDetected: false,
-        });
-        // Sanitized name: `..` and `/` replaced with `_` → `_.._.._etc_passwd`
-        const entries = await fs.readdir(tmp);
-        expect(entries.length).toBe(1);
-        expect(entries[0]).toMatch(/^[a-zA-Z0-9_-]+\.jsonl$/);
-        expect(entries[0]).not.toContain("/");
-        expect(entries[0]).not.toContain("..");
-    });
-    it("skips events without sessionId", async () => {
-        await appendTrajectoryEvent({
-            ts: new Date().toISOString(),
-            sessionId: "",
-            kind: "user_turn",
-            excerpt: "hi",
-            vetoDetected: false,
-        });
-        const entries = await fs.readdir(tmp).catch(() => []);
-        expect(entries.length).toBe(0);
-    });
-    it("respects disable flag", async () => {
-        disableTrajectoryLogging(true);
-        await appendTrajectoryEvent({
-            ts: new Date().toISOString(),
-            sessionId: "sess1",
-            kind: "user_turn",
-            excerpt: "hi",
-            vetoDetected: false,
-        });
-        const entries = await fs.readdir(tmp).catch(() => []);
-        expect(entries.length).toBe(0);
-    });
-});
-describe("session-trajectory / rotation", () => {
-    it("removes files older than 30 days", async () => {
-        const fresh = path.join(tmp, "fresh.jsonl");
-        const old = path.join(tmp, "old.jsonl");
-        await fs.writeFile(fresh, "{}\n");
-        await fs.writeFile(old, "{}\n");
-        // Backdate `old` by 31 days.
-        const oldTime = Date.now() - 31 * 24 * 60 * 60 * 1000;
-        await fs.utimes(old, oldTime / 1000, oldTime / 1000);
-        const result = await rotateOldSessions();
-        expect(result.removedAge).toBe(1);
-        const remaining = await fs.readdir(tmp);
-        expect(remaining).toContain("fresh.jsonl");
-        expect(remaining).not.toContain("old.jsonl");
-    });
-    it("evicts oldest files when total size exceeds 100MB", async () => {
-        // Write 3 files of 40MB each → 120MB total → 1 must be evicted (40MB removed).
-        const sizes = [40, 40, 40];
-        const names = ["a.jsonl", "b.jsonl", "c.jsonl"];
-        const buf = Buffer.alloc(40 * 1024 * 1024, "x"); // 40 MB
-        for (let i = 0; i < names.length; i++) {
-            const full = path.join(tmp, names[i]);
-            await fs.writeFile(full, buf);
-            // Stagger mtimes — `a` is oldest.
-            const t = (Date.now() - (sizes.length - i) * 60_000) / 1000;
-            await fs.utimes(full, t, t);
-        }
-        const result = await rotateOldSessions();
-        expect(result.removedSize).toBeGreaterThanOrEqual(1);
-        const after = await fs.readdir(tmp);
-        expect(after).not.toContain("a.jsonl"); // oldest evicted first
-    }, 30_000);
-    it("returns zero counts when directory does not exist yet", async () => {
-        setSessionsDir(path.join(tmp, "nonexistent"));
-        const result = await rotateOldSessions();
-        expect(result.removedAge).toBe(0);
-        expect(result.removedSize).toBe(0);
-    });
-});
-//# sourceMappingURL=session-trajectory.test.js.map

package/dist/src/ee/touch.test.d.ts

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

package/dist/src/ee/touch.test.js

@@ -1,62 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "./client.js";
-describe("EEClient feedback + touch fire-and-forget", () => {
-    let stub;
-    let ee;
-    beforeAll(async () => {
-        stub = await startStubEEServer({});
-        ee = createEEClient({ baseUrl: `http://localhost:${stub.port}` });
-    });
-    afterAll(async () => {
-        await stub.stop();
-    });
-    it("feedback() returns void synchronously; calls /api/feedback POST", async () => {
-        const before = stub.calls.feedback.length;
-        const payload = {
-            principle_uuid: "P1",
-            classification: "FOLLOWED",
-            tool_name: "Edit",
-            duration_ms: 42,
-            tenantId: "local",
-        };
-        const result = ee.feedback(payload);
-        expect(result).toBeUndefined();
-        // Wait for fire-and-forget to land (200ms to avoid flake under load)
-        await new Promise((r) => setTimeout(r, 200));
-        expect(stub.calls.feedback.length).toBe(before + 1);
-        expect(stub.calls.feedback[stub.calls.feedback.length - 1]).toMatchObject({
-            principle_uuid: "P1",
-            classification: "FOLLOWED",
-        });
-    });
-    it("touch() returns void synchronously; calls /api/principle/touch POST", async () => {
-        const before = stub.calls.touch.length;
-        const result = ee.touch("P2", "local");
-        expect(result).toBeUndefined();
-        await new Promise((r) => setTimeout(r, 200));
-        expect(stub.calls.touch.length).toBe(before + 1);
-        expect(stub.calls.touch[stub.calls.touch.length - 1]).toBe("P2");
-    });
-    it("feedback() never throws even on network error", () => {
-        const broken = createEEClient({
-            baseUrl: "http://localhost:1",
-            fetchImpl: vi.fn().mockRejectedValue(new Error("ECONNREFUSED")),
-        });
-        expect(() => broken.feedback({
-            principle_uuid: "X",
-            classification: "IGNORED",
-            tool_name: "Bash",
-            duration_ms: 0,
-            tenantId: "local",
-        })).not.toThrow();
-    });
-    it("touch() never throws even on network error", () => {
-        const broken = createEEClient({
-            baseUrl: "http://localhost:1",
-            fetchImpl: vi.fn().mockRejectedValue(new Error("ECONNREFUSED")),
-        });
-        expect(() => broken.touch("X", "local")).not.toThrow();
-    });
-});
-//# sourceMappingURL=touch.test.js.map

package/dist/src/ee/who-am-i.test.d.ts

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

package/dist/src/ee/who-am-i.test.js

@@ -1,101 +0,0 @@
-import * as os from "node:os";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache, selectWhoAmIDims, } from "./who-am-i.js";
-// Build a raw EE profile (the shape ~/.experience/src/profile-model.js loadProfile() returns).
-function rawDim(value, confidence, sampleCount = 20) {
-    return { value, confidence, sampleCount, distribution: {}, evidence: null };
-}
-function rawProfile(dims) {
-    return { version: 1, updatedAt: null, dimensions: dims };
-}
-describe("selectWhoAmIDims — privacy allowlist + commit/confidence gates", () => {
-    const all = () => rawProfile({
-        "communication.question_style": rawDim("directive", 0.8),
-        "communication.feedback_style": rawDim("implicit", 0.75),
-        "communication.brevity": rawDim("concise", 0.83),
-        "personality.conflict_style": rawDim("direct-constructive", 0.7),
-        "personality.risk_tolerance": rawDim("experimental", 0.72),
-        "personality.decision_speed": rawDim("fast-intuitive", 0.7),
-        "work_patterns.energy": rawDim("night-owl", 0.6),
-        "work_patterns.multitasking": rawDim("sequential-deep", 0.65),
-        "work_patterns.session_length": rawDim("long", 0.55),
-        "work_patterns.delegation_style": rawDim("autonomous", 0.68),
-    });
-    test("minimal exposes only the 4 Tang-1 work dims", () => {
-        const dims = selectWhoAmIDims(all(), "minimal");
-        expect(Object.keys(dims).sort()).toEqual([
-            "personality.decision_speed",
-            "work_patterns.energy",
-            "work_patterns.multitasking",
-            "work_patterns.session_length",
-        ].sort());
-    });
-    test("standard exposes all 10 committed dims", () => {
-        const dims = selectWhoAmIDims(all(), "standard");
-        expect(Object.keys(dims).length).toBe(10);
-    });
-    test("delegation_style is standard-only — stripped at minimal (transcript-derived, not Tang-1)", () => {
-        expect(selectWhoAmIDims(all(), "minimal")["work_patterns.delegation_style"]).toBeUndefined();
-        expect(selectWhoAmIDims(all(), "standard")["work_patterns.delegation_style"]).toBeDefined();
-    });
-    test("standard-built profile rendered at minimal strips Tang-2 dims (no stale leak)", () => {
-        const dims = selectWhoAmIDims(all(), "minimal");
-        expect(dims["communication.brevity"]).toBeUndefined();
-        expect(dims["personality.conflict_style"]).toBeUndefined();
-    });
-    test("pending (value=null) dims are skipped", () => {
-        const dims = selectWhoAmIDims(rawProfile({ "communication.brevity": rawDim(null, 0.9, 5) }), "standard");
-        expect(Object.keys(dims).length).toBe(0);
-    });
-    test("per-tier confidence floors: 0.55 Tang-2 drops at 0.6, 0.50 work survives at 0.45", () => {
-        const dims = selectWhoAmIDims(rawProfile({
-            "communication.brevity": rawDim("concise", 0.55),
-            "work_patterns.energy": rawDim("night-owl", 0.5),
-        }), "standard");
-        expect(dims["communication.brevity"]).toBeUndefined();
-        expect(dims["work_patterns.energy"]).toBeDefined();
-    });
-    test("Tang-3 emotional.* is never exposed (not in any allowlist)", () => {
-        const dims = selectWhoAmIDims(rawProfile({ "emotional.mood": rawDim("calm", 0.99) }), "full");
-        expect(Object.keys(dims).length).toBe(0);
-    });
-    test("decision_speed (personality.* but Tang-1) is allowed at minimal — namespace trap", () => {
-        const dims = selectWhoAmIDims(rawProfile({ "personality.decision_speed": rawDim("measured", 0.7) }), "minimal");
-        expect(dims["personality.decision_speed"]).toBeDefined();
-    });
-});
-describe("outputStyleFromProfile — brevity/decision_speed → OutputStyle", () => {
-    const p = (dims) => ({ level: "standard", dims });
-    test("brevity concise → concise, verbose → detailed, moderate → balanced", () => {
-        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "concise", confidence: 0.8, samples: 20 } }))).toBe("concise");
-        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "verbose", confidence: 0.8, samples: 20 } }))).toBe("detailed");
-        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "moderate", confidence: 0.8, samples: 20 } }))).toBe("balanced");
-    });
-    test("no brevity → decision_speed fast-intuitive → concise; deliberate → detailed", () => {
-        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "fast-intuitive", confidence: 0.7, samples: 20 } }))).toBe("concise");
-        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "deliberate", confidence: 0.7, samples: 20 } }))).toBe("detailed");
-    });
-    test("null profile or no usable dim → null (caller keeps its own default)", () => {
-        expect(outputStyleFromProfile(null)).toBeNull();
-        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "measured", confidence: 0.7, samples: 20 } }))).toBeNull();
-    });
-});
-describe("getWhoAmIProfile — fail-open + cache", () => {
-    const origHome = process.env.HOME;
-    const origUser = process.env.USERPROFILE;
-    beforeEach(() => {
-        resetWhoAmICache();
-    });
-    afterEach(() => {
-        process.env.HOME = origHome;
-        process.env.USERPROFILE = origUser;
-        resetWhoAmICache();
-    });
-    test("returns null when no EE install is present (no ~/.experience modules)", () => {
-        const empty = os.tmpdir(); // no .experience/src here
-        process.env.HOME = empty;
-        process.env.USERPROFILE = empty;
-        expect(getWhoAmIProfile()).toBeNull();
-    });
-});
-//# sourceMappingURL=who-am-i.test.js.map

package/dist/src/flow/__tests__/migration.test.d.ts

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

package/dist/src/flow/__tests__/migration.test.js

@@ -1,105 +0,0 @@
-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 { detectLegacyFlow, migrateQuickCodexFlow } from "../migration.js";
-describe("migration", () => {
-    let tmpDir;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "flow-migrate-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    describe("detectLegacyFlow", () => {
-        it("returns true when .quick-codex-flow/ exists", async () => {
-            await fs.mkdir(path.join(tmpDir, ".quick-codex-flow"), { recursive: true });
-            expect(await detectLegacyFlow(tmpDir)).toBe(true);
-        });
-        it("returns false when .quick-codex-flow/ does not exist", async () => {
-            expect(await detectLegacyFlow(tmpDir)).toBe(false);
-        });
-    });
-    describe("migrateQuickCodexFlow", () => {
-        it("copies STATE.md -> state.md, PROJECT-ROADMAP.md -> roadmap.md, BACKLOG.md -> backlog.md", async () => {
-            const qcDir = path.join(tmpDir, ".quick-codex-flow");
-            await fs.mkdir(qcDir, { recursive: true });
-            await fs.writeFile(path.join(qcDir, "STATE.md"), "## Active Run\n\nmy-run", "utf8");
-            await fs.writeFile(path.join(qcDir, "PROJECT-ROADMAP.md"), "## Milestones\n\nv1.0", "utf8");
-            await fs.writeFile(path.join(qcDir, "BACKLOG.md"), "## Deferred\n\nitem 1", "utf8");
-            await migrateQuickCodexFlow(tmpDir);
-            const flowDir = path.join(tmpDir, ".muonroi-flow");
-            const state = await fs.readFile(path.join(flowDir, "state.md"), "utf8");
-            expect(state).toContain("my-run");
-            const roadmap = await fs.readFile(path.join(flowDir, "roadmap.md"), "utf8");
-            expect(roadmap).toContain("v1.0");
-            const backlog = await fs.readFile(path.join(flowDir, "backlog.md"), "utf8");
-            expect(backlog).toContain("item 1");
-        });
-        it("splits monolithic QC run file into runs/<id>/{roadmap,state,delegations,gray-areas}.md", async () => {
-            const qcDir = path.join(tmpDir, ".quick-codex-flow");
-            await fs.mkdir(qcDir, { recursive: true });
-            // Top-level files needed for migration not to fail
-            await fs.writeFile(path.join(qcDir, "STATE.md"), "", "utf8");
-            await fs.writeFile(path.join(qcDir, "PROJECT-ROADMAP.md"), "", "utf8");
-            await fs.writeFile(path.join(qcDir, "BACKLOG.md"), "", "utf8");
-            // Monolithic run file
-            const runContent = [
-                "## Delivery Roadmap\n\nPhase 1 done",
-                "## Resume Digest\n\nLast worked on X",
-                "## Experience Snapshot\n\nLearned Y",
-                "## Delegation State\n\nAgent A owns task 1",
-                "## Gray Area Register\n\nG1: unclear requirement",
-                "## Decision Register\n\nD1: chose option A",
-            ].join("\n\n");
-            await fs.writeFile(path.join(qcDir, "my-feature-run.md"), runContent, "utf8");
-            const result = await migrateQuickCodexFlow(tmpDir);
-            expect(result.runsCreated).toBe(1);
-            const flowDir = path.join(tmpDir, ".muonroi-flow");
-            // Find the created run directory
-            const runs = await fs.readdir(path.join(flowDir, "runs"));
-            expect(runs.length).toBe(1);
-            const runDir = path.join(flowDir, "runs", runs[0]);
-            const roadmap = await fs.readFile(path.join(runDir, "roadmap.md"), "utf8");
-            expect(roadmap).toContain("Phase 1 done");
-            const state = await fs.readFile(path.join(runDir, "state.md"), "utf8");
-            expect(state).toContain("Last worked on X");
-            expect(state).toContain("Learned Y");
-            const delegations = await fs.readFile(path.join(runDir, "delegations.md"), "utf8");
-            expect(delegations).toContain("Agent A owns task 1");
-            const grayAreas = await fs.readFile(path.join(runDir, "gray-areas.md"), "utf8");
-            expect(grayAreas).toContain("unclear requirement");
-            // Decision Register appended to top-level decisions.md
-            const decisions = await fs.readFile(path.join(flowDir, "decisions.md"), "utf8");
-            expect(decisions).toContain("chose option A");
-        });
-        it("preserves unknown sections as-is in state.md (tolerant)", async () => {
-            const qcDir = path.join(tmpDir, ".quick-codex-flow");
-            await fs.mkdir(qcDir, { recursive: true });
-            await fs.writeFile(path.join(qcDir, "STATE.md"), "", "utf8");
-            await fs.writeFile(path.join(qcDir, "PROJECT-ROADMAP.md"), "", "utf8");
-            await fs.writeFile(path.join(qcDir, "BACKLOG.md"), "", "utf8");
-            const runContent = ["## Resume Digest\n\nresume info", "## Custom Unknown Section\n\ncustom content here"].join("\n\n");
-            await fs.writeFile(path.join(qcDir, "custom-run.md"), runContent, "utf8");
-            await migrateQuickCodexFlow(tmpDir);
-            const flowDir = path.join(tmpDir, ".muonroi-flow");
-            const runs = await fs.readdir(path.join(flowDir, "runs"));
-            const state = await fs.readFile(path.join(flowDir, "runs", runs[0], "state.md"), "utf8");
-            expect(state).toContain("custom content here");
-        });
-        it("does NOT delete original .quick-codex-flow/ after migration", async () => {
-            const qcDir = path.join(tmpDir, ".quick-codex-flow");
-            await fs.mkdir(qcDir, { recursive: true });
-            await fs.writeFile(path.join(qcDir, "STATE.md"), "original", "utf8");
-            await fs.writeFile(path.join(qcDir, "PROJECT-ROADMAP.md"), "", "utf8");
-            await fs.writeFile(path.join(qcDir, "BACKLOG.md"), "", "utf8");
-            await migrateQuickCodexFlow(tmpDir);
-            // Original still exists
-            const stat = await fs.stat(qcDir);
-            expect(stat.isDirectory()).toBe(true);
-            const content = await fs.readFile(path.join(qcDir, "STATE.md"), "utf8");
-            expect(content).toBe("original");
-        });
-    });
-});
-//# sourceMappingURL=migration.test.js.map

package/dist/src/flow/__tests__/parser.test.d.ts

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

package/dist/src/flow/__tests__/parser.test.js

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getSection, parseSections, serializeSections } from "../parser.js";
-describe("parseSections", () => {
-    it("parses two headed sections", () => {
-        const result = parseSections("## A\ncontent a\n\n## B\ncontent b");
-        expect(result.sections.get("A")).toBe("content a");
-        expect(result.sections.get("B")).toBe("content b");
-        expect(result.preamble).toBe("");
-    });
-    it("captures preamble before first heading", () => {
-        const result = parseSections("preamble\n\n## A\ncontent");
-        expect(result.preamble).toBe("preamble");
-        expect(result.sections.get("A")).toBe("content");
-    });
-    it("returns empty sections and preamble for empty string", () => {
-        const result = parseSections("");
-        expect(result.sections.size).toBe(0);
-        expect(result.preamble).toBe("");
-    });
-    it("returns preamble only for text without headings", () => {
-        const result = parseSections("no headings at all");
-        expect(result.preamble).toBe("no headings at all");
-        expect(result.sections.size).toBe(0);
-    });
-});
-describe("getSection", () => {
-    it("returns undefined for missing section (tolerant, no throw)", () => {
-        const map = parseSections("## A\ncontent");
-        expect(getSection(map, "Missing")).toBeUndefined();
-    });
-    it("returns content for existing section", () => {
-        const map = parseSections("## A\ncontent a");
-        expect(getSection(map, "A")).toBe("content a");
-    });
-});
-describe("serializeSections", () => {
-    it("round-trips: parse then serialize produces equivalent output", () => {
-        const input = "## A\n\ncontent a\n\n## B\n\ncontent b\n";
-        const parsed = parseSections(input);
-        const output = serializeSections(parsed);
-        const reparsed = parseSections(output);
-        expect(reparsed.sections.get("A")).toBe(parsed.sections.get("A"));
-        expect(reparsed.sections.get("B")).toBe(parsed.sections.get("B"));
-        expect(reparsed.preamble).toBe(parsed.preamble);
-    });
-    it("respects heading order parameter", () => {
-        const map = parseSections("## B\nb content\n\n## A\na content\n\n## C\nc content");
-        const output = serializeSections(map, ["A", "B", "C"]);
-        const aPos = output.indexOf("## A");
-        const bPos = output.indexOf("## B");
-        const cPos = output.indexOf("## C");
-        expect(aPos).toBeLessThan(bPos);
-        expect(bPos).toBeLessThan(cPos);
-    });
-    it("includes headings not in order parameter at the end", () => {
-        const map = parseSections("## X\nx\n\n## Y\ny");
-        const output = serializeSections(map, ["Y"]);
-        const yPos = output.indexOf("## Y");
-        const xPos = output.indexOf("## X");
-        expect(yPos).toBeLessThan(xPos);
-    });
-    it("serializes preamble first when present", () => {
-        const map = parseSections("my preamble\n\n## A\ncontent");
-        const output = serializeSections(map);
-        expect(output.startsWith("my preamble")).toBe(true);
-    });
-});
-//# sourceMappingURL=parser.test.js.map

package/dist/src/flow/__tests__/run-manager-product.test.d.ts

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

package/dist/src/flow/__tests__/run-manager-product.test.js

@@ -1,49 +0,0 @@
-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 { createRun, loadRun } from "../run-manager.js";
-describe("run-manager product extension", () => {
-    let tmpDir;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-flow-test-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("should create 6 files in createRun", async () => {
-        const run = await createRun(tmpDir);
-        const runDir = path.join(tmpDir, "runs", run.id);
-        const files = await fs.readdir(runDir);
-        expect(files).toContain("roadmap.md");
-        expect(files).toContain("state.md");
-        expect(files).toContain("delegations.md");
-        expect(files).toContain("gray-areas.md");
-        expect(files).toContain("iterations.md");
-        expect(files).toContain("manifest.md");
-        expect(files.length).toBe(6);
-    });
-    it("should initialize iterations.md and manifest.md", async () => {
-        const run = await createRun(tmpDir);
-        expect(run.iterations).toBeDefined();
-        expect(run.iterations.sections.has("Iterations")).toBe(true);
-        expect(run.manifest).toBeDefined();
-        expect(run.manifest.sections.has("Manifest")).toBe(true);
-    });
-    it("should load 6 SectionMaps in loadRun", async () => {
-        const runCreated = await createRun(tmpDir);
-        const runLoaded = await loadRun(tmpDir, runCreated.id);
-        expect(runLoaded).not.toBeNull();
-        if (runLoaded) {
-            expect(runLoaded.roadmap).toBeDefined();
-            expect(runLoaded.state).toBeDefined();
-            expect(runLoaded.delegations).toBeDefined();
-            expect(runLoaded.grayAreas).toBeDefined();
-            expect(runLoaded.iterations).toBeDefined();
-            expect(runLoaded.manifest).toBeDefined();
-            expect(runLoaded.iterations.sections.has("Iterations")).toBe(true);
-            expect(runLoaded.manifest.sections.has("Manifest")).toBe(true);
-        }
-    });
-});
-//# sourceMappingURL=run-manager-product.test.js.map

package/dist/src/flow/__tests__/run-manager.test.d.ts

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

package/dist/src/flow/__tests__/run-manager.test.js

@@ -1,83 +0,0 @@
-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 { parseSections } from "../parser.js";
-import { createRun, getActiveRunId, loadRun, setActiveRunId, updateRunFile } from "../run-manager.js";
-import { ensureFlowDir } from "../scaffold.js";
-describe("run-manager", () => {
-    let tmpDir;
-    let flowDir;
-    beforeEach(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "flow-run-"));
-        flowDir = await ensureFlowDir(tmpDir);
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    describe("createRun", () => {
-        it("creates runs/<id>/ with roadmap.md, state.md, delegations.md, gray-areas.md", async () => {
-            const run = await createRun(flowDir);
-            const runDir = path.join(flowDir, "runs", run.id);
-            const roadmap = await fs.stat(path.join(runDir, "roadmap.md"));
-            expect(roadmap.isFile()).toBe(true);
-            const state = await fs.stat(path.join(runDir, "state.md"));
-            expect(state.isFile()).toBe(true);
-            const delegations = await fs.stat(path.join(runDir, "delegations.md"));
-            expect(delegations.isFile()).toBe(true);
-            const grayAreas = await fs.stat(path.join(runDir, "gray-areas.md"));
-            expect(grayAreas.isFile()).toBe(true);
-        });
-        it("returns RunState with id matching Date.now().toString(36) + 4-char hex suffix", async () => {
-            const run = await createRun(flowDir);
-            // ID should be base36 timestamp (7-8 chars) + 4-char hex suffix
-            expect(run.id).toMatch(/^[a-z0-9]+[a-f0-9]{4}$/);
-            expect(run.id.length).toBeGreaterThanOrEqual(11);
-            expect(run.id.length).toBeLessThanOrEqual(13);
-        });
-        it("initializes state.md with Resume Digest and Experience Snapshot headings", async () => {
-            const run = await createRun(flowDir);
-            const stateContent = await fs.readFile(path.join(flowDir, "runs", run.id, "state.md"), "utf8");
-            expect(stateContent).toContain("## Resume Digest");
-            expect(stateContent).toContain("## Experience Snapshot");
-        });
-    });
-    describe("loadRun", () => {
-        it("reads all 4 files and returns RunState with SectionMaps", async () => {
-            const created = await createRun(flowDir);
-            const loaded = await loadRun(flowDir, created.id);
-            expect(loaded).not.toBeNull();
-            expect(loaded.id).toBe(created.id);
-            expect(loaded.state.sections).toBeInstanceOf(Map);
-            expect(loaded.roadmap.sections).toBeInstanceOf(Map);
-            expect(loaded.delegations.sections).toBeInstanceOf(Map);
-            expect(loaded.grayAreas.sections).toBeInstanceOf(Map);
-        });
-        it("returns null for non-existent run", async () => {
-            const result = await loadRun(flowDir, "nonexistent123");
-            expect(result).toBeNull();
-        });
-    });
-    describe("setActiveRunId / getActiveRunId", () => {
-        it("writes and reads active run ID from state.md", async () => {
-            const run = await createRun(flowDir);
-            await setActiveRunId(flowDir, run.id);
-            const activeId = await getActiveRunId(flowDir);
-            expect(activeId).toBe(run.id);
-        });
-        it("returns null when no active run is set", async () => {
-            const activeId = await getActiveRunId(flowDir);
-            expect(activeId).toBeNull();
-        });
-    });
-    describe("updateRunFile", () => {
-        it("writes atomically to runs/<runId>/<filename>", async () => {
-            const run = await createRun(flowDir);
-            const sections = parseSections("## Test\n\nupdated content");
-            await updateRunFile(flowDir, run.id, "roadmap.md", sections);
-            const content = await fs.readFile(path.join(flowDir, "runs", run.id, "roadmap.md"), "utf8");
-            expect(content).toContain("updated content");
-        });
-    });
-});
-//# sourceMappingURL=run-manager.test.js.map

package/dist/src/flow/__tests__/scaffold-checkpoint.test.d.ts

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