chapterhouse 0.3.14 → 0.3.16

package/dist/wiki/lint.js

@@ -0,0 +1,424 @@
+import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { config } from "../config.js";
+import { WIKI_DIR } from "../paths.js";
+import { parseIndex } from "./index-manager.js";
+import { listPages, listSources, readPage } from "./fs.js";
+import { parseWikiFrontmatter, validateWikiFrontmatter } from "./frontmatter.js";
+import { ACTION_LOG_PATH } from "./log-manager.js";
+import { TAXONOMY_PATH, loadTaxonomy, parseTaxonomyTags } from "./taxonomy.js";
+const DEFAULT_STALE_OVERRIDES = {
+    decisions: "never",
+    "feature-ideas": 90,
+    conversations: "never",
+    default: 180,
+};
+const DEFAULT_OPTIONS = {
+    requireUpdated: true,
+    requireFrontmatter: true,
+    disallowSkippedHeadingLevels: true,
+    pageWarnLines: 300,
+    pageErrorLines: 800,
+    prematureBodyChars: 100,
+    autostubExtraLines: 10,
+    reportDeadTags: true,
+    surfaceContestedFirst: true,
+    staleOverrides: DEFAULT_STALE_OVERRIDES,
+};
+const SPECIAL_META_PAGE_RE = /^pages\/_meta\/(?:taxonomy|log(?:-\d{4})?)\.md$/;
+const LEGACY_DATE_STAMP_RE = /^(?:Logged|Updated):\s*\d{4}-\d{2}-\d{2}\b/m;
+export function lintWiki(options = {}) {
+    const staleOverrides = {
+        ...DEFAULT_STALE_OVERRIDES,
+        ...(options.staleOverrides ?? {}),
+    };
+    const resolved = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        staleOverrides,
+    };
+    const actionLogIssues = lintActionLog();
+    const indexEntries = parseIndex();
+    const pages = listPages().filter((path) => path !== ACTION_LOG_PATH).sort();
+    const sources = listSources();
+    const indexPaths = new Set(indexEntries.map((entry) => entry.path));
+    const issues = [...actionLogIssues];
+    let allowedTags = [];
+    try {
+        allowedTags = loadTaxonomy();
+    }
+    catch (error) {
+        issues.push({
+            rule: "frontmatter-shape",
+            severity: "error",
+            path: TAXONOMY_PATH,
+            message: error instanceof Error ? error.message : String(error),
+            suggestion: "Fix pages/_meta/taxonomy.md so it only contains '## Group' headings and '- tag' bullets.",
+        });
+    }
+    for (const path of pages.filter((page) => !indexPaths.has(page) && !isSpecialMetaPage(page))) {
+        issues.push({
+            rule: "orphan-page",
+            severity: "warning",
+            path,
+            message: "Page exists on disk but is missing from the wiki index.",
+            suggestion: "Rebuild the index or add the page entry explicitly.",
+        });
+    }
+    for (const entry of indexEntries.filter((candidate) => !readPage(candidate.path))) {
+        issues.push({
+            rule: "missing-page",
+            severity: "warning",
+            path: entry.path,
+            message: `Index entry points to a page that does not exist on disk: ${entry.title}`,
+            suggestion: "Delete the stale index entry or restore the page.",
+        });
+    }
+    issues.push(...lintIndexIntegrity(pages));
+    for (const path of pages) {
+        const content = readPage(path);
+        if (!content)
+            continue;
+        const { parsed, body } = parseWikiFrontmatter(content);
+        const autostub = parsed.autostub === true;
+        const specialMetaPage = isSpecialMetaPage(path);
+        if (resolved.surfaceContestedFirst && (parsed.contested === true || parsed.confidence === "low")) {
+            const state = parsed.contested === true && parsed.confidence === "low"
+                ? "contested and low confidence"
+                : parsed.contested === true
+                    ? "contested"
+                    : "low confidence";
+            issues.push({
+                rule: "contested-review",
+                severity: "info",
+                path,
+                message: `Page is marked ${state} and should be reviewed first.`,
+            });
+        }
+        if (resolved.requireFrontmatter && !specialMetaPage) {
+            const validation = validateWikiFrontmatter(content, allowedTags.length > 0 ? { allowedTags } : undefined);
+            if (!validation.valid) {
+                issues.push({
+                    rule: "frontmatter-shape",
+                    severity: "error",
+                    path,
+                    message: validation.errors.map((error) => error.message).join(" "),
+                    suggestion: "Rewrite the page frontmatter to match the canonical wiki shape before the next update.",
+                });
+            }
+        }
+        if (resolved.requireUpdated && !autostub && !specialMetaPage && !parsed.updated && !LEGACY_DATE_STAMP_RE.test(body)) {
+            issues.push({
+                rule: "missing-updated",
+                severity: "warning",
+                path,
+                message: "Page does not declare an updated date stamp.",
+                suggestion: "Add 'updated: YYYY-MM-DD' to the frontmatter.",
+            });
+        }
+        const staleThreshold = staleThresholdForPath(path, resolved.staleOverrides);
+        if (!autostub && staleThreshold !== "never" && isPageOlderThan(path, staleThreshold)) {
+            issues.push({
+                rule: "stale-page",
+                severity: "warning",
+                path,
+                message: `Page has not been touched in more than ${staleThreshold} days.`,
+                suggestion: "Refresh the page or archive it if the information is no longer active.",
+            });
+        }
+        if (!autostub && !specialMetaPage && resolved.disallowSkippedHeadingLevels) {
+            const headingIssue = lintHeadingDepth(path, body);
+            if (headingIssue)
+                issues.push(headingIssue);
+        }
+        if (isDecisionMisfile(path)) {
+            issues.push({
+                rule: "decision-misfile",
+                severity: "error",
+                path,
+                message: "decisions.md must live under an entity directory.",
+                suggestion: "Move this page to pages/<entity-category>/<topic>/decisions.md.",
+            });
+        }
+        if (!autostub && !specialMetaPage) {
+            const lineCount = content.split("\n").length;
+            if (lineCount > resolved.pageErrorLines) {
+                issues.push({
+                    rule: "page-size",
+                    severity: "error",
+                    path,
+                    message: `Page is ${lineCount} lines long, which exceeds the ${resolved.pageErrorLines}-line error threshold.`,
+                    suggestion: "Split the page into focused sub-pages or archive older material.",
+                });
+            }
+            else if (lineCount > resolved.pageWarnLines) {
+                issues.push({
+                    rule: "page-size",
+                    severity: "warning",
+                    path,
+                    message: `Page is ${lineCount} lines long, which exceeds the ${resolved.pageWarnLines}-line warning threshold.`,
+                    suggestion: "Consider splitting this page before it becomes unwieldy.",
+                });
+            }
+        }
+        if (!autostub && !specialMetaPage && bodyVisibleCharCount(body) <= resolved.prematureBodyChars) {
+            issues.push({
+                rule: "premature-page",
+                severity: "info",
+                path,
+                message: `Page body is too small to justify its own page (${bodyVisibleCharCount(body)} chars).`,
+                suggestion: "Fold the content into a parent page until there is enough material to stand alone.",
+            });
+        }
+        if (autostub && autostubExtraLines(body) > resolved.autostubExtraLines) {
+            issues.push({
+                rule: "autostub-not-flipped",
+                severity: "info",
+                path,
+                message: "Page has grown past stub size but still declares autostub: true.",
+                suggestion: "Remove autostub: true once the page becomes a real page.",
+            });
+        }
+    }
+    if (resolved.reportDeadTags) {
+        issues.push(...lintDeadTaxonomyEntries(pages));
+    }
+    return {
+        pageCount: pages.length,
+        sourceCount: sources.length,
+        issues: sortIssues(issues),
+    };
+}
+export function renderWikiLintReport(report) {
+    const sections = [
+        `Wiki health report (${report.pageCount} pages, ${report.sourceCount} sources):`,
+    ];
+    if (report.issues.length === 0) {
+        sections.push("\n✅ No issues found. Index and pages are in sync.");
+        sections.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.");
+        return sections.join("\n");
+    }
+    const contested = report.issues.filter((issue) => issue.rule === "contested-review");
+    const general = report.issues.filter((issue) => issue.rule !== "contested-review");
+    if (contested.length > 0) {
+        sections.push("\n**Review first**:");
+        for (const issue of contested) {
+            sections.push(formatIssueLine(issue));
+        }
+    }
+    if (general.length > 0) {
+        sections.push("\n**Issues**:");
+        for (const issue of general) {
+            sections.push(formatIssueLine(issue));
+        }
+    }
+    sections.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.");
+    return sections.join("\n");
+}
+function lintIndexIntegrity(pages) {
+    const issues = [];
+    const entityCategories = new Set(config.wikiEntityCategories);
+    const dirsWithFacets = new Set();
+    const dirsWithIndex = new Set();
+    for (const path of pages) {
+        const match = path.match(/^pages\/([^/]+)\/([^/]+)\/([^/]+)\.md$/);
+        if (!match)
+            continue;
+        const [, category, topic, page] = match;
+        if (!entityCategories.has(category))
+            continue;
+        const dirPath = `pages/${category}/${topic}`;
+        if (page === "index") {
+            dirsWithIndex.add(dirPath);
+        }
+        else {
+            dirsWithFacets.add(dirPath);
+        }
+    }
+    for (const dirPath of [...dirsWithFacets].sort()) {
+        if (!dirsWithIndex.has(dirPath)) {
+            issues.push({
+                rule: "index-integrity",
+                severity: "error",
+                path: dirPath,
+                message: "Entity directory has facet pages but no index.md overview page.",
+                suggestion: `Add ${dirPath}/index.md so the topic has a canonical overview page.`,
+            });
+        }
+    }
+    return issues;
+}
+function lintHeadingDepth(path, body) {
+    const headings = body
+        .split("\n")
+        .map((line) => line.match(/^(#{1,6})\s+(.+)$/))
+        .filter((match) => match !== null);
+    if (headings.length === 0)
+        return undefined;
+    const firstLevel = headings[0][1].length;
+    if (firstLevel !== 1) {
+        return {
+            rule: "heading-depth",
+            severity: "warning",
+            path,
+            message: "Page headings must start with a single '#' title heading.",
+            suggestion: "Start the page with '# Title' before any deeper sections.",
+        };
+    }
+    let previousLevel = firstLevel;
+    for (const heading of headings.slice(1)) {
+        const level = heading[1].length;
+        if (level > previousLevel + 1) {
+            return {
+                rule: "heading-depth",
+                severity: "warning",
+                path,
+                message: `Heading depth skips from h${previousLevel} to h${level}.`,
+                suggestion: "Add the missing intermediate heading level or flatten the structure.",
+            };
+        }
+        previousLevel = level;
+    }
+    return undefined;
+}
+function lintDeadTaxonomyEntries(pages) {
+    const taxonomyContent = readPage(TAXONOMY_PATH);
+    if (!taxonomyContent) {
+        return [];
+    }
+    let overrideTags;
+    try {
+        overrideTags = parseTaxonomyTags(taxonomyContent);
+    }
+    catch {
+        return [];
+    }
+    const usedTags = new Set();
+    for (const path of pages) {
+        const content = readPage(path);
+        if (!content)
+            continue;
+        const { parsed } = parseWikiFrontmatter(content);
+        for (const tag of parsed.tags ?? []) {
+            usedTags.add(tag.toLowerCase());
+        }
+    }
+    return overrideTags
+        .filter((tag) => !usedTags.has(tag.toLowerCase()))
+        .sort()
+        .map((tag) => ({
+        rule: "dead-taxonomy-entry",
+        severity: "info",
+        path: TAXONOMY_PATH,
+        message: `Tag '${tag}' is declared in the taxonomy but unused by any page.`,
+        suggestion: `Remove '${tag}' from pages/_meta/taxonomy.md or tag a page with it.`,
+    }));
+}
+function staleThresholdForPath(path, overrides) {
+    if (path.startsWith("pages/conversations/")) {
+        return overrides.conversations ?? "never";
+    }
+    if (path.endsWith("/decisions.md")) {
+        return overrides.decisions ?? "never";
+    }
+    if (path.endsWith("/feature-ideas.md")) {
+        return overrides["feature-ideas"] ?? 90;
+    }
+    return overrides.default ?? 180;
+}
+function isPageOlderThan(path, ageInDays) {
+    const stats = statSync(join(WIKI_DIR, path));
+    const ageMs = Date.now() - stats.mtime.getTime();
+    return ageMs > ageInDays * 24 * 60 * 60 * 1000;
+}
+function lintActionLog() {
+    const fullPath = join(WIKI_DIR, ACTION_LOG_PATH);
+    if (!existsSync(fullPath)) {
+        return [{
+                rule: "action-log",
+                severity: "error",
+                path: ACTION_LOG_PATH,
+                message: "The wiki action log is missing.",
+                suggestion: "Restore pages/_meta/log.md so wiki operations keep an append-only audit trail.",
+            }];
+    }
+    try {
+        const stats = statSync(fullPath);
+        if (!stats.isFile()) {
+            return [{
+                    rule: "action-log",
+                    severity: "error",
+                    path: ACTION_LOG_PATH,
+                    message: "The wiki action log path exists but is not a writable file.",
+                    suggestion: "Replace pages/_meta/log.md with a regular writable Markdown file.",
+                }];
+        }
+        accessSync(fullPath, fsConstants.W_OK);
+        return [];
+    }
+    catch (error) {
+        return [{
+                rule: "action-log",
+                severity: "error",
+                path: ACTION_LOG_PATH,
+                message: error instanceof Error
+                    ? `The wiki action log is not writable: ${error.message}`
+                    : "The wiki action log is not writable.",
+                suggestion: "Fix permissions on pages/_meta/log.md so wiki operations can append to it.",
+            }];
+    }
+}
+function isDecisionMisfile(path) {
+    if (!path.endsWith("/decisions.md")) {
+        return false;
+    }
+    return !config.wikiEntityCategories.some((category) => {
+        const expectedPrefix = `pages/${category}/`;
+        return path.startsWith(expectedPrefix) && path.split("/").length === 4;
+    });
+}
+function isSpecialMetaPage(path) {
+    return SPECIAL_META_PAGE_RE.test(path);
+}
+function bodyVisibleCharCount(body) {
+    const visible = body
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"))
+        .join(" ")
+        .trim();
+    return visible.length;
+}
+function autostubExtraLines(body) {
+    const meaningfulLines = body
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return Math.max(0, meaningfulLines.length - 1);
+}
+function sortIssues(issues) {
+    const severityRank = {
+        error: 0,
+        warning: 1,
+        info: 2,
+    };
+    return [...issues].sort((left, right) => {
+        if (left.rule === "contested-review" && right.rule !== "contested-review")
+            return -1;
+        if (right.rule === "contested-review" && left.rule !== "contested-review")
+            return 1;
+        const severityDelta = severityRank[left.severity] - severityRank[right.severity];
+        if (severityDelta !== 0)
+            return severityDelta;
+        const pathDelta = (left.path ?? "").localeCompare(right.path ?? "");
+        if (pathDelta !== 0)
+            return pathDelta;
+        return left.rule.localeCompare(right.rule);
+    });
+}
+function formatIssueLine(issue) {
+    const path = issue.path ?? "-";
+    const suggestion = issue.suggestion ? `\n  suggestion: ${issue.suggestion}` : "";
+    return `- ${issue.severity} | ${issue.rule} | ${path} | ${issue.message}${suggestion}`;
+}
+//# sourceMappingURL=lint.js.map

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