chapterhouse 0.9.2 → 0.10.0

package/dist/store/db.test.js

@@ -26,6 +26,58 @@ test.after(() => {
     resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
+test("getDb returns the same singleton connection until closeDb is called", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const first = dbModule.getDb();
+        const second = dbModule.getDb();
+        assert.equal(second, first);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("closeDb allows getDb to reinitialize a new usable connection without losing persisted state", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const first = dbModule.getDb();
+        dbModule.setState("db-reinit-sentinel", "persisted");
+        dbModule.closeDb();
+        const second = dbModule.getDb();
+        assert.notEqual(second, first);
+        assert.equal(dbModule.getState("db-reinit-sentinel"), "persisted");
+        assert.deepEqual(second.prepare("SELECT 1 AS ok").get(), { ok: 1 });
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb records migrations once in registry order across repeated startups", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        let db = dbModule.getDb();
+        const firstRows = db.prepare(`
+      SELECT version, name
+      FROM __db_migrations
+      ORDER BY rowid
+    `).all();
+        assert.ok(firstRows.length > 0, "expected at least one tracked migration");
+        assert.deepEqual(firstRows.map((row) => row.version), [...firstRows].map((row) => row.version).sort((a, b) => a - b), "migrations should be recorded in ascending registry order");
+        assert.equal(new Set(firstRows.map((row) => row.version)).size, firstRows.length, "migration versions should be unique");
+        assert.equal(new Set(firstRows.map((row) => row.name)).size, firstRows.length, "migration names should be unique");
+        dbModule.closeDb();
+        db = dbModule.getDb();
+        const secondRows = db.prepare(`
+      SELECT version, name
+      FROM __db_migrations
+      ORDER BY rowid
+    `).all();
+        assert.deepEqual(secondRows, firstRows);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb startup reindex populates wiki_pages when pages exist on disk", async () => {
     mkdirSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust"), { recursive: true });
     writeFileSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust", "index.md"), "---\ntitle: Rust\nsummary: Systems language\nupdated: 2026-05-15\n---\n\n# Rust\n\nFearless concurrency.\n", "utf-8");
@@ -68,6 +120,18 @@ test("getDb startup reindex creates the wiki log directory when it is missing",
         dbModule.closeDb();
     }
 });
+test("getDb reports FTS5 readiness after deferred rebuild work finishes", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        assert.equal(typeof dbModule.isFts5Ready, "function");
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        assert.equal(dbModule.isFts5Ready(), true);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb initializes schema, state helpers, and conversation formatting", async () => {
     const dbModule = await loadDbModule();
     try {
@@ -91,13 +155,23 @@ test("getDb initializes schema, state helpers, and conversation formatting", asy
         dbModule.deleteState("router_config");
         assert.equal(dbModule.getState("router_config"), undefined);
         const longReply = "A".repeat(1_550);
+        const oversizedTurn = "B".repeat(10_050);
         dbModule.logConversation("system", "Started background sync", "worker");
         dbModule.logConversation("user", "Please summarize the last deploy", "web");
         dbModule.logConversation("assistant", longReply, "web");
+        dbModule.logConversation("assistant", oversizedTurn, "web");
+        const storedOversizedTurn = db.prepare(`
+      SELECT content
+      FROM conversation_log
+      WHERE content LIKE 'B%'
+      ORDER BY id DESC
+      LIMIT 1
+    `).get();
+        assert.equal(storedOversizedTurn.content.length, 10_000);
         assert.equal(dbModule.getRecentConversation(3), [
-            "[worker] System: Started background sync",
             "[web] User: Please summarize the last deploy",
             `Chapterhouse: ${"A".repeat(1_500)}…`,
+            `Chapterhouse: ${"B".repeat(1_500)}…`,
         ].join("\n\n"));
     }
     finally {
@@ -115,6 +189,7 @@ test("getDb initializes action-item memory schema, reflect patterns schema, and
         assert.equal(tableNames.has("mem_patterns"), true, "expected mem_patterns table");
         const columns = db.prepare(`PRAGMA table_info(mem_action_items)`).all();
         const columnNames = new Set(columns.map((column) => column.name));
+        const columnTypes = new Map(columns.map((column) => [column.name, column.type]));
         for (const name of [
             "id",
             "scope_id",
@@ -136,6 +211,7 @@ test("getDb initializes action-item memory schema, reflect patterns schema, and
         ]) {
             assert.equal(columnNames.has(name), true, `expected mem_action_items.${name}`);
         }
+        assert.equal(columnTypes.get("created_at"), "DATETIME");
         const patternColumns = db.prepare(`PRAGMA table_info(mem_patterns)`).all();
         const patternColumnNames = new Set(patternColumns.map((column) => column.name));
         for (const name of [
@@ -153,6 +229,10 @@ test("getDb initializes action-item memory schema, reflect patterns schema, and
         }
         const patternIndexes = db.prepare(`PRAGMA index_list(mem_patterns)`).all();
         assert.equal(patternIndexes.some((index) => index.name === "mem_patterns_scope_tier_idx"), true, "expected mem_patterns scope/tier index");
+        const observationIndexes = db.prepare(`PRAGMA index_list(mem_observations)`).all();
+        const decisionIndexes = db.prepare(`PRAGMA index_list(mem_decisions)`).all();
+        assert.equal(observationIndexes.some((index) => index.name === "mem_observations_scope_superseded_by_idx"), true);
+        assert.equal(decisionIndexes.some((index) => index.name === "mem_decisions_scope_superseded_by_idx"), true);
         const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
         const inserted = db.prepare(`
       INSERT INTO mem_action_items (scope_id, title, detail, source)
@@ -169,6 +249,107 @@ test("getDb initializes action-item memory schema, reflect patterns schema, and
         dbModule.closeDb();
     }
 });
+test("getDb migrates legacy mem_action_items created_at TEXT schemas without losing rows or indexes", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE mem_scopes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      slug TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      keywords TEXT NOT NULL DEFAULT '[]',
+      active INTEGER NOT NULL DEFAULT 1 CHECK(active IN (0, 1)),
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE mem_action_items (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+      entity_id INTEGER,
+      title TEXT NOT NULL,
+      detail TEXT,
+      status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'done', 'dropped', 'snoozed')),
+      due_at TEXT,
+      snooze_until TEXT,
+      source TEXT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      resolved_at TEXT,
+      resolution_reason TEXT,
+      tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+      tier_pinned_at TEXT,
+      tier_reason TEXT,
+      last_recalled_at TEXT
+    );
+    INSERT INTO mem_scopes (slug, title, description) VALUES ('chapterhouse', 'Chapterhouse', 'Test scope');
+    INSERT INTO mem_action_items (
+      scope_id, title, detail, status, due_at, source, created_at, updated_at, tier, tier_reason
+    ) VALUES (
+      1, 'Follow up on migration', 'Preserve this row', 'open', '2026-05-20 12:00:00', 'test',
+      '2026-05-14 10:11:12', '2026-05-14 10:11:13', 'hot', 'legacy'
+    );
+  `);
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const columns = db.prepare(`PRAGMA table_info(mem_action_items)`).all();
+        const columnTypes = new Map(columns.map((column) => [column.name, column.type]));
+        assert.equal(columnTypes.get("created_at"), "DATETIME");
+        assert.deepEqual(db.prepare(`SELECT title, detail, created_at, tier, tier_reason FROM mem_action_items`).get(), {
+            title: "Follow up on migration",
+            detail: "Preserve this row",
+            created_at: "2026-05-14 10:11:12",
+            tier: "hot",
+            tier_reason: "legacy",
+        });
+        const indexes = db.prepare(`PRAGMA index_list(mem_action_items)`).all();
+        assert.equal(indexes.some((index) => index.name === "idx_mem_action_items_scope_status"), true);
+        assert.equal(indexes.some((index) => index.name === "idx_mem_action_items_due"), true);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb legacy entity tier rebuild promotes recent high-confidence entities to hot", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE mem_scopes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      slug TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      keywords TEXT NOT NULL DEFAULT '[]',
+      active INTEGER NOT NULL DEFAULT 1 CHECK(active IN (0, 1)),
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE mem_entities (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+      kind TEXT NOT NULL,
+      name TEXT NOT NULL,
+      summary TEXT,
+      tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold', 'glacier', 'unknown')),
+      confidence REAL NOT NULL DEFAULT 1.0,
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    INSERT INTO mem_scopes (slug, title, description) VALUES ('chapterhouse', 'Chapterhouse', 'Test scope');
+    INSERT INTO mem_entities (scope_id, kind, name, tier, confidence, updated_at)
+    VALUES (1, 'component', 'memory-db', 'unknown', 0.95, datetime('now'));
+  `);
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const row = db.prepare(`SELECT tier FROM mem_entities WHERE name = 'memory-db'`).get();
+        assert.equal(row.tier, "hot");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb migrates legacy conversation_log tables to allow system messages", async () => {
     const seedDb = new Database(dbPath);
     seedDb.exec(`