akemon 0.3.2 → 0.3.4

package/dist/engine-queue.test.js

@@ -1,99 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { EngineQueue } from "./engine-queue.js";
-// Helpers
-const tick = () => new Promise((r) => setImmediate(r));
-async function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-describe("EngineQueue", () => {
-    it("free slot: acquire resolves immediately and isBusy becomes true", async () => {
-        const q = new EngineQueue();
-        assert.equal(q.isBusy(), false);
-        await q.acquire("high", 1000);
-        assert.equal(q.isBusy(), true);
-        q.release();
-        assert.equal(q.isBusy(), false);
-    });
-    it("tryAcquire: succeeds when free, returns false when busy", () => {
-        const q = new EngineQueue();
-        assert.equal(q.tryAcquire(), true);
-        assert.equal(q.isBusy(), true);
-        assert.equal(q.tryAcquire(), false);
-        q.release();
-    });
-    it("priority ordering: high waiter beats normal when slot is released", async () => {
-        const q = new EngineQueue();
-        await q.acquire("high", 1000); // take the slot
-        const order = [];
-        const p1 = q.acquire("normal", 2000).then(() => { order.push("normal"); q.release(); });
-        await tick();
-        const p2 = q.acquire("high", 2000).then(() => { order.push("high"); q.release(); });
-        await tick();
-        assert.equal(q.queueDepth(), 2);
-        q.release(); // hand off to highest-priority waiter
-        await Promise.all([p1, p2]);
-        assert.deepEqual(order, ["high", "normal"]);
-    });
-    it("FIFO within same priority: earlier enqueuer wins", async () => {
-        const q = new EngineQueue();
-        await q.acquire("high", 1000);
-        const order = [];
-        const p1 = q.acquire("normal", 2000).then(() => { order.push("first"); q.release(); });
-        await sleep(5); // ensure different enqueuedAt timestamps
-        const p2 = q.acquire("normal", 2000).then(() => { order.push("second"); q.release(); });
-        await tick();
-        q.release();
-        await Promise.all([p1, p2]);
-        assert.deepEqual(order, ["first", "second"]);
-    });
-    it("deadline timeout: waiter is removed and rejects with busy-timeout error", async () => {
-        const q = new EngineQueue();
-        await q.acquire("high", 1000); // hold the slot
-        let caught = null;
-        const p = q.acquire("low", 30).catch((e) => { caught = e; });
-        await sleep(60); // let the 30ms deadline fire
-        assert.equal(q.queueDepth(), 0, "waiter must be removed after timeout");
-        await p;
-        assert.ok(caught !== null && typeof caught === "object", "should have rejected with an Error");
-        const msg = caught.message;
-        assert.ok(msg.includes("Engine busy timeout"), msg);
-        q.release();
-    });
-    it("release with no waiters makes slot free", () => {
-        const q = new EngineQueue();
-        assert.equal(q.tryAcquire(), true);
-        q.release();
-        assert.equal(q.isBusy(), false);
-        assert.equal(q.heldMs(), 0);
-    });
-    it("queueDepth tracks waiters correctly", async () => {
-        const q = new EngineQueue();
-        await q.acquire("high", 1000);
-        assert.equal(q.queueDepth(), 0);
-        const p1 = q.acquire("normal", 2000);
-        await tick();
-        assert.equal(q.queueDepth(), 1);
-        const p2 = q.acquire("low", 2000);
-        await tick();
-        assert.equal(q.queueDepth(), 2);
-        q.release(); // hand to normal (higher priority)
-        await tick();
-        assert.equal(q.queueDepth(), 1);
-        const holder = await p1; // p1 resolved — release it
-        void holder; // suppress unused warning
-        q.release();
-        await p2;
-        q.release();
-        assert.equal(q.queueDepth(), 0);
-    });
-    it("heldMs: returns 0 when free, positive when busy", async () => {
-        const q = new EngineQueue();
-        assert.equal(q.heldMs(), 0);
-        await q.acquire("high", 1000);
-        await sleep(10);
-        assert.ok(q.heldMs() >= 10, `heldMs should be >= 10, got ${q.heldMs()}`);
-        q.release();
-        assert.equal(q.heldMs(), 0);
-    });
-});

package/dist/engine-routing.test.js

