chapterhouse 0.4.1 → 0.4.3

package/dist/store/db.js

@@ -1,11 +1,25 @@
 import Database from "better-sqlite3";
+import { randomUUID } from "node:crypto";
 import { ensureChapterhouseHome, getDbPath } from "../paths.js";
 let db;
 let logInsertCount = 0;
 let fts5Available = false;
+let currentDaemonRunId;
+let daemonRunRecorded = false;
 function hasColumn(database, table, column) {
     return database.prepare(`PRAGMA table_info(${table})`).all().some((entry) => entry.name === column);
 }
+export function getCurrentRunId() {
+    currentDaemonRunId ??= randomUUID();
+    return currentDaemonRunId;
+}
+function recordCurrentDaemonRun(database) {
+    if (daemonRunRecorded) {
+        return;
+    }
+    database.prepare(`INSERT OR IGNORE INTO daemon_runs (run_id) VALUES (?)`).run(getCurrentRunId());
+    daemonRunRecorded = true;
+}
 function memoryTierCase(tableAlias = "") {
     const prefix = tableAlias ? `${tableAlias}.` : "";
     return `
@@ -127,7 +141,7 @@ function rebuildMemoryTierTables(database) {
     }
 }
 function ensureMemoryTierColumns(database) {
-    for (const table of ["mem_entities", "mem_observations", "mem_decisions"]) {
+    for (const table of ["mem_entities", "mem_observations", "mem_decisions", "mem_action_items"]) {
         if (!hasColumn(database, table, "tier")) {
             database.exec(`ALTER TABLE ${table} ADD COLUMN tier TEXT DEFAULT 'warm'`);
         }
@@ -170,12 +184,24 @@ function ensureMemoryTierColumns(database) {
       ELSE 'warm'
     END
   `);
