@forwardimpact/libwiki 0.2.25 → 0.2.27

package/src/commands/claim.js

@@ -8,7 +8,25 @@ import {
   filterExpired,
 } from "../active-claims.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveWikiRoot } from "../util/wiki-dir.js";
+import { refusalEnvelope } from "../secret-gate.js";
+import { AncestryRefusal } from "../wiki-sync.js";
+
+/** Non-zero envelope returned when the ancestry guard refused publication. */
+const NOT_PUBLISHED = {
+  ok: false,
+  code: 1,
+};
+
+/** Build the not-published refusal message for the given guard refusal. */
+function notPublishedMessage(err) {
+  return (
+    `${err.message}\n` +
+    "The row was written to MEMORY.md but is NOT published — it remains an " +
+    "uncommitted working-tree change.\n"
+  );
+}
 
 function readMemory(runtime, memPath) {
   if (!runtime.fsSync.existsSync(memPath)) return "";
@@ -19,20 +37,72 @@ function memoryPath(runtime, options) {
   return path.join(resolveWikiRoot(runtime, options), "MEMORY.md");
 }
 
-async function pushWiki(wikiSync, runtime, message) {
-  if (!wikiSync) return;
+/**
+ * Push the claim/release MEMORY.md change through the secret-gated push path
+ * and translate the result into a command envelope. A secret block fails the
+ * command closed (`{ ok: false, code: 1 }`) and names the finding or the
+ * scanner absence on stderr — distinct from a *network* push failure, which
+ * still degrades to "saved locally" and succeeds (`{ ok: true }`).
+ *
+ * The `reapply` closure re-derives this row against the fresh tip if the
+ * landing contends, so a parallel writer's row is never erased. An
+ * ancestry-guard refusal ({@link AncestryRefusal}) is rethrown so the caller's
+ * `pushRowOrRefuse` can map it to the not-published non-zero envelope; every
+ * other throw is a network/credential failure that degrades to "saved locally".
+ *
+ * @param {object} wikiSync - The WikiSync collaborator (may be absent in tests).
+ * @param {object} runtime - The runtime bag (for stdout/stderr).
+ * @param {string} message - The commit message.
+ * @param {(freshText: string) => string | null} [reapply] - Re-derives the row
+ *   against the fresh tip when the landing contends.
+ * @returns {Promise<{ok: boolean, code?: number}>}
+ */
+async function pushWiki(wikiSync, runtime, message, reapply) {
+  if (!wikiSync) return { ok: true };
+  let result;
   try {
     await wikiSync.inheritIdentity();
     // claim/release contract is a 1-line MEMORY.md change; the pathspec keeps
-    // foreign uncommitted files from parallel writers out of the commit.
-    const result = await wikiSync.commitAndPush(message, ["MEMORY.md"]);
-    if (result.pushed)
-      runtime.proc.stdout.write("push: committed and pushed\n");
+    // foreign uncommitted files from parallel writers out of the commit. The
+    // `reapply` closure re-derives this row against the fresh tip if the landing
+    // contends, so a parallel writer's row is never erased.
+    result = await wikiSync.commitAndPush(message, ["MEMORY.md"], { reapply });
   } catch (err) {
+    // An ancestry-guard refusal pierces the saved-locally degradation: it must
+    // reach a non-zero exit so the session stops rather than scroll past. Every
+    // other failure is a network/credential failure: preserve fire-and-forget
+    // "saved locally" — the change is on disk and the command still succeeds.
+    if (err instanceof AncestryRefusal) throw err;
     createLogger("wiki", runtime).warn(
       "claim",
       `push failed (saved locally): ${err.message}`,
     );
+    return { ok: true };
+  }
+  const refusal = refusalEnvelope(runtime, result);
+  if (refusal) return refusal;
+  if (result.pushed) runtime.proc.stdout.write("push: committed and pushed\n");
+  return { ok: true };
+}
+
+/**
+ * Push a written claim/release row, mapping an ancestry-guard refusal to the
+ * not-published non-zero envelope and any other outcome to `{ ok: true }`. The
+ * row is already written to MEMORY.md; on refusal it stays as an uncommitted
+ * working-tree change. The `reapply` closure re-derives the same row against
+ * the fresh tip when the landing contends.
+ */
+async function pushRowOrRefuse(wikiSync, runtime, message, reapply) {
+  try {
+    // Propagate pushWiki's envelope so a secret-gate refusal ({ ok: false })
+    // fails the command closed; a clean push returns { ok: true }.
+    return await pushWiki(wikiSync, runtime, message, reapply);
+  } catch (err) {
+    if (err instanceof AncestryRefusal) {
+      runtime.proc.stderr.write(notPublishedMessage(err));
+      return NOT_PUBLISHED;
+    }
+    throw err;
   }
 }
 
@@ -40,14 +110,13 @@ async function pushWiki(wikiSync, runtime, message) {
 export async function runClaimCommand(ctx) {
   const { runtime, wikiSync } = ctx.deps;
   const options = ctx.options;
-  const agent = options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
-  if (!agent) {
-    return {
-      ok: false,
-      code: 2,
-      error: "claim requires --agent or LIBEVAL_AGENT_PROFILE",
-    };
-  }
+  const resolved = requireAgentFlag(options, {
+    command: "claim",
+    example:
+      "fit-wiki claim --agent staff-engineer --target spec-NNNN --branch claude/...",
+  });
+  if (!resolved.ok) return resolved;
+  const agent = resolved.agent;
   if (!options.target || !options.branch) {
     return {
       ok: false,
@@ -59,14 +128,15 @@ export async function runClaimCommand(ctx) {
   const expires = options["expires-at"] || addDays(today, 7);
   const memPath = memoryPath(runtime, options);
   const text = readMemory(runtime, memPath);
-  const result = appendClaim(text, {
+  const claim = {
     agent,
     target: options.target,
     branch: options.branch,
     pr: options.pr || null,
     claimed_at: today,
     expires_at: expires,
-  });
+  };
+  const result = appendClaim(text, claim);
   if (!result.inserted) {
     createLogger("wiki", runtime).warn(
       "claim",
@@ -76,8 +146,17 @@ export async function runClaimCommand(ctx) {
   }
   runtime.fsSync.writeFileSync(memPath, result.text);
   runtime.proc.stdout.write(`claimed ${options.target} (expires ${expires})\n`);
-  await pushWiki(wikiSync, runtime, `wiki: claim ${options.target}`);
-  return { ok: true };
+  // Re-apply the same append against the fresh tip if the landing contends.
+  const reapply = (fresh) => {
+    const r = appendClaim(fresh, claim);
+    return r.inserted ? r.text : null;
+  };
+  return pushRowOrRefuse(
+    wikiSync,
+    runtime,
+    `wiki: claim ${options.target}`,
+    reapply,
+  );
 }
 
 /** Remove a claim row. `--expired` cleans every row past expires_at. */
@@ -102,18 +181,35 @@ export async function runReleaseCommand(ctx) {
     }
     runtime.fsSync.writeFileSync(memPath, current);
     runtime.proc.stdout.write(`released ${count} expired claim(s)\n`);
-    await pushWiki(wikiSync, runtime, "wiki: release expired claims");
-    return { ok: true };
-  }
-
-  const agent = options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
-  if (!agent) {
-    return {
-      ok: false,
-      code: 2,
-      error: "release requires --agent or --expired",
+    // Re-derive expiry against the fresh tip so a renewal landed since the stale
+    // read survives; only still-expired rows are removed.
+    const reapply = (fresh) => {
+      const freshExpired = filterExpired(parseClaims(fresh), today).expired;
+      let next = fresh;
+      let anyRemoved = false;
+      for (const c of freshExpired) {
+        const r = removeClaim(next, { agent: c.agent, target: c.target });
+        if (r.removed) {
+          next = r.text;
+          anyRemoved = true;
+        }
+      }
+      return anyRemoved ? next : null;
     };
+    return pushRowOrRefuse(
+      wikiSync,
+      runtime,
+      "wiki: release expired claims",
+      reapply,
+    );
   }
+
+  const resolved = requireAgentFlag(options, {
+    command: "release",
+    example: "fit-wiki release --agent staff-engineer --target spec-NNNN",
+  });
+  if (!resolved.ok) return resolved;
+  const agent = resolved.agent;
   if (!options.target) {
     return {
       ok: false,
@@ -127,9 +223,19 @@ export async function runReleaseCommand(ctx) {
     runtime.proc.stdout.write(
       `no matching claim for ${agent}/${options.target}\n`,
     );
-  } else {
-    runtime.proc.stdout.write(`released ${options.target}\n`);
-    await pushWiki(wikiSync, runtime, `wiki: release ${options.target}`);
+    return { ok: true };
   }
-  return { ok: true };
+  runtime.proc.stdout.write(`released ${options.target}\n`);
+  // Re-apply the same removal against the fresh tip if the landing contends;
+  // re-removing an absent row is a no-op, so a re-release never resurrects it.
+  const reapply = (fresh) => {
+    const r = removeClaim(fresh, { agent, target: options.target });
+    return r.removed ? r.text : null;
+  };
+  return pushRowOrRefuse(
+    wikiSync,
+    runtime,
+    `wiki: release ${options.target}`,
+    reapply,
+  );
 }

package/src/commands/fix.js

@@ -38,14 +38,18 @@ function classOf(finding) {
  * Handing the agent the full contract for the files it edits — not just the
  * failing rules — stops it fixing one finding by breaking another (dropping
  * the `**Last run**:` line, appending a section after `## Open Blockers`, …).
+ *
+ * Only static-string hints are listed: a function hint is a per-finding
+ * resolved command (a `rotate` remediation the agent never performs), not a
+ * file invariant, so listing it would leak its source text into the prompt.
  */
 function invariantContract(findings) {
   const scopes = new Set(
     findings.map((f) => RULES.find((r) => r.id === f.id)?.scope),
   );
-  return RULES.filter((r) => scopes.has(r.scope) && r.hint).map(
-    (r) => `- ${r.id} — ${r.hint}`,
-  );
+  return RULES.filter(
+    (r) => scopes.has(r.scope) && typeof r.hint === "string",
+  ).map((r) => `- ${r.id} — ${r.hint}`);
 }
 
 /**
@@ -106,7 +110,7 @@ function sealMainLog(agent, { wikiRoot, today, projectRoot, fs, out, err }) {
       wikiRoot,
       agent,
       today,
-      0,
+      { lines: 0, words: 0 },
       { force: true },
       fs,
     );
@@ -282,7 +286,11 @@ export async function runFixCommand(ctx) {
 
   // The agent's edits change the result, so re-read and re-audit each round.
   const audit = () =>
-    runRules(RULES, buildContext({ wikiRoot, today, fs }), { resolveScope });
+    runRules(
+      RULES,
+      buildContext({ wikiRoot, today, fs, subprocess: runtime.subprocess }),
+      { resolveScope },
+    );
   // The agent only ever gets prose-judgment (`agent`-class) findings. A
   // `rotate` finding that survived the pre-pass (e.g. a prior-week log) is
   // unfixable by the agent — and trimming append-only history to satisfy a

package/src/commands/inbox.js

@@ -6,18 +6,17 @@ import {
   PRIORITY_INDEX_TABLE_HEADER,
 } from "../constants.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveWikiRoot } from "../util/wiki-dir.js";
 
 function paths(runtime, options) {
   const wikiRoot = resolveWikiRoot(runtime, options);
-  const agent = options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
-  if (!agent) {
-    createLogger("wiki", runtime).warn(
-      "inbox",
-      "inbox requires --agent or LIBEVAL_AGENT_PROFILE",
-    );
-    return { error: { ok: false, code: 2 } };
-  }
+  const resolved = requireAgentFlag(options, {
+    command: "inbox",
+    example: "fit-wiki inbox list --agent staff-engineer",
+  });
+  if (!resolved.ok) return { error: resolved };
+  const agent = resolved.agent;
   return {
     summaryPath: path.join(wikiRoot, `${agent}.md`),
     memoryPath: path.join(wikiRoot, "MEMORY.md"),

package/src/commands/init.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { createLogger } from "@forwardimpact/libtelemetry";
+import { ensureMetricsCsvMergeAttribute } from "../gitattributes.js";
 import { listSkills } from "../skill-roster.js";
 import { resolveProjectRoot, resolveWikiRoot } from "../util/wiki-dir.js";
 import {
@@ -100,6 +101,11 @@ export async function runInitCommand(ctx) {
         `init: scaffolded ${ACTIVE_CLAIMS_HEADING} in ${memoryPath}\n`,
       );
     }
+    if (ensureMetricsCsvMergeAttribute(wikiDir, runtime.fsSync).changed) {
+      runtime.proc.stdout.write(
+        "init: declared metrics-CSV union merge in .gitattributes\n",
+      );
+    }
   }
 
   runtime.proc.stdout.write(`init: wiki ready at ${wikiDir}\n`);

package/src/commands/log.js

@@ -4,28 +4,33 @@ import {
   rotateIfOverBudget,
   appendEntry,
 } from "../weekly-log.js";
-import { DECISION_HEADING } from "../constants.js";
+import {
+  DECISION_HEADING,
+  WEEKLY_LOG_LINE_BUDGET,
+  WEEKLY_LOG_SEAM_RE,
+  WEEKLY_LOG_WORD_BUDGET,
+} from "../constants.js";
+import { countLines, countWords } from "../budget.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveWikiRoot } from "../util/wiki-dir.js";
 
 function commonContext(runtime, options) {
-  const agent = options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
-  if (!agent) {
-    createLogger("wiki", runtime).warn(
-      "log",
-      "log requires --agent <name> or LIBEVAL_AGENT_PROFILE env var",
-    );
-    return { error: { ok: false, code: 2 } };
-  }
+  const resolved = requireAgentFlag(options, {
+    command: "log",
+    example:
+      'fit-wiki log decision --agent staff-engineer --chosen "..." --rationale "..."',
+  });
+  if (!resolved.ok) return { error: resolved };
   const wikiRoot = resolveWikiRoot(runtime, options);
   const today = options.today || currentDayIso(runtime);
-  return { agent, wikiRoot, today };
+  return { agent: resolved.agent, wikiRoot, today };
 }
 
 function lastDateHeading(text) {
   // Match `## YYYY-MM-DD` at the start of a line, optionally followed by
   // suffix text (e.g. `## 2026-05-19 (third activation)`).
-  const re = /^## (\d{4}-\d{2}-\d{2})/gm;
+  const re = new RegExp(WEEKLY_LOG_SEAM_RE.source, "gm");
   let last = null;
   let match;
   while ((match = re.exec(text)) !== null) last = match[1];
@@ -40,13 +45,14 @@ function lastDateHeading(text) {
  * thrown fs error is reported and swallowed: the writer rolled back, so the
  * (intact) current file still receives the new entry.
  */
-function rotateBeforeAppend(wikiRoot, agent, today, appendLines, runtime) {
+function rotateBeforeAppend(wikiRoot, agent, today, body, runtime) {
   try {
+    const delta = { lines: countLines(body), words: countWords(body) };
     const res = rotateIfOverBudget(
       wikiRoot,
       agent,
       today,
-      appendLines,
+      delta,
       {},
       runtime.fsSync,
     );
@@ -63,6 +69,26 @@ function rotateBeforeAppend(wikiRoot, agent, today, appendLines, runtime) {
   }
 }
 
+/**
+ * Report the just-written weekly log's budget state — value, cap, and remaining
+ * headroom for both the line and word budget — so a writer sees the ceiling
+ * before composing the next entry rather than discovering it via a red gate.
+ * Runs after every successful append, on the rotated and non-rotated path alike.
+ */
+function reportBudget(target, runtime) {
+  const text = runtime.fsSync.existsSync(target)
+    ? runtime.fsSync.readFileSync(target, "utf-8")
+    : "";
+  const lines = countLines(text);
+  const words = countWords(text);
+  runtime.proc.stdout.write(
+    `weekly log budget: ${lines}/${WEEKLY_LOG_LINE_BUDGET} lines ` +
+      `(${WEEKLY_LOG_LINE_BUDGET - lines} remaining), ` +
+      `${words}/${WEEKLY_LOG_WORD_BUDGET} words ` +
+      `(${WEEKLY_LOG_WORD_BUDGET - words} remaining)\n`,
+  );
+}
+
 function runDecision(runtime, options) {
   const ctx = commonContext(runtime, options);
   if (ctx.error) return ctx.error;
@@ -85,11 +111,11 @@ function runDecision(runtime, options) {
     `**Rationale:** ${rationale}`,
     "",
   ].join("\n");
-  const lineCount = body.split("\n").length;
-  rotateBeforeAppend(wikiRoot, agent, today, lineCount, runtime);
+  rotateBeforeAppend(wikiRoot, agent, today, body, runtime);
   const target = weeklyLogPath(wikiRoot, agent, today);
   appendEntry(target, body, agent, today, runtime.fsSync);
   runtime.proc.stdout.write(`logged decision to ${target}\n`);
+  reportBudget(target, runtime);
   return { ok: true };
 }
 
@@ -105,15 +131,10 @@ function runNote(runtime, options) {
     return { ok: false, code: 2 };
   }
   const fieldBlock = `### ${options.field}\n\n${options.body}\n`;
-  // Conservative line budget: assume we'll prepend a date heading.
+  // Conservative budget: assume we'll prepend a date heading. Rotate on the
+  // larger `withHeading` body so the word/line projection never under-counts.
   const withHeading = `## ${today}\n\n${fieldBlock}`;
-  rotateBeforeAppend(
-    wikiRoot,
-    agent,
-    today,
-    withHeading.split("\n").length,
-    runtime,
-  );
+  rotateBeforeAppend(wikiRoot, agent, today, withHeading, runtime);
   const target = weeklyLogPath(wikiRoot, agent, today);
   // Append under the open entry if the file's last `## YYYY-MM-DD` is today;
   // otherwise open a new entry by prepending a date heading.
@@ -123,6 +144,7 @@ function runNote(runtime, options) {
   const body = lastDateHeading(existing) === today ? fieldBlock : withHeading;
   appendEntry(target, body, agent, today, runtime.fsSync);
   runtime.proc.stdout.write(`logged note to ${target}\n`);
+  reportBudget(target, runtime);
   return { ok: true };
 }
 
@@ -131,11 +153,11 @@ function runDone(runtime, options) {
   if (ctx.error) return ctx.error;
   const { agent, wikiRoot, today } = ctx;
   const body = `### Closed\n\nRun closed ${today}.\n`;
-  const lineCount = body.split("\n").length;
-  rotateBeforeAppend(wikiRoot, agent, today, lineCount, runtime);
+  rotateBeforeAppend(wikiRoot, agent, today, body, runtime);
   const target = weeklyLogPath(wikiRoot, agent, today);
   appendEntry(target, body, agent, today, runtime.fsSync);
   runtime.proc.stdout.write(`closed entry in ${target}\n`);
+  reportBudget(target, runtime);
   return { ok: true };
 }
 

package/src/commands/memo.js

@@ -4,6 +4,7 @@ import { writeMemo } from "../memo-writer.js";
 import { listAgents } from "../agent-roster.js";
 import { BROADCAST_TARGET } from "../constants.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveProjectRoot } from "../util/wiki-dir.js";
 
 function writeAndCheck(runtime, summaryPath, sender, message, today) {
@@ -63,19 +64,19 @@ function writeBroadcast(
   return { ok: true };
 }
 
-/** Write a memo to a target agent's summary file (or broadcast to all except the sender); sender is --from or LIBEVAL_AGENT_PROFILE env var. */
+/** Write a memo to a target agent's summary file (or broadcast to all except the sender); the sender is the required --from flag. */
 export function runMemoCommand(ctx) {
   const { runtime } = ctx.deps;
   const options = ctx.options;
-  const sender = options.from || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
+  const resolved = requireAgentFlag(options, {
+    command: "memo",
+    flag: "--from",
+    example:
+      'fit-wiki memo --from staff-engineer --to security-engineer --message "..."',
+  });
+  if (!resolved.ok) return resolved;
+  const sender = resolved.agent;
 
-  if (!sender) {
-    return {
-      ok: false,
-      code: 2,
-      error: "memo requires --from <sender> or LIBEVAL_AGENT_PROFILE env var",
-    };
-  }
   if (!options.to) {
     return { ok: false, code: 2, error: "memo requires --to <target|all>" };
   }

package/src/commands/refresh.js

@@ -27,6 +27,7 @@ async function renderForBlock(block, projectRoot, ghContext, runtime) {
     return renderBlock({
       metric: block.metric,
       csvPath: block.csvPath,
+      priorReadAnchor: block.priorReadAnchor,
       projectRoot,
       fs: runtime.fsSync,
     });

package/src/commands/rotate.js

@@ -1,26 +1,28 @@
 import { createLogger } from "@forwardimpact/libtelemetry";
 import { rotateIfOverBudget, weeklyLogPath } from "../weekly-log.js";
 import { currentDayIso } from "../util/clock.js";
+import { requireAgentFlag } from "../util/agent-flag.js";
 import { resolveWikiRoot } from "../util/wiki-dir.js";
 
-/** Force-rotate the current weekly log to a sealed part file. */
+/**
+ * Rotate the current weekly log to a sealed part file. Refuses an under-budget
+ * target (exit 2) unless `--force`; the header-only floor stays a zero-exit
+ * no-op even under `--force`; a missing target exits 2.
+ */
 export function runRotateCommand(ctx) {
   const { runtime } = ctx.deps;
   const logger = createLogger("wiki", runtime);
   const options = ctx.options;
-  const agent = options.agent || runtime.proc.env.LIBEVAL_AGENT_PROFILE;
-  if (!agent) {
-    return {
-      ok: false,
-      code: 2,
-      error: "rotate requires --agent or LIBEVAL_AGENT_PROFILE",
-    };
-  }
+  const resolved = requireAgentFlag(options, {
+    command: "rotate",
+    example: "fit-wiki rotate --agent staff-engineer",
+  });
+  if (!resolved.ok) return resolved;
+  const agent = resolved.agent;
   const wikiRoot = resolveWikiRoot(runtime, options);
   const today = options.today || currentDayIso(runtime);
   // Name the resolved target before any seal: the file follows from agent +
-  // current week, not from any audit finding, so an env-default agent can
-  // silently select a different file than the one the operator has in mind.
+  // current week, not from any audit finding.
   runtime.proc.stdout.write(
     `target → ${weeklyLogPath(wikiRoot, agent, today)}\n`,
   );
@@ -31,8 +33,8 @@ export function runRotateCommand(ctx) {
       wikiRoot,
       agent,
       today,
-      0,
-      { force: true },
+      { lines: 0, words: 0 },
+      { force: Boolean(options.force) },
       runtime.fsSync,
     );
   } catch (e) {
@@ -41,8 +43,27 @@ export function runRotateCommand(ctx) {
   }
   switch (result.status) {
     case "noop":
-      runtime.proc.stdout.write(`no rotation needed for ${agent}\n`);
-      return { ok: true };
+      // The header-only floor is a benign no-op; an under-budget or missing
+      // target fails closed so a stale/typo'd invocation cannot pass silently.
+      if (result.reason === "floor") {
+        runtime.proc.stdout.write(`no rotation needed for ${agent}\n`);
+        return { ok: true };
+      }
+      if (result.reason === "missing") {
+        return {
+          ok: false,
+          code: 2,
+          error: `no weekly log for ${agent} at ${result.fromPath}`,
+        };
+      }
+      return {
+        ok: false,
+        code: 2,
+        error:
+          `${result.fromPath} is under budget ` +
+          `(${result.lines} lines, ${result.words} words); ` +
+          `pass --force to seal it early`,
+      };
     case "sealed":
       for (const part of result.parts) {
         runtime.proc.stdout.write(`sealed → ${part}\n`);
@@ -55,10 +76,10 @@ export function runRotateCommand(ctx) {
       const { section, lines, words, path: residuePath } = result.residue;
       logger.error(
         "rotate",
-        `day-section ${section} alone exceeds the budget ` +
-          `(${lines} lines, ${words} words) and cannot be split at a day ` +
-          `seam: ${residuePath}\n` +
-          `recover it by hand — bisect the section at a finer seam ` +
+        `section ${section} alone exceeds the budget ` +
+          `(${lines} lines, ${words} words) and has no finer seam to split ` +
+          `at: ${residuePath}\n` +
+          `recover it by hand — shorten the section ` +
           `(see the memory protocol's manual-recovery convention)`,
       );
       return { ok: false, code: 1 };