@forwardimpact/libwiki 0.2.24 → 0.2.26

package/src/audit/rules.js

@@ -13,6 +13,7 @@ import {
   SUMMARY_LINE_BUDGET,
   SUMMARY_WORD_BUDGET,
   WEEKLY_LOG_LINE_BUDGET,
+  WEEKLY_LOG_SEAM_RE,
   WEEKLY_LOG_WORD_BUDGET,
   XMR_CLOSE_RE,
   XMR_OPEN_RE,
@@ -22,6 +23,7 @@ import {
   SUMMARY_H1_RE,
   WEEKLY_LOG_H1_RE,
 } from "./scopes.js";
+import { CONFLICT_MARKER_RULE } from "./conflict-markers-rule.js";
 import { STATUS_ROW_RULES } from "./status-row.js";
 
 const PRIORITY_INDEX_HEADING_RE = new RegExp(
@@ -105,6 +107,22 @@ const decisionWithin5 =
     return offenders.length === 0 ? null : offenders;
   };
 
+// Flag entry-shaped `## ` headings that the rotation seam-finder would skip —
+// the grammar-drift that degrades a whole file to one unsplittable prologue and
+// is otherwise silent (the decision-block rule matches only dated headings).
+// Uses the same WEEKLY_LOG_SEAM_RE the seam-finder uses, so the flagged set is
+// exactly the complement of the rotatable set.
+const headingGrammarDrift = (s) => {
+  const offenders = [];
+  for (let i = 0; i < s.fileLines.length; i++) {
+    const line = s.fileLines[i];
+    if (/^## /.test(line) && !WEEKLY_LOG_SEAM_RE.test(line)) {
+      offenders.push({ lineNo: i + 1, observed: line.trim() });
+    }
+  }
+  return offenders.length === 0 ? null : offenders;
+};
+
 function scanMarkers(fileLines, openRe, closeRe, label) {
   const openings = [];
   const findings = [];
@@ -170,6 +188,25 @@ const AGENT_H3_REQUIREMENTS = STORYBOARD_DOMAIN_AGENTS.map((agent) => ({
   pattern: new RegExp(`^### ${agent}(\\s|$|—|-)`),
 }));
 
+// -- Metrics CSV duplicate rows --
+
+// Report every data line byte-identical to an earlier data line in the same
+// CSV. Line 1 is the header (positionally) and blank lines are skipped; the
+// header is never a duplicate subject. Keying on exact line equality gives the
+// spec's exit path for free: any column edit (run id or note) on one row makes
+// the pair non-identical and stops the finding firing.
+const duplicateCsvRows = (s) => {
+  const seen = new Set();
+  const findings = [];
+  s.rows.forEach((text, i) => {
+    const lineNo = i + 1;
+    if (lineNo === 1 || text.trim() === "") return;
+    if (seen.has(text)) findings.push({ lineNo });
+    else seen.add(text);
+  });
+  return findings.length === 0 ? null : findings;
+};
+
 const memoryExists = (s) => s.exists;
 const memoryHasPriorityHeader = (s) =>
   s.exists && PRIORITY_HEADER_RE.test(s.text);
@@ -257,7 +294,8 @@ export const RULES = [
     remediation: "rotate",
     check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
     message: (_s, r) => `${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
-    hint: "run `bunx fit-wiki rotate --agent <agent>` (agent = this filename's prefix) to seal this file as a sealed part and start a fresh weekly log",
+    hint: (s) =>
+      `run \`bunx fit-wiki rotate --agent ${s.agentPrefix}\` to seal this file as a sealed part and start a fresh weekly log`,
   },
   {
     id: "weekly-log.word-budget",
@@ -266,7 +304,8 @@ export const RULES = [
     remediation: "rotate",
     check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
     message: (_s, r) => `${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
-    hint: "run `bunx fit-wiki rotate --agent <agent>` (agent = this filename's prefix) to seal this file as a sealed part and start a fresh weekly log",
+    hint: (s) =>
+      `run \`bunx fit-wiki rotate --agent ${s.agentPrefix}\` to seal this file as a sealed part and start a fresh weekly log`,
   },
   {
     id: "weekly-log.h1-agent-matches-filename",
@@ -277,6 +316,15 @@ export const RULES = [
       `H1 title slug '${r.titleSlug}' does not match filename prefix '${s.agentPrefix}'`,
     hint: "rename either the H1 or the file so they agree",
   },
+  {
+    id: "weekly-log.heading-grammar",
+    scope: "weekly-log-main",
+    severity: "fail",
+    check: headingGrammarDrift,
+    message: (_s, r) =>
+      `Entry heading '${r.observed}' does not match the dated grammar`,
+    hint: "weekly-log entry headings must be '## YYYY-MM-DD'; open entries with `fit-wiki log decision/note`, which emit a conforming heading the rotation seam-finder can split",
+  },
   {
     id: "decision-block.heading-within-5",
     scope: "weekly-log-main",
@@ -290,7 +338,7 @@ export const RULES = [
       r.nearMiss
         ? `Entry opens with '${r.nearMiss}'; the heading must be exactly '${DECISION_HEADING}' — move the suffix into the body`
         : `Entry lacks a line that is exactly '${DECISION_HEADING}'`,
-    hint: `open each '## YYYY-MM-DD' entry with a line containing exactly '${DECISION_HEADING}' (no suffix — the check is an exact match); put the one-line summary in the body below it, drawn from the entry's own narrative — do not invent rationale the entry does not support`,
+    hint: `open each '## YYYY-MM-DD' entry with \`fit-wiki log decision\`, which emits a line containing exactly '${DECISION_HEADING}' (no suffix — the check is an exact match); put the one-line summary in the body below it, drawn from the entry's own narrative — do not invent rationale the entry does not support`,
   },
 
   // -- Weekly logs (sealed parts) --
@@ -303,6 +351,15 @@ export const RULES = [
     message: () => "Missing valid H1 heading",
     hint: "set the H1 to '# <agent> — YYYY-Www (part N of M)'",
   },
+  {
+    id: "weekly-log-part.heading-grammar",
+    scope: "weekly-log-part",
+    severity: "fail",
+    check: headingGrammarDrift,
+    message: (_s, r) =>
+      `Entry heading '${r.observed}' does not match the dated grammar`,
+    hint: "weekly-log entry headings must be '## YYYY-MM-DD'; open entries with `fit-wiki log decision/note`, which emit a conforming heading the rotation seam-finder can split",
+  },
   {
     id: "weekly-log-part.line-budget",
     scope: "weekly-log-part",
@@ -310,7 +367,7 @@ export const RULES = [
     remediation: "rotate",
     check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
     message: (_s, r) => `${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
-    hint: "`bunx fit-wiki fix` re-bisects an over-budget part with day-section seams; an irreducible single-day section that alone exceeds the budget must be split at a finer seam by hand",
+    hint: "`bunx fit-wiki fix` re-bisects an over-budget part at its day-section seams and, for a lone over-cap day, at its '### ' block seams; only a single '### ' block that alone exceeds the budget remains for a human to shorten",
   },
   {
     id: "weekly-log-part.word-budget",
@@ -319,7 +376,7 @@ export const RULES = [
     remediation: "rotate",
     check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
     message: (_s, r) => `${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
-    hint: "`bunx fit-wiki fix` re-bisects an over-budget part with day-section seams; an irreducible single-day section that alone exceeds the budget must be split at a finer seam by hand",
+    hint: "`bunx fit-wiki fix` re-bisects an over-budget part at its day-section seams and, for a lone over-cap day, at its '### ' block seams; only a single '### ' block that alone exceeds the budget remains for a human to shorten",
   },
   {
     id: "weekly-log-part.h1-agent-matches-filename",
@@ -488,7 +545,41 @@ export const RULES = [
     hint: "every '<!-- obstacles:* -->' or '<!-- experiments:* -->' needs a matching close marker",
   },
 
+  // -- Metrics CSVs (union merge keeps both sides on concurrent appends;
+  // exact-duplicate rows are surfaced here, never silently removed) --
+
+  {
+    id: "metrics-csv.duplicate-row",
+    scope: "metrics-csv",
+    severity: "fail",
+    check: duplicateCsvRows,
+    message: (_s, r) =>
+      `Duplicate metrics row at line ${r.lineNo} (exact match of an earlier row)`,
+    hint: "remove the surplus row, or differentiate a genuinely-distinct measurement by editing its run id or note so the rows are no longer identical",
+  },
+
   // -- STATUS.md rows (per-migration-unit sub-row schema) --
 
   ...STATUS_ROW_RULES,
+
+  // -- Conflict markers (structural; all audited surfaces) --
+
+  CONFLICT_MARKER_RULE,
+
+  // -- Filename admission --
+
+  // The `admission` resolver yields one subject per git-tracked path the
+  // filename grammar rejects, so the check always fires. Flag-for-human: a
+  // wrong automated move or delete destroys memory, so `fix` routes this to the
+  // human report (any non-`agent` remediation class does) and never touches the
+  // file.
+  {
+    id: "admission.not-in-grammar",
+    scope: "admission",
+    severity: "fail",
+    remediation: "flag",
+    check: () => ({}),
+    message: (s) => `${s.relPath} matches no wiki filename grammar class`,
+    hint: "rename to an admitted class, or extend the Wiki Filename Grammar section in memory-protocol.md and audit/grammar.js together (the single admission path)",
+  },
 ];

package/src/audit/scopes.js

@@ -7,6 +7,8 @@ import {
   WEEKLY_LOG_NAME_RE,
   WEEKLY_LOG_PART_NAME_RE,
 } from "../constants.js";
+import { listAdmissionPaths } from "./admission.js";
+import { classifyPath, rootSummaryStem } from "./grammar.js";
 
 // Capture the agent-title group so the same regex both classifies a file
 // (`.test`) and yields the title for the agent-prefix audit (`.match[1]`).
@@ -33,6 +35,34 @@ function listMdFiles(wikiRoot, fs) {
     .map((e) => path.join(wikiRoot, e));
 }
 
+// Recursively collect every *.csv under `<wikiRoot>/metrics/`. The real layout
+// is `metrics/<skill>/<year>.csv` (two levels), so the walk recurses rather
+// than assuming a fixed depth. Uses readdirSync + statSync (rather than
+// `withFileTypes` Dirents) so it runs unchanged under the in-memory mock fs.
+function listCsvFiles(wikiRoot, fs) {
+  const metricsRoot = path.join(wikiRoot, "metrics");
+  if (!fs.existsSync(metricsRoot)) return [];
+  const found = [];
+  const walk = (dir) => {
+    for (const name of fs.readdirSync(dir)) {
+      const full = path.join(dir, name);
+      if (fs.statSync(full).isDirectory()) walk(full);
+      else if (name.endsWith(".csv")) found.push(full);
+    }
+  };
+  walk(metricsRoot);
+  return found;
+}
+
+// Load a metrics CSV as an audit subject: `rows` is the array of line strings,
+// so a rule indexes `rows[i]` (a string) and `i + 1` is its line number.
+function loadCsv(filePath, fs) {
+  return {
+    path: filePath,
+    rows: fs.readFileSync(filePath, "utf-8").split("\n"),
+  };
+}
+
 function loadFile(filePath, fs) {
   const text = fs.readFileSync(filePath, "utf-8");
   const fileLines = text.split("\n");
@@ -177,6 +207,7 @@ 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"],
+  "metrics-csv": (ctx) => ctx.subjects["metrics-csv"],
   memory: (ctx) => [ctx.memory],
   "claims-row": (ctx) =>
     parseClaims(ctx.memory.text).map((c) => ({ ...c, path: ctx.memory.path })),
@@ -191,8 +222,54 @@ const SCOPE_RESOLVERS = {
       ...r,
       path: ctx.status.path,
     })),
+  "conflict-scan": (ctx) => conflictScanSubjects(ctx),
+  admission: (ctx) =>
+    ctx.admission.paths
+      .filter((p) => classifyPath(p, ctx.admission) === "rejected")
+      .map((relPath) => ({
+        path: path.join(ctx.wikiRoot, relPath),
+        relPath,
+      })),
 };
 
+// Normalize every audited surface into a uniform `{ path, text, fenceExempt }`
+// subject for the conflict-marker scan. The per-file subjects (summaries,
+// weekly logs and sealed parts, storyboard) carry `fileLines`; MEMORY.md and
+// STATUS.md carry `text` (readOptional shape). `fenceExempt` is true for prose
+// surfaces, where a fence quotes content, and false for STATUS.md, whose fenced
+// rows are data — a marker there is never legitimate (per-surface fence
+// contract). Files absent from disk (missing MEMORY/STATUS/storyboard) yield
+// empty text and produce no findings.
+function conflictScanSubjects(ctx) {
+  const subjects = [];
+  const fileScopes = ["summary", "weekly-log-main", "weekly-log-part"];
+  for (const scope of fileScopes) {
+    for (const s of ctx.subjects[scope]) {
+      subjects.push({
+        path: s.path,
+        text: s.fileLines.join("\n"),
+        fenceExempt: true,
+      });
+    }
+  }
+  subjects.push({
+    path: ctx.storyboard.path,
+    text: ctx.storyboard.text,
+    fenceExempt: true,
+  });
+  subjects.push({
+    path: ctx.memory.path,
+    text: ctx.memory.text,
+    fenceExempt: true,
+  });
+  subjects.push({
+    path: ctx.status.path,
+    text: ctx.status.text,
+    fenceExempt: false,
+  });
+  return subjects;
+}
+
 /** Resolve a scope key into the list of subjects the engine should iterate. */
 export function resolveScope(scopeKey, ctx) {
   const resolver = SCOPE_RESOLVERS[scopeKey];
@@ -200,21 +277,48 @@ export function resolveScope(scopeKey, ctx) {
   return resolver(ctx);
 }
 
+/**
+ * Build the admission slice: the tracked-file universe plus the
+ * `rootSummaryAgents` set that gates `<agent>/` sidecar directories. The agent
+ * set is derived first (a root-level summary-class file's stem) so the
+ * `admission` scope can classify sidecar directories against it.
+ *
+ * Returns the empty universe when `subprocess` is absent — callers that only
+ * read `.subjects` (the rotation pre-pass) skip the git read and the tree walk
+ * entirely, and produce no `admission` findings.
+ */
+function buildAdmission(wikiRoot, fs, subprocess) {
+  if (!subprocess) return { paths: [], rootSummaryAgents: new Set() };
+  const paths = listAdmissionPaths({ wikiRoot, fs, subprocess });
+  const rootSummaryAgents = new Set();
+  for (const p of paths) {
+    if (p.includes("/")) continue; // root-level files only
+    const stem = rootSummaryStem(p);
+    if (stem) rootSummaryAgents.add(stem);
+  }
+  return { paths, rootSummaryAgents };
+}
+
 /**
  * Build the audit context: classifies and loads every wiki file once.
- * @param {{wikiRoot: string, today: string, fs: object}} options
- *   `fs` is the sync filesystem surface (`runtime.fsSync`).
+ * @param {{wikiRoot: string, today: string, fs: object, subprocess: object}} options
+ *   `fs` is the sync filesystem surface (`runtime.fsSync`); `subprocess` is
+ *   `runtime.subprocess` (its `runSync` backs the admission scope's git read).
  */
-export function buildContext({ wikiRoot, today, fs }) {
+export function buildContext({ wikiRoot, today, fs, subprocess }) {
   const subjects = {
     summary: [],
     "weekly-log-main": [],
     "weekly-log-part": [],
+    "metrics-csv": [],
   };
   for (const file of listMdFiles(wikiRoot, fs)) {
     const classified = classifyFile(file, fs);
     if (classified) subjects[classified.kind].push(classified.subject);
   }
+  for (const file of listCsvFiles(wikiRoot, fs)) {
+    subjects["metrics-csv"].push(loadCsv(file, fs));
+  }
   return {
     wikiRoot,
     today,
@@ -222,5 +326,6 @@ export function buildContext({ wikiRoot, today, fs }) {
     memory: readOptional(path.join(wikiRoot, "MEMORY.md"), fs),
     status: readOptional(path.join(wikiRoot, "STATUS.md"), fs),
     storyboard: loadStoryboard(wikiRoot, today, fs),
+    admission: buildAdmission(wikiRoot, fs, subprocess),
   };
 }

package/src/block-renderer.js

@@ -13,10 +13,17 @@ export class BlockRenderError extends Error {
 /**
  * Render an XmR chart block for a metric by reading its CSV and producing
  * markdown lines.
- * @param {{metric: string, csvPath: string, projectRoot: string, fs: object}} options
- *   `fs` is the sync filesystem surface (`runtime.fsSync`).
+ * @param {{metric: string, csvPath: string, projectRoot: string, fs: object, priorReadAnchor?: string|null}} options
+ *   `fs` is the sync filesystem surface (`runtime.fsSync`). `priorReadAnchor`,
+ *   when supplied, stamps per-signal provenance surfaced in the Signals line.
  */
-export function renderBlock({ metric, csvPath, projectRoot, fs }) {
+export function renderBlock({
+  metric,
+  csvPath,
+  projectRoot,
+  fs,
+  priorReadAnchor,
+}) {
   const fullPath = path.resolve(projectRoot, csvPath);
   let csvText;
   try {
@@ -24,7 +31,7 @@ export function renderBlock({ metric, csvPath, projectRoot, fs }) {
   } catch {
     throw new BlockRenderError(`csv-not-found: ${csvPath}`);
   }
-  const report = analyze(csvText);
+  const report = analyze(csvText, { priorReadAnchor });
 
   const m = report.metrics.find((entry) => entry.metric === metric);
   if (!m) {
@@ -50,11 +57,18 @@ export function renderBlock({ metric, csvPath, projectRoot, fs }) {
   ];
 }
 
+// Annotate each fired rule with its records' provenance when present, so a
+// storyboard reader distinguishes recomputation-revealed signals from
+// new-point signals at the cell. Without a prior-read anchor, provenance is
+// absent and the line renders bare rule names exactly as before.
 function formatSignals(signals) {
   if (!signals) return "—";
   const fired = [];
   for (const rule of ["xRule1", "xRule2", "xRule3", "mrRule1"]) {
-    if (signals[rule]?.length > 0) fired.push(rule);
+    const recs = signals[rule];
+    if (!recs?.length) continue;
+    const tags = [...new Set(recs.map((r) => r.provenance).filter(Boolean))];
+    fired.push(tags.length ? `${rule} (${tags.join(", ")})` : rule);
   }
   return fired.length > 0 ? fired.join(", ") : "—";
 }

package/src/boot.js

@@ -1,7 +1,16 @@
 import path from "node:path";
 import { yearMonth } from "@forwardimpact/libutil";
 import { parseClaims, filterExpired } from "./active-claims.js";
-import { MEMO_INBOX_MARKER, PRIORITY_INDEX_HEADING } from "./constants.js";
+import { countLines, countWords } from "./budget.js";
+import {
+  MEMO_INBOX_MARKER,
+  PRIORITY_INDEX_HEADING,
+  SUMMARY_LINE_BUDGET,
+  SUMMARY_WORD_BUDGET,
+  WEEKLY_LOG_LINE_BUDGET,
+  WEEKLY_LOG_WORD_BUDGET,
+} from "./constants.js";
+import { weeklyLogPath } from "./weekly-log.js";
 
 function readIfExists(fs, filePath) {
   if (!fs.existsSync(filePath)) return null;
@@ -133,6 +142,24 @@ function countInbox(text) {
   return n;
 }
 
+/**
+ * Remaining budget for a budgeted surface: current value, cap, and headroom for
+ * both the line and word budget. An absent file (empty text) reports zero usage
+ * and full headroom so a writer sees the ceiling before composing.
+ */
+function headroom(text, lineCap, wordCap) {
+  const lines = countLines(text);
+  const words = countWords(text);
+  return {
+    words,
+    lines,
+    word_cap: wordCap,
+    line_cap: lineCap,
+    words_remaining: wordCap - words,
+    lines_remaining: lineCap - lines,
+  };
+}
+
 function mapPriority(r) {
   return { item: r.item, status: r.status, added: r.added, link: r.link };
 }
@@ -162,6 +189,7 @@ export function buildDigest({ wikiRoot, agent, today, fs }) {
   const summaryText = readIfExists(fs, summaryPath);
   const memoryText = readIfExists(fs, memoryPath);
   const storyboardText = readIfExists(fs, storyboardPath);
+  const weeklyLogText = readIfExists(fs, weeklyLogPath(wikiRoot, agent, today));
 
   const { active } = filterExpired(parseClaims(memoryText ?? ""), today);
   const { owned, cross } = splitPriorities(
@@ -176,6 +204,16 @@ export function buildDigest({ wikiRoot, agent, today, fs }) {
     claims: active.map(mapClaim),
     storyboard_items: parseStoryboardItems(storyboardText ?? "", agent),
     inbox_count: countInbox(summaryText),
+    summary_headroom: headroom(
+      summaryText ?? "",
+      SUMMARY_LINE_BUDGET,
+      SUMMARY_WORD_BUDGET,
+    ),
+    weekly_log_headroom: headroom(
+      weeklyLogText ?? "",
+      WEEKLY_LOG_LINE_BUDGET,
+      WEEKLY_LOG_WORD_BUDGET,
+    ),
     storyboard_path: fs.existsSync(storyboardPath)
       ? path.relative(path.dirname(wikiRoot) || ".", storyboardPath)
       : "",

package/src/cli-definition.js

@@ -11,18 +11,17 @@ import { runAuditCommand } from "./commands/audit.js";
 import { runFixCommand } from "./commands/fix.js";
 
 /**
- * Build the `fit-wiki` libcli definition. The agent/sender defaults read the
- * injected `env` rather than the ambient `process.env` so this module carries
- * no ambient dependency; the bin shim passes `runtime.proc.env`. The version is
- * resolved by libcli's `createCli` from the bin's `packageJsonUrl`. Each
- * subcommand carries a `handler` and (for subcommand-bearing commands)
- * `args`/`argsUsage` so `cli.dispatch` can route to the per-command handler
- * with a frozen `ctx`.
+ * Build the `fit-wiki` libcli definition. Agent identity is never resolved from
+ * the environment: agent-scoped subcommands require an explicit `--agent`
+ * (`--from` for `memo`) and fail closed without it, so this module carries no
+ * ambient agent identity. The version is resolved by libcli's `createCli` from
+ * the bin's `packageJsonUrl`. Each subcommand carries a `handler` and (for
+ * subcommand-bearing commands) `args`/`argsUsage` so `cli.dispatch` can route to
+ * the per-command handler with a frozen `ctx`.
  *
- * @param {Record<string, string>} env - The process env (`runtime.proc.env`).
  * @returns {object} The libcli definition.
  */
-export function createDefinition(env) {
+export function createDefinition() {
   const wikiRootOpt = {
     "wiki-root": {
       type: "string",
@@ -33,9 +32,7 @@ export function createDefinition(env) {
   const agentOpt = {
     agent: {
       type: "string",
-      description:
-        "Agent name (falls back to LIBEVAL_AGENT_PROFILE, then staff-engineer)",
-      default: env.LIBEVAL_AGENT_PROFILE || "staff-engineer",
+      description: "Agent name (required; no environment fallback)",
     },
   };
 
@@ -148,12 +145,17 @@ export function createDefinition(env) {
       },
       {
         name: "rotate",
-        description: "Force-rotate the current weekly log to a sealed part",
+        description: "Rotate the current weekly log to a sealed part",
         handler: runRotateCommand,
         options: {
           ...agentOpt,
           ...wikiRootOpt,
           ...todayOpt,
+          force: {
+            type: "boolean",
+            description:
+              "Seal even an under-budget log (the header-only floor still holds)",
+          },
         },
       },
       {
@@ -188,8 +190,7 @@ export function createDefinition(env) {
           from: {
             type: "string",
             description:
-              "Sender agent name (falls back to LIBEVAL_AGENT_PROFILE env var)",
-            default: env.LIBEVAL_AGENT_PROFILE,
+              "Sender agent name (required; no environment fallback)",
           },
           to: {
             type: "string",
@@ -239,7 +240,7 @@ export function createDefinition(env) {
         name: "pull",
         description: "Pull remote wiki changes into the local working tree",
         handler: runPullCommand,
-        options: { ...wikiRootOpt },
+        options: { ...agentOpt, ...wikiRootOpt, ...todayOpt },
       },
     ],
     globalOptions: {

package/src/commands/audit.js

@@ -17,7 +17,12 @@ export function runAuditCommand(ctx) {
   const wikiRoot = options["wiki-root"] || path.join(projectRoot, "wiki");
   const today = options.today || currentDayIso(runtime);
 
-  const auditCtx = buildContext({ wikiRoot, today, fs: runtime.fsSync });
+  const auditCtx = buildContext({
+    wikiRoot,
+    today,
+    fs: runtime.fsSync,
+    subprocess: runtime.subprocess,
+  });
   const findings = runRules(RULES, auditCtx, { resolveScope });
 
   runtime.proc.stdout.write(

package/src/commands/boot.js

@@ -1,5 +1,6 @@
 import { buildDigest } from "../boot.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveWikiRoot } from "../util/wiki-dir.js";
 
 function renderMarkdown(digest) {
@@ -43,8 +44,12 @@ function renderMarkdown(digest) {
 export function runBootCommand(ctx) {
   const { runtime } = ctx.deps;
   const options = ctx.options;
-  const agent =
-    options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE || "staff-engineer";
+  const resolved = requireAgentFlag(options, {
+    command: "boot",
+    example: "fit-wiki boot --agent staff-engineer",
+  });
+  if (!resolved.ok) return resolved;
+  const agent = resolved.agent;
 
   const wikiRoot = resolveWikiRoot(runtime, options);
   const today = options.today || currentDayIso(runtime);