chapterhouse 0.3.26 → 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,
@@ -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);

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(`

package/dist/test/setup-env.js

@@ -3,6 +3,22 @@ const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_SELF_EDIT",
     "CHAPTERHOUSE_WORKIQ_AUTO_INSTALL",
     "CHAPTERHOUSE_CHAT_SSE",
+    "CHAPTERHOUSE_SSE_BUFFER_CAPACITY",
+    "CHAPTERHOUSE_SSE_REPLAY_LIMIT",
+    "CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED",
+    "CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS",
+    "CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE",
+    "CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE",
+    "CHAPTERHOUSE_MEMORY_INJECT",
+    "CHAPTERHOUSE_MEMORY_AUTO_ACCEPT",
+    "CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED",
+    "CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED",
+    "CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS",
+    "CHAPTERHOUSE_MEMORY_DECAY_DAYS",
+    "CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS",
+    "CHAPTERHOUSE_MEMORY_TIERING_ENABLED",
+    "CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST",
+    "CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS",
 ];
 for (const name of RUNTIME_OVERRIDE_ENV_VARS) {
     delete process.env[name];

package/dist/test/setup-env.test.js

@@ -5,6 +5,8 @@ const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_SELF_EDIT",
     "CHAPTERHOUSE_WORKIQ_AUTO_INSTALL",
     "CHAPTERHOUSE_CHAT_SSE",
+    "CHAPTERHOUSE_SSE_BUFFER_CAPACITY",
+    "CHAPTERHOUSE_SSE_REPLAY_LIMIT",
 ];
 test("setup-env clears ambient Chapterhouse runtime overrides", async () => {
     const originalValues = new Map(["CHAPTERHOUSE_DISABLE_DOTENV", ...RUNTIME_OVERRIDE_ENV_VARS].map((name) => [name, process.env[name]]));
@@ -14,6 +16,8 @@ test("setup-env clears ambient Chapterhouse runtime overrides", async () => {
         process.env.CHAPTERHOUSE_SELF_EDIT = "1";
         process.env.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL = "false";
         process.env.CHAPTERHOUSE_CHAT_SSE = "0";
+        process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = "3";
+        process.env.CHAPTERHOUSE_SSE_REPLAY_LIMIT = "9";
         await import(`./setup-env.js?cache-bust=${Date.now()}`);
         assert.equal(process.env.CHAPTERHOUSE_DISABLE_DOTENV, "1");
         for (const name of RUNTIME_OVERRIDE_ENV_VARS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.3.26",
+  "version": "0.4.0",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"