@@ -1,122 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { resolveEngineConfig, deriveChildOrigin, downgradeForRetry, } from "./engine-routing.js";
-// ---------------------------------------------------------------------------
-// resolveEngineConfig
-// ---------------------------------------------------------------------------
-describe("resolveEngineConfig", () => {
-    const claudeEntry = { engine: "claude", model: "claude-opus-4-5" };
-    const rawEntry = { engine: "raw", rawApiUrl: "https://api.deepseek.com/v1", model: "deepseek-chat", rawApiKeyEnv: "DEEPSEEK_API_KEY" };
-    const defaultEntry = { engine: "raw", rawApiUrl: "https://api.anthropic.com/v1", model: "claude-haiku-4-5", rawApiKeyEnv: "ANTHROPIC_API_KEY" };
-    it("returns exact origin entry when routing has that origin", () => {
-        const routing = {
-            user_manual: claudeEntry,
-            platform: rawEntry,
-            default: defaultEntry,
-        };
-        const result = resolveEngineConfig(routing, "user_manual");
-        assert.deepEqual(result, claudeEntry);
-    });
-    it("returns platform entry for platform origin", () => {
-        const routing = {
-            user_manual: claudeEntry,
-            platform: rawEntry,
-            default: defaultEntry,
-        };
-        const result = resolveEngineConfig(routing, "platform");
-        assert.deepEqual(result, rawEntry);
-    });
-    it("falls back to default when origin not in routing", () => {
-        const routing = {
-            user_manual: claudeEntry,
-            default: defaultEntry,
-        };
-        // self_cycle not in routing → fallback to default
-        const result = resolveEngineConfig(routing, "self_cycle");
-        assert.deepEqual(result, defaultEntry);
-    });
-    it("falls back to default when origin is undefined", () => {
-        const routing = { default: defaultEntry };
-        const result = resolveEngineConfig(routing, undefined);
-        assert.deepEqual(result, defaultEntry);
-    });
-    it("returns null when routing is undefined (backward-compat: use base config)", () => {
-        const result = resolveEngineConfig(undefined, "user_manual");
-        assert.equal(result, null);
-    });
-    it("returns null when routing is null", () => {
-        const result = resolveEngineConfig(null, "user_manual");
-        assert.equal(result, null);
-    });
-    it("returns null when routing has no matching entry and no default", () => {
-        const routing = { user_manual: claudeEntry };
-        // self_cycle not in routing, no default
-        const result = resolveEngineConfig(routing, "self_cycle");
-        assert.equal(result, null);
-    });
-    it("returns null when routing is empty object and origin is undefined", () => {
-        const result = resolveEngineConfig({}, undefined);
-        assert.equal(result, null);
-    });
-    it("retry origin resolves to its own routing entry when configured", () => {
-        const retryEntry = { engine: "raw", rawApiUrl: "https://api.deepseek.com/v1", model: "deepseek-chat" };
-        const routing = {
-            user_manual: claudeEntry,
-            retry: retryEntry,
-            default: defaultEntry,
-        };
-        const result = resolveEngineConfig(routing, "retry");
-        assert.deepEqual(result, retryEntry);
-    });
-    it("retry origin falls back to default when no retry entry configured", () => {
-        const routing = {
-            user_manual: claudeEntry,
-            default: defaultEntry,
-        };
-        const result = resolveEngineConfig(routing, "retry");
-        assert.deepEqual(result, defaultEntry);
-    });
-    it("reflection origin resolves correctly", () => {
-        const reflEntry = { engine: "raw", model: "gemma3:4b" };
-        const routing = { reflection: reflEntry, default: defaultEntry };
-        const result = resolveEngineConfig(routing, "reflection");
-        assert.deepEqual(result, reflEntry);
-    });
-});
-// ---------------------------------------------------------------------------
-// downgradeForRetry
-// ---------------------------------------------------------------------------
-describe("downgradeForRetry", () => {
-    const origins = ["user_manual", "self_cycle", "platform", "retry", "reflection"];
-    it("always returns 'retry' regardless of input", () => {
-        for (const origin of origins) {
-            assert.equal(downgradeForRetry(origin), "retry", `downgradeForRetry(${origin}) should be 'retry'`);
-        }
-    });
-    it("user_manual + isRetry=true → 'retry' (not user_manual)", () => {
-        // This is the spec's explicit test case for the downgrade rule
-        const original = "user_manual";
-        const downgraded = downgradeForRetry(original);
-        assert.equal(downgraded, "retry");
-        assert.notEqual(downgraded, "user_manual");
-    });
-});
-// ---------------------------------------------------------------------------
-// deriveChildOrigin
-// ---------------------------------------------------------------------------
-describe("deriveChildOrigin", () => {
-    const origins = ["user_manual", "self_cycle", "platform", "retry", "reflection"];
-    it("always returns 'platform' regardless of parent", () => {
-        for (const origin of origins) {
-            assert.equal(deriveChildOrigin(origin), "platform", `deriveChildOrigin(${origin}) should be 'platform'`);
-        }
-    });
-    it("user_manual parent does NOT propagate to child (anti-contamination rule)", () => {
-        const child = deriveChildOrigin("user_manual");
-        assert.equal(child, "platform");
-        assert.notEqual(child, "user_manual");
-    });
-    it("self_cycle parent → child is platform, not self_cycle", () => {
-        assert.equal(deriveChildOrigin("self_cycle"), "platform");
-    });
-});

