chapterhouse 0.3.26 → 0.4.1

package/dist/copilot/tools.memory.test.js

@@ -0,0 +1,297 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const toolsModule = await import(new URL(`./tools.js?case=${nonce}`, import.meta.url).href);
+    const agentsModule = await import(new URL("./agents.js", import.meta.url).href);
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    return { toolsModule, agentsModule, dbModule };
+}
+function findTool(tools, name) {
+    const tool = tools.find((entry) => entry.name === name);
+    assert.ok(tool, `${name} tool should be registered`);
+    return tool;
+}
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-memory-"));
+});
+test.afterEach(async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    if (home) {
+        const dbModule = await import("../store/db.js");
+        dbModule.closeDb();
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("memory_set_scope invalidates the orchestrator session after scheduling the scope-change checkpoint", async (t) => {
+    const events = [];
+    t.mock.module("./orchestrator.js", {
+        namedExports: {
+            getCurrentSourceChannel: () => "web",
+            getCurrentActivityCallback: () => undefined,
+            getCurrentActiveProjectRules: () => null,
+            getCurrentAuthenticatedUser: () => undefined,
+            getLastAuthenticatedUser: () => undefined,
+            getCurrentAuthorizationHeader: () => undefined,
+            getCurrentSessionKey: () => "session-test",
+            maybeScheduleScopeChangeCheckpoint: (sessionKey, previousScope, nextScope) => {
+                events.push(`checkpoint:${sessionKey}:${previousScope?.slug ?? "null"}->${nextScope?.slug ?? "null"}`);
+            },
+            resetCheckpointSessionState: (sessionKey) => {
+                events.push(`reset:${sessionKey}`);
+            },
+            invalidateOrchestratorSession: (sessionKey) => {
+                events.push(`invalidate:${sessionKey}`);
+            },
+            switchSessionModel: async () => { },
+        },
+    });
+    const { toolsModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const memoryRemember = findTool(tools, "memory_remember");
+    const memorySetScope = findTool(tools, "memory_set_scope");
+    const remembered = await memoryRemember.handler({
+        content: "Scope changes should refresh hot-tier memory on the next turn.",
+        scope: "chapterhouse",
+        kind: "observation",
+    }, {});
+    assert.equal(remembered.ok, true);
+    events.length = 0;
+    const result = await memorySetScope.handler({ slug: "chapterhouse" }, {});
+    assert.equal(result.active_scope?.slug, "chapterhouse");
+    assert.deepEqual(events, [
+        "checkpoint:session-test:null->chapterhouse",
+        "invalidate:session-test",
+        "reset:session-test",
+    ]);
+    events.length = 0;
+    const unchangedResult = await memorySetScope.handler({ slug: "chapterhouse" }, {});
+    assert.equal(unchangedResult.active_scope?.slug, "chapterhouse");
+    assert.deepEqual(events, []);
+});
+test("memory tools remember, recall, set scope, and enforce orchestrator-only writes", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const memoryRemember = findTool(tools, "memory_remember");
+    const memoryRecall = findTool(tools, "memory_recall");
+    const memorySetScope = findTool(tools, "memory_set_scope");
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools);
+    const chapterhouseRemember = findTool(chapterhouseTools, "memory_remember");
+    const chapterhouseRecall = findTool(chapterhouseTools, "memory_recall");
+    const chapterhouseSetScope = findTool(chapterhouseTools, "memory_set_scope");
+    const remembered = await chapterhouseRemember.handler({
+        content: "Use SQLite FTS5 to recall scoped memory entries.",
+        scope: "chapterhouse",
+        kind: "observation",
+    }, {});
+    assert.equal(typeof remembered, "object");
+    assert.equal(remembered.ok, true);
+    const db = dbModule.getDb();
+    const row = db.prepare(`
+    SELECT id, content
+    FROM mem_observations
+    WHERE content = ?
+  `).get("Use SQLite FTS5 to recall scoped memory entries.");
+    assert.ok(row, "memory_remember should write an observation row");
+    const ftsHits = db.prepare(`
+    SELECT rowid
+    FROM mem_observations_fts
+    WHERE mem_observations_fts MATCH 'SQLite'
+  `).all();
+    assert.equal(ftsHits.some((hit) => hit.rowid === row.id), true);
+    const recalled = await chapterhouseRecall.handler({
+        query: "SQLite FTS5 scoped memory",
+        scope: "chapterhouse",
+        limit: 10,
+    }, {});
+    assert.equal(typeof recalled, "object");
+    assert.equal((recalled.hits ?? []).some((hit) => hit.id === row.id), true);
+    const scopeResult = await chapterhouseSetScope.handler({ slug: "chapterhouse" }, {});
+    assert.equal(scopeResult.active_scope?.slug, "chapterhouse");
+    const implicitScopeRemember = await chapterhouseRemember.handler({
+        content: "Implicit active-scope writes should route to chapterhouse.",
+        kind: "observation",
+    }, {});
+    assert.equal(implicitScopeRemember.ok, true);
+    const coderVisibleTools = agentsModule.filterToolsForAgent({
+        slug: "coder",
+        name: "Coder",
+        description: "Software engineer",
+        model: "gpt-5.4",
+        systemMessage: "test",
+    }, tools);
+    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_remember"), false);
+    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_set_scope"), false);
+    assert.equal(coderVisibleTools.some((tool) => tool.name === "memory_recall"), true);
+    const coderRemember = findTool(coderTools, "memory_remember");
+    const rejected = await coderRemember.handler({
+        content: "Subagents should not be able to write memory directly.",
+        scope: "chapterhouse",
+        kind: "observation",
+    }, {});
+    assert.match(String(rejected), /orchestrator-only|memory_propose/i);
+    const coderRecall = findTool(coderVisibleTools, "memory_recall");
+    const coderRecalled = await coderRecall.handler({
+        query: "SQLite",
+        scope: "chapterhouse",
+        limit: 10,
+    }, {});
+    assert.equal(typeof coderRecalled, "object");
+    assert.equal((coderRecalled.hits ?? []).some((hit) => hit.id === row.id), true);
+    assert.ok(memoryRemember && memoryRecall && memorySetScope);
+});
+test("memory_propose queues pending proposals, defaults scope from the active scope, and captures delegated task context", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools, "task-propose-001");
+    const memorySetScope = findTool(chapterhouseTools, "memory_set_scope");
+    const memoryPropose = findTool(coderTools, "memory_propose");
+    await memorySetScope.handler({ slug: "chapterhouse" }, {});
+    const proposed = await memoryPropose.handler({
+        kind: "observation",
+        payload: {
+            content: "Subagents can queue durable observations for orchestrator review.",
+            source: "final task summary",
+        },
+        confidence: 0.9,
+        reason: "The user explicitly asked for the new proposal path.",
+    }, {});
+    assert.equal(proposed.status, "queued");
+    assert.equal(typeof proposed.proposal_id, "number");
+    const db = dbModule.getDb();
+    const row = db.prepare(`
+    SELECT kind, status, source_agent, source_task_id, payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    assert.ok(row, "memory_propose should insert a mem_inbox row");
+    assert.equal(row.kind, "memory_proposal");
+    assert.equal(row.status, "pending");
+    assert.equal(row.source_agent, "coder");
+    assert.equal(row.source_task_id, "task-propose-001");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.kind, "observation");
+    assert.equal(payload.scope_slug, "chapterhouse");
+    assert.equal(payload.confidence, 0.9);
+    assert.equal(payload.reason, "The user explicitly asked for the new proposal path.");
+    assert.equal(payload.payload.content, "Subagents can queue durable observations for orchestrator review.");
+});
+test("memory_propose rejects invalid proposal kinds", async () => {
+    const { toolsModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const memoryPropose = findTool(tools, "memory_propose");
+    const result = await memoryPropose.handler({
+        kind: "pattern",
+        payload: { content: "invalid kind" },
+    }, {});
+    assert.match(String(result), /observation|decision|entity/i);
+});
+test("memory_housekeep is orchestrator-only and returns housekeeping summaries", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools);
+    const memorySetScope = findTool(chapterhouseTools, "memory_set_scope");
+    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
+    const memoryHousekeep = findTool(chapterhouseTools, "memory_housekeep");
+    const coderHousekeep = findTool(coderTools, "memory_housekeep");
+    await memorySetScope.handler({ slug: "chapterhouse" }, {});
+    const remembered = await memoryRemember.handler({
+        content: "Very old low-confidence memory should be archived by housekeeping.",
+        scope: "chapterhouse",
+        kind: "observation",
+    }, {});
+    const observationId = remembered.id;
+    const db = dbModule.getDb();
+    db.prepare(`
+    UPDATE mem_observations
+    SET confidence = 0.1, created_at = datetime('now', '-31 days')
+    WHERE id = ?
+  `).run(observationId);
+    const denied = await coderHousekeep.handler({ passes: ["decay"] }, {});
+    assert.match(String(denied), /orchestrator-only/i);
+    const visibleToCoder = agentsModule.filterToolsForAgent({
+        slug: "coder",
+        name: "Coder",
+        description: "Software engineer",
+        model: "gpt-5.4",
+        systemMessage: "test",
+    }, tools);
+    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_housekeep"), false);
+    const result = await memoryHousekeep.handler({
+        scope_slug: "chapterhouse",
+        passes: ["decay"],
+    }, {});
+    assert.equal(result.ok, true);
+    assert.deepEqual(result.scope_ids.length, 1);
+    assert.equal(result.summaries[0]?.pass, "decayPass");
+    assert.equal(result.summaries[0]?.modified, 1);
+});
+test("memory_promote and memory_demote are orchestrator-only manual tier controls", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools);
+    const memoryRemember = findTool(chapterhouseTools, "memory_remember");
+    const memoryPromote = findTool(chapterhouseTools, "memory_promote");
+    const memoryDemote = findTool(chapterhouseTools, "memory_demote");
+    const coderPromote = findTool(coderTools, "memory_promote");
+    const coderDemote = findTool(coderTools, "memory_demote");
+    const remembered = await memoryRemember.handler({
+        content: "Manual tier controls should change this observation.",
+        scope: "chapterhouse",
+        kind: "observation",
+    }, {});
+    const observationId = remembered.id;
+    const db = dbModule.getDb();
+    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "warm");
+    const deniedPromote = await coderPromote.handler({ table: "observation", id: observationId, reason: "test" }, {});
+    const deniedDemote = await coderDemote.handler({ table: "observation", id: observationId, reason: "test" }, {});
+    assert.match(String(deniedPromote), /orchestrator-only/i);
+    assert.match(String(deniedDemote), /orchestrator-only/i);
+    assert.equal(agentsModule.filterToolsForAgent({
+        slug: "coder",
+        name: "Coder",
+        description: "Software engineer",
+        model: "gpt-5.4",
+        systemMessage: "test",
+    }, tools).some((tool) => tool.name === "memory_promote" || tool.name === "memory_demote"), false);
+    const promoted = await memoryPromote.handler({ table: "observation", id: observationId, reason: "actively relevant" }, {});
+    assert.equal(promoted.ok, true);
+    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "hot");
+    const demoted = await memoryDemote.handler({ table: "observation", id: observationId, reason: "no longer active", tier: "cold" }, {});
+    assert.equal(demoted.ok, true);
+    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(observationId).tier, "cold");
+});
+//# sourceMappingURL=tools.memory.test.js.map

package/dist/copilot/turn-event-log-env.test.js

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+test("SESSION_BUFFER_CAPACITY respects CHAPTERHOUSE_SSE_BUFFER_CAPACITY", async () => {
+    const previous = process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY;
+    process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = "3";
+    try {
+        const module = await import(`./turn-event-log.js?capacity=${Date.now()}`);
+        assert.equal(module.SESSION_BUFFER_CAPACITY, 3);
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY;
+        }
+        else {
+            process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = previous;
+        }
+    }
+});
+//# sourceMappingURL=turn-event-log-env.test.js.map

package/dist/copilot/turn-event-log.js

@@ -3,8 +3,8 @@
  *
  * Architecture decisions (from Mal #129):
  *  - Events accumulate in a per-turn ring buffer (200 events) during the turn.
- *  - A parallel per-session ring buffer (200 events) feeds the SSE reconnect path.
- *  - On turn completion, events are persisted to the `turn_events` SQLite table.
+ *  - A parallel per-session ring buffer feeds the hot SSE reconnect path.
+ *  - Events are persisted to the `turn_events` SQLite table as they are emitted.
  *  - The per-turn buffer is cleared after a 30 s grace window so late reconnects
  *    can still replay from memory before SQLite is needed.
  *  - After the grace window, SSE replay falls back to SQLite.
@@ -13,7 +13,7 @@
  *  - `emitTurnEvent(sessionKey, event)` — emit an event (called from orchestrator.ts)
  *  - `subscribeTurn(turnId, listener)` — per-turn subscribe with immediate replay
  *  - `subscribeSession(sessionKey, listener, afterSeq?)` — session SSE subscribe + replay
- *  - `persistTurnEvents(turnId, sessionKey)` — write ring buffer to SQLite
+ *  - `persistTurnEvents(turnId, sessionKey)` — compatibility no-op after eager persistence
  *  - `scheduleClearTurnLog(turnId)` — schedule buffer clear after grace window
  *  - `getSessionEventsFromDb(sessionKey, afterSeq)` — SQLite fallback for completed turns
  *
@@ -21,6 +21,7 @@
  */
 import { childLogger } from "../util/logger.js";
 import { getDb } from "../store/db.js";
+import { config } from "../config.js";
 import { RingBuffer } from "./ring-buffer.js";
 const log = childLogger("turn-event-log");
 // ---------------------------------------------------------------------------
@@ -29,7 +30,9 @@ const log = childLogger("turn-event-log");
 /** Events retained per turn in memory (covers long turns with many tool calls). */
 export const TURN_BUFFER_CAPACITY = 200;
 /** Recent events retained per session for SSE reconnect replay. */
-export const SESSION_BUFFER_CAPACITY = 200;
+export const SESSION_BUFFER_CAPACITY = config.sseBufferCapacity;
+/** Maximum SQLite replay events returned for one session reconnect. */
+export const SESSION_REPLAY_LIMIT = config.sseReplayLimit;
 /** Grace window before per-turn buffer is cleared after turn completion (ms). */
 export const TURN_CLEAR_GRACE_MS = 30_000;
 // ---------------------------------------------------------------------------
@@ -58,6 +61,7 @@ let globalSeq = 0;
  */
 export function emitTurnEvent(sessionKey, event) {
     const indexed = { ...event, _seq: ++globalSeq, _ts: Date.now() };
+    persistIndexedTurnEvent(sessionKey, indexed);
     // Per-turn buffer --------------------------------------------------------
     const turnId = event.turnId;
     let entry = turnBuffers.get(turnId);
@@ -182,31 +186,26 @@ export function subscribeSession(sessionKey, listener, afterSeq) {
 // Persistence
 // ---------------------------------------------------------------------------
 /**
- * Persist the turn's buffered events to the `turn_events` SQLite table.
- * Called on `turn:complete` and `turn:error` before scheduling the clear.
- * No-ops silently if the turn has no buffered events.
+ * Persist one indexed event to the `turn_events` SQLite table synchronously.
+ * SQLite is the replay source of truth; the in-memory rings are hot caches.
  */
-export function persistTurnEvents(turnId, sessionKey) {
-    const entry = turnBuffers.get(turnId);
-    if (!entry)
-        return;
-    const events = entry.buf.getAll();
-    if (events.length === 0)
-        return;
+function persistIndexedTurnEvent(sessionKey, event) {
     try {
         const db = getDb();
-        const stmt = db.prepare(`INSERT OR IGNORE INTO turn_events (turn_id, session_key, seq, ts, event_type, payload)
+        const stmt = db.prepare(`INSERT INTO turn_events (turn_id, session_key, seq, ts, event_type, payload)
        VALUES (?, ?, ?, ?, ?, ?)`);
-        db.transaction(() => {
-            for (const e of events) {
-                stmt.run(turnId, sessionKey, e._seq, e._ts, e.type, JSON.stringify(e));
-            }
-        })();
+        stmt.run(event.turnId, sessionKey, event._seq, event._ts, event.type, JSON.stringify(event));
     }
     catch (err) {
-        log.warn({ err: err instanceof Error ? err.message : err, turnId }, "turn-event-log: SQLite persist failed");
+        log.warn({ err: err instanceof Error ? err.message : err, turnId: event.turnId }, "turn-event-log: SQLite persist failed");
     }
 }
