chapterhouse 0.13.0 → 0.14.0

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

package/dist/copilot/orchestrator.js

@@ -3,8 +3,7 @@ import { randomUUID } from "node:crypto";
 import { approveAll } from "@github/copilot-sdk";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
-import { getActiveScope, withActiveScope } from "../memory/active-scope.js";
-import { getScope } from "../memory/scopes.js";
+import { getMemoryManager } from "../memory/index.js";
 import { MemoryCoordinator } from "./memory-coordinator.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
@@ -39,18 +38,6 @@ const AGENT_REPLY_CHUNK_THRESHOLD = 8 * 1024;
 const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
 const LAST_AUTHENTICATED_USER_KEY = "last_authenticated_user";
 let taskEventLogCleanup;
-function getWikiSummary() {
-    try {
-        const db = getDb();
-        const pages = db.prepare(`SELECT title, summary, last_updated FROM wiki_pages ORDER BY last_updated DESC LIMIT 50`).all();
-        if (pages.length === 0)
-            return "";
-        return pages.map((page) => `${page.title}: ${page.summary || ""}`.trim()).join("\n");
-    }
-    catch {
-        return "";
-    }
-}
 let logMessage = () => { };
 export function setMessageLogger(fn) {
     logMessage = fn;
@@ -84,14 +71,6 @@ let memoryCoordinator;
 export function getLastRouteResult() {
     return lastRouteResult;
 }
-export function resetCheckpointSessionState(sessionKey) {
-    memoryCoordinator?.reset(sessionKey);
-}
-export function maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope) {
-    void memoryCoordinator?.onScopeChange(sessionKey, previousScope?.slug ?? "", nextScope?.slug ?? "").catch((error) => {
-        log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-    });
-}
 export function subscribeTaskEvents(taskId, listener) {
     return agentEventBus.subscribe("session:tool_call", (event) => {
         if (event.sessionId !== taskId)
@@ -176,6 +155,7 @@ export function getCurrentAuthorizationHeader() {
 function getSessionConfig() {
     const baseTools = createTools({
         client: copilotClient,
+        memoryManager: getMemoryManager(),
         onAgentTaskComplete: feedAgentResult,
     });
     const tools = agentsModule.bindToolsToAgent?.("chapterhouse", baseTools) ?? baseTools;
@@ -200,18 +180,9 @@ function getPersistentAgentForSessionKey(sessionKey) {
     const agent = getAgent(slug);
     return agent?.persistent ? agent : undefined;
 }
-function getMemoryScopeForSession(sessionKey) {
-    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
-    if (persistentAgent?.scope) {
-        return getScope(persistentAgent.scope) ?? null;
-    }
-    return getActiveScope();
-}
-function getSystemMessageOptions(memorySummary, hotTierXml) {
+function getSystemMessageOptions() {
     return {
         selfEditEnabled: config.selfEditEnabled,
-        memorySummary: memorySummary || undefined,
-        hotTierXml,
         agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
@@ -242,9 +213,6 @@ function recordLastAuthenticatedUser(source) {
     }
 }
 export function feedAgentResult(taskId, agentSlug, result) {
-    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;
@@ -346,7 +314,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    const memoryHooks = memoryCoordinator?.buildPerTurnHooks(sessionKey);
+    const memoryHooks = memoryCoordinator?.buildPerTurnHooks();
     let model = config.copilotModel;
     let systemMessageContent;
     let sessionMode = isProjectSession ? "project" : "default";
@@ -354,23 +322,20 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         model = persistentAgent.model === "auto" ? config.copilotModel : persistentAgent.model;
         tools = agentsModule.bindToolsToAgent(persistentAgent.slug, filterToolsForAgent(persistentAgent, createTools({
             client: copilotClient,
+            memoryManager: getMemoryManager(),
             onAgentTaskComplete: feedAgentResult,
         })));
         mcpServers = filterMcpServersForAgent(persistentAgent, mcpServers);
-        const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
-        const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
+        const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}).`;
         systemMessageContent = [
             composeAgentSystemMessage(persistentAgent),
             channelNote,
-            scopedHotTier,
         ].filter(Boolean).join("\n\n");
         sessionMode = "agent";
     }
     else {
-        const memorySummary = getWikiSummary();
-        const hotTierXml = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         systemMessageContent = getOrchestratorSystemMessage({
-            ...getSystemMessageOptions(memorySummary, hotTierXml),
+            ...getSystemMessageOptions(),
             version: CHAPTERHOUSE_VERSION,
         });
     }
@@ -393,7 +358,6 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
-            memoryCoordinator?.reset(sessionKey);
             upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
             const mgr = registry?.get(sessionKey);
             if (mgr)
@@ -422,7 +386,6 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
-    memoryCoordinator?.reset(sessionKey);
     upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
@@ -433,12 +396,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
 }
 export async function initOrchestrator(client) {
     copilotClient = client;
-    memoryCoordinator?.shutdown();
-    memoryCoordinator = new MemoryCoordinator({
-        getCopilotClient: () => copilotClient,
-        config,
-        resolveScopeForSession: getMemoryScopeForSession,
-    });
+    memoryCoordinator = new MemoryCoordinator();
     // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
     taskEventLogCleanup?.();
     taskEventLogCleanup = initTaskEventLog();
@@ -738,11 +696,6 @@ async function executeOnSession(manager, item) {
                         log.warn({ taskId, length: finalResult.length, limit: 10_000 }, "subagent result truncated before persistence");
                     }
                     db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
-                    if (finalResult) {
-                        void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
-                            log.error({ err: error, taskId }, "memory.eot.error");
-                        });
-                    }
                     const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
                     void agentEventBus.emit({
                         type: "session:destroyed",
@@ -902,13 +855,9 @@ async function executeOnSession(manager, item) {
             unsubTurnReasoning();
         }
     });
-    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
     const scopedRunTurn = () => item.taskId
         ? withToolTaskContext(item.taskId, runTurn)
         : runTurn();
-    if (persistentAgent?.scope) {
-        return withActiveScope(persistentAgent.scope, scopedRunTurn);
-    }
     return scopedRunTurn();
 }
 /**
@@ -1087,9 +1036,6 @@ export function sendToOrchestrator(prompt, source, callback, attachments, onActi
                     logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                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)");
@@ -1194,9 +1140,6 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                     logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                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)");
@@ -1373,7 +1316,6 @@ export function getAgentInfo() {
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
     stopClassifier();
-    memoryCoordinator?.shutdown();
     memoryCoordinator = undefined;
     if (!registry) {
         await clearActiveTasks();