package/dist/engine-stream.test.js

@@ -1,103 +0,0 @@
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { describe, it } from "node:test";
-import { PassThrough } from "node:stream";
-import { EnginePeripheral } from "./engine-peripheral.js";
-function createFakeChild() {
-    const child = new EventEmitter();
-    child.stdin = new PassThrough();
-    child.stdout = new PassThrough();
-    child.stderr = new PassThrough();
-    Object.defineProperty(child, "pid", { value: 12345, configurable: true });
-    child.unref = () => child;
-    return child;
-}
-describe("Engine stream publish", () => {
-    it("publishes task lifecycle and stdout/stderr chunks", async () => {
-        const events = [];
-        let spawnedChild = null;
-        const engine = new EnginePeripheral({
-            engine: "claude",
-            workdir: "/tmp",
-            spawnImpl: ((cmd, args) => {
-                assert.equal(cmd, "claude");
-                assert.deepEqual(args, ["--print"]);
-                const child = createFakeChild();
-                spawnedChild = child;
-                queueMicrotask(() => {
-                    child.stdout?.emit("data", Buffer.from("hello "));
-                    child.stderr?.emit("data", Buffer.from("warn"));
-                    child.stdout?.emit("data", Buffer.from("world"));
-                    child.emit("close", 0, null);
-                });
-                return child;
-            }),
-            taskRelay: {
-                sendTaskStart(taskId, origin, cmd) {
-                    events.push({ type: "start", taskId, origin, cmd });
-                },
-                sendTaskStream(taskId, stream, chunk) {
-                    events.push({ type: "stream", taskId, stream, chunk });
-                },
-                sendTaskEnd(taskId, exitCode, durationMs) {
-                    events.push({ type: "end", taskId, exitCode, durationMs });
-                },
-            },
-        });
-        const result = await engine.runEngine("say hello", false, undefined, undefined, "user_manual", undefined, "order-123");
-        assert.equal(result, "hello world");
-        assert.ok(spawnedChild, "spawn should be called");
-        assert.deepEqual(events.slice(0, 4), [
-            { type: "start", taskId: "order-123", origin: "user_manual", cmd: "claude --print" },
-            { type: "stream", taskId: "order-123", stream: "stdout", chunk: "hello " },
-            { type: "stream", taskId: "order-123", stream: "stderr", chunk: "warn" },
-            { type: "stream", taskId: "order-123", stream: "stdout", chunk: "world" },
-        ]);
-        const end = events[4];
-        assert.equal(end?.type, "end");
-        if (end?.type === "end") {
-            assert.equal(end.taskId, "order-123");
-            assert.equal(end.exitCode, 0);
-            assert.ok(end.durationMs >= 0);
-        }
-    });
-    it("generates a task id when caller does not provide one", async () => {
-        const events = [];
-        const engine = new EnginePeripheral({
-            engine: "opencode",
-            workdir: "/tmp",
-            spawnImpl: (() => {
-                const child = createFakeChild();
-                queueMicrotask(() => {
-                    child.stdout?.emit("data", Buffer.from("done"));
-                    child.emit("close", 0, null);
-                });
-                return child;
-            }),
-            taskRelay: {
-                sendTaskStart(taskId, origin, cmd) {
-                    events.push({ type: "start", taskId, origin, cmd });
-                },
-                sendTaskStream(taskId, stream, chunk) {
-                    events.push({ type: "stream", taskId, stream, chunk });
-                },
-                sendTaskEnd(taskId, exitCode, durationMs) {
-                    events.push({ type: "end", taskId, exitCode, durationMs });
-                },
-            },
-        });
-        const result = await engine.runEngine("say hello", false, undefined, undefined, "platform");
-        assert.equal(result, "done");
-        assert.equal(events[0]?.type, "start");
-        if (events[0]?.type === "start") {
-            assert.match(events[0].taskId, /^task_/);
-            assert.equal(events[0].origin, "platform");
-            assert.equal(events[0].cmd, "opencode run say hello");
-        }
-        assert.equal(events[2]?.type, "end");
-        if (events[2]?.type === "end" && events[0]?.type === "start") {
-            assert.equal(events[2].taskId, events[0].taskId);
-            assert.equal(events[2].exitCode, 0);
-        }
-    });
-});

