chapterhouse 0.13.1 → 0.14.1

package/dist/copilot/agents.js

@@ -12,6 +12,7 @@ import { loadMcpConfig } from "./mcp-config.js";
 import { getCurrentDateSystemLine } from "./prompt-date.js";
 import { getSkillDirectories } from "./skills.js";
 import { EXCLUDED_BUILTIN_TOOLS } from "./builtin-tools.js";
+import { memorySystemInstructions } from "../memory/index.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("agents");
 const toolAgentContext = new AsyncLocalStorage();
@@ -297,12 +298,12 @@ function getAgentBasePrompt() {
 You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
 
 ### Agent Memory
-Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\` and \`memory_list_action_items\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, a named system/tool/person can be proposed as an \`entity\`, and a reminder/follow-up can be proposed as an \`action_item\`.
+Chapterhouse gives every agent a persistent, file-based memory tree under \`memory/\`, organized into domains. Read it with \`cog_read\`, \`cog_l0_scan\`, \`cog_l1_outline\`, \`cog_tree\`, and \`cog_search\`; write directly with \`cog_write\`, \`cog_edit\`, \`cog_append\`, and \`cog_move\` whenever you learn something worth remembering — don't wait for end of task. Every write auto-commits to git. The full memory operating instructions are included below.
 
 ### Shared Wiki
 All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
 
-Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\` and \`wiki_ingest_source\` as write-sensitive workflows, and use \`memory_propose\` for agent-memory handoff. Before using wiki write tools, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
+Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\` and \`wiki_ingest_source\` as write-sensitive workflows. Before using wiki write tools, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
 
 ### Communication
 - You receive tasks from @chapterhouse (the orchestrator) or directly from the user
@@ -321,11 +322,12 @@ export function composeAgentSystemMessage(agent, rosterInfo) {
     const agentPrompt = agent.systemMessage;
     const currentDateLine = getCurrentDateSystemLine();
     const currentDateBlock = currentDateLine ? `${currentDateLine}\n\n` : "";
+    const memoryBlock = memorySystemInstructions() ? `\n\n${memorySystemInstructions()}` : "";
     // For @chapterhouse, inject the agent roster
     if (agent.slug === "chapterhouse" && rosterInfo) {
-        return `${currentDateBlock}${agentPrompt.replace("{agent_roster}", rosterInfo)}`;
+        return `${currentDateBlock}${agentPrompt.replace("{agent_roster}", rosterInfo)}${memoryBlock}`;
     }
-    return `${currentDateBlock}${agentPrompt}\n\n${base}`;
+    return `${currentDateBlock}${agentPrompt}\n\n${base}${memoryBlock}`;
 }
 /** Build a roster description of all agents for @chapterhouse's system prompt. */
 export function buildAgentRoster() {
@@ -341,10 +343,13 @@ export function buildAgentRoster() {
         return "No agents registered.";
     return chLines.join("\n");
 }
-// The wiki tools that every agent gets regardless of tool config
-const WIKI_TOOL_NAMES = new Set([
+// Tools every agent gets regardless of tool config: the shared wiki and the
+// full file-based memory surface (all agents read and write memory directly).
+const ALWAYS_AVAILABLE_TOOL_NAMES = new Set([
     "wiki_search", "wiki_read", "wiki_update", "wiki_reindex", "wiki_append_timeline", "wiki_ingest_source",
-    "memory_recall", "memory_propose", "memory_list_action_items",
+    "cog_read", "cog_l0_scan", "cog_l1_outline", "cog_tree", "cog_search", "cog_stats",
+    "cog_write", "cog_edit", "cog_append", "cog_move",
+    "cog_git", "cog_domains", "cog_domain_create", "cog_sessions",
 ]);
 // Management tools that only @chapterhouse should have
 const MANAGEMENT_TOOL_NAMES = new Set([
@@ -353,8 +358,6 @@ const MANAGEMENT_TOOL_NAMES = new Set([
     "switch_model", "toggle_auto", "list_models",
     "restart_chapterhouse", "list_skills", "learn_skill", "uninstall_skill",
     "list_machine_sessions", "attach_machine_session",
-    "memory_remember", "memory_set_scope", "memory_housekeep", "memory_reflect", "memory_promote", "memory_demote",
-    "memory_add_action_item", "memory_complete_action_item", "memory_drop_action_item", "memory_snooze_action_item",
 ]);
 export function getCurrentToolAgentSlug() {
     return toolAgentContext.getStore();
@@ -375,7 +378,7 @@ export function bindToolsToAgent(agentSlug, allTools, taskId) {
 export function filterToolsForAgent(agent, allTools) {
     if (agent.tools && agent.tools.length > 0) {
         // Agent specifies an explicit allowlist — give those + wiki tools
-        const allowed = new Set([...agent.tools, ...WIKI_TOOL_NAMES]);
+        const allowed = new Set([...agent.tools, ...ALWAYS_AVAILABLE_TOOL_NAMES]);
         return allTools.filter((t) => allowed.has(t.name));
     }
     // Default: all tools except management (only @chapterhouse gets those by default)

package/dist/copilot/agents.test.js

@@ -50,18 +50,17 @@ test("composeAgentSystemMessage steers wiki-capable agents to wiki-conventions",
     for (const slug of ["coder", "general-purpose"]) {
         const message = composeAgentSystemMessage(makeAgent(slug));
         assert.match(message, /invoke `wiki-conventions` before wiki writes/i);
-        assert.match(message, /wiki_update[\s\S]{0,120}wiki_ingest_source[\s\S]{0,120}memory_propose/i);
+        assert.match(message, /wiki_update[\s\S]{0,120}wiki_ingest_source/i);
         assert.doesNotMatch(message, /`remember`|`forget`|`wiki_ingest`(?!_source)|`wiki_lint`|`wiki_rebuild_index`/);
         assert.match(message, /read `pages\/index\.md`/i);
         assert.match(message, /scan the last 20-30 entries of `pages\/_meta\/log\.md`/i);
     }
 });
-test("composeAgentSystemMessage teaches subagents the three-tier memory model and directs them to memory_propose", () => {
+test("composeAgentSystemMessage teaches subagents the file-based memory tools", () => {
     const message = composeAgentSystemMessage(makeAgent("coder"));
-    assert.match(message, /three-tier memory model|read, propose, write/i);
-    assert.match(message, /memory_recall/i);
-    assert.match(message, /memory_propose/i);
-    assert.match(message, /do not call `memory_remember` directly|should not call `memory_remember` directly/i);
+    assert.match(message, /cog_read/);
+    assert.match(message, /cog_write/);
+    assert.match(message, /write directly/i);
 });
 test("parseAgentMd detects persistent agent scope from charter frontmatter", () => {
     const agent = parseAgentMd([
@@ -103,22 +102,22 @@ test("korg charter is persistent and standardizes on the Summary heading", () =>
     assert.match(charter, /## Summary/);
     assert.doesNotMatch(charter, /## Compiled Truth/);
 });
-test("persistent agents cannot receive scope-changing management tools", () => {
+test("persistent agents cannot receive management tools", () => {
     const agent = {
         ...makeAgent("bellonda"),
         persistent: true,
         scope: "infra",
     };
     const tools = [
-        { name: "memory_recall" },
-        { name: "memory_propose" },
-        { name: "memory_set_scope" },
+        { name: "cog_read" },
+        { name: "cog_write" },
         { name: "delegate_to_agent" },
+        { name: "hire_agent" },
         { name: "bash" },
     ];
     const filtered = filterToolsForAgent(agent, tools);
     const names = filtered.map((tool) => tool.name);
-    assert.deepEqual(names.sort(), ["bash", "memory_propose", "memory_recall"].sort());
+    assert.deepEqual(names.sort(), ["bash", "cog_read", "cog_write"].sort());
 });
 test("bindToolsToAgent uses the per-turn task context when no fixed task id is provided", async () => {
     const tools = bindToolsToAgent("bellonda", [{

package/dist/copilot/memory-coordinator.js

@@ -1,234 +1,19 @@
-import { getActiveScope } from "../memory/active-scope.js";
-import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
-import { runEndOfTaskMemoryHook } from "../memory/eot.js";
-import { getHotTierEntries, renderHotTierForActiveScope, renderHotTierXML } from "../memory/hot-tier.js";
-import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
-import { getScope } from "../memory/scopes.js";
-import { config as defaultConfig } from "../config.js";
-import { childLogger } from "../util/logger.js";
-const log = childLogger("memory-coordinator");
-const MAX_CHECKPOINT_CHARS_PER_SIDE = 4_000;
+import { getMemoryManager } from "../memory/index.js";
+/**
+ * Wires the file-based memory subsystem into the agent runtime. Its only job is
+ * to inject the always-loaded hot-tier block into each turn via the
+ * onUserPromptSubmitted hook — all memory reads and writes are agent-driven via
+ * the cog_* tools.
+ */
 export class MemoryCoordinator {
-    checkpointTrackers = new Map();
-    checkpointTurnsBySession = new Map();
-    housekeepingTurnsBySession = new Map();
-    completedTaskIds = new Set();
-    getCopilotClient;
-    resolveScopeForSession;
-    config;
-    constructor(options) {
-        this.getCopilotClient = options.getCopilotClient;
-        this.resolveScopeForSession = options.resolveScopeForSession ?? (() => getActiveScope());
-        this.config = options.config ?? defaultConfig;
-    }
-    async onTurnComplete(sessionKey, prompt, response, source) {
-        const sourceType = this.normalizeSource(source);
-        if (sourceType === "background") {
-            return;
-        }
-        this.scheduleCheckpointExtraction(sessionKey, prompt, response);
-        this.scheduleHousekeeping(sessionKey);
-    }
-    async onScopeChange(sessionKey, prev, next) {
-        if (!prev) {
-            return;
-        }
-        const previousScope = getScope(prev) ?? null;
-        if (!previousScope) {
-            return;
-        }
-        if (!this.config.memoryCheckpointOnScopeChange) {
-            log.info({ sessionKey, scope: previousScope.slug }, "memory.checkpoint.scope_change_disabled");
-            return;
-        }
-        const tracker = this.getCheckpointTracker(sessionKey);
-        const turnsSinceLast = tracker.turnsSinceLastFire();
-        if (turnsSinceLast < this.config.memoryCheckpointMinTurnsForScopeFire) {
-            log.info({
-                sessionKey,
-                scope: previousScope.slug,
-                turns_since_last: turnsSinceLast,
-                min_required: this.config.memoryCheckpointMinTurnsForScopeFire,
-            }, "memory.checkpoint.scope_change_skip");
-            return;
-        }
-        if (isCheckpointInFlight(sessionKey)) {
-            log.info({ sessionKey, trigger: "scope_change" }, "memory.checkpoint.in_flight_skip");
-            return;
-        }
-        const copilotClient = this.getCopilotClient();
-        if (!copilotClient) {
-            log.error({ sessionKey }, "memory.checkpoint.error");
-            return;
-        }
-        const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
-        if (turns.length === 0) {
-            log.info({
-                sessionKey,
-                scope: previousScope.slug,
-                turns_since_last: turnsSinceLast,
-                min_required: this.config.memoryCheckpointMinTurnsForScopeFire,
-            }, "memory.checkpoint.scope_change_skip");
-            return;
-        }
-        tracker.markScopeChangeFire();
-        const nextScope = next ? (getScope(next) ?? null) : null;
-        void runCheckpointExtraction({
-            sessionKey,
-            turns: turns.slice(-this.config.memoryCheckpointTurns),
-            activeScope: previousScope,
-            copilotClient,
-            trigger: "scope_change",
-            scopeChangeContext: {
-                from: previousScope.slug,
-                to: nextScope?.slug ?? "no active scope",
-            },
-        }).catch((error) => {
-            log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-        });
-    }
-    async buildHotTierContext(sessionKey) {
-        if (!this.config.memoryInjectEnabled) {
-            return "";
-        }
-        const scope = this.resolveScopeForSession(sessionKey);
-        if (!scope) {
-            return "";
-        }
-        const activeScope = getActiveScope();
-        const hotTierXml = activeScope?.id === scope.id
-            ? renderHotTierForActiveScope()
-            : renderHotTierXML(getHotTierEntries(scope.id));
-        return hotTierXml ? hotTierXml.trimEnd() : "";
-    }
-    buildPerTurnHooks(sessionKey) {
-        if (!this.config.memoryInjectEnabled) {
-            return undefined;
-        }
-        const hooks = {
+    /** Returns the per-turn hooks that inject the hot-tier memory block. */
+    buildPerTurnHooks() {
+        return {
             onUserPromptSubmitted: async () => {
-                const hotTierXml = await this.buildHotTierContext(sessionKey);
-                return hotTierXml ? { additionalContext: hotTierXml } : undefined;
+                const block = getMemoryManager().hotTier();
+                return block ? { additionalContext: block } : undefined;
             },
         };
-        return hooks;
-    }
-    async onAgentTaskComplete(taskId, result) {
-        if (this.completedTaskIds.has(taskId)) {
-            log.info({ taskId }, "memory.eot.duplicate_skip");
-            return;
-        }
-        this.completedTaskIds.add(taskId);
-        const copilotClient = this.getCopilotClient();
-        if (!copilotClient) {
-            return;
-        }
-        const finalResult = typeof result === "string" ? result : result == null ? "" : String(result);
-        await runEndOfTaskMemoryHook({
-            taskId,
-            finalResult,
-            copilotClient,
-        });
-    }
-    reset(sessionKey) {
-        this.getCheckpointTracker(sessionKey).reset();
-        this.checkpointTurnsBySession.delete(sessionKey);
-        this.housekeepingTurnsBySession.delete(sessionKey);
-        this.completedTaskIds.clear();
-    }
-    shutdown() {
-        this.checkpointTrackers.clear();
-        this.checkpointTurnsBySession.clear();
-        this.housekeepingTurnsBySession.clear();
-        this.completedTaskIds.clear();
-    }
-    normalizeSource(source) {
-        return source === "background" ? "background" : source === "sse-web" ? "sse-web" : "web";
-    }
-    truncateCheckpointText(value) {
-        const trimmed = value.trim();
-        if (trimmed.length <= MAX_CHECKPOINT_CHARS_PER_SIDE) {
-            return trimmed;
-        }
-        return `${trimmed.slice(0, MAX_CHECKPOINT_CHARS_PER_SIDE)}…`;
-    }
-    getCheckpointTracker(sessionKey) {
-        let tracker = this.checkpointTrackers.get(sessionKey);
-        if (!tracker) {
-            tracker = new CheckpointTracker();
-            this.checkpointTrackers.set(sessionKey, tracker);
-        }
-        return tracker;
-    }
-    appendCheckpointTurn(sessionKey, turn) {
-        const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
-        turns.push(turn);
-        const overflow = turns.length - this.config.memoryCheckpointTurns;
-        if (overflow > 0) {
-            turns.splice(0, overflow);
-        }
-        this.checkpointTurnsBySession.set(sessionKey, turns);
-        return turns;
-    }
-    scheduleCheckpointExtraction(sessionKey, prompt, response) {
-        const tracker = this.getCheckpointTracker(sessionKey);
-        const turns = this.appendCheckpointTurn(sessionKey, {
-            user: this.truncateCheckpointText(prompt),
-            assistant: this.truncateCheckpointText(response),
-        });
-        if (!this.config.memoryCheckpointEnabled) {
-            log.info({ sessionKey }, "memory.checkpoint.disabled");
-            return;
-        }
-        tracker.tickOrchestratorTurn();
-        if (!tracker.shouldFire()) {
-            return;
-        }
-        tracker.markFired();
-        if (isCheckpointInFlight(sessionKey)) {
-            log.info({ sessionKey }, "memory.checkpoint.in_flight_skip");
-            return;
-        }
-        const copilotClient = this.getCopilotClient();
-        if (!copilotClient) {
-            log.error({ sessionKey }, "memory.checkpoint.error");
-            return;
-        }
-        const activeScope = this.resolveScopeForSession(sessionKey);
-        void runCheckpointExtraction({
-            sessionKey,
-            turns: turns.slice(-this.config.memoryCheckpointTurns),
-            activeScope,
-            copilotClient,
-            trigger: "cadence",
-        }).catch((error) => {
-            log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-        });
-    }
-    scheduleHousekeeping(sessionKey) {
-        if (!this.config.memoryHousekeepingEnabled) {
-            log.info({ sessionKey }, "memory.housekeeping.disabled");
-            return;
-        }
-        const turns = (this.housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
-        if (turns < this.config.memoryHousekeepingTurns) {
-            this.housekeepingTurnsBySession.set(sessionKey, turns);
-            return;
-        }
-        this.housekeepingTurnsBySession.set(sessionKey, 0);
-        const activeScope = this.resolveScopeForSession(sessionKey);
-        if (!activeScope) {
-            log.info({ sessionKey }, "memory.housekeeping.no_active_scope");
-            return;
-        }
-        const scopeIds = [activeScope.id];
-        if (isHousekeepingInFlight(scopeIds)) {
-            log.info({ sessionKey, scope_ids: scopeIds }, "memory.housekeeping.in_flight_skip");
-            return;
-        }
-        void runHousekeeping({ scopeIds }).catch((error) => {
-            log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
-        });
     }
 }
 //# sourceMappingURL=memory-coordinator.js.map

package/dist/copilot/memory-coordinator.test.js

@@ -1,257 +1,38 @@
 import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import test from "node:test";
-function makeScope(id, slug, title = slug, description = `${slug} scope`) {
-    return {
-        id,
-        slug,
-        title,
-        description,
-        keywords: [],
-        active: true,
-        createdAt: "2026-05-14T00:00:00.000Z",
-        updatedAt: "2026-05-14T00:00:00.000Z",
-    };
-}
-async function loadMemoryCoordinatorModule(t, overrides = {}) {
-    const chapterhouseScope = makeScope(1, "chapterhouse", "Chapterhouse", "Core Chapterhouse work.");
-    const wikiScope = makeScope(2, "wiki", "Wiki", "Wiki work.");
-    const state = {
-        config: {
-            copilotModel: "claude-sonnet-4.6",
-            memoryInjectEnabled: true,
-            memoryCheckpointEnabled: true,
-            memoryCheckpointTurns: 2,
-            memoryCheckpointOnScopeChange: true,
-            memoryCheckpointMinTurnsForScopeFire: 2,
-            memoryHousekeepingEnabled: true,
-            memoryHousekeepingTurns: 2,
-        },
-        activeScope: chapterhouseScope,
-        scopes: new Map([
-            [chapterhouseScope.slug, chapterhouseScope],
-            [wikiScope.slug, wikiScope],
-        ]),
-        sessionScopes: new Map([["default", chapterhouseScope]]),
-        hotTierXmlByScope: new Map([[chapterhouseScope.slug, "<memory_context scope=\"chapterhouse\">\n  <decision>Ship it</decision>\n</memory_context>\n"]]),
-        checkpointRuns: [],
-        checkpointInFlight: false,
-        checkpointTickCalls: 0,
-        checkpointMarkFiredCalls: 0,
-        checkpointMarkScopeChangeFireCalls: 0,
-        checkpointResetCalls: 0,
-        housekeepingRuns: [],
-        housekeepingInFlight: false,
-        eotCalls: [],
-        ...overrides,
-    };
-    t.mock.module("../config.js", {
-        namedExports: {
-            config: state.config,
-        },
-    });
-    t.mock.module("../memory/active-scope.js", {
-        namedExports: {
-            getActiveScope: () => state.activeScope,
-        },
-    });
-    t.mock.module("../memory/scopes.js", {
-        namedExports: {
-            getScope: (slug) => state.scopes.get(slug) ?? null,
-        },
-    });
-    t.mock.module("../memory/hot-tier.js", {
-        namedExports: {
-            getHotTierEntries: (scopeId) => {
-                const scope = Array.from(state.scopes.values()).find((candidate) => candidate.id === scopeId) ?? null;
-                return { scope, entities: [], observations: [], decisions: [], actionItems: [] };
-            },
-            renderHotTierXML: (entries) => entries.scope ? (state.hotTierXmlByScope.get(entries.scope.slug) ?? "") : "",
-            renderHotTierForActiveScope: () => state.activeScope ? (state.hotTierXmlByScope.get(state.activeScope.slug) ?? "") : "",
-        },
-    });
-    t.mock.module("../memory/checkpoint.js", {
-        namedExports: {
-            CheckpointTracker: class {
-                turns = 0;
-                tickOrchestratorTurn() {
-                    state.checkpointTickCalls++;
-                    this.turns++;
-                }
-                shouldFire() {
-                    return this.turns >= state.config.memoryCheckpointTurns;
-                }
-                turnsSinceLastFire() {
-                    return this.turns;
-                }
-                markFired() {
-                    state.checkpointMarkFiredCalls++;
-                    this.turns = 0;
-                }
-                markScopeChangeFire() {
-                    state.checkpointMarkScopeChangeFireCalls++;
-                    this.turns = 0;
-                }
-                reset() {
-                    state.checkpointResetCalls++;
-                    this.turns = 0;
-                }
-            },
-            isCheckpointInFlight: () => state.checkpointInFlight,
-            runCheckpointExtraction: async (input) => {
-                state.checkpointRuns.push(input);
-                return { written: 0, skipped: 0, errors: [] };
-            },
-        },
-    });
-    t.mock.module("../memory/housekeeping.js", {
-        namedExports: {
-            isHousekeepingInFlight: () => state.housekeepingInFlight,
-            runHousekeeping: async (input) => {
-                state.housekeepingRuns.push(input);
-                return { scopeIds: input.scopeIds ?? [], summaries: [], totalExamined: 0, totalModified: 0, durationMs: 0 };
-            },
-        },
-    });
-    t.mock.module("../memory/eot.js", {
-        namedExports: {
-            runEndOfTaskMemoryHook: async (input) => {
-                state.eotCalls.push(input);
-                return {
-                    task_id: String(input.taskId ?? "task"),
-                    proposals_total: 0,
-                    accepted: 0,
-                    rejected: 0,
-                    implicit_extracted: 0,
-                    auto_accept: true,
-                };
-            },
-        },
-    });
-    const module = await import(new URL(`./memory-coordinator.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-    return { module, state };
-}
-test("buildHotTierContext and buildPerTurnHooks inject trimmed scoped hot-tier memory", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const client = { name: "mock-client" };
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => client,
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    const hotTierContext = await coordinator.buildHotTierContext("default");
-    const hooks = coordinator.buildPerTurnHooks("default");
-    const hookResult = await hooks?.onUserPromptSubmitted?.();
-    assert.equal(hotTierContext, "<memory_context scope=\"chapterhouse\">\n  <decision>Ship it</decision>\n</memory_context>");
-    assert.deepEqual(hookResult, {
-        additionalContext: "<memory_context scope=\"chapterhouse\">\n  <decision>Ship it</decision>\n</memory_context>",
-    });
+const sandbox = join(process.cwd(), ".test-work", `memory-coordinator-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandbox;
+import { MemoryCoordinator } from "./memory-coordinator.js";
+import { gitAvailable } from "../memory/git.js";
+import { getMemoryManager, resetMemoryManagerForTests } from "../memory/index.js";
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+    resetMemoryManagerForTests();
 });
-test("onTurnComplete schedules checkpoint and housekeeping at the configured turn boundary", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => ({ name: "mock-client" }),
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onTurnComplete("default", "First prompt", "First response", "web");
-    assert.equal(state.checkpointRuns.length, 0);
-    assert.equal(state.housekeepingRuns.length, 0);
-    await coordinator.onTurnComplete("default", "Second prompt", "Second response", "web");
-    assert.equal(state.checkpointMarkFiredCalls, 1);
-    assert.equal(state.checkpointRuns.length, 1);
-    assert.equal(state.housekeepingRuns.length, 1);
-    assert.deepEqual(state.housekeepingRuns[0]?.scopeIds, [1]);
-    assert.equal((state.checkpointRuns[0]?.activeScope).slug, "chapterhouse");
-    assert.deepEqual(state.checkpointRuns[0]?.turns, [
-        { user: "First prompt", assistant: "First response" },
-        { user: "Second prompt", assistant: "Second response" },
-    ]);
-    await coordinator.onTurnComplete("default", "Background prompt", "Background response", "background");
-    assert.equal(state.checkpointRuns.length, 1);
-    assert.equal(state.housekeepingRuns.length, 1);
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("buildPerTurnHooks returns an onUserPromptSubmitted hook", () => {
+    const hooks = new MemoryCoordinator().buildPerTurnHooks();
+    assert.ok(hooks);
+    assert.equal(typeof hooks.onUserPromptSubmitted, "function");
 });
-test("onScopeChange triggers checkpoint extraction for the previous scope", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t, {
-        config: {
-            copilotModel: "claude-sonnet-4.6",
-            memoryInjectEnabled: true,
-            memoryCheckpointEnabled: true,
-            memoryCheckpointTurns: 5,
-            memoryCheckpointOnScopeChange: true,
-            memoryCheckpointMinTurnsForScopeFire: 2,
-            memoryHousekeepingEnabled: true,
-            memoryHousekeepingTurns: 2,
-        },
-    });
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => ({ name: "mock-client" }),
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onTurnComplete("default", "Turn one", "Reply one", "web");
-    await coordinator.onTurnComplete("default", "Turn two", "Reply two", "web");
-    state.checkpointRuns.length = 0;
-    await coordinator.onScopeChange("default", "chapterhouse", "wiki");
-    assert.equal(state.checkpointMarkScopeChangeFireCalls, 1);
-    assert.equal(state.checkpointRuns.length, 1);
-    assert.equal((state.checkpointRuns[0]?.activeScope).slug, "chapterhouse");
-    assert.equal(state.checkpointRuns[0]?.trigger, "scope_change");
-    assert.deepEqual(state.checkpointRuns[0]?.scopeChangeContext, { from: "chapterhouse", to: "wiki" });
+test("the hook returns undefined when memory has no hot-tier content", async () => {
+    const hooks = new MemoryCoordinator().buildPerTurnHooks();
+    const result = await hooks.onUserPromptSubmitted();
+    assert.equal(result, undefined);
 });
-test("onAgentTaskComplete runs the end-of-task memory hook with the mock client", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const client = { name: "mock-client" };
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => client,
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onAgentTaskComplete("task-42", "Final delegated result");
-    assert.equal(state.eotCalls.length, 1);
-    assert.equal(state.eotCalls[0]?.taskId, "task-42");
-    assert.equal(state.eotCalls[0]?.finalResult, "Final delegated result");
-    assert.equal(state.eotCalls[0]?.copilotClient, client);
-});
-test("onAgentTaskComplete is a no-op for a duplicate task ID (double-fire guard)", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const client = { name: "mock-client" };
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => client,
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onAgentTaskComplete("task-99", "result one");
-    await coordinator.onAgentTaskComplete("task-99", "result two");
-    assert.equal(state.eotCalls.length, 1);
-    assert.equal(state.eotCalls[0]?.taskId, "task-99");
-    assert.equal(state.eotCalls[0]?.finalResult, "result one");
-});
-test("reset clears turn buffers and tracker state for a session", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => ({ name: "mock-client" }),
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onTurnComplete("default", "Turn one", "Reply one", "web");
-    coordinator.reset("default");
-    await coordinator.onTurnComplete("default", "Turn two", "Reply two", "web");
-    await coordinator.onScopeChange("default", "chapterhouse", "wiki");
-    assert.equal(state.checkpointResetCalls, 1);
-    assert.equal(state.checkpointRuns.length, 0);
-    assert.equal(state.housekeepingRuns.length, 0);
-});
-test("shutdown clears session state across all tracked maps", async (t) => {
-    const { module, state } = await loadMemoryCoordinatorModule(t);
-    const coordinator = new module.MemoryCoordinator({
-        getCopilotClient: () => ({ name: "mock-client" }),
-        config: state.config,
-        resolveScopeForSession: (sessionKey) => state.sessionScopes.get(sessionKey) ?? null,
-    });
-    await coordinator.onTurnComplete("default", "Turn one", "Reply one", "web");
-    coordinator.shutdown();
-    await coordinator.onTurnComplete("default", "Turn two", "Reply two", "web");
-    assert.equal(state.checkpointRuns.length, 0);
-    assert.equal(state.housekeepingRuns.length, 0);
+test("the hook injects the hot-tier block once memory is scaffolded", async () => {
+    if (!gitAvailable())
+        return;
+    const manager = getMemoryManager();
+    await manager.ensureReady();
+    writeFileSync(join(manager.paths.memoryRoot, "hot-memory.md"), "<!-- L0: hot -->\ntop of mind");
+    const hooks = new MemoryCoordinator().buildPerTurnHooks();
+    const result = await hooks.onUserPromptSubmitted();
+    assert.ok(result && typeof result === "object");
+    assert.match(result.additionalContext, /top of mind/);
+    assert.match(result.additionalContext, /<chapterhouse-memory>/);
 });
 //# sourceMappingURL=memory-coordinator.test.js.map