@forwardimpact/libwiki 0.2.3 → 0.2.5

package/README.md

@@ -7,23 +7,148 @@ persists across sessions.
 
 <!-- END:description -->
 
-## Getting Started
+A wiki under `wiki/` holds each agent's running state: per-agent summaries,
+weekly logs, shared memory (priorities and active claims), and monthly
+storyboards. `libwiki` keeps that wiki coherent across sessions — agents boot
+from it, write decisions back, send memos to each other, and audit the
+result against a declarative rule set.
+
+The primary interface is the `fit-wiki` CLI. The library also exposes a few
+helpers for programmatic use.
+
+## Getting started
 
 ```sh
-npx fit-wiki memo --from staff-engineer --to security-engineer --message "audit d642ff0c"
-npx fit-wiki memo --from staff-engineer --to all --message "new XmR baseline"
+npx fit-wiki init
+npx fit-wiki boot --agent staff-engineer
+npx fit-wiki audit
 ```
 
-```js
-import { writeMemo, listAgents, insertMarkers } from "@forwardimpact/libwiki";
+## CLI
+
+Every command accepts `--wiki-root` (default `wiki/`) and `--today` (default
+today, ISO date). Agent commands take `--agent <name>` or read
+`LIBEVAL_AGENT_PROFILE` from the environment.
+
+### `boot` — start a session
+
+```sh
+npx fit-wiki boot --agent staff-engineer [--format json|markdown]
+```
+
+Print the on-boot digest for the agent: own priorities, cross-cutting
+priorities, active claims, storyboard items, inbox count.
+
+### `log` — record decisions, notes, done
+
+```sh
+npx fit-wiki log decision --agent X --surveyed "..." --chosen "..." --rationale "..."
+npx fit-wiki log note     --agent X --field "PR Status" --body "merged"
+npx fit-wiki log done     --agent X
+```
+
+Appends to `wiki/<agent>-YYYY-WVV.md`. Auto-rotates to `*-partN.md` when the
+line budget would be exceeded.
+
+### `claim` / `release` — coordinate work
+
+```sh
+npx fit-wiki claim   --agent X --target spec-1060 --branch claude/spec-1060
+npx fit-wiki release --agent X --target spec-1060
+npx fit-wiki release --agent X --expired
+```
+
+Maintains the `## Active Claims` table in `MEMORY.md`. Duplicates refused;
+row absent means settled.
+
+### `inbox` — triage memos
+
+```sh
+npx fit-wiki inbox list    --agent X
+npx fit-wiki inbox ack     --agent X --index 0
+npx fit-wiki inbox promote --agent X --index 0 [--owner X]
+npx fit-wiki inbox drop    --agent X --index 0
+```
+
+Reads bullets under the `<!-- memo:inbox -->` marker in the agent's summary.
+`promote` moves a bullet into the cross-cutting priorities table.
+
+### `memo` — cross-team coordination
+
+```sh
+npx fit-wiki memo --from X --to Y   --message "audit d642ff0c"
+npx fit-wiki memo --from X --to all --message "new XmR baseline"
+```
+
+Inserts a bullet `- YYYY-MM-DD from **X**: ...` after the recipient's
+`<!-- memo:inbox -->` marker.
+
+### `audit` — verify wiki state
+
+```sh
+npx fit-wiki audit [--format text|json]
+```
+
+Runs a declarative catalogue of rules across the wiki. Exits 0 on pass, 1
+on any failure. Text output: `WARN ...` and `FAIL ...` lines plus a
+`RESULT: ...` trailer. JSON output:
+
+```json
+{ "result": "pass|fail", "failures": [...], "warnings": [...] }
+```
+
+Each finding carries a stable `id` for filtering. The catalogue lives in
+`src/audit/rules.js` — adding a rule is one literal.
+
+### `rotate` — force a part split
+
+```sh
+npx fit-wiki rotate --agent X
+```
+
+Renames the current weekly log to the next `-partN.md` and starts a fresh
+main file.
+
+### `refresh` — re-render storyboard blocks
+
+```sh
+npx fit-wiki refresh [storyboard-path]
+```
+
+Re-renders `<!-- xmr:metric:csv-path -->` and `<!-- obstacles:open[:Nd] -->`
+marker blocks inside a storyboard from their backing CSV / GitHub state.
+Default path: `wiki/storyboard-YYYY-MMM.md` for the current month.
+
+### `init` / `push` / `pull` — wiki working tree
+
+```sh
+npx fit-wiki init [--wiki-root wiki] [--skills-dir .claude/skills]
+npx fit-wiki push
+npx fit-wiki pull
 ```
 
-## Key Exports
+`init` clones the wiki repo if missing, scaffolds Active Claims in
+`MEMORY.md`, and creates `wiki/metrics/<skill>/` directories. `push` and
+`pull` are thin wrappers over `git` with conflict handling.
+
+## Programmatic API
 
-- `writeMemo({ summaryPath, sender, message, today })` — append a timestamped
-  bullet after the `<!-- memo:inbox -->` marker in a wiki summary's
-  `## Message Inbox` section.
+```js
+import {
+  writeMemo, listAgents, insertMarkers, runAudit, RULES,
+} from "@forwardimpact/libwiki";
+```
+
+- `writeMemo({ summaryPath, sender, message, today })` — append a memo
+  bullet after the `<!-- memo:inbox -->` marker.
 - `listAgents({ agentsDir, wikiRoot })` — discover agents from
   `.claude/agents/*.md` and derive wiki summary paths.