package/dist/event-bus.test.js

@@ -1,51 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, readFile, appendFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { FileEventLog, PersistentEventBus } from "./event-bus.js";
-import { SIG, sig } from "./types.js";
-describe("PersistentEventBus", () => {
-    let tmpDir;
-    beforeEach(async () => {
-        tmpDir = await mkdtemp(join(tmpdir(), "akemon-event-bus-"));
-    });
-    afterEach(async () => {
-        await rm(tmpDir, { recursive: true, force: true });
-    });
-    it("appends emitted events and still dispatches handlers", async () => {
-        const path = join(tmpDir, "events.jsonl");
-        const bus = new PersistentEventBus(new FileEventLog(path));
-        const seen = [];
-        bus.on(SIG.AGENT_START, (signal) => {
-            seen.push(String(signal.data.agentName));
-        });
-        bus.emit(SIG.AGENT_START, sig(SIG.AGENT_START, { agentName: "momo" }, "test"));
-        assert.deepEqual(seen, ["momo"]);
-        const lines = (await readFile(path, "utf-8")).trim().split("\n");
-        assert.equal(lines.length, 1);
-        const logged = JSON.parse(lines[0]);
-        assert.equal(logged.e, SIG.AGENT_START);
-        assert.equal(logged.s.type, SIG.AGENT_START);
-        assert.equal(logged.s.data.agentName, "momo");
-        assert.equal(logged.s.source, "test");
-    });
-    it("recovers valid logged events without appending duplicates", async () => {
-        const path = join(tmpDir, "events.jsonl");
-        await appendFile(path, JSON.stringify({
-            e: "custom:event",
-            s: { type: "custom:event", data: { n: 1 }, source: "fixture" },
-        }) + "\n");
-        await appendFile(path, "not-json\n");
-        const bus = new PersistentEventBus(new FileEventLog(path));
-        const seen = [];
-        bus.on("custom:event", (signal) => {
-            seen.push(Number(signal.data.n));
-        });
-        const count = await bus.recover();
-        assert.equal(count, 1);
-        assert.deepEqual(seen, [1]);
-        const lines = (await readFile(path, "utf-8")).trim().split("\n");
-        assert.equal(lines.length, 2);
-    });
-});

package/dist/orphan-scan.test.js

