chapterhouse 0.3.25 → 0.4.0

package/dist/memory/housekeeping.test.js

@@ -0,0 +1,280 @@
+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-housekeeping-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+process.env.CHAPTERHOUSE_MEMORY_DECAY_DAYS = "30";
+process.env.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS = "7";
+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);
+    const housekeepingModule = await import(new URL("./housekeeping.js", import.meta.url).href);
+    return { dbModule, memoryModule, housekeepingModule };
+}
+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 });
+    delete process.env.CHAPTERHOUSE_MEMORY_DECAY_DAYS;
+    delete process.env.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS;
+});
+test("dedupObservationsPass supersedes similar observations in scope deterministically and is idempotent", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse && team);
+    const first = recordObservation({
+        scope_id: chapterhouse.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,
+        content: "Worker event streams use server sent events for live task output.",
+        source: "test",
+        confidence: 0.9,
+    });
+    const third = recordObservation({
+        scope_id: chapterhouse.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,
+        content: "Worker event streams use server sent events for live task output.",
+        source: "test",
+        confidence: 0.1,
+    });
+    const summary = housekeepingModule.dedupObservationsPass(chapterhouse.id);
+    assert.equal(summary.pass, "dedupObservationsPass");
+    assert.equal(summary.examined, 3);
+    assert.equal(summary.modified, 2);
+    assert.deepEqual(summary.errors, []);
+    assert.deepEqual(db.prepare(`SELECT id, superseded_by FROM mem_observations WHERE id IN (?, ?, ?) ORDER BY id`).all(first.id, keeper.id, third.id), [
+        { id: first.id, superseded_by: keeper.id },
+        { id: keeper.id, superseded_by: null },
+        { 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);
+    assert.equal(second.modified, 0);
+});
+test("dedupDecisionsPass supersedes similar active decisions within scope and keeps the latest decision", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    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 oldDecision = recordDecision({
+        scope_id: chapterhouse.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,
+        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,
+        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,
+        title: "Use SQLite FTS5 for memory recall",
+        rationale: "Same title, different scope.",
+        decided_at: "2026-05-14",
+    });
+    const summary = housekeepingModule.dedupDecisionsPass(chapterhouse.id);
+    assert.equal(summary.pass, "dedupDecisionsPass");
+    assert.equal(summary.examined, 3);
+    assert.equal(summary.modified, 2);
+    assert.deepEqual(summary.errors, []);
+    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(oldDecision.id).superseded_by, otherEntity.id);
+    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);
+    assert.equal(second.modified, 0);
+});
+test("orphanCleanupPass clears missing observation entity references without touching valid or out-of-scope rows", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse && team);
+    const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "tool", name: "sqlite" });
+    const valid = recordObservation({ scope_id: chapterhouse.id, entity_id: entity.id, content: "Valid entity reference", source: "test" });
+    const orphan = recordObservation({ scope_id: chapterhouse.id, content: "Will become orphaned", source: "test" });
+    const otherScope = recordObservation({ scope_id: team.id, content: "Other scope orphan", source: "test" });
+    db.pragma("foreign_keys = OFF");
+    db.prepare(`UPDATE mem_observations SET entity_id = 987654 WHERE id IN (?, ?)`).run(orphan.id, otherScope.id);
+    db.pragma("foreign_keys = ON");
+    const summary = housekeepingModule.orphanCleanupPass(chapterhouse.id);
+    assert.equal(summary.pass, "orphanCleanupPass");
+    assert.equal(summary.examined, 1);
+    assert.equal(summary.modified, 1);
+    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(orphan.id).entity_id, null);
+    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(valid.id).entity_id, entity.id);
+    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(otherScope.id).entity_id, 987654);
+    const second = housekeepingModule.orphanCleanupPass(chapterhouse.id);
+    assert.equal(second.modified, 0);
+});
+test("decayPass archives old low-confidence observations only in scope and compactInboxPass removes resolved inbox rows after retention", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse && team);
+    const archiveMe = recordObservation({ scope_id: chapterhouse.id, content: "Old low confidence", source: "test", confidence: 0.2 });
+    const highConfidence = recordObservation({ scope_id: chapterhouse.id, content: "Old high confidence", source: "test", confidence: 0.9 });
+    const fresh = recordObservation({ scope_id: chapterhouse.id, content: "Fresh low confidence", source: "test", confidence: 0.2 });
+    const otherScope = recordObservation({ scope_id: team.id, content: "Other scope old low confidence", source: "test", confidence: 0.2 });
+    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?, ?)`).run(archiveMe.id, highConfidence.id, otherScope.id);
+    const decay = housekeepingModule.decayPass(chapterhouse.id);
+    assert.equal(decay.pass, "decayPass");
+    assert.equal(decay.examined, 1);
+    assert.equal(decay.modified, 1);
+    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(archiveMe.id).archived_at);
+    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(highConfidence.id).archived_at, null);
+    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(fresh.id).archived_at, null);
+    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(otherScope.id).archived_at, null);
+    assert.equal(housekeepingModule.decayPass(chapterhouse.id).modified, 0);
+    db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at, resolved_at)
+    VALUES
+      (?, 'memory_proposal', '{}', 'test', 'accepted', datetime('now', '-20 days'), datetime('now', '-8 days')),
+      (?, 'memory_proposal', '{}', 'test', 'rejected', datetime('now', '-20 days'), datetime('now', '-6 days')),
+      (?, 'memory_proposal', '{}', 'test', 'pending', datetime('now', '-20 days'), NULL)
+  `).run(chapterhouse.id, chapterhouse.id, chapterhouse.id);
+    const compact = housekeepingModule.compactInboxPass();
+    assert.equal(compact.pass, "compactInboxPass");
+    assert.equal(compact.examined, 1);
+    assert.equal(compact.modified, 1);
+    assert.deepEqual(db.prepare(`SELECT status FROM mem_inbox ORDER BY id`).all(), [{ status: "rejected" }, { status: "pending" }]);
+    assert.equal(housekeepingModule.compactInboxPass().modified, 0);
+});
+test("runHousekeeping defaults to the active scope and can target all active scopes", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse && team);
+    const chapterhouseOld = recordObservation({ scope_id: chapterhouse.id, content: "Chapterhouse old low", source: "test", confidence: 0.1 });
+    const teamOld = recordObservation({ scope_id: team.id, content: "Team old low", source: "test", confidence: 0.1 });
+    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?)`).run(chapterhouseOld.id, teamOld.id);
+    setActiveScope("chapterhouse");
+    const activeOnly = housekeepingModule.runHousekeeping({ passes: ["decay"] });
+    assert.deepEqual(activeOnly.scopeIds, [chapterhouse.id]);
+    assert.equal(activeOnly.summaries.length, 1);
+    assert.equal(activeOnly.summaries[0]?.modified, 1);
+    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(chapterhouseOld.id).archived_at);
+    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at, null);
+    const allScopes = housekeepingModule.runHousekeeping({ allScopes: true, passes: ["decay"] });
+    assert.ok(allScopes.scopeIds.includes(team.id));
+    assert.equal(allScopes.summaries.some((summary) => summary.modified === 1), true);
+    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at);
+});
+test("tieringPass promotes and demotes rows from lifecycle signals and is idempotent", async () => {
+    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    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 referencedObservation = recordObservation({
+        scope_id: chapterhouse.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,
+        entity_id: entity.id,
+        title: "Restate memory tiering decision",
+        rationale: "Recent entity-linked decisions keep related observations hot.",
+        decided_at: new Date().toISOString(),
+        tier: "warm",
+    });
+    const oldHot = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Old hot row with no recall activity should cool down.",
+        source: "test",
+        tier: "hot",
+    });
+    const staleLowConfidence = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Low confidence stale row should go cold.",
+        source: "test",
+        tier: "warm",
+        confidence: 0.2,
+    });
+    const archived = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Archived row should always be cold.",
+        source: "test",
+        tier: "hot",
+    });
+    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);
+    assert.equal(summary.pass, "tieringPass");
+    assert.equal(summary.modified, 5);
+    assert.deepEqual(summary.errors, []);
+    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(referencedObservation.id).tier, "hot");
+    assert.equal(db.prepare(`SELECT tier FROM mem_decisions WHERE id = ?`).get(recentDecision.id).tier, "hot");
+    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);
+    assert.equal(second.modified, 0);
+});
+//# sourceMappingURL=housekeeping.test.js.map

package/dist/memory/inbox.js

@@ -0,0 +1,73 @@
+import { getDb } from "../store/db.js";
+import { getActiveScope } from "./active-scope.js";
+import { getScope } from "./scopes.js";
+function toInboxItem(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id ?? undefined,
+        kind: row.kind,
+        payload: row.payload,
+        sourceAgent: row.source_agent,
+        sourceTaskId: row.source_task_id ?? undefined,
+        status: row.status,
+        createdAt: row.created_at,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolutionReason: row.resolution_reason ?? undefined,
+    };
+}
+export function resolveProposalScope(scopeSlug) {
+    if (scopeSlug) {
+        const explicit = getScope(scopeSlug);
+        if (!explicit) {
+            throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+        }
+        return { scopeId: explicit.id, scopeSlug: explicit.slug };
+    }
+    const activeScope = getActiveScope();
+    if (!activeScope) {
+        throw new Error("No active memory scope is set. Use memory_set_scope or pass scope_slug explicitly.");
+    }
+    return { scopeId: activeScope.id, scopeSlug: activeScope.slug };
+}
+export function queueMemoryProposal(input) {
+    const { scopeId, scopeSlug } = resolveProposalScope(input.scopeSlug);
+    const envelope = {
+        kind: input.kind,
+        scope_slug: scopeSlug,
+        confidence: input.confidence ?? 0.5,
+        reason: input.reason,
+        payload: input.payload,
+    };
+    const result = getDb().prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status, created_at)
+    VALUES (?, 'memory_proposal', ?, ?, ?, 'pending', CURRENT_TIMESTAMP)
+  `).run(scopeId, JSON.stringify(envelope), input.sourceAgent, input.sourceTaskId ?? null);
+    return getInboxItem(Number(result.lastInsertRowid));
+}
+export function getInboxItem(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, kind, payload, source_agent, source_task_id, status, created_at, resolved_at, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(id);
+    return row ? toInboxItem(row) : undefined;
+}
+export function listPendingMemoryProposalsForTask(taskId) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, kind, payload, source_agent, source_task_id, status, created_at, resolved_at, resolution_reason
+    FROM mem_inbox
+    WHERE source_task_id = ?
+      AND status = 'pending'
+      AND kind = 'memory_proposal'
+    ORDER BY id ASC
+  `).all(taskId);
+    return rows.map(toInboxItem);
+}
+export function resolveInboxItem(id, status, reason) {
+    getDb().prepare(`
+    UPDATE mem_inbox
+    SET status = ?, resolution_reason = ?, resolved_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(status, reason, id);
+}
+//# sourceMappingURL=inbox.js.map

