chapterhouse 0.3.20 → 0.3.22

package/dist/store/db.js

@@ -37,6 +37,7 @@ export function getDb() {
         task_id TEXT PRIMARY KEY,
         agent_slug TEXT NOT NULL,
         description TEXT NOT NULL,
+        prompt TEXT,
         status TEXT NOT NULL DEFAULT 'running',
         result TEXT,
         origin_channel TEXT,
@@ -114,6 +115,9 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === 'source')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
         }
+        if (!taskCols.some((c) => c.name === "prompt")) {
+            db.exec(`ALTER TABLE agent_tasks ADD COLUMN prompt TEXT`);
+        }
         // agent_task_events: append-only per-task tool-call activity log for /workers streaming
         db.exec(`
       CREATE TABLE IF NOT EXISTS agent_task_events (

package/dist/store/db.test.js

@@ -86,6 +86,36 @@ test("getDb migrates legacy conversation_log tables to allow system messages", a
         dbModule.closeDb();
     }
 });
+test("getDb migrates legacy agent_tasks tables to add a nullable prompt column", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE agent_tasks (
+      task_id TEXT PRIMARY KEY,
+      agent_slug TEXT NOT NULL,
+      description TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'running',
+      result TEXT,
+      origin_channel TEXT,
+      started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      completed_at DATETIME
+    )
+  `);
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const cols = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
+        assert.ok(cols.some((col) => col.name === "prompt"), "agent_tasks.prompt column must be added by migration");
+        const longPrompt = "Investigate worker prompt capture.\n".repeat(30);
+        db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, prompt, status)
+       VALUES (?, ?, ?, ?, ?)`).run("task-prompt-001", "coder", "Investigate workers", longPrompt, "running");
+        const row = db.prepare(`SELECT prompt FROM agent_tasks WHERE task_id = ?`).get("task-prompt-001");
+        assert.equal(row.prompt, longPrompt, "prompt text should round-trip without truncation");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 test("getDb prunes oversized conversation logs on startup and during inserts", async () => {
     const seedDb = new Database(dbPath);
     seedDb.exec(`

package/dist/wiki/frontmatter.js

@@ -23,7 +23,7 @@ const KNOWN_WIKI_FRONTMATTER_FIELDS = new Set([
     "contradictions",
     "related",
 ]);
-const PROJECT_RULE_HARD_FIELDS = [
+export const PROJECT_RULE_HARD_FIELDS = [
     "auto_pr",
     "require_worktree",
     "pr_draft_default",

package/dist/wiki/lint.js

@@ -4,7 +4,7 @@ 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 { parseWikiFrontmatter, validateProjectRulesFrontmatter, validateWikiFrontmatter, } from "./frontmatter.js";
 import { ACTION_LOG_PATH } from "./log-manager.js";
 import { TAXONOMY_PATH, loadTaxonomy, parseTaxonomyTags } from "./taxonomy.js";
 const DEFAULT_STALE_OVERRIDES = {
@@ -96,15 +96,39 @@ export function lintWiki(options = {}) {
             });
         }
         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.",
-                });
+            const validationOptions = allowedTags.length > 0 ? { allowedTags } : undefined;
+            if (isProjectRulesPage(path)) {
+                const validation = validateProjectRulesFrontmatter(content, validationOptions);
+                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.",
+                    });
+                }
+                for (const warning of validation.warnings) {
+                    issues.push({
+                        rule: warning.rule,
+                        severity: "warning",
+                        path,
+                        message: warning.message,
+                        suggestion: "Remove the unknown key or add it to the project-rules schema before relying on it.",
+                    });
+                }
+            }
+            else {
+                const validation = validateWikiFrontmatter(content, validationOptions);
+                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)) {
@@ -377,6 +401,9 @@ function isDecisionMisfile(path) {
         return path.startsWith(expectedPrefix) && path.split("/").length === 4;
     });
 }
