chapterhouse 0.3.25 → 0.4.0

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

package/dist/memory/checkpoint-prompt.js

@@ -0,0 +1,71 @@
+function renderTurns(turns) {
+    return turns
+        .map((turn, index) => [
+        `Turn ${index + 1}`,
+        `User: ${turn.user}`,
+        `Assistant: ${turn.assistant}`,
+    ].join("\n"))
+        .join("\n\n");
+}
+function renderEntities(entities) {
+    if (entities.length === 0) {
+        return "- none";
+    }
+    return entities
+        .map((entity) => `- ${entity.name} (${entity.kind}): ${entity.summary ?? entity.name}`)
+        .join("\n");
+}
+function renderDecisions(decisions) {
+    if (decisions.length === 0) {
+        return "- none";
+    }
+    return decisions
+        .map((decision) => `- ${decision.title}: ${decision.rationale}`)
+        .join("\n");
+}
+export function buildCheckpointSystemPrompt() {
+    return [
+        "You extract durable agent memory from the most recent orchestrator turns.",
+        "Only return valid JSON. No prose, no markdown, no code fences.",
+        "Remember durable items only:",
+        "- decisions (architecture, process, user preferences)",
+        "- durable facts learned about code, tools, people, or infrastructure",
+        "- reusable gotchas or lessons learned",
+        "- named entities only when they are durable and worth remembering as an observation",
+        "Skip greetings, ephemeral progress updates, temporary branch names, one-off commit wording, and off-topic chatter.",
+        "Prefer concrete entries over vague summaries.",
+        "Use kind='decision' only when a real decision was made; otherwise use kind='observation'.",
+        "If nothing is worth remembering, return {\"proposals\":[]}.",
+        "JSON schema:",
+        "{\"proposals\":[{\"kind\":\"observation|decision\",\"title\":\"required for decision\",\"content\":\"string\",\"scope\":\"optional scope slug; omit to use active scope\",\"confidence\":0.0}]}",
+        "Example good output:",
+        "{\"proposals\":[{\"kind\":\"decision\",\"title\":\"Use SQLite FTS5 for recall\",\"content\":\"Chapterhouse uses SQLite FTS5 for scoped memory recall in v1.\",\"confidence\":0.93}]}",
+        "{\"proposals\":[{\"kind\":\"observation\",\"content\":\"Only orchestrator turns count toward memory checkpoints.\",\"confidence\":0.88}]}",
+    ].join("\n");
+}
+export function buildCheckpointUserPrompt(input) {
+    const scopeChangeBlock = input.scopeChangeContext
+        ? [
+            `Scope-change context: the user is moving from scope ${input.scopeChangeContext.from} to ${input.scopeChangeContext.to}.`,
+            `Extract everything worth remembering about scope ${input.scopeChangeContext.from} from the recent turns BEFORE the context shifts.`,
+            "",
+        ].join("\n")
+        : "";
+    return [
+        `Active scope: ${input.activeScope.slug} — ${input.activeScope.title}`,
+        `Scope description: ${input.activeScope.description}`,
+        "",
+        scopeChangeBlock,
+        "Known entities in the active scope:",
+        renderEntities(input.entities),
+        "",
+        "Known decisions in the active scope:",
+        renderDecisions(input.decisions),
+        "",
+        "Recent orchestrator turns:",
+        renderTurns(input.turns),
+        "",
+        "Return only the JSON object.",
+    ].join("\n");
+}
+//# sourceMappingURL=checkpoint-prompt.js.map

package/dist/memory/checkpoint.js

