chapterhouse 0.6.0 → 0.8.0

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/store/db.js

@@ -63,6 +63,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 +77,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 +118,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 +130,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 +200,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 +755,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 +785,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 +798,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 +832,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 +863,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 +919,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);
@@ -997,6 +1073,40 @@ export function getDb() {
           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
       `);
             // Backfill: check if FTS is in sync by comparing row counts
             const memCount = db.prepare(`SELECT COUNT(*) as c FROM memories`).get().c;
@@ -1019,6 +1129,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 {

package/dist/store/db.test.js

@@ -58,7 +58,7 @@ test("getDb initializes schema, state helpers, and conversation formatting", asy
         dbModule.closeDb();
     }
 });
-test("getDb initializes action-item memory schema and FTS shadow", async () => {
+test("getDb initializes action-item memory schema, reflect patterns schema, and FTS shadow", async () => {
     const dbModule = await loadDbModule();
     try {
         const db = dbModule.getDb();
@@ -66,6 +66,7 @@ test("getDb initializes action-item memory schema and FTS shadow", async () => {
         const tableNames = new Set(tables.map((row) => row.name));
         assert.equal(tableNames.has("mem_action_items"), true, "expected mem_action_items table");
         assert.equal(tableNames.has("mem_action_items_fts"), true, "expected mem_action_items_fts virtual table");
+        assert.equal(tableNames.has("mem_patterns"), true, "expected mem_patterns table");
         const columns = db.prepare(`PRAGMA table_info(mem_action_items)`).all();
         const columnNames = new Set(columns.map((column) => column.name));
         for (const name of [
@@ -89,6 +90,23 @@ test("getDb initializes action-item memory schema and FTS shadow", async () => {
         ]) {
             assert.equal(columnNames.has(name), true, `expected mem_action_items.${name}`);
         }
+        const patternColumns = db.prepare(`PRAGMA table_info(mem_patterns)`).all();
+        const patternColumnNames = new Set(patternColumns.map((column) => column.name));
+        for (const name of [
+            "id",
+            "scope_id",
+            "title",
+            "summary",
+            "source_observation_ids",
+            "confidence",
+            "tier",
+            "created_at",
+            "last_updated",
+        ]) {
+            assert.equal(patternColumnNames.has(name), true, `expected mem_patterns.${name}`);
+        }
+        const patternIndexes = db.prepare(`PRAGMA index_list(mem_patterns)`).all();
+        assert.equal(patternIndexes.some((index) => index.name === "mem_patterns_scope_tier_idx"), true, "expected mem_patterns scope/tier index");
         const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
         const inserted = db.prepare(`
       INSERT INTO mem_action_items (scope_id, title, detail, source)

package/dist/test/setup-env.js

@@ -12,6 +12,7 @@ const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_MEMORY_INJECT",
     "CHAPTERHOUSE_MEMORY_AUTO_ACCEPT",
     "CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED",
+    "CHAPTERHOUSE_MEMORY_HOOKS_ENABLED",
     "CHAPTERHOUSE_MEMORY_HOUSEKEEPING_ENABLED",
     "CHAPTERHOUSE_MEMORY_HOUSEKEEPING_TURNS",
     "CHAPTERHOUSE_MEMORY_DECAY_DAYS",
@@ -20,7 +21,8 @@ const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST",
     "CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS",
 ];
-for (const name of RUNTIME_OVERRIDE_ENV_VARS) {
+const AUTH_ENV_VARS = ["COPILOT_TOKEN", "GITHUB_TOKEN"];
+for (const name of [...RUNTIME_OVERRIDE_ENV_VARS, ...AUTH_ENV_VARS]) {
     delete process.env[name];
 }
 process.env.CHAPTERHOUSE_DISABLE_DOTENV = "1";

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

@@ -8,8 +8,10 @@ const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_SSE_BUFFER_CAPACITY",
     "CHAPTERHOUSE_SSE_REPLAY_LIMIT",
 ];
+const AUTH_ENV_VARS = ["COPILOT_TOKEN", "GITHUB_TOKEN"];
 test("setup-env clears ambient Chapterhouse runtime overrides", async () => {
-    const originalValues = new Map(["CHAPTERHOUSE_DISABLE_DOTENV", ...RUNTIME_OVERRIDE_ENV_VARS].map((name) => [name, process.env[name]]));
+    const originalValues = new Map(["CHAPTERHOUSE_DISABLE_DOTENV", ...RUNTIME_OVERRIDE_ENV_VARS, ...AUTH_ENV_VARS]
+        .map((name) => [name, process.env[name]]));
     try {
         process.env.CHAPTERHOUSE_DISABLE_DOTENV = "0";
         process.env.CHAPTERHOUSE_MODE = "team";
@@ -18,11 +20,16 @@ test("setup-env clears ambient Chapterhouse runtime overrides", async () => {
         process.env.CHAPTERHOUSE_CHAT_SSE = "0";
         process.env.CHAPTERHOUSE_SSE_BUFFER_CAPACITY = "3";
         process.env.CHAPTERHOUSE_SSE_REPLAY_LIMIT = "9";
+        process.env.COPILOT_TOKEN = "ambient-copilot-token";
+        process.env.GITHUB_TOKEN = "ambient-github-token";
         await import(`./setup-env.js?cache-bust=${Date.now()}`);
         assert.equal(process.env.CHAPTERHOUSE_DISABLE_DOTENV, "1");
         for (const name of RUNTIME_OVERRIDE_ENV_VARS) {
             assert.equal(process.env[name], undefined, `${name} should be cleared by setup-env`);
         }
+        for (const name of AUTH_ENV_VARS) {
+            assert.equal(process.env[name], undefined, `${name} should be cleared by setup-env`);
+        }
     }
     finally {
         for (const [name, value] of originalValues) {