chapterhouse 0.9.2 → 0.11.0

package/dist/store/schema.js

@@ -0,0 +1,501 @@
+import { logger } from "../util/logger.js";
+import { applyMigrations } from "./migrations.js";
+import { MEMORY_SCOPE_SEEDS, seedChapterhouseWikiIndexMemory } from "./repositories/memory.js";
+import { seedWikiPagesFromDisk } from "./repositories/wiki.js";
+function countRows(database, table) {
+    return database.prepare(`SELECT COUNT(*) as c FROM ${table}`).get().c;
+}
+export function initializeSchema(database, hooks) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS worker_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        copilot_session_id TEXT,
+        working_dir TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'idle',
+        last_output TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS agent_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        slug TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        model TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'idle',
+        current_task TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS agent_tasks (
+        task_id TEXT PRIMARY KEY,
+        agent_slug TEXT NOT NULL,
+        description TEXT NOT NULL,
+        prompt TEXT,
+        status TEXT NOT NULL DEFAULT 'running',
+        result TEXT,
+        origin_channel TEXT,
+        started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        slug TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS max_state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS daemon_runs (
+        run_id TEXT PRIMARY KEY,
+        started_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    hooks.recordCurrentDaemonRun(database);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS conversation_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'unknown',
+        session_key TEXT NOT NULL DEFAULT 'default',
+        turn_id TEXT,
+        agent_slug TEXT,
+        agent_display_name TEXT,
+        run_id TEXT,
+        ts DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        category TEXT NOT NULL CHECK(category IN ('preference', 'fact', 'project', 'person', 'routine')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'user',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    applyMigrations(database, 1);
+    // New persistent session table — one row per chat session (default or project)
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS copilot_sessions (
+        session_key TEXT PRIMARY KEY,
+        mode TEXT NOT NULL CHECK(mode IN ('default', 'project', 'agent')),
+        project_root TEXT,
+        copilot_session_id TEXT NOT NULL,
+        model TEXT,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    applyMigrations(database, 4);
+    // agent_task_events: append-only per-task activity log for /workers streaming
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS agent_task_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
+        seq INTEGER NOT NULL,
+        ts INTEGER NOT NULL,
+        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
+        tool_name TEXT,
+        summary TEXT,
+        text TEXT,
+        status TEXT
+      )
+    `);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+    applyMigrations(database, 6);
+    // turn_events: append-only per-turn event log for the SSE chat channel (#130).
+    // Events are written eagerly; ring buffer serves live/recent hot replay.
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS turn_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        turn_id TEXT NOT NULL,
+        session_key TEXT NOT NULL DEFAULT 'default',
+        run_id TEXT,
+        seq INTEGER NOT NULL,
+        ts INTEGER NOT NULL,
+        event_type TEXT NOT NULL,
+        payload TEXT NOT NULL
+      )
+    `);
+    const turnEventCols = database.prepare(`PRAGMA table_info(turn_events)`).all();
+    if (!turnEventCols.some((c) => c.name === "run_id")) {
+        database.exec(`ALTER TABLE turn_events ADD COLUMN run_id TEXT`);
+    }
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_turn_events_turn_id ON turn_events(turn_id, seq)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_turn_events_session_key ON turn_events(session_key, seq)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_turn_events_session_run ON turn_events(session_key, run_id, seq)`);
+    database.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
+      )
+    `);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_scopes_slug_idx ON mem_scopes(slug)`);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS mem_patterns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+        title TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        source_observation_ids TEXT NOT NULL DEFAULT '[]',
+        confidence REAL NOT NULL DEFAULT 0.5,
+        tier TEXT NOT NULL DEFAULT 'warm',
+        created_at TEXT NOT NULL,
+        last_updated TEXT NOT NULL
+      )
+    `);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_patterns_scope_tier_idx ON mem_patterns(scope_id, tier)`);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS mem_entities (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+        slug TEXT,
+        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
+      )
+    `);
+    applyMigrations(database, 7);
+    database.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 = database.prepare(`PRAGMA table_info(mem_observations)`).all();
+    if (!observationCols.some((column) => column.name === "superseded_by")) {
+        database.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")) {
+        database.exec(`ALTER TABLE mem_observations ADD COLUMN archived_at DATETIME`);
+    }
+    database.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,
+        source TEXT,
+        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(`
+      CREATE TABLE IF NOT EXISTS mem_action_items (
+        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,
+        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 DATETIME 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
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS wiki_pages (
+        path TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        entity_type TEXT,
+        tags TEXT DEFAULT '[]',
+        summary TEXT,
+        last_updated TEXT,
+        visibility TEXT DEFAULT 'private',
+        version INTEGER DEFAULT 1,
+        compiled_truth_hash TEXT,
+        pinned INTEGER DEFAULT 0
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS wiki_sources (
+        id TEXT PRIMARY KEY,
+        source_type TEXT NOT NULL,
+        origin TEXT NOT NULL,
+        title TEXT,
+        ingested_at TEXT NOT NULL,
+        raw_path TEXT,
+        parsed_content TEXT,
+        pages_updated TEXT DEFAULT '[]',
+        status TEXT NOT NULL DEFAULT 'active',
+        session_id TEXT,
+        session_name TEXT
+      )
+    `);
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS wiki_links (
+        from_page TEXT NOT NULL,
+        to_page TEXT NOT NULL,
+        link_type TEXT NOT NULL,
+        extracted_at TEXT NOT NULL,
+        PRIMARY KEY (from_page, to_page, link_type)
+      )
+    `);
+    database.exec(`CREATE INDEX IF NOT EXISTS wiki_links_to ON wiki_links(to_page)`);
+    applyMigrations(database, 10);
+    database.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
+      )
+    `);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_inbox_status_idx ON mem_inbox(status)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_inbox_task_status_idx ON mem_inbox(source_task_id, status, kind)`);
+    const inboxCols = database.prepare(`PRAGMA table_info(mem_inbox)`).all();
+    if (!inboxCols.some((column) => column.name === "resolution_reason")) {
+        database.exec(`ALTER TABLE mem_inbox ADD COLUMN resolution_reason TEXT`);
+    }
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS mem_settings (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT NOT NULL UNIQUE,
+        value TEXT NOT NULL
+      )
+    `);
+    const seedMemoryScopes = database.transaction(() => {
+        const insert = database.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();
+    seedChapterhouseWikiIndexMemory(database);
+    // Prune conversation log at startup — keep more history for better recovery
+    database.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)
+    try {
+        database.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          content,
+          content_rowid='id'
+        )
+      `);
+        database.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_observations_fts USING fts5(
+          content,
+          content_rowid='id'
+        )
+      `);
+        database.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_decisions_fts USING fts5(
+          title,
+          rationale,
+          content_rowid='id'
+        )
+      `);
+        database.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_action_items_fts USING fts5(
+          title,
+          detail,
+          content_rowid='id'
+        )
+      `);
+        // Sync triggers
+        database.exec(`DROP TRIGGER IF EXISTS memories_ai`);
+        database.exec(`DROP TRIGGER IF EXISTS memories_ad`);
+        database.exec(`DROP TRIGGER IF EXISTS memories_au`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_observations_ai`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_observations_ad`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_observations_au`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_decisions_ai`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_decisions_ad`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_decisions_au`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_action_items_ai`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_action_items_ad`);
+        database.exec(`DROP TRIGGER IF EXISTS mem_action_items_au`);
+        database.exec(`
+        CREATE TRIGGER memories_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
+        END
+      `);
+        database.exec(`
+        CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
+          DELETE FROM memories_fts WHERE rowid = old.id;
+        END
+      `);
+        database.exec(`
+        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
+      `);
+        database.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
+      `);
+        database.exec(`
+        CREATE TRIGGER mem_observations_ad AFTER DELETE ON mem_observations BEGIN
+          DELETE FROM mem_observations_fts WHERE rowid = old.id;
+        END
+      `);
+        database.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
+      `);
+        database.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
+      `);
+        database.exec(`
+        CREATE TRIGGER mem_decisions_ad AFTER DELETE ON mem_decisions BEGIN
+          DELETE FROM mem_decisions_fts WHERE rowid = old.id;
+        END
+      `);
+        database.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
+      `);
+        database.exec(`
+        CREATE TRIGGER mem_action_items_ai AFTER INSERT ON mem_action_items BEGIN
+          INSERT INTO mem_action_items_fts(rowid, title, detail)
+          VALUES (new.id, new.title, new.detail);
+        END
+      `);
+        database.exec(`
+        CREATE TRIGGER mem_action_items_ad AFTER DELETE ON mem_action_items BEGIN
+          DELETE FROM mem_action_items_fts WHERE rowid = old.id;
+        END
+      `);
+        database.exec(`
+        CREATE TRIGGER mem_action_items_au AFTER UPDATE ON mem_action_items BEGIN
+          DELETE FROM mem_action_items_fts WHERE rowid = old.id;
+          INSERT INTO mem_action_items_fts(rowid, title, detail)
+          VALUES (new.id, new.title, new.detail);
+        END
+      `);
+        database.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS wiki_pages_fts USING fts5(
+          path UNINDEXED,
+          title,
+          entity_type,
+          tags,
+          summary,
+          content='wiki_pages',
+          content_rowid='rowid'
+        )
+      `);
+        database.exec(`DROP TRIGGER IF EXISTS wiki_pages_ai`);
+        database.exec(`DROP TRIGGER IF EXISTS wiki_pages_ad`);
+        database.exec(`DROP TRIGGER IF EXISTS wiki_pages_au`);
+        database.exec(`
+        CREATE TRIGGER wiki_pages_ai AFTER INSERT ON wiki_pages BEGIN
+          INSERT INTO wiki_pages_fts(rowid, path, title, entity_type, tags, summary)
+          VALUES (new.rowid, new.path, new.title, new.entity_type, new.tags, new.summary);
+        END
+      `);
+        database.exec(`
+        CREATE TRIGGER wiki_pages_ad AFTER DELETE ON wiki_pages BEGIN
+          INSERT INTO wiki_pages_fts(wiki_pages_fts, rowid, path, title, entity_type, tags, summary)
+          VALUES('delete', old.rowid, old.path, old.title, old.entity_type, old.tags, old.summary);
+        END
+      `);
+        database.exec(`
+        CREATE TRIGGER wiki_pages_au AFTER UPDATE ON wiki_pages BEGIN
+          INSERT INTO wiki_pages_fts(wiki_pages_fts, rowid, path, title, entity_type, tags, summary)
+          VALUES('delete', old.rowid, old.path, old.title, old.entity_type, old.tags, old.summary);
+          INSERT INTO wiki_pages_fts(rowid, path, title, entity_type, tags, summary)
+          VALUES(new.rowid, new.path, new.title, new.entity_type, new.tags, new.summary);
+        END
+      `);
+        seedWikiPagesFromDisk(database);
+        // Backfill: check if FTS is in sync by comparing row counts
+        const rebuildTables = [];
+        if (countRows(database, "memories") > 0 && countRows(database, "memories_fts") < countRows(database, "memories")) {
+            rebuildTables.push("memories_fts");
+        }
+        if (countRows(database, "mem_observations") > 0 && countRows(database, "mem_observations_fts") < countRows(database, "mem_observations")) {
+            rebuildTables.push("mem_observations_fts");
+        }
+        if (countRows(database, "mem_decisions") > 0 && countRows(database, "mem_decisions_fts") < countRows(database, "mem_decisions")) {
+            rebuildTables.push("mem_decisions_fts");
+        }
+        if (countRows(database, "mem_action_items") > 0 && countRows(database, "mem_action_items_fts") < countRows(database, "mem_action_items")) {
+            rebuildTables.push("mem_action_items_fts");
+        }
+        if (countRows(database, "wiki_pages") > 0 && countRows(database, "wiki_pages_fts") < countRows(database, "wiki_pages")) {
+            rebuildTables.push("wiki_pages_fts");
+        }
+        hooks.setFts5Available(true);
+        hooks.queueFts5Rebuild(database, rebuildTables);
+    }
+    catch {
+        // FTS5 not available in this SQLite build — fall back to LIKE queries
+        hooks.setFts5Available(false);
+        hooks.setFts5Ready(true);
+        logger.warn("FTS5 is not available in this SQLite build — memory recall will use LIKE queries (degraded quality)");
+    }
+}
+//# sourceMappingURL=schema.js.map

package/dist/util/logger.js

@@ -15,9 +15,10 @@
 // System events (startup, sessions, agent dispatch, DB) go at info.
 // ---------------------------------------------------------------------------
 import pino from "pino";
+import { config } from "../config.js";
 const VALID_LEVELS = new Set(["trace", "debug", "info", "warn", "error", "fatal", "silent"]);
 export function resolveLevel(envOverride) {
-    const raw = (envOverride ?? process.env.LOG_LEVEL ?? "info").toLowerCase();
+    const raw = (envOverride ?? config.logLevel ?? "info").toLowerCase();
     return VALID_LEVELS.has(raw) ? raw : "info";
 }
 /** Create a fresh pino logger for the given level. Useful in tests. */
@@ -26,7 +27,7 @@ export function createLogger(level) {
 }
 // In test environments (CHAPTERHOUSE_DISABLE_DOTENV=1), default to silent so
 // test output stays clean. An explicit LOG_LEVEL env var overrides this.
-const defaultLevel = process.env.CHAPTERHOUSE_DISABLE_DOTENV === "1" && !process.env.LOG_LEVEL
+const defaultLevel = config.disableDotenv && !config.logLevel
     ? "silent"
     : resolveLevel();
 export const logger = pino({

package/dist/wiki/consolidation.js

@@ -9,10 +9,9 @@ import { getChapterhouseHome, resolveWikiRelativePath } from "../paths.js";
 import { childLogger } from "../util/logger.js";
 import { deletePage, listPages, readPage, writePage } from "./fs.js";
 import { parseWikiFrontmatter, validateAndBackfillFrontmatter } from "./frontmatter.js";
-import { rebuildWikiIndex, upsertWikiPage, removeWikiPage } from "./index-manager.js";
+import { rebuildWikiIndex, refreshWikiPages, upsertWikiPage, removeWikiPage } from "./index-manager.js";
 import { normalizeWikiPath } from "./path-utils.js";
 const log = childLogger("wiki.consolidation");
-const TRUTH_REWRITE_BUDGET = 18;
 const ONE_DAY_MS = 24 * 60 * 60 * 1000;
 const STALE_SESSION_MS = 7 * ONE_DAY_MS;
 const DEFAULT_MODEL = "claude-haiku-4.5";
@@ -33,9 +32,11 @@ export async function runConsolidationWithDeps(db, partialDeps = {}) {
         staleSessionsNotified: 0,
         llmCallsUsed: 0,
     };
-    const rewriteCandidates = collectRewriteCandidates(db);
+    // Cursor resumes within collectRewriteCandidates' deterministic ordering.
+    const rewriteCandidates = orderCandidatesFromCursor(collectRewriteCandidates(db), getRewriteCursor(db));
+    let lastProcessedRewritePath = null;
     for (const candidate of rewriteCandidates) {
-        if (result.llmCallsUsed >= TRUTH_REWRITE_BUDGET) {
+        if (result.llmCallsUsed >= deps.truthRewriteBudget) {
             break;
         }
         const row = db.prepare(`SELECT title FROM wiki_pages WHERE path = ?`).get(candidate.path);
@@ -51,6 +52,7 @@ export async function runConsolidationWithDeps(db, partialDeps = {}) {
         result.llmCallsUsed += 1;
         applyTruthRewrite(db, candidate.path, candidate.content, synthesized, runAt.toISOString());
         modifiedPaths.add(candidate.path);
+        lastProcessedRewritePath = candidate.path;
         result.truthRewrites += 1;
     }
     result.fragmentsMerged += mergeFragments(db, runAt.toISOString(), modifiedPaths);
@@ -58,7 +60,12 @@ export async function runConsolidationWithDeps(db, partialDeps = {}) {
     result.sourcesArchived += archiveOrphanSources(db);
     result.staleSessionsNotified += notifyStaleSessions(db, deps, runAt);
     ensureConsolidationStateTable(db);
-    deps.rebuildIndex();
+    if (modifiedPaths.size > 0) {
+        refreshWikiPages([...modifiedPaths]);
+    }
+    else {
+        deps.rebuildIndex();
+    }
     result.linksRepaired += repairOrphanLinks(db);
     result.pagesReindexed = modifiedPaths.size;
     db.prepare(`
