chapterhouse 0.3.25 → 0.4.0

package/dist/store/db.js

@@ -1,13 +1,220 @@
 import Database from "better-sqlite3";
-import { DB_PATH, ensureChapterhouseHome } from "../paths.js";
+import { ensureChapterhouseHome, getDbPath } from "../paths.js";
 let db;
 let logInsertCount = 0;
 let fts5Available = false;
+function hasColumn(database, table, column) {
+    return database.prepare(`PRAGMA table_info(${table})`).all().some((entry) => entry.name === column);
+}
+function memoryTierCase(tableAlias = "") {
+    const prefix = tableAlias ? `${tableAlias}.` : "";
+    return `
+    CASE
+      WHEN ${prefix}archived_at IS NOT NULL OR ${prefix}superseded_by IS NOT NULL THEN 'cold'
+      WHEN ${prefix}tier = 'glacier' THEN 'cold'
+      WHEN ${prefix}tier IN ('hot', 'warm', 'cold') THEN ${prefix}tier
+      ELSE 'warm'
+    END
+  `;
+}
+function entityTierCase(tableAlias = "") {
+    const prefix = tableAlias ? `${tableAlias}.` : "";
+    return `
+    CASE
+      WHEN ${prefix}tier = 'glacier' THEN 'cold'
+      WHEN ${prefix}tier IN ('hot', 'warm', 'cold') THEN ${prefix}tier
+      ELSE 'warm'
+    END
+  `;
+}
+function tableCreateSql(database, table) {
+    const row = database.prepare(`
+    SELECT sql
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ?
+  `).get(table);
+    return row?.sql ?? "";
+}
+function rebuildMemoryTierTables(database) {
+    const needsRebuild = ["mem_entities", "mem_observations", "mem_decisions"]
+        .some((table) => tableCreateSql(database, table).includes("'glacier'"));
+    if (!needsRebuild) {
+        return;
+    }
+    database.pragma("foreign_keys = OFF");
+    try {
+        database.transaction(() => {
+            database.exec(`ALTER TABLE mem_entities RENAME TO mem_entities_legacy_tier`);
+            database.exec(`
+        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')),
+          confidence REAL NOT NULL DEFAULT 1.0,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_entities (id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
+        SELECT id, scope_id, kind, name, summary, ${entityTierCase()}, confidence, created_at, updated_at
+        FROM mem_entities_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_entities_legacy_tier`);
+            database.exec(`ALTER TABLE mem_observations RENAME TO mem_observations_legacy_tier`);
+            database.exec(`
+        CREATE TABLE mem_observations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          entity_id INTEGER REFERENCES mem_entities(id),
+          content TEXT NOT NULL,
+          source TEXT NOT NULL,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          confidence REAL NOT NULL DEFAULT 1.0,
+          embedding BLOB,
+          superseded_by INTEGER REFERENCES mem_observations(id) ON DELETE SET NULL,
+          archived_at DATETIME,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_observations (
+          id, scope_id, entity_id, content, source, tier, confidence, embedding, superseded_by, archived_at, created_at
+        )
+        SELECT id, scope_id, entity_id, content, source, ${memoryTierCase()}, confidence, embedding, superseded_by, archived_at, created_at
+        FROM mem_observations_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_observations_legacy_tier`);
+            database.exec(`ALTER TABLE mem_decisions RENAME TO mem_decisions_legacy_tier`);
+            database.exec(`
+        CREATE TABLE mem_decisions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          entity_id INTEGER REFERENCES mem_entities(id),
+          title TEXT NOT NULL,
+          rationale TEXT NOT NULL,
+          decided_at TEXT NOT NULL,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL,
+          archived_at DATETIME,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_decisions (
+          id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+        )
+        SELECT id, scope_id, entity_id, title, rationale, decided_at, ${memoryTierCase()}, superseded_by, archived_at, created_at
+        FROM mem_decisions_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_decisions_legacy_tier`);
+        })();
+    }
+    finally {
+        database.pragma("foreign_keys = ON");
+    }
+}
+function ensureMemoryTierColumns(database) {
+    for (const table of ["mem_entities", "mem_observations", "mem_decisions"]) {
+        if (!hasColumn(database, table, "tier")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier TEXT DEFAULT 'warm'`);
+        }
+        if (!hasColumn(database, table, "tier_pinned_at")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier_pinned_at DATETIME`);
+        }
+        if (!hasColumn(database, table, "tier_reason")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier_reason TEXT`);
+        }
+        if (!hasColumn(database, table, "last_recalled_at")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN last_recalled_at DATETIME`);
+        }
+    }
+    database.exec(`
+    UPDATE mem_entities
+    SET tier = CASE
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN confidence > 0.7 AND datetime(updated_at) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+    database.exec(`
+    UPDATE mem_observations
+    SET tier = CASE
+      WHEN archived_at IS NOT NULL OR superseded_by IS NOT NULL THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN confidence > 0.7 AND datetime(created_at) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+    database.exec(`
+    UPDATE mem_decisions
+    SET tier = CASE
+      WHEN archived_at IS NOT NULL OR superseded_by IS NOT NULL THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN datetime(COALESCE(decided_at, created_at)) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+}
+function ensureMemoryIndexes(database) {
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_entities_scope_kind_idx ON mem_entities(scope_id, kind)`);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_kind_name_idx ON mem_entities(scope_id, kind, name)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_observations_scope_idx ON mem_observations(scope_id)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_decisions_scope_idx ON mem_decisions(scope_id)`);
+}
+const MEMORY_SCOPE_SEEDS = [
+    {
+        slug: "global",
+        title: "Global",
+        description: "Cross-cutting facts that apply everywhere",
+        keywords: ["everywhere", "general"],
+    },
+    {
+        slug: "chapterhouse",
+        title: "Chapterhouse",
+        description: "Chapterhouse codebase, conventions, decisions, gotchas",
+        keywords: ["chapterhouse", "this repo", "this project", "the daemon"],
+    },
+    {
+        slug: "infra",
+        title: "Infra",
+        description: "Infrastructure, hosting, deployment, CI/CD",
+        keywords: ["infra"],
+    },
+    {
+        slug: "team",
+        title: "Team",
+        description: "Team processes, rituals, OKRs",
+        keywords: ["team"],
+    },
+    {
+        slug: "brian",
+        title: "Brian",
+        description: "Brian's preferences, context, working style",
+        keywords: ["brian"],
+    },
+];
 export function getDb() {
     if (!db) {
         ensureChapterhouseHome();
-        db = new Database(DB_PATH);
+        db = new Database(getDbPath());
         db.pragma("journal_mode = WAL");
+        db.pragma("foreign_keys = ON");
         db.exec(`
       CREATE TABLE IF NOT EXISTS worker_sessions (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -62,7 +269,7 @@ export function getDb() {
         db.exec(`
       CREATE TABLE IF NOT EXISTS conversation_log (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
         content TEXT NOT NULL,
         source TEXT NOT NULL DEFAULT 'unknown',
         ts DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -80,16 +287,16 @@ export function getDb() {
     `);
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
-            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();
+            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('agent_completion', '__migration_test__', 'test')`).run();
             db.prepare(`DELETE FROM conversation_log WHERE content = '__migration_test__'`).run();
         }
         catch {
-            // CHECK constraint doesn't allow 'system' — recreate table preserving data
+            // CHECK constraint doesn't allow current synthetic roles — recreate table preserving data
             db.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
             db.exec(`
         CREATE TABLE conversation_log (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
-          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
           content TEXT NOT NULL,
           source TEXT NOT NULL DEFAULT 'unknown',
           ts DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -171,7 +378,7 @@ export function getDb() {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN event_seq INTEGER NOT NULL DEFAULT 0`);
         }
         // turn_events: append-only per-turn event log for the SSE chat channel (#130).
-        // Events are written on turn completion; ring buffer serves live/recent replay.
+        // Events are written eagerly; ring buffer serves live/recent hot replay.
         db.exec(`
       CREATE TABLE IF NOT EXISTS turn_events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -185,6 +392,133 @@ export function getDb() {
     `);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_turn_events_turn_id ON turn_events(turn_id, seq)`);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_turn_events_session_key ON turn_events(session_key, seq)`);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS 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
+      )
+    `);
+        db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_scopes_slug_idx ON mem_scopes(slug)`);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS 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')),
+        confidence REAL NOT NULL DEFAULT 1.0,
+        tier_pinned_at DATETIME,
+        tier_reason TEXT,
+        last_recalled_at DATETIME,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      DELETE FROM mem_entities
+      WHERE id NOT IN (
+        SELECT MIN(id)
+        FROM mem_entities
+        GROUP BY scope_id, kind, name
+      )
+    `);
+        db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_kind_name_idx ON mem_entities(scope_id, kind, name)`);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS mem_observations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+        entity_id INTEGER REFERENCES mem_entities(id),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL,
+        tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+        confidence REAL NOT NULL DEFAULT 1.0,
+        embedding BLOB,
+        superseded_by INTEGER REFERENCES mem_observations(id) ON DELETE SET NULL,
+        archived_at DATETIME,
+        tier_pinned_at DATETIME,
+        tier_reason TEXT,
+        last_recalled_at DATETIME,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        const observationCols = db.prepare(`PRAGMA table_info(mem_observations)`).all();
+        if (!observationCols.some((column) => column.name === "superseded_by")) {
+            db.exec(`ALTER TABLE mem_observations ADD COLUMN superseded_by INTEGER REFERENCES mem_observations(id) ON DELETE SET NULL`);
+        }
+        if (!observationCols.some((column) => column.name === "archived_at")) {
+            db.exec(`ALTER TABLE mem_observations ADD COLUMN archived_at DATETIME`);
+        }
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS mem_decisions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+        entity_id INTEGER REFERENCES mem_entities(id),
+        title TEXT NOT NULL,
+        rationale TEXT NOT NULL,
+        decided_at TEXT NOT NULL,
+        tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+        superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL,
+        archived_at DATETIME,
+        tier_pinned_at DATETIME,
+        tier_reason TEXT,
+        last_recalled_at DATETIME,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        const decisionCols = db.prepare(`PRAGMA table_info(mem_decisions)`).all();
+        if (!decisionCols.some((column) => column.name === "superseded_by")) {
+            db.exec(`ALTER TABLE mem_decisions ADD COLUMN superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL`);
+        }
+        if (!decisionCols.some((column) => column.name === "archived_at")) {
+            db.exec(`ALTER TABLE mem_decisions ADD COLUMN archived_at DATETIME`);
+        }
+        rebuildMemoryTierTables(db);
+        ensureMemoryTierColumns(db);
+        ensureMemoryIndexes(db);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS mem_inbox (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_id INTEGER REFERENCES mem_scopes(id),
+        kind TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        source_agent TEXT NOT NULL,
+        source_task_id TEXT,
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'accepted', 'rejected', 'edited')),
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        resolved_at TEXT,
+        resolution_reason TEXT
+      )
+    `);
+        db.exec(`CREATE INDEX IF NOT EXISTS mem_inbox_status_idx ON mem_inbox(status)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS mem_inbox_task_status_idx ON mem_inbox(source_task_id, status, kind)`);
+        const inboxCols = db.prepare(`PRAGMA table_info(mem_inbox)`).all();
+        if (!inboxCols.some((column) => column.name === "resolution_reason")) {
+            db.exec(`ALTER TABLE mem_inbox ADD COLUMN resolution_reason TEXT`);
+        }
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS mem_settings (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT NOT NULL UNIQUE,
+        value TEXT NOT NULL
+      )
+    `);
+        const seedMemoryScopes = db.transaction(() => {
+            const insert = db.prepare(`
+        INSERT OR IGNORE INTO mem_scopes (slug, title, description, keywords, active, created_at, updated_at)
+        VALUES (?, ?, ?, ?, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      `);
+            for (const scope of MEMORY_SCOPE_SEEDS) {
+                insert.run(scope.slug, scope.title, scope.description, JSON.stringify(scope.keywords));
+            }
+        });
+        seedMemoryScopes();
         // Prune conversation log at startup — keep more history for better recovery
         db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
         // Set up FTS5 for memory search (graceful fallback if not available)
@@ -194,23 +528,79 @@ export function getDb() {
           content,
           content_rowid='id'
         )
+      `);
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_observations_fts USING fts5(
+          content,
+          content_rowid='id'
+        )
+      `);
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_decisions_fts USING fts5(
+          title,
+          rationale,
+          content_rowid='id'
+        )
       `);
             // Sync triggers
+            db.exec(`DROP TRIGGER IF EXISTS memories_ai`);
+            db.exec(`DROP TRIGGER IF EXISTS memories_ad`);
+            db.exec(`DROP TRIGGER IF EXISTS memories_au`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_observations_ai`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_observations_ad`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_observations_au`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_decisions_ai`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_decisions_ad`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_decisions_au`);
             db.exec(`
-        CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        CREATE TRIGGER memories_ai AFTER INSERT ON memories BEGIN
           INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
         END
       `);
             db.exec(`
-        CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-          INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.id, old.content);
+        CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
+          DELETE FROM memories_fts WHERE rowid = old.id;
         END
       `);
             db.exec(`
-        CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-          INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.id, old.content);
+        CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
+          DELETE FROM memories_fts WHERE rowid = old.id;
           INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
         END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_observations_ai AFTER INSERT ON mem_observations BEGIN
+          INSERT INTO mem_observations_fts(rowid, content) VALUES (new.id, new.content);
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_observations_ad AFTER DELETE ON mem_observations BEGIN
+          DELETE FROM mem_observations_fts WHERE rowid = old.id;
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_observations_au AFTER UPDATE ON mem_observations BEGIN
+          DELETE FROM mem_observations_fts WHERE rowid = old.id;
+          INSERT INTO mem_observations_fts(rowid, content) VALUES (new.id, new.content);
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_decisions_ai AFTER INSERT ON mem_decisions BEGIN
+          INSERT INTO mem_decisions_fts(rowid, title, rationale)
+          VALUES (new.id, new.title, new.rationale);
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_decisions_ad AFTER DELETE ON mem_decisions BEGIN
+          DELETE FROM mem_decisions_fts WHERE rowid = old.id;
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER mem_decisions_au AFTER UPDATE ON mem_decisions BEGIN
+          DELETE FROM mem_decisions_fts WHERE rowid = old.id;
+          INSERT INTO mem_decisions_fts(rowid, title, rationale)
+          VALUES (new.id, new.title, new.rationale);
+        END
       `);
             // Backfill: check if FTS is in sync by comparing row counts
             const memCount = db.prepare(`SELECT COUNT(*) as c FROM memories`).get().c;
@@ -218,6 +608,16 @@ export function getDb() {
             if (memCount > 0 && ftsCount < memCount) {
                 db.exec(`INSERT INTO memories_fts(memories_fts) VALUES ('rebuild')`);
             }
+            const observationCount = db.prepare(`SELECT COUNT(*) as c FROM mem_observations`).get().c;
+            const observationFtsCount = db.prepare(`SELECT COUNT(*) as c FROM mem_observations_fts`).get().c;
+            if (observationCount > 0 && observationFtsCount < observationCount) {
+                db.exec(`INSERT INTO mem_observations_fts(mem_observations_fts) VALUES ('rebuild')`);
+            }
+            const decisionCount = db.prepare(`SELECT COUNT(*) as c FROM mem_decisions`).get().c;
+            const decisionFtsCount = db.prepare(`SELECT COUNT(*) as c FROM mem_decisions_fts`).get().c;
+            if (decisionCount > 0 && decisionFtsCount < decisionCount) {
+                db.exec(`INSERT INTO mem_decisions_fts(mem_decisions_fts) VALUES ('rebuild')`);
+            }
             fts5Available = true;
         }
         catch {
@@ -227,6 +627,10 @@ export function getDb() {
     }
     return db;
 }
+export function isFts5Available() {
+    getDb();
+    return fts5Available;
+}
 export function getState(key) {
     const db = getDb();
     const row = db.prepare(`SELECT value FROM max_state WHERE key = ?`).get(key);
@@ -309,7 +713,8 @@ export function getRecentConversation(limit, sessionKey) {
     return rows.map((r) => {
         const tag = r.role === "user" ? `[${r.source}] User`
             : r.role === "system" ? `[${r.source}] System`
-                : "Chapterhouse";
+                : r.role === "agent_completion" ? `[${r.source}] Agent completion`
+                    : "Chapterhouse";
         // Truncate long messages to keep context manageable
         const content = r.content.length > 1500 ? r.content.slice(0, 1500) + "…" : r.content;
         return `${tag}: ${content}`;
@@ -344,21 +749,22 @@ export function normalizeSqliteTsToIso(ts) {
  * suitable for seeding the frontend Zustand store on mount.
  *
  * Unlike `getRecentConversation()`, this returns structured objects (not a
- * formatted string) and omits system messages (role = 'system') because the
- * UI only renders user/assistant turns.
+ * formatted string) and omits internal system messages. Synthetic background
+ * completion notices are included and mapped to assistant-style turns so reload
+ * matches the live chat rendering path.
  */
 export function getSessionMessages(sessionKey, limit) {
     const db = getDb();
     const effectiveLimit = Math.min(limit ?? DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT);
     const rows = db
         .prepare(`SELECT role, content, ts FROM conversation_log
-       WHERE session_key = ? AND role IN ('user', 'assistant')
+       WHERE session_key = ? AND role IN ('user', 'assistant', 'agent_completion')
        ORDER BY id DESC LIMIT ?`)
         .all(sessionKey, effectiveLimit);
     // Reverse so oldest is first (chronological order for the UI)
     rows.reverse();
     return rows.map((r) => ({
-        role: r.role,
+        role: r.role === "agent_completion" ? "assistant" : r.role,
         content: r.content,
         ts: normalizeSqliteTsToIso(r.ts),
     }));

package/dist/store/db.test.js

@@ -117,6 +117,89 @@ test("getDb migrates legacy agent_tasks tables to add a nullable prompt column",
         dbModule.closeDb();
     }
 });
+test("getDb migrates legacy memory tiers from glacier to cold and preserves explicit tiers", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE mem_scopes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      slug TEXT NOT NULL UNIQUE,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      keywords TEXT NOT NULL DEFAULT '[]',
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    INSERT INTO mem_scopes (id, slug, title) VALUES (1, 'chapterhouse', 'Chapterhouse');
+    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', 'glacier')),
+      confidence REAL NOT NULL DEFAULT 1.0,
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE mem_observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+      entity_id INTEGER REFERENCES mem_entities(id),
+      content TEXT NOT NULL,
+      source TEXT NOT NULL,
+      tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'glacier')),
+      confidence REAL NOT NULL DEFAULT 1.0,
+      embedding BLOB,
+      superseded_by INTEGER REFERENCES mem_observations(id) ON DELETE SET NULL,
+      archived_at DATETIME,
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE mem_decisions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+      entity_id INTEGER REFERENCES mem_entities(id),
+      title TEXT NOT NULL,
+      rationale TEXT NOT NULL,
+      decided_at TEXT NOT NULL,
+      tier TEXT NOT NULL DEFAULT 'hot' CHECK(tier IN ('hot', 'warm', 'glacier')),
+      superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL,
+      archived_at DATETIME,
+      created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    INSERT INTO mem_entities (id, scope_id, kind, name, tier) VALUES
+      (1, 1, 'tool', 'warm kept', 'warm'),
+      (2, 1, 'tool', 'cold mapped', 'glacier');
+    INSERT INTO mem_observations (id, scope_id, content, source, tier) VALUES
+      (1, 1, 'hot kept', 'test', 'hot'),
+      (2, 1, 'cold mapped', 'test', 'glacier');
+    INSERT INTO mem_decisions (id, scope_id, title, rationale, decided_at, tier) VALUES
+      (1, 1, 'warm kept', 'test', '2026-05-01', 'warm'),
+      (2, 1, 'cold mapped', 'test', '2026-05-01', 'glacier');
+  `);
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        assert.deepEqual(db.prepare(`SELECT id, tier FROM mem_entities ORDER BY id`).all(), [
+            { id: 1, tier: "warm" },
+            { id: 2, tier: "cold" },
+        ]);
+        assert.deepEqual(db.prepare(`SELECT id, tier FROM mem_observations ORDER BY id`).all(), [
+            { id: 1, tier: "hot" },
+            { id: 2, tier: "cold" },
+        ]);
+        assert.deepEqual(db.prepare(`SELECT id, tier FROM mem_decisions ORDER BY id`).all(), [
+            { id: 1, tier: "warm" },
+            { id: 2, tier: "cold" },
+        ]);
+        db.prepare(`INSERT INTO mem_observations (scope_id, content, source, tier) VALUES (1, 'new cold', 'test', 'cold')`).run();
+        assert.throws(() => db.prepare(`INSERT INTO mem_observations (scope_id, content, source, tier) VALUES (1, 'legacy', 'test', 'glacier')`).run(), /CHECK constraint failed/);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb prunes oversized conversation logs on startup and during inserts", async () => {
     const seedDb = new Database(dbPath);
     seedDb.exec(`
@@ -165,28 +248,32 @@ test("getSessionMessages returns empty array for unknown session", async () => {
         dbModule.closeDb();
     }
 });
-test("getSessionMessages returns structured messages in chronological order, excludes system rows, respects limit", async () => {
+test("getSessionMessages returns structured messages in chronological order, includes agent completions, excludes system rows, respects limit", async () => {
     const dbModule = await loadDbModule();
     try {
-        dbModule.getDb();
+        const db = dbModule.getDb();
         dbModule.logConversation("user", "hello", "web", "test-session");
         dbModule.logConversation("assistant", "hi there", "web", "test-session");
         dbModule.logConversation("system", "system noise", "worker", "test-session");
+        db.prepare(`INSERT INTO conversation_log (role, content, source, session_key)
+       VALUES ('agent_completion', ?, 'background', 'test-session')`).run("[Agent task completed] @coder finished task task-1:\n\nDone");
         dbModule.logConversation("user", "second message", "web", "test-session");
         dbModule.logConversation("user", "from other session", "web", "other-session");
         const all = dbModule.getSessionMessages("test-session");
-        assert.equal(all.length, 3, "3 user/assistant rows, system excluded");
+        assert.equal(all.length, 4, "user/assistant rows plus agent completion, system excluded");
         assert.equal(all[0].role, "user");
         assert.equal(all[0].content, "hello");
         assert.equal(all[1].role, "assistant");
         assert.equal(all[1].content, "hi there");
-        assert.equal(all[2].role, "user");
-        assert.equal(all[2].content, "second message");
+        assert.equal(all[2].role, "assistant");
+        assert.equal(all[2].content, "[Agent task completed] @coder finished task task-1:\n\nDone");
+        assert.equal(all[3].role, "user");
+        assert.equal(all[3].content, "second message");
         // Limit clamping
         const limited = dbModule.getSessionMessages("test-session", 2);
         assert.equal(limited.length, 2, "limit=2 returns 2 most recent rows");
-        // After reversal, these should be the 2 most-recent (assistant + second user)
-        assert.equal(limited[0].content, "hi there");
+        // After reversal, these should be the 2 most-recent renderable rows.
+        assert.equal(limited[0].content, "[Agent task completed] @coder finished task task-1:\n\nDone");
         assert.equal(limited[1].content, "second message");
         // Other session not leaked
         const other = dbModule.getSessionMessages("other-session");