@forwardimpact/libwiki 0.2.14 → 0.2.16

package/package.json

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

package/src/audit/rules.js

@@ -77,7 +77,6 @@ const columnCount = (expected) => (s) =>
 
 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;
@@ -311,7 +310,7 @@ export const RULES = [
     remediation: "flag",
     check: lineBudget(WEEKLY_LOG_LINE_BUDGET),
     message: (_s, r) => `${r.value} lines (limit ${WEEKLY_LOG_LINE_BUDGET})`,
-    hint: "sealed parts should already be at-or-under the cap; if not, the rotation that produced this part needs investigation",
+    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",
   },
   {
     id: "weekly-log-part.word-budget",
@@ -320,7 +319,7 @@ export const RULES = [
     remediation: "flag",
     check: wordBudget(WEEKLY_LOG_WORD_BUDGET),
     message: (_s, r) => `${r.value} words (limit ${WEEKLY_LOG_WORD_BUDGET})`,
-    hint: "sealed parts should already be at-or-under the cap; if not, the rotation that produced this part needs investigation",
+    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",
   },
   {
     id: "weekly-log-part.h1-agent-matches-filename",
@@ -492,15 +491,4 @@ export const RULES = [
   // -- STATUS.md rows (per-migration-unit sub-row schema) --
 
   ...STATUS_ROW_RULES,
-
-  // -- Stray files --
-
-  {
-    id: "wiki.stray-file",
-    scope: "stray-file",
-    severity: "fail",
-    check: always,
-    message: () => "Does not match any known scope",
-    hint: "rename to a recognized scope (summary, weekly log, weekly-log part) or remove the file",
-  },
 ];

package/src/audit/scopes.js

@@ -1,6 +1,7 @@
 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";
 
 const SUMMARY_H1_RE = /^# [A-Z].* — Summary$/;
@@ -28,25 +29,6 @@ function listMdFiles(wikiRoot, fs) {
     .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, fs) {
   const text = fs.readFileSync(filePath, "utf-8");
   const fileLines = text.split("\n");
@@ -74,8 +56,7 @@ 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 so it is not treated
-  // as a stray file.
+  // `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)) {
@@ -85,8 +66,10 @@ function classifyFile(filePath, fs) {
     return { kind: "weekly-log-part", subject: loadFile(filePath, fs) };
   }
   const subject = loadFile(filePath, fs);
-  const kind = SUMMARY_H1_RE.test(subject.firstLine) ? "summary" : "stray";
-  return { kind, subject };
+  // Files that do not match a summary or weekly-log shape are left
+  // unclassified: stray files are not audited.
+  if (!SUMMARY_H1_RE.test(subject.firstLine)) return null;
+  return { kind: "summary", subject };
 }
 
 function loadMemory(wikiRoot, fs) {
@@ -216,7 +199,6 @@ const SCOPE_RESOLVERS = {
       ...r,
       path: ctx.status.path,
     })),
-  "stray-file": (ctx) => ctx.subjects.stray,
 };
 
 /** Resolve a scope key into the list of subjects the engine should iterate. */