-- `insertMarkers({ agentsDir, wikiRoot })` — idempotent insertion of the memo
-  marker into existing summaries.
+- `insertMarkers({ agentsDir, wikiRoot })` — idempotent insertion of the
+  memo marker into existing summaries.
+- `runAudit(rules, ctx)` — pure audit engine: `(rules, ctx) → findings[]`.
+- `RULES` — the audit rule catalogue (one literal per rule).
+
+## Documentation
+
+- [Operate a Predictable Agent Team](https://www.forwardimpact.team/docs/libraries/predictable-team/index.md)
+- [Send a Memo or Update a Storyboard](https://www.forwardimpact.team/docs/libraries/predictable-team/wiki-operations/index.md)

package/bin/fit-wiki.js

@@ -143,7 +143,7 @@ const definition = {
     {
       name: "audit",
       description:
-        "Audit the wiki against the memory-protocol contract (500-line cap; cutover 2026-W23)",
+        "Audit the wiki against the declarative rule catalogue (line and word budgets, headings, decision blocks, storyboards, claims)",
       options: {
         ...wikiRootOpt,
         ...todayOpt,
@@ -151,11 +151,6 @@ const definition = {
           type: "string",
           description: "Output format: text (default) or json",
         },
-        "legacy-only": {
-          type: "boolean",
-          description:
-            "Run only the checks the legacy wiki-audit.sh carried (parity mode)",
-        },
       },
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libwiki",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Wiki lifecycle primitives — stable memory for agent teams so coordination persists across sessions.",
   "keywords": [
     "wiki",

package/src/audit/engine.js

@@ -0,0 +1,36 @@
+import { resolveScope } from "./scopes.js";
+
+function groupByScope(rules) {
+  const groups = new Map();
+  for (const rule of rules) {
+    if (!groups.has(rule.scope)) groups.set(rule.scope, []);
+    groups.get(rule.scope).push(rule);
+  }
+  return groups;
+}
+
+function applyRule(rule, subject, ctx) {
+  if (rule.when && !rule.when(subject, ctx)) return [];
+  const result = rule.check(subject, ctx);
+  if (result == null) return [];
+  const items = Array.isArray(result) ? result : [result];
+  return items.map((item) => ({
+    id: rule.id,
+    level: rule.severity,
+    path: subject.path ?? null,
+    message: rule.message(subject, item, ctx),
+  }));
+}
+
+/** Apply the declarative rule catalogue to the wiki context. */
+export function runAudit(rules, ctx) {
+  const findings = [];
+  for (const [scopeKey, scopeRules] of groupByScope(rules)) {
+    for (const subject of resolveScope(scopeKey, ctx)) {
+      for (const rule of scopeRules) {
+        findings.push(...applyRule(rule, subject, ctx));
+      }
+    }
+  }
+  return findings;
+}

package/src/audit/format.js

@@ -0,0 +1,39 @@
+function partition(findings) {
+  const failures = [];
+  const warnings = [];
+  for (const f of findings) {
+    if (f.level === "warn") warnings.push(f);
+    else failures.push(f);
+  }
+  return { failures, warnings };
+}
+
+/** Render findings as `WARN`/`FAIL` lines followed by a `RESULT:` trailer. */
+export function emitText(findings) {
+  const { failures, warnings } = partition(findings);
+  const lines = [];
+  for (const w of warnings) lines.push(`WARN ${w.message}`);
+  for (const f of failures) lines.push(`FAIL ${f.message}`);
+  lines.push(
+    failures.length === 0
+      ? "RESULT: pass"
+      : `RESULT: fail (${failures.length} checks failed)`,
+  );
+  return lines.join("\n") + "\n";
+}
+
+/** Render findings as a JSON document. */
+export function emitJson(findings) {
+  const { failures, warnings } = partition(findings);
+  return (
+    JSON.stringify(
+      {
+        result: failures.length === 0 ? "pass" : "fail",
+        failures,
+        warnings,
+      },
+      null,
+      2,
+    ) + "\n"
+  );
+}

package/src/audit/rules.js

@@ -0,0 +1,459 @@
+import {
+  ACTIVE_CLAIMS_HEADING,
+  ACTIVE_CLAIMS_TABLE_HEADER,
+  DECISION_HEADING,
+  MEMO_INBOX_MARKER,
+  PRIORITY_INDEX_HEADING,
+  SUMMARY_LINE_BUDGET,
+  SUMMARY_WORD_BUDGET,
+  WEEKLY_LOG_LINE_BUDGET,
+  WEEKLY_LOG_WORD_BUDGET,
+} from "../constants.js";
+import { PRIORITY_HEADER_RE, WEEKLY_LOG_H1_RE } from "./scopes.js";
+
+const PRIORITY_INDEX_HEADING_RE = new RegExp(
+  `^${PRIORITY_INDEX_HEADING}$`,
+  "m",
+);
+const ACTIVE_CLAIMS_HEADING_RE = new RegExp(`^${ACTIVE_CLAIMS_HEADING}$`, "m");
+const PRIORITY_SEPARATOR_RE =
+  /^\|\s*---\s*\|\s*---\s*\|\s*---\s*\|\s*---\s*\|\s*---\s*\|/m;
+const CLAIMS_HEADER_RE =
+  /^\|\s*agent\s*\|\s*target\s*\|\s*branch\s*\|\s*pr\s*\|\s*claimed_at\s*\|\s*expires_at\s*\|/m;
+const CLAIMS_SEPARATOR_RE =
+  /^\|\s*---\s*\|\s*---\s*\|\s*---\s*\|\s*---\s*\|\s*---\s*\|\s*---\s*\|/m;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const XMR_OPEN_RE = /^<!--\s*xmr:([^:\s]+):([^\s]+)\s*-->\s*$/;
+const XMR_CLOSE_RE = /^<!--\s*\/xmr\s*-->\s*$/;
+const ISSUE_OPEN_RE =
+  /^<!--\s*(obstacles|experiments):(open|closed)(?::(\d+d))?\s*-->\s*$/;
+const ISSUE_CLOSE_RE = /^<!--\s*\/(obstacles|experiments)\s*-->\s*$/;
+
+// improvement-coach is the storyboard facilitator and carries no domain
+// metrics; only the five domain agents need their own H3.
+const STORYBOARD_DOMAIN_AGENTS = [
+  "product-manager",
+  "release-engineer",
+  "security-engineer",
+  "staff-engineer",
+  "technical-writer",
+];
+
+// -- Check builders: subject (+ ctx) → null | finding | finding[] --
+
+const matches = (pattern) => (s) => (pattern.test(s.text) ? null : {});
+const firstLineMatches = (pattern) => (s) =>
+  pattern.test(s.firstLine) ? null : {};
+const containsLine = (needle) => (s) =>
+  s.fileLines.some((l) => l.trim() === needle) ? null : {};
+
+const lineBudget = (limit) => (s) =>
+  s.lines > limit ? { value: s.lines } : null;
+const wordBudget = (limit) => (s) =>
+  s.words > limit ? { value: s.words } : null;
+
+const firstH2Is = (expected) => (s) =>
+  s.h2s.length === 0 || s.h2s[0] === expected ? null : { observed: s.h2s[0] };
+
+const nothingAfterH2 = (marker) => (s) => {
+  const idx = s.h2s.indexOf(marker);
+  if (idx === -1) return null;
+  const after = s.h2s.slice(idx + 1);
+  return after.length === 0 ? null : after.map((h) => ({ observed: h }));
+};
+
+const fieldMatches = (name, pattern) => (s) =>
+  pattern.test(s[name]) ? null : { value: s[name] };
+
+const columnCount = (expected) => (s) =>
+  s.cells.length === expected ? null : { actual: s.cells.length, expected };
+
+const exists = (s) => (s.exists ? null : {});
+const expired = (s, ctx) => (s.expires_at < ctx.today ? {} : null);
+const always = () => ({});
+
+function entryHasDecision(lines, startIdx, requiredLine, stopRe) {
+  let seen = 0;
+  for (let j = startIdx + 1; j < lines.length && seen < 5; j++) {
+    const ln = lines[j].trim();
+    if (ln === "") continue;
+    seen++;
+    if (ln === requiredLine) return true;
+    if (stopRe.test(lines[j])) return false;
+  }
+  return false;
+}
+
+const decisionWithin5 =
+  ({ entryRe, requiredLine, stopRe }) =>
+  (s) => {
+    const offenders = [];
+    for (let i = 0; i < s.fileLines.length; i++) {
+      if (
+        entryRe.test(s.fileLines[i]) &&
+        !entryHasDecision(s.fileLines, i, requiredLine, stopRe)
+      ) {
+        offenders.push({ lineNo: i + 1 });
+      }
+    }
+    return offenders.length === 0 ? null : offenders;
+  };
+
+function scanMarkers(fileLines, openRe, closeRe, label) {
+  const openings = [];
+  const findings = [];
+  for (let i = 0; i < fileLines.length; i++) {
+    const openMatch = fileLines[i].match(openRe);
+    if (openMatch) {
+      openings.push({ label: openMatch[1] || label, lineNo: i + 1 });
+    } else if (closeRe.test(fileLines[i])) {
+      if (openings.length > 0) openings.pop();
+      else findings.push({ lineNo: i + 1, reason: "unpaired-close" });
+    }
+  }
+  for (const open of openings) {
+    findings.push({
+      lineNo: open.lineNo,
+      reason: "dangling-open",
+      label: open.label,
+    });
+  }
+  return findings;
+}
+
+const markersBalanced =
+  ({ openRe, closeRe, label }) =>
+  (s) => {
+    const findings = scanMarkers(s.fileLines, openRe, closeRe, label);
+    return findings.length === 0 ? null : findings;
+  };
+
+const allRequiredLines = (required) => (s) => {
+  const findings = [];
+  for (const r of required) {
+    if (!s.fileLines.some((l) => r.pattern.test(l))) {
+      findings.push({ label: r.label });
+    }
+  }
+  return findings.length === 0 ? null : findings;
+};
+
+// -- H1 → filename agent prefix --
+
+const slugify = (title) =>
+  title
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)/g, "");
+
+const summaryAgentMismatch = (s) => {
+  const titleSlug = slugify(s.firstLine.match(/^# (.+) — Summary$/)[1]);
+  return titleSlug === s.agentPrefix ? null : { titleSlug };
+};
+
+const weeklyAgentMismatch = (s) => {
+  const m = s.firstLine.match(
+    /^# (.+) — \d{4}-W\d{2}(?: \(part \d+ of \d+\))?$/,
+  );
+  if (!m) return null;
+  const titleSlug = slugify(m[1]);
+  return titleSlug === s.agentPrefix ? null : { titleSlug };
+};
+
+const AGENT_H3_REQUIREMENTS = STORYBOARD_DOMAIN_AGENTS.map((agent) => ({
+  label: agent,
+  pattern: new RegExp(`^### ${agent}(\\s|$|—|-)`),
+}));
+
+const memoryExists = (s) => s.exists;
+const memoryHasPriorityHeader = (s) =>
+  s.exists && PRIORITY_HEADER_RE.test(s.text);
+const memoryHasClaimsHeading = (s) =>
+  s.exists && ACTIVE_CLAIMS_HEADING_RE.test(s.text);
+const memoryHasClaimsHeader = (s) => CLAIMS_HEADER_RE.test(s.text);
+const storyboardExists = (s) => s.exists;
+
+export const RULES = [
+  // -- Summary files --
+
+  {
+    id: "summary.last-run-marker",
+    scope: "summary",
+    severity: "fail",
+    check: matches(/^\*\*Last run\*\*:/m),
+    message: (s) => `sections: ${s.path} missing '**Last run**:' line`,
+  },
+  {
+    id: "summary.first-h2-inbox",
+    scope: "summary",
+    severity: "fail",
+    check: firstH2Is("Message Inbox"),
+    message: (s, r) =>
+      `sections: ${s.path} first H2 is '${r.observed}', expected 'Message Inbox'`,
+  },
+  {
+    id: "summary.memo-inbox-marker",
+    scope: "summary",
+    severity: "fail",
+    when: (s) => s.h2s.includes("Message Inbox"),
+    check: containsLine(MEMO_INBOX_MARKER),
+    message: (s) => `sections: ${s.path} missing <!-- memo:inbox --> marker`,
+  },
+  {
+    id: "summary.open-blockers-last",
+    scope: "summary",
+    severity: "fail",
+    check: nothingAfterH2("Open Blockers"),
+    message: (s, r) =>
+      `sections: ${s.path} '${r.observed}' appears after 'Open Blockers'`,
+  },
+  {
+    id: "summary.line-budget",
+    scope: "summary",
+    severity: "fail",
+    check: lineBudget(SUMMARY_LINE_BUDGET),
+    message: (s, r) =>
+      `budget: ${s.path} has ${r.value} lines (limit ${SUMMARY_LINE_BUDGET})`,
+  },
+  {
+    id: "summary.word-budget",
+    scope: "summary",
+    severity: "fail",
+    check: wordBudget(SUMMARY_WORD_BUDGET),
+    message: (s, r) =>
+      `budget: ${s.path} has ${r.value} words (limit ${SUMMARY_WORD_BUDGET})`,
+  },
+  {
+    id: "summary.h1-agent-matches-filename",
+    scope: "summary",
+    severity: "fail",
+    check: summaryAgentMismatch,
+    message: (s, r) =>
+      `sections: ${s.path} H1 title slug '${r.titleSlug}' does not match filename prefix '${s.agentPrefix}'`,
+  },
+
+  // -- Weekly logs (main) --
+
+  {
+    id: "weekly-log.h1-shape",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: firstLineMatches(WEEKLY_LOG_H1_RE),
+    message: (s) => `weekly-log: ${s.path} missing valid H1 heading`,
+  },
+  {
+    id: "weekly-log.line-budget",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
+    message: (s, r) =>
+      `weekly-log: ${s.path} has ${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
+  },
+  {
+    id: "weekly-log.word-budget",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
+    message: (s, r) =>
+      `weekly-log: ${s.path} has ${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
+  },
+  {
+    id: "weekly-log.h1-agent-matches-filename",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: weeklyAgentMismatch,
+    message: (s, r) =>
+      `weekly-log: ${s.path} H1 title slug '${r.titleSlug}' does not match filename prefix '${s.agentPrefix}'`,
+  },
+  {
+    id: "decision-block.heading-within-5",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: decisionWithin5({
+      entryRe: /^## \d{4}-\d{2}-\d{2}(?:[\s(].*)?$/,
+      requiredLine: DECISION_HEADING,
+      stopRe: /^##\s/,
+    }),
+    message: (s, r) =>
+      `decision-block: ${s.path}:${r.lineNo} entry lacks leading '### Decision'`,
+  },
+
+  // -- Weekly logs (sealed parts) --
+
+  {
+    id: "weekly-log-part.h1-shape",
+    scope: "weekly-log-part",
+    severity: "fail",
+    check: firstLineMatches(WEEKLY_LOG_H1_RE),
+    message: (s) => `weekly-log: ${s.path} missing valid H1 heading`,
+  },
+  {
+    id: "weekly-log-part.line-budget",
+    scope: "weekly-log-part",
+    severity: "fail",
+    check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
+    message: (s, r) =>
+      `weekly-log: ${s.path} has ${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
+  },
+  {
+    id: "weekly-log-part.word-budget",
+    scope: "weekly-log-part",
+    severity: "fail",
+    check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
+    message: (s, r) =>
+      `weekly-log: ${s.path} has ${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
+  },
+  {
+    id: "weekly-log-part.h1-agent-matches-filename",
+    scope: "weekly-log-part",
+    severity: "fail",
+    check: weeklyAgentMismatch,
+    message: (s, r) =>
+      `weekly-log: ${s.path} H1 title slug '${r.titleSlug}' does not match filename prefix '${s.agentPrefix}'`,
+  },
+
+  // -- MEMORY.md --
+
+  {
+    id: "memory.file-exists",
+    scope: "memory",
+    severity: "fail",
+    check: exists,
+    message: (s) => `memory: ${s.path} not found`,
+  },
+  {
+    id: "memory.priority-heading",
+    scope: "memory",
+    severity: "fail",
+    when: memoryExists,
+    check: matches(PRIORITY_INDEX_HEADING_RE),
+    message: () => `memory: missing '${PRIORITY_INDEX_HEADING}' heading`,
+  },
+  {
+    id: "memory.priority-table-header",
+    scope: "memory",
+    severity: "fail",
+    when: memoryExists,
+    check: matches(PRIORITY_HEADER_RE),
+    message: () => "memory: missing priority table header row",
+  },
+  {
+    id: "memory.priority-separator-row",
+    scope: "memory",
+    severity: "fail",
+    when: memoryHasPriorityHeader,
+    check: matches(PRIORITY_SEPARATOR_RE),
+    message: () =>
+      "memory: missing priority table separator row (| --- | --- | --- | --- | --- |)",
+  },
+  {
+    id: "memory.active-claims-table-header",
+    scope: "memory",
+    severity: "fail",
+    when: memoryHasClaimsHeading,
+    check: matches(CLAIMS_HEADER_RE),
+    message: () =>
+      `active-claims: header mismatch (expected ${ACTIVE_CLAIMS_TABLE_HEADER})`,
+  },
+  {
+    id: "memory.active-claims-separator-row",
+    scope: "memory",
+    severity: "fail",
+    when: memoryHasClaimsHeader,
+    check: matches(CLAIMS_SEPARATOR_RE),
+    message: () =>
+      "active-claims: missing separator row (| --- | --- | --- | --- | --- | --- |)",
+  },
+
+  // -- Table rows --
+
+  {
+    id: "priority-row.column-count",
+    scope: "priority-row",
+    severity: "fail",
+    check: columnCount(5),
+    message: (s, r) =>
+      `priority-row: row at line ${s.lineNo} has ${r.actual} cells (expected ${r.expected})`,
+  },
+  {
+    id: "claims-row.claimed-at-format",
+    scope: "claims-row",
+    severity: "fail",
+    check: fieldMatches("claimed_at", ISO_DATE_RE),
+    message: (s, r) =>
+      `active-claims: bad claimed_at '${r.value}' for ${s.agent}/${s.target}`,
+  },
+  {
+    id: "claims-row.expires-at-format",
+    scope: "claims-row",
+    severity: "fail",
+    check: fieldMatches("expires_at", ISO_DATE_RE),
+    message: (s, r) =>
+      `active-claims: bad expires_at '${r.value}' for ${s.agent}/${s.target}`,
+  },
+  {
+    id: "expired-claim",
+    scope: "claims-row",
+    severity: "warn",
+    check: expired,
+    message: (s) =>
+      `expired-claim: ${s.agent}/${s.target} expired ${s.expires_at}`,
+  },
+
+  // -- Storyboards --
+
+  {
+    id: "storyboard.current-month-exists",
+    scope: "storyboard",
+    severity: "fail",
+    check: exists,
+    message: (s) =>
+      `storyboard: ${s.path} (current month ${s.yearMonth}) not found`,
+  },
+  {
+    id: "storyboard.agent-h3-required",
+    scope: "storyboard",
+    severity: "fail",
+    when: storyboardExists,
+    check: allRequiredLines(AGENT_H3_REQUIREMENTS),
+    message: (s, r) => `storyboard: ${s.path} missing '### ${r.label}' H3`,
+  },
+  {
+    id: "storyboard.markers-balanced.xmr",
+    scope: "storyboard",
+    severity: "fail",
+    when: storyboardExists,
+    check: markersBalanced({
+      openRe: XMR_OPEN_RE,
+      closeRe: XMR_CLOSE_RE,
+      label: "xmr",
+    }),
+    message: (s, r) =>
+      `storyboard: ${s.path}:${r.lineNo} ${r.reason} xmr marker${r.label ? ` (${r.label})` : ""}`,
+  },
+  {
+    id: "storyboard.markers-balanced.issues",
+    scope: "storyboard",
+    severity: "fail",
+    when: storyboardExists,
+    check: markersBalanced({
+      openRe: ISSUE_OPEN_RE,
+      closeRe: ISSUE_CLOSE_RE,
+      label: "issue-list",
+    }),
+    message: (s, r) =>
+      `storyboard: ${s.path}:${r.lineNo} ${r.reason} issue-list marker${r.label ? ` (${r.label})` : ""}`,
+  },
+
+  // -- Stray files --
+
+  {
+    id: "wiki.stray-file",
+    scope: "stray-file",
+    severity: "fail",
+    check: always,
+    message: (s) =>
+      `stray-file: ${s.path} does not match any known scope (summary, weekly log, or excluded prefix)`,
+  },
+];

package/src/audit/scopes.js

@@ -0,0 +1,194 @@
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { parseClaims } from "../active-claims.js";
+import { PRIORITY_INDEX_HEADING } from "../constants.js";
+
+const SUMMARY_H1_RE = /^# [A-Z].* — Summary$/;
+const WEEKLY_LOG_NAME_RE = /^([a-z][a-z-]*)-(\d{4})-W(\d{2})\.md$/;
+const WEEKLY_LOG_PART_NAME_RE = /^([a-z][a-z-]*)-(\d{4})-W(\d{2})-part\d+\.md$/;
+export const WEEKLY_LOG_H1_RE =
+  /^# .* — \d{4}-W\d{2}(?: \(part \d+ of \d+\))?$/;
+export const PRIORITY_HEADER_RE =
+  /^\|\s*Item\s*\|\s*Agents\s*\|\s*Owner\s*\|\s*Status\s*\|\s*Added\s*\|/m;
+
+const EXCLUDED_BASES = new Set(["MEMORY.md", "Home.md", "STATUS.md"]);
+const NON_SUMMARY_PREFIXES = [
+  "storyboard-",
+  "downstream-",
+  "memory-protocol-",
+  "kata-interview-",
+  "fit-trace-",
+];
+
+function listMdFiles(wikiRoot) {
+  if (!existsSync(wikiRoot)) return [];
+  return readdirSync(wikiRoot)
+    .filter((e) => e.endsWith(".md"))
+    .map((e) => path.join(wikiRoot, e));
+}
+
+function countLines(text) {
+  return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
+
+function countWords(text) {
+  let count = 0;
+  let inWord = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const isWs = c === 32 || c === 9 || c === 10 || c === 13;
+    if (isWs) inWord = false;
+    else if (!inWord) {
+      inWord = true;
+      count++;
+    }
+  }
+  return count;
+}
+
+function loadFile(filePath) {
+  const text = readFileSync(filePath, "utf-8");
+  const fileLines = text.split("\n");
+  const h2s = [];
+  for (const line of fileLines) {
+    const m = line.match(/^## (.+)$/);
+    if (m) h2s.push(m[1].trim());
+  }
+  const base = path.basename(filePath);
+  const weekMatch =
+    base.match(WEEKLY_LOG_NAME_RE) || base.match(WEEKLY_LOG_PART_NAME_RE);
+  return {
+    path: filePath,
+    text,
+    fileLines,
+    firstLine: fileLines.find((l) => l.trim() !== "") || "",
+    h2s,
+    lines: countLines(text),
+    words: countWords(text),
+    agentPrefix: weekMatch ? weekMatch[1] : base.replace(/\.md$/, ""),
+  };
+}
+
+function classifyFile(filePath) {
+  const base = path.basename(filePath);
+  if (EXCLUDED_BASES.has(base)) return null;
+  if (NON_SUMMARY_PREFIXES.some((p) => base.startsWith(p))) return null;
+  if (WEEKLY_LOG_NAME_RE.test(base)) {
+    return { kind: "weekly-log-main", subject: loadFile(filePath) };
+  }
+  if (WEEKLY_LOG_PART_NAME_RE.test(base)) {
+    return { kind: "weekly-log-part", subject: loadFile(filePath) };
+  }
+  const subject = loadFile(filePath);
+  const kind = SUMMARY_H1_RE.test(subject.firstLine) ? "summary" : "stray";
+  return { kind, subject };
+}
+
+function loadMemory(wikiRoot) {
+  const filePath = path.join(wikiRoot, "MEMORY.md");
+  const exists = existsSync(filePath);
+  return {
+    path: filePath,
+    text: exists ? readFileSync(filePath, "utf-8") : "",
+    exists,
+  };
+}
+
+function loadStoryboard(wikiRoot, today) {
+  const date = new Date(today);
+  const yyyy = date.getUTCFullYear();
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const filePath = path.join(wikiRoot, `storyboard-${yyyy}-M${mm}.md`);
+  const exists = existsSync(filePath);
+  const text = exists ? readFileSync(filePath, "utf-8") : "";
+  return {
+    path: filePath,
+    text,
+    fileLines: text.split("\n"),
+    exists,
+    yearMonth: `${yyyy}-M${mm}`,
+  };
+}
+
+function priorityTableBounds(lines) {
+  const start = lines.findIndex((l) => l.trim() === PRIORITY_INDEX_HEADING);
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return { start, end };
+}
+
+function parseTableRow(line, lineNo) {
+  const cells = line
+    .split("|")
+    .slice(1, -1)
+    .map((c) => c.trim());
+  if (cells.length === 0 || cells[0] === "*None*") return null;
+  return { path: null, lineNo, cells };
+}
+
+function parsePriorityRows(memoryText) {
+  const lines = memoryText.split("\n");
+  const bounds = priorityTableBounds(lines);
+  if (bounds === null) return [];
+  const rows = [];
+  let inTable = false;
+  let seenSep = false;
+  for (let i = bounds.start + 1; i < bounds.end; i++) {
+    const line = lines[i];
+    if (PRIORITY_HEADER_RE.test(line)) {
+      inTable = true;
+    } else if (inTable && /^\|\s*---/.test(line)) {
+      seenSep = true;
+    } else if (inTable && seenSep && line.startsWith("|")) {
+      const row = parseTableRow(line, i + 1);
+      if (row) rows.push(row);
+    }
+  }
+  return rows;
+}
+
+const SCOPE_RESOLVERS = {
+  summary: (ctx) => ctx.subjects.summary,
+  "weekly-log-main": (ctx) => ctx.subjects["weekly-log-main"],
+  "weekly-log-part": (ctx) => ctx.subjects["weekly-log-part"],
+  memory: (ctx) => [ctx.memory],
+  "claims-row": (ctx) =>
+    parseClaims(ctx.memory.text).map((c) => ({ path: null, ...c })),
+  "priority-row": (ctx) => parsePriorityRows(ctx.memory.text),
+  storyboard: (ctx) => [ctx.storyboard],
+  "stray-file": (ctx) => ctx.subjects.stray,
+};
+
+/** Resolve a scope key into the list of subjects the engine should iterate. */
+export function resolveScope(scopeKey, ctx) {
+  const resolver = SCOPE_RESOLVERS[scopeKey];
+  if (!resolver) throw new Error(`unknown scope: ${scopeKey}`);
+  return resolver(ctx);
+}
+
+/** Build the audit context: classifies and loads every wiki file once. */
+export function buildContext({ wikiRoot, today }) {
+  const subjects = {
+    summary: [],
+    "weekly-log-main": [],
+    "weekly-log-part": [],
+    stray: [],
+  };
+  for (const file of listMdFiles(wikiRoot)) {
+    const classified = classifyFile(file);
+    if (classified) subjects[classified.kind].push(classified.subject);
+  }
+  return {
+    wikiRoot,
+    today,
+    subjects,
+    memory: loadMemory(wikiRoot),
+    storyboard: loadStoryboard(wikiRoot, today),
+  };
+}

package/src/commands/audit.js

@@ -1,354 +1,24 @@
-import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
 import fsAsync from "node:fs/promises";
 import path from "node:path";
 import { Finder } from "@forwardimpact/libutil";
-import {
-  ACTIVE_CLAIMS_HEADING,
-  ACTIVE_CLAIMS_TABLE_HEADER,
-  CUTOVER_ISO_WEEK,
-  DECISION_HEADING,
-  MEMO_INBOX_MARKER,
-  PRIORITY_INDEX_HEADING,
-  SUMMARY_LINE_BUDGET,
-  WEEKLY_LOG_LINE_BUDGET,
-} from "../constants.js";
-import { parseClaims, filterExpired } from "../active-claims.js";
-
-const SUMMARY_H1_RE = /^# [A-Z].* — Summary$/;
-const WEEKLY_LOG_NAME_RE = /^[a-z-]+-(\d{4})-W(\d{2})\.md$/;
-const WEEKLY_LOG_PART_NAME_RE = /^[a-z-]+-(\d{4})-W(\d{2})-part\d+\.md$/;
-const WEEKLY_LOG_H1_RE = /^# .* — \d{4}-W\d{2}(?: \(part \d+ of \d+\))?$/;
-const ENTRY_RE = /^## \d{4}-\d{2}-\d{2}(?:[\s(].*)?$/;
-
-const EXCLUDED_SUMMARY_BASES = new Set(["MEMORY.md", "Home.md", "STATUS.md"]);
-const NON_SUMMARY_PREFIXES = [
-  "storyboard-",
-  "downstream-",
-  "memory-protocol-",
-  "kata-interview-",
-  "fit-trace-",
-];
-
-function hasNonSummaryPrefix(base) {
-  return NON_SUMMARY_PREFIXES.some((p) => base.startsWith(p));
-}
-
-function isSummaryFile(wikiRoot, filePath) {
-  const rel = path.relative(wikiRoot, filePath);
-  if (rel.includes(path.sep) || !rel.endsWith(".md")) return false;
-  const base = path.basename(rel);
-  if (EXCLUDED_SUMMARY_BASES.has(base)) return false;
-  if (hasNonSummaryPrefix(base)) return false;
-  if (WEEKLY_LOG_NAME_RE.test(base) || WEEKLY_LOG_PART_NAME_RE.test(base)) {
-    return false;
-  }
-  try {
-    const text = readFileSync(filePath, "utf-8");
-    const firstLine = text.split("\n").find((l) => l.trim() !== "");
-    return Boolean(firstLine && SUMMARY_H1_RE.test(firstLine));
-  } catch {
-    return false;
-  }
-}
-
-function listMdFiles(wikiRoot) {
-  if (!existsSync(wikiRoot)) return [];
-  return readdirSync(wikiRoot)
-    .filter((e) => e.endsWith(".md"))
-    .map((e) => path.join(wikiRoot, e))
-    .filter((f) => {
-      try {
-        return statSync(f).isFile();
-      } catch {
-        return false;
-      }
-    });
-}
-
-function countLines(text) {
-  return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
-}
-
-function compareIsoWeek(a, b) {
-  return a.localeCompare(b);
-}
-
-function isoWeekForFile(base) {
-  const match =
-    base.match(WEEKLY_LOG_NAME_RE) || base.match(WEEKLY_LOG_PART_NAME_RE);
-  if (!match) return null;
-  return `${match[1]}-W${match[2]}`;
-}
-
-function pushFail(findings, level, message) {
-  findings.push({ level, message });
-}
-
-function inGraceWindow(graceUntil, today) {
-  return Boolean(graceUntil && graceUntil >= today);
-}
-
-function checkSummaryStructure(f, text, fileLines, h2s, findings) {
-  const firstLine = fileLines.find((l) => l.trim() !== "");
-  if (!firstLine || !SUMMARY_H1_RE.test(firstLine)) {
-    pushFail(findings, "fail", `sections: ${f} missing H1 '# ... — Summary'`);
-  }
-  if (!/^\*\*Last run\*\*:/m.test(text)) {
-    pushFail(findings, "fail", `sections: ${f} missing '**Last run**:' line`);
-  }
-  if (h2s.length > 0 && h2s[0] !== "Message Inbox") {
-    pushFail(
-      findings,
-      "fail",
-      `sections: ${f} first H2 is '${h2s[0]}', expected 'Message Inbox'`,
-    );
-  }
-  if (h2s.indexOf("Message Inbox") !== -1) {
-    const markerIdx = fileLines.findIndex(
-      (l) => l.trim() === MEMO_INBOX_MARKER,
-    );
-    if (markerIdx === -1) {
-      pushFail(
-        findings,
-        "fail",
-        `sections: ${f} missing <!-- memo:inbox --> marker`,
-      );
-    }
-  }
-}
-
-function checkSummaryOrdering(f, h2s, findings) {
-  let seenBlockers = false;
-  for (const h of h2s) {
-    if (h === "Open Blockers") {
-      seenBlockers = true;
-      continue;
-    }
-    if (seenBlockers) {
-      pushFail(
-        findings,
-        "fail",
-        `sections: ${f} '${h}' appears after 'Open Blockers'`,
-      );
-    }
-  }
-}
-
-function checkSummaryFile(f, findings, grace) {
-  const text = readFileSync(f, "utf-8");
-  const lines = countLines(text);
-  if (lines > SUMMARY_LINE_BUDGET) {
-    pushFail(
-      findings,
-      grace ? "warn" : "fail",
-      `budget: ${f} has ${lines} lines (limit ${SUMMARY_LINE_BUDGET})`,
-    );
-  }
-  const fileLines = text.split("\n");
-  const h2s = [];
-  for (const line of fileLines) {
-    const m = line.match(/^## (.+)$/);
-    if (m) h2s.push(m[1].trim());
-  }
-  checkSummaryStructure(f, text, fileLines, h2s, findings);
-  checkSummaryOrdering(f, h2s, findings);
-}
-
-function checkSummaries(wikiRoot, files, findings, options) {
-  const grace = inGraceWindow(options.graceUntil, options.today);
-  for (const f of files) {
-    if (!isSummaryFile(wikiRoot, f)) continue;
-    checkSummaryFile(f, findings, grace);
-  }
-}
-
-function entryHasDecision(allLines, startIdx) {
-  let nonBlankSeen = 0;
-  for (let j = startIdx + 1; j < allLines.length && nonBlankSeen < 5; j++) {
-    const ln = allLines[j];
-    if (ln.trim() === "") continue;
-    nonBlankSeen++;
-    if (ln.trim() === DECISION_HEADING) return true;
-    if (/^##\s/.test(ln)) return false;
-  }
-  return false;
-}
-
-function checkDecisionBlocks(f, text, findings, grace) {
-  const allLines = text.split("\n");
-  for (let i = 0; i < allLines.length; i++) {
-    if (!ENTRY_RE.test(allLines[i])) continue;
-    if (entryHasDecision(allLines, i)) continue;
-    pushFail(
-      findings,
-      grace ? "warn" : "fail",
-      `decision-block: ${f}:${i + 1} entry lacks leading '### Decision'`,
-    );
-  }
-}
-
-function checkWeeklyLogFile(f, base, findings, grace) {
-  const isMain = WEEKLY_LOG_NAME_RE.test(base);
-  const isPart = WEEKLY_LOG_PART_NAME_RE.test(base);
-  if (!isMain && !isPart) return;
-  const text = readFileSync(f, "utf-8");
-  const firstLine = text.split("\n").find((l) => l.trim() !== "");
-  if (!firstLine || !WEEKLY_LOG_H1_RE.test(firstLine)) {
-    pushFail(findings, "fail", `weekly-log: ${f} missing valid H1 heading`);
-  }
-  const week = isoWeekForFile(base);
-  const postCutover = week && compareIsoWeek(week, CUTOVER_ISO_WEEK) >= 0;
-  const lines = countLines(text);
-  if (postCutover && lines > WEEKLY_LOG_LINE_BUDGET) {
-    pushFail(
-      findings,
-      "fail",
-      `weekly-log: ${f} has ${lines} lines (limit ${WEEKLY_LOG_LINE_BUDGET}, post-cutover)`,
-    );
-  }
-  if (isMain && postCutover) {
-    checkDecisionBlocks(f, text, findings, grace);
-  }
-}
-
-function checkWeeklyLogs(_wikiRoot, files, findings, options) {
-  const grace = inGraceWindow(options.graceUntil, options.today);
-  for (const f of files) {
-    checkWeeklyLogFile(f, path.basename(f), findings, grace);
-  }
-}
-
-function checkPriorityIndex(wikiRoot, findings) {
-  const memPath = path.join(wikiRoot, "MEMORY.md");
-  if (!existsSync(memPath)) {
-    pushFail(findings, "fail", `memory: ${memPath} not found`);
-    return;
-  }
-  const text = readFileSync(memPath, "utf-8");
-  if (!new RegExp(`^${PRIORITY_INDEX_HEADING}$`, "m").test(text)) {
-    pushFail(
-      findings,
-      "fail",
-      "memory: missing '## Cross-Cutting Priorities' heading",
-    );
-  }
-  const headerRe =
-    /^\|\s*Item\s*\|\s*Agents\s*\|\s*Owner\s*\|\s*Status\s*\|\s*Added\s*\|/m;
-  if (!headerRe.test(text)) {
-    pushFail(findings, "fail", "memory: missing priority table header row");
-  }
-}
-
-function findActiveClaimsHeader(lines, headingIdx) {
-  for (let i = headingIdx + 1; i < lines.length; i++) {
-    if (/^## /.test(lines[i])) return -1;
-    if (lines[i].startsWith("|") && /agent/.test(lines[i])) return i;
-  }
-  return -1;
-}
-
-function checkActiveClaimsRows(claims, findings, today) {
-  for (const c of claims) {
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(c.expires_at)) {
-      pushFail(
-        findings,
-        "fail",
-        `active-claims: bad expires_at '${c.expires_at}' for ${c.agent}/${c.target}`,
-      );
-    }
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(c.claimed_at)) {
-      pushFail(
-        findings,
-        "fail",
-        `active-claims: bad claimed_at '${c.claimed_at}' for ${c.agent}/${c.target}`,
-      );
-    }
-  }
-  const { expired } = filterExpired(claims, today);
-  for (const c of expired) {
-    pushFail(
-      findings,
-      "warn",
-      `expired-claim: ${c.agent}/${c.target} expired ${c.expires_at}`,
-    );
-  }
-}
-
-function checkActiveClaims(wikiRoot, findings, options) {
-  const memPath = path.join(wikiRoot, "MEMORY.md");
-  if (!existsSync(memPath)) return;
-  const text = readFileSync(memPath, "utf-8");
-  if (!new RegExp(`^${ACTIVE_CLAIMS_HEADING}$`, "m").test(text)) return;
-  const lines = text.split("\n");
-  const headingIdx = lines.findIndex((l) => l.trim() === ACTIVE_CLAIMS_HEADING);
-  const headerIdx = findActiveClaimsHeader(lines, headingIdx);
-  if (
-    headerIdx === -1 ||
-    lines[headerIdx].trim() !== ACTIVE_CLAIMS_TABLE_HEADER
-  ) {
-    pushFail(
-      findings,
-      "fail",
-      `active-claims: header mismatch (expected ${ACTIVE_CLAIMS_TABLE_HEADER})`,
-    );
-  }
-  checkActiveClaimsRows(parseClaims(text), findings, options.today);
-}
-
-function emitText(failures, warnings) {
-  for (const w of warnings) process.stdout.write(`WARN ${w.message}\n`);
-  for (const f of failures) process.stdout.write(`FAIL ${f.message}\n`);
-  if (failures.length === 0) {
-    process.stdout.write("RESULT: pass\n");
-  } else {
-    process.stdout.write(`RESULT: fail (${failures.length} checks failed)\n`);
-  }
-}
-
-function emitJson(failures, warnings, graceUntil, today) {
-  process.stdout.write(
-    JSON.stringify(
-      {
-        result: failures.length === 0 ? "pass" : "fail",
-        failures,
-        warnings,
-        grace_active: inGraceWindow(graceUntil, today),
-        grace_until: graceUntil,
-      },
-      null,
-      2,
-    ) + "\n",
-  );
-}
+import { runAudit } from "../audit/engine.js";
+import { RULES } from "../audit/rules.js";
+import { buildContext } from "../audit/scopes.js";
+import { emitJson, emitText } from "../audit/format.js";
 
 /** Run the wiki audit and emit findings. JSON via --format json. */
 export function runAuditCommand(values, _args, _cli) {
-  const logger = { debug() {} };
-  const finder = new Finder(fsAsync, logger, process);
+  const finder = new Finder(fsAsync, { debug() {} }, process);
   const projectRoot = finder.findProjectRoot(process.cwd());
   const wikiRoot = values["wiki-root"] || path.join(projectRoot, "wiki");
   const today = values.today || new Date().toISOString().slice(0, 10);
-  const graceUntil = process.env.FIT_WIKI_AUDIT_GRACE_UNTIL || null;
-  const legacyOnly = !!values["legacy-only"];
-
-  const findings = [];
-  const files = listMdFiles(wikiRoot);
 
-  checkSummaries(wikiRoot, files, findings, { graceUntil, today });
-  checkWeeklyLogs(wikiRoot, files, findings, { graceUntil, today });
-  checkPriorityIndex(wikiRoot, findings);
-  if (!legacyOnly) {
-    checkActiveClaims(wikiRoot, findings, { today });
-  }
+  const ctx = buildContext({ wikiRoot, today });
+  const findings = runAudit(RULES, ctx);
 
-  const failures = findings.filter((f) => f.level === "fail");
-  const warnings = findings.filter((f) => f.level === "warn");
-
-  if ((values.format || "text") === "json") {
-    emitJson(failures, warnings, graceUntil, today);
-  } else {
-    emitText(failures, warnings);
-  }
+  process.stdout.write(
+    values.format === "json" ? emitJson(findings) : emitText(findings),
+  );
 
-  if (failures.length > 0) process.exit(1);
+  if (findings.some((f) => f.level === "fail")) process.exit(1);
 }

package/src/constants.js

@@ -14,8 +14,9 @@ export const PRIORITY_INDEX_TABLE_HEADER =
 export const DECISION_HEADING = "### Decision";
 
 // Cap derivation: ≤2.5% of a 1M-token context window = 25k tokens;
-// ≈42 tokens/line empirical proxy → ~500 lines. See spec 1060
-// design-a.md § Decision area 2 for the full anchor.
-export const WEEKLY_LOG_LINE_BUDGET = 500;
-export const SUMMARY_LINE_BUDGET = 80;
-export const CUTOVER_ISO_WEEK = "2026-W23";
+// converted via ≈42 tokens/line empirical proxy, then 64-aligned.
+// See spec 1060 design-a.md § Decision area 2 for the full anchor.
+export const WEEKLY_LOG_LINE_BUDGET = 496;
+export const SUMMARY_LINE_BUDGET = 72;
+export const WEEKLY_LOG_WORD_BUDGET = 6400;
+export const SUMMARY_WORD_BUDGET = 12800;

package/src/index.js

@@ -14,7 +14,8 @@ export {
   DECISION_HEADING,
   WEEKLY_LOG_LINE_BUDGET,
   SUMMARY_LINE_BUDGET,
-  CUTOVER_ISO_WEEK,
+  WEEKLY_LOG_WORD_BUDGET,
+  SUMMARY_WORD_BUDGET,
 } from "./constants.js";
 export { scanMarkers } from "./marker-scanner.js";
 export { renderBlock } from "./block-renderer.js";
@@ -34,3 +35,5 @@ export {
   appendEntry,
 } from "./weekly-log.js";
 export { buildDigest } from "./boot.js";
+export { runAudit } from "./audit/engine.js";
+export { RULES } from "./audit/rules.js";