chapterhouse 0.3.15 → 0.3.17

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/agents.js

@@ -222,6 +222,8 @@ You are an agent within Chapterhouse, a team-level AI assistant for engineering
 ### Shared Wiki
 All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
 
+Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\`, \`remember\`, \`forget\`, \`wiki_ingest\`, \`wiki_lint\`, and \`wiki_rebuild_index\` as write-sensitive workflows. Before using them, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
+
 ### Communication
 - You receive tasks from @chapterhouse (the orchestrator) or directly from the user
 - Your results are relayed back to the user by @chapterhouse

package/dist/copilot/agents.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { composeAgentSystemMessage, } from "./agents.js";
+function makeAgent(slug) {
+    return {
+        slug,
+        name: slug,
+        description: `${slug} test agent`,
+        model: "claude-sonnet-4.6",
+        systemMessage: `You are ${slug}.`,
+    };
+}
+test("composeAgentSystemMessage steers wiki-capable agents to wiki-conventions", () => {
+    for (const slug of ["coder", "general-purpose"]) {
+        const message = composeAgentSystemMessage(makeAgent(slug));
+        assert.match(message, /invoke `wiki-conventions` before wiki writes/i);
+        assert.match(message, /wiki_update[\s\S]{0,80}remember[\s\S]{0,80}forget[\s\S]{0,80}wiki_ingest[\s\S]{0,80}wiki_lint[\s\S]{0,80}wiki_rebuild_index/i);
+        assert.match(message, /read `pages\/index\.md`/i);
+        assert.match(message, /scan the last 20-30 entries of `pages\/_meta\/log\.md`/i);
+    }
+});
+//# sourceMappingURL=agents.test.js.map

package/dist/copilot/skills.test.js

@@ -0,0 +1,10 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { listSkills } from "./skills.js";
+test("listSkills includes bundled wiki-conventions skill metadata", () => {
+    const skill = listSkills().find((entry) => entry.slug === "wiki-conventions" && entry.source === "bundled");
+    assert.ok(skill);
+    assert.equal(skill.name, "wiki-conventions");
+    assert.match(skill.description, /creating, editing, linting, restructuring, or reviewing Chapterhouse wiki content/i);
+});
+//# sourceMappingURL=skills.test.js.map

package/dist/copilot/system-message.js

@@ -122,6 +122,8 @@ You can delegate **multiple tasks simultaneously**. Different agents can work in
 - With \`remember\`, pass \`entity\` for entity categories (and \`facet\` to target a sub-page). With \`wiki_update\`, give the full canonical path — bad paths are rejected with a suggested correction; just retry with the suggestion.
 - If the structure ever looks wrong, call \`wiki_rebuild_index\` to regenerate the index from disk.
 
+**Wiki writes and restructuring**: Before writing or restructuring wiki content, invoke the \`wiki-conventions\` skill. Treat \`wiki_update\`, \`remember\`, \`forget\`, \`wiki_ingest\`, \`wiki_lint\`, and \`wiki_rebuild_index\` as write-sensitive workflows. Before using them, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
+
 **Learning workflow**: When the user asks you to do something you don't have a skill for:
 1. **Search skills.sh first**: Use the find-skills skill to search for existing community skills.
 2. **Present what you found**: Tell the user the skill name, what it does, and its security status.

package/dist/copilot/system-message.test.js

@@ -22,4 +22,15 @@ test("orchestrator prompt omits version banner when version is not provided", ()
     const message = getOrchestratorSystemMessage();
     assert.doesNotMatch(message, /chapterhouse v\d/);
 });
+test("orchestrator prompt requires wiki-conventions before write-sensitive wiki work", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, /wiki-conventions[\s\S]{0,500}wiki_update[\s\S]{0,200}remember[\s\S]{0,200}forget[\s\S]{0,200}wiki_ingest[\s\S]{0,200}wiki_lint[\s\S]{0,200}wiki_rebuild_index/i);
+    assert.match(message, /before writing or restructuring wiki content/i);
+});
+test("orchestrator prompt describes the wiki orientation ritual", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, /read `pages\/index\.md`/i);
+    assert.match(message, /scan the last 20-30 entries of `pages\/_meta\/log\.md`/i);
+    assert.match(message, /run `wiki_search` for the topic/i);
+});
 //# sourceMappingURL=system-message.test.js.map

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);