chapterhouse 0.9.2 → 0.10.0

package/dist/wiki/consolidation.test.js

@@ -83,6 +83,24 @@ test("runConsolidation merges fragment pages into a canonical page and repoints
     assert.equal(fragmentRow, undefined);
     assert.ok(repointed.c >= 1, "links should be repointed to the canonical page");
 });
+test("runConsolidation rewrites only wiki links when merging fragments", async () => {
+    const { dbModule, wikiFs, indexManager, consolidation } = await loadModules();
+    const db = dbModule.getDb();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/topics/rust/index.md", makePage("Rust", "Main Rust page", "2026-05-10", "Canonical summary.", `### 2026-05-10T10:00:00.000Z\n\nCanonical fact.`));
+    wikiFs.writePage("pages/topics/ruts/index.md", makePage("Ruts", "Fragment Rust page", "2026-05-11", "Fragment summary.", `### 2026-05-11T10:00:00.000Z\n\nFragment fact.`));
+    wikiFs.writePage("pages/topics/terrain/index.md", makePage("Terrain", "Terrain topic", "2026-05-10", "Ruts should remain plain prose while [[Ruts]] and [[Ruts|rut-like paths]] are repointed.", `### 2026-05-10T08:00:00.000Z\n\nRuts are hazardous, but [[Ruts|the fragment link]] should move.`));
+    indexManager.rebuildWikiIndex();
+    await consolidation.runConsolidationWithDeps(db, {
+        now: () => new Date("2026-05-14T22:30:03.086Z"),
+        synthesizeTruth: async () => "unused",
+        commitWikiChanges: async () => false,
+    });
+    const terrain = wikiFs.readPage("pages/topics/terrain/index.md") ?? "";
+    assert.match(terrain, /Ruts are hazardous, but \[\[Rust\|the fragment link\]\] should move\./);
+    assert.match(terrain, /Ruts are hazardous/);
+    assert.doesNotMatch(terrain, /\[\[Ruts(?:\||\]\])/);
+});
 test("runConsolidation removes orphaned wiki_links rows", async () => {
     const { dbModule, wikiFs, indexManager, consolidation } = await loadModules();
     const db = dbModule.getDb();
@@ -140,4 +158,31 @@ test("runConsolidation caps truth rewrites before exceeding the LLM budget", asy
     assert.equal(result.llmCallsUsed, 18);
     assert.equal(llmCalls, 18);
 });
+test("runConsolidation honors configurable rewrite budgets and resumes remaining candidates", async () => {
+    const { dbModule, wikiFs, indexManager, consolidation } = await loadModules();
+    const db = dbModule.getDb();
+    wikiFs.ensureWikiStructure();
+    const slugs = ["alpha-planet", "bravo-river", "charlie-forest", "delta-mountain", "echo-harbor"];
+    for (let i = 0; i < slugs.length; i++) {
+        wikiFs.writePage(`pages/topics/${slugs[i]}/index.md`, makePage(`Resumable ${i}`, `Resumable ${i}`, "2026-05-01", `Old resumable ${i}.`, `### 2026-05-13T10:00:00.000Z\n\nFresh fact ${i}.`));
+    }
+    indexManager.rebuildWikiIndex();
+    const seen = [];
+    const deps = {
+        now: () => new Date("2026-05-14T22:30:03.086Z"),
+        synthesizeTruth: async ({ pagePath }) => {
+            seen.push(pagePath);
+            return `Synthesized ${pagePath}`;
+        },
+        commitWikiChanges: async () => false,
+        truthRewriteBudget: 2,
+    };
+    const first = await consolidation.runConsolidationWithDeps(db, deps);
+    const second = await consolidation.runConsolidationWithDeps(db, deps);
+    const third = await consolidation.runConsolidationWithDeps(db, deps);
+    assert.equal(first.truthRewrites, 2);
+    assert.equal(second.truthRewrites, 2);
+    assert.equal(third.truthRewrites, 1);
+    assert.equal(new Set(seen).size, 5);
+});
 //# sourceMappingURL=consolidation.test.js.map

package/dist/wiki/frontmatter.js

@@ -1,4 +1,5 @@
 import { normalizeWikiPath } from "./path-utils.js";
+import { DEFAULT_SCHEMA, load } from "js-yaml";
 const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?/;
 const SUMMARY_MARKDOWN_RE = /(\*\*|__|[_*`~]|^\s*#+\s|\[[^\]]+\]\([^)]+\)|!\[[^\]]*\]\([^)]+\)|^\s*>)/m;
 const FRONTMATTER_TEMPLATE = `---\ntitle: <title>\nsummary: <plain-text one-line summary, max 200 chars>\nupdated: YYYY-MM-DD\ntags: []\nrelated: []\n---`;
@@ -45,13 +46,18 @@ export function parseWikiFrontmatter(content) {
         };
     }
     const parsed = { metadata: {} };
-    for (const line of match[1].split("\n")) {
-        const idx = line.indexOf(":");
-        if (idx <= 0)
-            continue;
-        const key = line.slice(0, idx).trim();
-        const rawValue = line.slice(idx + 1).trim();
-        const value = parseValue(rawValue);
+    let yaml;
+    try {
+        yaml = load(match[1], { schema: DEFAULT_SCHEMA });
+    }
+    catch {
+        yaml = parseLegacyFrontmatterBlock(match[1]);
+    }
+    const record = yaml && typeof yaml === "object" && !Array.isArray(yaml)
+        ? yaml
+        : {};
+    for (const [key, rawValue] of Object.entries(record)) {
+        const value = normalizeFrontmatterValue(rawValue);
         switch (key) {
             case "title":
             case "summary":
@@ -260,22 +266,46 @@ function deriveTitleFromPath(path) {
 function formatFrontmatterMessage(reason) {
     return `Wiki page frontmatter violates the required shape: ${reason}. Use:\n${FRONTMATTER_TEMPLATE}`;
 }
-function parseValue(rawValue) {
+function normalizeFrontmatterValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => item instanceof Date ? item.toISOString().slice(0, 10) : String(item));
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return "";
+    }
+    return String(value);
+}
+function parseLegacyFrontmatterBlock(block) {
+    const parsed = {};
+    for (const line of block.split("\n")) {
+        const idx = line.indexOf(":");
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const rawValue = line.slice(idx + 1).trim();
+        parsed[key] = parseLegacyFrontmatterValue(rawValue);
+    }
+    return parsed;
+}
+function parseLegacyFrontmatterValue(rawValue) {
     if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
         return rawValue
             .slice(1, -1)
             .split(",")
-            .map((item) => stripQuotes(item.trim()))
+            .map((item) => item.trim().replace(/^['"]|['"]$/g, ""))
             .filter(Boolean);
     }
     if (rawValue === "true")
         return true;
     if (rawValue === "false")
         return false;
-    return stripQuotes(rawValue);
-}
-function stripQuotes(value) {
-    return value.replace(/^['"]|['"]$/g, "");
+    return rawValue.replace(/^['"]|['"]$/g, "");
 }
 function materializeProjectRulesHardFields(parsed) {
     return {

package/dist/wiki/frontmatter.test.js

@@ -41,6 +41,30 @@ Runtime notes.
         body: "# Chapterhouse\n\nRuntime notes.\n",
     });
 });
+test("parseWikiFrontmatter uses YAML semantics while preserving typed string fields", async () => {
+    const { parseWikiFrontmatter } = await loadFrontmatterModule();
+    const result = parseWikiFrontmatter(`---
+title: "Quoted: Title"
+summary: >
+  Plain folded summary
+updated: 2026-05-12
+tags:
+  - engineering
+  - orchestration
+related:
+  - pages/projects/chapterhouse/index.md
+autostub: false
+---
+
+# Chapterhouse
+`);
+    assert.equal(result.parsed.title, "Quoted: Title");
+    assert.equal(result.parsed.summary, "Plain folded summary\n");
+    assert.equal(result.parsed.updated, "2026-05-12");
+    assert.deepEqual(result.parsed.tags, ["engineering", "orchestration"]);
+    assert.deepEqual(result.parsed.related, ["pages/projects/chapterhouse/index.md"]);
+    assert.equal(result.parsed.autostub, false);
+});
 test("parseWikiFrontmatter tolerates legacy pages without frontmatter", async () => {
     const { parseWikiFrontmatter } = await loadFrontmatterModule();
     const result = parseWikiFrontmatter("# Legacy Page\n\nStill readable.\n");

package/dist/wiki/fs.js

@@ -1,7 +1,7 @@
 // ---------------------------------------------------------------------------
 // Wiki file system primitives
 // ---------------------------------------------------------------------------
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, statSync, renameSync, openSync, fsyncSync, closeSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, statSync, lstatSync, renameSync, openSync, fsyncSync, closeSync } from "fs";
 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";
@@ -21,6 +21,11 @@ function getLogPath() {
  * gives readers an all-or-nothing view.
  */
 export function writeFileAtomic(fullPath, content) {
+    // Reject symlink at the target path to prevent TOCTOU attacks.
+    const existing = lstatSync(fullPath, { throwIfNoEntry: false });
+    if (existing?.isSymbolicLink()) {
+        throw new Error(`Refusing to write: target path is a symlink: ${fullPath}`);
+    }
     mkdirSync(dirname(fullPath), { recursive: true });
     const tmp = `${fullPath}.${process.pid}.${Date.now()}.tmp`;
     const fd = openSync(tmp, "w");
@@ -61,7 +66,7 @@ export function assertPagePath(relativePath) {
 function getInitialIndex() {
     return `# Wiki Index
 
-_Max's knowledge base. This file is maintained automatically._
+_Chapterhouse wiki. This file is maintained automatically._
 
 Last updated: ${new Date().toISOString().slice(0, 10)}
 
@@ -124,8 +129,12 @@ export function writePage(relativePath, content) {
 /** Delete a wiki page. Returns true if the file existed and was removed. */
 export function deletePage(relativePath) {
     const fullPath = resolvePath(relativePath);
-    if (!existsSync(fullPath))
+    const stat = lstatSync(fullPath, { throwIfNoEntry: false });
+    if (!stat)
         return false;
+    if (stat.isSymbolicLink()) {
+        throw new Error(`Refusing to delete: target path is a symlink: ${fullPath}`);
+    }
     unlinkSync(fullPath);
     return true;
 }
@@ -153,7 +162,10 @@ export function writeRawSource(name, content) {
 /** Read a raw source document. */
 export function readRawSource(name) {
     const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "-");
-    const fullPath = join(WIKI_SOURCES_DIR, safeName);
+    const fullPath = resolve(WIKI_SOURCES_DIR, safeName);
+    if (!fullPath.startsWith(WIKI_SOURCES_DIR + sep)) {
+        throw new Error(`Source path escapes sources dir: ${name}`);
+    }
     if (!existsSync(fullPath))
         return undefined;
     return readFileSync(fullPath, "utf-8");

package/dist/wiki/fs.test.js

@@ -55,4 +55,88 @@ test("wiki fs rejects unsafe page paths", async () => {
     assert.throws(() => wiki.assertPagePath("sources/raw.md"), /only pages under pages\//);
     assert.throws(() => wiki.assertPagePath("pages/shared/runbooks/deploy.txt"), /must end in \.md/);
 });
+// ---------------------------------------------------------------------------
+// TOCTOU / symlink hardening tests
+// ---------------------------------------------------------------------------
+test("writeFileAtomic rejects a symlink at the target path (TOCTOU guard)", async () => {
+    const { symlinkSync, mkdirSync: mkdir2, writeFileSync: write2 } = await import("node:fs");
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    // Set up a real file outside the wiki and a symlink pointing to it inside the wiki.
+    const targetDir = join(sandboxRoot, "symlink-target");
+    mkdir2(targetDir, { recursive: true });
+    write2(join(targetDir, "outside.md"), "outside content", "utf-8");
+    const pageDir = join(wikiDir, "pages", "shared", "runbooks");
+    mkdir2(pageDir, { recursive: true });
+    symlinkSync(join(targetDir, "outside.md"), join(pageDir, "evil.md"));
+    // writeFileAtomic (via writePage) must reject the symlink.
+    assert.throws(() => wiki.writePage("pages/shared/runbooks/evil.md", "# Evil\n"), /Refusing to write: target path is a symlink/);
+    // The real file must be untouched.
+    assert.equal(readFileSync(join(targetDir, "outside.md"), "utf-8"), "outside content");
+});
+test("writeFileAtomic succeeds for a normal (non-symlink) path", async () => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    wiki.writePage("pages/shared/runbooks/normal.md", "# Normal\n");
+    assert.equal(wiki.readPage("pages/shared/runbooks/normal.md"), "# Normal\n");
+});
+test("writeFileAtomic allows an intermediate symlinked directory (only final target matters)", async () => {
+    const { symlinkSync, mkdirSync: mkdir3 } = await import("node:fs");
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    // A directory under the wiki that is itself a symlink to another dir inside the wiki.
+    const realSubdir = join(wikiDir, "pages", "real-runbooks");
+    mkdir3(realSubdir, { recursive: true });
+    const linkedSubdir = join(wikiDir, "pages", "linked-runbooks");
+    symlinkSync(realSubdir, linkedSubdir);
+    // Writing through the symlinked directory should succeed (intermediate is OK).
+    assert.doesNotThrow(() => wiki.writePage("pages/linked-runbooks/guide.md", "# Guide\n"));
+});
+test("deletePage rejects a symlink at the target path (TOCTOU guard)", async () => {
+    const { symlinkSync, mkdirSync: mkdir4, writeFileSync: write4 } = await import("node:fs");
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    const targetDir = join(sandboxRoot, "delete-target");
+    mkdir4(targetDir, { recursive: true });
+    write4(join(targetDir, "outside.md"), "keep me", "utf-8");
+    const pageDir = join(wikiDir, "pages", "shared", "runbooks");
+    mkdir4(pageDir, { recursive: true });
+    symlinkSync(join(targetDir, "outside.md"), join(pageDir, "poison.md"));
+    assert.throws(() => wiki.deletePage("pages/shared/runbooks/poison.md"), /Refusing to delete: target path is a symlink/);
+    // Target file must still exist.
+    assert.equal(readFileSync(join(targetDir, "outside.md"), "utf-8"), "keep me");
+});
+test("readRawSource rejects '..' path traversal — escapes sources dir", async () => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    // ".." survives the character whitelist (both "." chars are whitelisted) but
+    // resolve(WIKI_SOURCES_DIR, "..") resolves to the parent directory — containment
+    // check must catch this and throw.
+    assert.throws(() => wiki.readRawSource(".."), /Source path escapes sources dir/);
+});
+test("readRawSource returns undefined for a valid name that does not exist", async () => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    assert.equal(wiki.readRawSource("nonexistent.md"), undefined);
+});
+test("readRawSource reads back a file written by writeRawSource", async () => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const wiki = await loadFsModule();
+    wiki.ensureWikiStructure();
+    wiki.writeRawSource("test-doc.md", "# Hello Source\n");
+    assert.equal(wiki.readRawSource("test-doc.md"), "# Hello Source\n");
+});
 //# sourceMappingURL=fs.test.js.map

package/dist/wiki/index-manager.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 import { getDb, isFts5Available } from "../store/db.js";
 import { childLogger } from "../util/logger.js";
+import { assertWikiWriteHeld } from "./lock.js";
 import { listPages, readPage } from "./fs.js";
 import { parseWikiFrontmatter } from "./frontmatter.js";
 import { normalizeWikiPath } from "./path-utils.js";
@@ -143,6 +144,25 @@ function runWikiReindex() {
 export function rebuildWikiIndex() {
     runWikiReindex();
 }
+export function refreshWikiPages(paths) {
+    const seen = new Set(paths.map(normalizeWikiPath));
+    for (const path of seen) {
+        try {
+            const content = readPage(path);
+            if (!content) {
+                removeWikiPage(path);
+                continue;
+            }
+            const { parsed: fm, body } = parseWikiFrontmatter(content);
+            const summary = buildPageSummary(fm.summary, body);
+            upsertWikiPage(path, fm, summary);
+            updateLinks(path);
+        }
+        catch (err) {
+            log.warn({ path, err: getErrorMessage(err) }, "Skipping wiki page during incremental reindex");
+        }
+    }
+}
 /**
  * Search wiki pages using FTS5 BM25 ranking.
  * Falls back to LIKE query if FTS5 unavailable.
@@ -321,8 +341,12 @@ export function parseIndex() {
         };
     });
 }
-/** Add or update a page in the index. Delegates to upsertWikiPage. */
+/**
+ * Add or update a page in the index. Callers must already hold withWikiWrite()
+ * so the page write and wiki_pages update stay serialized together.
+ */
 export function addToIndex(entry) {
+    assertWikiWriteHeld();
     const fm = {
         title: entry.title,
         summary: entry.summary,
@@ -332,8 +356,12 @@ export function addToIndex(entry) {
     };
     upsertWikiPage(entry.path, fm, entry.summary);
 }
-/** Remove an entry from the index by path. Returns true if found. */
+/**
+ * Remove an entry from the index by path. Callers must already hold
+ * withWikiWrite() so file deletion and index cleanup stay serialized together.
+ */
 export function removeFromIndex(path) {
+    assertWikiWriteHeld();
     const db = getDb();
     const normalizedPath = normalizeWikiPath(path);
     const existing = db.prepare(`SELECT 1 FROM wiki_pages WHERE path = ?`).get(normalizedPath);

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

@@ -3,6 +3,7 @@ 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";
+import { withWikiWrite } from "./lock.js";
 // Sandbox: every test gets a fresh CHAPTERHOUSE_HOME
 function makeSandbox() {
     const dir = mkdtempSync(join(process.cwd(), ".test-work", "wiki-idx-"));
@@ -10,17 +11,19 @@ function makeSandbox() {
     resetSingletons();
     return dir;
 }
-async function loadModules(sandbox) {
+async function loadModules(_sandbox) {
     const nonce = `${Date.now()}-${Math.random()}`;
     const indexManager = await import(new URL(`./index-manager.js?c=${nonce}`, import.meta.url).href);
     const wikiFs = await import(new URL(`./fs.js?c=${nonce}`, import.meta.url).href);
     return { indexManager, wikiFs };
 }
-function resetWikiState(indexManager, wikiFs) {
+async function resetWikiState(indexManager, wikiFs) {
     rmSync(wikiFs.getWikiDir(), { recursive: true, force: true });
-    for (const entry of indexManager.parseIndex()) {
-        indexManager.removeFromIndex(entry.path);
-    }
+    await withWikiWrite(() => {
+        for (const entry of indexManager.parseIndex()) {
+            indexManager.removeFromIndex(entry.path);
+        }
+    });
 }
 async function loadModulesWithMocks(t, sandbox, options = {}) {
     const warnings = [];
@@ -106,9 +109,11 @@ test("ensureWikiIndexPopulated rebuilds from disk when wiki_pages starts empty",
     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);
-        }
+        await withWikiWrite(() => {
+            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);
@@ -155,14 +160,40 @@ test("FTS search returns results under 50ms", async () => {
         rmSync(sandbox, { recursive: true, force: true });
     }
 });
-test("removeFromIndex removes from wiki_pages", async () => {
+test("addToIndex requires the wiki write lock", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager } = await loadModules(sandbox);
+        assert.throws(() => indexManager.addToIndex({
+            path: "pages/people/test/index.md",
+            title: "Test Person",
+            summary: "A test",
+            section: "People",
+        }), /withWikiWrite/);
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("removeFromIndex requires the wiki write lock", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager } = await loadModules(sandbox);
+        indexManager.upsertWikiPage("pages/people/test/index.md", { title: "Test Person", summary: "A test", tags: [], updated: "2026-05-01", metadata: {} }, "A test");
+        assert.throws(() => indexManager.removeFromIndex("pages/people/test/index.md"), /withWikiWrite/);
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("removeFromIndex removes from wiki_pages within the wiki write lock", async () => {
     const sandbox = makeSandbox();
     try {
         const { indexManager } = await loadModules(sandbox);
         indexManager.upsertWikiPage("pages/people/test/index.md", { title: "Test Person", summary: "A test", tags: [], updated: "2026-05-01", metadata: {} }, "A test");
         const before = indexManager.wikiSearch("Test Person");
         assert.ok(before.length > 0, "Should exist before removal");
-        const removed = indexManager.removeFromIndex("pages/people/test/index.md");
+        const removed = await withWikiWrite(() => indexManager.removeFromIndex("pages/people/test/index.md"));
         assert.equal(removed, true);
         const after = indexManager.wikiSearch("Test Person");
         assert.equal(after.length, 0, "Should not exist after removal");
@@ -208,7 +239,7 @@ test("reindexWikiPages skips unreadable pages and continues indexing others", as
     const sandbox = makeSandbox();
     try {
         const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox);
-        resetWikiState(indexManager, wikiFs);
+        await 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");
@@ -237,7 +268,7 @@ test("reindexWikiPages skips malformed pages and continues indexing others", asy
     const sandbox = makeSandbox();
     try {
         const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox, { malformedMarker: "UNPARSEABLE" });
-        resetWikiState(indexManager, wikiFs);
+        await 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");

package/dist/wiki/ingest.js

@@ -137,7 +137,7 @@ async function parseRepo(repoUrl) {
 async function extractEntities(text, topic) {
     // Skip entity extraction if no auth token is configured
     const { config } = await import("../config.js");
-    const token = config.copilotAuthToken || process.env.COPILOT_TOKEN || process.env.GITHUB_TOKEN;
+    const token = config.copilotAuthToken;
     if (!token) {
         log.debug("No Copilot auth token configured, skipping entity extraction");
         return { entities: [], relationships: [] };

package/dist/wiki/lock.js

@@ -6,19 +6,29 @@
 // and the async episode-writer overlap, every mutation must run through
 // withWikiWrite(). Reads do NOT need to acquire the lock — they are protected
 // by atomic file replacement at the FS level.
+//
+// Low-level index mutations assert this lock is owned by the current async call
+// chain so page writes and wiki_pages updates cannot silently interleave.
 // ---------------------------------------------------------------------------
+import { AsyncLocalStorage } from "node:async_hooks";
 let chain = Promise.resolve();
+const wikiWriteContext = new AsyncLocalStorage();
 /**
  * Run an async wiki mutation under the global write lock.
  * Calls are serialized FIFO. Errors propagate to the caller but do not
  * break the chain for subsequent writers.
  */
 export function withWikiWrite(fn) {
-    const next = chain.then(() => fn(), () => fn());
+    const next = chain.then(() => wikiWriteContext.run(true, fn), () => wikiWriteContext.run(true, fn));
     // Keep the chain alive even if `next` rejects so the next caller can run.
     chain = next.catch(() => undefined);
     return next;
 }
+export function assertWikiWriteHeld() {
+    if (wikiWriteContext.getStore() !== true) {
+        throw new Error("Wiki index mutations must run within withWikiWrite().");
+    }
+}
 /** For tests/diagnostics: wait for the current write queue to drain. */
 export function drainWikiWrites() {
     return chain.then(() => undefined, () => undefined);

package/dist/wiki/log-manager.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 import { appendFileSync, existsSync, readFileSync, renameSync } from "fs";
 import { join } from "path";
+import { config } from "../config.js";
 import { WIKI_PAGES_DIR } from "../paths.js";
 import { ensureWikiStructure, writeFileAtomic } from "./fs.js";
 export const ACTION_LOG_PATH = "pages/_meta/log.md";
@@ -55,12 +56,6 @@ function extractEntries(content) {
         .filter((chunk) => chunk.startsWith("## ["));
 }
 function resolveAgentName() {
-    const candidates = [
-        process.env.CHAPTERHOUSE_SESSION_AGENT_NAME,
-        process.env.CHAPTERHOUSE_AGENT_NAME,
-        process.env.COPILOT_AGENT_NAME,
-        process.env.AGENT_NAME,
-    ];
-    return candidates.find((candidate) => candidate && candidate.trim().length > 0)?.trim() ?? "unknown";
+    return config.agentNameCandidates[0] ?? "unknown";
 }
 //# sourceMappingURL=log-manager.js.map

package/dist/wiki/migrate.js

@@ -33,6 +33,7 @@ const CATEGORY_MAP = {
 export function migrateMemoriesToWiki() {
     ensureWikiStructure();
     const db = getDb();
+    ensureWikiMigrationVersionTable(db);
     const rows = db.prepare(`SELECT id, category, content, source, created_at FROM memories ORDER BY category, id`).all();
     if (rows.length === 0) {
         setState(MIGRATION_KEY, "true");
@@ -73,30 +74,26 @@ export function migrateMemoriesToWiki() {
         lines.push("");
         // Check if a page already exists (avoid clobbering manual content)
         const existing = readPage(mapping.path);
-        // Idempotency marker: if the migration block was already appended, skip the
-        // append so re-runs don't duplicate bullets.
-        const MIGRATE_MARKER = `<!-- migrate:${category}:v1 -->`;
+        backfillMemoryMigrationVersionFromLegacyMarker(db, category, mapping.path, existing);
+        if (hasWikiMigrationVersion(db, category, 1)) {
+            const entry = {
+                path: mapping.path,
+                title: mapping.title,
+                summary: `${items.length} ${category} memories (already migrated)`,
+                section: mapping.section,
+            };
+            addToIndex(entry);
+            continue;
+        }
         if (existing) {
-            if (existing.includes(MIGRATE_MARKER)) {
-                // Already migrated; just refresh the index entry.
-                const entry = {
-                    path: mapping.path,
-                    title: mapping.title,
-                    summary: `${items.length} ${category} memories (already migrated)`,
-                    section: mapping.section,
-                };
-                addToIndex(entry);
-                continue;
-            }
             // Extract only the bullet-point items to append
             const bulletLines = lines.filter((l) => l.startsWith("- "));
-            writePage(mapping.path, existing + `\n${MIGRATE_MARKER}\n## Migrated Memories\n\n` + bulletLines.join("\n") + "\n");
+            writePage(mapping.path, existing + `\n## Migrated Memories\n\n` + bulletLines.join("\n") + "\n");
         }
         else {
-            // Embed the marker in fresh pages too so future re-runs are no-ops.
-            lines.splice(lines.length - 1, 0, MIGRATE_MARKER);
             writePage(mapping.path, lines.join("\n"));
         }
+        setWikiMigrationVersion(db, category, 1);
         // Update index
         const entry = {
             path: mapping.path,
@@ -113,6 +110,36 @@ export function migrateMemoriesToWiki() {
     log.info({ total, pageCount: Object.keys(grouped).length }, "Wiki migration complete");
     return total;
 }
+function ensureWikiMigrationVersionTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS wiki_migration_versions (
+      name TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (name, version)
+    )
+  `);
+}
+function hasWikiMigrationVersion(db, category, version) {
+    const row = db.prepare(`SELECT 1 FROM wiki_migration_versions WHERE name = ? AND version = ?`).get(`memory:${category}`, version);
+    return Boolean(row);
+}
+function setWikiMigrationVersion(db, category, version) {
+    db.prepare(`
+    INSERT OR IGNORE INTO wiki_migration_versions (name, version)
+    VALUES (?, ?)
+  `).run(`memory:${category}`, version);
+}
+function backfillMemoryMigrationVersionFromLegacyMarker(db, category, path, existing) {
+    if (existing?.includes(`<!-- migrate:${category}:v1 -->`)) {
+        setWikiMigrationVersion(db, category, 1);
+        return;
+    }
+    const markerPage = readPage(path);
+    if (markerPage?.includes(`<!-- migrate:${category}:v1 -->`)) {
+        setWikiMigrationVersion(db, category, 1);
+    }
+}
 // ---------------------------------------------------------------------------
 // One-time reorganization: flat dump pages → entity pages
 // ---------------------------------------------------------------------------