chapterhouse 0.13.1 → 0.14.1

package/dist/memory/eot.test.js

@@ -1,949 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-import { resetSingletons } from "../test/helpers/reset-singletons.js";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `memory-eot-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
-    const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
-    const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, eotModule, agentsModule };
-}
-async function loadModulesWithWarnSpy(t, cacheBust) {
-    const warnings = [];
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            childLogger: () => ({
-                info: () => { },
-                warn: (...args) => {
-                    warnings.push(args);
-                },
-                error: () => { },
-            }),
-        },
-    });
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
-    const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, eotModule, warnings };
-}
-function getFunction(module, name) {
-    const value = module[name];
-    assert.equal(typeof value, "function", `expected ${name} to be exported`);
-    return value;
-}
-test.beforeEach(() => {
-    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-    delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
-    delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    resetSandbox();
-    resetSingletons();
-});
-test.after(() => {
-    delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
-    delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    resetSingletons();
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED=0", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED = "0";
-    const { dbModule, memoryModule, eotModule } = await loadModules("disabled");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-001', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Disabled hooks must not persist memory." },
-        confidence: 0.8,
-    }));
-    let llmCalls = 0;
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-001",
-        finalResult: "done",
-        copilotClient: {},
-        callLLM: async () => {
-            llmCalls++;
-            return JSON.stringify({ decisions: [] });
-        },
-    });
-    assert.equal(llmCalls, 0);
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Disabled hooks must not persist memory."), false);
-    const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
-    assert.equal(row.status, "pending");
-});
-test("runEndOfTaskMemoryHook accepts matching proposals, rejects others from the same task, and emits a structured summary", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("accept");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const acceptedInsert = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-accept', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "End-of-task review should remember durable findings." },
-        confidence: 0.9,
-    }));
-    const rejectedInsert = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-accept', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Ephemeral shell chatter should be discarded." },
-        confidence: 0.4,
-    }));
-    db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-other', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Other task proposals must stay untouched." },
-        confidence: 0.8,
-    }));
-    const summaries = [];
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-accept",
-        finalResult: "Completed the feature and found one durable design note.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [
-                {
-                    proposal_id: Number(acceptedInsert.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Durable implementation guidance.",
-                },
-                {
-                    proposal_id: Number(rejectedInsert.lastInsertRowid),
-                    decision: "reject",
-                    reason: "Ephemeral output.",
-                },
-            ],
-            implicit_memories: [],
-        }),
-        onProcessed: (summary) => {
-            summaries.push(summary);
-        },
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "End-of-task review should remember durable findings."), true);
-    const acceptedRow = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(acceptedInsert.lastInsertRowid));
-    const rejectedRow = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(rejectedInsert.lastInsertRowid));
-    const untouchedRow = db.prepare(`
-    SELECT status
-    FROM mem_inbox
-    WHERE source_task_id = 'task-other'
-  `).get();
-    assert.equal(acceptedRow.status, "accepted");
-    assert.equal(acceptedRow.resolution_reason, "Durable implementation guidance.");
-    assert.equal(rejectedRow.status, "rejected");
-    assert.equal(rejectedRow.resolution_reason, "Ephemeral output.");
-    assert.equal(untouchedRow.status, "pending");
-    assert.deepEqual(summaries, [{
-            task_id: "task-eot-accept",
-            proposals_total: 2,
-            accepted: 1,
-            rejected: 1,
-            implicit_extracted: 0,
-            auto_accept: true,
-        }]);
-});
-test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-accept");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "action_item",
-        payload: {
-            title: "Migrate feature ideas",
-            detail: "Move feature-ideas.md into mem_action_items.",
-        },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-action-item",
-        finalResult: "Completed and proposed a follow-up action item.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Concrete follow-up.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    const actionItems = listActionItems({ scope_id: chapterhouse.id });
-    const actionItem = actionItems.find((item) => item.title === "Migrate feature ideas");
-    assert.ok(actionItem);
-    assert.equal(actionItem.detail, "Move feature-ideas.md into mem_action_items.");
-    assert.equal(actionItem.status, "open");
-    assert.equal(actionItem.source, "subagent_proposal:coder");
-    const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
-    assert.equal(inbox.status, "accepted");
-});
-test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear reason", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-invalid");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-invalid', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "action_item",
-        payload: {
-            detail: "A title is required before this can become an action item.",
-        },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-action-item-invalid",
-        finalResult: "Completed and proposed a malformed follow-up.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Concrete follow-up.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
-    const inbox = db.prepare(`
-    SELECT status, resolution_reason, resolved_at
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    assert.equal(inbox.status, "rejected");
-    assert.match(inbox.resolution_reason ?? "", /title/i);
-    assert.ok(inbox.resolved_at);
-});
-async function runAcceptedObservationHookScenario(t, cacheBust, taskId, payload) {
-    const warnings = [];
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            childLogger: () => ({
-                info: () => { },
-                warn: (obj, msg) => warnings.push({ obj, msg }),
-                error: () => { },
-            }),
-        },
-    });
-    const { dbModule, memoryModule, eotModule } = await loadModules(cacheBust);
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const before = listObservations({ scope_id: chapterhouse.id });
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', ?, 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload,
-        confidence: 0.9,
-    }), taskId);
-    await runEndOfTaskMemoryHook({
-        taskId,
-        finalResult: "Completed and reviewed an observation proposal.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Durable finding.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    const inbox = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    return {
-        beforeCount: before.length,
-        after: listObservations({ scope_id: chapterhouse.id }),
-        warnings,
-        inbox,
-    };
-}
-test("runEndOfTaskMemoryHook skips accepted observation proposals with null content and warns", async (t) => {
-    const result = await runAcceptedObservationHookScenario(t, "observation-null-content", "task-eot-observation-null-content", { content: null });
-    assert.equal(result.after.length, result.beforeCount);
-    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
-    assert.equal(result.inbox.status, "accepted");
-    assert.equal(result.inbox.resolution_reason, "Durable finding.");
-    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
-});
-test("runEndOfTaskMemoryHook skips accepted observation proposals with undefined content and warns", async (t) => {
-    const result = await runAcceptedObservationHookScenario(t, "observation-undefined-content", "task-eot-observation-undefined-content", {});
-    assert.equal(result.after.length, result.beforeCount);
-    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
-    assert.equal(result.inbox.status, "accepted");
-    assert.equal(result.inbox.resolution_reason, "Durable finding.");
-    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
-});
-test("runEndOfTaskMemoryHook skips accepted observation proposals with empty string content and warns", async (t) => {
-    const result = await runAcceptedObservationHookScenario(t, "observation-empty-string-content", "task-eot-observation-empty-string-content", { content: "" });
-    assert.equal(result.after.length, result.beforeCount);
-    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
-    assert.equal(result.inbox.status, "accepted");
-    assert.equal(result.inbox.resolution_reason, "Durable finding.");
-    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
-});
-test("runEndOfTaskMemoryHook skips accepted observation proposals with whitespace-only content and warns", async (t) => {
-    const result = await runAcceptedObservationHookScenario(t, "observation-whitespace-content", "task-eot-observation-whitespace-content", { content: "   " });
-    assert.equal(result.after.length, result.beforeCount);
-    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
-    assert.equal(result.inbox.status, "accepted");
-    assert.equal(result.inbox.resolution_reason, "Durable finding.");
-    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
-});
-test("runEndOfTaskMemoryHook inserts accepted observation proposals with valid content", async (t) => {
-    const result = await runAcceptedObservationHookScenario(t, "observation-valid-content", "task-eot-observation-valid-content", { content: " Durable finding from the task. " });
-    assert.equal(result.after.length, result.beforeCount + 1);
-    assert.ok(result.after.some((row) => row.content === "Durable finding from the task."));
-    assert.equal(result.inbox.status, "accepted");
-    assert.equal(result.inbox.resolution_reason, "Durable finding.");
-    assert.equal(result.warnings.length, 0);
-});
-test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-ambiguous-entity', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "action_item",
-        payload: {
-            title: "Resolve ambiguous entity link",
-            entity_id: 1,
-            entity_name: "Bellonda",
-            entity_kind: "agent",
-        },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-action-item-ambiguous-entity",
-        finalResult: "Completed and proposed an ambiguous follow-up.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Concrete follow-up.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
-    const inbox = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    assert.equal(inbox.status, "rejected");
-    assert.match(inbox.resolution_reason ?? "", /entity_id.*entity_name|entity_name.*entity_id/i);
-});
-test("runEndOfTaskMemoryHook falls back to the source agent bound scope for action_item proposals without scope_slug", async () => {
-    const home = process.env.CHAPTERHOUSE_HOME;
-    assert.ok(home, "test home should be set");
-    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
-    mkdirSync(agentsDir, { recursive: true });
-    writeFileSync(join(agentsDir, "bellonda.agent.md"), [
-        "---",
-        "name: Bellonda",
-        "description: Mentat of the infrastructure domain",
-        "model: claude-sonnet-4.6",
-        "persistent: true",
-        "scope: infra",
-        "---",
-        "",
-        "You are Bellonda.",
-    ].join("\n"));
-    const { dbModule, memoryModule, eotModule, agentsModule } = await loadModules("action-item-bound-scope");
-    agentsModule.loadAgents();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const createScope = getFunction(memoryModule, "createScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    const infra = createScope({
-        slug: "infra",
-        title: "Infra",
-        description: "Infra test scope",
-        keywords: ["infra"],
-    });
-    assert.ok(chapterhouse);
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'bellonda', 'task-eot-action-item-bound-scope', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "action_item",
-        payload: {
-            title: "Review NAS disk alerts",
-        },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-action-item-bound-scope",
-        finalResult: "Bellonda proposed an infra follow-up.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Concrete infra follow-up.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    assert.equal(listActionItems({ scope_id: infra.id }).some((item) => item.title === "Review NAS disk alerts"), true);
-    assert.equal(listActionItems({ scope_id: chapterhouse.id }).some((item) => item.title === "Review NAS disk alerts"), false);
-});
-test("runEndOfTaskMemoryHook still accepts observation, decision, and entity proposals", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("existing-proposal-kinds");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const listDecisions = getFunction(memoryModule, "listDecisions");
-    const listEntities = getFunction(memoryModule, "listEntities");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const proposals = [
-        { kind: "observation", payload: { content: "Existing observation proposals still persist." } },
-        { kind: "decision", payload: { title: "Keep auto-accept", rationale: "It is required for EOT memory promotion." } },
-        { kind: "entity", payload: { name: "Bellonda", entity_kind: "agent", summary: "Infrastructure mentat." } },
-    ].map((envelope) => db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-existing-kinds', 'pending')
-  `).run(chapterhouse.id, JSON.stringify(envelope)));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-existing-kinds",
-        finalResult: "Completed with several proposal kinds.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: proposals.map((proposal) => ({
-                proposal_id: Number(proposal.lastInsertRowid),
-                decision: "accept",
-                reason: "Valid durable memory.",
-            })),
-            implicit_memories: [],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Existing observation proposals still persist."), true);
-    assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Keep auto-accept" && row.rationale === "It is required for EOT memory promotion."), true);
-    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "agent" }).some((row) => row.name === "Bellonda"), true);
-});
-test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listEntities = getFunction(memoryModule, "listEntities");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-entity', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "entity",
-        payload: {
-            name: "truenas",
-            entity_kind: "host",
-            summary: "NAS host used by Bellonda.",
-        },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-entity",
-        finalResult: "Completed and proposed a durable host entity.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Durable entity.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
-    assert.equal(entities.some((entity) => entity.name === "truenas"
-        && entity.kind === "host"
-        && entity.summary === "NAS host used by Bellonda."), true);
-    const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
-    assert.equal(inbox.status, "accepted");
-});
-test("runEndOfTaskMemoryHook leaves reviewed proposals pending when CHAPTERHOUSE_MEMORY_AUTO_ACCEPT=0", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT = "0";
-    const { dbModule, memoryModule, eotModule } = await loadModules("pending");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-pending', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Review can approve this, but auto-accept is disabled." },
-        confidence: 0.9,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-pending",
-        finalResult: "done",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Looks durable.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Review can approve this, but auto-accept is disabled."), false);
-    const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
-    assert.equal(row.status, "pending");
-});
-test("runEndOfTaskMemoryHook rejects pending same-task proposals omitted by the reviewer", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("omitted");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-omitted', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Reviewer omissions should not silently leave proposals pending." },
-        confidence: 0.6,
-    }));
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-omitted",
-        finalResult: "done",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Reviewer omissions should not silently leave proposals pending."), false);
-    const row = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    assert.equal(row.status, "rejected");
-    assert.match(row.resolution_reason ?? "", /did not select/i);
-});
-test("runEndOfTaskMemoryHook can persist implicit extracted memories that were not explicitly proposed", async () => {
-    const { memoryModule, eotModule } = await loadModules("implicit");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const summaries = [];
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit",
-        finalResult: "The subagent discovered a durable constraint while finishing the task.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "observation",
-                    scope_slug: "chapterhouse",
-                    payload: {
-                        content: "The end-of-task reviewer can persist implicit durable findings from a subagent summary.",
-                        source: "implicit-extraction",
-                    },
-                }],
-        }),
-        onProcessed: (summary) => {
-            summaries.push(summary);
-        },
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "The end-of-task reviewer can persist implicit durable findings from a subagent summary."), true);
-    assert.deepEqual(summaries, [{
-            task_id: "task-eot-implicit",
-            proposals_total: 0,
-            accepted: 0,
-            rejected: 0,
-            implicit_extracted: 1,
-            auto_accept: true,
-        }]);
-});
-test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind", async () => {
-    const { memoryModule, eotModule } = await loadModules("implicit-entity");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listEntities = getFunction(memoryModule, "listEntities");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit-entity",
-        finalResult: "The subagent discovered a durable host entity while finishing the task.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "entity",
-                    scope_slug: "chapterhouse",
-                    payload: {
-                        name: "synology",
-                        entity_kind: "host",
-                        summary: "NAS host used by Bellonda.",
-                    },
-                }],
-        }),
-    });
-    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
-    assert.equal(entities.some((entity) => entity.name === "synology"
-        && entity.kind === "host"
-        && entity.summary === "NAS host used by Bellonda."), true);
-});
-test("runEndOfTaskMemoryHook skips implicit observation memories with null content and warns", async (t) => {
-    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-null-content");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit-null",
-        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "observation",
-                    scope_slug: "chapterhouse",
-                    payload: {
-                        content: null,
-                    },
-                }],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
-    assert.equal(summary.implicit_extracted, 0);
-    assert.equal(warnings.length, 1);
-});
-test("runEndOfTaskMemoryHook skips implicit observation memories with undefined content and warns", async (t) => {
-    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-undefined-content");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit-undefined",
-        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "observation",
-                    scope_slug: "chapterhouse",
-                    payload: {},
-                }],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
-    assert.equal(summary.implicit_extracted, 0);
-    assert.equal(warnings.length, 1);
-});
-test("runEndOfTaskMemoryHook skips implicit observation memories with empty content and warns", async (t) => {
-    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-empty-content");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit-empty",
-        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "observation",
-                    scope_slug: "chapterhouse",
-                    payload: {
-                        content: "   ",
-                    },
-                }],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
-    assert.equal(summary.implicit_extracted, 0);
-    assert.equal(warnings.length, 1);
-});
-test("runEndOfTaskMemoryHook persists implicit observation memories with valid content", async (t) => {
-    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-valid-content");
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-implicit-valid",
-        finalResult: "The reviewer discovered a valid durable memory.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [],
-            implicit_memories: [{
-                    kind: "observation",
-                    scope_slug: "chapterhouse",
-                    payload: {
-                        content: "A valid implicit memory should still be stored.",
-                    },
-                }],
-        }),
-    });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "A valid implicit memory should still be stored."), true);
-    assert.equal(summary.implicit_extracted, 1);
-    assert.equal(warnings.length, 0);
-});
-test("runEndOfTaskMemoryHook treats malformed reviewer JSON as an empty review and warns", async (t) => {
-    const { dbModule, memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "reviewer-malformed-json");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-reviewer-malformed-json', 'pending')
-  `).run(chapterhouse.id, JSON.stringify({
-        kind: "observation",
-        payload: { content: "Malformed reviewer JSON must not crash the hook." },
-        confidence: 0.9,
-    }));
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-reviewer-malformed-json",
-        finalResult: "The reviewer returned malformed JSON, so the hook should fail closed and continue.",
-        copilotClient: {},
-        callLLM: async () => "{ definitely-not-json",
-    });
-    const inbox = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    assert.equal(summary.accepted, 0);
-    assert.equal(summary.rejected, 1);
-    assert.equal(inbox.status, "rejected");
-    assert.match(inbox.resolution_reason ?? "", /reviewer did not select/i);
-    assert.equal(warnings.length, 1);
-});
-test("runEndOfTaskMemoryHook rejects malformed accepted proposal payload JSON and warns", async (t) => {
-    const { dbModule, memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "proposal-malformed-json");
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const beforeCount = listObservations({ scope_id: chapterhouse.id }).length;
-    const inserted = db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
-    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-proposal-malformed-json', 'pending')
-  `).run(chapterhouse.id, "{ definitely-not-json");
-    const summary = await runEndOfTaskMemoryHook({
-        taskId: "task-eot-proposal-malformed-json",
-        finalResult: "The accepted proposal payload is malformed JSON, so the hook should reject it safely.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            decisions: [{
-                    proposal_id: Number(inserted.lastInsertRowid),
-                    decision: "accept",
-                    reason: "Looks durable.",
-                }],
-            implicit_memories: [],
-        }),
-    });
-    const inbox = db.prepare(`
-    SELECT status, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(Number(inserted.lastInsertRowid));
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, beforeCount);
-    assert.equal(summary.accepted, 0);
-    assert.equal(summary.rejected, 1);
-    assert.equal(inbox.status, "rejected");
-    assert.match(inbox.resolution_reason ?? "", /malformed/i);
-    assert.equal(warnings.length, 1);
-});
-test("runFrictionHook does nothing by default when CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED is unset", async () => {
-    const { eotModule } = await loadModules("friction-disabled-default");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    let llmCalls = 0;
-    await runFrictionHook({
-        taskId: "task-friction-disabled-default",
-        finalResult: "A substantive final result that is definitely longer than one hundred characters to prove the friction hook still stays off by default.",
-        copilotClient: {},
-        callLLM: async () => {
-            llmCalls++;
-            return "[]";
-        },
-    });
-    assert.equal(llmCalls, 0);
-});
-test("runFrictionHook skips short final results even when enabled", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
-    const { eotModule } = await loadModules("friction-short-result");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    let llmCalls = 0;
-    await runFrictionHook({
-        taskId: "task-friction-short-result",
-        finalResult: "too short",
-        copilotClient: {},
-        callLLM: async () => {
-            llmCalls++;
-            return "[]";
-        },
-    });
-    assert.equal(llmCalls, 0);
-});
-test("runFrictionHook records action items when enabled and the task result is substantive", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
-    const { memoryModule, eotModule } = await loadModules("friction-records-action-items");
-    const getScope = getFunction(memoryModule, "getScope");
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    setActiveScope("chapterhouse");
-    await runFrictionHook({
-        taskId: "task-friction-records-action-items",
-        finalResult: "The agent had to retry the same command several times because the tool returned a generic error with no validation detail, which made the task materially slower and harder to finish cleanly.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify([
-            {
-                title: "Improve validation feedback for memory tools",
-                detail: "Return the rejected field name and allowed values instead of a generic failure.",
-                source: "eot:friction",
-            },
-        ]),
-    });
-    const actionItems = listActionItems({ scope_id: chapterhouse.id });
-    assert.equal(actionItems.length, 1);
-    assert.equal(actionItems[0]?.title, "Improve validation feedback for memory tools");
-    assert.equal(actionItems[0]?.detail, "Return the rejected field name and allowed values instead of a generic failure.");
-    assert.equal(actionItems[0]?.source, "eot:friction");
-    assert.equal(actionItems[0]?.status, "open");
-});
-test("runFrictionHook caps parsed friction items at 3", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
-    const { memoryModule, eotModule } = await loadModules("friction-cap");
-    const getScope = getFunction(memoryModule, "getScope");
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    setActiveScope("chapterhouse");
-    await runFrictionHook({
-        taskId: "task-friction-cap",
-        finalResult: "The toolchain created several distinct sources of friction across the task, and the result is long enough that the friction hook should inspect it and write only the first three issues back into memory.",
-        copilotClient: {},
-        callLLM: async () => JSON.stringify([
-            { title: "Item 1", detail: "detail 1", source: "eot:friction" },
-            { title: "Item 2", detail: "detail 2", source: "eot:friction" },
-            { title: "Item 3", detail: "detail 3", source: "eot:friction" },
-            { title: "Item 4", detail: "detail 4", source: "eot:friction" },
-        ]),
-    });
-    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.title).sort(), ["Item 1", "Item 2", "Item 3"]);
-});
-test("runFrictionHook treats malformed JSON as no friction items", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
-    const { memoryModule, eotModule } = await loadModules("friction-malformed-json");
-    const getScope = getFunction(memoryModule, "getScope");
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    const listActionItems = getFunction(memoryModule, "listActionItems");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    setActiveScope("chapterhouse");
-    await runFrictionHook({
-        taskId: "task-friction-malformed-json",
-        finalResult: "The agent hit confusing tool friction repeatedly, but the friction reviewer returned malformed JSON and the hook should safely ignore it without writing any action items.",
-        copilotClient: {},
-        callLLM: async () => "{not valid json",
-    });
-    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
-});
-test("runFrictionHook never propagates errors from the LLM call", async (t) => {
-    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
-    const { eotModule, warnings } = await loadModulesWithWarnSpy(t, "friction-no-throw");
-    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
-    await assert.doesNotReject(() => runFrictionHook({
-        taskId: "task-friction-no-throw",
-        finalResult: "The agent encountered enough friction to trigger the hook, but the LLM call itself crashed and the hook must still fail closed without breaking end-of-task processing.",
-        copilotClient: {},
-        callLLM: async () => {
-            throw new Error("boom");
-        },
-    }));
-    assert.equal(warnings.length, 1);
-});
-//# sourceMappingURL=eot.test.js.map