chapterhouse 0.13.1 → 0.14.1

package/dist/memory/checkpoint.js

@@ -1,274 +0,0 @@
-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 { releaseScopeWriteLocks, tryAcquireScopeWriteLocks } from "./scope-lock.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) {
-    try {
-        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,
-                }];
-        });
-    }
-    catch (err) {
-        log.warn({ err }, "malformed checkpoint proposals response");
-        return [];
-    }
-}
-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) >= config.memoryCheckpointDuplicateThreshold);
-}
-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 >= config.memoryCheckpointDuplicateThreshold
-            || rationaleSimilarity >= config.memoryCheckpointDuplicateThreshold;
-    });
-}
-export class CheckpointTracker {
-    turnCountSinceLastFire = 0;
-    cadence;
-    enabled;
-    constructor(options = {}) {
-        this.cadence = options.turns ?? config.memoryCheckpointTurns;
-        this.enabled = options.enabled ?? 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");
-        const resolvedProposals = proposals.map((proposal) => ({
-            proposal,
-            scope: resolveProposalScope(proposal, input.activeScope),
-        }));
-        const lockedScopeIds = [...new Set(resolvedProposals.flatMap(({ scope }) => (scope ? [scope.id] : [])))];
-        if (lockedScopeIds.length > 0 && !tryAcquireScopeWriteLocks(lockedScopeIds)) {
-            log.info({ sessionKey: input.sessionKey ?? "default", scope: input.activeScope.slug }, "memory.checkpoint.scope_in_flight_skip");
-            return { written: 0, skipped: 0, errors };
-        }
-        let written = 0;
-        let skipped = 0;
-        const pendingObservationContents = [];
-        try {
-            for (const { proposal, scope } of resolvedProposals) {
-                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;
-                }
-                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 };
-        }
-        finally {
-            releaseScopeWriteLocks(lockedScopeIds);
-        }
-    }
-    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

@@ -1,275 +0,0 @@
-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 };
-}
-async function loadModulesWithWarnSpy(t, cacheBust) {
-    const warnings = [];
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            childLogger: () => ({
-                info: () => { },
-                warn: (...args) => {
-                    warnings.push(args);
-                },
-                error: () => { },
-            }),
-        },
-    });
-    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);
-    return { dbModule, memoryModule, checkpointModule, warnings };
-}
-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 ignores malformed JSON responses and warns", async (t) => {
-    const { dbModule, memoryModule, checkpointModule, warnings } = await loadModulesWithWarnSpy(t, "malformed-json");
-    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.equal(result.skipped, 0);
-    assert.deepEqual(result.errors, []);
-    assert.equal(warnings.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

@@ -1,54 +0,0 @@
-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,
-        source: row.source ?? undefined,
-        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, source, 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.source ?? null, 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, source, 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, source, 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