@forwardimpact/libwiki 0.2.16 → 0.2.17

package/package.json

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

package/src/active-claims.js

@@ -1,11 +1,13 @@
 import {
+  ACTIVE_CLAIMS_HEADER_RE,
   ACTIVE_CLAIMS_HEADING,
   ACTIVE_CLAIMS_TABLE_HEADER,
   ACTIVE_CLAIMS_TABLE_SEPARATOR,
 } from "./constants.js";
 
-const HEADER_RE =
-  /^\|\s*agent\s*\|\s*target\s*\|\s*branch\s*\|\s*pr\s*\|\s*claimed_at\s*\|\s*expires_at\s*\|\s*$/;
+// The header matcher is shared with the audit (via constants.js); the loose
+// separator and the 6-cell row parser stay local — they serve parsing, not the
+// audit's column-count check.
 const SEPARATOR_RE = /^\|\s*---\s*\|/;
 const ROW_RE =
   /^\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*([^|]*?)\s*\|\s*$/;
@@ -47,7 +49,7 @@ function scanRowsBetween(lines, start, end) {
   let seenSeparator = false;
   for (let i = start; i < end; i++) {
     const line = lines[i];
-    if (HEADER_RE.test(line)) {
+    if (ACTIVE_CLAIMS_HEADER_RE.test(line)) {
       inTable = true;
       continue;
     }
@@ -96,7 +98,7 @@ function findTableIndices(lines, heading, sectionEnd) {
   let headerIdx = -1;
   let separatorIdx = -1;
   for (let i = heading + 1; i < sectionEnd; i++) {
-    if (HEADER_RE.test(lines[i])) headerIdx = i;
+    if (ACTIVE_CLAIMS_HEADER_RE.test(lines[i])) headerIdx = i;
     if (headerIdx !== -1 && SEPARATOR_RE.test(lines[i])) {
       separatorIdx = i;
       break;

package/src/audit/rules.js

@@ -1,7 +1,11 @@
 import {
+  ACTIVE_CLAIMS_HEADER_RE,
   ACTIVE_CLAIMS_HEADING,
+  ACTIVE_CLAIMS_SEPARATOR_RE,
   ACTIVE_CLAIMS_TABLE_HEADER,
   DECISION_HEADING,
+  ISSUE_CLOSE_RE,
+  ISSUE_OPEN_RE,
   MEMO_INBOX_MARKER,
   PRIORITY_INDEX_HEADING,
   STORYBOARD_LINE_BUDGET,
@@ -10,8 +14,14 @@ import {
   SUMMARY_WORD_BUDGET,
   WEEKLY_LOG_LINE_BUDGET,
   WEEKLY_LOG_WORD_BUDGET,
+  XMR_CLOSE_RE,
+  XMR_OPEN_RE,
 } from "../constants.js";
-import { PRIORITY_HEADER_RE, WEEKLY_LOG_H1_RE } from "./scopes.js";
+import {
+  PRIORITY_HEADER_RE,
+  SUMMARY_H1_RE,
+  WEEKLY_LOG_H1_RE,
+} from "./scopes.js";
 import { STATUS_ROW_RULES } from "./status-row.js";
 
 const PRIORITY_INDEX_HEADING_RE = new RegExp(
@@ -21,20 +31,7 @@ const PRIORITY_INDEX_HEADING_RE = new RegExp(
 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}$/;
-// Marker regexes (mirror of marker-scanner.js): tolerate optional trailing
-// text inside the marker so an open marker can carry an inline notice like
-// "Do not edit. Auto-generated." without breaking the audit's balance check.
-const XMR_OPEN_RE = /^<!--\s*xmr:([^:\s]+):(\S+)(?:\s+[^>]*?)?\s*-->\s*$/;
-const XMR_CLOSE_RE = /^<!--\s*\/xmr(?:\s+[^>]*?)?\s*-->\s*$/;
-const ISSUE_OPEN_RE =
-  /^<!--\s*(obstacles|experiments):(open|closed)(?::(\d+d))?(?:\s+[^>]*?)?\s*-->\s*$/;
-const ISSUE_CLOSE_RE =
-  /^<!--\s*\/(obstacles|experiments)(?:\s+[^>]*?)?\s*-->\s*$/;
 
 // improvement-coach is the storyboard facilitator and carries no domain
 // metrics; only the five domain agents need their own H3.
@@ -154,14 +151,12 @@ const slugify = (title) =>
     .replace(/(^-|-$)/g, "");
 
 const summaryAgentMismatch = (s) => {
-  const titleSlug = slugify(s.firstLine.match(/^# (.+) — Summary$/)[1]);
+  const titleSlug = slugify(s.firstLine.match(SUMMARY_H1_RE)[1]);
   return titleSlug === s.agentPrefix ? null : { titleSlug };
 };
 
 const weeklyAgentMismatch = (s) => {
-  const m = s.firstLine.match(
-    /^# (.+) — \d{4}-W\d{2}(?: \(part \d+ of \d+\))?$/,
-  );
+  const m = s.firstLine.match(WEEKLY_LOG_H1_RE);
   if (!m) return null;
   const titleSlug = slugify(m[1]);
   return titleSlug === s.agentPrefix ? null : { titleSlug };
@@ -177,7 +172,7 @@ 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 memoryHasClaimsHeader = (s) => ACTIVE_CLAIMS_HEADER_RE.test(s.text);
 const storyboardExists = (s) => s.exists;
 
 export const RULES = [
@@ -283,14 +278,13 @@ export const RULES = [
     id: "decision-block.heading-within-5",
     scope: "weekly-log-main",
     severity: "fail",
-    remediation: "flag",
     check: decisionWithin5({
       entryRe: /^## \d{4}-\d{2}-\d{2}(?:[\s(].*)?$/,
       requiredLine: DECISION_HEADING,
       stopRe: /^##\s/,
     }),
     message: () => "Entry lacks leading '### Decision'",
-    hint: "open each '## YYYY-MM-DD' entry with a '### Decision' subheading; use `bunx fit-wiki log decision` to do this mechanically",
+    hint: "open each '## YYYY-MM-DD' entry with a '### Decision' subheading that summarises the decision recorded in the entry's own narrative — do not invent rationale the entry does not support",
   },
 
   // -- Weekly logs (sealed parts) --
@@ -307,19 +301,19 @@ export const RULES = [
     id: "weekly-log-part.line-budget",
     scope: "weekly-log-part",
     severity: "fail",
-    remediation: "flag",
+    remediation: "rotate",
     check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
     message: (_s, r) => `${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
-    hint: "the bisecting seal produces conforming parts, so an over-budget part means a hand-edited part or an irreducible single-day section — bisect it at a finer seam by hand",
+    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",
   },
   {
     id: "weekly-log-part.word-budget",
     scope: "weekly-log-part",
     severity: "fail",
-    remediation: "flag",
+    remediation: "rotate",
     check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
     message: (_s, r) => `${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
-    hint: "the bisecting seal produces conforming parts, so an over-budget part means a hand-edited part or an irreducible single-day section — bisect it at a finer seam by hand",
+    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",
   },
   {
     id: "weekly-log-part.h1-agent-matches-filename",
@@ -373,7 +367,7 @@ export const RULES = [
     scope: "memory",
     severity: "fail",
     when: memoryHasClaimsHeading,
-    check: matches(CLAIMS_HEADER_RE),
+    check: matches(ACTIVE_CLAIMS_HEADER_RE),
     message: () => `Active claims header mismatch`,
     hint: `expected header row: '${ACTIVE_CLAIMS_TABLE_HEADER}'`,
   },
@@ -382,7 +376,7 @@ export const RULES = [
     scope: "memory",
     severity: "fail",
     when: memoryHasClaimsHeader,
-    check: matches(CLAIMS_SEPARATOR_RE),
+    check: matches(ACTIVE_CLAIMS_SEPARATOR_RE),
     message: () => "Missing active-claims separator row",
     hint: "add '| --- | --- | --- | --- | --- | --- |' directly below the claims header",
   },

package/src/audit/scopes.js

@@ -2,13 +2,17 @@ import path from "node:path";
 import { yearMonth } from "@forwardimpact/libutil";
 import { parseClaims } from "../active-claims.js";
 import { countLines, countWords } from "../budget.js";
-import { PRIORITY_INDEX_HEADING } from "../constants.js";
+import {
+  PRIORITY_INDEX_HEADING,
+  WEEKLY_LOG_NAME_RE,
+  WEEKLY_LOG_PART_NAME_RE,
+} 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$/;
+// 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]`).
+export const SUMMARY_H1_RE = /^# ([A-Z].*) — Summary$/;
 export const WEEKLY_LOG_H1_RE =
-  /^# .* — \d{4}-W\d{2}(?: \(part \d+ of \d+\))?$/;
+  /^# (.*) — \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;
 
@@ -55,8 +59,8 @@ function loadFile(filePath, fs) {
 function classifyFile(filePath, fs) {
   const base = path.basename(filePath);
   if (EXCLUDED_BASES.has(base)) return null;
-  // STATUS.md is loaded separately (loadStatus) and audited via the dedicated
-  // `status-row` scope — skip the per-file classification.
+  // STATUS.md is loaded separately (readOptional in buildContext) and audited
+  // via the dedicated `status-row` scope — skip the per-file classification.
   if (base === "STATUS.md") return null;
   if (NON_SUMMARY_PREFIXES.some((p) => base.startsWith(p))) return null;
   if (WEEKLY_LOG_NAME_RE.test(base)) {
@@ -72,18 +76,10 @@ function classifyFile(filePath, fs) {
   return { kind: "summary", subject };
 }
 
-function loadMemory(wikiRoot, fs) {
-  const filePath = path.join(wikiRoot, "MEMORY.md");
-  const exists = fs.existsSync(filePath);
-  return {
-    path: filePath,
-    text: exists ? fs.readFileSync(filePath, "utf-8") : "",
-    exists,
-  };
-}
-
-function loadStatus(wikiRoot, fs) {
-  const filePath = path.join(wikiRoot, "STATUS.md");
+// Read a file if present; an absent file yields empty text so callers audit
+// "missing" uniformly. The common { path, text, exists } shape backs the
+// MEMORY.md, STATUS.md, and storyboard context loads.
+function readOptional(filePath, fs) {
   const exists = fs.existsSync(filePath);
   return {
     path: filePath,
@@ -124,17 +120,13 @@ function parseStatusRows(statusText) {
 
 function loadStoryboard(wikiRoot, today, fs) {
   const ym = yearMonth(today);
-  const filePath = path.join(wikiRoot, `storyboard-${ym}.md`);
-  const exists = fs.existsSync(filePath);
-  const text = exists ? fs.readFileSync(filePath, "utf-8") : "";
+  const base = readOptional(path.join(wikiRoot, `storyboard-${ym}.md`), fs);
   return {
-    path: filePath,
-    text,
-    fileLines: text.split("\n"),
-    exists,
+    ...base,
+    fileLines: base.text.split("\n"),
     yearMonth: ym,
-    lines: countLines(text),
-    words: countWords(text),
+    lines: countLines(base.text),
+    words: countWords(base.text),
   };
 }
 
@@ -227,8 +219,8 @@ export function buildContext({ wikiRoot, today, fs }) {
     wikiRoot,
     today,
     subjects,
-    memory: loadMemory(wikiRoot, fs),
-    status: loadStatus(wikiRoot, fs),
+    memory: readOptional(path.join(wikiRoot, "MEMORY.md"), fs),
+    status: readOptional(path.join(wikiRoot, "STATUS.md"), fs),
     storyboard: loadStoryboard(wikiRoot, today, fs),
   };
 }

package/src/commands/fix.js

@@ -8,7 +8,11 @@ import {
 } from "@forwardimpact/libeval";
 import { RULES } from "../audit/rules.js";
 import { buildContext, resolveScope } from "../audit/scopes.js";
-import { rotateIfOverBudget, weeklyLogPath } from "../weekly-log.js";
+import {
+  rotateIfOverBudget,
+  rebisectOverBudgetPart,
+  weeklyLogPath,
+} from "../weekly-log.js";
 import { currentDayIso } from "../util/clock.js";
 import { resolveProjectRoot } from "../util/wiki-dir.js";
 
@@ -131,6 +135,50 @@ function rotateOverBudgetMainLogs(findings, deps) {
   }
 }
 
+/**
+ * Re-bisect one over-budget sealed part, logging each new sibling slot it
+ * produces (the reused source slot is not a new file). A failed reseal leaves
+ * the source intact (the writer rolled back), so the re-audit re-flags it.
+ */
+function resealPart(partPath, { fs, projectRoot, out, err }) {
+  try {
+    const res = rebisectOverBudgetPart(partPath, fs);
+    if (res.status !== "resealed" && res.status !== "incomplete") return;
+    for (const part of res.parts) {
+      if (part === res.fromPath) continue; // the reused source slot
+      out(
+        `rotated ${path.relative(projectRoot, res.fromPath)} -> ` +
+          `${path.relative(projectRoot, part)}\n`,
+      );
+    }
+  } catch (e) {
+    err(
+      `fit-wiki fix: rebisect failed for ` +
+        `${path.relative(projectRoot, partPath)}: ${e.message}\n`,
+    );
+  }
+}
+
+/**
+ * Deterministic pass for over-budget sealed parts: re-bisect each at its
+ * day-section seams. A part with no splittable seam is left byte-identical (the
+ * re-audit re-flags it for a human). Agent and week come from the part filename,
+ * so no subject lookup is needed. Part findings are disjoint from the main-log
+ * findings `rotateOverBudgetMainLogs` handles.
+ */
+function rebisectOverBudgetParts(findings, deps) {
+  // A part over both budgets yields two findings with the same path; re-bisect
+  // each path once.
+  const done = new Set();
+  for (const f of findings) {
+    if (classOf(f) !== "rotate") continue;
+    if (!f.id.startsWith("weekly-log-part.")) continue;
+    if (done.has(f.path)) continue;
+    done.add(f.path);
+    resealPart(f.path, deps);
+  }
+}
+
 /** Report findings that need human judgment — never auto-fixed. */
 function reportFlags(err, flagFindings, projectRoot) {
   err(
@@ -242,16 +290,12 @@ export async function runFixCommand(ctx) {
     return { ok: true };
   }
 
-  // Deterministic layer: weekly-log rotation only.
+  // Deterministic layer: seal over-budget main logs, then re-bisect over-budget
+  // sealed parts. Both are content-preserving — no agent, no history rewrite.
   if (findings.some((f) => classOf(f) === "rotate")) {
-    rotateOverBudgetMainLogs(findings, {
-      wikiRoot,
-      today,
-      projectRoot,
-      fs,
-      out,
-      err,
-    });
+    const rotateDeps = { wikiRoot, today, projectRoot, fs, out, err };
+    rotateOverBudgetMainLogs(findings, rotateDeps);
+    rebisectOverBudgetParts(findings, rotateDeps);
     findings = audit();
     if (findings.length === 0) {
       out("fixed: wiki audit is clean\n");

package/src/constants.js

@@ -8,6 +8,26 @@ export const ACTIVE_CLAIMS_TABLE_HEADER =
   "| agent | target | branch | pr | claimed_at | expires_at |";
 export const ACTIVE_CLAIMS_TABLE_SEPARATOR =
   "| --- | --- | --- | --- | --- | --- |";
+
+// Match a rendered pipe-table row (header or separator) line-anchored and
+// whitespace-tolerant between cells. Deriving the matcher from the rendered
+// literal keeps the claims parser (active-claims.js) and the audit
+// (audit/rules.js) from drifting on the column set — one literal, one matcher.
+function pipeRowRe(literal, flags) {
+  const cells = literal
+    .split("|")
+    .map((c) => c.trim())
+    .filter((c) => c !== "");
+  return new RegExp(`^\\|\\s*${cells.join("\\s*\\|\\s*")}\\s*\\|`, flags);
+}
+export const ACTIVE_CLAIMS_HEADER_RE = pipeRowRe(
+  ACTIVE_CLAIMS_TABLE_HEADER,
+  "m",
+);
+export const ACTIVE_CLAIMS_SEPARATOR_RE = pipeRowRe(
+  ACTIVE_CLAIMS_TABLE_SEPARATOR,
+  "m",
+);
 export const PRIORITY_INDEX_HEADING = "## Cross-Cutting Priorities";
 export const PRIORITY_INDEX_TABLE_HEADER =
   "| Item | Agents | Owner | Status | Added |";
@@ -24,3 +44,23 @@ export const WEEKLY_LOG_LINE_BUDGET = 496;
 export const WEEKLY_LOG_WORD_BUDGET = 6400;
 export const STORYBOARD_LINE_BUDGET = 496;
 export const STORYBOARD_WORD_BUDGET = 6400;
+
+// Weekly-log filename convention: `<agent>-YYYY-Www.md` for the live main log
+// and `<agent>-YYYY-Www-partN.md` for a sealed part. Capture groups are
+// agent / year / week. One home so the audit's file classifier
+// (audit/scopes.js) and the part re-bisector (weekly-log.js) cannot drift.
+export const WEEKLY_LOG_NAME_RE = /^([a-z][a-z-]*)-(\d{4})-W(\d{2})\.md$/;
+export const WEEKLY_LOG_PART_NAME_RE =
+  /^([a-z][a-z-]*)-(\d{4})-W(\d{2})-part\d+\.md$/;
+
+// Storyboard marker syntax. An open or close marker tolerates optional trailing
+// text after the tag (typically an inline "Do not edit. Generated from fit-wiki
+// refresh." notice). One home so the marker scanner (marker-scanner.js) and the
+// audit's balance check (audit/rules.js) cannot drift on the syntax.
+export const XMR_OPEN_RE =
+  /^<!--\s*xmr:([^:\s]+):(\S+)(?:\s+[^>]*?)?\s*-->\s*$/;
+export const XMR_CLOSE_RE = /^<!--\s*\/xmr(?:\s+[^>]*?)?\s*-->\s*$/;
+export const ISSUE_OPEN_RE =
+  /^<!--\s*(obstacles|experiments):(open|closed)(?::(\d+d))?(?:\s+[^>]*?)?\s*-->\s*$/;
+export const ISSUE_CLOSE_RE =
+  /^<!--\s*\/(obstacles|experiments)(?:\s+[^>]*?)?\s*-->\s*$/;

package/src/index.js

@@ -32,6 +32,7 @@ export {
   isoWeek,
   weeklyLogPath,
   rotateIfOverBudget,
+  rebisectOverBudgetPart,
   bisectWeeklyLog,
   appendEntry,
 } from "./weekly-log.js";

package/src/marker-scanner.js

@@ -1,12 +1,9 @@
-// Markers tolerate optional trailing text after the tag (typically an inline
-// "Do not edit. Generated from fit-wiki refresh." notice), so an open or close
-// marker can carry its own warning without needing a separate notice line.
-const XMR_OPEN_RE = /^<!--\s*xmr:([^:\s]+):(\S+)(?:\s+[^>]*?)?\s*-->\s*$/;
-const ISSUE_OPEN_RE =
-  /^<!--\s*(obstacles|experiments):(open|closed)(?::(\d+d))?(?:\s+[^>]*?)?\s*-->\s*$/;
-const XMR_CLOSE_RE = /^<!--\s*\/xmr(?:\s+[^>]*?)?\s*-->\s*$/;
-const ISSUE_CLOSE_RE =
-  /^<!--\s*\/(obstacles|experiments)(?:\s+[^>]*?)?\s*-->\s*$/;
+import {
+  ISSUE_CLOSE_RE,
+  ISSUE_OPEN_RE,
+  XMR_CLOSE_RE,
+  XMR_OPEN_RE,
+} from "./constants.js";
 
 function openLabel(open) {
   return open.kind === "xmr" ? open.metric : open.topic;

package/src/weekly-log.js

@@ -1,7 +1,11 @@
 import path from "node:path";
 import { isoWeekString } from "@forwardimpact/libutil";
 import { countLines, countWords } from "./budget.js";
-import { WEEKLY_LOG_LINE_BUDGET, WEEKLY_LOG_WORD_BUDGET } from "./constants.js";
+import {
+  WEEKLY_LOG_LINE_BUDGET,
+  WEEKLY_LOG_PART_NAME_RE,
+  WEEKLY_LOG_WORD_BUDGET,
+} from "./constants.js";
 
 // ISO week computation lives in libutil's calendar util (the one place a
 // `new Date` is allowed); re-exported here for the existing public surface.
@@ -185,58 +189,71 @@ export function bisectWeeklyLog(text, agent, isoWeekStr) {
 }
 
 /**
- * Stage every part at its slot and the fresh-main body at temps, then commit
- * by renaming each part onto its `-partN.md` slot and the fresh main over
- * `filePath` as the single final step. On any failure before that last rename,
- * unlink every committed slot and remaining temp this seal wrote and re-throw,
- * so the source's path/contents/inode are untouched. Returns the produced slot
- * paths in part order.
+ * Stage every write to `${path}.tmp`, then commit by renaming each `leading`
+ * write onto its path (tracked for rollback) and the `anchor` write LAST — the
+ * single point of no return. The anchor is the live/source file: until its
+ * rename it still holds its original bytes, so a failure anywhere unlinks every
+ * committed leading path and remaining temp and re-throws, leaving the anchor's
+ * path/contents/inode untouched. Leading paths must be verified-free slots (a
+ * rollback unlinks them). Returns the leading paths, in order.
  *
- * @param {string} filePath - The current weekly-log path.
- * @param {Array<{h1: string, body: string}>} parts - Ordered parts to seal.
- * @param {string} agent
- * @param {string} isoWeekStr
+ * @param {Array<{path: string, content: string}>} leading - Committed first.
+ * @param {{path: string, content: string}} anchor - Committed last.
  * @param {object} fs - Sync filesystem surface.
- * @returns {string[]} The `-partN.md` slot paths, in part order.
+ * @returns {string[]} The leading paths, in commit order.
  */
-function atomicSeal(filePath, parts, agent, isoWeekStr, fs) {
-  const slots = nextFreeSlots(filePath, parts.length, fs);
-  const mainTemp = `${filePath}.tmp`;
-  const temps = []; // temp paths this seal wrote, for rollback
-  const committed = []; // slots already renamed into place, for rollback
+function commitAtomic(leading, anchor, fs) {
+  const temps = []; // temp paths written but not yet renamed, for rollback
+  const committed = []; // leading paths already renamed into place, for rollback
   try {
-    // Stage every part and the fresh main at temp files.
-    slots.forEach((slot, i) => {
-      const tmp = `${slot}.tmp`;
-      fs.writeFileSync(tmp, `${parts[i].h1}\n${parts[i].body}`);
-      temps.push(tmp);
-    });
-    fs.writeFileSync(mainTemp, defaultH1(agent, isoWeekStr));
-    temps.push(mainTemp);
-    // Commit: parts onto their slots, then the fresh main as the final step.
-    slots.forEach((slot, i) => {
-      fs.renameSync(`${slot}.tmp`, slot);
-      committed.push(slot);
-      // The part temp is consumed by its rename; drop it from the rollback set.
-      temps.splice(temps.indexOf(`${slot}.tmp`), 1);
-    });
-    fs.renameSync(mainTemp, filePath);
-    return slots;
+    for (const w of [...leading, anchor]) {
+      fs.writeFileSync(`${w.path}.tmp`, w.content);
+      temps.push(`${w.path}.tmp`);
+    }
+    for (const w of leading) {
+      fs.renameSync(`${w.path}.tmp`, w.path);
+      committed.push(w.path);
+      temps.splice(temps.indexOf(`${w.path}.tmp`), 1);
+    }
+    fs.renameSync(`${anchor.path}.tmp`, anchor.path);
+    return committed;
   } catch (e) {
-    for (const slot of committed) {
+    for (const p of committed) {
       try {
-        fs.unlinkSync(slot);
+        fs.unlinkSync(p);
       } catch {}
     }
-    for (const tmp of temps) {
+    for (const t of temps) {
       try {
-        fs.unlinkSync(tmp);
+        fs.unlinkSync(t);
       } catch {}
     }
     throw e;
   }
 }
 
+/**
+ * Seal a bisected weekly log: write each part to a fresh `-partN.md` slot and a
+ * fresh empty main over `filePath` (the anchor, committed last). Returns the
+ * `-partN.md` slot paths in part order.
+ *
+ * @param {string} filePath - The current weekly-log path.
+ * @param {Array<{h1: string, body: string}>} parts - Ordered parts to seal.
+ * @param {string} agent
+ * @param {string} isoWeekStr
+ * @param {object} fs - Sync filesystem surface.
+ * @returns {string[]} The `-partN.md` slot paths, in part order.
+ */
+function atomicSeal(filePath, parts, agent, isoWeekStr, fs) {
+  const slots = nextFreeSlots(filePath, parts.length, fs);
+  const leading = slots.map((path, i) => ({
+    path,
+    content: `${parts[i].h1}\n${parts[i].body}`,
+  }));
+  const anchor = { path: filePath, content: defaultH1(agent, isoWeekStr) };
+  return commitAtomic(leading, anchor, fs);
+}
+
 /**
  * Rotate the current weekly log, sealing an over-budget source into
  * budget-conforming parts via a bisecting seal. Returns a tagged union:
@@ -287,6 +304,118 @@ export function rotateIfOverBudget(
   };
 }
 
+/**
+ * Derive the agent, ISO week, and MAIN-log path from a sealed part's path. The
+ * week comes from the filename (a part may belong to a past week, not today),
+ * and the main-log path — not the part path — is what `nextFreeSlots` must base
+ * new sibling slots on. Returns null for a non-conforming filename. Shares
+ * WEEKLY_LOG_PART_NAME_RE with the audit's file classifier so the two cannot
+ * drift on the filename convention.
+ */
+function parsePartPath(partPath) {
+  const m = path.basename(partPath).match(WEEKLY_LOG_PART_NAME_RE);
+  if (!m) return null;
+  const [, agent, year, week] = m;
+  const isoWeekStr = `${year}-W${week}`;
+  return {
+    agent,
+    isoWeekStr,
+    mainLogPath: path.join(path.dirname(partPath), `${agent}-${isoWeekStr}.md`),
+  };
+}
+
+/**
+ * Reseal a re-bisected part: the first sub-part overwrites the source slot (the
+ * anchor, committed last) and the rest claim fresh sibling slots of the main-log
+ * path. `nextFreeSlots` skips occupied slots (including the source's own), so a
+ * commit never clobbers a sibling nor a rollback unlinks a pre-existing one.
+ * Returns `[partPath, ...newSlots]` in part order.
+ */
+function atomicResealPart(partPath, mainLogPath, parts, fs) {
+  const newSlots = nextFreeSlots(mainLogPath, parts.length - 1, fs);
+  const leading = newSlots.map((path, i) => ({
+    path,
+    content: `${parts[i + 1].h1}\n${parts[i + 1].body}`,
+  }));
+  const anchor = {
+    path: partPath,
+    content: `${parts[0].h1}\n${parts[0].body}`,
+  };
+  commitAtomic(leading, anchor, fs);
+  return [partPath, ...newSlots];
+}
+
+/**
+ * Re-bisect a single over-budget sealed weekly-log PART in place. Agent and ISO
+ * week come from the part filename. A part within both budgets is a noop; a part
+ * whose body cannot be reduced (a lone over-cap day-section or an over-cap
+ * zero-seam body) is left BYTE-IDENTICAL and reported `incomplete` with a
+ * residue, so the re-audit re-flags it for a human. Otherwise the first sub-part
+ * overwrites `partPath` (slot reused) and the remaining sub-parts land on fresh
+ * sibling slots, with full rollback (source untouched on any failure).
+ *
+ * The produced sub-parts carry `bisectWeeklyLog`'s `(part i of M)` H1s, where M
+ * is LOCAL to this part's split — not a global count of the week's parts.
+ * Sibling parts are never renumbered (the audit does not validate the numbers).
+ *
+ * @param {string} partPath - Absolute path to an `<agent>-YYYY-Www-partN.md`.
+ * @param {object} fs - Sync filesystem surface (`runtime.fsSync`).
+ * @returns {{status: "noop"|"resealed"|"incomplete", fromPath: string, parts?: string[], residue?: {path: string, section: string, lines: number, words: number}}}
+ */
+export function rebisectOverBudgetPart(partPath, fs) {
+  if (!fs.existsSync(partPath)) return { status: "noop", fromPath: partPath };
+  const parsed = parsePartPath(partPath);
+  if (!parsed) return { status: "noop", fromPath: partPath };
+  const text = fs.readFileSync(partPath, "utf-8");
+  const lines = countLines(text);
+  const words = countWords(text);
+  if (lines <= WEEKLY_LOG_LINE_BUDGET && words <= WEEKLY_LOG_WORD_BUDGET) {
+    return { status: "noop", fromPath: partPath };
+  }
+  const { parts, residue } = bisectWeeklyLog(
+    text,
+    parsed.agent,
+    parsed.isoWeekStr,
+  );
+  // A single produced part has no splittable seam: leave the file untouched and
+  // surface a residue (synthesised from the file when the bisector did not name
+  // one) so the caller's re-audit re-flags it.
+  if (parts.length === 1) {
+    const seam = text.match(/^## (\d{4}-\d{2}-\d{2})/m);
+    const r = residue ?? {
+      section: seam ? seam[1] : "prologue",
+      lines,
+      words,
+    };
+    return {
+      status: "incomplete",
+      fromPath: partPath,
+      parts: [partPath],
+      residue: {
+        path: partPath,
+        section: r.section,
+        lines: r.lines,
+        words: r.words,
+      },
+    };
+  }
+  const slots = atomicResealPart(partPath, parsed.mainLogPath, parts, fs);
+  if (residue === null) {
+    return { status: "resealed", fromPath: partPath, parts: slots };
+  }
+  return {
+    status: "incomplete",
+    fromPath: partPath,
+    parts: slots,
+    residue: {
+      path: slots[residue.partIndex],
+      section: residue.section,
+      lines: residue.lines,
+      words: residue.words,
+    },
+  };
+}
+
 /**
  * Append a body to a weekly log file. Creates it with an H1 if missing.
  * @param {string} filePath