chapterhouse 0.8.0 → 0.8.2

package/dist/memory/eot.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `memory-eot-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
@@ -18,24 +19,40 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
     return { dbModule, memoryModule, eotModule, agentsModule };
 }
+async function loadModulesWithWarnSpy(t, cacheBust) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (...args) => {
+                    warnings.push(args);
+                },
+                error: () => { },
+            }),
+        },
+    });
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
+    const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, warnings };
+}
 function getFunction(module, name) {
     const value = module[name];
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
     return value;
 }
-test.beforeEach(async () => {
+test.beforeEach(() => {
     process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
     resetSandbox();
+    resetSingletons();
 });
-test.after(async () => {
+test.after(() => {
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED=0", async () => {
@@ -239,6 +256,98 @@ test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear
     assert.match(inbox.resolution_reason ?? "", /title/i);
     assert.ok(inbox.resolved_at);
 });
+async function runAcceptedObservationHookScenario(t, cacheBust, taskId, payload) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (obj, msg) => warnings.push({ obj, msg }),
+                error: () => { },
+            }),
+        },
+    });
+    const { dbModule, memoryModule, eotModule } = await loadModules(cacheBust);
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const before = listObservations({ scope_id: chapterhouse.id });
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', ?, 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "observation",
+        payload,
+        confidence: 0.9,
+    }), taskId);
+    await runEndOfTaskMemoryHook({
+        taskId,
+        finalResult: "Completed and reviewed an observation proposal.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Durable finding.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    return {
+        beforeCount: before.length,
+        after: listObservations({ scope_id: chapterhouse.id }),
+        warnings,
+        inbox,
+    };
+}
+test("runEndOfTaskMemoryHook skips accepted observation proposals with null content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-null-content", "task-eot-observation-null-content", { content: null });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with undefined content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-undefined-content", "task-eot-observation-undefined-content", {});
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with empty string content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-empty-string-content", "task-eot-observation-empty-string-content", { content: "" });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with whitespace-only content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-whitespace-content", "task-eot-observation-whitespace-content", { content: "   " });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook inserts accepted observation proposals with valid content", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-valid-content", "task-eot-observation-valid-content", { content: " Durable finding from the task. " });
+    assert.equal(result.after.length, result.beforeCount + 1);
+    assert.ok(result.after.some((row) => row.content === "Durable finding from the task."));
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.equal(result.warnings.length, 0);
+});
 test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
     const db = dbModule.getDb();
@@ -549,4 +658,109 @@ test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind",
         && entity.kind === "host"
         && entity.summary === "NAS host used by Bellonda."), true);
 });
+test("runEndOfTaskMemoryHook skips implicit observation memories with null content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-null-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-null",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: null,
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with undefined content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-undefined-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-undefined",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {},
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with empty content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-empty-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-empty",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "   ",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook persists implicit observation memories with valid content", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-valid-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-valid",
+        finalResult: "The reviewer discovered a valid durable memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "A valid implicit memory should still be stored.",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "A valid implicit memory should still be stored."), true);
+    assert.equal(summary.implicit_extracted, 1);
+    assert.equal(warnings.length, 0);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/migration.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 let sandboxRoot;
 let chapterhouseHome;
 let dbModule;
@@ -20,12 +21,15 @@ test.before(async () => {
     sandboxRoot = mkdtempSync(join(process.cwd(), ".test-work", "memory-migration-"));
     process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+    resetSingletons();
     const nonce = `${Date.now()}-${Math.random()}`;
     dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
     migrationModule = await import(new URL(`./migration.js?case=${nonce}`, import.meta.url).href);
 });
 test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     dbModule.closeDb();
+    resetSingletons();
     resetSandbox();
 });
 test.after(() => {
@@ -33,6 +37,10 @@ test.after(() => {
         dbModule.closeDb();
     }
     catch { }
+    try {
+        resetSingletons();
+    }
+    catch { }
     try {
         rmSync(sandboxRoot, { recursive: true, force: true });
     }
@@ -84,9 +92,9 @@ test("runP6Migration is idempotent across repeated runs", async () => {
     assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_observations WHERE source = 'migration:p6'`).get().count, 1);
     assert.equal(db.prepare(`SELECT COUNT(*) AS count FROM mem_migrations WHERE name = 'p6-wiki-seed'`).get().count, 1);
 });
