chapterhouse 0.4.1 → 0.4.2

package/dist/api/server.js

@@ -23,9 +23,9 @@ import { withWikiWrite } from "../wiki/lock.js";
 import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH } from "../paths.js";
-import { getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
+import { getCurrentRunId, getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
 import { getTaskLogEvents, subscribeTaskLog } from "../copilot/task-event-log.js";
-import { subscribeSession, getSessionEventsFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
+import { subscribeSession, getSessionEventsFromDb, getSessionMaxSeqFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
 import { getStatus, onStatusChange } from "../status.js";
 import { formatSseData, formatSseEvent } from "./sse.js";
 import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
@@ -728,6 +728,7 @@ if (config.chatSseEnabled) {
         const sessionKey = Array.isArray(req.params.key) ? req.params.key[0] : req.params.key;
         if (!sessionKey)
             throw new BadRequestError("Missing session key");
+        const includeHistorical = req.query.include === "all";
         res.setHeader("Content-Type", "text/event-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.setHeader("Connection", "keep-alive");
@@ -738,6 +739,10 @@ if (config.chatSseEnabled) {
         const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
             ? parseInt(rawLastId.trim(), 10)
             : undefined;
+        const maxCurrentSeq = getSessionMaxSeqFromDb(sessionKey, { includeHistorical });
+        const effectiveLastSeq = maxCurrentSeq !== undefined && lastSeq !== undefined && lastSeq > maxCurrentSeq
+            ? 0
+            : lastSeq;
         // Helper: send a named SSE event with an id: field
         const sendEvent = (event, seq) => {
             const payload = JSON.stringify(event);
@@ -745,13 +750,13 @@ if (config.chatSseEnabled) {
         };
         // If Last-Event-ID is present and the session ring buffer doesn't cover it,
         // fall back to SQLite for replay of completed turns.
-        let replayHighSeq = lastSeq;
-        if (lastSeq !== undefined) {
+        let replayHighSeq = effectiveLastSeq;
+        if (effectiveLastSeq !== undefined) {
             const oldestBuf = oldestSessionSeq(sessionKey);
-            const bufferMissesRange = oldestBuf === undefined || oldestBuf > lastSeq + 1;
+            const bufferMissesRange = oldestBuf === undefined || oldestBuf > effectiveLastSeq + 1;
             if (bufferMissesRange) {
                 // Replay from SQLite (completed turns)
-                const dbEvents = getSessionEventsFromDb(sessionKey, lastSeq);
+                const dbEvents = getSessionEventsFromDb(sessionKey, effectiveLastSeq, { includeHistorical });
                 for (const e of dbEvents) {
                     sendEvent(e, e._seq);
                     if (replayHighSeq === undefined || e._seq > replayHighSeq)
@@ -766,7 +771,7 @@ if (config.chatSseEnabled) {
             sendEvent(e, e._seq);
         }, replayHighSeq);
         // Send connected event
-        res.write(`: connected session=${sessionKey}\n\n`);
+        res.write(`: connected session=${sessionKey} run=${getCurrentRunId()}\n\n`);
         // Keep-alive every 15 s
         const keepAlive = setInterval(() => {
             res.write(`: keep-alive\n\n`);
@@ -1063,7 +1068,8 @@ app.get("/api/session/:sessionKey/messages", (req, res) => {
     if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
         throw new BadRequestError("'limit' must be a positive integer");
     }
-    const messages = getSessionMessages(sessionKey, limit);
+    const includeHistorical = req.query.include === "all";
+    const messages = getSessionMessages(sessionKey, limit, { includeHistorical });
     res.json({ sessionKey, messages });
 });
 app.use(apiNotFoundHandler);

package/dist/api/server.test.js

@@ -371,6 +371,36 @@ test("server worker detail returns the stored dispatched prompt", async () => {
         assert.equal(body.completedAt, null);
     });
 });
+test("server session message hydration returns current run by default and include=all returns history", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(join(testRoot, ".chapterhouse", "chapterhouse.db"));
+        try {
+            const currentRun = db.prepare(`SELECT run_id FROM daemon_runs LIMIT 1`).get();
+            db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, run_id)
+         VALUES ('user', ?, 'web', 'hydration-session', ?)`).run("previous run", "previous-run");
+            db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, run_id)
+         VALUES ('assistant', ?, 'web', 'hydration-session', ?)`).run("current run", currentRun.run_id);
+        }
+        finally {
+            db.close();
+        }
+        const currentOnly = await fetch(`${baseUrl}/api/session/hydration-session/messages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(currentOnly.status, 200);
+        assert.deepEqual((await currentOnly.json()).messages.map((message) => message.content), [
+            "current run",
+        ]);
+        const allRuns = await fetch(`${baseUrl}/api/session/hydration-session/messages?include=all`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(allRuns.status, 200);
+        assert.deepEqual((await allRuns.json()).messages.map((message) => message.content), [
+            "previous run",
+            "current run",
+        ]);
+    });
+});
 test("server wiki route synthesizes a welcome page when pages/index.md is missing", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
         rmSync(join(testRoot, ".chapterhouse", "wiki", "pages", "index.md"), { force: true });

package/dist/copilot/orchestrator.js

@@ -1104,11 +1104,11 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation(logRole, prompt, sourceLabel, sessionKey);
+                    logConversation(logRole, prompt, sourceLabel, sessionKey, turnId);
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
@@ -1205,11 +1205,11 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("user", newPrompt, sourceLabel, sessionKey);
+                    logConversation("user", newPrompt, sourceLabel, sessionKey, turnId);
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);

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

@@ -20,7 +20,7 @@
  * @module copilot/turn-event-log
  */
 import { childLogger } from "../util/logger.js";
-import { getDb } from "../store/db.js";
+import { getCurrentRunId, getDb } from "../store/db.js";
 import { config } from "../config.js";
 import { RingBuffer } from "./ring-buffer.js";
 const log = childLogger("turn-event-log");
@@ -192,9 +192,9 @@ export function subscribeSession(sessionKey, listener, afterSeq) {
 function persistIndexedTurnEvent(sessionKey, event) {
     try {
         const db = getDb();
-        const stmt = db.prepare(`INSERT INTO turn_events (turn_id, session_key, seq, ts, event_type, payload)
-       VALUES (?, ?, ?, ?, ?, ?)`);
-        stmt.run(event.turnId, sessionKey, event._seq, event._ts, event.type, JSON.stringify(event));
+        const stmt = db.prepare(`INSERT INTO turn_events (turn_id, session_key, run_id, seq, ts, event_type, payload)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        stmt.run(event.turnId, sessionKey, getCurrentRunId(), event._seq, event._ts, event.type, JSON.stringify(event));
     }
     catch (err) {
         log.warn({ err: err instanceof Error ? err.message : err, turnId: event.turnId }, "turn-event-log: SQLite persist failed");
@@ -260,19 +260,24 @@ export function getTurnEventsFromDb(turnId, afterSeq = 0) {
         return [];
     }
 }
-/**
- * Return persisted events for a session from SQLite, after a given sequence number.
- * Used as SSE replay fallback when the session buffer doesn't cover the requested range.
- */
-export function getSessionEventsFromDb(sessionKey, afterSeq = 0) {
+export function getSessionEventsFromDb(sessionKey, afterSeq = 0, options = {}) {
     try {
         const db = getDb();
-        const rows = db
-            .prepare(`SELECT payload FROM turn_events
-          WHERE session_key = ? AND seq > ?
-          ORDER BY seq ASC
-          LIMIT ?`)
-            .all(sessionKey, afterSeq, SESSION_REPLAY_LIMIT);
+        const includeHistorical = options.includeHistorical ?? false;
+        const runId = options.runId ?? getCurrentRunId();
+        const rows = includeHistorical
+            ? db
+                .prepare(`SELECT payload FROM turn_events
+            WHERE session_key = ? AND seq > ?
+            ORDER BY id ASC
+            LIMIT ?`)
+                .all(sessionKey, afterSeq, SESSION_REPLAY_LIMIT)
+            : db
+                .prepare(`SELECT payload FROM turn_events
+            WHERE session_key = ? AND run_id = ? AND seq > ?
+            ORDER BY seq ASC
+            LIMIT ?`)
+                .all(sessionKey, runId, afterSeq, SESSION_REPLAY_LIMIT);
         return rows.map((r) => JSON.parse(r.payload));
     }
     catch (err) {
@@ -280,6 +285,21 @@ export function getSessionEventsFromDb(sessionKey, afterSeq = 0) {
         return [];
     }
 }
+export function getSessionMaxSeqFromDb(sessionKey, options = {}) {
+    try {
+        const db = getDb();
+        const includeHistorical = options.includeHistorical ?? false;
+        const runId = options.runId ?? getCurrentRunId();
+        const row = includeHistorical
+            ? db.prepare(`SELECT MAX(seq) AS max_seq FROM turn_events WHERE session_key = ?`).get(sessionKey)
+            : db.prepare(`SELECT MAX(seq) AS max_seq FROM turn_events WHERE session_key = ? AND run_id = ?`).get(sessionKey, runId);
+        return row?.max_seq ?? undefined;
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, sessionKey }, "turn-event-log: SQLite session max-seq read failed");
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // Diagnostics
 // ---------------------------------------------------------------------------

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

@@ -119,6 +119,37 @@ describe("turn-event-log", () => {
             assert.equal(persisted[0].type, "turn:started");
             assert.equal(persisted[0].turnId, turnId);
         });
+        it("replays persisted session events from the current daemon run by default and can include historical runs", () => {
+            const session = freshSessionKey();
+            const db = getDb();
+            const columns = db.prepare("PRAGMA table_info(turn_events)").all();
+            if (!columns.some((column) => column.name === "run_id")) {
+                db.exec("ALTER TABLE turn_events ADD COLUMN run_id TEXT");
+            }
+            const insert = db.prepare(`INSERT INTO turn_events (turn_id, session_key, seq, ts, event_type, payload, run_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`);
+            const previous = {
+                type: "turn:complete",
+                turnId: "previous-turn",
+                sessionKey: session,
+                finalMessage: "previous",
+                _seq: 10,
+                _ts: 10,
+            };
+            const current = {
+                type: "turn:complete",
+                turnId: "current-turn",
+                sessionKey: session,
+                finalMessage: "current",
+                _seq: 11,
+                _ts: 11,
+            };
+            insert.run(previous.turnId, session, previous._seq, previous._ts, previous.type, JSON.stringify(previous), "previous-run");
+            insert.run(current.turnId, session, current._seq, current._ts, current.type, JSON.stringify(current), "current-run");
+            const getEvents = getSessionEventsFromDb;
+            assert.deepEqual(getEvents(session, 0, { runId: "current-run" }).map((event) => event.turnId), ["current-turn"]);
+            assert.deepEqual(getEvents(session, 0, { runId: "current-run", includeHistorical: true }).map((event) => event.turnId), ["previous-turn", "current-turn"]);
+        });
     });
     describe("subscribeTurn", () => {
         it("replays existing buffered events immediately on subscribe", () => {

package/dist/memory/eot.test.js

@@ -65,7 +65,7 @@ test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENAB
         },
     });
     assert.equal(llmCalls, 0);
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Disabled hooks must not persist memory."), false);
     const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(row.status, "pending");
 });
@@ -185,7 +185,7 @@ test("runEndOfTaskMemoryHook leaves reviewed proposals pending when CHAPTERHOUSE
             implicit_memories: [],
         }),
     });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Review can approve this, but auto-accept is disabled."), false);
     const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(row.status, "pending");
 });
@@ -214,7 +214,7 @@ test("runEndOfTaskMemoryHook rejects pending same-task proposals omitted by the
             implicit_memories: [],
         }),
     });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Reviewer omissions should not silently leave proposals pending."), false);
     const row = db.prepare(`
     SELECT status, resolution_reason
     FROM mem_inbox

package/dist/memory/housekeeping.test.js

@@ -45,30 +45,30 @@ test("dedupObservationsPass supersedes similar observations in scope determinist
     const team = getScope("team");
     assert.ok(chapterhouse && team);
     const first = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "The worker event stream uses server sent events for live task output.",
         source: "test",
         confidence: 0.4,
     });
     const keeper = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "Worker event streams use server sent events for live task output.",
         source: "test",
         confidence: 0.9,
     });
     const third = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "The worker event stream uses server sent events for live task output today.",
         source: "test",
         confidence: 0.9,
     });
     const otherScope = recordObservation({
-        scope_id: team.id,
+        scope_id: chapterhouse.id,
         content: "Worker event streams use server sent events for live task output.",
         source: "test",
         confidence: 0.1,
     });
-    const summary = housekeepingModule.dedupObservationsPass(chapterhouse.id);
+    const summary = housekeepingModule.dedupObservationsPass(team.id);
     assert.equal(summary.pass, "dedupObservationsPass");
     assert.equal(summary.examined, 3);
     assert.equal(summary.modified, 2);
@@ -79,7 +79,7 @@ test("dedupObservationsPass supersedes similar observations in scope determinist
         { id: third.id, superseded_by: keeper.id },
     ]);
     assert.equal(db.prepare(`SELECT superseded_by FROM mem_observations WHERE id = ?`).get(otherScope.id).superseded_by, null);
-    const second = housekeepingModule.dedupObservationsPass(chapterhouse.id);
+    const second = housekeepingModule.dedupObservationsPass(team.id);
     assert.equal(second.modified, 0);
 });
 test("dedupDecisionsPass supersedes similar active decisions within scope and keeps the latest decision", async () => {
@@ -88,39 +88,39 @@ test("dedupDecisionsPass supersedes similar active decisions within scope and ke
     const getScope = getFunction(memoryModule, "getScope");
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const chapterhouse = getScope("chapterhouse");
     const team = getScope("team");
-    assert.ok(chapterhouse && team);
-    const api = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "api" });
-    const web = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "web" });
+    const infra = getScope("infra");
+    assert.ok(team && infra);
+    const api = upsertEntity({ scope_id: team.id, kind: "component", name: "api" });
+    const web = upsertEntity({ scope_id: team.id, kind: "component", name: "web" });
     const oldDecision = recordDecision({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         entity_id: api.id,
         title: "Use SQLite FTS5 for memory recall",
         rationale: "Initial choice.",
         decided_at: "2026-05-11",
     });
     const keeper = recordDecision({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         entity_id: api.id,
         title: "Use SQLite FTS5 for scoped memory recall",
         rationale: "Latest choice.",
         decided_at: "2026-05-13",
     });
     const otherEntity = recordDecision({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         entity_id: web.id,
         title: "Use SQLite FTS5 for memory recall",
         rationale: "Same title, different entity context, but newer scope-level decision.",
         decided_at: "2026-05-14",
     });
     const otherScope = recordDecision({
-        scope_id: team.id,
+        scope_id: infra.id,
         title: "Use SQLite FTS5 for memory recall",
         rationale: "Same title, different scope.",
         decided_at: "2026-05-14",
     });
-    const summary = housekeepingModule.dedupDecisionsPass(chapterhouse.id);
+    const summary = housekeepingModule.dedupDecisionsPass(team.id);
     assert.equal(summary.pass, "dedupDecisionsPass");
     assert.equal(summary.examined, 3);
     assert.equal(summary.modified, 2);
@@ -129,7 +129,7 @@ test("dedupDecisionsPass supersedes similar active decisions within scope and ke
     assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(keeper.id).superseded_by, otherEntity.id);
     assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(otherEntity.id).superseded_by, null);
     assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(otherScope.id).superseded_by, null);
-    const second = housekeepingModule.dedupDecisionsPass(chapterhouse.id);
+    const second = housekeepingModule.dedupDecisionsPass(team.id);
     assert.equal(second.modified, 0);
 });
 test("orphanCleanupPass clears missing observation entity references without touching valid or out-of-scope rows", async () => {
@@ -225,18 +225,18 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse);
-    const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "memory", tier: "warm" });
+    const team = getScope("team");
+    assert.ok(team);
+    const entity = upsertEntity({ scope_id: team.id, kind: "component", name: "memory", tier: "warm" });
     const referencedObservation = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         entity_id: entity.id,
         content: "Referenced by a recent decision through its entity.",
         source: "test",
         tier: "warm",
     });
     const recentDecision = recordDecision({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         entity_id: entity.id,
         title: "Restate memory tiering decision",
         rationale: "Recent entity-linked decisions keep related observations hot.",
@@ -244,20 +244,20 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
         tier: "warm",
     });
     const oldHot = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "Old hot row with no recall activity should cool down.",
         source: "test",
         tier: "hot",
     });
     const staleLowConfidence = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "Low confidence stale row should go cold.",
         source: "test",
         tier: "warm",
         confidence: 0.2,
     });
     const archived = recordObservation({
-        scope_id: chapterhouse.id,
+        scope_id: team.id,
         content: "Archived row should always be cold.",
         source: "test",
         tier: "hot",
@@ -265,7 +265,7 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
     db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-45 days') WHERE id = ?`).run(oldHot.id);
     db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-61 days') WHERE id = ?`).run(staleLowConfidence.id);
     db.prepare(`UPDATE mem_observations SET archived_at = CURRENT_TIMESTAMP WHERE id = ?`).run(archived.id);
-    const summary = housekeepingModule.tieringPass(chapterhouse.id);
+    const summary = housekeepingModule.tieringPass(team.id);
     assert.equal(summary.pass, "tieringPass");
     assert.equal(summary.modified, 5);
     assert.deepEqual(summary.errors, []);
@@ -274,7 +274,7 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
     assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(oldHot.id).tier, "warm");
     assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(staleLowConfidence.id).tier, "cold");
     assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(archived.id).tier, "cold");
-    const second = housekeepingModule.tieringPass(chapterhouse.id);
+    const second = housekeepingModule.tieringPass(team.id);
     assert.equal(second.modified, 0);
 });
 //# sourceMappingURL=housekeeping.test.js.map