chapterhouse 0.3.26 → 0.4.0

package/dist/memory/recall.js

@@ -0,0 +1,197 @@
+import { config } from "../config.js";
+import { getDb, isFts5Available } from "../store/db.js";
+import { getActiveScope } from "./active-scope.js";
+function recallHotTier(scopeId, options = {}) {
+    const rows = getDb().prepare(`
+    SELECT 'observation' AS kind, id, content
+    FROM mem_observations
+    WHERE scope_id = ? AND tier = 'hot'
+      AND (? = 1 OR superseded_by IS NULL)
+      AND (? = 1 OR archived_at IS NULL)
+    UNION ALL
+    SELECT 'decision' AS kind, id, title || ' — ' || rationale AS content
+    FROM mem_decisions
+    WHERE scope_id = ? AND tier = 'hot'
+      AND (? = 1 OR superseded_by IS NULL)
+      AND (? = 1 OR archived_at IS NULL)
+    UNION ALL
+    SELECT 'entity' AS kind, id, name || COALESCE(' — ' || summary, '') AS content
+    FROM mem_entities
+    WHERE scope_id = ? AND tier = 'hot'
+    ORDER BY id DESC
+    LIMIT 10
+  `).all(scopeId, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, scopeId, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, scopeId);
+    return rows;
+}
+function recallObservationHits(query, scopeId, options = {}) {
+    if (isFts5Available()) {
+        const rows = getDb().prepare(`
+      SELECT
+        o.id,
+        o.scope_id,
+        s.slug AS scope,
+        o.content,
+        o.tier,
+        -bm25(mem_observations_fts) * CASE WHEN o.tier = 'hot' THEN ? ELSE 1 END AS score,
+        snippet(mem_observations_fts, 0, '[', ']', '…', 12) AS snippet
+      FROM mem_observations o
+      JOIN mem_scopes s ON s.id = o.scope_id
+      JOIN mem_observations_fts ON mem_observations_fts.rowid = o.id
+      WHERE mem_observations_fts MATCH ?
+        AND (? IS NULL OR o.scope_id = ?)
+        AND (? = 1 OR o.tier != 'cold')
+        AND (? = 1 OR o.superseded_by IS NULL)
+        AND (? = 1 OR o.archived_at IS NULL)
+      ORDER BY score DESC, o.id DESC
+    `).all(config.memoryHotRecallBoost, query, scopeId ?? null, scopeId ?? null, options.includeCold ? 1 : 0, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0);
+        return rows.map((row) => ({
+            kind: "observation",
+            id: row.id,
+            scopeId: row.scope_id,
+            scope: row.scope,
+            content: row.content,
+            score: row.score,
+            snippet: row.snippet ?? row.content,
+        }));
+    }
+    const pattern = `%${query}%`;
+    const rows = getDb().prepare(`
+    SELECT o.id, o.scope_id, s.slug AS scope, o.content, o.tier
+    FROM mem_observations o
+    JOIN mem_scopes s ON s.id = o.scope_id
+    WHERE (? IS NULL OR o.scope_id = ?)
+      AND (? = 1 OR o.tier != 'cold')
+      AND (? = 1 OR o.superseded_by IS NULL)
+      AND (? = 1 OR o.archived_at IS NULL)
+      AND o.content LIKE ?
+    ORDER BY o.id DESC
+  `).all(scopeId ?? null, scopeId ?? null, options.includeCold ? 1 : 0, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, pattern);
+    return rows.map((row) => ({
+        kind: "observation",
+        id: row.id,
+        scopeId: row.scope_id,
+        scope: row.scope,
+        content: row.content,
+        score: row.tier === "hot" ? config.memoryHotRecallBoost : 1,
+        snippet: row.content,
+    }));
+}
+function recallDecisionHits(query, scopeId, options = {}) {
+    if (isFts5Available()) {
+        const rows = getDb().prepare(`
+      SELECT
+        d.id,
+        d.scope_id,
+        s.slug AS scope,
+        d.title,
+        d.rationale,
+        d.decided_at,
+        d.tier,
+        -bm25(mem_decisions_fts) * CASE WHEN d.tier = 'hot' THEN ? ELSE 1 END AS score,
+        snippet(mem_decisions_fts, 0, '[', ']', '…', 8) || ' — ' ||
+          snippet(mem_decisions_fts, 1, '[', ']', '…', 12) AS snippet
+      FROM mem_decisions d
+      JOIN mem_scopes s ON s.id = d.scope_id
+      JOIN mem_decisions_fts ON mem_decisions_fts.rowid = d.id
+      WHERE mem_decisions_fts MATCH ?
+        AND (? IS NULL OR d.scope_id = ?)
+        AND (? = 1 OR d.tier != 'cold')
+        AND (? = 1 OR d.superseded_by IS NULL)
+        AND (? = 1 OR d.archived_at IS NULL)
+      ORDER BY score DESC, d.id DESC
+    `).all(config.memoryHotRecallBoost, query, scopeId ?? null, scopeId ?? null, options.includeCold ? 1 : 0, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0);
+        return rows.map((row) => ({
+            kind: "decision",
+            id: row.id,
+            scopeId: row.scope_id,
+            scope: row.scope,
+            content: `${row.title} — ${row.rationale}`,
+            decidedAt: row.decided_at,
+            score: row.score,
+            snippet: row.snippet ?? `${row.title} — ${row.rationale}`,
+        }));
+    }
+    const pattern = `%${query}%`;
+    const rows = getDb().prepare(`
+    SELECT d.id, d.scope_id, s.slug AS scope, d.title, d.rationale, d.decided_at, d.tier
+    FROM mem_decisions d
+    JOIN mem_scopes s ON s.id = d.scope_id
+    WHERE (? IS NULL OR d.scope_id = ?)
+      AND (? = 1 OR d.tier != 'cold')
+      AND (? = 1 OR d.superseded_by IS NULL)
+      AND (? = 1 OR d.archived_at IS NULL)
+      AND (d.title LIKE ? OR d.rationale LIKE ?)
+    ORDER BY d.decided_at DESC, d.id DESC
+  `).all(scopeId ?? null, scopeId ?? null, options.includeCold ? 1 : 0, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, pattern, pattern);
+    return rows.map((row) => ({
+        kind: "decision",
+        id: row.id,
+        scopeId: row.scope_id,
+        scope: row.scope,
+        content: `${row.title} — ${row.rationale}`,
+        decidedAt: row.decided_at,
+        score: row.tier === "hot" ? config.memoryHotRecallBoost : 1,
+        snippet: `${row.title} — ${row.rationale}`,
+    }));
+}
+function recallEntityHits(query, scopeId, options = {}) {
+    const pattern = `%${query}%`;
+    const rows = getDb().prepare(`
+    SELECT e.id, e.scope_id, s.slug AS scope, e.name, e.summary, e.tier
+    FROM mem_entities e
+    JOIN mem_scopes s ON s.id = e.scope_id
+    WHERE (? IS NULL OR e.scope_id = ?)
+      AND (e.name LIKE ? OR COALESCE(e.summary, '') LIKE ?)
+      AND (? = 1 OR e.tier != 'cold')
+    ORDER BY e.updated_at DESC, e.id DESC
+  `).all(scopeId ?? null, scopeId ?? null, pattern, pattern, options.includeCold ? 1 : 0);
+    return rows.map((row) => ({
+        kind: "entity",
+        id: row.id,
+        scopeId: row.scope_id,
+        scope: row.scope,
+        content: `${row.name}${row.summary ? ` — ${row.summary}` : ""}`,
+        score: (row.name.toLowerCase().includes(query.toLowerCase()) ? 2 : 1)
+            * (row.tier === "hot" ? config.memoryHotRecallBoost : 1),
+        snippet: `${row.name}${row.summary ? ` — ${row.summary}` : ""}`,
+    }));
+}
+export function recall(input) {
+    const activeScope = getActiveScope();
+    const effectiveScopeId = input.scope_id ?? activeScope?.id;
+    const requestedKinds = new Set(input.kinds ?? ["observation", "decision", "entity"]);
+    const hotTier = activeScope && (!effectiveScopeId || activeScope.id === effectiveScopeId)
+        ? recallHotTier(activeScope.id, input)
+        : [];
+    const hits = [
+        ...(requestedKinds.has("observation") ? recallObservationHits(input.query, effectiveScopeId, input) : []),
+        ...(requestedKinds.has("decision") ? recallDecisionHits(input.query, effectiveScopeId, input) : []),
+        ...(requestedKinds.has("entity") ? recallEntityHits(input.query, effectiveScopeId, input) : []),
+    ]
+        .sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return b.id - a.id;
+    })
+        .slice(0, input.limit ?? 10);
+    if (hits.length > 0) {
+        const db = getDb();
+        const tables = {
+            observation: "mem_observations",
+            decision: "mem_decisions",
+            entity: "mem_entities",
+        };
+        for (const kind of Object.keys(tables)) {
+            const ids = hits.filter((hit) => hit.kind === kind).map((hit) => hit.id);
+            if (ids.length > 0) {
+                db.prepare(`UPDATE ${tables[kind]} SET last_recalled_at = CURRENT_TIMESTAMP WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
+            }
+        }
+    }
+    return {
+        activeScope,
+        hotTier,
+        hits,
+    };
+}
+//# sourceMappingURL=recall.js.map

package/dist/memory/recall.test.js

@@ -0,0 +1,196 @@
+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-recall-${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("recall returns active-scope hot-tier entries before ranked FTS hits and respects filters", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const recall = getFunction(memoryModule, "recall");
+    const chapterhouse = getScope("chapterhouse");
+    const global = getScope("global");
+    assert.ok(chapterhouse && global, "seeded scopes should be available");
+    setActiveScope("chapterhouse");
+    const hotObservation = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Hot memory: build with npm run build before releasing scoped memory changes.",
+        source: "user",
+        tier: "hot",
+    });
+    const bestDecision = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "Use SQLite FTS5 for scoped recall",
+        rationale: "SQLite FTS5 gives ranked scoped recall and snippet generation for agent memory.",
+        decided_at: "2026-05-13",
+    });
+    recordObservation({
+        scope_id: chapterhouse.id,
+        content: "SQLite recall fallback exists, but FTS5 is preferred for ranked snippet output.",
+        source: "user",
+        tier: "warm",
+    });
+    recordObservation({
+        scope_id: global.id,
+        content: "Global memory should not leak into chapterhouse-scoped recall.",
+        source: "user",
+        tier: "hot",
+    });
+    upsertEntity({
+        scope_id: chapterhouse.id,
+        kind: "tool",
+        name: "better-sqlite3",
+        summary: "SQLite driver backing FTS5 recall and scope settings.",
+        tier: "warm",
+        confidence: 0.9,
+    });
+    const full = recall({ query: "SQLite FTS5 scoped recall", scope_id: chapterhouse.id, limit: 10 });
+    assert.equal(full.activeScope?.slug, "chapterhouse");
+    assert.equal(full.hotTier.some((entry) => entry.id === hotObservation.id), true);
+    assert.equal(full.hits.some((entry) => entry.id === bestDecision.id && entry.kind === "decision"), true);
+    assert.equal(full.hits.every((entry) => entry.snippet.toLowerCase().includes("sqlite")), true);
+    assert.equal(full.hits[0]?.id, bestDecision.id);
+    const decisionOnly = recall({
+        query: "SQLite FTS5 scoped recall",
+        scope_id: chapterhouse.id,
+        kinds: ["decision"],
+        limit: 10,
+    });
+    assert.equal(decisionOnly.hits.every((entry) => entry.kind === "decision"), true);
+    const limited = recall({
+        query: "SQLite FTS5 scoped recall",
+        scope_id: chapterhouse.id,
+        limit: 1,
+    });
+    assert.equal(limited.hits.length, 1);
+});
+test("recall excludes superseded and archived rows by default with opt-in inclusion", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const recall = getFunction(memoryModule, "recall");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const liveObservation = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "retention sentinel live observation",
+        source: "test",
+    });
+    const supersededObservation = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "retention sentinel superseded observation",
+        source: "test",
+    });
+    const archivedObservation = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "retention sentinel archived observation",
+        source: "test",
+    });
+    const liveDecision = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "retention sentinel live decision",
+        rationale: "visible decision",
+    });
+    const supersededDecision = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "retention sentinel superseded decision",
+        rationale: "hidden decision",
+        decided_at: "2026-05-12",
+    });
+    const archivedDecision = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "retention sentinel archived decision",
+        rationale: "hidden decision",
+        decided_at: "2026-05-11",
+    });
+    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(liveObservation.id, supersededObservation.id);
+    db.prepare(`UPDATE mem_observations SET archived_at = CURRENT_TIMESTAMP WHERE id = ?`).run(archivedObservation.id);
+    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(liveDecision.id, supersededDecision.id);
+    db.prepare(`UPDATE mem_decisions SET archived_at = CURRENT_TIMESTAMP WHERE id = ?`).run(archivedDecision.id);
+    const defaults = recall({ query: "retention sentinel", scope_id: chapterhouse.id, limit: 20 });
+    assert.equal(defaults.hits.some((hit) => hit.id === liveObservation.id && hit.kind === "observation"), true);
+    assert.equal(defaults.hits.some((hit) => hit.id === liveDecision.id && hit.kind === "decision"), true);
+    assert.equal(defaults.hits.some((hit) => hit.id === supersededObservation.id && hit.kind === "observation"), false);
+    assert.equal(defaults.hits.some((hit) => hit.id === archivedObservation.id && hit.kind === "observation"), false);
+    assert.equal(defaults.hits.some((hit) => hit.id === supersededDecision.id && hit.kind === "decision"), false);
+    assert.equal(defaults.hits.some((hit) => hit.id === archivedDecision.id && hit.kind === "decision"), false);
+    const included = recall({
+        query: "retention sentinel",
+        scope_id: chapterhouse.id,
+        limit: 20,
+        includeSuperseded: true,
+        includeArchived: true,
+    });
+    assert.equal(included.hits.some((hit) => hit.id === supersededObservation.id && hit.kind === "observation"), true);
+    assert.equal(included.hits.some((hit) => hit.id === archivedObservation.id && hit.kind === "observation"), true);
+    assert.equal(included.hits.some((hit) => hit.id === supersededDecision.id && hit.kind === "decision"), true);
+    assert.equal(included.hits.some((hit) => hit.id === archivedDecision.id && hit.kind === "decision"), true);
+});
+test("recall boosts hot rows and excludes cold rows unless includeCold is set", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const recall = getFunction(memoryModule, "recall");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const warm = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "tierboost sentinel equal lexical match",
+        source: "test",
+        tier: "warm",
+    });
+    const hot = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "tierboost sentinel equal lexical match",
+        source: "test",
+        tier: "hot",
+    });
+    const cold = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "tierboost sentinel cold lexical match",
+        source: "test",
+        tier: "cold",
+    });
+    const defaults = recall({ query: "tierboost sentinel", scope_id: chapterhouse.id, kinds: ["observation"], limit: 10 });
+    assert.equal(defaults.hits[0]?.id, hot.id);
+    assert.equal(defaults.hits.some((hit) => hit.id === warm.id), true);
+    assert.equal(defaults.hits.some((hit) => hit.id === cold.id), false);
+    const withCold = recall({ query: "tierboost sentinel", scope_id: chapterhouse.id, kinds: ["observation"], limit: 10, includeCold: true });
+    assert.equal(withCold.hits.some((hit) => hit.id === cold.id), true);
+});
+//# sourceMappingURL=recall.test.js.map

package/dist/memory/scopes.js

@@ -0,0 +1,89 @@
+import { getDb } from "../store/db.js";
+function parseKeywords(raw, scopeSlug) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string")) {
+        throw new Error(`Invalid mem_scopes.keywords payload for scope '${scopeSlug}'.`);
+    }
+    return parsed;
+}
+function serializeKeywords(keywords) {
+    if (!Array.isArray(keywords) || keywords.some((keyword) => typeof keyword !== "string")) {
+        throw new Error("Scope keywords must be an array of strings.");
+    }
+    return JSON.stringify(keywords);
+}
+function toScope(row) {
+    return {
+        id: row.id,
+        slug: row.slug,
+        title: row.title,
+        description: row.description,
+        keywords: parseKeywords(row.keywords, row.slug),
+        active: row.active === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function getScopeRow(idOrSlug) {
+    const db = getDb();
+    if (typeof idOrSlug === "number") {
+        return db.prepare(`
+      SELECT id, slug, title, description, keywords, active, created_at, updated_at
+      FROM mem_scopes
+      WHERE id = ?
+    `).get(idOrSlug);
+    }
+    return db.prepare(`
+    SELECT id, slug, title, description, keywords, active, created_at, updated_at
+    FROM mem_scopes
+    WHERE slug = ?
+  `).get(idOrSlug);
+}
+export function listScopes() {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT id, slug, title, description, keywords, active, created_at, updated_at
+    FROM mem_scopes
+    ORDER BY slug
+  `).all();
+    return rows.map(toScope);
+}
+export function getScope(idOrSlug) {
+    const row = getScopeRow(idOrSlug);
+    return row ? toScope(row) : undefined;
+}
+export function createScope(input) {
+    const db = getDb();
+    const result = db.prepare(`
+    INSERT INTO mem_scopes (slug, title, description, keywords, active, created_at, updated_at)
+    VALUES (?, ?, ?, ?, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.slug, input.title, input.description, serializeKeywords(input.keywords));
+    return getScope(Number(result.lastInsertRowid));
+}
+export function updateScope(id, patch) {
+    const existing = getScope(id);
+    if (!existing) {
+        throw new Error(`Unknown scope id '${id}'.`);
+    }
+    const nextTitle = patch.title ?? existing.title;
+    const nextDescription = patch.description ?? existing.description;
+    const nextKeywords = patch.keywords ?? existing.keywords;
+    getDb().prepare(`
+    UPDATE mem_scopes
+    SET title = ?, description = ?, keywords = ?, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(nextTitle, nextDescription, serializeKeywords(nextKeywords), id);
+    return getScope(id);
+}
+export function deactivateScope(id) {
+    const result = getDb().prepare(`
+    UPDATE mem_scopes
+    SET active = 0, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown scope id '${id}'.`);
+    }
+    return getScope(id);
+}
+//# sourceMappingURL=scopes.js.map

package/dist/memory/scopes.test.js

@@ -0,0 +1,201 @@
+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-scopes-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+const dbPath = join(chapterhouseHome, "chapterhouse.db");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./scopes.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+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("getDb creates memory tables and indexes", async () => {
+    const { dbModule } = await loadModules();
+    try {
+        const db = dbModule.getDb();
+        const tables = new Set(db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'mem_%'`).all()
+            .map((row) => row.name));
+        const indexes = new Set(db.prepare(`SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE 'mem_%'`).all()
+            .map((row) => row.name));
+        for (const name of [
+            "mem_scopes",
+            "mem_entities",
+            "mem_observations",
+            "mem_decisions",
+            "mem_inbox",
+        ]) {
+            assert.equal(tables.has(name), true, `expected memory table ${name}`);
+        }
+        for (const name of [
+            "mem_scopes_slug_idx",
+            "mem_entities_scope_kind_idx",
+            "mem_observations_scope_idx",
+            "mem_decisions_scope_idx",
+            "mem_inbox_status_idx",
+        ]) {
+            assert.equal(indexes.has(name), true, `expected memory index ${name}`);
+        }
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb seeds canonical memory scopes on first run", async () => {
+    const { dbModule } = await loadModules();
+    try {
+        const db = dbModule.getDb();
+        const rows = db.prepare(`
+      SELECT slug, title, description, keywords, active
+      FROM mem_scopes
+      ORDER BY slug
+    `).all();
+        assert.deepEqual(rows, [
+            {
+                slug: "brian",
+                title: "Brian",
+                description: "Brian's preferences, context, working style",
+                keywords: JSON.stringify(["brian"]),
+                active: 1,
+            },
+            {
+                slug: "chapterhouse",
+                title: "Chapterhouse",
+                description: "Chapterhouse codebase, conventions, decisions, gotchas",
+                keywords: JSON.stringify(["chapterhouse", "this repo", "this project", "the daemon"]),
+                active: 1,
+            },
+            {
+                slug: "global",
+                title: "Global",
+                description: "Cross-cutting facts that apply everywhere",
+                keywords: JSON.stringify(["everywhere", "general"]),
+                active: 1,
+            },
+            {
+                slug: "infra",
+                title: "Infra",
+                description: "Infrastructure, hosting, deployment, CI/CD",
+                keywords: JSON.stringify(["infra"]),
+                active: 1,
+            },
+            {
+                slug: "team",
+                title: "Team",
+                description: "Team processes, rituals, OKRs",
+                keywords: JSON.stringify(["team"]),
+                active: 1,
+            },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("memory schema initialization is idempotent", async () => {
+    const { dbModule } = await loadModules();
+    try {
+        dbModule.getDb();
+        dbModule.closeDb();
+        const reopened = await loadModules();
+        const db = reopened.dbModule.getDb();
+        const counts = db.prepare(`
+      SELECT slug, COUNT(*) AS count
+      FROM mem_scopes
+      GROUP BY slug
+      ORDER BY slug
+    `).all();
+        assert.deepEqual(counts, [
+            { slug: "brian", count: 1 },
+            { slug: "chapterhouse", count: 1 },
+            { slug: "global", count: 1 },
+            { slug: "infra", count: 1 },
+            { slug: "team", count: 1 },
+        ]);
+        reopened.dbModule.closeDb();
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("scope CRUD creates, reads, lists, updates, deactivates, and preserves keywords", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    try {
+        const created = memoryModule.createScope({
+            slug: "docs-site",
+            title: "Docs Site",
+            description: "Documentation publishing and content workflows",
+            keywords: ["docs", "content", "publish"],
+        });
+        assert.equal(created.slug, "docs-site");
+        assert.equal(created.title, "Docs Site");
+        assert.equal(created.description, "Documentation publishing and content workflows");
+        assert.deepEqual(created.keywords, ["docs", "content", "publish"]);
+        assert.equal(created.active, true);
+        assert.deepEqual(memoryModule.getScope("docs-site"), created);
+        assert.deepEqual(memoryModule.getScope(created.id), created);
+        const listed = memoryModule.listScopes();
+        assert.equal(listed.some((scope) => scope.slug === "docs-site"), true);
+        await new Promise((resolve) => setTimeout(resolve, 1_100));
+        const updated = memoryModule.updateScope(created.id, {
+            title: "Docs Platform",
+            description: "Docs platform and release content",
+            keywords: ["docs", "release", "guides"],
+        });
+        assert.equal(updated.id, created.id);
+        assert.equal(updated.slug, "docs-site");
+        assert.equal(updated.title, "Docs Platform");
+        assert.equal(updated.description, "Docs platform and release content");
+        assert.deepEqual(updated.keywords, ["docs", "release", "guides"]);
+        assert.notEqual(updated.updatedAt, created.updatedAt);
+        const inactive = memoryModule.deactivateScope(created.id);
+        assert.equal(inactive.active, false);
+        assert.deepEqual(inactive.keywords, ["docs", "release", "guides"]);
+        assert.deepEqual(memoryModule.getScope(created.id), inactive);
+        const storedKeywords = dbModule.getDb()
+            .prepare(`SELECT keywords FROM mem_scopes WHERE id = ?`)
+            .get(created.id).keywords;
+        assert.deepEqual(JSON.parse(storedKeywords), ["docs", "release", "guides"]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("createScope enforces unique slugs", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    try {
+        memoryModule.createScope({
+            slug: "shared",
+            title: "Shared",
+            description: "Shared scope",
+            keywords: ["shared"],
+        });
+        assert.throws(() => memoryModule.createScope({
+            slug: "shared",
+            title: "Shared Again",
+            description: "Duplicate scope",
+            keywords: ["duplicate"],
+        }), /UNIQUE|constraint/i);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+//# sourceMappingURL=scopes.test.js.map