chapterhouse 0.8.0 → 0.8.1

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 () => {

package/dist/wiki/fs.js

@@ -6,9 +6,15 @@ import { join, dirname, relative, resolve, sep } from "path";
 import { WIKI_DIR, WIKI_PAGES_DIR, WIKI_SOURCES_DIR } from "../paths.js";
 import { normalizeWikiPath } from "./path-utils.js";
 import { topicPathError } from "./topic-structure.js";
-const INDEX_PATH = join(WIKI_DIR, "index.md");
-const PAGES_INDEX_PATH = join(WIKI_PAGES_DIR, "index.md");
-const LOG_PATH = join(WIKI_PAGES_DIR, "_meta", "log.md");
+function getIndexPath() {
+    return join(WIKI_DIR, "index.md");
+}
+function getPagesIndexPath() {
+    return join(WIKI_PAGES_DIR, "index.md");
+}
+function getLogPath() {
+    return join(WIKI_PAGES_DIR, "_meta", "log.md");
+}
 /**
  * Write a file atomically: write to a temp file in the same directory, fsync,
  * then rename over the destination. Prevents partial writes on crash and
@@ -89,14 +95,17 @@ export function ensureWikiStructure() {
     const isNew = !existsSync(WIKI_DIR);
     mkdirSync(WIKI_PAGES_DIR, { recursive: true });
     mkdirSync(WIKI_SOURCES_DIR, { recursive: true });
-    if (!existsSync(INDEX_PATH)) {
-        writeFileAtomic(INDEX_PATH, getInitialIndex());
+    const indexPath = getIndexPath();
+    const pagesIndexPath = getPagesIndexPath();
+    const logPath = getLogPath();
+    if (!existsSync(indexPath)) {
+        writeFileAtomic(indexPath, getInitialIndex());
     }
-    if (!existsSync(PAGES_INDEX_PATH)) {
-        writeFileAtomic(PAGES_INDEX_PATH, getInitialPagesIndex());
+    if (!existsSync(pagesIndexPath)) {
+        writeFileAtomic(pagesIndexPath, getInitialPagesIndex());
     }
-    if (!existsSync(LOG_PATH)) {
-        writeFileAtomic(LOG_PATH, INITIAL_LOG);
+    if (!existsSync(logPath)) {
+        writeFileAtomic(logPath, INITIAL_LOG);
     }
     return isNew;
 }
@@ -161,20 +170,20 @@ export function listSources() {
 /** Read index.md raw content. */
 export function readIndexFile() {
     ensureWikiStructure();
-    return readFileSync(INDEX_PATH, "utf-8");
+    return readFileSync(getIndexPath(), "utf-8");
 }
 /** Write index.md content atomically. */
 export function writeIndexFile(content) {
-    writeFileAtomic(INDEX_PATH, content);
+    writeFileAtomic(getIndexPath(), content);
 }
 /** Read log.md raw content. */
 export function readLogFile() {
     ensureWikiStructure();
-    return readFileSync(LOG_PATH, "utf-8");
+    return readFileSync(getLogPath(), "utf-8");
 }
 /** Write log.md content atomically. */
 export function writeLogFile(content) {
-    writeFileAtomic(LOG_PATH, content);
+    writeFileAtomic(getLogPath(), content);
 }
 /** Get the full wiki directory path (for external tools that need it). */
 export function getWikiDir() {

package/dist/wiki/index-manager.js

@@ -2,15 +2,44 @@
 // Wiki index manager — SQLite FTS5-backed wiki page catalog
 // ---------------------------------------------------------------------------
 import { getDb, isFts5Available } from "../store/db.js";
+import { childLogger } from "../util/logger.js";
 import { listPages, readPage } from "./fs.js";
 import { parseWikiFrontmatter } from "./frontmatter.js";
 import { normalizeWikiPath } from "./path-utils.js";
 import { updateLinks } from "./links.js";
 const ACTION_LOG_PAGE_RE = /^pages\/_meta\/log(?:-\d{4})?\.md$/;
 const LEGACY_INDEX_PAGE = "pages/index.md";
+const log = childLogger("wiki-index");
 function isIgnoredIndexPage(path) {
     return path === LEGACY_INDEX_PAGE || ACTION_LOG_PAGE_RE.test(path);
 }
+function getIndexablePages() {
+    return listPages().filter((p) => !isIgnoredIndexPage(p));
+}
+function getWikiPageCount() {
+    const db = getDb();
+    return db.prepare(`SELECT COUNT(*) as c FROM wiki_pages`).get().c;
+}
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function buildPageSummary(summary, body) {
+    let nextSummary = summary?.trim() ?? "";
+    if (!nextSummary) {
+        for (const raw of body.split("\n")) {
+            const line = raw.trim();
+            if (!line || line.startsWith("#") || line.startsWith("<!--"))
+                continue;
+            nextSummary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
+            if (!nextSummary)
+                continue;
+            break;
+        }
+    }
+    if (nextSummary.length > 160)
+        nextSummary = nextSummary.slice(0, 157) + "…";
+    return nextSummary;
+}
 function categoryOfPath(path) {
     const rest = path.startsWith("pages/") ? path.slice("pages/".length) : path;
     const segs = rest.split("/").filter(Boolean);
@@ -72,12 +101,11 @@ export function removeWikiPage(path) {
  * Rebuild the wiki_pages SQLite index from the filesystem.
  * Filesystem is the source of truth: insert missing pages, remove stale entries.
  */
-export function rebuildWikiIndex() {
-    const pages = listPages().filter((p) => !isIgnoredIndexPage(p));
+function runWikiReindex() {
+    const pages = getIndexablePages();
     const db = getDb();
     const onDisk = new Set(pages.map(normalizeWikiPath));
     db.transaction(() => {
-        // Remove DB entries not on disk; also clean their wiki_links
         const inDb = db.prepare(`SELECT path FROM wiki_pages`).all();
         for (const { path } of inDb) {
             if (!onDisk.has(path)) {
@@ -85,33 +113,35 @@ export function rebuildWikiIndex() {
                 db.prepare(`DELETE FROM wiki_links WHERE from_page = ? OR to_page = ?`).run(path, path);
             }
         }
-        // Upsert all on-disk pages
-        for (const p of pages) {
+    })();
+    let indexedPageCount = 0;
+    let skippedPageCount = 0;
+    for (const p of pages) {
+        try {
             const content = readPage(p);
             if (!content)
                 continue;
             const { parsed: fm, body } = parseWikiFrontmatter(content);
-            let summary = fm.summary?.trim() ?? "";
-            if (!summary) {
-                for (const raw of body.split("\n")) {
-                    const line = raw.trim();
-                    if (!line || line.startsWith("#") || line.startsWith("<!--"))
-                        continue;
-                    summary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
-                    if (!summary)
-                        continue;
-                    break;
-                }
-            }
-            if (summary.length > 160)
-                summary = summary.slice(0, 157) + "…";
+            const summary = buildPageSummary(fm.summary, body);
             upsertWikiPage(p, fm, summary);
+            updateLinks(p);
+            indexedPageCount++;
+        }
+        catch (err) {
+            skippedPageCount++;
+            log.warn({ path: p, err: getErrorMessage(err) }, "Skipping wiki page during reindex");
+            continue;
         }
-    })();
-    // Backfill wiki_links for all on-disk pages (outside transaction — each call is self-contained)
-    for (const p of pages) {
-        updateLinks(p);
     }
+    log.info({ indexedPageCount, skippedPageCount }, `Reindexed ${indexedPageCount} pages, skipped ${skippedPageCount} pages (errors)`);
+    return {
+        diskPageCount: pages.length,
+        indexedPageCount,
+        skippedPageCount,
+    };
+}
+export function rebuildWikiIndex() {
+    runWikiReindex();
 }
 /**
  * Search wiki pages using FTS5 BM25 ranking.
@@ -120,6 +150,35 @@ export function rebuildWikiIndex() {
  * Each direct result includes 1-hop neighbors from wiki_links in `related`.
  * Neighbor pages not already in direct results are appended (deduplicated).
  */
+export function ensureWikiIndexPopulated() {
+    const pages = getIndexablePages();
+    const indexedPageCount = getWikiPageCount();
+    if (indexedPageCount === 0 && pages.length > 0) {
+        log.warn({ diskPageCount: pages.length }, "wiki_pages empty while wiki files exist; rebuilding from disk");
+        const result = runWikiReindex();
+        return {
+            reindexed: true,
+            diskPageCount: result.diskPageCount,
+            indexedPageCount: result.indexedPageCount,
+            skippedPageCount: result.skippedPageCount,
+        };
+    }
+    return {
+        reindexed: false,
+        diskPageCount: pages.length,
+        indexedPageCount,
+        skippedPageCount: 0,
+    };
+}
+export function reindexWikiPages() {
+    const result = runWikiReindex();
+    return {
+        reindexed: true,
+        diskPageCount: result.diskPageCount,
+        indexedPageCount: result.indexedPageCount,
+        skippedPageCount: result.skippedPageCount,
+    };
+}
 export function wikiSearch(query, limit = 20) {
     const db = getDb();
     const trimmed = query.trim();

package/dist/wiki/index-manager.test.js

@@ -1,11 +1,13 @@
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 import { join } from "node:path";
 import test from "node:test";
 // Sandbox: every test gets a fresh CHAPTERHOUSE_HOME
 function makeSandbox() {
     const dir = mkdtempSync(join(process.cwd(), ".test-work", "wiki-idx-"));
     process.env.CHAPTERHOUSE_HOME = dir;
+    resetSingletons();
     return dir;
 }
 async function loadModules(sandbox) {
@@ -14,6 +16,39 @@ async function loadModules(sandbox) {
     const wikiFs = await import(new URL(`./fs.js?c=${nonce}`, import.meta.url).href);
     return { indexManager, wikiFs };
 }
+function resetWikiState(indexManager, wikiFs) {
+    rmSync(wikiFs.getWikiDir(), { recursive: true, force: true });
+    for (const entry of indexManager.parseIndex()) {
+        indexManager.removeFromIndex(entry.path);
+    }
+}
+async function loadModulesWithMocks(t, sandbox, options = {}) {
+    const warnings = [];
+    const infos = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: (obj, msg) => infos.push({ obj, msg }),
+                warn: (obj, msg) => warnings.push({ obj, msg }),
+                error: () => { },
+            }),
+        },
+    });
+    if (options.malformedMarker) {
+        const actualFrontmatter = await import(new URL(`./frontmatter.js?actual=${Date.now()}-${Math.random()}`, import.meta.url).href);
+        t.mock.module("./frontmatter.js", {
+            namedExports: {
+                parseWikiFrontmatter: (content) => {
+                    if (content.includes(options.malformedMarker)) {
+                        throw new Error("Malformed wiki page");
+                    }
+                    return actualFrontmatter.parseWikiFrontmatter(content);
+                },
+            },
+        });
+    }
+    return { ...(await loadModules(sandbox)), warnings, infos };
+}
 test.before(() => {
     mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
 });
@@ -66,6 +101,25 @@ test("rebuildWikiIndex populates wiki_pages from filesystem", async () => {
         rmSync(sandbox, { recursive: true, force: true });
     }
 });
+test("ensureWikiIndexPopulated rebuilds from disk when wiki_pages starts empty", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust\nsummary: Systems programming\nupdated: 2026-05-10\n---\n\n# Rust\n");
+        for (const entry of indexManager.parseIndex()) {
+            indexManager.removeFromIndex(entry.path);
+        }
+        assert.equal(indexManager.parseIndex().length, 0, "Precondition: wiki_pages should start empty");
+        const result = indexManager.ensureWikiIndexPopulated();
+        assert.equal(result.reindexed, true);
+        assert.ok(result.diskPageCount >= 1);
+        assert.ok(result.indexedPageCount >= 1);
+        assert.ok(indexManager.parseIndex().some((entry) => entry.path === "pages/topics/rust/index.md"));
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
 test("upsertWikiPage inserts and updates correctly", async () => {
     const sandbox = makeSandbox();
     try {
@@ -150,4 +204,78 @@ test("rebuildWikiIndex removes stale entries not on disk", async () => {
         rmSync(sandbox, { recursive: true, force: true });
     }
 });
+test("reindexWikiPages skips unreadable pages and continues indexing others", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox);
+        resetWikiState(indexManager, wikiFs);
+        const unreadablePath = join(wikiFs.getWikiDir(), "pages", "topics", "blocked", "index.md");
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/blocked/index.md", "---\ntitle: Blocked\nsummary: Unreadable topic\nupdated: 2026-05-02\n---\n\n# Blocked\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        chmodSync(unreadablePath, 0o000);
+        try {
+            const result = indexManager.reindexWikiPages();
+            const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
+            assert.deepEqual(paths, [
+                "pages/topics/alpha/index.md",
+                "pages/topics/gamma/index.md",
+            ]);
+            assert.equal(result.diskPageCount, 3);
+            assert.equal(result.indexedPageCount, 2);
+            assert.ok(warnings.some((entry) => entry.obj.path === "pages/topics/blocked/index.md"), "Expected a warning for the unreadable page");
+        }
+        finally {
+            chmodSync(unreadablePath, 0o644);
+        }
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("reindexWikiPages skips malformed pages and continues indexing others", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox, { malformedMarker: "UNPARSEABLE" });
+        resetWikiState(indexManager, wikiFs);
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/bad/index.md", "---\ntitle: Bad\nsummary: Broken topic\nupdated: 2026-05-02\n---\n\nUNPARSEABLE\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        const result = indexManager.reindexWikiPages();
+        const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
+        assert.deepEqual(paths, [
+            "pages/topics/alpha/index.md",
+            "pages/topics/gamma/index.md",
+        ]);
+        assert.equal(result.diskPageCount, 3);
+        assert.equal(result.indexedPageCount, 2);
+        assert.ok(warnings.some((entry) => entry.obj.path === "pages/topics/bad/index.md"), "Expected a warning for the malformed page");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("reindexWikiPages logs a summary with indexed and skipped counts", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, infos } = await loadModulesWithMocks(t, sandbox);
+        resetWikiState(indexManager, wikiFs);
+        const unreadablePath = join(wikiFs.getWikiDir(), "pages", "topics", "blocked", "index.md");
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/blocked/index.md", "---\ntitle: Blocked\nsummary: Unreadable topic\nupdated: 2026-05-02\n---\n\n# Blocked\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        chmodSync(unreadablePath, 0o000);
+        try {
+            const result = indexManager.reindexWikiPages();
+            assert.equal(result.indexedPageCount, 2);
+            assert.ok(infos.some((entry) => /Reindexed 2 pages, skipped 1/.test(entry.msg)), "Expected a summary log with indexed and skipped counts");
+        }
+        finally {
+            chmodSync(unreadablePath, 0o644);
+        }
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=index-manager.test.js.map

package/dist/wiki/log-manager.js

@@ -6,7 +6,9 @@ import { join } from "path";
 import { WIKI_PAGES_DIR } from "../paths.js";
 import { ensureWikiStructure, writeFileAtomic } from "./fs.js";
 export const ACTION_LOG_PATH = "pages/_meta/log.md";
-const LOG_PATH = join(WIKI_PAGES_DIR, "_meta", "log.md");
+function getLogPath() {
+    return join(WIKI_PAGES_DIR, "_meta", "log.md");
+}
 const MAX_LOG_ENTRIES = 500;
 const LOG_ENTRY_RE = /^## \[/gm;
 const INITIAL_LOG = `# Wiki Action Log
@@ -24,17 +26,18 @@ export function appendLog(type, subject, agent = resolveAgentName()) {
     const now = new Date();
     const ts = now.toISOString().slice(0, 16).replace("T", " ");
     const entry = `## [${ts}] ${type} | ${subject} | ${agent}\n\n`;
-    appendFileSync(LOG_PATH, entry, "utf-8");
+    appendFileSync(getLogPath(), entry, "utf-8");
 }
 function rotateLogIfNeeded() {
-    const currentLog = readFileSync(LOG_PATH, "utf-8");
+    const logPath = getLogPath();
+    const currentLog = readFileSync(logPath, "utf-8");
     const entryCount = (currentLog.match(LOG_ENTRY_RE) ?? []).length;
     if (entryCount < MAX_LOG_ENTRIES) {
         return;
     }
     const archivePath = join(WIKI_PAGES_DIR, "_meta", `log-${new Date().getFullYear()}.md`);
     if (!existsSync(archivePath)) {
-        renameSync(LOG_PATH, archivePath);
+        renameSync(logPath, archivePath);
     }
     else {
         const archivedEntries = extractEntries(currentLog);
@@ -43,7 +46,7 @@ function rotateLogIfNeeded() {
             appendFileSync(archivePath, `${separator}${archivedEntries.join("\n\n")}\n\n`, "utf-8");
         }
     }
-    writeFileAtomic(LOG_PATH, INITIAL_LOG);
+    writeFileAtomic(logPath, INITIAL_LOG);
 }
 function extractEntries(content) {
     return content