chapterhouse 0.5.1 → 0.6.0

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

@@ -0,0 +1,257 @@
+import assert from "node:assert/strict";
+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>",
+    });
+});
+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("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("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);
+});
+//# sourceMappingURL=memory-coordinator.test.js.map

package/dist/copilot/orchestrator.js

@@ -3,13 +3,9 @@ import { randomUUID } from "node:crypto";
 import { approveAll } from "@github/copilot-sdk";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
-import { renderHotTierForActiveScope } from "../memory/hot-tier.js";
-import { getHotTierEntries, renderHotTierXML } from "../memory/hot-tier.js";
 import { getActiveScope, withActiveScope } from "../memory/active-scope.js";
 import { getScope } from "../memory/scopes.js";
-import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
-import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
-import { runEndOfTaskMemoryHook } from "../memory/eot.js";
+import { MemoryCoordinator } from "./memory-coordinator.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
@@ -77,160 +73,15 @@ let currentUserContext;
 let currentAuthenticatedUser;
 let currentAuthorizationHeader;
 let lastRouteResult;
-const checkpointTrackers = new Map();
-const checkpointTurnsBySession = new Map();
-const housekeepingTurnsBySession = new Map();
-const MAX_CHECKPOINT_CHARS_PER_SIDE = 4_000;
+let memoryCoordinator;
 export function getLastRouteResult() {
     return lastRouteResult;
 }