package/dist/memory/index.js

@@ -0,0 +1,11 @@
+export { getActiveScope, inferScopeFromText, setActiveScope } from "./active-scope.js";
+export { recordDecision, getDecision, listDecisions, supersedeDecision } from "./decisions.js";
+export { getEntity, findEntityByName, listEntities, upsertEntity } from "./entities.js";
+export { getHotTierEntries, renderHotTierForActiveScope, renderHotTierXML } from "./hot-tier.js";
+export { compactInboxPass, decayPass, dedupDecisionsPass, dedupObservationsPass, isHousekeepingInFlight, orphanCleanupPass, runHousekeeping, } from "./housekeeping.js";
+export { getInboxItem, listPendingMemoryProposalsForTask, queueMemoryProposal, resolveInboxItem, resolveProposalScope } from "./inbox.js";
+export { recordObservation, getObservation, listObservations, deleteObservation } from "./observations.js";
+export { recall } from "./recall.js";
+export { createScope, deactivateScope, getScope, listScopes, updateScope } from "./scopes.js";
+export { demoteToCold, demoteToWarm, inferTierFromSignals, promoteToHot, tieringPass } from "./tiering.js";
+//# sourceMappingURL=index.js.map

package/dist/memory/observations.js

@@ -0,0 +1,46 @@
+import { getDb } from "../store/db.js";
+function toObservation(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        content: row.content,
+        source: row.source,
+        tier: row.tier,
+        confidence: row.confidence,
+        embedding: row.embedding ?? undefined,
+        supersededBy: row.superseded_by ?? undefined,
+        archivedAt: row.archived_at ?? undefined,
+        createdAt: row.created_at,
+    };
+}
+export function recordObservation(input) {
+    const result = getDb().prepare(`
+    INSERT INTO mem_observations (scope_id, entity_id, content, source, tier, confidence, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.content, input.source, input.tier ?? "warm", input.confidence ?? 1.0);
+    return getObservation(Number(result.lastInsertRowid));
+}
+export function getObservation(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, entity_id, content, source, tier, confidence, embedding, superseded_by, archived_at, created_at
+    FROM mem_observations
+    WHERE id = ?
+  `).get(id);
+    return row ? toObservation(row) : undefined;
+}
+export function listObservations(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, entity_id, content, source, tier, confidence, embedding, superseded_by, archived_at, created_at
+    FROM mem_observations
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (? IS NULL OR entity_id = ?)
+    ORDER BY 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(toObservation);
+}
+export function deleteObservation(id) {
+    getDb().prepare(`DELETE FROM mem_observations WHERE id = ?`).run(id);
+}
+//# sourceMappingURL=observations.js.map

