@forwardimpact/libwiki 0.2.15 → 0.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libwiki",
-  "version": "0.2.15",
+  "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: "sealed parts should already be at-or-under the cap; if not, the rotation that produced this part needs investigation",
+    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: "sealed parts should already be at-or-under the cap; if not, the rotation that produced this part needs investigation",
+    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

@@ -1,13 +1,18 @@
 import path from "node:path";
 import { yearMonth } from "@forwardimpact/libutil";
 import { parseClaims } from "../active-claims.js";
-import { PRIORITY_INDEX_HEADING } from "../constants.js";
-
-const SUMMARY_H1_RE = /^# [A-Z].* — Summary$/;
-const WEEKLY_LOG_NAME_RE = /^([a-z][a-z-]*)-(\d{4})-W(\d{2})\.md$/;
-const WEEKLY_LOG_PART_NAME_RE = /^([a-z][a-z-]*)-(\d{4})-W(\d{2})-part\d+\.md$/;
+import { countLines, countWords } from "../budget.js";
+import {
+  PRIORITY_INDEX_HEADING,
+  WEEKLY_LOG_NAME_RE,
+  WEEKLY_LOG_PART_NAME_RE,
+} from "../constants.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]`).
+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;
 
@@ -28,25 +33,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");
@@ -73,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)) {
@@ -90,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,
@@ -142,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),
   };
 }
 
@@ -245,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/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

@@ -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";
 
@@ -85,19 +89,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 +103,79 @@ 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, 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);
+  }
+}
+
+/**
+ * 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, res.toPath)}\n`,
+          `${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);
   }
 }
 
@@ -226,15 +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,
-    });
+    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/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/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,8 +32,11 @@ export {
   isoWeek,
   weeklyLogPath,
   rotateIfOverBudget,
+  rebisectOverBudgetPart,
+  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/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,6 +1,11 @@
 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_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.
@@ -11,22 +16,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 +48,220 @@ 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 };
+}
+
+/**
+ * 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);
+}
+
 /**
- * Rotate the current weekly log if next append would exceed the budget.
- * @returns {{rotated: boolean, fromPath: string, toPath?: string}}
+ * 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 {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 leading paths, in commit order.
+ */
+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 {
+    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 p of committed) {
+      try {
+        fs.unlinkSync(p);
+      } catch {}
+    }
+    for (const t of temps) {
+      try {
+        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:
+ * `{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 +279,141 @@ 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 };
+  }
+  return {
+    status: "incomplete",
+    fromPath: filePath,
+    parts: slots,
+    residue: {
+      path: slots[residue.partIndex],
+      section: residue.section,
+      lines: residue.lines,
+      words: residue.words,
+    },
+  };
+}
+
+/**
+ * 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 };
   }
-  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: partPath,
+    parts: slots,
+    residue: {
+      path: slots[residue.partIndex],
+      section: residue.section,
+      lines: residue.lines,
+      words: residue.words,
+    },
+  };
 }
 
 /**