chapterhouse 0.6.0 → 0.8.0

package/dist/wiki/ingest.test.js

@@ -0,0 +1,111 @@
+// ---------------------------------------------------------------------------
+// Ingestion pipeline tests — ingestSource
+// Sandbox: single CHAPTERHOUSE_HOME per file to avoid module-singleton confusion
+// ---------------------------------------------------------------------------
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+// Single sandbox shared across all tests in this file
+let SANDBOX;
+let mods;
+test.before(async () => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
+    SANDBOX = mkdtempSync(join(process.cwd(), ".test-work", "ingest-"));
+    process.env.CHAPTERHOUSE_HOME = SANDBOX;
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const ingestMod = await import(new URL(`./ingest.js?c=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?c=${nonce}`, import.meta.url).href);
+    const dbMod = await import(new URL(`../store/db.js?c=${nonce}`, import.meta.url).href);
+    mods = { ingestMod, wikiFs, dbMod };
+    mods.wikiFs.ensureWikiStructure();
+});
+test.after(() => {
+    try {
+        rmSync(SANDBOX, { recursive: true, force: true });
+    }
+    catch { /* best-effort */ }
+});
+test("ingestSource(text) creates wiki_sources record", async () => {
+    const text = `Source-A: Alice is a senior engineer at Acme Corp. timestamp=${Date.now()}`;
+    const result = await mods.ingestMod.ingestSource(text, "text", "people");
+    assert.ok(result.source_id, "Should return a source_id");
+    assert.equal(result.already_existed, false, "Should not already exist on first call");
+    const db = mods.dbMod.getDb();
+    const row = db.prepare(`SELECT * FROM wiki_sources WHERE id = ?`).get(result.source_id);
+    assert.ok(row, "Should be persisted in wiki_sources");
+    assert.equal(row.source_type, "text");
+});
+test("ingestSource(text) saves raw source file", async () => {
+    const text = `Source-B: Bob leads the platform engineering team at TechCo. timestamp=${Date.now()}`;
+    const result = await mods.ingestMod.ingestSource(text, "text");
+    const sources = mods.wikiFs.listSources();
+    assert.ok(sources.length > 0, "Should have saved a raw source file");
+    assert.ok(sources.some((s) => s.startsWith(result.source_id.slice(0, 16))), "Source file should be named with source_id prefix");
+});
+test("ingestSource duplicate ingestion returns already_existed=true", async () => {
+    const text = `Source-C: Carol is a product manager at StartupXYZ. timestamp=${Date.now()}`;
+    const first = await mods.ingestMod.ingestSource(text, "text");
+    assert.equal(first.already_existed, false, "First call should not be a duplicate");
+    const second = await mods.ingestMod.ingestSource(text, "text");
+    assert.equal(second.already_existed, true, "Second ingestion should be idempotent");
+    assert.equal(second.source_id, first.source_id, "Should return same source_id");
+    const db = mods.dbMod.getDb();
+    const count = db.prepare(`SELECT COUNT(*) as c FROM wiki_sources WHERE id = ?`).get(first.source_id).c;
+    assert.equal(count, 1, "Should only have one row in wiki_sources");
+});
+test("computeSourceId is deterministic and type-scoped", () => {
+    const id1 = mods.ingestMod.computeSourceId("text", "hello world");
+    const id2 = mods.ingestMod.computeSourceId("text", "hello world");
+    assert.equal(id1, id2, "Same input should give same id");
+    const id3 = mods.ingestMod.computeSourceId("url", "hello world");
+    assert.notEqual(id1, id3, "Different types should give different ids");
+});
+test("detectSourceType identifies URLs, repos, and text", () => {
+    assert.equal(mods.ingestMod.detectSourceType("https://tokio.rs"), "url");
+    assert.equal(mods.ingestMod.detectSourceType("http://example.com"), "url");
+    assert.equal(mods.ingestMod.detectSourceType("https://github.com/user/repo"), "repo");
+    assert.equal(mods.ingestMod.detectSourceType("some plain text content"), "text");
+    assert.equal(mods.ingestMod.detectSourceType(""), "text");
+});
+test("assertSafeRemoteUrl blocks all RFC 1918 private ranges", () => {
+    assert.throws(() => mods.ingestMod.assertSafeRemoteUrl("http://10.1.2.3"), /Cannot fetch internal\/private URLs\./);
+    assert.throws(() => mods.ingestMod.assertSafeRemoteUrl("http://172.16.5.4"), /Cannot fetch internal\/private URLs\./);
+    assert.throws(() => mods.ingestMod.assertSafeRemoteUrl("http://172.31.255.255"), /Cannot fetch internal\/private URLs\./);
+    assert.throws(() => mods.ingestMod.assertSafeRemoteUrl("http://192.168.1.9"), /Cannot fetch internal\/private URLs\./);
+});
+test("createEntityPageContent uses the Summary and Timeline headings", () => {
+    const content = mods.ingestMod.createEntityPageContent({
+        pageTitle: "Alice Example",
+        pageSummary: "Senior engineer at Acme.",
+        entityType: "people",
+        updatedAt: "2026-05-15",
+    });
+    assert.match(content, /## Summary/);
+    assert.match(content, /## Timeline/);
+    assert.doesNotMatch(content, /## Compiled Truth/);
+});
+test("ingestSource stores optional research session metadata in wiki_sources", async () => {
+    const text = `Source-D: Research session metadata should persist. timestamp=${Date.now()}`;
+    const result = await mods.ingestMod.ingestSource(text, "text", "topics", {
+        sessionId: "compiler-research",
+        sessionName: "Compiler research",
+    });
+    const db = mods.dbMod.getDb();
+    const row = db.prepare(`SELECT session_id, session_name FROM wiki_sources WHERE id = ?`).get(result.source_id);
+    assert.deepEqual(row, {
+        session_id: "compiler-research",
+        session_name: "Compiler research",
+    });
+});
+// URL/PDF/repo tests are skipped if connectivity or dependencies are unavailable
+test.skip("ingestSource(url) fetches and parses content — requires network", async () => {
+    // Integration test: run manually with network access
+});
+test.skip("ingestSource(pdf) parses PDF — requires pdf-parse", async () => {
+    // Integration test: run manually with pdf-parse installed
+});
+test.skip("ingestSource(repo) clones and summarises repo — requires network + git", async () => {
+    // Integration test: run manually
+});
+//# sourceMappingURL=ingest.test.js.map

package/dist/wiki/links.js

@@ -0,0 +1,151 @@
+// ---------------------------------------------------------------------------
+// Wiki entity graph — link extraction and graph traversal
+// ---------------------------------------------------------------------------
+import { getDb } from "../store/db.js";
+import { readPage, pageExists } from "./fs.js";
+import { parseWikiFrontmatter } from "./frontmatter.js";
+import { normalizeWikiPath } from "./path-utils.js";
+const RELATIONSHIP_PATTERNS = [
+    { regex: /\bimplements\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "implements" },
+    { regex: /\bsupersedes\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "supersedes" },
+    { regex: /\bmember\s+of\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "member_of" },
+    { regex: /\bworks?\s+at\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "member_of" },
+    { regex: /\bworks\s+on\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "works_on" },
+    { regex: /\bdecided\s+by\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "decided_by" },
+    { regex: /\bdepends\s+on\s+([A-Za-z0-9][^\n.,;:!?]{1,60})/gi, linkType: "depends_on" },
+];
+function nameToSlug(name) {
+    return name
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9-]/g, "");
+}
+function wikiLinkToPath(name) {
+    return `pages/${nameToSlug(name)}/index.md`;
+}
+function tagToTopicPath(tag) {
+    return `pages/topics/${nameToSlug(tag)}/index.md`;
+}
+/** Extract typed links from a page. Returns deduplicated WikiLink array. */
+export function extractLinks(pagePath) {
+    const normalizedPath = normalizeWikiPath(pagePath);
+    const content = readPage(normalizedPath);
+    if (!content)
+        return [];
+    const { parsed: fm, body } = parseWikiFrontmatter(content);
+    const links = [];
+    const seen = new Set();
+    const extractedAt = new Date().toISOString();
+    function addLink(toPage, linkType) {
+        const normalized = normalizeWikiPath(toPage);
+        if (!normalized || normalized === normalizedPath)
+            return;
+        const key = `${normalized}:${linkType}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        links.push({ from_page: normalizedPath, to_page: normalized, link_type: linkType, extracted_at: extractedAt });
+    }
+    // 1. [[Page Name]] wiki links
+    const wikiLinkRe = /\[\[([^\]]+)\]\]/g;
+    let m;
+    while ((m = wikiLinkRe.exec(body)) !== null) {
+        const target = wikiLinkToPath(m[1].trim());
+        addLink(target, "references");
+    }
+    // 2. Frontmatter `related` array
+    for (const rel of fm.related ?? []) {
+        if (typeof rel === "string" && rel.trim()) {
+            addLink(normalizeWikiPath(rel.trim()), "references");
+        }
+    }
+    // 3. Frontmatter `tags` → topic pages (only if target page exists on disk)
+    for (const tag of fm.tags ?? []) {
+        if (typeof tag === "string" && tag.trim()) {
+            const target = tagToTopicPath(tag.trim());
+            if (pageExists(target)) {
+                addLink(target, "references");
+            }
+        }
+    }
+    // 4. Relationship statements in body text
+    for (const { regex, linkType } of RELATIONSHIP_PATTERNS) {
+        regex.lastIndex = 0;
+        while ((m = regex.exec(body)) !== null) {
+            const rawTarget = nameToSlug(m[1].trim());
+            if (rawTarget) {
+                addLink(`pages/${rawTarget}/index.md`, linkType);
+            }
+        }
+    }
+    return links;
+}
+/** Re-extract links for a page and sync to wiki_links table. */
+export function updateLinks(pagePath) {
+    const normalizedPath = normalizeWikiPath(pagePath);
+    const db = getDb();
+    const existing = db.prepare(`SELECT COUNT(*) as c FROM wiki_links WHERE from_page = ?`).get(normalizedPath);
+    const removedCount = existing.c;
+    const newLinks = extractLinks(normalizedPath);
+    db.transaction(() => {
+        db.prepare(`DELETE FROM wiki_links WHERE from_page = ?`).run(normalizedPath);
+        const insert = db.prepare(`
+      INSERT OR IGNORE INTO wiki_links (from_page, to_page, link_type, extracted_at)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const link of newLinks) {
+            insert.run(link.from_page, link.to_page, link.link_type, link.extracted_at);
+        }
+    })();
+    return { added: newLinks.length, removed: removedCount };
+}
+/**
+ * Walk the entity graph from a starting page.
+ * Default depth 1, max depth 3. Returns flat list sorted by depth then page.
+ */
+export function traverse(pagePath, linkType, depth = 1) {
+    const MAX_DEPTH = 3;
+    const effectiveDepth = Math.min(Math.max(depth, 1), MAX_DEPTH);
+    const normalizedPath = normalizeWikiPath(pagePath);
+    const db = getDb();
+    const results = [];
+    const visited = new Set([normalizedPath]);
+    const queue = [{ page: normalizedPath, depth: 0 }];
+    while (queue.length > 0) {
+        const { page: currentPage, depth: currentDepth } = queue.shift();
+        if (currentDepth >= effectiveDepth)
+            continue;
+        const outbound = (linkType
+            ? db.prepare(`SELECT to_page, link_type FROM wiki_links WHERE from_page = ? AND link_type = ?`).all(currentPage, linkType)
+            : db.prepare(`SELECT to_page, link_type FROM wiki_links WHERE from_page = ?`).all(currentPage));
+        for (const row of outbound) {
+            if (!visited.has(row.to_page)) {
+                visited.add(row.to_page);
+                results.push({ page: row.to_page, link_type: row.link_type, direction: "outbound", depth: currentDepth + 1 });
+                if (currentDepth + 1 < effectiveDepth) {
+                    queue.push({ page: row.to_page, depth: currentDepth + 1 });
+                }
+            }
+        }
+        const inbound = (linkType
+            ? db.prepare(`SELECT from_page, link_type FROM wiki_links WHERE to_page = ? AND link_type = ?`).all(currentPage, linkType)
+            : db.prepare(`SELECT from_page, link_type FROM wiki_links WHERE to_page = ?`).all(currentPage));
+        for (const row of inbound) {
+            if (!visited.has(row.from_page)) {
+                visited.add(row.from_page);
+                results.push({ page: row.from_page, link_type: row.link_type, direction: "inbound", depth: currentDepth + 1 });
+                if (currentDepth + 1 < effectiveDepth) {
+                    queue.push({ page: row.from_page, depth: currentDepth + 1 });
+                }
+            }
+        }
+    }
+    results.sort((a, b) => {
+        if (a.depth !== b.depth)
+            return a.depth - b.depth;
+        return a.page.localeCompare(b.page);
+    });
+    return results;
+}
+//# sourceMappingURL=links.js.map