-test("runP6Migration skips gracefully when the wiki pages directory is empty or absent", async () => {
+test("runP6Migration skips gracefully when the wiki skeleton exists but contains no migratable pages", async () => {
     const db = dbModule.getDb();
-    assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages")), false);
+    assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages")), true);
     const result = await migrationModule.runP6Migration(db);
     assert.deepEqual(result, {
         entitiesCreated: 0,

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'"));
@@ -1108,6 +1168,7 @@ export function getDb() {
           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;
@@ -1427,4 +1488,11 @@ export function closeDb() {
         daemonRunRecorded = false;
     }
 }
+export function resetDbForTests() {
+    closeDb();
+    logInsertCount = 0;
+    fts5Available = false;
+    currentDaemonRunId = undefined;
+    daemonRunRecorded = false;
+}
 //# sourceMappingURL=db.js.map

package/dist/store/db.test.js

@@ -1,8 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `store-db-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
@@ -17,11 +18,56 @@ function resetSandbox() {
     mkdirSync(chapterhouseHome, { recursive: true });
 }
 test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     resetSandbox();
+    resetSingletons();
 });
 test.after(() => {
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
+test("getDb startup reindex populates wiki_pages when pages exist on disk", async () => {
+    mkdirSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust"), { recursive: true });
+    writeFileSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust", "index.md"), "---\ntitle: Rust\nsummary: Systems language\nupdated: 2026-05-15\n---\n\n# Rust\n\nFearless concurrency.\n", "utf-8");
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const count = db.prepare(`SELECT COUNT(*) AS count FROM wiki_pages`).get().count;
+        assert.equal(count, 1);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb startup reindex is idempotent across repeated startups", async () => {
+    mkdirSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust"), { recursive: true });
+    writeFileSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust", "index.md"), "---\ntitle: Rust\nsummary: Systems language\nupdated: 2026-05-15\n---\n\n# Rust\n\nFearless concurrency.\n", "utf-8");
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        dbModule.closeDb();
+        dbModule.getDb();
+        const reopened = new Database(dbPath, { readonly: true });
+        const count = reopened.prepare(`SELECT COUNT(*) AS count FROM wiki_pages WHERE path = 'pages/topics/rust/index.md'`).get().count;
+        reopened.close();
+        assert.equal(count, 1);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb startup reindex creates the wiki log directory when it is missing", async () => {
+    mkdirSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust"), { recursive: true });
+    writeFileSync(join(chapterhouseHome, "wiki", "pages", "topics", "rust", "index.md"), "---\ntitle: Rust\nsummary: Systems language\nupdated: 2026-05-15\n---\n\n# Rust\n\nFearless concurrency.\n", "utf-8");
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        assert.equal(existsSync(join(chapterhouseHome, "wiki", "pages", "_meta", "log.md")), true);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb initializes schema, state helpers, and conversation formatting", async () => {
     const dbModule = await loadDbModule();
     try {

package/dist/test/helpers/reset-singletons.js

@@ -0,0 +1,8 @@
+import { resetPathsForTests } from "../../paths.js";
+import { resetDbForTests } from "../../store/db.js";
+export function resetSingletons() {
+    resetDbForTests();
+    resetPathsForTests();
+}
+export const resetModuleCache = resetSingletons;
+//# sourceMappingURL=reset-singletons.js.map

package/dist/test/helpers/reset-singletons.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `reset-singletons-${process.pid}`);
+function sandboxPath(name) {
+    return join(sandboxRoot, name);
+}
+test.before(() => {
+    mkdirSync(sandboxRoot, { recursive: true });
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("resetSingletons refreshes cached db and path singletons after CHAPTERHOUSE_HOME changes", async () => {
+    const helper = await import("./reset-singletons.js");
+    const paths = await import("../../paths.js");
+    const dbModule = await import("../../store/db.js");
+    const firstHome = sandboxPath("first-home");
+    const secondHome = sandboxPath("second-home");
+    mkdirSync(firstHome, { recursive: true });
+    process.env.CHAPTERHOUSE_HOME = firstHome;
+    await helper.resetSingletons();
+    dbModule.getDb().prepare("SELECT 1").get();
+    assert.equal(paths.CHAPTERHOUSE_HOME, join(firstHome, ".chapterhouse"));
+    assert.equal(paths.DB_PATH, join(firstHome, ".chapterhouse", "chapterhouse.db"));
+    assert.equal(existsSync(join(firstHome, ".chapterhouse", "chapterhouse.db")), true);
+    mkdirSync(secondHome, { recursive: true });
+    process.env.CHAPTERHOUSE_HOME = secondHome;
+    await helper.resetSingletons();
+    dbModule.getDb().prepare("SELECT 1").get();
+    assert.equal(paths.CHAPTERHOUSE_HOME, join(secondHome, ".chapterhouse"));
+    assert.equal(paths.DB_PATH, join(secondHome, ".chapterhouse", "chapterhouse.db"));
+    assert.equal(existsSync(join(secondHome, ".chapterhouse", "chapterhouse.db")), true);
+});
+//# sourceMappingURL=reset-singletons.test.js.map

package/dist/test/setup-env.js

@@ -1,3 +1,5 @@
+import test from "node:test";
+import { resetSingletons } from "./helpers/reset-singletons.js";
 const RUNTIME_OVERRIDE_ENV_VARS = [
     "CHAPTERHOUSE_MODE",
     "CHAPTERHOUSE_SELF_EDIT",
@@ -26,5 +28,10 @@ for (const name of [...RUNTIME_OVERRIDE_ENV_VARS, ...AUTH_ENV_VARS]) {
     delete process.env[name];
 }
 process.env.CHAPTERHOUSE_DISABLE_DOTENV = "1";
-export {};
+test.beforeEach(() => {
+    resetSingletons();
+});
+test.afterEach(() => {
+    resetSingletons();
+});
 //# sourceMappingURL=setup-env.js.map

package/dist/wiki/consolidation.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `wiki-consolidation-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
@@ -27,10 +28,12 @@ test.beforeEach(async () => {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     dbModule.closeDb();
     resetSandbox();
+    resetSingletons();
 });
 test.after(async () => {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     dbModule.closeDb();
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("runConsolidation rewrites stale compiled truth and skips pinned pages", async () => {