chapterhouse 0.7.0 → 0.8.1

package/dist/memory/reflect.test.js

@@ -0,0 +1,254 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const testWorkRoot = join(repoRoot, ".test-work");
+let sandboxRoot = "";
+function resetSandbox() {
+    mkdirSync(testWorkRoot, { recursive: true });
+    sandboxRoot = mkdtempSync(join(testWorkRoot, "memory-reflect-"));
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+}
+async function loadBaseModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
+    const memoryModule = await import(new URL(`./index.js?case=${nonce}`, import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+async function loadReflectModule(t, llmResponse) {
+    t.mock.module("../copilot/oneshot.js", {
+        namedExports: {
+            runOneShotPrompt: async () => ({ content: llmResponse, model: "mock-model", attempts: 1 }),
+        },
+    });
+    t.mock.module("../copilot/client.js", {
+        namedExports: {
+            getClient: async () => ({}),
+        },
+    });
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
+        },
+    });
+    return await import(new URL(`./reflect.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+async function loadToolsModule(t) {
+    t.mock.module("../copilot/orchestrator.js", {
+        namedExports: {
+            getCurrentSourceChannel: () => "web",
+            getCurrentActivityCallback: () => undefined,
+            getCurrentActiveProjectRules: () => null,
+            getCurrentAuthenticatedUser: () => undefined,
+            getLastAuthenticatedUser: () => undefined,
+            getCurrentAuthorizationHeader: () => undefined,
+            getCurrentSessionKey: () => "session-reflect-test",
+            sendToAgentSession: async () => "",
+            invalidateOrchestratorSession: () => { },
+            maybeScheduleScopeChangeCheckpoint: () => { },
+            resetCheckpointSessionState: () => { },
+            switchSessionModel: async () => { },
+        },
+    });
+    t.mock.module("../memory/reflect.js", {
+        namedExports: {
+            reflectOnScope: async () => ({ patternsCreated: 1, patternsUpdated: 0, contradictionsFound: 0 }),
+            reflectAllScopes: async () => ({
+                chapterhouse: { patternsCreated: 1, patternsUpdated: 0, contradictionsFound: 0 },
+            }),
+        },
+    });
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
+        },
+    });
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const toolsModule = await import(new URL(`../copilot/tools.js?case=${nonce}`, import.meta.url).href);
+    const agentsModule = await import(new URL(`../copilot/agents.js?case=${nonce}`, import.meta.url).href);
+    const dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
+    return { toolsModule, agentsModule, dbModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+function findTool(tools, name) {
+    const tool = tools.find((entry) => entry.name === name);
+    assert.ok(tool, `${name} tool should be registered`);
+    return tool;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.afterEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    if (sandboxRoot) {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+    }
+});
+test("reflectOnScope creates a pattern when three similar observations accumulate for one entity", async (t) => {
+    const { dbModule, memoryModule } = await loadBaseModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const workerQueue = upsertEntity({ scope_id: chapterhouse.id, kind: "subsystem", name: "worker-queue" });
+    const first = recordObservation({
+        scope_id: chapterhouse.id,
+        entity_id: workerQueue.id,
+        content: "The worker queue serializes task execution through SQLite state.",
+        source: "test",
+        tier: "hot",
+    });
+    const second = recordObservation({
+        scope_id: chapterhouse.id,
+        entity_id: workerQueue.id,
+        content: "Worker queue execution is serialized using SQLite-backed state.",
+        source: "test",
+        tier: "warm",
+    });
+    const third = recordObservation({
+        scope_id: chapterhouse.id,
+        entity_id: workerQueue.id,
+        content: "SQLite keeps worker queue execution serialized across turns.",
+        source: "test",
+        tier: "warm",
+    });
+    const reflectModule = await loadReflectModule(t, JSON.stringify({
+        title: "Queue execution pattern",
+        summary: "Worker queue execution stays serialized through SQLite-backed coordination.",
+        confidence: 0.88,
+    }));
+    const result = await reflectModule.reflectOnScope("chapterhouse", db);
+    assert.equal(result.patternsCreated >= 1, true);
+    assert.equal(result.patternsCreated + result.patternsUpdated >= 1, true);
+    assert.equal(result.contradictionsFound, 0);
+    const pattern = db.prepare(`
+    SELECT title, summary, source_observation_ids, confidence, tier
+    FROM mem_patterns
+    ORDER BY id DESC
+    LIMIT 1
+  `).get();
+    assert.ok(pattern, "reflectOnScope should persist a pattern");
+    assert.equal(pattern.title, "Queue execution pattern");
+    assert.match(pattern.summary, /serialized/i);
+    assert.deepEqual(JSON.parse(pattern.source_observation_ids), [first.id, second.id, third.id]);
+    assert.equal(pattern.confidence, 0.88);
+    assert.equal(pattern.tier, "warm");
+});
+test("reflectOnScope counts contradictions inside the same entity group", async (t) => {
+    const { dbModule, memoryModule } = await loadBaseModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const auth = upsertEntity({ scope_id: chapterhouse.id, kind: "subsystem", name: "auth" });
+    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth used GitHub login for sign-in.", source: "test" });
+    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth changed to Entra ID for sign-in.", source: "test" });
+    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth no longer uses GitHub login.", source: "test" });
+    const reflectModule = await loadReflectModule(t, JSON.stringify({
+        title: "Auth provider transition",
+        summary: "Authentication moved away from GitHub login toward Entra ID.",
+        confidence: 0.82,
+    }));
+    const result = await reflectModule.reflectOnScope("chapterhouse", db);
+    assert.equal(result.contradictionsFound, 1);
+});
+test("reflectOnScope folds global observations into project-scope reflection", async (t) => {
+    const { dbModule, memoryModule } = await loadBaseModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const chapterhouse = getScope("chapterhouse");
+    const global = getScope("global");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    assert.ok(global, "global scope should be seeded");
+    const globalObservation = recordObservation({
+        scope_id: global.id,
+        content: "SQLite WAL keeps Chapterhouse memory writes fast.",
+        source: "test",
+        tier: "warm",
+    });
+    const scopedOne = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Chapterhouse memory writes stay fast because SQLite uses WAL mode.",
+        source: "test",
+        tier: "hot",
+    });
+    const scopedTwo = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "WAL mode keeps Chapterhouse memory writes quick under concurrency.",
+        source: "test",
+        tier: "warm",
+    });
+    const reflectModule = await loadReflectModule(t, JSON.stringify({
+        title: "SQLite WAL performance pattern",
+        summary: "Across scopes, Chapterhouse relies on SQLite WAL mode for fast memory writes.",
+        confidence: 0.91,
+    }));
+    const result = await reflectModule.reflectOnScope("chapterhouse", db);
+    assert.equal(result.patternsCreated, 1);
+    const pattern = db.prepare(`
+    SELECT source_observation_ids
+    FROM mem_patterns
+    ORDER BY id DESC
+    LIMIT 1
+  `).get();
+    assert.ok(pattern, "cross-scope reflection should persist a pattern");
+    assert.deepEqual(JSON.parse(pattern.source_observation_ids), [globalObservation.id, scopedOne.id, scopedTwo.id]);
+});
+test("memory_reflect runs end-to-end for chapterhouse and is only bound to orchestrator tools", async (t) => {
+    const { toolsModule, agentsModule, dbModule } = await loadToolsModule(t);
+    const db = dbModule.getDb();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    const filterToolsForAgent = agentsModule.filterToolsForAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    assert.equal(typeof filterToolsForAgent, "function", "filterToolsForAgent should be exported");
+    const chapterhouseVisibleTools = filterToolsForAgent({
+        slug: "chapterhouse",
+        name: "Chapterhouse",
+        description: "Orchestrator",
+        model: "auto",
+        systemMessage: "test",
+    }, tools);
+    const coderVisibleTools = filterToolsForAgent({
+        slug: "coder",
+        name: "Coder",
+        description: "Software engineer",
+        model: "gpt-5.4",
+        systemMessage: "test",
+    }, tools);
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", chapterhouseVisibleTools);
+    const coderTools = bindToolsToAgent("coder", coderVisibleTools);
+    assert.equal(chapterhouseTools.some((tool) => tool.name === "memory_reflect"), true);
+    assert.equal(coderTools.some((tool) => tool.name === "memory_reflect"), false);
+    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    db.prepare(`
+    INSERT INTO mem_observations (scope_id, content, source, tier)
+    VALUES (?, ?, 'test', 'hot'), (?, ?, 'test', 'warm'), (?, ?, 'test', 'warm')
+  `).run(scope.id, "The worker queue serializes task execution through SQLite state.", scope.id, "Worker queue execution is serialized using SQLite-backed state.", scope.id, "SQLite keeps worker queue execution serialized across turns.");
+    const memoryReflect = findTool(chapterhouseTools, "memory_reflect");
+    const result = await memoryReflect.handler({ scope: "chapterhouse" }, {});
+    assert.deepEqual(result, {
+        ok: true,
+        scope: "chapterhouse",
+        patterns_created: 1,
+        patterns_updated: 0,
+        contradictions_found: 0,
+    });
+});
+//# sourceMappingURL=reflect.test.js.map

package/dist/paths.js

@@ -12,36 +12,56 @@ function resolveChapterhouseHome() {
         ? configuredHome
         : join(configuredHome, ".chapterhouse");
 }
-export const CHAPTERHOUSE_HOME = resolveChapterhouseHome();
+// Reset in tests via src/test/helpers/reset-singletons.ts
+export let CHAPTERHOUSE_HOME = resolveChapterhouseHome();
 export function getChapterhouseHome() {
     return resolveChapterhouseHome();
 }
 /** Path to the SQLite database */
-export const DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
+export let DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
 export function getDbPath() {
     return join(resolveChapterhouseHome(), "chapterhouse.db");
 }
 /** Path to the user .env file */
-export const ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
+export let ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
 /** Path to user-local skills */
-export const SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
+export let SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
 /** Path to Chapterhouse's isolated session state (keeps CLI history clean) */
-export const SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
+export let SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
 /** Path to the API bearer token file */
-export const API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+export let API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+/** Path to Chapterhouse runtime logs */
+export const LOGS_DIR = join(CHAPTERHOUSE_HOME, "logs");
 /** Agent definition files (~/.chapterhouse/agents/) */
-export const AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
+export let AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
 /** Root of the LLM-maintained wiki knowledge base */
-export const WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
+export let WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
 /** Wiki pages (entity, concept, summary files) */
-export const WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
+export let WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
 /** Raw ingested source documents (immutable) */
-export const WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+export let WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+function refreshCachedPaths() {
+    CHAPTERHOUSE_HOME = resolveChapterhouseHome();
+    DB_PATH = join(CHAPTERHOUSE_HOME, "chapterhouse.db");
+    ENV_PATH = join(CHAPTERHOUSE_HOME, ".env");
+    SKILLS_DIR = join(CHAPTERHOUSE_HOME, "skills");
+    SESSIONS_DIR = join(CHAPTERHOUSE_HOME, "sessions");
+    API_TOKEN_PATH = join(CHAPTERHOUSE_HOME, "api-token");
+    AGENTS_DIR = join(CHAPTERHOUSE_HOME, "agents");
+    WIKI_DIR = join(CHAPTERHOUSE_HOME, "wiki");
+    WIKI_PAGES_DIR = join(WIKI_DIR, "pages");
+    WIKI_SOURCES_DIR = join(WIKI_DIR, "sources");
+}
+export function resetPathsForTests() {
+    refreshCachedPaths();
+}
 export function resolveWikiRelativePath(relativePath) {
     return join(WIKI_DIR, ...normalizeWikiPath(relativePath).split("/"));
 }
 /** Ensure ~/.chapterhouse/ exists */
 export function ensureChapterhouseHome() {
-    mkdirSync(resolveChapterhouseHome(), { recursive: true });
+    const home = resolveChapterhouseHome();
+    mkdirSync(home, { recursive: true });
+    mkdirSync(join(home, "logs"), { recursive: true });
 }
 //# sourceMappingURL=paths.js.map

package/dist/store/db.js

@@ -1,6 +1,9 @@
 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;
@@ -49,6 +52,63 @@ function tableCreateSql(database, table) {
   `).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'"));
@@ -63,6 +123,7 @@ function rebuildMemoryTierTables(database) {
         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,
@@ -76,8 +137,8 @@ function rebuildMemoryTierTables(database) {
         )
       `);
             database.exec(`
-        INSERT INTO mem_entities (id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
-        SELECT id, scope_id, kind, name, summary, ${entityTierCase()}, confidence, created_at, updated_at
+        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`);
@@ -117,6 +178,7 @@ function rebuildMemoryTierTables(database) {
           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,
@@ -128,9 +190,9 @@ function rebuildMemoryTierTables(database) {
       `);
             database.exec(`
         INSERT INTO mem_decisions (
-          id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+          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, ${memoryTierCase()}, 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`);
@@ -198,6 +260,7 @@ function ensureMemoryTierColumns(database) {
 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)`);
@@ -752,9 +815,24 @@ export function getDb() {
     `);
         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,
@@ -767,6 +845,10 @@ export function getDb() {
         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 (
@@ -776,6 +858,7 @@ export function getDb() {
       )
     `);
         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,
@@ -809,6 +892,7 @@ export function getDb() {
         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,
@@ -839,6 +923,55 @@ export function getDb() {
         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`);
@@ -846,6 +979,9 @@ export function getDb() {
         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);
@@ -998,6 +1134,41 @@ export function getDb() {
           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;
@@ -1019,6 +1190,11 @@ export function getDb() {
             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 {
@@ -1312,4 +1488,11 @@ export function closeDb() {
         daemonRunRecorded = false;
     }
 }
+export function resetDbForTests() {
+    closeDb();
+    logInsertCount = 0;
+    fts5Available = false;
+    currentDaemonRunId = undefined;
+    daemonRunRecorded = false;
+}
 //# sourceMappingURL=db.js.map