@@ -0,0 +1,257 @@
+import { config } from "../config.js";
+import { runOneShotPrompt } from "../copilot/oneshot.js";
+import { childLogger } from "../util/logger.js";
+import { recordDecision } from "./decisions.js";
+import { listEntities } from "./entities.js";
+import { recordObservation, listObservations } from "./observations.js";
+import { getScope } from "./scopes.js";
+import { listDecisions } from "./decisions.js";
+import { buildCheckpointSystemPrompt, buildCheckpointUserPrompt, } from "./checkpoint-prompt.js";
+const log = childLogger("memory.checkpoint");
+const MAX_WRITES_PER_CHECKPOINT = 5;
+const MIN_CONFIDENCE = 0.5;
+const RECENT_MEMORY_LIMIT = 50;
+const inFlightSessions = new Set();
+function getInFlightKey(sessionKey) {
+    return sessionKey?.trim() || "__global__";
+}
+function normalizeText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function calculateSimilarity(left, right) {
+    const normalizedLeft = normalizeText(left);
+    const normalizedRight = normalizeText(right);
+    if (!normalizedLeft || !normalizedRight) {
+        return 0;
+    }
+    if (normalizedLeft === normalizedRight) {
+        return 1;
+    }
+    if (normalizedLeft.includes(normalizedRight) || normalizedRight.includes(normalizedLeft)) {
+        return Math.min(normalizedLeft.length, normalizedRight.length) / Math.max(normalizedLeft.length, normalizedRight.length);
+    }
+    const leftTokens = new Set(normalizedLeft.split(" ").filter(Boolean));
+    const rightTokens = new Set(normalizedRight.split(" ").filter(Boolean));
+    if (leftTokens.size === 0 || rightTokens.size === 0) {
+        return 0;
+    }
+    let overlap = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            overlap++;
+        }
+    }
+    return overlap / new Set([...leftTokens, ...rightTokens]).size;
+}
+function parseProposals(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.proposals)) {
+        return [];
+    }
+    return parsed.proposals.flatMap((proposal) => {
+        if (!proposal || typeof proposal !== "object") {
+            return [];
+        }
+        const candidate = proposal;
+        if ((candidate.kind !== "observation" && candidate.kind !== "decision")
+            || typeof candidate.content !== "string"
+            || typeof candidate.confidence !== "number") {
+            return [];
+        }
+        return [{
+                kind: candidate.kind,
+                title: typeof candidate.title === "string" ? candidate.title.trim() : undefined,
+                content: candidate.content.trim(),
+                scope: typeof candidate.scope === "string" ? candidate.scope.trim() : undefined,
+                confidence: candidate.confidence,
+                decided_at: typeof candidate.decided_at === "string" ? candidate.decided_at.trim() : undefined,
+            }];
+    });
+}
+function resolveProposalScope(proposal, activeScope) {
+    if (!proposal.scope || proposal.scope === activeScope.slug) {
+        return activeScope;
+    }
+    return getScope(proposal.scope) ?? null;
+}
+function isDuplicateObservation(content, scopeId, batchContents) {
+    const existing = listObservations({ scope_id: scopeId, limit: RECENT_MEMORY_LIMIT });
+    const combined = [...existing.map((observation) => observation.content), ...batchContents];
+    return combined.some((candidate) => calculateSimilarity(candidate, content) >= 0.85);
+}
+function isDuplicateDecision(proposal, scopeId) {
+    const existing = listDecisions({ scope_id: scopeId, limit: RECENT_MEMORY_LIMIT });
+    return existing.some((decision) => {
+        const titleSimilarity = proposal.title ? calculateSimilarity(decision.title, proposal.title) : 0;
+        const rationaleSimilarity = calculateSimilarity(decision.rationale, proposal.content);
+        return titleSimilarity >= 0.85 || rationaleSimilarity >= 0.85;
+    });
+}
+export class CheckpointTracker {
+    turnCountSinceLastFire = 0;
+    cadence;
+    enabled;
+    constructor(options = {}) {
+        const rawTurns = process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS?.trim();
+        const envTurns = rawTurns && /^\d+$/.test(rawTurns) ? Number(rawTurns) : undefined;
+        const rawEnabled = process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED?.trim();
+        const envEnabled = rawEnabled === "0" ? false : rawEnabled === "1" ? true : undefined;
+        this.cadence = options.turns ?? envTurns ?? config.memoryCheckpointTurns;
+        this.enabled = options.enabled ?? envEnabled ?? config.memoryCheckpointEnabled;
+    }
+    tickOrchestratorTurn() {
+        this.turnCountSinceLastFire++;
+    }
+    shouldFire() {
+        return this.enabled && this.turnCountSinceLastFire >= this.cadence;
+    }
+    turnsSinceLastFire() {
+        return this.turnCountSinceLastFire;
+    }
+    markFired() {
+        this.turnCountSinceLastFire = 0;
+    }
+    markScopeChangeFire() {
+        this.turnCountSinceLastFire = 0;
+    }
+    reset() {
+        this.turnCountSinceLastFire = 0;
+    }
+}
+export function isCheckpointInFlight(sessionKey) {
+    if (sessionKey) {
+        return inFlightSessions.has(getInFlightKey(sessionKey));
+    }
+    return inFlightSessions.size > 0;
+}
+export async function runCheckpointExtraction(input) {
+    const model = input.model ?? config.copilotModel;
+    const inFlightKey = getInFlightKey(input.sessionKey);
+    const errors = [];
+    const trigger = input.trigger ?? "cadence";
+    if (!input.activeScope) {
+        log.info({ sessionKey: input.sessionKey ?? "default", reason: "no_scope" }, "memory.checkpoint.skip");
+        return { written: 0, skipped: 0, errors };
+    }
+    if (isCheckpointInFlight(input.sessionKey)) {
+        log.info({ sessionKey: input.sessionKey ?? "default" }, "memory.checkpoint.in_flight_skip");
+        return { written: 0, skipped: 0, errors };
+    }
+    inFlightSessions.add(inFlightKey);
+    try {
+        log.info({
+            turnCount: input.turns.length,
+            scope: input.activeScope.slug,
+            model,
+            sessionKey: input.sessionKey ?? "default",
+            trigger,
+        }, "memory.checkpoint.fire");
+        const entities = listEntities({ scope_id: input.activeScope.id, limit: 8 });
+        const decisions = listDecisions({ scope_id: input.activeScope.id, limit: 8 });
+        const system = buildCheckpointSystemPrompt();
+        const user = buildCheckpointUserPrompt({
+            turns: input.turns,
+            activeScope: input.activeScope,
+            entities,
+            decisions,
+            scopeChangeContext: input.scopeChangeContext ?? null,
+        });
+        const callLLM = input.callLLM
+            ?? (async ({ system: systemPrompt, user: userPrompt, model: chosenModel }) => {
+                const result = await runOneShotPrompt({
+                    client: input.copilotClient,
+                    model: chosenModel,
+                    system: systemPrompt,
+                    user: userPrompt,
+                    expectJson: true,
+                });
+                return result.content;
+            });
+        const rawResponse = await callLLM({ system, user, model });
+        const proposals = parseProposals(rawResponse)
+            .filter((proposal) => proposal.content.length > 0)
+            .sort((left, right) => right.confidence - left.confidence);
+        log.info({
+            count: proposals.length,
+            scope: input.activeScope.slug,
+            sessionKey: input.sessionKey ?? "default",
+        }, "memory.checkpoint.proposal_count");
+        let written = 0;
+        let skipped = 0;
+        const pendingObservationContents = [];
+        for (const proposal of proposals) {
+            if (proposal.confidence < MIN_CONFIDENCE) {
+                skipped++;
+                log.info({ reason: "low_confidence", confidence: proposal.confidence, scope: input.activeScope.slug }, "memory.checkpoint.skip");
+                continue;
+            }
+            if (written >= MAX_WRITES_PER_CHECKPOINT) {
+                skipped++;
+                log.info({ reason: "cap_exceeded", scope: input.activeScope.slug }, "memory.checkpoint.skip");
+                continue;
+            }
+            const scope = resolveProposalScope(proposal, input.activeScope);
+            if (!scope) {
+                skipped++;
+                log.info({ reason: "no_scope", scope: proposal.scope ?? input.activeScope.slug }, "memory.checkpoint.skip");
+                continue;
+            }
+            if (proposal.kind === "observation" && isDuplicateObservation(proposal.content, scope.id, pendingObservationContents)) {
+                skipped++;
+                log.info({ reason: "duplicate", scope_id: scope.id }, "memory.checkpoint.skip");
+                continue;
+            }
+            if (proposal.kind === "decision") {
+                if (!proposal.title) {
+                    skipped++;
+                    log.info({ reason: "missing_title", scope_id: scope.id }, "memory.checkpoint.skip");
+                    continue;
+                }
+                if (isDuplicateDecision(proposal, scope.id)) {
+                    skipped++;
+                    log.info({ reason: "duplicate", scope_id: scope.id }, "memory.checkpoint.skip");
+                    continue;
+                }
+                const decision = recordDecision({
+                    scope_id: scope.id,
+                    title: proposal.title,
+                    rationale: proposal.content,
+                    decided_at: proposal.decided_at || new Date().toISOString().slice(0, 10),
+                    tier: "warm",
+                });
+                written++;
+                log.info({ kind: "decision", scope_id: scope.id, id: decision.id }, "memory.checkpoint.write");
+                continue;
+            }
+            const observation = recordObservation({
+                scope_id: scope.id,
+                content: proposal.content,
+                source: "checkpoint:orchestrator",
+                tier: "warm",
+                confidence: proposal.confidence,
+            });
+            pendingObservationContents.push(proposal.content);
+            written++;
+            log.info({ kind: "observation", scope_id: scope.id, id: observation.id }, "memory.checkpoint.write");
+        }
+        return { written, skipped, errors };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(message);
+        log.error({
+            err: error,
+            sessionKey: input.sessionKey ?? "default",
+            scope: input.activeScope.slug,
+        }, "memory.checkpoint.error");
+        return { written: 0, skipped: 0, errors };
+    }
+    finally {
+        inFlightSessions.delete(inFlightKey);
+    }
+}
+//# sourceMappingURL=checkpoint.js.map