@@ -1,81 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseProcessList } from "./orphan-scan.js";
-describe("parseProcessList", () => {
-    it("empty string returns empty array", () => {
-        assert.deepStrictEqual(parseProcessList(""), []);
-    });
-    it("whitespace-only string returns empty array", () => {
-        assert.deepStrictEqual(parseProcessList("\n\n  \n"), []);
-    });
-    it("header line (PID PPID COMMAND) is silently skipped", () => {
-        const output = "  PID  PPID COMMAND\n  123     1 opencode run --flag\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].pid, 123);
-    });
-    it("ppid=1 + command matches 'opencode run' → hit", () => {
-        const output = "  123     1 opencode run --headless\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].pid, 123);
-        assert.strictEqual(result[0].ppid, 1);
-        assert.ok(result[0].command.includes("opencode run"));
-    });
-    it("ppid=1 + command is 'opencode install' → not hit (install is not agent mode)", () => {
-        const output = "  456     1 opencode install some-plugin\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 0);
-    });
-    it("ppid=1 + command is 'opencode update' → not hit", () => {
-        const output = "  789     1 opencode update\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 0);
-    });
-    it("ppid != 1 but command matches → not hit (never kill non-orphans)", () => {
-        const output = "  999  5678 opencode run --headless\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 0);
-    });
-    it("ppid=1 + 'claude -p' → hit", () => {
-        const output = "  100     1 claude -p some prompt text\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].pid, 100);
-    });
-    it("ppid=1 + 'codex exec' → hit", () => {
-        const output = "  200     1 codex exec --flag\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-    });
-    it("ppid=1 + 'gemini -p' → hit", () => {
-        const output = "  300     1 gemini -p --output-format json\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-    });
-    it("command with full path still matches", () => {
-        const output = "  400     1 /usr/local/bin/opencode run --headless task\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].pid, 400);
-    });
-    it("multiple orphans parsed correctly, non-orphan interleaved is skipped", () => {
-        const output = [
-            "  PID  PPID COMMAND",
-            "  111     1 opencode run",
-            "  222  3456 opencode run", // ppid != 1, not orphan
-            "  333     1 claude -p task",
-            "  444     1 bash", // not a known pattern
-        ].join("\n");
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 2);
-        assert.strictEqual(result[0].pid, 111);
-        assert.strictEqual(result[1].pid, 333);
-    });
-    it("large PID and PPID values parse correctly", () => {
-        const output = "  99999     1 opencode run\n";
-        const result = parseProcessList(output);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].pid, 99999);
-    });
-});

package/dist/reflection-module.integration.test.js

@@ -1,180 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { ReflectionModule } from "./reflection-module.js";
-import { loadDiscoveries } from "./self.js";
-import { SIG } from "./types.js";
-// ---------------------------------------------------------------------------
-// Fake helpers
-// ---------------------------------------------------------------------------
-class FakeBus {
-    handlers = new Map();
-    emitted = [];
-    on(event, fn) {
-        const arr = this.handlers.get(event) ?? [];
-        arr.push(fn);
-        this.handlers.set(event, arr);
-    }
-    off(event, fn) {
-        const arr = this.handlers.get(event) ?? [];
-        this.handlers.set(event, arr.filter(h => h !== fn));
-    }
-    emit(event, s) {
-        this.emitted.push(s);
-        (this.handlers.get(event) ?? []).forEach(fn => fn(s));
-    }
-}
-function makeCtx(workdir, agentName, bus, computeResponses) {
-    let callIdx = 0;
-    const computeCalls = [];
-    const ctx = {
-        workdir,
-        agentName,
-        bus,
-        requestCompute: async (req) => {
-            computeCalls.push({ context: req.context, question: req.question, priority: req.priority });
-            return (computeResponses[callIdx++] ?? { success: false });
-        },
-        getPeripherals: (_capability) => [],
-        sendTo: async (_capability, _signal) => null,
-        getPromptContributions: () => [],
-    };
-    return { ctx, computeCalls };
-}
-/** Drain pending microtasks + I/O by waiting n setImmediate ticks. */
-async function flush(n = 8) {
-    for (let i = 0; i < n; i++) {
-        await new Promise(r => setImmediate(r));
-    }
-}
-/** Wait ms milliseconds — for fire-and-forget chains with multiple sequential I/O steps. */
-function wait(ms) {
-    return new Promise(r => setTimeout(r, ms));
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("ReflectionModule reflect integration", () => {
-    it("self_cycle=false → start does not schedule reflect, stop does not throw", async () => {
-        const tmpDir = await mkdtemp(join(tmpdir(), "akemon-refl-"));
-        try {
-            const agentName = "test-agent";
-            const agentDir = join(tmpDir, ".akemon", "agents", agentName);
-            await mkdir(agentDir, { recursive: true });
-            await writeFile(join(agentDir, "config.json"), JSON.stringify({ self_cycle: false }));
-            const bus = new FakeBus();
-            const { ctx, computeCalls } = makeCtx(tmpDir, agentName, bus, []);
-            const mod = new ReflectionModule();
-            await mod.start(ctx);
-            await flush();
-            assert.strictEqual(computeCalls.length, 0, "no compute calls expected when self_cycle=false");
-            await assert.doesNotReject(() => mod.stop());
-        }
-        finally {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it("single TASK_FAILED does not trigger reflect (below threshold of 2)", async () => {
-        const tmpDir = await mkdtemp(join(tmpdir(), "akemon-refl-"));
-        try {
-            const agentName = "test-agent";
-            const bus = new FakeBus();
-            const { ctx, computeCalls } = makeCtx(tmpDir, agentName, bus, []);
-            const mod = new ReflectionModule();
-            await mod.start(ctx);
-            bus.emit(SIG.TASK_FAILED, { type: SIG.TASK_FAILED, data: { taskLabel: "a", error: "oops" } });
-            await flush();
-            assert.strictEqual(computeCalls.length, 0, "one failure must not trigger reflect");
-            await mod.stop();
-        }
-        finally {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it("two TASK_FAILED events trigger reflect and save discoveries to disk", async () => {
-        const tmpDir = await mkdtemp(join(tmpdir(), "akemon-refl-"));
-        try {
-            const agentName = "test-agent";
-            // Self dir must exist for saveDiscoveries to write successfully
-            await mkdir(join(tmpDir, ".akemon", "agents", agentName, "self"), { recursive: true });
-            const bus = new FakeBus();
-            const response = JSON.stringify({
-                discoveries: [{ capability: "X", confidence: 0.7, evidence: "Y" }],
-            });
-            const { ctx, computeCalls } = makeCtx(tmpDir, agentName, bus, [
-                { success: true, response },
-            ]);
-            const mod = new ReflectionModule();
-            await mod.start(ctx);
-            bus.emit(SIG.TASK_FAILED, { type: SIG.TASK_FAILED, data: { taskLabel: "task1", error: "err1" } });
-            bus.emit(SIG.TASK_FAILED, { type: SIG.TASK_FAILED, data: { taskLabel: "task2", error: "err2" } });
-            await flush();
-            assert.strictEqual(computeCalls.length, 1, "reflect should call requestCompute exactly once");
-            const discoveries = await loadDiscoveries(tmpDir, agentName);
-            assert.ok(discoveries.length > 0, "at least one discovery should be saved");
-            assert.ok(discoveries.some(d => d.capability === "X"), "saved discovery should have capability='X'");
-            await mod.stop();
-        }
-        finally {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it("unparseable compute response → no crash, recentFailures cleared, no discoveries saved", async () => {
-        const tmpDir = await mkdtemp(join(tmpdir(), "akemon-refl-"));
-        try {
-            const agentName = "test-agent";
-            const bus = new FakeBus();
-            const { ctx, computeCalls } = makeCtx(tmpDir, agentName, bus, [
-                { success: true, response: "this is not json at all" },
-            ]);
-            const mod = new ReflectionModule();
-            await mod.start(ctx);
-            bus.emit(SIG.TASK_FAILED, { type: SIG.TASK_FAILED, data: { taskLabel: "x1", error: "e1" } });
-            bus.emit(SIG.TASK_FAILED, { type: SIG.TASK_FAILED, data: { taskLabel: "x2", error: "e2" } });
-            await flush();
-            assert.strictEqual(computeCalls.length, 1, "reflect should still have run");
-            const state = mod.getState();
-            assert.strictEqual(state["recentFailures"], 0, "recentFailures should be cleared even when response is unparseable");
-            const discoveries = await loadDiscoveries(tmpDir, agentName);
-            assert.strictEqual(discoveries.length, 0, "no discoveries should be saved for bad response");
-            await mod.stop();
-        }
-        finally {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it("TASK_COMPLETED with success=true and productName appends experience to playbook", async () => {
-        const tmpDir = await mkdtemp(join(tmpdir(), "akemon-refl-"));
-        try {
-            const agentName = "test-agent";
-            const selfBase = join(tmpDir, ".akemon", "agents", agentName, "self");
-            const pbDir = join(selfBase, "playbooks");
-            const prodDir = join(selfBase, "products");
-            await mkdir(pbDir, { recursive: true });
-            await mkdir(prodDir, { recursive: true });
-            await writeFile(join(prodDir, "widget.md"), "# Widget\n\n## playbook\nwidget-pb\n\n## products\n- p_w1\n");
-            await writeFile(join(pbDir, "widget-pb.md"), "# Widget Playbook\n\n## 经验\n");
-            const bus = new FakeBus();
-            const { ctx } = makeCtx(tmpDir, agentName, bus, []);
-            const mod = new ReflectionModule();
-            await mod.start(ctx);
-            bus.emit(SIG.TASK_COMPLETED, {
-                type: SIG.TASK_COMPLETED,
-                data: { success: true, productName: "widget", taskLabel: "deliver-logo", creditsEarned: 3 },
-            });
-            // Fire-and-forget handler — appendPlaybookExperience chains several sequential I/O ops
-            // (readdir + readFile per directory in loadMdFiles). Use a time-based wait to be safe.
-            await wait(100);
-            const content = await readFile(join(pbDir, "widget-pb.md"), "utf-8");
-            assert.ok(content.includes("widget"), "playbook should contain productName");
-            assert.ok(content.includes("deliver-logo"), "playbook should contain taskLabel");
-            assert.ok(content.includes("earned 3¢"), "playbook should contain credits");
-            await mod.stop();
-        }
-        finally {
-            await rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});