+    database.exec(`
+    UPDATE mem_action_items
+    SET tier = CASE
+      WHEN status IN ('done', 'dropped') THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN status = 'open' AND due_at IS NOT NULL AND datetime(due_at) <= datetime('now', '+7 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)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_mem_action_items_scope_status ON mem_action_items(scope_id, status)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_mem_action_items_due ON mem_action_items(status, due_at)`);
 }
 const MEMORY_SCOPE_SEEDS = [
     {
@@ -209,6 +235,272 @@ const MEMORY_SCOPE_SEEDS = [
         keywords: ["brian"],
     },
 ];
+const CHAPTERHOUSE_WIKI_INDEX_SOURCE = "wiki:pages/projects/chapterhouse/index.md";
+const CHAPTERHOUSE_WIKI_HOT_TIER_REASON = "P6 PR1 wiki migration hot-tier candidate";
+const CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON = "P6 PR2 wiki migration hot-tier candidate";
+const CHAPTERHOUSE_PROJECT_ENTITY_SEED = {
+    name: "Chapterhouse",
+    kind: "project",
+    summary: "Always-on team-level AI assistant daemon that orchestrates specialist subagents and maintains a persistent knowledge wiki.",
+};
+const CHAPTERHOUSE_WIKI_OBSERVATION_SEEDS = [
+    {
+        content: "Chapterhouse architecture: Node.js daemon, web UI, per-conversation sessions, specialist agents, modular skills, MCP servers, local markdown wiki, project-rules prompt injection, and background workers with SSE event streaming.",
+        tier: "warm",
+    },
+    {
+        content: "Chapterhouse source lives at bketelsen/chapterhouse with local checkout ~/projects/chapterhouse; engineering plans are in docs/plans/ and product specs are in docs/prd/.",
+        tier: "warm",
+    },
+    {
+        content: "Background agent completions arrive as automatic system notifications; after spawning a background agent, end the turn and wait instead of polling read_agent, sleeping, or re-checking list_agents.",
+        tier: "hot",
+    },
+    {
+        content: "Use the default Chapterhouse chat for research and general questions; move code changes against a specific project into that project's chat session.",
+        tier: "warm",
+    },
+    {
+        content: "Squad manages Chapterhouse's own development workflow.",
+        tier: "warm",
+    },
+    {
+        content: "Chapterhouse uses frequent semver patch releases published to npm via the Publish to npm GitHub Actions workflow on tag push; never publish manually.",
+        tier: "hot",
+    },
+    {
+        content: "Agent-memory P1 shipped on 2026-05-13 as Chapterhouse v0.4.0 across 7 PRs: #215 through #225.",
+        tier: "warm",
+    },
+    {
+        content: "The v0.3.2 per-session orchestrator was confirmed under real concurrent load on 2026-05-08, enabling concurrent sessions without cross-blocking.",
+        tier: "hot",
+    },
+];
+const CHAPTERHOUSE_WIKI_DECISION_SEEDS = [
+    {
+        title: "Standardize API validation and JSON errors around `src/api/errors.ts`",
+        rationale: "Keep one 400/403/404/500 contract across routes instead of ad hoc parsing and responses; `src/api/errors.ts`, `src/api/server.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Run in standalone mode when neither Entra nor an API token is configured",
+        rationale: "Disable auth checks and team sync together so local single-user startup still works; `src/config.ts`, `src/api/auth.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Use bearer auth for SSE and serialize wiki writes",
+        rationale: "`/stream` no longer accepts query tokens, and wiki mutations go through `withWikiWrite()`; `web/src/stream.ts`, `src/wiki/lock.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Default production to least privilege",
+        rationale: "Run as a non-root container, validate env early, and keep CORS and security headers tight in production; `Dockerfile`, `deploy/deploy.sh`, `src/config.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Keep chat state session-scoped by `sessionKey`",
+        rationale: "Conversation history, SSE routing, and frontend buffers stay isolated per session instead of bleeding across chats; `src/store/db.ts`, `web/src/store.ts`.",
+        decidedAt: "2026-05-07",
+        tier: "warm",
+    },
+    {
+        title: "Preserve the 3-layer daemon timing contract",
+        rationale: "Orchestrator timeout must stay below daemon shutdown grace, which must stay below systemd `TimeoutStopSec`; `README.md`, `src/daemon.ts`, `src/daemon-install.ts`.",
+        decidedAt: "2026-05-08",
+        tier: "hot",
+    },
+    {
+        title: "Start WorkIQ MCP auto-install at daemon startup",
+        rationale: "Write the MCP entry before the SDK client starts so new sessions see it immediately; issue #33, PR #78.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Use per-session orchestrators instead of a global queue",
+        rationale: "`SessionManager` and `SessionRegistry` keep independent queues so one chat cannot block another; issue #74, `src/copilot/session-manager.ts`.",
+        decidedAt: "2026-05-08",
+        tier: "hot",
+    },
+    {
+        title: "Make wiki path hierarchy the primary navigation model",
+        rationale: "`path` drives the tree and breadcrumbs, while `section` remains secondary metadata; `web/src/wiki/index.ts`, `web/src/routes/Wiki.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Route wiki breadcrumbs through `selected` state",
+        rationale: "Breadcrumb clicks use the same route-state flow as the sidebar so navigation stays predictable; `web/src/components/wiki/WikiBreadcrumbs.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Derive wiki page scope from configured team paths",
+        rationale: "The API returns `scope` and the UI shows personal/team indicators without adding new persisted metadata; `src/api/server.ts`, `web/src/components/wiki/WikiScopeIndicator.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Sort sidebar recents by actual project activity",
+        rationale: "`last_used_at` replaces registration time so recent projects reflect chat usage rather than signup order; issue #26, PR #30.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Preload `CHAPTERHOUSE_DISABLE_DOTENV=1` for Node tests",
+        rationale: "Tests must not inherit developer-local env files before config singletons initialize; `src/test/setup-env.ts`, `src/config.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Test API routes through a spawned server process",
+        rationale: "Real HTTP coverage catches auth, config preload, error middleware, and wiki I/O behavior that an unexported in-process app would miss; `src/api/server.test.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Centralize frontend API Zod schemas in `web/src/api-schemas.ts`",
+        rationale: "Keep one audit surface for the browser-to-daemon contract and require validated JSON reads; issue #40, PR #63.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Make frontend test isolation an infrastructure concern",
+        rationale: "Vitest globals, `test-setup.ts`, and MSW own cleanup so tests do not hand-roll it; issue #43, PR #62.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Clean `dist/` before `npm test`",
+        rationale: "Remove stale compiled artifacts so deleted tests cannot linger in the Node test run; `package.json`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Adopt `pino` as the backend logger",
+        rationale: "Use `childLogger()` everywhere and keep chat content at `debug`, not `info`; issue #13, PR #28.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Keep daemon control as a thin CLI over `src/daemon-install.ts`",
+        rationale: "Generate service artifacts in one module and support launchd and systemd user services without a separate control layer; issue #14, PR #24.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Default publish workflows to Node 24+",
+        rationale: "npm Trusted Publishing depends on npm 11.5.1+, which Node 22 does not provide; `.github/workflows/npm-publish.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Make `chapterhouse update` registry-aware",
+        rationale: "Registry installs update via npm, while legacy git installs keep the older pull-and-rebuild path; issue #31, PR #32.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Keep markdownlint pragmatic rather than maximalist",
+        rationale: "Disable MD060, ignore `.github/agents/**`, and suppress MD041 only where template UX requires it; `.markdownlint-cli2.jsonc`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Enforce issue-closing references in feature and fix PRs",
+        rationale: "PR bodies must include `Closes #N`, `Fixes #N`, or `Resolves #N`, with a documented `no-issue` bypass; PR #60, `.github/workflows/lint-pr-closes.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Use Conventional Commits for commits and PR titles",
+        rationale: "Keep repo history machine-readable and enforce it with commitlint, husky, and PR-title linting; `commitlint.config.js`, `.github/workflows/lint-pr-title.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+];
+function seedChapterhouseWikiIndexMemory(database) {
+    database.transaction(() => {
+        const chapterhouseScope = database.prepare(`
+      SELECT id
+      FROM mem_scopes
+      WHERE slug = 'chapterhouse'
+    `).get();
+        if (!chapterhouseScope) {
+            throw new Error("Cannot seed Chapterhouse wiki memory because scope 'chapterhouse' does not exist.");
+        }
+        database.prepare(`
+      INSERT INTO mem_entities (scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 'warm', 1.0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT(scope_id, kind, name) DO UPDATE SET
+        summary = excluded.summary,
+        updated_at = CURRENT_TIMESTAMP
+    `).run(chapterhouseScope.id, CHAPTERHOUSE_PROJECT_ENTITY_SEED.kind, CHAPTERHOUSE_PROJECT_ENTITY_SEED.name, CHAPTERHOUSE_PROJECT_ENTITY_SEED.summary);
+        const chapterhouseEntity = database.prepare(`
+      SELECT id
+      FROM mem_entities
+      WHERE scope_id = ? AND kind = ? AND name = ?
+    `).get(chapterhouseScope.id, CHAPTERHOUSE_PROJECT_ENTITY_SEED.kind, CHAPTERHOUSE_PROJECT_ENTITY_SEED.name);
+        if (!chapterhouseEntity) {
+            throw new Error("Cannot seed Chapterhouse wiki observations because the Chapterhouse entity was not created.");
+        }
+        const insertObservation = database.prepare(`
+      INSERT INTO mem_observations (
+        scope_id, entity_id, content, source, tier, confidence, tier_pinned_at, tier_reason, created_at
+      )
+      SELECT ?, ?, ?, ?, ?, 1.0,
+        CASE WHEN ? = 'hot' THEN CURRENT_TIMESTAMP ELSE NULL END,
+        CASE WHEN ? = 'hot' THEN ? ELSE NULL END,
+        CURRENT_TIMESTAMP
+      WHERE NOT EXISTS (
+        SELECT 1 FROM mem_observations WHERE scope_id = ? AND content = ?
+      )
+    `);
+        const updateObservation = database.prepare(`
+      UPDATE mem_observations
+      SET entity_id = ?,
+        source = ?,
+        tier = CASE WHEN ? = 'hot' THEN 'hot' ELSE tier END,
+        tier_pinned_at = CASE WHEN ? = 'hot' THEN COALESCE(tier_pinned_at, CURRENT_TIMESTAMP) ELSE tier_pinned_at END,
+        tier_reason = CASE WHEN ? = 'hot' THEN ? ELSE tier_reason END
+      WHERE scope_id = ? AND content = ?
+    `);
+        for (const observation of CHAPTERHOUSE_WIKI_OBSERVATION_SEEDS) {
+            insertObservation.run(chapterhouseScope.id, chapterhouseEntity.id, observation.content, CHAPTERHOUSE_WIKI_INDEX_SOURCE, observation.tier, observation.tier, observation.tier, CHAPTERHOUSE_WIKI_HOT_TIER_REASON, chapterhouseScope.id, observation.content);
+            updateObservation.run(chapterhouseEntity.id, CHAPTERHOUSE_WIKI_INDEX_SOURCE, observation.tier, observation.tier, observation.tier, CHAPTERHOUSE_WIKI_HOT_TIER_REASON, chapterhouseScope.id, observation.content);
+        }
+        const insertDecision = database.prepare(`
+      INSERT INTO mem_decisions (
+        scope_id, entity_id, title, rationale, decided_at, tier, tier_pinned_at, tier_reason, created_at
+      )
+      SELECT ?, ?, ?, ?, ?, ?,
+        CASE WHEN ? = 'hot' THEN CURRENT_TIMESTAMP ELSE NULL END,
+        CASE WHEN ? = 'hot' THEN ? ELSE NULL END,
+        CURRENT_TIMESTAMP
+      WHERE NOT EXISTS (
+        SELECT 1 FROM mem_decisions WHERE scope_id = ? AND title = ?
+      )
+    `);
+        const updateDecision = database.prepare(`
+      UPDATE mem_decisions
+      SET entity_id = ?,
+        rationale = ?,
+        decided_at = ?,
+        tier = ?,
+        tier_pinned_at = CASE WHEN ? = 'hot' THEN COALESCE(tier_pinned_at, CURRENT_TIMESTAMP) ELSE NULL END,
+        tier_reason = CASE WHEN ? = 'hot' THEN ? ELSE NULL END
+      WHERE scope_id = ? AND title = ?
+    `);
+        for (const decision of CHAPTERHOUSE_WIKI_DECISION_SEEDS) {
+            insertDecision.run(chapterhouseScope.id, chapterhouseEntity.id, decision.title, decision.rationale, decision.decidedAt, decision.tier, decision.tier, decision.tier, CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON, chapterhouseScope.id, decision.title);
+            updateDecision.run(chapterhouseEntity.id, decision.rationale, decision.decidedAt, decision.tier, decision.tier, decision.tier, CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON, chapterhouseScope.id, decision.title);
+        }
+    })();
+}
 export function getDb() {
     if (!db) {
         ensureChapterhouseHome();
@@ -267,11 +559,23 @@ export function getDb() {
       )
     `);
         db.exec(`
+      CREATE TABLE IF NOT EXISTS daemon_runs (
+        run_id TEXT PRIMARY KEY,
+        started_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        recordCurrentDaemonRun(db);
+        db.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
       )
     `);
@@ -293,16 +597,31 @@ export function getDb() {
         catch {
             // CHECK constraint doesn't allow current synthetic roles — recreate table preserving data
             db.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
+            const oldConvCols = db.prepare(`PRAGMA table_info(conversation_log_old)`).all();
+            const oldConvColNames = new Set(oldConvCols.map((column) => column.name));
+            const sessionKeySelect = oldConvColNames.has("session_key") ? "session_key" : "'default'";
+            const turnIdSelect = oldConvColNames.has("turn_id") ? "turn_id" : "NULL";
+            const agentSlugSelect = oldConvColNames.has("agent_slug") ? "agent_slug" : "NULL";
+            const agentDisplayNameSelect = oldConvColNames.has("agent_display_name") ? "agent_display_name" : "NULL";
+            const runIdSelect = oldConvColNames.has("run_id") ? "run_id" : "NULL";
             db.exec(`
         CREATE TABLE 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
         )
       `);
-            db.exec(`INSERT INTO conversation_log (role, content, source, ts) SELECT role, content, source, ts FROM conversation_log_old`);
+            db.exec(`
+        INSERT INTO conversation_log (role, content, source, session_key, turn_id, agent_slug, agent_display_name, run_id, ts)
+        SELECT role, content, source, ${sessionKeySelect}, ${turnIdSelect}, ${agentSlugSelect}, ${agentDisplayNameSelect}, ${runIdSelect}, ts FROM conversation_log_old
+      `);
             db.exec(`DROP TABLE conversation_log_old`);
         }
         // New persistent session table — one row per chat session (default or project)
@@ -316,11 +635,24 @@ export function getDb() {
         updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
       )
     `);
-        // Migrate: add session_key column to conversation_log if not present
+        // Migrate: add metadata columns to conversation_log if not present
         const convCols = db.prepare(`PRAGMA table_info(conversation_log)`).all();
         if (!convCols.some((c) => c.name === 'session_key')) {
             db.exec(`ALTER TABLE conversation_log ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
         }
+        if (!convCols.some((c) => c.name === 'turn_id')) {
+            db.exec(`ALTER TABLE conversation_log ADD COLUMN turn_id TEXT`);
+        }
+        if (!convCols.some((c) => c.name === 'agent_slug')) {
+            db.exec(`ALTER TABLE conversation_log ADD COLUMN agent_slug TEXT`);
+        }
+        if (!convCols.some((c) => c.name === 'agent_display_name')) {
+            db.exec(`ALTER TABLE conversation_log ADD COLUMN agent_display_name TEXT`);
+        }
+        if (!convCols.some((c) => c.name === "run_id")) {
+            db.exec(`ALTER TABLE conversation_log ADD COLUMN run_id TEXT`);
+        }
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_conversation_log_session_run ON conversation_log(session_key, run_id, id)`);
         // Migrate: add session_key column to agent_tasks if not present
         const taskCols = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
         if (!taskCols.some((c) => c.name === 'session_key')) {
@@ -384,14 +716,20 @@ export function getDb() {
         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 = db.prepare(`PRAGMA table_info(turn_events)`).all();
+        if (!turnEventCols.some((c) => c.name === "run_id")) {
+            db.exec(`ALTER TABLE turn_events ADD COLUMN run_id TEXT`);
+        }
         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 INDEX IF NOT EXISTS idx_turn_events_session_run ON turn_events(session_key, run_id, seq)`);
         db.exec(`
       CREATE TABLE IF NOT EXISTS mem_scopes (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -471,6 +809,27 @@ export function getDb() {
         last_recalled_at DATETIME,
         created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        db.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 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
+      )
     `);
         const decisionCols = db.prepare(`PRAGMA table_info(mem_decisions)`).all();
         if (!decisionCols.some((column) => column.name === "superseded_by")) {
@@ -519,6 +878,7 @@ export function getDb() {
             }
         });
         seedMemoryScopes();
+        seedChapterhouseWikiIndexMemory(db);
         // 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)
@@ -541,6 +901,13 @@ export function getDb() {
           rationale,
           content_rowid='id'
         )
+      `);
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS mem_action_items_fts USING fts5(
+          title,
+          detail,
+          content_rowid='id'
+        )
       `);
             // Sync triggers
             db.exec(`DROP TRIGGER IF EXISTS memories_ai`);
@@ -552,6 +919,9 @@ export function getDb() {
             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(`DROP TRIGGER IF EXISTS mem_action_items_ai`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_action_items_ad`);
+            db.exec(`DROP TRIGGER IF EXISTS mem_action_items_au`);
             db.exec(`
         CREATE TRIGGER memories_ai AFTER INSERT ON memories BEGIN
           INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
@@ -601,6 +971,24 @@ export function getDb() {
           INSERT INTO mem_decisions_fts(rowid, title, rationale)
           VALUES (new.id, new.title, new.rationale);
         END
+      `);
+            db.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
+      `);
+            db.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
+      `);
+            db.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
       `);
             // Backfill: check if FTS is in sync by comparing row counts
             const memCount = db.prepare(`SELECT COUNT(*) as c FROM memories`).get().c;
@@ -618,6 +1006,11 @@ export function getDb() {
             if (decisionCount > 0 && decisionFtsCount < decisionCount) {
                 db.exec(`INSERT INTO mem_decisions_fts(mem_decisions_fts) VALUES ('rebuild')`);
             }
+            const actionItemCount = db.prepare(`SELECT COUNT(*) as c FROM mem_action_items`).get().c;
+            const actionItemFtsCount = db.prepare(`SELECT COUNT(*) as c FROM mem_action_items_fts`).get().c;
+            if (actionItemCount > 0 && actionItemFtsCount < actionItemCount) {
+                db.exec(`INSERT INTO mem_action_items_fts(mem_action_items_fts) VALUES ('rebuild')`);
+            }
             fts5Available = true;
         }
         catch {
@@ -646,9 +1039,10 @@ export function deleteState(key) {
     db.prepare(`DELETE FROM max_state WHERE key = ?`).run(key);
 }
 /** Log a conversation turn (user, assistant, or system). */
-export function logConversation(role, content, source, sessionKey = "default") {
+export function logConversation(role, content, source, sessionKey = "default", metadata) {
     const db = getDb();
-    db.prepare(`INSERT INTO conversation_log (role, content, source, session_key) VALUES (?, ?, ?, ?)`).run(role, content, source, sessionKey);
+    db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, turn_id, agent_slug, agent_display_name, run_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(role, content, source, sessionKey, metadata?.turnId ?? null, metadata?.agentSlug ?? null, metadata?.agentDisplayName ?? null, getCurrentRunId());
     // Keep last 1000 entries to support context recovery after session loss
     logInsertCount++;
     if (logInsertCount % 50 === 0) {
@@ -753,21 +1147,40 @@ export function normalizeSqliteTsToIso(ts) {
  * completion notices are included and mapped to assistant-style turns so reload
  * matches the live chat rendering path.
  */
-export function getSessionMessages(sessionKey, limit) {
+export function getSessionMessages(sessionKey, limit, options = {}) {
     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', 'agent_completion')
-       ORDER BY id DESC LIMIT ?`)
-        .all(sessionKey, effectiveLimit);
+    const includeHistorical = options.includeHistorical ?? false;
+    const runId = options.runId ?? getCurrentRunId();
+    const rows = includeHistorical
+        ? db
+            .prepare(`SELECT id, role, content, ts, turn_id, agent_slug, agent_display_name FROM conversation_log
+         WHERE session_key = ? AND role IN ('user', 'assistant', 'agent_completion')
+         ORDER BY id DESC LIMIT ?`)
+            .all(sessionKey, effectiveLimit)
+        : db
+            .prepare(`SELECT id, role, content, ts, turn_id, agent_slug, agent_display_name FROM conversation_log
+         WHERE session_key = ? AND run_id = ? AND role IN ('user', 'assistant', 'agent_completion')
+         ORDER BY id DESC LIMIT ?`)
+            .all(sessionKey, runId, effectiveLimit);
     // Reverse so oldest is first (chronological order for the UI)
     rows.reverse();
-    return rows.map((r) => ({
-        role: r.role === "agent_completion" ? "assistant" : r.role,
-        content: r.content,
-        ts: normalizeSqliteTsToIso(r.ts),
-    }));
+    return rows.map((r) => {
+        const message = {
+            id: r.id,
+            role: r.role === "agent_completion" ? "assistant" : r.role,
+            content: r.content,
+            ts: normalizeSqliteTsToIso(r.ts),
+            turn_id: r.turn_id,
+        };
+        if (r.turn_id)
+            message.turnId = r.turn_id;
+        if (r.agent_slug)
+            message.agentSlug = r.agent_slug;
+        if (r.agent_display_name)
+            message.agentDisplayName = r.agent_display_name;
+        return message;
+    });
 }
 /**
  * Append one event to agent_task_events and return the new event.
@@ -825,6 +1238,7 @@ export function closeDb() {
     if (db) {
         db.close();
         db = undefined;
+        daemonRunRecorded = false;
     }
 }
 //# sourceMappingURL=db.js.map