package/dist/wiki/links.test.js

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+// Sandbox: every test gets a fresh CHAPTERHOUSE_HOME under .test-work/
+function makeSandbox() {
+    const dir = mkdtempSync(join(process.cwd(), ".test-work", "wiki-links-"));
+    process.env.CHAPTERHOUSE_HOME = dir;
+    return dir;
+}
+async function loadModules(sandbox) {
+    void sandbox; // CHAPTERHOUSE_HOME already set via env
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const links = await import(new URL(`./links.js?c=${nonce}`, import.meta.url).href);
+    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 { links, indexManager, wikiFs };
+}
+test.before(() => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
+});
+test("extractLinks finds [[Page Name]] wiki links in content", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust\nsummary: Systems language\ntags: [rust]\nupdated: 2026-05-14\n---\n\n# Rust\n\nSee [[Tokio]] for async runtime.\n");
+        const extracted = links.extractLinks("pages/topics/rust/index.md");
+        assert.ok(extracted.length > 0, "Should find links");
+        const tokioLink = extracted.find((l) => l.to_page === "pages/tokio/index.md");
+        assert.ok(tokioLink, "Should find link to tokio page");
+        assert.equal(tokioLink?.link_type, "references");
+        assert.equal(tokioLink?.from_page, "pages/topics/rust/index.md");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("extractLinks reads related from frontmatter", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust\nsummary: Systems language\ntags: [rust]\nrelated: [pages/topics/wasm/index.md, pages/topics/async/index.md]\nupdated: 2026-05-14\n---\n\n# Rust\n\nContent.\n");
+        const extracted = links.extractLinks("pages/topics/rust/index.md");
+        const paths = extracted.map((l) => l.to_page);
+        assert.ok(paths.includes("pages/topics/wasm/index.md"), "Should include wasm from related");
+        assert.ok(paths.includes("pages/topics/async/index.md"), "Should include async from related");
+        assert.ok(extracted.every((l) => l.link_type === "references"), "Frontmatter related links should be type references");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("extractLinks creates tag links only for existing topic pages", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        // Create the rust topic page (the tag target)
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust\nsummary: Systems language\ntags: []\nupdated: 2026-05-14\n---\n\n# Rust\n");
+        // Write a page with a tag pointing to rust (exists) and typescript (does not exist)
+        wikiFs.writePage("pages/projects/myproject/index.md", "---\ntitle: My Project\nsummary: A project\ntags: [rust, typescript]\nupdated: 2026-05-14\n---\n\n# My Project\n");
+        const extracted = links.extractLinks("pages/projects/myproject/index.md");
+        const paths = extracted.map((l) => l.to_page);
+        assert.ok(paths.includes("pages/topics/rust/index.md"), "Should link to existing rust topic");
+        assert.ok(!paths.includes("pages/topics/typescript/index.md"), "Should NOT link to non-existent typescript topic");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("updateLinks inserts links into wiki_links table", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/tokio/index.md", "---\ntitle: Tokio\nsummary: Async runtime for Rust\ntags: [rust, async]\nrelated: [pages/topics/rust/index.md]\nupdated: 2026-05-14\n---\n\n# Tokio\n\nAsync runtime.\n");
+        const result = links.updateLinks("pages/topics/tokio/index.md");
+        assert.ok(result.added > 0, "Should insert links");
+        // Verify via traverse
+        const neighbors = links.traverse("pages/topics/tokio/index.md");
+        const pages = neighbors.map((n) => n.page);
+        assert.ok(pages.includes("pages/topics/rust/index.md"), "Should find rust in neighbors");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("updateLinks removes stale links on re-run", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        // Initial page with two related links
+        wikiFs.writePage("pages/topics/stale-tokio/index.md", "---\ntitle: Tokio\nsummary: Async runtime\ntags: []\nrelated: [pages/topics/rust/index.md, pages/topics/async/index.md]\nupdated: 2026-05-14\n---\n\n# Tokio\n");
+        links.updateLinks("pages/topics/stale-tokio/index.md");
+        let neighbors = links.traverse("pages/topics/stale-tokio/index.md");
+        assert.ok(neighbors.length === 2, "Should have 2 initial links");
+        // Update page to remove one related link
+        wikiFs.writePage("pages/topics/stale-tokio/index.md", "---\ntitle: Tokio\nsummary: Async runtime\ntags: []\nrelated: [pages/topics/rust/index.md]\nupdated: 2026-05-14\n---\n\n# Tokio\n");
+        links.updateLinks("pages/topics/stale-tokio/index.md");
+        neighbors = links.traverse("pages/topics/stale-tokio/index.md");
+        assert.ok(neighbors.length === 1, "Should have 1 link after stale removal");
+        assert.equal(neighbors[0].page, "pages/topics/rust/index.md");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("traverse returns 1-hop neighbors correctly", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/trav-rust/index.md", "---\ntitle: Rust\nsummary: Lang\ntags: []\nrelated: [pages/topics/trav-tokio/index.md, pages/topics/trav-wasm/index.md]\nupdated: 2026-05-14\n---\n\n# Rust\n");
+        links.updateLinks("pages/topics/trav-rust/index.md");
+        const results = links.traverse("pages/topics/trav-rust/index.md", undefined, 1);
+        assert.ok(results.length === 2, `Should have 2 neighbors, got ${results.length}`);
+        assert.ok(results.every((r) => r.depth === 1), "All results should be at depth 1");
+        assert.ok(results.every((r) => r.direction === "outbound"), "Should be outbound from rust");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("traverse handles missing page gracefully (no crash)", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links } = await loadModules(sandbox);
+        // Page doesn't exist — should return empty, not throw
+        const results = links.traverse("pages/topics/nonexistent/index.md", undefined, 1);
+        assert.ok(Array.isArray(results), "Should return an array");
+        assert.equal(results.length, 0, "Should return empty array for missing page");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("wikiSearch results include related neighbors from wiki_links", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/search-rust/index.md", "---\ntitle: Rust\nsummary: Systems programming language\ntags: [rust]\nrelated: [pages/topics/search-tokio/index.md]\nupdated: 2026-05-14\n---\n\n# Rust\n\nSystems language.\n");
+        wikiFs.writePage("pages/topics/search-tokio/index.md", "---\ntitle: Tokio\nsummary: Async runtime for Rust\ntags: [tokio]\nupdated: 2026-05-14\n---\n\n# Tokio\n\nAsync runtime.\n");
+        indexManager.rebuildWikiIndex(); // also calls updateLinks via backfill
+        links.updateLinks("pages/topics/search-rust/index.md"); // ensure link exists
+        const results = indexManager.wikiSearch("rust systems");
+        const rustResult = results.find((r) => r.path === "pages/topics/search-rust/index.md");
+        assert.ok(rustResult, "Should find rust page");
+        assert.ok(rustResult?.related && rustResult.related.length > 0, "Rust result should have related neighbors");
+        const relatedPages = rustResult.related.map((r) => r.page);
+        assert.ok(relatedPages.includes("pages/topics/search-tokio/index.md"), "Should include tokio as related");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("rebuildWikiIndex cleans up wiki_links for deleted pages", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { links, indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/del-rust/index.md", "---\ntitle: Rust\nsummary: Lang\ntags: []\nrelated: [pages/topics/del-tokio/index.md]\nupdated: 2026-05-14\n---\n\n# Rust\n");
+        wikiFs.writePage("pages/topics/del-tokio/index.md", "---\ntitle: Tokio\nsummary: Async runtime\ntags: []\nupdated: 2026-05-14\n---\n\n# Tokio\n");
+        indexManager.rebuildWikiIndex();
+        links.updateLinks("pages/topics/del-rust/index.md");
+        // Verify link exists
+        const before = links.traverse("pages/topics/del-rust/index.md");
+        assert.ok(before.some((r) => r.page === "pages/topics/del-tokio/index.md"), "Should have tokio link before deletion");
+        // Delete rust page from disk, then rebuild
+        wikiFs.deletePage("pages/topics/del-rust/index.md");
+        indexManager.rebuildWikiIndex();
+        // Links from rust should be cleaned up
+        const after = links.traverse("pages/topics/del-tokio/index.md");
+        const hasRustInbound = after.some((r) => r.page === "pages/topics/del-rust/index.md");
+        assert.ok(!hasRustInbound, "Inbound link from deleted rust page should be gone after rebuild");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+//# sourceMappingURL=links.test.js.map

package/dist/wiki/migrate-topics.test.js

@@ -9,17 +9,22 @@ async function loadModules() {
     const nonce = `${Date.now()}-${Math.random()}`;
     const migrate = await import(new URL(`./migrate-topics.js?case=${nonce}`, import.meta.url).href);
     const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
-    return { migrate, wikiFs };
+    const indexManager = await import(new URL(`./index-manager.js?case=${nonce}`, import.meta.url).href);
+    return { migrate, wikiFs, indexManager };
 }
-test.beforeEach(() => {
+test.beforeEach(async () => {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const dbModule = await import("../store/db.js");
+    dbModule.closeDb();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
-test.after(() => {
+test.after(async () => {
+    const dbModule = await import("../store/db.js");
+    dbModule.closeDb();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("enforceTopicStructure relocates bare entity pages and folds facet pages", async () => {
-    const { migrate, wikiFs } = await loadModules();
+    const { migrate, wikiFs, indexManager } = await loadModules();
     wikiFs.ensureWikiStructure();
     wikiFs.writePage("pages/projects/chapterhouse.md", "---\ntitle: Chapterhouse\n---\n\n# Chapterhouse\n\n- Source at ~/projects/chapterhouse\n");
     wikiFs.writePage("pages/projects/chapterhouse-feature-ideas.md", "---\ntitle: Chapterhouse Feature Ideas\n---\n\n# Feature Ideas\n\n- Add wiki topics\n");
@@ -37,8 +42,13 @@ test("enforceTopicStructure relocates bare entity pages and folds facet pages",
     assert.match(wikiFs.readPage("pages/projects/chapterhouse/index.md") ?? "", /Source at ~\/projects\/chapterhouse/);
     assert.match(wikiFs.readPage("pages/projects/chapterhouse/feature-ideas.md") ?? "", /Add wiki topics/);
     // Index reflects the new shape.
-    assert.match(wikiFs.readIndexFile(), /^- \[Chapterhouse\]\(pages\/projects\/chapterhouse\/index\.md\) — /m);
-    assert.match(wikiFs.readIndexFile(), /^ {2}- \[.+\]\(pages\/projects\/chapterhouse\/feature-ideas\.md\) — /m);
+    const indexedPaths = indexManager.parseIndex().map((entry) => entry.path).sort();
+    assert.deepEqual(indexedPaths, [
+        "pages/conversations/2026-05-09.md",
+        "pages/projects/chapterhouse/decisions.md",
+        "pages/projects/chapterhouse/feature-ideas.md",
+        "pages/projects/chapterhouse/index.md",
+    ]);
     // Idempotent.
     assert.equal(migrate.enforceTopicStructure(), 0);
 });

package/dist/wiki/scheduler.js

@@ -0,0 +1,118 @@
+import { config } from "../config.js";
+import { getDb } from "../store/db.js";
+import { childLogger } from "../util/logger.js";
+import { runConsolidation } from "./consolidation.js";
+const DEFAULT_PKB_CONSOLIDATION_HOUR = 3;
+const DAY_MS = 24 * 60 * 60 * 1000;
+export class WikiConsolidationScheduler {
+    env;
+    runConsolidationImpl;
+    now;
+    log;
+    setTimeoutImpl;
+    clearTimeoutImpl;
+    timeoutHandle;
+    activeRun;
+    started = false;
+    running = false;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.runConsolidationImpl = options.runConsolidation ?? (() => runConsolidation(getDb()));
+        this.now = options.now ?? (() => new Date());
+        this.log = options.log ?? childLogger("wiki.scheduler");
+        this.setTimeoutImpl = options.setTimeoutImpl ?? setTimeout;
+        this.clearTimeoutImpl = options.clearTimeoutImpl ?? ((handle) => clearTimeout(handle));
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        const enabled = parseEnabledEnv(this.env.CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED);
+        if (!enabled) {
+            this.log.info({ enabled }, "Wiki consolidation scheduler disabled");
+            return;
+        }
+        const hour = parseHourEnv(this.env.CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR);
+        this.started = true;
+        this.scheduleIn(delayUntilNextHour(this.now(), hour), hour, "initial");
+    }
+    async stop() {
+        if (this.timeoutHandle) {
+            this.clearTimeoutImpl(this.timeoutHandle);
+            this.timeoutHandle = undefined;
+        }
+        this.started = false;
+        await this.activeRun;
+    }
+    scheduleIn(delayMs, hour, trigger) {
+        this.timeoutHandle = this.setTimeoutImpl(() => {
+            this.timeoutHandle = undefined;
+            const tracked = this.runScheduledConsolidation(hour, trigger).finally(() => {
+                if (this.activeRun === tracked) {
+                    this.activeRun = undefined;
+                }
+            });
+            this.activeRun = tracked;
+            void tracked;
+        }, delayMs);
+        this.timeoutHandle?.unref?.();
+        this.log.info({ delay_ms: delayMs, hour, trigger }, "Wiki consolidation scheduled");
+    }
+    async runScheduledConsolidation(hour, trigger) {
+        if (this.running) {
+            this.log.warn({ hour, trigger }, "Wiki consolidation run skipped because a previous run is still active");
+            this.scheduleIn(DAY_MS, hour, "daily");
+            return;
+        }
+        this.running = true;
+        try {
+            const result = await this.runConsolidationImpl();
+            this.log.info({ trigger, hour, result }, "Wiki consolidation scheduled run complete");
+        }
+        catch (error) {
+            const err = error instanceof Error ? error.message : String(error);
+            if (this.log.error) {
+                this.log.error({ trigger, hour, err }, "Wiki consolidation scheduled run failed");
+            }
+            else {
+                this.log.warn({ trigger, hour, err }, "Wiki consolidation scheduled run failed");
+            }
+        }
+        finally {
+            this.running = false;
+            if (this.started) {
+                this.scheduleIn(DAY_MS, hour, "daily");
+            }
+        }
+    }
+}
+function parseEnabledEnv(rawValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return config.pkbConsolidationEnabled;
+    }
+    if (normalized !== "true" && normalized !== "false") {
+        throw new Error(`CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED must be 'true' or 'false', got: "${rawValue}"`);
+    }
+    return normalized === "true";
+}
+function parseHourEnv(rawValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return config.pkbConsolidationHour ?? DEFAULT_PKB_CONSOLIDATION_HOUR;
+    }
+    const parsed = Number(normalized);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 23) {
+        throw new Error(`CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR must be an integer between 0 and 23, got: "${rawValue}"`);
+    }
+    return parsed;
+}
+function delayUntilNextHour(now, hour) {
+    const next = new Date(now);
+    next.setUTCHours(hour, 0, 0, 0);
+    if (next.getTime() <= now.getTime()) {
+        next.setUTCDate(next.getUTCDate() + 1);
+    }
+    return next.getTime() - now.getTime();
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/wiki/scheduler.test.js

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+function createTimers() {
+    let nextId = 1;
+    const timeouts = [];
+    return {
+        timeouts,
+        setTimeoutImpl(callback, delayMs) {
+            const handle = { id: nextId++, unref() { } };
+            timeouts.push({ handle, callback, delayMs, cleared: false });
+            return handle;
+        },
+        clearTimeoutImpl(handle) {
+            const entry = timeouts.find((item) => item.handle === handle);
+            if (entry)
+                entry.cleared = true;
+        },
+    };
+}
+async function loadSchedulerModule() {
+    return await import(new URL(`./scheduler.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test("WikiConsolidationScheduler stays disabled when CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED is false", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    let runs = 0;
+    const scheduler = new schedulerModule.WikiConsolidationScheduler({
+        env: { CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED: "false" },
+        runConsolidation: async () => {
+            runs += 1;
+            return { truthRewrites: 0, fragmentsMerged: 0, linksRepaired: 0, pagesReindexed: 0, sourcesArchived: 0, staleSessionsNotified: 0, llmCallsUsed: 0 };
+        },
+        now: () => new Date("2026-05-14T22:30:03.086-04:00"),
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+    });
+    scheduler.start();
+    assert.equal(timers.timeouts.length, 0);
+    assert.equal(runs, 0);
+});
+test("WikiConsolidationScheduler schedules the next run for the configured hour and reschedules daily", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    let runs = 0;
+    const scheduler = new schedulerModule.WikiConsolidationScheduler({
+        env: { CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED: "true", CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: "3" },
+        runConsolidation: async () => {
+            runs += 1;
+            return { truthRewrites: 0, fragmentsMerged: 0, linksRepaired: 0, pagesReindexed: 0, sourcesArchived: 0, staleSessionsNotified: 0, llmCallsUsed: 0 };
+        },
+        now: () => new Date("2026-05-14T22:30:03.086-04:00"),
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+    });
+    scheduler.start();
+    assert.equal(timers.timeouts.length, 1);
+    assert.equal(timers.timeouts[0]?.delayMs, 1_796_914);
+    timers.timeouts[0]?.callback();
+    await Promise.resolve();
+    assert.equal(runs, 1);
+    assert.equal(timers.timeouts.length, 2);
+    assert.equal(timers.timeouts[1]?.delayMs, 86_400_000);
+});
+//# sourceMappingURL=scheduler.test.js.map