+/**
+ * Compatibility no-op for callers that still finalize turns through this API.
+ * Events are now persisted eagerly by emitTurnEvent(), including terminal events.
+ */
+export function persistTurnEvents(_turnId, _sessionKey) {
+}
 // ---------------------------------------------------------------------------
 // Lifecycle — clear
 // ---------------------------------------------------------------------------
@@ -272,8 +271,8 @@ export function getSessionEventsFromDb(sessionKey, afterSeq = 0) {
             .prepare(`SELECT payload FROM turn_events
           WHERE session_key = ? AND seq > ?
           ORDER BY seq ASC
-          LIMIT 500`)
-            .all(sessionKey, afterSeq);
+          LIMIT ?`)
+            .all(sessionKey, afterSeq, SESSION_REPLAY_LIMIT);
         return rows.map((r) => JSON.parse(r.payload));
     }
     catch (err) {

package/dist/copilot/turn-event-log.test.js

@@ -25,17 +25,21 @@
 import { describe, it, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { setTimeout as setTimeoutPromise } from "node:timers/promises";
-import { emitTurnEvent, subscribeTurn, subscribeSession, clearTurnLog, scheduleClearTurnLog, turnLogSize, oldestSessionSeq, TURN_BUFFER_CAPACITY, SESSION_BUFFER_CAPACITY, } from "./turn-event-log.js";
+import { emitTurnEvent, subscribeTurn, subscribeSession, clearTurnLog, scheduleClearTurnLog, turnLogSize, oldestSessionSeq, persistTurnEvents, getSessionEventsFromDb, TURN_BUFFER_CAPACITY, SESSION_BUFFER_CAPACITY, } from "./turn-event-log.js";
+import { getDb } from "../store/db.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 let turnCounter = 0;
 let sessionCounter = 0;
+const usedSessionKeys = [];
 function freshTurnId() {
     return `turn-test-${++turnCounter}-${Date.now()}`;
 }
 function freshSessionKey() {
-    return `session-test-${++sessionCounter}-${Date.now()}`;
+    const sessionKey = `session-test-${++sessionCounter}-${Date.now()}`;
+    usedSessionKeys.push(sessionKey);
+    return sessionKey;
 }
 function makeStarted(turnId, sessionKey) {
     return { type: "turn:started", turnId, sessionKey, prompt: "hello" };
@@ -63,6 +67,14 @@ afterEach(() => {
     for (const id of usedTurnIds.splice(0)) {
         clearTurnLog(id);
     }
+    const sessions = usedSessionKeys.splice(0);
+    if (sessions.length > 0) {
+        const db = getDb();
+        const deleteSessionEvents = db.prepare("DELETE FROM turn_events WHERE session_key = ?");
+        for (const sessionKey of sessions) {
+            deleteSessionEvents.run(sessionKey);
+        }
+    }
 });
 function trackTurn(turnId) {
     usedTurnIds.push(turnId);
@@ -98,6 +110,15 @@ describe("turn-event-log", () => {
             const after = Date.now();
             assert.ok(collected[0]._ts >= before && collected[0]._ts <= after);
         });
+        it("persists each event to SQLite immediately", () => {
+            const session = freshSessionKey();
+            const turnId = trackTurn(freshTurnId());
+            emitTurnEvent(session, makeStarted(turnId, session));
+            const persisted = getSessionEventsFromDb(session);
+            assert.equal(persisted.length, 1);
+            assert.equal(persisted[0].type, "turn:started");
+            assert.equal(persisted[0].turnId, turnId);
+        });
     });
     describe("subscribeTurn", () => {
         it("replays existing buffered events immediately on subscribe", () => {
@@ -224,6 +245,16 @@ describe("turn-event-log", () => {
             assert.equal(recv1[0].turnId, turn1);
             assert.equal(recv2[0].turnId, turn2);
         });
+        it("SQLite fallback returns events from an in-flight turn", () => {
+            const session = freshSessionKey();
+            const turnId = trackTurn(freshTurnId());
+            emitTurnEvent(session, makeStarted(turnId, session));
+            emitTurnEvent(session, makeDelta(turnId, session, "still-running"));
+            const persisted = getSessionEventsFromDb(session);
+            assert.equal(persisted.length, 2);
+            assert.deepEqual(persisted.map((event) => event.type), ["turn:started", "turn:delta"]);
+            assert.equal(persisted[1].part.text, "still-running");
+        });
     });
     describe("clearTurnLog", () => {
         it("removes the per-turn buffer immediately", () => {
@@ -321,6 +352,34 @@ describe("turn-event-log", () => {
             trackUnsub(subscribeTurn(turnId, (e) => received.push(e)));
             assert.equal(received.length, TURN_BUFFER_CAPACITY);
         });
+        it("SQLite replay keeps events that were evicted from the session ring buffer", () => {
+            const session = freshSessionKey();
+            const turnId = trackTurn(freshTurnId());
+            const totalEvents = SESSION_BUFFER_CAPACITY + 3;
+            for (let i = 0; i < totalEvents; i++) {
+                emitTurnEvent(session, makeDelta(turnId, session, `chunk-${i}`));
+            }
+            const fromBuffer = [];
+            const unsubscribe = subscribeSession(session, (event) => fromBuffer.push(event), 0);
+            unsubscribe();
+            assert.equal(fromBuffer.length, SESSION_BUFFER_CAPACITY);
+            const fromDb = getSessionEventsFromDb(session);
+            assert.equal(fromDb.length, totalEvents);
+            assert.equal(fromDb[0].part.text, "chunk-0");
+        });
+    });
+    describe("persistTurnEvents", () => {
+        it("does not double-write events that were eagerly persisted by turn completion", () => {
+            const session = freshSessionKey();
+            const turnId = trackTurn(freshTurnId());
+            emitTurnEvent(session, makeStarted(turnId, session));
+            emitTurnEvent(session, makeComplete(turnId, session));
+            assert.equal(getSessionEventsFromDb(session).length, 2);
+            persistTurnEvents(turnId, session);
+            const persisted = getSessionEventsFromDb(session);
+            assert.equal(persisted.length, 2);
+            assert.deepEqual(persisted.map((event) => event.type), ["turn:started", "turn:complete"]);
+        });
     });
 });
 //# sourceMappingURL=turn-event-log.test.js.map

package/dist/memory/active-scope.js

@@ -0,0 +1,69 @@
+import { getDb } from "../store/db.js";
+import { getScope, listScopes } from "./scopes.js";
+const ACTIVE_SCOPE_KEY = "current_scope_slug";
+function setSetting(key, value) {
+    getDb().prepare(`
+    INSERT INTO mem_settings (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(key, value);
+}
+function getSetting(key) {
+    const row = getDb().prepare(`
+    SELECT value
+    FROM mem_settings
+    WHERE key = ?
+  `).get(key);
+    return row?.value;
+}
+function clearSetting(key) {
+    getDb().prepare(`DELETE FROM mem_settings WHERE key = ?`).run(key);
+}
+export function getActiveScope() {
+    const slug = getSetting(ACTIVE_SCOPE_KEY);
+    if (!slug)
+        return null;
+    const scope = getScope(slug);
+    if (!scope) {
+        clearSetting(ACTIVE_SCOPE_KEY);
+        return null;
+    }
+    return scope;
+}
+export function setActiveScope(slug) {
+    if (slug === null) {
+        clearSetting(ACTIVE_SCOPE_KEY);
+        return null;
+    }
+    const scope = getScope(slug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${slug}'.`);
+    }
+    setSetting(ACTIVE_SCOPE_KEY, scope.slug);
+    return scope;
+}
+export function inferScopeFromText(text) {
+    const lowered = text.toLowerCase();
+    const ranked = listScopes()
+        .filter((scope) => scope.active)
+        .map((scope) => {
+        const matchedKeywords = scope.keywords.filter((keyword, index, keywords) => lowered.includes(keyword.toLowerCase()) && keywords.indexOf(keyword) === index);
+        return { scope, matchedKeywords };
+    })
+        .filter((entry) => entry.matchedKeywords.length > 0)
+        .sort((a, b) => {
+        if (b.matchedKeywords.length !== a.matchedKeywords.length) {
+            return b.matchedKeywords.length - a.matchedKeywords.length;
+        }
+        return a.scope.slug.localeCompare(b.scope.slug);
+    });
+    const winner = ranked[0];
+    if (!winner)
+        return null;
+    return {
+        scope_id: winner.scope.id,
+        confidence: winner.matchedKeywords.length / Math.max(winner.scope.keywords.length, 1),
+        matched_keywords: winner.matchedKeywords,
+    };
+}
+//# sourceMappingURL=active-scope.js.map

package/dist/memory/active-scope.test.js

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-active-scope-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("active scope can be set, read, and cleared without changing scope activation status", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const getActiveScope = getFunction(memoryModule, "getActiveScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const deactivateScope = getFunction(memoryModule, "deactivateScope");
+    assert.equal(getActiveScope(), null);
+    assert.equal(setActiveScope("chapterhouse")?.slug, "chapterhouse");
+    assert.equal(getActiveScope()?.slug, "chapterhouse");
+    const team = getScope("team");
+    assert.ok(team);
+    const deactivated = deactivateScope(team.id);
+    assert.equal(deactivated.active, false);
+    assert.equal(getActiveScope()?.slug, "chapterhouse");
+    assert.equal(setActiveScope(null), null);
+    assert.equal(getActiveScope(), null);
+});
+test("inferScopeFromText prefers the highest keyword match count and breaks ties deterministically", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const createScope = getFunction(memoryModule, "createScope");
+    const inferScopeFromText = getFunction(memoryModule, "inferScopeFromText");
+    const alpha = createScope({
+        slug: "alpha-release",
+        title: "Alpha Release",
+        description: "Alpha release work",
+        keywords: ["release"],
+    });
+    const beta = createScope({
+        slug: "beta-deploy",
+        title: "Beta Deploy",
+        description: "Deployment work",
+        keywords: ["deploy", "release"],
+    });
+    const bestMatch = inferScopeFromText("Please deploy the release workflow today.");
+    assert.equal(bestMatch?.scope_id, beta.id);
+    assert.deepEqual(bestMatch?.matched_keywords.sort(), ["deploy", "release"]);
+    const tie = inferScopeFromText("This release needs triage.");
+    assert.equal(tie?.scope_id, alpha.id);
+    assert.deepEqual(tie?.matched_keywords, ["release"]);
+});
+//# sourceMappingURL=active-scope.test.js.map