package/dist/memory/observations.test.js

@@ -0,0 +1,86 @@
+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-observations-${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("recordObservation supports CRUD and keeps the observation FTS index in sync", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const getObservation = getFunction(memoryModule, "getObservation");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const deleteObservation = getFunction(memoryModule, "deleteObservation");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const created = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "SQLite WAL mode keeps Chapterhouse memory writes fast.",
+        source: "user",
+        tier: "hot",
+        confidence: 0.9,
+    });
+    assert.equal(created.content, "SQLite WAL mode keeps Chapterhouse memory writes fast.");
+    assert.deepEqual(getObservation(created.id)?.content, created.content);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.id === created.id), true);
+    const initialHits = db.prepare(`
+    SELECT rowid
+    FROM mem_observations_fts
+    WHERE mem_observations_fts MATCH 'WAL'
+  `).all();
+    assert.deepEqual(initialHits, [{ rowid: created.id }]);
+    db.prepare(`
+    UPDATE mem_observations
+    SET content = ?
+    WHERE id = ?
+  `).run("FTS rebuild test for hot-tier prompts and scoped recall.", created.id);
+    const walHits = db.prepare(`
+    SELECT rowid
+    FROM mem_observations_fts
+    WHERE mem_observations_fts MATCH 'WAL'
+  `).all();
+    const rebuildHits = db.prepare(`
+    SELECT rowid
+    FROM mem_observations_fts
+    WHERE mem_observations_fts MATCH 'rebuild'
+  `).all();
+    assert.deepEqual(walHits, []);
+    assert.deepEqual(rebuildHits, [{ rowid: created.id }]);
+    deleteObservation(created.id);
+    assert.equal(getObservation(created.id), undefined);
+    const postDeleteHits = db.prepare(`
+    SELECT rowid
+    FROM mem_observations_fts
+    WHERE mem_observations_fts MATCH 'rebuild'
+  `).all();
+    assert.deepEqual(postDeleteHits, []);
+});
+//# sourceMappingURL=observations.test.js.map