-function 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)}…`;
-}
-function getCheckpointTracker(sessionKey) {
-    let tracker = checkpointTrackers.get(sessionKey);
-    if (!tracker) {
-        tracker = new CheckpointTracker();
-        checkpointTrackers.set(sessionKey, tracker);
-    }
-    return tracker;
-}
 export function resetCheckpointSessionState(sessionKey) {
-    getCheckpointTracker(sessionKey).reset();
-    checkpointTurnsBySession.delete(sessionKey);
-    housekeepingTurnsBySession.delete(sessionKey);
-}
-function appendCheckpointTurn(sessionKey, turn) {
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    turns.push(turn);
-    const overflow = turns.length - config.memoryCheckpointTurns;
-    if (overflow > 0) {
-        turns.splice(0, overflow);
-    }
-    checkpointTurnsBySession.set(sessionKey, turns);
-    return turns;
-}
-function scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source) {
-    if (source.type === "background") {
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turns = appendCheckpointTurn(sessionKey, {
-        user: truncateCheckpointText(prompt),
-        assistant: truncateCheckpointText(finalContent),
-    });
-    if (!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;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const activeScope = getMemoryScopeForSession(sessionKey);
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope,
-        copilotClient,
-        trigger: "cadence",
-    }).catch((error) => {
-        log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-    });
-}
-function scheduleHousekeeping(sessionKey, source) {
-    if (source.type === "background") {
-        return;
-    }
-    if (!config.memoryHousekeepingEnabled) {
-        log.info({ sessionKey }, "memory.housekeeping.disabled");
-        return;
-    }
-    const turns = (housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
-    if (turns < config.memoryHousekeepingTurns) {
-        housekeepingTurnsBySession.set(sessionKey, turns);
-        return;
-    }
-    housekeepingTurnsBySession.set(sessionKey, 0);
-    const activeScope = getMemoryScopeForSession(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;
-    }
-    try {
-        void runHousekeeping({ scopeIds });
-    }
-    catch (error) {
-        log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
-    }
+    memoryCoordinator?.reset(sessionKey);
 }
 export function maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope) {
-    if (!previousScope) {
-        return;
-    }
-    if (!config.memoryCheckpointOnScopeChange) {
-        log.info({ sessionKey, scope: previousScope.slug }, "memory.checkpoint.scope_change_disabled");
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turnsSinceLast = tracker.turnsSinceLastFire();
-    if (turnsSinceLast < config.memoryCheckpointMinTurnsForScopeFire) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    if (isCheckpointInFlight(sessionKey)) {
-        log.info({ sessionKey, trigger: "scope_change" }, "memory.checkpoint.in_flight_skip");
-        return;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    if (turns.length === 0) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    tracker.markScopeChangeFire();
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope: previousScope,
-        copilotClient,
-        trigger: "scope_change",
-        scopeChangeContext: {
-            from: previousScope.slug,
-            to: nextScope?.slug ?? "no active scope",
-        },
-    }).catch((error) => {
+    void memoryCoordinator?.onScopeChange(sessionKey, previousScope?.slug ?? "", nextScope?.slug ?? "").catch((error) => {
         log.error({ err: error, sessionKey }, "memory.checkpoint.error");
     });
 }
@@ -342,39 +193,11 @@ function getMemoryScopeForSession(sessionKey) {
     }
     return getActiveScope();
 }
-function buildScopedHotTierContext(scope) {
-    if (!config.memoryInjectEnabled || !scope) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierXML(getHotTierEntries(scope.id));
-    return hotTierXml ? hotTierXml.trimEnd() : undefined;
-}
-function buildHotTierContext() {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierForActiveScope();
-    if (!hotTierXml) {
-        return undefined;
-    }
-    return hotTierXml.trimEnd();
-}
-function buildPerTurnMemoryHooks(sessionKey) {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    return {
-        onUserPromptSubmitted: () => {
-            const hotTierXml = buildScopedHotTierContext(getMemoryScopeForSession(sessionKey));
-            return hotTierXml ? { additionalContext: hotTierXml } : undefined;
-        },
-    };
-}
-function getSystemMessageOptions(memorySummary) {
+function getSystemMessageOptions(memorySummary, hotTierXml) {
     return {
         selfEditEnabled: config.selfEditEnabled,
         memorySummary: memorySummary || undefined,
-        hotTierXml: buildHotTierContext(),
+        hotTierXml,
         agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
@@ -410,15 +233,9 @@ function updateRequestContext(source) {
     }
 }
 export function feedAgentResult(taskId, agentSlug, result) {
-    if (copilotClient) {
-        void runEndOfTaskMemoryHook({
-            taskId,
-            finalResult: result,
-            copilotClient,
-        }).catch((error) => {
-            log.error({ err: error, taskId }, "memory.eot.error");
-        });
-    }
+    void memoryCoordinator?.onAgentTaskComplete(taskId, result).catch((error) => {
+        log.error({ err: error, taskId }, "memory.eot.error");
+    });
     const sessionKey = getTaskSessionKey(taskId) || "default";
     const agentTurnId = randomUUID();
     const agentDisplayName = getAgentRegistry().find((agent) => agent.slug === agentSlug)?.name ?? agentSlug;
@@ -512,13 +329,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     let { tools, mcpServers, skillDirectories } = baseConfig;
     const isProjectSession = sessionKey.startsWith("project:");
     const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
-    const agentScope = persistentAgent?.scope ? getScope(persistentAgent.scope) ?? null : null;
     const infiniteSessions = {
         enabled: true,
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    const memoryHooks = buildPerTurnMemoryHooks(sessionKey);
+    const memoryHooks = memoryCoordinator?.buildPerTurnHooks(sessionKey);
     let model = config.copilotModel;
     let systemMessageContent;
     let sessionMode = isProjectSession ? "project" : "default";
@@ -528,7 +344,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             client: copilotClient,
             onAgentTaskComplete: feedAgentResult,
         })));
-        const scopedHotTier = buildScopedHotTierContext(agentScope);
+        const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
         systemMessageContent = [
             composeAgentSystemMessage(persistentAgent),
@@ -539,8 +355,9 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     }
     else {
         const memorySummary = getWikiSummary();
+        const hotTierXml = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         systemMessageContent = getOrchestratorSystemMessage({
-            ...getSystemMessageOptions(memorySummary),
+            ...getSystemMessageOptions(memorySummary, hotTierXml),
             version: CHAPTERHOUSE_VERSION,
         });
     }
@@ -562,7 +379,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
-            resetCheckpointSessionState(sessionKey);
+            memoryCoordinator?.reset(sessionKey);
             upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
             const mgr = registry?.get(sessionKey);
             if (mgr)
@@ -589,7 +406,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
-    resetCheckpointSessionState(sessionKey);
+    memoryCoordinator?.reset(sessionKey);
     upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
@@ -600,6 +417,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
 }
 export async function initOrchestrator(client) {
     copilotClient = client;
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = new MemoryCoordinator({
+        getCopilotClient: () => copilotClient,
+        config,
+        resolveScopeForSession: getMemoryScopeForSession,
+    });
     // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
     initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
@@ -896,12 +719,8 @@ async function executeOnSession(manager, item) {
                 spawnArgsMap.delete(taskId);
                 activeSubagentTaskIds.delete(taskId);
                 db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
-                if (copilotClient && finalResult) {
-                    void runEndOfTaskMemoryHook({
-                        taskId,
-                        finalResult,
-                        copilotClient,
-                    }).catch((error) => {
+                if (finalResult) {
+                    void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
                         log.error({ err: error, taskId }, "memory.eot.error");
                     });
                 }
@@ -1252,8 +1071,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, prompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1353,8 +1173,9 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                     logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, newPrompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1494,15 +1315,13 @@ export function getAgentInfo() {
 }
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = undefined;
     if (!registry) {
-        checkpointTrackers.clear();
-        checkpointTurnsBySession.clear();
         await clearActiveTasks();
         return;
     }
     await registry.shutdown();
-    checkpointTrackers.clear();
-    checkpointTurnsBySession.clear();
     await clearActiveTasks();
 }
 //# sourceMappingURL=orchestrator.js.map