chapterhouse 0.3.15 → 0.3.17

package/dist/wiki/lint.test.js

@@ -0,0 +1,260 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `wiki-lint-${process.pid}`);
+const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const lint = await import(new URL(`./lint.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { lint, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+function wikiPage(frontmatter, body) {
+    return `---\n${frontmatter.join("\n")}\n---\n\n${body.trim()}\n`;
+}
+function setPageAge(relativePath, ageInDays) {
+    const stamped = new Date(Date.now() - ageInDays * 24 * 60 * 60 * 1000);
+    const fullPath = join(wikiDir, relativePath);
+    utimesSync(fullPath, stamped, stamped);
+}
+test("lintWiki reports orphan pages and index entries pointing to missing pages", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/shared/orphan.md", wikiPage([
+        "title: Orphan",
+        "summary: Not indexed yet",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Orphan\n\nThis orphan page has enough descriptive body text to avoid the premature-page lint while still remaining absent from the index."));
+    wikiFs.writeIndexFile(`# Wiki Index
+
+## Shared
+
+- [Missing](pages/shared/missing.md) — Not on disk
+`);
+    const report = lint.lintWiki();
+    assert.equal(report.pageCount, 1);
+    assert.equal(report.sourceCount, 0);
+    assert.deepEqual(report.issues.map((issue) => `${issue.rule}:${issue.severity}:${issue.path ?? "-"}`).sort(), [
+        "missing-page:warning:pages/shared/missing.md",
+        "orphan-page:warning:pages/shared/orphan.md",
+    ]);
+});
+test("renderWikiLintReport preserves the current wiki_lint report format", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/shared/orphan.md", wikiPage([
+        "title: Orphan",
+        "summary: Not indexed yet",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Orphan\n\nThis orphan page has enough descriptive body text to avoid the premature-page lint while still remaining absent from the index."));
+    wikiFs.writeIndexFile(`# Wiki Index
+
+## Shared
+
+- [Tracked](pages/shared/tracked.md) — Present only in the index
+`);
+    const rendered = lint.renderWikiLintReport(lint.lintWiki());
+    assert.match(rendered, /^Wiki health report \(1 pages, 0 sources\):/);
+    assert.match(rendered, /warning\s+\|\s+orphan-page\s+\|\s+pages\/shared\/orphan\.md/);
+    assert.match(rendered, /warning\s+\|\s+missing-page\s+\|\s+pages\/shared\/tracked\.md/);
+    assert.match(rendered, /\*\*Suggestions\*\*: Look for pages that should link to each other/);
+});
+test("renderWikiLintReport reports the healthy wiki message when no issues are found", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/shared/indexed.md", wikiPage([
+        "title: Indexed",
+        "summary: Tracked page",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Indexed\n\n## Overview\n\nTracked page with enough detail to stay above the premature-page threshold and remain clearly established as a real page in the healthy-wiki case."));
+    wikiFs.writeIndexFile(`# Wiki Index
+
+## Shared
+
+- [Indexed](pages/shared/indexed.md) — Tracked page
+`);
+    const rendered = lint.renderWikiLintReport(lint.lintWiki());
+    assert.match(rendered, /✅ No issues found\. Index and pages are in sync\./);
+});
+test("lintWiki reports the remaining Phase 1 structural and content rules", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+- engineering
+- release
+
+## Unused
+- ghost-tag
+`);
+    wikiFs.writePage("pages/projects/chapterhouse/feature-ideas.md", wikiPage([
+        "title: Chapterhouse ideas",
+        "summary: Candidate follow-up work",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Chapterhouse ideas\n\n## Ideas\n\n- Add a conventions skill."));
+    setPageAge("pages/projects/chapterhouse/feature-ideas.md", 91);
+    wikiFs.writePage("pages/shared/missing-updated.md", wikiPage([
+        "title: Missing updated",
+        "summary: This page omits the updated field",
+        "tags: [engineering]",
+    ], "# Missing updated\n\nThis page forgot its date stamp."));
+    wikiFs.writePage("pages/shared/invalid-frontmatter.md", wikiPage([
+        "title: Invalid frontmatter",
+        "summary: **Not plain text**",
+        "tags: [engineering, unknown-tag]",
+    ], "# Invalid frontmatter\n\nBody content."));
+    wikiFs.writePage("pages/shared/skipped-heading.md", wikiPage([
+        "title: Skipped heading",
+        "summary: Heading depth should not skip levels",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Skipped heading\n\n### Too deep"));
+    wikiFs.writePage("pages/shared/decisions.md", wikiPage([
+        "title: Misfiled decisions",
+        "summary: Decisions must live under an entity directory",
+        "updated: 2026-05-12",
+        "tags: [decision]",
+    ], "# Misfiled decisions\n\n## Record\n\nA misplaced decision log."));
+    wikiFs.writePage("pages/shared/large-warning.md", wikiPage([
+        "title: Large warning",
+        "summary: Page size warning threshold coverage",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], `# Large warning\n\n${Array.from({ length: 301 }, (_, index) => `Line ${index + 1}`).join("\n")}`));
+    wikiFs.writePage("pages/shared/large-error.md", wikiPage([
+        "title: Large error",
+        "summary: Page size error threshold coverage",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], `# Large error\n\n${Array.from({ length: 801 }, (_, index) => `Line ${index + 1}`).join("\n")}`));
+    wikiFs.writePage("pages/shared/tiny.md", wikiPage([
+        "title: Tiny page",
+        "summary: Tiny pages should be linted as premature",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Tiny page\n\nTiny."));
+    wikiFs.writePage("pages/shared/stub.md", wikiPage([
+        "title: Stub page",
+        "summary: Stub pages should be flipped once they grow up",
+        "autostub: true",
+        "tags: [autostub]",
+    ], `# Stub page\n\n${Array.from({ length: 12 }, (_, index) => `- fleshed out line ${index + 1}`).join("\n")}`));
+    const report = lint.lintWiki();
+    const signatures = report.issues.map((issue) => `${issue.rule}:${issue.severity}:${issue.path ?? "-"}`);
+    assert.ok(signatures.includes("index-integrity:error:pages/projects/chapterhouse"));
+    assert.ok(signatures.includes("stale-page:warning:pages/projects/chapterhouse/feature-ideas.md"));
+    assert.ok(signatures.includes("missing-updated:warning:pages/shared/missing-updated.md"));
+    assert.ok(signatures.includes("frontmatter-shape:error:pages/shared/invalid-frontmatter.md"));
+    assert.ok(signatures.includes("heading-depth:warning:pages/shared/skipped-heading.md"));
+    assert.ok(signatures.includes("decision-misfile:error:pages/shared/decisions.md"));
+    assert.ok(signatures.includes("page-size:warning:pages/shared/large-warning.md"));
+    assert.ok(signatures.includes("page-size:error:pages/shared/large-error.md"));
+    assert.ok(signatures.includes("premature-page:info:pages/shared/tiny.md"));
+    assert.ok(signatures.includes("autostub-not-flipped:info:pages/shared/stub.md"));
+    assert.ok(signatures.includes("dead-taxonomy-entry:info:pages/_meta/taxonomy.md"));
+});
+test("lintWiki exempts decision and conversation pages from staleness and exempts autostubs from selected rules", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", wikiPage([
+        "title: Chapterhouse",
+        "summary: Overview page required for entity facets",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Chapterhouse\n\n## Overview\n\nProject overview."));
+    wikiFs.writePage("pages/projects/chapterhouse/decisions.md", wikiPage([
+        "title: Chapterhouse decisions",
+        "summary: Decision logs should never go stale",
+        "updated: 2026-05-12",
+        "tags: [decision]",
+    ], "# Chapterhouse decisions\n\n## Decisions\n\nRecorded decisions."));
+    setPageAge("pages/projects/chapterhouse/decisions.md", 365);
+    wikiFs.writePage("pages/conversations/2026-01-01.md", wikiPage([
+        "title: Conversations on 2026-01-01",
+        "summary: Daily conversation summary",
+        "updated: 2026-01-01",
+        "tags: [engineering]",
+    ], "# Conversations on 2026-01-01\n\nSummary body."));
+    setPageAge("pages/conversations/2026-01-01.md", 365);
+    wikiFs.writePage("pages/shared/autostub.md", wikiPage([
+        "title: Stub",
+        "summary: Placeholder page",
+        "autostub: true",
+        "tags: [autostub]",
+    ], `# Stub\n\n### Placeholder\n\n${Array.from({ length: 900 }, (_, index) => `Line ${index + 1}`).join("\n")}`));
+    const report = lint.lintWiki();
+    const signatures = report.issues.map((issue) => `${issue.rule}:${issue.path ?? "-"}`);
+    assert.equal(signatures.includes("stale-page:pages/projects/chapterhouse/decisions.md"), false);
+    assert.equal(signatures.includes("stale-page:pages/conversations/2026-01-01.md"), false);
+    assert.equal(signatures.includes("missing-updated:pages/shared/autostub.md"), false);
+    assert.equal(signatures.includes("premature-page:pages/shared/autostub.md"), false);
+    assert.equal(signatures.includes("heading-depth:pages/shared/autostub.md"), false);
+    assert.equal(signatures.includes("page-size:pages/shared/autostub.md"), false);
+});
+test("renderWikiLintReport surfaces contested and low-confidence pages ahead of the general issue list", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/shared/contested.md", wikiPage([
+        "title: Contested page",
+        "summary: This page is explicitly contested",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+        "contested: true",
+    ], "# Contested page\n\nThis page needs review."));
+    wikiFs.writePage("pages/shared/low-confidence.md", wikiPage([
+        "title: Low confidence page",
+        "summary: This page has low confidence",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+        "confidence: low",
+    ], "# Low confidence page\n\nThis page needs review."));
+    wikiFs.writePage("pages/shared/missing-updated.md", wikiPage([
+        "title: Missing updated",
+        "summary: A regular issue should come after contested pages",
+        "tags: [engineering]",
+    ], "# Missing updated\n\nBody."));
+    const rendered = lint.renderWikiLintReport(lint.lintWiki());
+    const contestedIndex = rendered.indexOf("pages/shared/contested.md");
+    const lowConfidenceIndex = rendered.indexOf("pages/shared/low-confidence.md");
+    const generalIssueIndex = rendered.indexOf("missing-updated");
+    assert.ok(contestedIndex >= 0);
+    assert.ok(lowConfidenceIndex >= 0);
+    assert.ok(generalIssueIndex >= 0);
+    assert.ok(contestedIndex < generalIssueIndex);
+    assert.ok(lowConfidenceIndex < generalIssueIndex);
+});
+test("lintWiki reports a missing or unwritable action log", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/shared/healthy.md", wikiPage([
+        "title: Healthy page",
+        "summary: Enough content to avoid incidental lint issues",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Healthy page\n\n## Overview\n\nThis page exists so the action-log rule is isolated from unrelated findings in the test."));
+    rmSync(join(wikiDir, "pages", "_meta", "log.md"), { force: true });
+    let report = lint.lintWiki();
+    assert.ok(report.issues.some((issue) => issue.rule === "action-log" &&
+        issue.severity === "error" &&
+        issue.path === "pages/_meta/log.md"));
+    rmSync(join(wikiDir, "pages", "_meta"), { recursive: true, force: true });
+    mkdirSync(join(wikiDir, "pages", "_meta", "log.md"), { recursive: true });
+    report = lint.lintWiki();
+    assert.ok(report.issues.some((issue) => issue.rule === "action-log" &&
+        issue.severity === "error" &&
+        issue.path === "pages/_meta/log.md"));
+});
+//# sourceMappingURL=lint.test.js.map

package/dist/wiki/log-manager.js

@@ -1,20 +1,63 @@
 // ---------------------------------------------------------------------------
-// Wiki log.md manager — append-only chronological operation log
+// Wiki action-log manager — append-only chronological operation log
 // ---------------------------------------------------------------------------
-import { appendFileSync } from "fs";
+import { appendFileSync, existsSync, readFileSync, renameSync } from "fs";
 import { join } from "path";
-import { WIKI_DIR } from "../paths.js";
-import { ensureWikiStructure } from "./fs.js";
-const LOG_PATH = join(WIKI_DIR, "log.md");
+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");
+const MAX_LOG_ENTRIES = 500;
+const LOG_ENTRY_RE = /^## \[/gm;
+const INITIAL_LOG = `# Wiki Action Log
+
+_Append-only record of wiki operations._
+
+`;
 /**
- * Append a timestamped entry to log.md.
- * Format: `## [YYYY-MM-DD HH:MM] type | description`
+ * Append a timestamped entry to pages/_meta/log.md.
+ * Format: `## [YYYY-MM-DD HH:MM] action | subject | agent`
  */
-export function appendLog(type, description) {
+export function appendLog(type, subject, agent = resolveAgentName()) {
     ensureWikiStructure();
+    rotateLogIfNeeded();
     const now = new Date();
     const ts = now.toISOString().slice(0, 16).replace("T", " ");
-    const entry = `## [${ts}] ${type} | ${description}\n\n`;
+    const entry = `## [${ts}] ${type} | ${subject} | ${agent}\n\n`;
     appendFileSync(LOG_PATH, entry, "utf-8");
 }
+function rotateLogIfNeeded() {
+    const currentLog = readFileSync(LOG_PATH, "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);
+    }
+    else {
+        const archivedEntries = extractEntries(currentLog);
+        if (archivedEntries.length > 0) {
+            const separator = readFileSync(archivePath, "utf-8").endsWith("\n\n") ? "" : "\n\n";
+            appendFileSync(archivePath, `${separator}${archivedEntries.join("\n\n")}\n\n`, "utf-8");
+        }
+    }
+    writeFileAtomic(LOG_PATH, INITIAL_LOG);
+}
+function extractEntries(content) {
+    return content
+        .split(/\n{2,}/)
+        .map((chunk) => chunk.trim())
+        .filter((chunk) => chunk.startsWith("## ["));
+}
+function resolveAgentName() {
+    const candidates = [
+        process.env.CHAPTERHOUSE_SESSION_AGENT_NAME,
+        process.env.CHAPTERHOUSE_AGENT_NAME,
+        process.env.COPILOT_AGENT_NAME,
+        process.env.AGENT_NAME,
+    ];
+    return candidates.find((candidate) => candidate && candidate.trim().length > 0)?.trim() ?? "unknown";
+}
 //# sourceMappingURL=log-manager.js.map

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

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `wiki-log-${process.pid}`);
+const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+process.env.CHAPTERHOUSE_AGENT_NAME = "wiki-test-agent";
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const logManager = await import(new URL(`./log-manager.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { logManager, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("appendLog writes action entries to pages/_meta/log.md with the resolved agent name", async () => {
+    const { logManager, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    logManager.appendLog("update", "wiki_update: Chapterhouse (pages/shared/chapterhouse.md)");
+    assert.equal(existsSync(join(wikiDir, "pages", "_meta", "log.md")), true);
+    assert.match(wikiFs.readLogFile(), /^## \[\d{4}-\d{2}-\d{2} \d{2}:\d{2}\] update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| wiki-test-agent/m);
+});
+test("appendLog rotates the active log after 500 entries and keeps appending to a fresh log", async () => {
+    const { logManager, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writeLogFile("# Wiki Action Log\n\n" +
+        Array.from({ length: 500 }, (_, index) => `## [2026-01-01 00:00] update | historical entry ${index + 1} | wiki-test-agent\n\n`).join(""));
+    logManager.appendLog("update", "fresh entry after rotation");
+    const archiveYear = String(new Date().getFullYear());
+    const activeLog = wikiFs.readLogFile();
+    const archivedLog = wikiFs.readPage(`pages/_meta/log-${archiveYear}.md`);
+    assert.ok(archivedLog);
+    assert.match(archivedLog, /historical entry 1/);
+    assert.doesNotMatch(activeLog, /historical entry 1/);
+    assert.match(activeLog, /fresh entry after rotation/);
+});
+//# sourceMappingURL=log-manager.test.js.map

package/dist/wiki/taxonomy.js

@@ -0,0 +1,73 @@
+import { readPage } from "./fs.js";
+const ENGINEERING_TAGS = [
+    "engineering",
+    "architecture",
+    "release",
+    "runbook",
+    "incident",
+    "orchestration",
+];
+const PEOPLE_TAGS = [
+    "people",
+    "person",
+    "org",
+    "team",
+    "tool",
+];
+const PROCESS_TAGS = [
+    "process",
+    "project",
+    "topic",
+    "area",
+    "decision",
+    "preference",
+    "fact",
+    "routine",
+    "research",
+];
+const META_TAGS = [
+    "meta",
+    "index",
+    "source",
+    "taxonomy",
+    "autostub",
+];
+export const DEFAULT_TAGS = [
+    ...ENGINEERING_TAGS,
+    ...PEOPLE_TAGS,
+    ...PROCESS_TAGS,
+    ...META_TAGS,
+];
+export const TAXONOMY_PATH = "pages/_meta/taxonomy.md";
+export function parseTaxonomyTags(content) {
+    const tags = new Set();
+    let seenHeading = false;
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (/^##\s+.+/.test(line)) {
+            seenHeading = true;
+            continue;
+        }
+        const bulletMatch = line.match(/^-\s+([a-z0-9][a-z0-9-]*)$/i);
+        if (bulletMatch && seenHeading) {
+            tags.add(bulletMatch[1].toLowerCase());
+            continue;
+        }
+        throw new Error(`Invalid wiki taxonomy at ${TAXONOMY_PATH}: expected '## Group' headings with '- tag' bullets.`);
+    }
+    return [...tags];
+}
+export function loadTaxonomy() {
+    const tags = new Set(DEFAULT_TAGS);
+    const override = readPage(TAXONOMY_PATH);
+    if (!override) {
+        return [...tags].sort();
+    }
+    for (const tag of parseTaxonomyTags(override)) {
+        tags.add(tag);
+    }
+    return [...tags].sort();
+}
+//# sourceMappingURL=taxonomy.js.map

package/dist/wiki/taxonomy.test.js

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `wiki-taxonomy-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const taxonomy = await import(new URL(`./taxonomy.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { taxonomy, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("loadTaxonomy returns the default tags when no wiki taxonomy file exists", async () => {
+    const { taxonomy } = await loadModules();
+    const merged = taxonomy.loadTaxonomy();
+    assert.deepEqual(merged, [...taxonomy.DEFAULT_TAGS].sort());
+});
+test("loadTaxonomy merges pages/_meta/taxonomy.md entries with the defaults", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+- orchestration
+- release
+
+## Custom Group
+- teammate
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.includes("orchestration"), true);
+    assert.equal(merged.includes("release"), true);
+    assert.equal(merged.includes("teammate"), true);
+    assert.equal(merged.includes("engineering"), true);
+});
+test("loadTaxonomy deduplicates repeated tags across defaults and overrides", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+- engineering
+- release
+- release
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.filter((tag) => tag === "engineering").length, 1);
+    assert.equal(merged.filter((tag) => tag === "release").length, 1);
+});
+test("loadTaxonomy accepts arbitrary heading labels as grouping metadata", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Totally New Bucket
+- field-note
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.includes("field-note"), true);
+});
+test("loadTaxonomy rejects malformed taxonomy markdown clearly", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+not-a-bullet
+`);
+    assert.throws(() => taxonomy.loadTaxonomy(), /Invalid wiki taxonomy/i);
+});
+//# sourceMappingURL=taxonomy.test.js.map

package/dist/wiki/topic-structure.js

@@ -27,6 +27,9 @@ export const EXEMPT_PREFIXES = [
     "pages/kpis/",
     "pages/shared/",
 ];
+export const EXEMPT_PAGES = [
+    "pages/index.md",
+];
 /** Map a `remember`-style category name to its directory under pages/. */
 const CATEGORY_DIR_MAP = {
     person: "people",
@@ -65,7 +68,8 @@ function isFlatCategory(dir) {
     return FLAT_CATEGORIES.includes(dir);
 }
 function isExemptPath(relativePath) {
-    return EXEMPT_PREFIXES.some((p) => relativePath.startsWith(p));
+    return EXEMPT_PAGES.includes(relativePath)
+        || EXEMPT_PREFIXES.some((p) => relativePath.startsWith(p));
 }
 /** Slugify a free-text name into a wiki-safe path segment. */
 export function slugify(name) {

package/dist/wiki/topic-structure.test.js

@@ -25,6 +25,7 @@ test("topicPagePath builds canonical paths", () => {
     assert.equal(topicPagePath("tool", "Kubernetes"), "pages/tools/kubernetes/index.md");
 });
 test("validateTopicPath accepts canonical and exempt paths", () => {
+    assert.deepEqual(validateTopicPath("pages/index.md"), { ok: true });
     assert.deepEqual(validateTopicPath("pages/projects/chapterhouse/index.md"), { ok: true });
     assert.deepEqual(validateTopicPath("pages/projects/chapterhouse/decisions.md"), { ok: true });
     assert.deepEqual(validateTopicPath("pages/people/brian/index.md"), { ok: true });

package/package.json

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