chapterhouse 0.3.26 → 0.4.1

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

package/dist/memory/checkpoint.test.js

@@ -0,0 +1,255 @@
+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-checkpoint-${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(cacheBust = `${Date.now()}-${Math.random()}`) {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
+    const checkpointModule = await import(new URL(`./checkpoint.js?case=${cacheBust}`, import.meta.url).href);
+    const checkpointPromptModule = await import(new URL(`./checkpoint-prompt.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, checkpointModule, checkpointPromptModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+function getConstructor(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("CheckpointTracker increments on orchestrator turns, fires at cadence, and resets after markFired", async () => {
+    const { checkpointModule } = await loadModules();
+    const CheckpointTracker = getConstructor(checkpointModule, "CheckpointTracker");
+    const tracker = new CheckpointTracker({ turns: 3, enabled: true });
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 1);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 2);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 3);
+    assert.equal(tracker.shouldFire(), true);
+    tracker.markFired();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 1);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.markScopeChangeFire();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    tracker.reset();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+});
+test("CheckpointTracker stays disabled when CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED=0", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED = "0";
+    const { checkpointModule } = await loadModules("disabled");
+    const CheckpointTracker = getConstructor(checkpointModule, "CheckpointTracker");
+    const tracker = new CheckpointTracker();
+    for (let index = 0; index < 10; index++) {
+        tracker.tickOrchestratorTurn();
+    }
+    assert.equal(tracker.shouldFire(), false);
+});
+test("runCheckpointExtraction writes high-confidence memories, skips low-confidence duplicates, and caps at five writes", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Base new memory implementation branches from origin/main after dependent PRs merge.",
+        source: "agent:test",
+    });
+    const result = await runCheckpointExtraction({
+        turns: [
+            {
+                user: "Implement checkpoint extraction after the response is committed.",
+                assistant: "I will add an async checkpoint pass with a five-turn cadence.",
+            },
+        ],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            proposals: [
+                {
+                    kind: "observation",
+                    content: "Base new memory implementation branches from origin/main after dependent PRs merge.",
+                    confidence: 0.99,
+                },
+                {
+                    kind: "decision",
+                    title: "Run checkpoint extraction asynchronously",
+                    content: "Checkpoint extraction runs in the background after the assistant response completes so the next user turn is never blocked.",
+                    confidence: 0.98,
+                },
+                {
+                    kind: "observation",
+                    content: "Only orchestrator turns count toward the checkpoint cadence.",
+                    confidence: 0.97,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint extraction skips overlapping runs instead of queueing them.",
+                    confidence: 0.96,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint extraction defaults to the active scope when writing remembered items.",
+                    confidence: 0.95,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint prompts include recent durable decisions already recorded in the active scope to avoid duplicates.",
+                    confidence: 0.94,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint prompts stay under a tight token budget.",
+                    confidence: 0.93,
+                },
+                {
+                    kind: "observation",
+                    content: "Low-confidence chatter about ephemeral commit messages should not be remembered.",
+                    confidence: 0.49,
+                },
+            ],
+        }),
+    });
+    assert.deepEqual(result.errors, []);
+    assert.equal(result.written, 5);
+    assert.equal(result.skipped, 3);
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Run checkpoint extraction asynchronously"), true);
+    assert.equal(listObservations({ scope_id: chapterhouse.id, limit: 20 }).filter((row) => row.content === "Base new memory implementation branches from origin/main after dependent PRs merge.").length, 1);
+});
+test("runCheckpointExtraction handles malformed JSON responses without crashing", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const result = await runCheckpointExtraction({
+        turns: [{ user: "Remember this.", assistant: "Okay." }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => "{ definitely-not-json",
+    });
+    assert.equal(result.written, 0);
+    assert.ok(result.errors.length >= 1);
+});
+test("runCheckpointExtraction prevents overlapping executions with the in-flight guard", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const isCheckpointInFlight = getFunction(checkpointModule, "isCheckpointInFlight");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    let resolveFirst;
+    let llmCalls = 0;
+    const pendingResponse = new Promise((resolve) => {
+        resolveFirst = resolve;
+    });
+    const firstRun = runCheckpointExtraction({
+        turns: [{ user: "First", assistant: "Turn" }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return await pendingResponse;
+        },
+    });
+    assert.equal(isCheckpointInFlight(), true);
+    const secondRun = await runCheckpointExtraction({
+        turns: [{ user: "Second", assistant: "Turn" }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return JSON.stringify({ proposals: [] });
+        },
+    });
+    assert.equal(secondRun.written, 0);
+    assert.equal(llmCalls, 1);
+    resolveFirst(JSON.stringify({ proposals: [] }));
+    await firstRun;
+    assert.equal(isCheckpointInFlight(), false);
+});
+test("buildCheckpointUserPrompt adds scope-change instructions when context is provided", async () => {
+    const { checkpointPromptModule } = await loadModules("scope-change-prompt");
+    const buildCheckpointUserPrompt = getFunction(checkpointPromptModule, "buildCheckpointUserPrompt");
+    const prompt = buildCheckpointUserPrompt({
+        turns: [{ user: "Wrap PR 4.5", assistant: "Switching to wiki lint next." }],
+        activeScope: {
+            id: 1,
+            slug: "chapterhouse",
+            title: "Chapterhouse",
+            description: "Core Chapterhouse work.",
+        },
+        entities: [],
+        decisions: [],
+        scopeChangeContext: { from: "chapterhouse", to: "wiki" },
+    });
+    assert.match(prompt, /moving from scope chapterhouse to wiki/i);
+    assert.match(prompt, /extract everything worth remembering about scope chapterhouse/i);
+});
+test("runCheckpointExtraction passes scope-change context through to the prompt", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules("scope-change-context");
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    let capturedUserPrompt = "";
+    const result = await runCheckpointExtraction({
+        turns: [{ user: "Finish memory work", assistant: "Next I will move to wiki cleanup." }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        trigger: "scope_change",
+        scopeChangeContext: { from: "chapterhouse", to: "wiki" },
+        callLLM: async ({ user }) => {
+            capturedUserPrompt = user;
+            return JSON.stringify({ proposals: [] });
+        },
+    });
+    assert.deepEqual(result.errors, []);
+    assert.match(capturedUserPrompt, /moving from scope chapterhouse to wiki/i);
+    assert.match(capturedUserPrompt, /before the context shifts/i);
+});
+//# sourceMappingURL=checkpoint.test.js.map

package/dist/memory/decisions.js

@@ -0,0 +1,53 @@
+import { getDb } from "../store/db.js";
+function toDecision(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        rationale: row.rationale,
+        decidedAt: row.decided_at,
+        tier: row.tier,
+        supersededBy: row.superseded_by ?? undefined,
+        archivedAt: row.archived_at ?? undefined,
+        createdAt: row.created_at,
+    };
+}
+export function recordDecision(input) {
+    const result = getDb().prepare(`
+    INSERT INTO mem_decisions (scope_id, entity_id, title, rationale, decided_at, tier, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.title, input.rationale, input.decided_at ?? new Date().toISOString().slice(0, 10), input.tier ?? "warm");
+    return getDecision(Number(result.lastInsertRowid));
+}
+export function getDecision(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    FROM mem_decisions
+    WHERE id = ?
+  `).get(id);
+    return row ? toDecision(row) : undefined;
+}
+export function listDecisions(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    FROM mem_decisions
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (? IS NULL OR entity_id = ?)
+    ORDER BY decided_at DESC, id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.entity_id ?? null, input.entity_id ?? null, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toDecision);
+}
+export function supersedeDecision(id, supersededByDecisionId) {
+    const result = getDb().prepare(`
+    UPDATE mem_decisions
+    SET superseded_by = ?
+    WHERE id = ?
+  `).run(supersededByDecisionId, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown decision id '${id}'.`);
+    }
+    return getDecision(id);
+}
+//# sourceMappingURL=decisions.js.map