@@ -236,7 +218,6 @@ export function buildContext({ wikiRoot, today, fs }) {
     summary: [],
     "weekly-log-main": [],
     "weekly-log-part": [],
-    stray: [],
   };
   for (const file of listMdFiles(wikiRoot, fs)) {
     const classified = classifyFile(file, fs);

package/src/budget.js

@@ -0,0 +1,25 @@
+// Canonical line- and word-counters for the budgeted wiki surfaces. The audit
+// (`audit/scopes.js`) and the rotation primitive's bisecting seal
+// (`weekly-log.js`) both import this one pair so a part the seal calls
+// conforming cannot later be flagged by an audit counting differently.
+
+/** Count lines, not counting a trailing newline as an empty final line. */
+export function countLines(text) {
+  return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
+
+/** Count whitespace-delimited words. */
+export 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;
+}

package/src/commands/fix.js

@@ -85,19 +85,12 @@ function composeFollowup(findings, projectRoot) {
  * untouched (rotating it would force-seal a healthy current-week log instead);
  * it survives the re-audit and is flagged for a human.
  */
-function rotateOverBudgetMainLogs(
-  findings,
-  { wikiRoot, today, projectRoot, fs, out },
-) {
-  const subjects = buildContext({ wikiRoot, today, fs }).subjects[
-    "weekly-log-main"
-  ];
-  const agentByPath = new Map(subjects.map((s) => [s.path, s.agentPrefix]));
-  for (const f of findings) {
-    if (classOf(f) !== "rotate") continue;
-    const agent = agentByPath.get(f.path);
-    if (!agent) continue;
-    if (weeklyLogPath(wikiRoot, agent, today) !== f.path) continue;
+/**
+ * Seal one over-budget current-week main log. A failed seal leaves the source
+ * intact (the writer rolled back), so the re-audit re-flags it for a human.
+ */
+function sealMainLog(agent, { wikiRoot, today, projectRoot, fs, out, err }) {
+  try {
     const res = rotateIfOverBudget(
       wikiRoot,
       agent,
@@ -106,12 +99,35 @@ function rotateOverBudgetMainLogs(
       { force: true },
       fs,
     );
-    if (res.rotated) {
+    if (res.status !== "sealed" && res.status !== "incomplete") return;
+    for (const part of res.parts) {
       out(
         `rotated ${path.relative(projectRoot, res.fromPath)} -> ` +
-          `${path.relative(projectRoot, res.toPath)}\n`,
+          `${path.relative(projectRoot, part)}\n`,
       );
     }
+  } catch (e) {
+    err(`fit-wiki fix: rotate failed for ${agent}: ${e.message}\n`);
+  }
+}
+
+function rotateOverBudgetMainLogs(findings, deps) {
+  const { wikiRoot, today, fs } = deps;
+  const subjects = buildContext({ wikiRoot, today, fs }).subjects[
+    "weekly-log-main"
+  ];
+  const agentByPath = new Map(subjects.map((s) => [s.path, s.agentPrefix]));
+  // A log over BOTH budgets yields two `rotate` findings with the same path
+  // (different rule ids); seal each path once, or the second force call would
+  // bisect the freshly-written fresh-main into a spurious near-empty part.
+  const sealed = new Set();
+  for (const f of findings) {
+    if (classOf(f) !== "rotate") continue;
+    const agent = agentByPath.get(f.path);
+    if (!agent || weeklyLogPath(wikiRoot, agent, today) !== f.path) continue;
+    if (sealed.has(f.path)) continue;
+    sealed.add(f.path);
+    sealMainLog(agent, deps);
   }
 }
 
@@ -234,6 +250,7 @@ export async function runFixCommand(ctx) {
       projectRoot,
       fs,
       out,
+      err,
     });
     findings = audit();
     if (findings.length === 0) {

package/src/commands/log.js

@@ -30,6 +30,36 @@ function lastDateHeading(text) {
   return last;
 }
 
+/**
+ * Rotate before an append, never blocking it. A bisecting seal may now produce
+ * multiple parts; the append still proceeds against the fresh current file. An
+ * `incomplete` residue (a lone over-cap day-section sealed as its own part —
+ * never the live file) is surfaced to stderr but does not block the append. A
+ * 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) {
+  try {
+    const res = rotateIfOverBudget(
+      wikiRoot,
+      agent,
+      today,
+      appendLines,
+      {},
+      runtime.fsSync,
+    );
+    if (res.status === "incomplete") {
+      runtime.proc.stderr.write(
+        `note: day-section ${res.residue.section} alone exceeds the budget ` +
+          `(${res.residue.lines} lines, ${res.residue.words} words); ` +
+          `sealed as ${res.residue.path} for manual recovery\n`,
+      );
+    }
+  } catch (e) {
+    runtime.proc.stderr.write(`note: rotation failed: ${e.message}\n`);
+  }
+}
+
 function runDecision(runtime, options) {
   const ctx = commonContext(runtime, options);
   if (ctx.error) return ctx.error;
@@ -53,7 +83,7 @@ function runDecision(runtime, options) {
     "",
   ].join("\n");
   const lineCount = body.split("\n").length;
-  rotateIfOverBudget(wikiRoot, agent, today, lineCount, {}, runtime.fsSync);
+  rotateBeforeAppend(wikiRoot, agent, today, lineCount, runtime);
   const target = weeklyLogPath(wikiRoot, agent, today);
   appendEntry(target, body, agent, today, runtime.fsSync);
   runtime.proc.stdout.write(`logged decision to ${target}\n`);
@@ -71,13 +101,12 @@ function runNote(runtime, options) {
   const fieldBlock = `### ${options.field}\n\n${options.body}\n`;
   // Conservative line budget: assume we'll prepend a date heading.
   const withHeading = `## ${today}\n\n${fieldBlock}`;
-  rotateIfOverBudget(
+  rotateBeforeAppend(
     wikiRoot,
     agent,
     today,
     withHeading.split("\n").length,
-    {},
-    runtime.fsSync,
+    runtime,
   );
   const target = weeklyLogPath(wikiRoot, agent, today);
   // Append under the open entry if the file's last `## YYYY-MM-DD` is today;
@@ -97,7 +126,7 @@ function runDone(runtime, options) {
   const { agent, wikiRoot, today } = ctx;
   const body = `### Closed\n\nRun closed ${today}.\n`;
   const lineCount = body.split("\n").length;
-  rotateIfOverBudget(wikiRoot, agent, today, lineCount, {}, runtime.fsSync);
+  rotateBeforeAppend(wikiRoot, agent, today, lineCount, runtime);
   const target = weeklyLogPath(wikiRoot, agent, today);
   appendEntry(target, body, agent, today, runtime.fsSync);
   runtime.proc.stdout.write(`closed entry in ${target}\n`);

package/src/commands/rotate.js

@@ -17,20 +17,46 @@ export function runRotateCommand(ctx) {
   const wikiRoot = resolveWikiRoot(runtime, options);
   const today = options.today || currentDayIso(runtime);
 
-  const result = rotateIfOverBudget(
-    wikiRoot,
-    agent,
-    today,
-    0,
-    { force: true },
-    runtime.fsSync,
-  );
-  if (result.rotated) {
-    runtime.proc.stdout.write(
-      `rotated ${result.fromPath} → ${result.toPath}\n`,
+  let result;
+  try {
+    result = rotateIfOverBudget(
+      wikiRoot,
+      agent,
+      today,
+      0,
+      { force: true },
+      runtime.fsSync,
     );
-  } else {
-    runtime.proc.stdout.write(`no rotation needed for ${agent}\n`);
+  } catch (e) {
+    runtime.proc.stderr.write(`rotate failed: ${e.message}\n`);
+    return { ok: false, code: 1 };
+  }
+  switch (result.status) {
+    case "noop":
+      runtime.proc.stdout.write(`no rotation needed for ${agent}\n`);
+      return { ok: true };
+    case "sealed":
+      for (const part of result.parts) {
+        runtime.proc.stdout.write(`sealed → ${part}\n`);
+      }
+      return { ok: true };
+    case "incomplete": {
+      for (const part of result.parts) {
+        runtime.proc.stdout.write(`sealed → ${part}\n`);
+      }
+      const { section, lines, words, path: residuePath } = result.residue;
+      runtime.proc.stderr.write(
+        `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 ` +
+          `(see the memory protocol's manual-recovery convention)\n`,
+      );
+      return { ok: false, code: 1 };
+    }
+    default:
+      // Defensive: the tagged union is exhaustive above, so this is
+      // unreachable; kept so a future status can't fall through to no return.
+      return { ok: true };
   }
-  return { ok: true };
 }

package/src/index.js

@@ -32,8 +32,10 @@ export {
   isoWeek,
   weeklyLogPath,
   rotateIfOverBudget,
+  bisectWeeklyLog,
   appendEntry,
 } from "./weekly-log.js";
 export { buildDigest } from "./boot.js";
+export { countLines, countWords } from "./budget.js";
 export { RULES } from "./audit/rules.js";
 export { resolveScope as resolveAuditScope } from "./audit/scopes.js";

package/src/weekly-log.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { isoWeekString } from "@forwardimpact/libutil";
-import { WEEKLY_LOG_LINE_BUDGET } from "./constants.js";
+import { countLines, countWords } from "./budget.js";
+import { WEEKLY_LOG_LINE_BUDGET, 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.
@@ -11,22 +12,27 @@ export function weeklyLogPath(wikiRoot, agent, today) {
   return path.join(wikiRoot, `${agent}-${isoWeekString(today)}.md`);
 }
 
-function countLines(text) {
-  if (text.length === 0) return 0;
-  let n = 0;
-  for (const ch of text) if (ch === "\n") n++;
-  if (!text.endsWith("\n")) n++;
-  return n;
-}
-
-function nextPartPath(filePath, fs) {
+function partPathAt(filePath, n) {
   const dir = path.dirname(filePath);
   const base = path.basename(filePath, ".md");
-  let n = 1;
-  while (fs.existsSync(path.join(dir, `${base}-part${n}.md`))) n++;
   return path.join(dir, `${base}-part${n}.md`);
 }
 
+// Find `count` part slots that are each verified free, skipping any occupied
+// `-partN.md` (e.g. a numbering gap left by a manually deleted middle part).
+// Every returned slot is unoccupied, so the seal never overwrites a pre-existing
+// part on commit nor unlinks one on rollback.
+function nextFreeSlots(filePath, count, fs) {
+  const slots = [];
+  let n = 1;
+  while (slots.length < count) {
+    const p = partPathAt(filePath, n);
+    if (!fs.existsSync(p)) slots.push(p);
+    n++;
+  }
+  return slots;
+}
+
 function agentTitle(agent) {
   return agent
     .split("-")
@@ -38,9 +44,207 @@ function defaultH1(agent, isoWeekStr) {
   return `# ${agentTitle(agent)} — ${isoWeekStr}\n`;
 }
 
+/** Describe a lone over-cap day-section as a residue at its part index. */
+function residueOf(sec, partIndex, measure) {
+  const { lines, words } = measure(sec.text);
+  return { section: sec.date, lines, words, partIndex };
+}
+
+/**
+ * An over-cap prologue cannot merge with any day-section (adding content only
+ * grows it), so it always seals as its own part 0. Flag it up front as the
+ * first residue so it is never shipped silently over budget.
+ */
+function prologueResidue(prologue, { overBudget, measure }) {
+  if (prologue.length === 0 || !overBudget(prologue)) return null;
+  const { lines, words } = measure(prologue);
+  return { section: "prologue", lines, words, partIndex: 0 };
+}
+
+/**
+ * Greedily pack day-sections into part bodies under both budgets, the prologue
+ * riding with part 1. A chunk that alone exceeds a budget — a lone day-section
+ * or an over-cap prologue — is sealed as its own part and recorded as the
+ * (first) residue; packed runs and single sections are kept under both budgets,
+ * so the only over-cap part bodies are the ones `residue` accounts for.
+ * @param {Array<{date: string, text: string}>} sections
+ * @param {string} prologue - Content above the first seam; rides with part 1.
+ * @param {{overBudget: (s: string) => boolean, measure: (s: string) => {lines: number, words: number}}} budget
+ * @returns {{partBodies: string[], residue: null | {section: string, lines: number, words: number, partIndex: number}}}
+ */
+function packSections(sections, prologue, budget) {
+  const { overBudget, measure } = budget;
+  const partBodies = [];
+  // The prologue, when over budget, is always pushed first (part 0) — record it
+  // before packing so a later lone-section residue cannot displace it.
+  let residue = prologueResidue(prologue, budget);
+  let open = prologue; // body of the part currently being filled
+  let opened = prologue.length > 0;
+  const flush = () => {
+    if (opened) {
+      partBodies.push(open);
+      open = "";
+      opened = false;
+    }
+  };
+  for (const sec of sections) {
+    if (overBudget(sec.text)) {
+      // Irreducible lone day-section: flush the open part, then seal it alone.
+      flush();
+      residue ??= residueOf(sec, partBodies.length, measure);
+      partBodies.push(sec.text);
+    } else if (!opened) {
+      open = sec.text;
+      opened = true;
+    } else if (overBudget(open + sec.text)) {
+      partBodies.push(open);
+      open = sec.text;
+    } else {
+      open += sec.text;
+    }
+  }
+  flush();
+  return { partBodies, residue };
+}
+
 /**
- * Rotate the current weekly log if next append would exceed the budget.
- * @returns {{rotated: boolean, fromPath: string, toPath?: string}}
+ * Split an over-budget weekly-log source at its `## YYYY-MM-DD` day-section
+ * seams into an ordered list of conforming parts. Pure — no I/O.
+ *
+ * The first line of `text` is the original H1; it is consumed and replaced by
+ * per-part H1s, never appearing in a part body. Everything after that first
+ * line is the body, sliced at the day-section seam byte offsets so that
+ * concatenating the parts' bodies reproduces the original body byte-for-byte.
+ * The prologue (any content above the first seam) rides with part 1. Sections
+ * are greedily packed left-to-right under both the line- and word-budget, with
+ * each candidate part measured H1-included so its own H1 is charged.
+ *
+ * When a single chunk alone exceeds a budget — a lone day-section, or the
+ * whole prologue when the source has no day-sections — it is sealed as its own
+ * (over-budget) part and named in `residue`; the rest still packs normally.
+ *
+ * @param {string} text - The full weekly-log source (H1 + body).
+ * @param {string} agent - Agent profile id (e.g. "staff-engineer").
+ * @param {string} isoWeekStr - ISO week label (e.g. "2026-W21").
+ * @returns {{parts: Array<{h1: string, body: string}>, residue: null | {section: string, lines: number, words: number, partIndex: number}}}
+ */
+export function bisectWeeklyLog(text, agent, isoWeekStr) {
+  const nl = text.indexOf("\n");
+  const body = nl === -1 ? "" : text.slice(nl + 1);
+  const title = agentTitle(agent);
+  // `(part N of M)` costs the same 1 line and 4 word-tokens regardless of the
+  // digits in N/M, so a fixed template measures every part exactly without
+  // needing to know M before packing finishes.
+  const h1Template = `# ${title} — ${isoWeekStr} (part 1 of 1)`;
+  const measure = (chunk) => {
+    const rendered = `${h1Template}\n${chunk}`;
+    return { lines: countLines(rendered), words: countWords(rendered) };
+  };
+  const overBudget = (chunk) => {
+    const { lines, words } = measure(chunk);
+    return lines > WEEKLY_LOG_LINE_BUDGET || words > WEEKLY_LOG_WORD_BUDGET;
+  };
+  const partH1 = (n, m) => `# ${title} — ${isoWeekStr} (part ${n} of ${m})`;
+  const finish = (partBodies, residue) => {
+    const m = partBodies.length;
+    return {
+      parts: partBodies.map((b, i) => ({ h1: partH1(i + 1, m), body: b })),
+      residue,
+    };
+  };
+
+  // Locate the day-section seams (date at line-start, trailing suffix
+  // tolerated, e.g. `## 2026-05-19 (third activation)`).
+  const seamRe = /^## (\d{4}-\d{2}-\d{2})/gm;
+  const seams = [];
+  let match;
+  while ((match = seamRe.exec(body)) !== null) {
+    seams.push({ offset: match.index, date: match[1] });
+  }
+
+  // Zero day-sections: the whole body is the prologue and its own single part,
+  // flagged as a residue when it alone exceeds a budget.
+  if (seams.length === 0) {
+    return finish([body], prologueResidue(body, { overBudget, measure }));
+  }
+
+  const prologue = body.slice(0, seams[0].offset);
+  const sections = seams.map((s, i) => ({
+    date: s.date,
+    text: body.slice(
+      s.offset,
+      i + 1 < seams.length ? seams[i + 1].offset : body.length,
+    ),
+  }));
+
+  const { partBodies, residue } = packSections(sections, prologue, {
+    overBudget,
+    measure,
+  });
+  return finish(partBodies, residue);
+}
+
+/**
+ * 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.
+ *
+ * @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 mainTemp = `${filePath}.tmp`;
+  const temps = []; // temp paths this seal wrote, for rollback
+  const committed = []; // slots 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;
+  } catch (e) {
+    for (const slot of committed) {
+      try {
+        fs.unlinkSync(slot);
+      } catch {}
+    }
+    for (const tmp of temps) {
+      try {
+        fs.unlinkSync(tmp);
+      } catch {}
+    }
+    throw e;
+  }
+}
+
+/**
+ * Rotate the current weekly log, sealing an over-budget source into
+ * budget-conforming parts via a bisecting seal. Returns a tagged union:
+ * `{status:"noop"}` (no rotation needed), `{status:"sealed",parts}` (sealed
+ * into one-or-more conforming parts), or `{status:"incomplete",parts,residue}`
+ * (a lone day-section exceeds a budget and is named).
+ *
+ * @returns {{status: "noop"|"sealed"|"incomplete", fromPath: string, parts?: string[], residue?: {path: string, section: string, lines: number, words: number}}}
  * @param {string} wikiRoot
  * @param {string} agent
  * @param {string} today - ISO date string.
@@ -58,16 +262,29 @@ export function rotateIfOverBudget(
 ) {
   const filePath = weeklyLogPath(wikiRoot, agent, today);
   const { force = false } = options;
-  if (!fs.existsSync(filePath)) return { rotated: false, fromPath: filePath };
+  if (!fs.existsSync(filePath)) return { status: "noop", fromPath: filePath };
   const text = fs.readFileSync(filePath, "utf-8");
   const current = countLines(text);
   if (!force && current + appendLines <= WEEKLY_LOG_LINE_BUDGET) {
-    return { rotated: false, fromPath: filePath };
+    return { status: "noop", fromPath: filePath };
+  }
+  const isoWeekStr = isoWeekString(today);
+  const { parts, residue } = bisectWeeklyLog(text, agent, isoWeekStr);
+  const slots = atomicSeal(filePath, parts, agent, isoWeekStr, fs);
+  if (residue === null) {
+    return { status: "sealed", fromPath: filePath, parts: slots };
   }
-  const toPath = nextPartPath(filePath, fs);
-  fs.renameSync(filePath, toPath);
-  fs.writeFileSync(filePath, defaultH1(agent, isoWeekString(today)));
-  return { rotated: true, fromPath: filePath, toPath };
+  return {
+    status: "incomplete",
+    fromPath: filePath,
+    parts: slots,
+    residue: {
+      path: slots[residue.partIndex],
+      section: residue.section,
+      lines: residue.lines,
+      words: residue.words,
+    },
+  };
 }
 
 /**