@@ -66,6 +73,7 @@ export async function runConsolidationWithDeps(db, partialDeps = {}) {
     VALUES (1, ?, ?)
     ON CONFLICT(id) DO UPDATE SET last_run = excluded.last_run, pages_processed = excluded.pages_processed
   `).run(runAt.toISOString(), modifiedPaths.size);
+    updateRewriteCursor(db, rewriteCandidates, lastProcessedRewritePath);
     await deps.commitWikiChanges(runAt);
     return result;
 }
@@ -76,6 +84,7 @@ function createDefaultDeps(db) {
         rebuildIndex: rebuildWikiIndex,
         commitWikiChanges: async (runAt) => commitWikiChanges(runAt),
         createActionItem: ({ title, detail, source }) => createStaleSessionActionItem(db, { title, detail, source }),
+        truthRewriteBudget: config.pkbTruthRewriteBudget,
     };
 }
 function ensureConsolidationSchema(db) {
@@ -96,9 +105,36 @@ function ensureConsolidationStateTable(db) {
     CREATE TABLE IF NOT EXISTS wiki_consolidation_state (
       id INTEGER PRIMARY KEY,
       last_run TEXT,
-      pages_processed INTEGER NOT NULL DEFAULT 0
+      pages_processed INTEGER NOT NULL DEFAULT 0,
+      rewrite_cursor_path TEXT
     )
   `);
