chapterhouse 0.13.1 → 0.14.1

package/dist/copilot/tools.memory.test.js

@@ -1,590 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import test from "node:test";
-async function loadModules() {
-    const nonce = `${Date.now()}-${Math.random()}`;
-    const toolsModule = await import(new URL(`./tools.js?case=${nonce}`, import.meta.url).href);
-    const agentsModule = await import(new URL("./agents.js", import.meta.url).href);
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    return { toolsModule, agentsModule, dbModule };
-}
-function findTool(tools, name) {
-    const tool = tools.find((entry) => entry.name === name);
-    assert.ok(tool, `${name} tool should be registered`);
-    return tool;
-}
-test.beforeEach(() => {
-    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-memory-"));
-});
-test.afterEach(async () => {
-    const home = process.env.CHAPTERHOUSE_HOME;
-    if (home) {
-        const dbModule = await import("../store/db.js");
-        dbModule.closeDb();
-        rmSync(home, { recursive: true, force: true });
-    }
-});
-test("memory_set_scope invalidates the orchestrator session after scheduling the scope-change checkpoint", async (t) => {
-    const events = [];
-    t.mock.module("./orchestrator.js", {
-        namedExports: {
-            getCurrentSourceChannel: () => "web",
-            getCurrentActivityCallback: () => undefined,
-            getCurrentActiveProjectRules: () => null,
-            getCurrentAuthenticatedUser: () => undefined,
-            getLastAuthenticatedUser: () => undefined,
-            getCurrentAuthorizationHeader: () => undefined,
-            getCurrentSessionKey: () => "session-test",
-            maybeScheduleScopeChangeCheckpoint: (sessionKey, previousScope, nextScope) => {
-                events.push(`checkpoint:${sessionKey}:${previousScope?.slug ?? "null"}->${nextScope?.slug ?? "null"}`);
-            },
-            resetCheckpointSessionState: (sessionKey) => {
-                events.push(`reset:${sessionKey}`);
-            },
-            invalidateOrchestratorSession: (sessionKey) => {
-                events.push(`invalidate:${sessionKey}`);
-            },
-            sendToAgentSession: async () => "",
-            switchSessionModel: async () => { },
-        },
-    });
-    const { toolsModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const memoryRemember = findTool(tools, "memory_remember");
-    const memorySetScope = findTool(tools, "memory_set_scope");
-    const remembered = await memoryRemember.handler({
-        content: "Scope changes should refresh hot-tier memory on the next turn.",
-        scope: "chapterhouse",
-        kind: "observation",
-    }, {});
-    assert.equal(remembered.ok, true);
-    events.length = 0;
-    const result = await memorySetScope.handler({ slug: "chapterhouse" }, {});
-    assert.equal(result.active_scope?.slug, "chapterhouse");
-    assert.deepEqual(events, [
-        "checkpoint:session-test:null->chapterhouse",
-        "invalidate:session-test",
-        "reset:session-test",
-    ]);
-    events.length = 0;
-    const unchangedResult = await memorySetScope.handler({ slug: "chapterhouse" }, {});
-    assert.equal(unchangedResult.active_scope?.slug, "chapterhouse");
-    assert.deepEqual(events, []);
-});
-test("memory tools remember, recall, set scope, and enforce orchestrator-only writes", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const memoryRemember = findTool(tools, "memory_remember");
-    const memoryRecall = findTool(tools, "memory_recall");
-    const memorySetScope = findTool(tools, "memory_set_scope");
-    const memoryCreateScope = findTool(tools, "memory_create_scope");
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools);
-    const chapterhouseRemember = findTool(chapterhouseTools, "memory_remember");
-    const chapterhouseRecall = findTool(chapterhouseTools, "memory_recall");
-    const chapterhouseSetScope = findTool(chapterhouseTools, "memory_set_scope");
-    const remembered = await chapterhouseRemember.handler({
-        content: "Use SQLite FTS5 to recall scoped memory entries.",
-        scope: "chapterhouse",
-        kind: "observation",
-    }, {});
-    assert.equal(typeof remembered, "object");
-    assert.equal(remembered.ok, true);
-    const db = dbModule.getDb();
-    const row = db.prepare(`
-    SELECT id, content
-    FROM mem_observations
-    WHERE content = ?
-  `).get("Use SQLite FTS5 to recall scoped memory entries.");
-    assert.ok(row, "memory_remember should write an observation row");
-    const ftsHits = db.prepare(`
-    SELECT rowid
-    FROM mem_observations_fts
-    WHERE mem_observations_fts MATCH 'SQLite'
-  `).all();
-    assert.equal(ftsHits.some((hit) => hit.rowid === row.id), true);
-    const recalled = await chapterhouseRecall.handler({
-        query: "SQLite FTS5 scoped memory",
-        scope: "chapterhouse",
-        limit: 10,
-    }, {});
-    assert.equal(typeof recalled, "object");
-    assert.equal((recalled.hits ?? []).some((hit) => hit.id === row.id), true);
-    const scopeResult = await chapterhouseSetScope.handler({ slug: "chapterhouse" }, {});
-    assert.equal(scopeResult.active_scope?.slug, "chapterhouse");
-    const createdScope = await memoryCreateScope.handler({
-        slug: "docs-site",
-        title: "Docs Site",
-        description: "Documentation publishing and content workflows",
-    }, {});
-    assert.deepEqual(createdScope, {
-        ok: true,
-        scope: {
-            slug: "docs-site",
-            title: "Docs Site",
-            description: "Documentation publishing and content workflows",
-            active: true,
-        },
-    });
-    const duplicateScope = await memoryCreateScope.handler({
-        slug: "docs-site",
-        title: "Docs Site Again",
-    }, {});
-    assert.match(String(duplicateScope), /already exists/i);
-    const invalidScope = await memoryCreateScope.handler({
-        slug: "Docs Site",
-        title: "Docs Site",
-    }, {});
-    assert.match(String(invalidScope), /kebab-case/i);
-    const implicitScopeRemember = await chapterhouseRemember.handler({
-        content: "Implicit active-scope writes should route to chapterhouse.",
-        kind: "observation",
-    }, {});
-    assert.equal(implicitScopeRemember.ok, true);
-    const coderVisibleTools = agentsModule.filterToolsForAgent({
-        slug: "coder",
-        name: "Coder",
-        description: "Software engineer",
-        model: "gpt-5.4",
-        systemMessage: "test",
-    }, tools);
-    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_remember"), false);
-    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_set_scope"), false);
-    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_recall"), true);
-    const coderRemember = findTool(coderTools, "memory_remember");
-    const rejected = await coderRemember.handler({
-        content: "Subagents should not be able to write memory directly.",
-        scope: "chapterhouse",
-        kind: "observation",
-    }, {});
-    assert.match(String(rejected), /orchestrator-only|memory_propose/i);
-    const coderRecall = findTool(coderVisibleTools, "memory_recall");
-    const coderRecalled = await coderRecall.handler({
-        query: "SQLite",
-        scope: "chapterhouse",
-        limit: 10,
-    }, {});
-    assert.equal(typeof coderRecalled, "object");
-    assert.equal((coderRecalled.hits ?? []).some((hit) => hit.id === row.id), true);
-    assert.ok(memoryRemember && memoryRecall && memorySetScope && memoryCreateScope);
-});
-test("memory_propose queues pending proposals, defaults scope from the active scope, and captures delegated task context", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools, "task-propose-001");
-    const memorySetScope = findTool(chapterhouseTools, "memory_set_scope");
-    const memoryPropose = findTool(coderTools, "memory_propose");
-    await memorySetScope.handler({ slug: "chapterhouse" }, {});
-    const proposed = await memoryPropose.handler({
-        kind: "observation",
-        payload: {
-            content: "Subagents can queue durable observations for orchestrator review.",
-            source: "final task summary",
-        },
-        confidence: 0.9,
-        reason: "The user explicitly asked for the new proposal path.",
-    }, {});
-    assert.equal(proposed.status, "queued");
-    assert.equal(typeof proposed.proposal_id, "number");
-    const db = dbModule.getDb();
-    const row = db.prepare(`
-    SELECT kind, status, source_agent, source_task_id, payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(proposed.proposal_id);
-    assert.ok(row, "memory_propose should insert a mem_inbox row");
-    assert.equal(row.kind, "memory_proposal");
-    assert.equal(row.status, "pending");
-    assert.equal(row.source_agent, "coder");
-    assert.equal(row.source_task_id, "task-propose-001");
-    const payload = JSON.parse(row.payload);
-    assert.equal(payload.kind, "observation");
-    assert.equal(payload.scope_slug, "chapterhouse");
-    assert.equal(payload.confidence, 0.9);
-    assert.equal(payload.reason, "The user explicitly asked for the new proposal path.");
-    assert.equal(payload.payload.content, "Subagents can queue durable observations for orchestrator review.");
-});
-test("memory_propose from a persistent agent honors an explicit 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 { toolsModule, agentsModule, dbModule } = await loadModules();
-    agentsModule.loadAgents();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const bellondaTools = bindToolsToAgent("bellonda", tools, "task-persistent-scope-001");
-    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
-    const memoryModule = await import("../memory/index.js");
-    const proposed = await memoryModule.withActiveScope("infra", () => findTool(bellondaTools, "memory_propose").handler({
-        kind: "observation",
-        scope_slug: "chapterhouse",
-        payload: {
-            content: "Persistent agents can explicitly route proposals to another scope when needed.",
-        },
-    }, {}));
-    assert.equal(proposed.status, "queued");
-    const row = dbModule.getDb().prepare(`
-    SELECT source_agent, source_task_id, payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(proposed.proposal_id);
-    assert.ok(row, "memory_propose should insert a mem_inbox row");
-    assert.equal(row.source_agent, "bellonda");
-    assert.equal(row.source_task_id, "task-persistent-scope-001");
-    const payload = JSON.parse(row.payload);
-    assert.equal(payload.scope_slug, "chapterhouse");
-});
-test("memory_propose ignores a missing subagent bound scope and falls back to the active scope", 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, "hwi.agent.md"), [
-        "---",
-        "name: Hwi",
-        "description: Mentat of Brian's personal scope",
-        "model: claude-sonnet-4.6",
-        "persistent: true",
-        "scope: brian",
-        "---",
-        "",
-        "You are Hwi.",
-    ].join("\n"));
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    agentsModule.loadAgents();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const hwiTools = bindToolsToAgent("hwi", tools, "task-hwi-action-item");
-    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
-    const proposed = await findTool(hwiTools, "memory_propose").handler({
-        kind: "action_item",
-        payload: {
-            title: "Follow up with Brian",
-        },
-    }, {});
-    assert.equal(proposed.status, "queued");
-    const row = dbModule.getDb().prepare(`
-    SELECT source_agent, payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(proposed.proposal_id);
-    assert.ok(row, "memory_propose should insert a mem_inbox row");
-    assert.equal(row.source_agent, "hwi");
-    const payload = JSON.parse(row.payload);
-    assert.equal(payload.scope_slug, "chapterhouse");
-});
-test("memory_propose accepts entity proposals with entity_kind and queues the full payload", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools, "task-entity-propose");
-    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
-    const proposed = await findTool(coderTools, "memory_propose").handler({
-        kind: "entity",
-        payload: {
-            name: "truenas",
-            entity_kind: "host",
-            summary: "NAS host used by Bellonda.",
-        },
-        confidence: 0.8,
-    }, {});
-    assert.equal(proposed.status, "queued");
-    const row = dbModule.getDb().prepare(`
-    SELECT payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(proposed.proposal_id);
-    assert.ok(row, "memory_propose should insert a mem_inbox row");
-    const payload = JSON.parse(row.payload);
-    assert.equal(payload.kind, "entity");
-    assert.equal(payload.scope_slug, "chapterhouse");
-    assert.deepEqual(payload.payload, {
-        name: "truenas",
-        entity_kind: "host",
-        summary: "NAS host used by Bellonda.",
-    });
-});
-test("action item memory tools add, list, complete, drop, and snooze action items", async () => {
-    const { toolsModule, agentsModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools);
-    const memoryAddActionItem = findTool(chapterhouseTools, "memory_add_action_item");
-    const memoryListActionItems = findTool(coderTools, "memory_list_action_items");
-    const memoryCompleteActionItem = findTool(chapterhouseTools, "memory_complete_action_item");
-    const memoryDropActionItem = findTool(chapterhouseTools, "memory_drop_action_item");
-    const memorySnoozeActionItem = findTool(chapterhouseTools, "memory_snooze_action_item");
-    const visibleToCoder = agentsModule.filterToolsForAgent({
-        slug: "coder",
-        name: "Coder",
-        description: "Software engineer",
-        model: "gpt-5.4",
-        systemMessage: "test",
-    }, tools);
-    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_list_action_items"), true);
-    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_add_action_item"), false);
-    const added = await memoryAddActionItem.handler({
-        scope: "chapterhouse",
-        title: "Migrate feature ideas",
-        detail: "Move the parked feature-ideas.md page into mem_action_items.",
-        due_at: "2026-05-15T12:00:00.000Z",
-        entity_name: "Chapterhouse",
-        entity_kind: "project",
-        source: "test",
-    }, {});
-    assert.equal(added.ok, true);
-    const addedId = added.id;
-    const listed = await memoryListActionItems.handler({ scope: "chapterhouse" }, {});
-    assert.equal((listed.action_items).some((item) => item.id === addedId), true);
-    const completed = await memoryCompleteActionItem.handler({ id: addedId, resolution_reason: "Done." }, {});
-    assert.equal(completed.ok, true);
-    assert.equal(completed.status, "done");
-    const afterComplete = await memoryListActionItems.handler({ scope: "chapterhouse" }, {});
-    assert.equal((afterComplete.action_items).some((item) => item.id === addedId), false);
-    const dropped = await memoryAddActionItem.handler({ scope: "chapterhouse", title: "Drop me" }, {});
-    const droppedResult = await memoryDropActionItem.handler({
-        id: dropped.id,
-        reason: "No longer needed.",
-    }, {});
-    assert.equal(droppedResult.status, "dropped");
-    const snoozed = await memoryAddActionItem.handler({ scope: "chapterhouse", title: "Snooze me" }, {});
-    const snoozedResult = await memorySnoozeActionItem.handler({
-        id: snoozed.id,
-        snooze_until: "2999-01-01T00:00:00.000Z",
-    }, {});
-    assert.equal(snoozedResult.status, "snoozed");
-});
-test("memory_propose accepts action_item proposals with a resolvable payload shape", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools, "task-action-propose");
-    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
-    const proposed = await findTool(coderTools, "memory_propose").handler({
-        kind: "action_item",
-        payload: {
-            title: "Remind infra about high disk usage",
-            detail: "Next time disk exceeds 85%, notify Bellonda.",
-            due_at: "2026-05-15T12:00:00.000Z",
-            source: "test",
-        },
-        confidence: 0.8,
-    }, {});
-    assert.equal(proposed.status, "queued");
-    const row = dbModule.getDb().prepare(`
-    SELECT payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(proposed.proposal_id);
-    const payload = JSON.parse(row.payload);
-    assert.equal(payload.kind, "action_item");
-    assert.equal(payload.scope_slug, "chapterhouse");
-    assert.equal(payload.payload.title, "Remind infra about high disk usage");
-    assert.equal(payload.payload.detail, "Next time disk exceeds 85%, notify Bellonda.");
-});
-test("memory_propose rejects action_item proposals with blank titles before queuing", async () => {
-    const { toolsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const memoryPropose = findTool(tools, "memory_propose");
-    const result = await memoryPropose.handler({
-        kind: "action_item",
-        payload: {
-            title: "   ",
-        },
-    }, {});
-    assert.match(String(result), /title/i);
-    const queued = dbModule.getDb().prepare(`
-    SELECT COUNT(*) AS count
-    FROM mem_inbox
-  `).get();
-    assert.equal(queued.count, 0);
-});
-test("memory_propose rejects invalid proposal kinds", async () => {
-    const { toolsModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const memoryPropose = findTool(tools, "memory_propose");
-    const result = await memoryPropose.handler({
-        kind: "pattern",
-        payload: { content: "invalid kind" },
-    }, {});
-    assert.match(String(result), /observation|decision|entity|action_item/i);
-});
-test("memory_housekeep is orchestrator-only and returns housekeeping summaries", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools);
-    const memorySetScope = findTool(chapterhouseTools, "memory_set_scope");
-    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
-    const memoryHousekeep = findTool(chapterhouseTools, "memory_housekeep");
-    const coderHousekeep = findTool(coderTools, "memory_housekeep");
-    await memorySetScope.handler({ slug: "chapterhouse" }, {});
-    const remembered = await memoryRemember.handler({
-        content: "Very old low-confidence memory should be archived by housekeeping.",
-        scope: "chapterhouse",
-        kind: "observation",
-    }, {});
-    const observationId = remembered.id;
-    const db = dbModule.getDb();
-    db.prepare(`
-    UPDATE mem_observations
-    SET confidence = 0.1, created_at = datetime('now', '-31 days')
-    WHERE id = ?
-  `).run(observationId);
-    const denied = await coderHousekeep.handler({ passes: ["decay"] }, {});
-    assert.match(String(denied), /orchestrator-only/i);
-    const visibleToCoder = agentsModule.filterToolsForAgent({
-        slug: "coder",
-        name: "Coder",
-        description: "Software engineer",
-        model: "gpt-5.4",
-        systemMessage: "test",
-    }, tools);
-    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_housekeep"), false);
-    const result = await memoryHousekeep.handler({
-        scope_slug: "chapterhouse",
-        passes: ["decay"],
-    }, {});
-    assert.equal(result.ok, true);
-    assert.deepEqual(result.scope_ids.length, 1);
-    assert.equal(result.summaries[0]?.pass, "decayPass");
-    assert.equal(result.summaries[0]?.modified, 1);
-});
-test("memory_promote and memory_demote are orchestrator-only manual tier controls", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const coderTools = bindToolsToAgent("coder", tools);
-    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
-    const memoryPromote = findTool(chapterhouseTools, "memory_promote");
-    const memoryDemote = findTool(chapterhouseTools, "memory_demote");
-    const coderPromote = findTool(coderTools, "memory_promote");
-    const coderDemote = findTool(coderTools, "memory_demote");
-    const remembered = await memoryRemember.handler({
-        content: "Manual tier controls should change this observation.",
-        scope: "chapterhouse",
-        kind: "observation",
-    }, {});
-    const observationId = remembered.id;
-    const db = dbModule.getDb();
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "warm");
-    const deniedPromote = await coderPromote.handler({ table: "observation", id: observationId, reason: "test" }, {});
-    const deniedDemote = await coderDemote.handler({ table: "observation", id: observationId, reason: "test" }, {});
-    assert.match(String(deniedPromote), /orchestrator-only/i);
-    assert.match(String(deniedDemote), /orchestrator-only/i);
-    assert.equal(agentsModule.filterToolsForAgent({
-        slug: "coder",
-        name: "Coder",
-        description: "Software engineer",
-        model: "gpt-5.4",
-        systemMessage: "test",
-    }, tools).some((tool) => tool.name === "memory_promote" || tool.name === "memory_demote"), false);
-    const promoted = await memoryPromote.handler({ table: "observation", id: observationId, reason: "actively relevant" }, {});
-    assert.equal(promoted.ok, true);
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "hot");
-    const demoted = await memoryDemote.handler({ table: "observation", id: observationId, reason: "no longer active", tier: "cold" }, {});
-    assert.equal(demoted.ok, true);
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "cold");
-});
-test("memory_remember dual-writes decisions to the wiki timeline when an entity is provided", async () => {
-    const { toolsModule, agentsModule, dbModule } = await loadModules();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const wikiFs = await import(new URL("../wiki/fs.js", import.meta.url).href);
-    wikiFs.ensureWikiStructure();
-    wikiFs.writePage("pages/projects/project-x/index.md", "---\ntitle: Project X\nsummary: Project X summary\nupdated: 2026-05-14\ntags: []\n---\n\n# Project X\n\n## Summary\n\nCurrent state.\n");
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
-    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
-    const result = await memoryRemember.handler({
-        scope: "chapterhouse",
-        kind: "decision",
-        entity_name: "project-x",
-        entity_kind: "project",
-        title: "Ship append-only decisions",
-        content: "Store the decision in SQLite and mirror it into the project timeline.",
-    }, {});
-    assert.equal(result.ok, true);
-    const db = dbModule.getDb();
-    const decision = db.prepare(`SELECT title, rationale FROM mem_decisions WHERE title = ?`).get("Ship append-only decisions");
-    assert.deepEqual(decision, {
-        title: "Ship append-only decisions",
-        rationale: "Store the decision in SQLite and mirror it into the project timeline.",
-    });
-    const page = wikiFs.readPage("pages/projects/project-x/index.md") ?? "";
-    assert.match(page, /## Timeline/);
-    assert.match(page, /Ship append-only decisions/);
-    assert.match(page, /Store the decision in SQLite and mirror it into the project timeline\./);
-});
-//# sourceMappingURL=tools.memory.test.js.map