chapterhouse 0.5.2 → 0.6.0

package/.pr-types.json

@@ -0,0 +1,14 @@
+[
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "chore",
+  "build",
+  "ci",
+  "revert",
+  "release"
+]

package/README.md

@@ -91,6 +91,12 @@ cd ~/.chapterhouse/src
 npm install && npm run build && npm link
 ```
 
+If you're opening a sprint PR from the repo, validate the title first:
+
+```bash
+npm run pr:title:check -- "chore: add PR title preflight validation"
+```
+
 ## Upgrading
 
 ```bash

package/dist/config.test.js

@@ -271,7 +271,19 @@ test("rejects invalid SSE replay settings", async () => {
         CHAPTERHOUSE_SSE_BUFFER_CAPACITY: "0",
     }), /CHAPTERHOUSE_SSE_BUFFER_CAPACITY must be a positive integer/);
 });
+test("personal mode starts cleanly without Entra env vars", async () => {
+    // Security: personal mode should boot in its intended unauthenticated configuration instead of requiring enterprise auth by accident.
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+    });
+    assert.equal(parsed.chapterhouseMode, "personal");
+    assert.equal(parsed.entraAuthEnabled, false);
+    assert.doesNotMatch(parsed.modeCompatibilityWarnings.join("\n"), /Entra/i);
+});
 test("personal mode rejects explicit Entra auth enablement with a clear fix suggestion", async () => {
+    // Security: personal deployments must fail fast instead of starting in a broken auth state that looks protected but is not.
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     assert.throws(() => configModule.parseRuntimeConfig({
@@ -281,7 +293,23 @@ test("personal mode rejects explicit Entra auth enablement with a clear fix sugg
         ENTRA_CLIENT_ID: "client-id",
     }), /Personal mode cannot be used with ENTRA_AUTH_ENABLED=true[\s\S]*CHAPTERHOUSE_MODE=team[\s\S]*unset ENTRA_AUTH_ENABLED/);
 });
+test("team mode accepts Entra auth when required settings are present", async () => {
+    // Security: team mode is the only safe place for Entra auth, so valid enterprise settings must remain supported there.
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
+        ENTRA_AUTH_ENABLED: "true",
+        ENTRA_TENANT_ID: "tenant-id",
+        ENTRA_CLIENT_ID: "client-id",
+    });
+    assert.equal(parsed.chapterhouseMode, "team");
+    assert.equal(parsed.entraAuthEnabled, true);
+    assert.equal(parsed.entraTenantId, "tenant-id");
+    assert.equal(parsed.entraClientId, "client-id");
+});
 test("personal mode still warns about leftover Entra settings when auth is not explicitly enabled", async () => {
+    // Security: leftover enterprise env vars should be called out so personal-mode operators know those settings are being ignored.
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     const parsed = configModule.parseRuntimeConfig({
@@ -293,6 +321,7 @@ test("personal mode still warns about leftover Entra settings when auth is not e
     assert.match(parsed.modeCompatibilityWarnings.join("\n"), /Entra/i);
 });
 test("personal mode warns and disables incomplete Teams notification settings instead of throwing", async () => {
+    // Security: personal mode should ignore team-only integrations without partially enabling cross-tenant notification flows.
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     const parsed = configModule.parseRuntimeConfig({

package/dist/copilot/memory-coordinator.js

@@ -0,0 +1,234 @@
+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;
+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 = {
+            onUserPromptSubmitted: async () => {
+                const hotTierXml = await this.buildHotTierContext(sessionKey);
+                return hotTierXml ? { additionalContext: hotTierXml } : 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

@@ -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