chapterhouse 0.5.2 → 0.7.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