+    const columns = db.prepare(`PRAGMA table_info(wiki_consolidation_state)`).all();
+    if (!columns.some((column) => column.name === "rewrite_cursor_path")) {
+        db.exec(`ALTER TABLE wiki_consolidation_state ADD COLUMN rewrite_cursor_path TEXT`);
+    }
+}
+function getRewriteCursor(db) {
+    const row = db.prepare(`SELECT rewrite_cursor_path FROM wiki_consolidation_state WHERE id = 1`).get();
+    return row?.rewrite_cursor_path ?? null;
+}
+function orderCandidatesFromCursor(candidates, cursor) {
+    if (!cursor) {
+        return candidates;
+    }
+    const index = candidates.findIndex((candidate) => candidate.path === cursor);
+    if (index < 0 || index === candidates.length - 1) {
+        return candidates;
+    }
+    return [...candidates.slice(index + 1), ...candidates.slice(0, index + 1)];
+}
+function updateRewriteCursor(db, candidates, lastProcessedPath) {
+    if (!lastProcessedPath) {
+        return;
+    }
+    const processedIndex = candidates.findIndex((candidate) => candidate.path === lastProcessedPath);
+    const nextCursor = processedIndex >= 0 && processedIndex < candidates.length - 1 ? lastProcessedPath : null;
+    db.prepare(`UPDATE wiki_consolidation_state SET rewrite_cursor_path = ? WHERE id = 1`).run(nextCursor);
 }
 function collectRewriteCandidates(db) {
     const rows = db.prepare(`
@@ -276,9 +312,9 @@ function rewritePageReferences(db, fragmentPath, canonicalPath, updatedAt, modif
         if (!content) {
             continue;
         }
-        let nextContent = content.replaceAll(`[[${fragmentTitle}]]`, `[[${canonicalTitle}]]`);
+        let nextContent = replaceWikiLink(content, fragmentTitle, canonicalTitle);
         if (fragmentSlug && canonicalSlug) {
-            nextContent = nextContent.replaceAll(`[[${fragmentSlug}]]`, `[[${canonicalSlug}]]`);
+            nextContent = replaceWikiLink(nextContent, fragmentSlug, canonicalSlug);
         }
         if (nextContent === content) {
             continue;
@@ -295,6 +331,11 @@ function rewritePageReferences(db, fragmentPath, canonicalPath, updatedAt, modif
         modifiedPaths.add(pagePath);
     }
 }
+function replaceWikiLink(content, from, to) {
+    const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`\\[\\[${escaped}(\\|[^\\]]+)?\\]\\]`, "g");
+    return content.replace(pattern, (_match, alias) => alias ? `[[${to}${alias}]]` : `[[${to}]]`);
+}
 function repointLinks(db, canonicalPath, fragmentPath) {
     const rows = db.prepare(`
     SELECT from_page, to_page, link_type, extracted_at
@@ -453,7 +494,7 @@ function recordDuplicateActionItemCheck(db, scopeId, title) {
     return Boolean(row);
 }
 async function synthesizeTruthWithCopilot(input) {
-    const token = config.copilotAuthToken || process.env.COPILOT_TOKEN || process.env.GITHUB_TOKEN;
+    const token = config.copilotAuthToken;
     if (!token) {
         throw new Error(`Cannot consolidate '${input.pagePath}' without a Copilot auth token.`);
     }