+function isProjectRulesPage(path) {
+    return /^pages\/projects\/[^/]+\/rules\.md$/.test(path);
+}
 function isSpecialMetaPage(path) {
     return SPECIAL_META_PAGE_RE.test(path);
 }

package/dist/wiki/lint.test.js

@@ -202,6 +202,78 @@ test("lintWiki exempts decision and conversation pages from staleness and exempt
     assert.equal(signatures.includes("heading-depth:pages/shared/autostub.md"), false);
     assert.equal(signatures.includes("page-size:pages/shared/autostub.md"), false);
 });
+test("lintWiki accepts valid project rules frontmatter on rules.md pages", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", wikiPage([
+        "title: Chapterhouse",
+        "summary: Project overview",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Chapterhouse\n\n## Overview\n\nProject overview body with enough content to stay out of the premature-page bucket."));
+    wikiFs.writePage("pages/projects/chapterhouse/rules.md", wikiPage([
+        "title: Project rules for chapterhouse",
+        "summary: Project-specific operating rules for Chapterhouse and delegated agents.",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+        "auto_pr: true",
+        "require_worktree: false",
+        "pr_draft_default: false",
+        "default_branch: main",
+        'commit_co_author: "Copilot <223556219+Copilot@users.noreply.github.com>"',
+        'test_command: "npm test"',
+        'build_command: "npm run build"',
+        'lint_command: "npm run lint"',
+        "require_clean_worktree: true",
+    ], "# Project rules\n\n## Soft Rules\n\n- Keep rules concise and operational.\n- Record workflow changes here when they become durable."));
+    const report = lint.lintWiki();
+    assert.equal(report.issues.some((issue) => issue.path === "pages/projects/chapterhouse/rules.md" && issue.rule === "frontmatter-shape"), false);
+    assert.equal(report.issues.some((issue) => issue.path === "pages/projects/chapterhouse/rules.md" && issue.rule === "unknown-project-rule-key"), false);
+});
+test("lintWiki reports invalid known project rule field types on rules.md pages", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", wikiPage([
+        "title: Chapterhouse",
+        "summary: Project overview",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Chapterhouse\n\n## Overview\n\nProject overview body with enough content to stay out of the premature-page bucket."));
+    wikiFs.writePage("pages/projects/chapterhouse/rules.md", wikiPage([
+        "title: Project rules for chapterhouse",
+        "summary: Project-specific operating rules for Chapterhouse and delegated agents.",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+        "auto_pr: [true]",
+    ], "# Project rules\n\n## Soft Rules\n\n- Keep rules concise and operational."));
+    const report = lint.lintWiki();
+    const issue = report.issues.find((candidate) => candidate.path === "pages/projects/chapterhouse/rules.md" && candidate.rule === "frontmatter-shape");
+    assert.ok(issue);
+    assert.equal(issue.severity, "error");
+    assert.match(issue.message, /invalid 'auto_pr' type/);
+});
+test("lintWiki warns on unknown project rule keys on rules.md pages", async () => {
+    const { lint, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", wikiPage([
+        "title: Chapterhouse",
+        "summary: Project overview",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+    ], "# Chapterhouse\n\n## Overview\n\nProject overview body with enough content to stay out of the premature-page bucket."));
+    wikiFs.writePage("pages/projects/chapterhouse/rules.md", wikiPage([
+        "title: Project rules for chapterhouse",
+        "summary: Project-specific operating rules for Chapterhouse and delegated agents.",
+        "updated: 2026-05-12",
+        "tags: [engineering]",
+        "mystery_setting: true",
+    ], "# Project rules\n\n## Soft Rules\n\n- Keep rules concise and operational."));
+    const report = lint.lintWiki();
+    assert.ok(report.issues.some((issue) => issue.rule === "unknown-project-rule-key" &&
+        issue.severity === "warning" &&
+        issue.path === "pages/projects/chapterhouse/rules.md" &&
+        issue.message.includes("mystery_setting")));
+});
 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([

package/dist/wiki/project-registry.js

@@ -0,0 +1,160 @@
+import { isAbsolute } from "node:path";
+import { readPage, writePage } from "./fs.js";
+const PROJECTS_INDEX_PATH = "pages/projects/index.md";
+const REGISTRY_HEADING = "## Project Registry";
+const OPENING_FENCE = "```yaml";
+const CLOSING_FENCE = "```";
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+export function loadRegistry() {
+    const content = readPage(PROJECTS_INDEX_PATH);
+    if (!content)
+        return {};
+    const section = parseRegistrySection(content);
+    if (!section)
+        return {};
+    return parseRegistryBlock(section.blockLines);
+}
+export function saveRegistry(registry) {
+    validateRegistry(registry);
+    const renderedSection = renderRegistrySection(registry);
+    const current = readPage(PROJECTS_INDEX_PATH);
+    if (!current) {
+        writePage(PROJECTS_INDEX_PATH, `${renderedSection}\n`);
+        return;
+    }
+    const section = parseRegistrySection(current);
+    if (!section) {
+        const trimmed = stripTrailingBlankLines(normalizeLineEndings(current));
+        const prefix = trimmed ? `${trimmed}\n\n` : "";
+        writePage(PROJECTS_INDEX_PATH, `${prefix}${renderedSection}\n`);
+        return;
+    }
+    const before = stripTrailingBlankLines(section.before.join("\n"));
+    const after = stripTrailingBlankLines(stripLeadingBlankLines(section.after).join("\n"));
+    const pieces = [];
+    if (before) {
+        pieces.push(before);
+        pieces.push("");
+    }
+    pieces.push(renderedSection);
+    if (after) {
+        pieces.push("");
+        pieces.push(after);
+    }
+    writePage(PROJECTS_INDEX_PATH, `${pieces.join("\n")}\n`);
+}
+function parseRegistrySection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split("\n");
+    const headingIndexes = lines
+        .map((line, index) => ({ line, index }))
+        .filter(({ line }) => line.trim() === REGISTRY_HEADING)
+        .map(({ index }) => index);
+    if (headingIndexes.length === 0)
+        return undefined;
+    if (headingIndexes.length > 1) {
+        throw new Error("Project registry is malformed: multiple registry sections found.");
+    }
+    const headingIndex = headingIndexes[0];
+    const nextHeadingIndex = findNextHeading(lines, headingIndex + 1);
+    const sectionEnd = nextHeadingIndex === -1 ? lines.length : nextHeadingIndex;
+    const sectionLines = lines.slice(headingIndex + 1, sectionEnd);
+    let cursor = 0;
+    while (cursor < sectionLines.length && sectionLines[cursor].trim() === "") {
+        cursor += 1;
+    }
+    if (cursor >= sectionLines.length || sectionLines[cursor].trim() !== OPENING_FENCE) {
+        throw new Error("Project registry is malformed: expected a ```yaml fenced block.");
+    }
+    cursor += 1;
+    const blockLines = [];
+    while (cursor < sectionLines.length && sectionLines[cursor].trim() !== CLOSING_FENCE) {
+        blockLines.push(sectionLines[cursor]);
+        cursor += 1;
+    }
+    if (cursor >= sectionLines.length) {
+        throw new Error("Project registry is malformed: missing closing ``` fence.");
+    }
+    cursor += 1;
+    for (; cursor < sectionLines.length; cursor += 1) {
+        if (sectionLines[cursor].trim() !== "") {
+            throw new Error("Project registry is malformed: unexpected content after the fenced block.");
+        }
+    }
+    return {
+        before: lines.slice(0, headingIndex),
+        blockLines,
+        after: lines.slice(sectionEnd),
+    };
+}
+function parseRegistryBlock(lines) {
+    const registry = {};
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0) {
+            throw new Error(`Project registry is malformed: malformed registry line '${rawLine}'.`);
+        }
+        const slug = line.slice(0, separatorIndex).trim();
+        const path = line.slice(separatorIndex + 1).trim();
+        assertValidProjectSlug(slug);
+        validatePath(path);
+        if (slug in registry) {
+            throw new Error(`Project registry is malformed: duplicate project slug '${slug}'.`);
+        }
+        registry[slug] = path;
+    }
+    return registry;
+}
+function validateRegistry(registry) {
+    for (const [slug, path] of Object.entries(registry)) {
+        assertValidProjectSlug(slug);
+        validatePath(path);
+    }
+}
+export function assertValidProjectSlug(slug) {
+    if (!SLUG_RE.test(slug)) {
+        throw new Error(`Project registry has invalid project slug '${slug}'. Expected a lowercase slug.`);
+    }
+}
+function validatePath(path) {
+    if (!path || !isAbsolute(path)) {
+        throw new Error(`Project registry path '${path}' must be an absolute path.`);
+    }
+}
+function renderRegistrySection(registry) {
+    const lines = [
+        REGISTRY_HEADING,
+        "",
+        OPENING_FENCE,
+        ...Object.keys(registry)
+            .sort()
+            .map((slug) => `${slug}: ${registry[slug]}`),
+        CLOSING_FENCE,
+    ];
+    return lines.join("\n");
+}
+function findNextHeading(lines, startIndex) {
+    for (let index = startIndex; index < lines.length; index += 1) {
+        if (/^##\s+/.test(lines[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n/g, "\n");
+}
+function stripTrailingBlankLines(content) {
+    return content.replace(/\n+$/g, "");
+}
+function stripLeadingBlankLines(lines) {
+    let start = 0;
+    while (start < lines.length && lines[start].trim() === "") {
+        start += 1;
+    }
+    return lines.slice(start);
+}
+//# sourceMappingURL=project-registry.js.map

package/dist/wiki/project-registry.test.js

@@ -0,0 +1,72 @@
+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-project-registry-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const projectRegistry = await import(new URL(`./project-registry.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { projectRegistry, 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("loadRegistry returns an empty object when pages/projects/index.md is absent", async () => {
+    const { projectRegistry } = await loadModules();
+    assert.deepEqual(projectRegistry.loadRegistry(), {});
+});
+test("loadRegistry returns an empty object when the projects page has no registry section", async () => {
+    const { projectRegistry, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Project pages live here.\nupdated: 2026-05-12\n---\n\n# Projects\n\nTracked project pages.\n");
+    assert.deepEqual(projectRegistry.loadRegistry(), {});
+});
+test("loadRegistry parses the fenced yaml registry block", async () => {
+    const { projectRegistry, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\n## Project Registry\n\n```yaml\nchapterhouse: /home/bjk/projects/chapterhouse\ndocs-site: /home/bjk/Documents/docs site\n```\n");
+    assert.deepEqual(projectRegistry.loadRegistry(), {
+        chapterhouse: "/home/bjk/projects/chapterhouse",
+        "docs-site": "/home/bjk/Documents/docs site",
+    });
+});
+test("loadRegistry rejects malformed registry content", async () => {
+    const { projectRegistry, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/index.md", "# Projects\n\n## Project Registry\n\n```yaml\nChapterHouse: /home/bjk/projects/chapterhouse\nrelative: ./docs-site\nbroken line\nchapterhouse: /home/bjk/projects/chapterhouse\n```\n");
+    assert.throws(() => projectRegistry.loadRegistry(), /invalid project slug|absolute path|malformed registry line|duplicate project slug/);
+});
+test("saveRegistry creates a new registry page with deterministic ordering", async () => {
+    const { projectRegistry, wikiFs } = await loadModules();
+    projectRegistry.saveRegistry({
+        "docs-site": "/home/bjk/projects/docs-site",
+        chapterhouse: "/home/bjk/projects/chapterhouse",
+    });
+    assert.equal(wikiFs.readPage("pages/projects/index.md"), "## Project Registry\n\n```yaml\nchapterhouse: /home/bjk/projects/chapterhouse\ndocs-site: /home/bjk/projects/docs-site\n```\n");
+});
+test("saveRegistry rewrites only the registry section and preserves surrounding content", async () => {
+    const { projectRegistry, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\nIntro paragraph.\n\n## Project Registry\n\n```yaml\nzeta: /srv/zeta\nalpha: /srv/alpha\n```\n\n## Notes\n\nKeep this section untouched.\n");
+    projectRegistry.saveRegistry({
+        beta: "/srv/beta",
+        alpha: "/srv/alpha",
+    });
+    assert.equal(wikiFs.readPage("pages/projects/index.md"), "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\nIntro paragraph.\n\n## Project Registry\n\n```yaml\nalpha: /srv/alpha\nbeta: /srv/beta\n```\n\n## Notes\n\nKeep this section untouched.\n");
+    assert.deepEqual(projectRegistry.loadRegistry(), {
+        alpha: "/srv/alpha",
+        beta: "/srv/beta",
+    });
+});
+test("saveRegistry rejects invalid slugs and non-absolute paths", async () => {
+    const { projectRegistry } = await loadModules();
+    assert.throws(() => projectRegistry.saveRegistry({ ChapterHouse: "/home/bjk/projects/chapterhouse" }), /invalid project slug/);
+    assert.throws(() => projectRegistry.saveRegistry({ chapterhouse: "./relative" }), /absolute path/);
+});
+//# sourceMappingURL=project-registry.test.js.map

package/dist/wiki/project-rules.js

@@ -0,0 +1,155 @@
+import { parseProjectRulesFrontmatter, parseWikiFrontmatter, PROJECT_RULE_HARD_FIELDS, validateProjectRulesFrontmatter, } from "./frontmatter.js";
+import { readPage, writePage } from "./fs.js";
+import { assertValidProjectSlug } from "./project-registry.js";
+export function getProjectRulesPath(slug) {
+    assertValidProjectSlug(slug);
+    return `pages/projects/${slug}/rules.md`;
+}
+export function renderInitialProjectRulesPage(slug, updatedAt = new Date()) {
+    assertValidProjectSlug(slug);
+    return [
+        "---",
+        `title: Project rules for ${slug}`,
+        "summary: Project-specific operating rules for Chapterhouse and delegated agents.",
+        `updated: ${updatedAt.toISOString().slice(0, 10)}`,
+        "tags: [engineering, workflow]",
+        "related: []",
+        "---",
+        "",
+        "## Soft Rules",
+    ].join("\n");
+}
+export function loadProjectRules(slug) {
+    const path = getProjectRulesPath(slug);
+    const content = readPage(path);
+    if (content === undefined) {
+        return {
+            found: false,
+            path,
+        };
+    }
+    const validation = validateProjectRulesFrontmatter(content);
+    if (!validation.valid) {
+        throw new Error(`Project rules page '${path}' is invalid: ${validation.errors.map((error) => error.message).join(" ")}`);
+    }
+    const { parsed, body, warnings } = parseProjectRulesFrontmatter(content);
+    return {
+        found: true,
+        path,
+        hard: parsed.hardRules,
+        soft: body,
+        warnings,
+        metadata: parsed.metadata,
+    };
+}
+export function saveProjectRulesHardFields(slug, hard) {
+    const path = getProjectRulesPath(slug);
+    const content = readPage(path);
+    if (content === undefined) {
+        throw new Error(`Project rules page '${path}' was not found.`);
+    }
+    const validation = validateProjectRulesFrontmatter(content);
+    if (!validation.valid) {
+        throw new Error(`Project rules page '${path}' is invalid: ${validation.errors.map((error) => error.message).join(" ")}`);
+    }
+    const { parsed, body } = parseWikiFrontmatter(content);
+    writePage(path, renderProjectRulesPage(parsed, hard, body));
+}
+export function saveProjectRulesSoftRules(slug, softRules) {
+    const path = getProjectRulesPath(slug);
+    const content = readPage(path);
+    if (content === undefined) {
+        throw new Error(`Project rules page '${path}' was not found.`);
+    }
+    const validation = validateProjectRulesFrontmatter(content);
+    if (!validation.valid) {
+        throw new Error(`Project rules page '${path}' is invalid: ${validation.errors.map((error) => error.message).join(" ")}`);
+    }
+    const { parsed } = parseProjectRulesFrontmatter(content);
+    writePage(path, renderProjectRulesPage(parsed, parsed.hardRules, renderSoftRulesBody(softRules)));
+}
+export function loadProjectRuleSummary(slug) {
+    const path = getProjectRulesPath(slug);
+    const content = readPage(path);
+    if (content === undefined) {
+        return {
+            slug,
+            path,
+            hardRuleCount: null,
+            softRuleCount: null,
+        };
+    }
+    const validation = validateProjectRulesFrontmatter(content);
+    if (!validation.valid) {
+        throw new Error(`Project rules page '${path}' is invalid: ${validation.errors.map((error) => error.message).join(" ")}`);
+    }
+    const { parsed, body } = parseWikiFrontmatter(content);
+    return {
+        slug,
+        path,
+        hardRuleCount: countExplicitHardRuleFields(parsed),
+        softRuleCount: listTopLevelSoftRules(body).length,
+    };
+}
+function countExplicitHardRuleFields(parsed) {
+    return PROJECT_RULE_HARD_FIELDS.filter((field) => Object.prototype.hasOwnProperty.call(parsed, field)).length;
+}
+export function listTopLevelSoftRules(body) {
+    return body
+        .split("\n")
+        .flatMap((line) => {
+        const match = /^[-*+]\s+(.+)$/.exec(line);
+        return match ? [match[1].trim()] : [];
+    });
+}
+function renderSoftRulesBody(softRules) {
+    if (softRules.length === 0) {
+        return "## Soft Rules";
+    }
+    return [
+        "## Soft Rules",
+        "",
+        ...softRules.map((rule) => `- ${rule}`),
+    ].join("\n");
+}
+function renderProjectRulesPage(frontmatter, hard, body) {
+    const lines = [
+        "---",
+        ...renderKnownFrontmatter(frontmatter),
+        ...PROJECT_RULE_HARD_FIELDS.map((field) => `${field}: ${renderFrontmatterValue(hard[field])}`),
+        ...Object.entries(frontmatter.metadata).map(([key, value]) => `${key}: ${renderFrontmatterValue(value)}`),
+        "---",
+        "",
+        body,
+    ];
+    return `${lines.join("\n").replace(/\n+$/g, "")}\n`;
+}
+function renderKnownFrontmatter(frontmatter) {
+    const rendered = [];
+    appendFrontmatterLine(rendered, "title", frontmatter.title);
+    appendFrontmatterLine(rendered, "summary", frontmatter.summary);
+    appendFrontmatterLine(rendered, "updated", frontmatter.updated);
+    appendFrontmatterLine(rendered, "tags", frontmatter.tags);
+    appendFrontmatterLine(rendered, "autostub", frontmatter.autostub);
+    appendFrontmatterLine(rendered, "confidence", frontmatter.confidence);
+    appendFrontmatterLine(rendered, "contested", frontmatter.contested);
+    appendFrontmatterLine(rendered, "contradictions", frontmatter.contradictions);
+    appendFrontmatterLine(rendered, "related", frontmatter.related);
+    return rendered;
+}
+function appendFrontmatterLine(lines, key, value) {
+    if (value === undefined) {
+        return;
+    }
+    lines.push(`${key}: ${renderFrontmatterValue(value)}`);
+}
+function renderFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        return `[${value.join(", ")}]`;
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    return value;
+}
+//# sourceMappingURL=project-rules.js.map