chapterhouse 0.7.0 → 0.8.1

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/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

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

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { existsSync, 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-log-${process.pid}`);
 const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
@@ -18,9 +19,12 @@ function resetSandbox() {
     rmSync(sandboxRoot, { recursive: true, force: true });
 }
 test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     resetSandbox();
+    resetSingletons();
 });
 test.after(() => {
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("appendLog writes action entries to pages/_meta/log.md with the resolved agent name", async () => {

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

package/dist/wiki/timeline.js

@@ -0,0 +1,51 @@
+// ---------------------------------------------------------------------------
+// Wiki timeline — append-only timeline section management
+// ---------------------------------------------------------------------------
+import { readPage, writePage } from "./fs.js";
+import { parseWikiFrontmatter } from "./frontmatter.js";
+import { upsertWikiPage } from "./index-manager.js";
+import { normalizeWikiPath } from "./path-utils.js";
+const TIMELINE_HEADING = "## Timeline";
+/**
+ * Append an entry to the `## Timeline` section of a wiki page.
+ * Creates the section (and the page itself) if absent.
+ * Calls upsertWikiPage to keep SQLite in sync after writing.
+ */
+export function appendTimeline(pagePath, entry, timestamp) {
+    const normalized = normalizeWikiPath(pagePath);
+    const ts = timestamp ?? new Date().toISOString();
+    const block = `\n### ${ts}\n\n${entry.trim()}\n`;
+    let content = readPage(normalized);
+    if (!content) {
+        // Create a minimal page with frontmatter + empty timeline
+        const title = deriveTitleFromPath(normalized);
+        content = `---\ntitle: ${title}\nsummary: ${title}\nupdated: ${ts.slice(0, 10)}\ntags: []\n---\n\n# ${title}\n\n${TIMELINE_HEADING}\n${block}`;
+        writePage(normalized, content);
+    }
+    else if (content.includes(TIMELINE_HEADING)) {
+        // Append after the last content in the timeline section
+        const idx = content.lastIndexOf(TIMELINE_HEADING);
+        const before = content.slice(0, idx + TIMELINE_HEADING.length);
+        const after = content.slice(idx + TIMELINE_HEADING.length);
+        content = before + after + block;
+        writePage(normalized, content);
+    }
+    else {
+        // Add timeline section at end of page
+        const trimmed = content.trimEnd();
+        content = trimmed + `\n\n${TIMELINE_HEADING}\n${block}`;
+        writePage(normalized, content);
+    }
+    // Keep SQLite in sync
+    const { parsed: fm } = parseWikiFrontmatter(readPage(normalized) ?? content);
+    const summary = fm.summary ?? deriveTitleFromPath(normalized);
+    upsertWikiPage(normalized, fm, summary);
+}
+function deriveTitleFromPath(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((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+//# sourceMappingURL=timeline.js.map

package/dist/wiki/timeline.test.js

@@ -0,0 +1,65 @@
+// ---------------------------------------------------------------------------
+// Timeline tests — appendTimeline
+// 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";
+let SANDBOX;
+let mods;
+test.before(async () => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
+    SANDBOX = mkdtempSync(join(process.cwd(), ".test-work", "timeline-"));
+    process.env.CHAPTERHOUSE_HOME = SANDBOX;
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const timeline = await import(new URL(`./timeline.js?c=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?c=${nonce}`, import.meta.url).href);
+    const indexManager = await import(new URL(`./index-manager.js?c=${nonce}`, import.meta.url).href);
+    mods = { timeline, wikiFs, indexManager };
+    mods.wikiFs.ensureWikiStructure();
+});
+test.after(() => {
+    try {
+        rmSync(SANDBOX, { recursive: true, force: true });
+    }
+    catch { /* best-effort */ }
+});
+test("appendTimeline creates page if it doesn't exist", () => {
+    mods.timeline.appendTimeline("pages/topics/rust/index.md", "First mention of Rust");
+    const content = mods.wikiFs.readPage("pages/topics/rust/index.md");
+    assert.ok(content, "Page should be created");
+    assert.ok(content.includes("## Timeline"), "Should have Timeline section");
+    assert.ok(content.includes("First mention of Rust"), "Should contain entry text");
+});
+test("appendTimeline creates Timeline section if absent", () => {
+    mods.wikiFs.writePage("pages/topics/go/index.md", "---\ntitle: Go\nsummary: Go programming language\nupdated: 2026-01-01\ntags: []\n---\n\n# Go\n\nSimple language.\n");
+    mods.timeline.appendTimeline("pages/topics/go/index.md", "Go 1.22 released");
+    const content = mods.wikiFs.readPage("pages/topics/go/index.md");
+    assert.ok(content.includes("## Timeline"), "Should have added Timeline section");
+    assert.ok(content.includes("Go 1.22 released"), "Should contain the entry");
+    assert.ok(content.includes("# Go"), "Should preserve original content");
+});
+test("appendTimeline is append-only: existing entries are unchanged", () => {
+    mods.timeline.appendTimeline("pages/topics/node/index.md", "First entry");
+    const after1 = mods.wikiFs.readPage("pages/topics/node/index.md");
+    assert.ok(after1.includes("First entry"));
+    mods.timeline.appendTimeline("pages/topics/node/index.md", "Second entry");
+    const after2 = mods.wikiFs.readPage("pages/topics/node/index.md");
+    assert.ok(after2.includes("First entry"), "First entry should still be present");
+    assert.ok(after2.includes("Second entry"), "Second entry should be appended");
+    assert.ok(after2.indexOf("First entry") < after2.indexOf("Second entry"), "Order should be preserved");
+});
+test("appendTimeline calls upsertWikiPage to sync SQLite", () => {
+    mods.timeline.appendTimeline("pages/topics/typescript/index.md", "TypeScript 5.0 notes");
+    const results = mods.indexManager.wikiSearch("typescript");
+    assert.ok(results.some((r) => r.path === "pages/topics/typescript/index.md"), "Page should be in SQLite after appendTimeline");
+});
+test("appendTimeline adds timestamp heading to each entry", () => {
+    const ts = "2026-05-14T20:45:55.900Z";
+    mods.timeline.appendTimeline("pages/topics/deno/index.md", "Deno 2.0 released", ts);
+    const content = mods.wikiFs.readPage("pages/topics/deno/index.md");
+    assert.ok(content.includes(`### ${ts}`), "Should have timestamp heading");
+    assert.ok(content.includes("Deno 2.0 released"), "Should have entry text");
+});
+//# sourceMappingURL=timeline.test.js.map

package/dist/wiki/topic-structure.js

@@ -31,7 +31,7 @@ export const EXEMPT_PREFIXES = [
 export const EXEMPT_PAGES = [
     "pages/index.md",
 ];
-/** Map a `remember`-style category name to its directory under pages/. */
+/** Map a legacy category name to its directory under pages/. */
 const CATEGORY_DIR_MAP = {
     person: "people",
     people: "people",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"