chapterhouse 0.9.2 → 0.11.0

package/dist/store/db.js

@@ -1,1499 +1,6 @@
-import Database from "better-sqlite3";
-import { randomUUID } from "node:crypto";
-import { ensureChapterhouseHome, getDbPath } from "../paths.js";
-import { ensureWikiStructure, listPages, readPage } from "../wiki/fs.js";
-import { parseWikiFrontmatter } from "../wiki/frontmatter.js";
-// Reset in tests via src/test/helpers/reset-singletons.ts
-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 `
-    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 ?? "";
-}
-const ACTION_LOG_PAGE_RE = /^pages\/_meta\/log(?:-\d{4})?\.md$/;
-const LEGACY_INDEX_PAGE = "pages/index.md";
-function isIgnoredWikiIndexPage(path) {
-    return path === LEGACY_INDEX_PAGE || ACTION_LOG_PAGE_RE.test(path);
-}
-function wikiBasenameTitle(path) {
-    const segs = path.split("/").filter(Boolean);
-    const file = segs[segs.length - 1] || path;
-    const base = file.replace(/\.md$/, "");
-    const titleBase = base === "index" && segs.length >= 2 ? segs[segs.length - 2] : base;
-    return titleBase.split(/[-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-function summarizeWikiBody(body) {
-    for (const raw of body.split("\n")) {
-        const line = raw.trim();
-        if (!line || line.startsWith("#") || line.startsWith("<!--")) {
-            continue;
-        }
-        const summary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
-        if (summary) {
-            return summary.length > 160 ? `${summary.slice(0, 157)}…` : summary;
-        }
-    }
-    return "";
-}
-function seedWikiPagesFromDisk(database) {
-    ensureWikiStructure();
-    const pages = listPages().filter((page) => !isIgnoredWikiIndexPage(page));
-    if (pages.length === 0) {
-        return;
-    }
-    const wikiPageCount = database.prepare(`SELECT COUNT(*) AS count FROM wiki_pages`).get().count;
-    if (wikiPageCount > 0) {
-        return;
-    }
-    const upsert = database.prepare(`
-    INSERT INTO wiki_pages (path, title, entity_type, tags, summary, last_updated)
-    VALUES (?, ?, ?, ?, ?, ?)
-    ON CONFLICT(path) DO UPDATE SET
-      title = excluded.title,
-      entity_type = excluded.entity_type,
-      tags = excluded.tags,
-      summary = excluded.summary,
-      last_updated = excluded.last_updated,
-      version = wiki_pages.version + 1
-  `);
-    for (const page of pages) {
-        const content = readPage(page);
-        if (!content) {
-            continue;
-        }
-        const { parsed: fm, body } = parseWikiFrontmatter(content);
-        const summary = fm.summary?.trim() || summarizeWikiBody(body) || fm.title || wikiBasenameTitle(page);
-        const entityType = fm.metadata?.["entity_type"] ?? null;
-        upsert.run(page, fm.title ?? wikiBasenameTitle(page), entityType, JSON.stringify(fm.tags ?? []), summary, fm.updated ?? new Date().toISOString());
-    }
-}
-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),
-          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
-        )
-      `);
-            database.exec(`
-        INSERT INTO mem_entities (id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at)
-        SELECT id, scope_id, NULL, 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,
-          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(`
-        INSERT INTO mem_decisions (
-          id, scope_id, entity_id, title, rationale, decided_at, source, tier, superseded_by, archived_at, created_at
-        )
-        SELECT id, scope_id, entity_id, title, rationale, decided_at, NULL, ${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", "mem_action_items"]) {
-        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
-  `);
-    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 UNIQUE INDEX IF NOT EXISTS mem_entities_scope_slug_idx ON mem_entities(scope_id, slug) WHERE slug IS NOT NULL`);
-    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 = [
-    {
-        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"],
-    },
-];
-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();
-        db = new Database(getDbPath());
-        db.pragma("journal_mode = WAL");
-        db.pragma("busy_timeout = 5000");
-        db.pragma("foreign_keys = ON");
-        db.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
-      )
-    `);
-        db.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
-      )
-    `);
-        db.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
-      )
-    `);
-        db.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
-      )
-    `);
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS max_state (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      )
-    `);
-        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
-      )
-    `);
-        db.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
-      )
-    `);
-        // Migrate: if the table already existed with a stricter CHECK, recreate it
-        try {
-            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 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, 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)
-        db.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
-      )
-    `);
-        try {
-            db.prepare(`
-        INSERT INTO copilot_sessions (session_key, mode, copilot_session_id)
-        VALUES ('__mode_probe__', 'agent', '__probe__')
-      `).run();
-            db.prepare(`DELETE FROM copilot_sessions WHERE session_key = '__mode_probe__'`).run();
-        }
-        catch {
-            db.exec(`ALTER TABLE copilot_sessions RENAME TO copilot_sessions_old`);
-            db.exec(`
-        CREATE TABLE 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
-        )
-      `);
-            db.exec(`
-        INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
-        SELECT session_key, mode, project_root, copilot_session_id, model, updated_at
-        FROM copilot_sessions_old
-      `);
-            db.exec(`DROP TABLE copilot_sessions_old`);
-        }
-        // 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')) {
-            db.exec(`ALTER TABLE agent_tasks ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
-        }
-        // Migrate: add source column to agent_tasks ('adhoc') if not present
-        if (!taskCols.some((c) => c.name === 'source')) {
-            db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
-        }
-        if (!taskCols.some((c) => c.name === "prompt")) {
-            db.exec(`ALTER TABLE agent_tasks ADD COLUMN prompt TEXT`);
-        }
-        // agent_task_events: append-only per-task activity log for /workers streaming
-        db.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
-      )
-    `);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
-        // Migrate existing agent_task_events tables that lack text/status columns
-        const taskEventCols = db.prepare(`PRAGMA table_info(agent_task_events)`).all();
-        if (!taskEventCols.some((c) => c.name === "text") || !taskEventCols.some((c) => c.name === "status")) {
-            db.exec(`ALTER TABLE agent_task_events RENAME TO agent_task_events_old`);
-            db.exec(`
-        CREATE TABLE 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
-        )
-      `);
-            db.exec(`
-        INSERT INTO agent_task_events (id, task_id, seq, ts, kind, tool_name, summary)
-        SELECT id, task_id, seq, ts, kind, tool_name, summary FROM agent_task_events_old
-      `);
-            db.exec(`DROP TABLE agent_task_events_old`);
-            db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
-        }
-        // Migrate: add event_seq column to agent_tasks for monotonic event numbering
-        const taskColsNow = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
-        if (!taskColsNow.some((c) => c.name === 'event_seq')) {
-            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 eagerly; ring buffer serves live/recent hot replay.
-        db.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 = 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,
-        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_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
-      )
-    `);
-        db.exec(`CREATE INDEX IF NOT EXISTS mem_patterns_scope_tier_idx ON mem_patterns(scope_id, tier)`);
-        db.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
-      )
-    `);
-        const entityCols = db.prepare(`PRAGMA table_info(mem_entities)`).all();
-        if (!entityCols.some((column) => column.name === "slug")) {
-            db.exec(`ALTER TABLE mem_entities ADD COLUMN slug TEXT`);
-        }
-        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 UNIQUE INDEX IF NOT EXISTS mem_entities_scope_slug_idx ON mem_entities(scope_id, slug) WHERE slug IS NOT NULL`);
-        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,
-        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
-      )
-    `);
-        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
-      )
-    `);
-        db.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
-      )
-    `);
-        db.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
-      )
-    `);
-        db.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)
-      )
-    `);
-        db.exec(`CREATE INDEX IF NOT EXISTS wiki_links_to ON wiki_links(to_page)`);
-        const wikiSourceCols = db.prepare(`PRAGMA table_info(wiki_sources)`).all();
-        if (!wikiSourceCols.some((column) => column.name === "status")) {
-            db.exec(`ALTER TABLE wiki_sources ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
-        }
-        if (!wikiSourceCols.some((column) => column.name === "session_id")) {
-            db.exec(`ALTER TABLE wiki_sources ADD COLUMN session_id TEXT`);
-        }
-        if (!wikiSourceCols.some((column) => column.name === "session_name")) {
-            db.exec(`ALTER TABLE wiki_sources ADD COLUMN session_name TEXT`);
-        }
-        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`);
-        }
-        if (!decisionCols.some((column) => column.name === "source")) {
-            db.exec(`ALTER TABLE mem_decisions ADD COLUMN source TEXT`);
-        }
-        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();
-        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)
-        try {
-            db.exec(`
-        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-          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'
-        )
-      `);
-            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`);
-            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(`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);
-        END
-      `);
-            db.exec(`
-        CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
-          DELETE FROM memories_fts WHERE rowid = old.id;
-        END
-      `);
-            db.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
-      `);
-            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
-      `);
-            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
-      `);
-            db.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'
-        )
-      `);
-            db.exec(`DROP TRIGGER IF EXISTS wiki_pages_ai`);
-            db.exec(`DROP TRIGGER IF EXISTS wiki_pages_ad`);
-            db.exec(`DROP TRIGGER IF EXISTS wiki_pages_au`);
-            db.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
-      `);
-            db.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
-      `);
-            db.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(db);
-            // Backfill: check if FTS is in sync by comparing row counts
-            const memCount = db.prepare(`SELECT COUNT(*) as c FROM memories`).get().c;
-            const ftsCount = db.prepare(`SELECT COUNT(*) as c FROM memories_fts`).get().c;
-            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')`);
-            }
-            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')`);
-            }
-            const wikiPageCount = db.prepare(`SELECT COUNT(*) as c FROM wiki_pages`).get().c;
-            const wikiPageFtsCount = db.prepare(`SELECT COUNT(*) as c FROM wiki_pages_fts`).get().c;
-            if (wikiPageCount > 0 && wikiPageFtsCount < wikiPageCount) {
-                db.exec(`INSERT INTO wiki_pages_fts(wiki_pages_fts) VALUES ('rebuild')`);
-            }
-            fts5Available = true;
-        }
-        catch {
-            // FTS5 not available in this SQLite build — fall back to LIKE queries
-            fts5Available = false;
-        }
-    }
-    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);
-    return row?.value;
-}
-export function setState(key, value) {
-    const db = getDb();
-    db.prepare(`INSERT OR REPLACE INTO max_state (key, value) VALUES (?, ?)`).run(key, value);
-}
-/** Remove a key from persistent state. */
-export function deleteState(key) {
-    const db = getDb();
-    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", metadata) {
-    const db = getDb();
-    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) {
-        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
-    }
-}
-/** Retrieve a stored Copilot session by key. */
-export function getCopilotSession(sessionKey) {
-    const db = getDb();
-    const row = db
-        .prepare(`SELECT copilot_session_id, model FROM copilot_sessions WHERE session_key = ?`)
-        .get(sessionKey);
-    if (!row)
-        return undefined;
-    return { copilotSessionId: row.copilot_session_id, model: row.model ?? undefined };
-}
-/** Insert or update a Copilot session record. */
-export function upsertCopilotSession(sessionKey, mode, copilotSessionId, projectRoot, model) {
-    const db = getDb();
-    db.prepare(`INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
-     VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-     ON CONFLICT(session_key) DO UPDATE SET
-       copilot_session_id = excluded.copilot_session_id,
-       model              = excluded.model,
-       project_root       = excluded.project_root,
-       updated_at         = CURRENT_TIMESTAMP`).run(sessionKey, mode, projectRoot ?? null, copilotSessionId, model ?? null);
-}
-/**
- * Return the session_key stored against a task, or 'default' if the column
- * doesn't exist yet (Kaylee will add it in a follow-on phase).
- */
-export function getTaskSessionKey(taskId) {
-    const db = getDb();
-    try {
-        const row = db
-            .prepare(`SELECT session_key FROM agent_tasks WHERE task_id = ?`)
-            .get(taskId);
-        return row?.session_key ?? "default";
-    }
-    catch {
-        return "default";
-    }
-}
-/**
- * Return whether a batch of agent tasks has fully reached terminal completion.
- *
- * `completed` and `error` are terminal. Missing rows are treated as not-ready
- * so callers do not open downstream barriers (for example, a Scribe merge pass)
- * until every expected task has recorded a terminal state.
- */
-export function getTaskBarrierStatus(taskIds) {
-    const orderedTaskIds = Array.from(new Set(taskIds.filter((taskId) => taskId.trim().length > 0)));
-    if (orderedTaskIds.length === 0) {
-        return {
-            ready: true,
-            pendingTaskIds: [],
-            missingTaskIds: [],
-            statuses: [],
-        };
-    }
-    const db = getDb();
-    const placeholders = orderedTaskIds.map(() => "?").join(", ");
-    const rows = db.prepare(`SELECT task_id, status FROM agent_tasks WHERE task_id IN (${placeholders})`).all(...orderedTaskIds);
-    const statusByTaskId = new Map(rows.map((row) => [row.task_id, row.status ?? "missing"]));
-    const statuses = orderedTaskIds.map((taskId) => ({
-        taskId,
-        status: statusByTaskId.get(taskId) ?? "missing",
-    }));
-    const missingTaskIds = statuses.filter((entry) => entry.status === "missing").map((entry) => entry.taskId);
-    const pendingTaskIds = statuses
-        .filter((entry) => entry.status !== "completed" && entry.status !== "error")
-        .map((entry) => entry.taskId);
-    return {
-        ready: pendingTaskIds.length === 0,
-        pendingTaskIds,
-        missingTaskIds,
-        statuses,
-    };
-}
-/**
- * Poll `getTaskBarrierStatus` until all tasks are terminal or the timeout
- * is reached.
- *
- * On VS Code, all subagents in a single coordinator turn run concurrently,
- * so Scribe cannot rely on siblings being complete at the instant it starts.
- * This function lets Scribe (or any downstream pass) wait until every
- * sibling has written its `.squad/decisions/inbox/` file and reached a
- * terminal state before proceeding with the merge.
- *
- * Returns the last observed `TaskBarrierStatus`. Callers must check
- * `.ready` — a `false` result means the timeout was reached with at least
- * one task still pending.
- */
-export async function pollTaskBarrierStatus(taskIds, options) {
-    const intervalMs = options?.intervalMs ?? 500;
-    const timeoutMs = options?.timeoutMs ?? 30_000;
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-        const status = getTaskBarrierStatus(taskIds);
-        if (status.ready)
-            return status;
-        if (Date.now() >= deadline)
-            return status;
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-}
-/**
- * Get recent conversation history formatted for injection into system message.
- *
- * When `sessionKey` is provided, only rows belonging to that session are
- * returned — useful for per-session isolation that must not bleed context
- * from other sessions. When omitted, rows from all sessions are returned
- * (legacy behavior for callers that don't care about session isolation).
- */
-export function getRecentConversation(limit, sessionKey) {
-    const db = getDb();
-    const effectiveLimit = limit ?? 20;
-    const rows = sessionKey
-        ? db.prepare(`SELECT role, content, source, ts FROM conversation_log WHERE session_key = ? ORDER BY id DESC LIMIT ?`).all(sessionKey, effectiveLimit)
-        : db.prepare(`SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?`).all(effectiveLimit);
-    if (rows.length === 0)
-        return "";
-    // Reverse so oldest is first (chronological order)
-    rows.reverse();
-    return rows.map((r) => {
-        const tag = r.role === "user" ? `[${r.source}] User`
-            : r.role === "system" ? `[${r.source}] System`
-                : 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}`;
-    }).join("\n\n");
-}
-const MAX_SESSION_MESSAGES_LIMIT = 500;
-const DEFAULT_SESSION_MESSAGES_LIMIT = 100;
-/**
- * Normalize a SQLite CURRENT_TIMESTAMP string to a proper ISO-8601 UTC string.
- *
- * SQLite stores CURRENT_TIMESTAMP as "YYYY-MM-DD HH:MM:SS" — no timezone
- * marker, space separator. Browsers that receive this bare string may parse it
- * as *local* time instead of UTC, shifting every displayed timestamp by the
- * user's UTC offset. This helper appends the `Z` suffix (and replaces the space
- * separator with `T`) so that `new Date(ts)` always parses as UTC.
- *
- * - Already-ISO strings (containing `T`) are returned unchanged (idempotent).
- * - Strings with a `T` but no `Z` are left as-is; they are already ISO format
- *   and the caller is responsible for any timezone semantics (we do not blindly
- *   append `Z` and risk double-shifting a value that might already be local).
- * - Falsy / empty input is returned as an empty string rather than throwing.
- */
-export function normalizeSqliteTsToIso(ts) {
-    if (!ts)
-        return "";
-    if (ts.includes("T"))
-        return ts;
-    return ts.replace(" ", "T") + "Z";
-}
-/**
- * Return conversation_log rows for a specific session as structured JSON,
- * suitable for seeding the frontend Zustand store on mount.
- *
- * Unlike `getRecentConversation()`, this returns structured objects (not a
- * 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, options = {}) {
-    const db = getDb();
-    const effectiveLimit = Math.min(limit ?? DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT);
-    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) => {
-        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.
- * Uses a transaction so seq is monotonically incremented.
- * Non-fatal: silently ignores DB errors (task may not exist yet due to race).
- */
-export function appendTaskEvent(taskId, kind, toolName, summary, text = null, status = null) {
-    const db = getDb();
-    try {
-        return db.transaction(() => {
-            db.prepare(`UPDATE agent_tasks SET event_seq = event_seq + 1 WHERE task_id = ?`).run(taskId);
-            const row = db.prepare(`SELECT event_seq FROM agent_tasks WHERE task_id = ?`).get(taskId);
-            if (!row)
-                return undefined;
-            const seq = row.event_seq;
-            const ts = Date.now();
-            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary, text, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary, text, status);
-            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary, text, status };
-        })();
-    }
-    catch {
-        return undefined;
-    }
-}
-export function appendTaskOutputDeltaEvent(taskId, text) {
-    return appendTaskEvent(taskId, "output_delta", null, null, text, null);
-}
-export function appendTaskStatusEvent(taskId, status, summary = null) {
-    return appendTaskEvent(taskId, "task_status", null, summary, null, status);
-}
-export function updateTaskResult(taskId, status, result) {
-    const db = getDb();
-    db.prepare(`UPDATE agent_tasks SET status = ?, result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(status, result ? result.slice(0, 10000) : null, taskId);
-}
-/**
- * Return all events for a task ordered by seq ascending.
- */
-export function getTaskEvents(taskId, afterSeq = 0) {
-    const db = getDb();
-    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary, text, status
-     FROM agent_task_events WHERE task_id = ? AND seq > ? ORDER BY seq ASC`).all(taskId, afterSeq);
-    return rows.map((r) => ({
-        id: r.id,
-        taskId: r.task_id,
-        seq: r.seq,
-        ts: r.ts,
-        kind: r.kind,
-        toolName: r.tool_name,
-        summary: r.summary,
-        text: r.text,
-        status: r.status,
-    }));
-}
-export function closeDb() {
-    if (db) {
-        db.close();
-        db = undefined;
-        daemonRunRecorded = false;
-    }
-}
-export function resetDbForTests() {
-    closeDb();
-    logInsertCount = 0;
-    fts5Available = false;
-    currentDaemonRunId = undefined;
-    daemonRunRecorded = false;
-}
+export { closeDb, getCurrentRunId, getDb, isFts5Available, isFts5Ready, resetDbForTests } from "./connection.js";
+export { applyMigrations, DB_MIGRATIONS } from "./migrations.js";
+export { seedWikiPagesFromDisk } from "./repositories/wiki.js";
+export { seedChapterhouseWikiIndexMemory } from "./repositories/memory.js";
+export { appendTaskEvent, appendTaskOutputDeltaEvent, appendTaskStatusEvent, deleteCopilotSession, deleteState, getCopilotSession, getRecentConversation, getSessionMessages, getState, getTaskBarrierStatus, getTaskEvents, getTaskSessionKey, logConversation, normalizeSqliteTsToIso, pollTaskBarrierStatus, setState, updateTaskResult, upsertCopilotSession, } from "./repositories/sessions.js";
 //# sourceMappingURL=db.js.map