chapterhouse 0.3.15 → 0.3.16

package/dist/config.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { API_TOKEN_PATH, ENV_PATH, ensureChapterhouseHome } from "./paths.js";
 export const DISABLE_DOTENV_ENV_VAR = "CHAPTERHOUSE_DISABLE_DOTENV";
-const DEFAULT_WORKER_TIMEOUT_MS = 600_000;
+const DEFAULT_WORKER_TIMEOUT_MS = 900_000;
 const BOOLEAN_ENV_PATTERN = /^(true|false)$/;
 function loadRuntimeEnv() {
     if (process.env[DISABLE_DOTENV_ENV_VAR] === "1") {

package/dist/copilot/tools.js

@@ -8,9 +8,12 @@ import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
-import { ensureWikiStructure, readPage, writePage, deletePage, listPages, writeRawSource, listSources, assertPagePath } from "../wiki/fs.js";
-import { searchIndex, addToIndex, removeFromIndex, parseIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
+import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
+import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
+import { validateWikiFrontmatter } from "../wiki/frontmatter.js";
+import { lintWiki, renderWikiLintReport } from "../wiki/lint.js";
 import { appendLog } from "../wiki/log-manager.js";
+import { loadTaxonomy } from "../wiki/taxonomy.js";
 import { getCategoryDir, topicPagePath, slugify, entityCategories, FLAT_CATEGORIES } from "../wiki/topic-structure.js";
 import { withWikiWrite } from "../wiki/lock.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
@@ -960,20 +963,20 @@ export function createTools(deps) {
                 return withWikiWrite(async () => {
                     ensureWikiStructure();
                     assertPagePath(args.path);
+                    const validation = validateWikiFrontmatter(args.content, {
+                        allowedTags: loadTaxonomy(),
+                    });
+                    if (!validation.valid) {
+                        throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
+                    }
                     writePage(args.path, args.content);
-                    // Rebuild from disk so the index summary/tags/updated reflect the actual page,
-                    // but prefer caller-supplied title/summary/section as overrides.
+                    // Rebuild from disk so the index summary/tags/updated reflect the actual page.
                     const today = new Date().toISOString().slice(0, 10);
                     const rebuilt = buildIndexEntryForPage(args.path, {
-                        title: args.title,
-                        summary: indexSafe(args.summary).slice(0, 160),
                         section: args.section || "Knowledge",
                         updated: today,
                     });
                     if (rebuilt) {
-                        // Overrides win even if the page frontmatter says otherwise.
-                        rebuilt.title = args.title;
-                        rebuilt.summary = indexSafe(args.summary).slice(0, 160);
                         rebuilt.section = args.section || "Knowledge";
                         addToIndex(rebuilt);
                     }
@@ -1064,25 +1067,11 @@ export function createTools(deps) {
             parameters: z.object({}),
             handler: async () => {
                 ensureWikiStructure();
-                const indexEntries = parseIndex();
-                const pages = listPages();
-                const sources = listSources();
-                const indexPaths = new Set(indexEntries.map((e) => e.path));
-                const orphans = pages.filter((p) => !indexPaths.has(p));
-                const missing = indexEntries.filter((e) => !readPage(e.path));
-                const report = [`Wiki health report (${pages.length} pages, ${sources.length} sources):`];
-                if (orphans.length > 0) {
-                    report.push(`\n**Orphan pages** (not in index):\n${orphans.map((p) => `- ${p}`).join("\n")}`);
-                }
-                if (missing.length > 0) {
-                    report.push(`\n**Missing pages** (in index but not on disk):\n${missing.map((e) => `- ${e.path}: ${e.title}`).join("\n")}`);
-                }
-                if (orphans.length === 0 && missing.length === 0) {
-                    report.push("\n✅ No issues found. Index and pages are in sync.");
-                }
-                report.push(`\n**Suggestions**: Look for pages that should link to each other, topics mentioned but lacking their own page, and stale content that needs updating.`);
-                appendLog("lint", `${orphans.length} orphans, ${missing.length} missing`);
-                return report.join("\n");
+                const report = lintWiki();
+                const orphanCount = report.issues.filter((issue) => issue.rule === "orphan-page").length;
+                const missingCount = report.issues.filter((issue) => issue.rule === "missing-page").length;
+                appendLog("lint", `${orphanCount} orphans, ${missingCount} missing`);
+                return renderWikiLintReport(report);
             },
         }),
         defineTool("wiki_rebuild_index", {
@@ -1094,7 +1083,7 @@ export function createTools(deps) {
                 return withWikiWrite(async () => {
                     const { rebuildIndexFromPages } = await import("../wiki/index-manager.js");
                     const entries = rebuildIndexFromPages();
-                    appendLog("lint", `wiki_rebuild_index: rebuilt ${entries.length} entries from pages on disk`);
+                    appendLog("rebuild-index", `wiki_rebuild_index: rebuilt ${entries.length} entries from pages on disk`);
                     return `Rebuilt index with ${entries.length} entries.`;
                 });
             },

package/dist/copilot/tools.wiki.test.js

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+async function loadToolsModule() {
+    return await import(new URL(`./tools.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+async function readWikiArtifacts() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const wikiFs = await import(new URL(`../wiki/fs.js?case=${nonce}`, import.meta.url).href);
+    return wikiFs;
+}
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-wiki-"));
+    process.env.CHAPTERHOUSE_AGENT_NAME = "tools-test-agent";
+});
+test.afterEach(async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    if (home) {
+        const dbModule = await import("../store/db.js");
+        dbModule.closeDb();
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("wiki_update rejects content without required frontmatter", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    await assert.rejects(tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: "# Chapterhouse\n\nRuntime notes.\n",
+    }), /Wiki page frontmatter violates the required shape/i);
+});
+test("wiki_update rejects malformed summaries and unknown tags", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    await assert.rejects(tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: **Runtime notes**
+tags: [engineering, made-up-tag]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    }), /Add it to `pages\/_meta\/taxonomy\.md` first\./);
+});
+test("wiki_update accepts valid frontmatter and refreshes the index entry", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "wiki_update");
+    assert.ok(tool);
+    const result = await tool.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+tags: [engineering]
+autostub: true
+confidence: low
+contested: true
+contradictions: [pages/shared/other.md]
+---
+
+# Chapterhouse
+
+Runtime notes.
+`,
+    });
+    assert.equal(result, "Wiki page updated: Chapterhouse (pages/shared/chapterhouse.md)");
+    const wikiFs = await readWikiArtifacts();
+    assert.match(wikiFs.readPage("pages/shared/chapterhouse.md") ?? "", /summary: Runtime notes/);
+    assert.match(wikiFs.readIndexFile(), /\[Chapterhouse\]\(pages\/shared\/chapterhouse\.md\) — Runtime notes/);
+});
+test("wiki tools append audit entries to pages/_meta/log.md", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const wikiUpdate = tools.find((entry) => entry.name === "wiki_update");
+    const wikiIngest = tools.find((entry) => entry.name === "wiki_ingest");
+    const wikiLint = tools.find((entry) => entry.name === "wiki_lint");
+    const wikiRebuildIndex = tools.find((entry) => entry.name === "wiki_rebuild_index");
+    const forget = tools.find((entry) => entry.name === "forget");
+    assert.ok(wikiUpdate && wikiIngest && wikiLint && wikiRebuildIndex && forget);
+    await wikiUpdate.handler({
+        path: "pages/shared/chapterhouse.md",
+        title: "Chapterhouse",
+        summary: "Runtime notes",
+        content: `---
+title: Chapterhouse
+summary: Runtime notes
+updated: 2026-05-12
+tags: [engineering]
+---
+
+# Chapterhouse
+
+## Overview
+
+Runtime notes with enough content to avoid incidental lint noise in the audit-log test.
+`,
+    });
+    await wikiIngest.handler({
+        type: "text",
+        source: "Source content for the wiki ingest audit log test.",
+        name: "audit-log-source",
+    });
+    await wikiLint.handler({});
+    await wikiRebuildIndex.handler({});
+    await forget.handler({ page_path: "pages/shared/chapterhouse.md" });
+    const wikiFs = await readWikiArtifacts();
+    const log = wikiFs.readLogFile();
+    assert.match(log, /update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| tools-test-agent/);
+    assert.match(log, /ingest \| Ingested text: audit-log-source \(\d+ chars\) \| tools-test-agent/);
+    assert.match(log, /lint \| .* \| tools-test-agent/);
+    assert.match(log, /rebuild-index \| wiki_rebuild_index: rebuilt \d+ entries from pages on disk \| tools-test-agent/);
+    assert.match(log, /delete \| forget: deleted page pages\/shared\/chapterhouse\.md \| tools-test-agent/);
+});
+//# sourceMappingURL=tools.wiki.test.js.map

package/dist/wiki/frontmatter.js

@@ -0,0 +1,148 @@
+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---`;
+export function parseWikiFrontmatter(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match) {
+        return {
+            parsed: { metadata: {} },
+            body: 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);
+        switch (key) {
+            case "title":
+            case "summary":
+            case "updated":
+                if (typeof value === "string")
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "tags":
+            case "contradictions":
+            case "related":
+                if (Array.isArray(value))
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "autostub":
+            case "contested":
+                if (typeof value === "boolean")
+                    parsed[key] = value;
+                else
+                    parsed.metadata[key] = value;
+                break;
+            case "confidence":
+                if (value === "high" || value === "medium" || value === "low") {
+                    parsed.confidence = value;
+                }
+                else {
+                    parsed.metadata[key] = value;
+                }
+                break;
+            default:
+                parsed.metadata[key] = value;
+                break;
+        }
+    }
+    return {
+        parsed,
+        body: content.slice(match[0].length),
+    };
+}
+export function hasWikiFrontmatter(content) {
+    return FRONTMATTER_RE.test(content);
+}
+export function validateWikiFrontmatter(content, options = {}) {
+    const errors = [];
+    const { parsed } = parseWikiFrontmatter(content);
+    if (!hasWikiFrontmatter(content)) {
+        errors.push({
+            rule: "missing-frontmatter",
+            message: "Wiki page frontmatter violates the required shape: missing YAML frontmatter. Use:\n" + FRONTMATTER_TEMPLATE,
+        });
+        return { valid: false, errors };
+    }
+    if (!parsed.title?.trim()) {
+        errors.push({
+            rule: "missing-title",
+            field: "title",
+            message: formatFrontmatterMessage("missing 'title'"),
+        });
+    }
+    if (!parsed.summary?.trim()) {
+        errors.push({
+            rule: "missing-summary",
+            field: "summary",
+            message: formatFrontmatterMessage("missing 'summary'"),
+        });
+    }
+    else {
+        const summary = parsed.summary.trim();
+        if (summary.length > 200 ||
+            summary.includes("\n") ||
+            summary.includes("\r") ||
+            SUMMARY_MARKDOWN_RE.test(summary)) {
+            errors.push({
+                rule: "invalid-summary",
+                field: "summary",
+                message: formatFrontmatterMessage("invalid 'summary' (use plain text, one line, max 200 chars)"),
+            });
+        }
+    }
+    for (const field of ["updated", "tags", "autostub", "confidence", "contested", "contradictions", "related"]) {
+        if (field in parsed.metadata) {
+            errors.push({
+                rule: "invalid-field-type",
+                field,
+                message: formatFrontmatterMessage(`invalid '${field}' type`),
+            });
+        }
+    }
+    if (options.allowedTags && parsed.tags) {
+        const allowed = new Set(options.allowedTags.map((tag) => tag.toLowerCase()));
+        for (const tag of parsed.tags) {
+            if (!allowed.has(tag.toLowerCase())) {
+                errors.push({
+                    rule: "unknown-tag",
+                    field: "tags",
+                    message: formatFrontmatterMessage(`unknown tag '${tag}'. Add it to \`pages/_meta/taxonomy.md\` first.`),
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+function formatFrontmatterMessage(reason) {
+    return `Wiki page frontmatter violates the required shape: ${reason}. Use:\n${FRONTMATTER_TEMPLATE}`;
+}
+function parseValue(rawValue) {
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+        return rawValue
+            .slice(1, -1)
+            .split(",")
+            .map((item) => stripQuotes(item.trim()))
+            .filter(Boolean);
+    }
+    if (rawValue === "true")
+        return true;
+    if (rawValue === "false")
+        return false;
+    return stripQuotes(rawValue);
+}
+function stripQuotes(value) {
+    return value.replace(/^['"]|['"]$/g, "");
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/wiki/frontmatter.test.js

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadFrontmatterModule() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    return await import(new URL(`./frontmatter.js?case=${nonce}`, import.meta.url).href);
+}
+test("parseWikiFrontmatter parses typed known fields and preserves unknown metadata", async () => {
+    const { parseWikiFrontmatter } = await loadFrontmatterModule();
+    const result = parseWikiFrontmatter(`---
+title: Chapterhouse
+summary: Team orchestrator runtime
+updated: 2026-05-12
+tags: [engineering, orchestration]
+autostub: true
+confidence: low
+contested: true
+contradictions: [pages/projects/chapterhouse/decisions.md]
+related: [pages/projects/chapterhouse/index.md]
+owner: brian
+---
+
+# Chapterhouse
+
+Runtime notes.
+`);
+    assert.deepEqual(result, {
+        parsed: {
+            title: "Chapterhouse",
+            summary: "Team orchestrator runtime",
+            updated: "2026-05-12",
+            tags: ["engineering", "orchestration"],
+            autostub: true,
+            confidence: "low",
+            contested: true,
+            contradictions: ["pages/projects/chapterhouse/decisions.md"],
+            related: ["pages/projects/chapterhouse/index.md"],
+            metadata: {
+                owner: "brian",
+            },
+        },
+        body: "# Chapterhouse\n\nRuntime notes.\n",
+    });
+});
+test("parseWikiFrontmatter tolerates legacy pages without frontmatter", async () => {
+    const { parseWikiFrontmatter } = await loadFrontmatterModule();
+    const result = parseWikiFrontmatter("# Legacy Page\n\nStill readable.\n");
+    assert.deepEqual(result, {
+        parsed: {
+            metadata: {},
+        },
+        body: "# Legacy Page\n\nStill readable.\n",
+    });
+});
+test("validateWikiFrontmatter requires authored pages to include title and summary", async () => {
+    const { validateWikiFrontmatter } = await loadFrontmatterModule();
+    const result = validateWikiFrontmatter(`---
+title: Chapterhouse
+---
+
+# Chapterhouse
+`);
+    assert.equal(result.valid, false);
+    assert.deepEqual(result.errors.map((error) => error.rule), ["missing-summary"]);
+    assert.match(result.errors[0]?.message ?? "", /missing 'summary'/i);
+});
+test("validateWikiFrontmatter rejects malformed summaries and invalid optional field types", async () => {
+    const { validateWikiFrontmatter } = await loadFrontmatterModule();
+    const result = validateWikiFrontmatter(`---
+title: Chapterhouse
+summary: **Bold summary**
+autostub: maybe
+confidence: unsure
+contested: perhaps
+contradictions: nope
+---
+
+# Chapterhouse
+`);
+    assert.equal(result.valid, false);
+    assert.deepEqual(result.errors.map((error) => error.rule), [
+        "invalid-summary",
+        "invalid-field-type",
+        "invalid-field-type",
+        "invalid-field-type",
+        "invalid-field-type",
+    ]);
+    assert.deepEqual(result.errors.map((error) => error.field), [
+        "summary",
+        "autostub",
+        "confidence",
+        "contested",
+        "contradictions",
+    ]);
+});
+test("validateWikiFrontmatter rejects unknown tags after taxonomy loading", async () => {
+    const { validateWikiFrontmatter } = await loadFrontmatterModule();
+    const result = validateWikiFrontmatter(`---
+title: Deploy
+summary: Runbook for production deployments
+tags: [engineering, made-up-tag]
+---
+
+# Deploy
+`, { allowedTags: ["engineering", "release"] });
+    assert.equal(result.valid, false);
+    assert.deepEqual(result.errors.map((error) => error.rule), ["unknown-tag"]);
+    assert.match(result.errors[0]?.message ?? "", /Add it to `pages\/_meta\/taxonomy\.md` first\./);
+});
+//# sourceMappingURL=frontmatter.test.js.map

package/dist/wiki/fs.js

@@ -7,7 +7,7 @@ import { WIKI_DIR, WIKI_PAGES_DIR, WIKI_SOURCES_DIR } from "../paths.js";
 import { normalizeWikiPath } from "./path-utils.js";
 import { topicPathError } from "./topic-structure.js";
 const INDEX_PATH = join(WIKI_DIR, "index.md");
-const LOG_PATH = join(WIKI_DIR, "log.md");
+const LOG_PATH = join(WIKI_PAGES_DIR, "_meta", "log.md");
 /**
  * Write a file atomically: write to a temp file in the same directory, fsync,
  * then rename over the destination. Prevents partial writes on crash and
@@ -63,9 +63,9 @@ Last updated: ${new Date().toISOString().slice(0, 10)}
 _(No pages yet.)_
 `;
 }
-const INITIAL_LOG = `# Wiki Log
+const INITIAL_LOG = `# Wiki Action Log
 
-_Chronological record of wiki operations._
+_Append-only record of wiki operations._
 
 `;
 /**

package/dist/wiki/fs.test.js

@@ -20,11 +20,12 @@ test("wiki fs creates the wiki structure and supports page CRUD", async () => {
     assert.equal(wiki.ensureWikiStructure(), true);
     assert.equal(wiki.ensureWikiStructure(), false);
     assert.equal(existsSync(join(wikiDir, "index.md")), true);
-    assert.equal(existsSync(join(wikiDir, "log.md")), true);
+    assert.equal(existsSync(join(wikiDir, "pages", "_meta", "log.md")), true);
     wiki.writePage("pages/shared/runbooks/deploy.md", "# Deploy\n");
     assert.equal(wiki.pageExists("pages/shared/runbooks/deploy.md"), true);
     assert.equal(wiki.readPage("pages/shared/runbooks/deploy.md"), "# Deploy\n");
-    assert.deepEqual(wiki.listPages(), ["pages/shared/runbooks/deploy.md"]);
+    assert.equal(wiki.listPages().includes("pages/shared/runbooks/deploy.md"), true);
+    assert.match(wiki.readLogFile(), /^# Wiki Action Log/m);
     assert.equal(wiki.deletePage("pages/shared/runbooks/deploy.md"), true);
     assert.equal(wiki.deletePage("pages/shared/runbooks/deploy.md"), false);
     assert.equal(wiki.readPage("pages/shared/runbooks/deploy.md"), undefined);

package/dist/wiki/index-manager.js

@@ -5,9 +5,11 @@ import { existsSync, statSync } from "fs";
 import { join } from "path";
 import { WIKI_DIR } from "../paths.js";
 import { readIndexFile, writeIndexFile, listPages, readPage } from "./fs.js";
+import { parseWikiFrontmatter } from "./frontmatter.js";
 import { normalizeWikiPath } from "./path-utils.js";
 import { entityCategories, FLAT_CATEGORIES } from "./topic-structure.js";
 const INDEX_PATH = join(WIKI_DIR, "index.md");
+const ACTION_LOG_PAGE_RE = /^pages\/_meta\/log(?:-\d{4})?\.md$/;
 // mtime-based cache so per-message context injection doesn't re-parse on every turn.
 let cache;
 function invalidateCache() {
@@ -73,7 +75,7 @@ export function parseIndex() {
     }
     // Self-heal: if index is empty/corrupted but pages exist on disk, rebuild from disk.
     if (entries.length === 0) {
-        const pages = listPages();
+        const pages = listPages().filter((path) => !isActionLogPage(path));
         if (pages.length > 0) {
             const rebuilt = rebuildIndexFromPages();
             cache = { mtimeMs, size, entries: rebuilt };
@@ -83,43 +85,20 @@ export function parseIndex() {
     cache = { mtimeMs, size, entries };
     return entries;
 }
-/** Parse YAML frontmatter (very simple — supports key: value and key: [a, b]). */
-function parseFrontmatter(content) {
-    const m = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!m)
-        return {};
-    const out = {};
-    for (const line of m[1].split("\n")) {
-        const idx = line.indexOf(":");
-        if (idx <= 0)
-            continue;
-        const key = line.slice(0, idx).trim();
-        let value = line.slice(idx + 1).trim();
-        if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
-            value = value.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
-        }
-        else if (typeof value === "string") {
-            value = value.replace(/^['"]|['"]$/g, "");
-        }
-        out[key] = value;
-    }
-    return out;
-}
 /** Build (or refresh) an IndexEntry by reading the page from disk. */
 export function buildIndexEntryForPage(path, fallback) {
     const normalizedPath = normalizeWikiPath(path);
     const content = readPage(normalizedPath);
     if (!content)
         return undefined;
-    const fm = parseFrontmatter(content);
-    const title = (typeof fm.title === "string" && fm.title) || fallback?.title || basenameTitle(normalizedPath);
-    const tags = Array.isArray(fm.tags) ? fm.tags : (fallback?.tags ?? []);
-    const updated = (typeof fm.updated === "string" && fm.updated) || fallback?.updated;
-    // Summary heuristic: existing summary if provided, else first non-frontmatter
-    // non-heading content line trimmed to 160 chars.
-    let summary = fallback?.summary?.trim() || "";
+    const { parsed: fm, body } = parseWikiFrontmatter(content);
+    const title = fm.title || fallback?.title || basenameTitle(normalizedPath);
+    const tags = fm.tags ?? fallback?.tags ?? [];
+    const updated = fm.updated || fallback?.updated;
+    // Compliant pages treat frontmatter summary as canonical. Legacy pages fall back
+    // to the first non-frontmatter, non-heading content line.
+    let summary = fm.summary?.trim() || fallback?.summary?.trim() || "";
     if (!summary) {
-        const body = content.replace(/^---[\s\S]*?---\s*/, "");
         for (const raw of body.split("\n")) {
             const line = raw.trim();
             if (!line || line.startsWith("#") || line.startsWith("<!--"))
@@ -149,7 +128,7 @@ function basenameTitle(path) {
 }
 /** Rebuild every index entry from on-disk pages. Preserves section if known. */
 export function rebuildIndexFromPages() {
-    const pages = listPages();
+    const pages = listPages().filter((path) => !isActionLogPage(path));
     const previous = new Map();
     // Try to keep section assignments by re-parsing the (possibly-corrupted) index without recursion.
     try {
@@ -288,6 +267,9 @@ function writeIndexInternal(entries) {
     }
     writeIndexFile(lines.join("\n"));
 }
+function isActionLogPage(path) {
+    return ACTION_LOG_PAGE_RE.test(path);
+}
 /** Add or update an entry in the index. Upserts by path. */
 export function addToIndex(entry) {
     const normalizedEntry = { ...entry, path: normalizeWikiPath(entry.path) };

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

@@ -43,14 +43,14 @@ test("parseIndex reads sections, summaries, tags, and updated dates", async () =
         },
     ]);
 });
-test("buildIndexEntryForPage derives title, metadata, and a trimmed summary from page content", async () => {
+test("buildIndexEntryForPage treats frontmatter summary as the canonical index summary", async () => {
     const { indexManager, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/shared/runbooks/deploy.md", `---\ntitle: Deploy Runbook\ntags: [ops, release]\nupdated: 2026-05-04\n---\n\n# Deploy\n\n${"Deploy carefully ".repeat(20)}\n`);
+    wikiFs.writePage("pages/shared/runbooks/deploy.md", `---\ntitle: Deploy Runbook\nsummary: Production deployment checklist\ntags: [ops, release]\nupdated: 2026-05-04\n---\n\n# Deploy\n\n${"Deploy carefully ".repeat(20)}\n`);
     const entry = indexManager.buildIndexEntryForPage("pages/shared/runbooks/deploy.md");
     assert.deepEqual(entry, {
         path: "pages/shared/runbooks/deploy.md",
         title: "Deploy Runbook",
-        summary: `${("Deploy carefully ".repeat(20)).trim().slice(0, 157)}…`,
+        summary: "Production deployment checklist",
         section: "Knowledge",
         tags: ["ops", "release"],
         updated: "2026-05-04",