pi-fold 3.1.0 → 4.1.0

package/extensions/index.js

@@ -11,7 +11,7 @@ export {
 
 const PUBLIC_OPTIONS = Object.freeze([
   "thresholds", "providerInputBudget", "blacklistAutoFoldTools", "toolFoldThreshold",
-  "workingMemory", "postFoldNotice",
+  "preCommitNotice", "noticeLeadShare",
 ]);
 
 const GENERATOR_DELETED = "the model brief generator is deleted (2026-08-14): across 15 sealed " +
@@ -25,11 +25,20 @@ const INVERTED_AUTO_FOLD_LIST = "renamed blacklistAutoFoldTools, and the sense i
   "it meant to permit";
 
 const REFUSED_OPTIONS = Object.freeze({
+  workingMemory: "deleted 2026-08-28: a session-scoped dictionary with remember and recall, "
+    + "offered to one sealed run that never called it once, wire-proven. Retention is a durable "
+    + "store's job and folding is the rotation half, so a second unused memory surface was the "
+    + "bloat the KISS rule exists to remove. Sealed state carrying it still loads, entries dropped",
   guidance: "deleted 2026-08-23: it switched the copy that taught the agent to " +
     "CHOOSE SPANS, and the agent does not choose spans. The runtime cuts at the frontier and " +
     "the agent annotates what it cut, so the guidance it switched is replaced wholesale by " +
-    "the post-fold notice. That notice has its own option, postFoldNotice, which defaults " +
+    "the pre-commit notice. That notice has its own option, preCommitNotice, which defaults " +
     "false: the deterministic shape is what the campaign measured",
+  postFoldNotice: "renamed preCommitNotice on 2026-08-30, and the carrier it switches has " +
+    "changed with it: it fires on occupancy approaching a commit rather than on a count of " +
+    "unbriefed folds, and it STATES the window's status rather than asking the model for " +
+    "briefs, which sol-20260826-full2 scored at 3 correct against 9 wrong. The default is " +
+    "still false; noticeLeadShare sets how far ahead of the commit it speaks",
   toolName: "the deployment identity is hardwired to pi-fold: the tool is pi_fold_context",
   toolLabel: "the deployment identity is hardwired to pi-fold",
   brandNoun: "the deployment identity is hardwired to pi-fold",

package/extensions/lib/brief-text.ts

@@ -0,0 +1,116 @@
+/* THE BOUNDING PRIMITIVES. Pure string rules, no fold state and no host types, so a
+   second consumer can hold the same rules rather than a second implementation of them.
+   Extracted 2026-08-30 when the DeepSeek Harness build became the third runtime that
+   needs them: dsh-fold mirrors this file and nothing else from lib.
+
+   Every deterministic cut in the runtime runs through boundedSubject so a bound always
+   leaves its mark: "..." means exactly "content continues in the exact source", and a
+   reader never mistakes a cut value for a complete one. oneLine collapses whitespace
+   then delegates; factualValue sanitizes then delegates through oneLine. No other site
+   slices. Gate 136 pins this.
+
+   The two brief predicates take their bounds as required arguments here. Their callers
+   in canonical.ts re-export them with the policy defaults applied, so every existing
+   call site is unchanged and the policy stays owned by policy.ts. */
+
+export function boundedSubject(text: string, budget: number): string {
+  if (text.length <= budget) return text;
+  let kept = text.slice(0, Math.max(0, budget - 3)).trimEnd();
+  const finalCode = kept.charCodeAt(kept.length - 1);
+  if (finalCode >= 0xd800 && finalCode <= 0xdbff) kept = kept.slice(0, -1);
+  return `${kept}...`;
+}
+
+export function oneLine(value: string, maximum: number): string {
+  return boundedSubject(value.replace(/\s+/g, " ").trim(), maximum);
+}
+
+/* THE TOOL-CLIP VIEW HEAD (2026-08-24). A clipped result keeps its opening verbatim,
+   not collapsed: the view stays a readable result head in place, unlike a brief's
+   one-line quote. The paragraph rule is gate 134's: an opening block terminated by a
+   blank line is kept whole up to the cap; a result that is bulk from line one keeps its
+   first cap's worth. The caller states the cut, per gate 136: the marker rides beside
+   the count of what it hides, never silently. */
+export function toolClipHead(text: string, cap: number): string {
+  const lines = String(text ?? "").split(/\r?\n/);
+  const kept: string[] = [];
+  for (const line of lines) {
+    if (line.trim()) kept.push(line);
+    else if (kept.length) break;
+  }
+  const paragraph = kept.join("\n");
+  const head = paragraph.length > 0 && paragraph.length <= cap
+    ? paragraph
+    : String(text ?? "").slice(0, cap);
+  return head;
+}
+
+export function usefulBriefWithin(value: unknown, maximum: number, toolName: string): value is string {
+  if (typeof value !== "string") return false;
+  const brief = value.trim();
+  if (!brief || brief.length > maximum) return false;
+  const factualLines: string[] = [];
+  const lines = brief.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const text = lines[index].trim();
+    if (!text || text.toLowerCase().includes(toolName.toLowerCase()) ||
+        /^\[[^\]]*(?:fold|active-context)[^\]]*\]$/i.test(text)) continue;
+    if (/^(?:topology\b|expand\b|refold\b|list(?:\/page)?\b|page\b|action\b|fold(?:ed)?\s+(?:placeholder|uid|id)\b|(?:this\s+)?fold\b.*\b(?:expand|refold|placeholder|topology|uid|id)\b|(?:parent|children?|previous|next|navigation)\s*[:=])/i.test(text)) continue;
+    factualLines.push(text);
+  }
+  const factual = factualLines.join(" ").trim();
+  return /[A-Za-z0-9]{3,}/.test(factual);
+}
+
+export function structurallyValidBriefWithin(value: unknown, maximum: number): value is string {
+  if (typeof value !== "string") return false;
+  const brief = value.trim();
+  return Boolean(brief) && brief.length <= maximum &&
+    (brief.match(/[A-Za-z0-9]/g)?.length ?? 0) >= 3;
+}
+
+/* THE DIVIDED SEATING (extracted 2026-08-30 for the same second consumer). A brief that
+   names several subjects does NOT concatenate and slice: a slice at the cap drops whole
+   subjects with no statement that it did, which is the silent-cut defect gate 136 exists
+   to refuse, one level up. Instead the room left by the lead is divided.
+
+   Two bounds, in order. The count-slice first: room admits at most one subject per
+   minSubjectChars, because a share below that names nothing a reader can use, and every
+   subject past that count is DROPPED AND COUNTED in the tail. Then the char division
+   over the subjects that did seat, ascending by length so a short subject claims only
+   what it needs and returns the rest to the pool; the longest subject is bounded last
+   against everything the shorter ones gave back, which is what lets a note shorter than
+   its fair share ride whole. Ties hold source order, so the output is deterministic.
+
+   Every cut inside a seated subject goes through boundedSubject, so it carries the
+   marker. The caller owns the lead, the minimum and the noun the tail counts, because
+   those are policy; the division is not. */
+export function seatSubjects(
+  subjects: readonly string[],
+  lead: string,
+  options: {
+    readonly total: number;
+    readonly minSubjectChars: number;
+    readonly omittedNoun: string;
+    readonly separator?: string;
+  },
+): string {
+  const separator = options.separator ?? " | ";
+  const room = options.total - lead.length - 1;
+  const named = Math.max(1, Math.min(subjects.length,
+    Math.floor((room + separator.length) / (options.minSubjectChars + separator.length))));
+  const omitted = subjects.length - named;
+  const tail = omitted ? `${separator}${omitted} more ${options.omittedNoun}` : "";
+  const budget = room - tail.length - separator.length * (named - 1);
+  const order = subjects.slice(0, named).map((text, index) => ({ text, index })).sort((a, b) =>
+    a.text.length - b.text.length || a.index - b.index);
+  const bounded = new Array<string>(named);
+  let left = budget;
+  for (let taken = 0; taken < order.length; taken += 1) {
+    const owed = Math.max(1, Math.floor(left / (order.length - taken)));
+    const kept = boundedSubject(order[taken].text, owed);
+    bounded[order[taken].index] = kept;
+    left -= kept.length;
+  }
+  return `${lead}${bounded.join(separator)}${tail}.`.replace(/\s+/g, " ").trim();
+}

package/extensions/lib/canonical.ts

@@ -5,6 +5,7 @@ import {
   stableStringify,
 } from "../json.ts";
 import { ACTIVE_CONTEXT_POLICY, DEFAULT_ACTIVE_CONTEXT_TOOL_NAME } from "./policy.ts";
+import { structurallyValidBriefWithin, usefulBriefWithin } from "./brief-text.ts";
 import type { ActiveContextState } from "./policy.ts";
 
 export function clone<T>(value: T): T {
@@ -185,25 +186,9 @@ export function usefulBrief(
   maximum = ACTIVE_CONTEXT_POLICY.maxBriefChars,
   toolName = DEFAULT_ACTIVE_CONTEXT_TOOL_NAME,
 ): value is string {
-  if (typeof value !== "string") return false;
-  const brief = value.trim();
-  if (!brief || brief.length > maximum) return false;
-  const factualLines: string[] = [];
-  const lines = brief.split(/\r?\n/);
-  for (let index = 0; index < lines.length; index += 1) {
-    const text = lines[index].trim();
-    if (!text || text.toLowerCase().includes(toolName.toLowerCase()) ||
-        /^\[[^\]]*(?:fold|active-context)[^\]]*\]$/i.test(text)) continue;
-    if (/^(?:topology\b|expand\b|refold\b|list(?:\/page)?\b|page\b|action\b|fold(?:ed)?\s+(?:placeholder|uid|id)\b|(?:this\s+)?fold\b.*\b(?:expand|refold|placeholder|topology|uid|id)\b|(?:parent|children?|previous|next|navigation)\s*[:=])/i.test(text)) continue;
-    factualLines.push(text);
-  }
-  const factual = factualLines.join(" ").trim();
-  return /[A-Za-z0-9]{3,}/.test(factual);
+  return usefulBriefWithin(value, maximum, toolName);
 }
 
 export function structurallyValidBrief(value: unknown, maximum = ACTIVE_CONTEXT_POLICY.maxBriefChars): value is string {
-  if (typeof value !== "string") return false;
-  const brief = value.trim();
-  return Boolean(brief) && brief.length <= maximum &&
-    (brief.match(/[A-Za-z0-9]/g)?.length ?? 0) >= 3;
+  return structurallyValidBriefWithin(value, maximum);
 }

package/extensions/lib/curation.ts

@@ -9,104 +9,108 @@ import {
 } from "./policy.ts";
 
 /**
- * THE POST-FOLD NOTICE: THE ONE MOMENT THE AGENT KNOWS SOMETHING THE RUNTIME DOES NOT.
+ * THE PRE-COMMIT NOTICE: STATUS AT THE ONE MOMENT IT CAN STILL BE ACTED ON (2026-08-30).
  *
- * The runtime has just cut folds behind the agent, out of material the agent is still
- * looking at. It knows the spans, the sizes and the staleness; it does not know why any
- * of it mattered. So the notice states what was cut and asks for exactly one thing, a
- * brief, and it states the price of answering, which is nothing: the folds it names are
- * PENDING, so a brief written now is stored outside the projection and reaches the window
- * only when the commit writes that placeholder for the first time.
+ * WHAT THIS REPLACED, AND WHY. Until 2026-08-30 this carrier was a brief SOLICITATION.
+ * It fired on a count of unbriefed folds and its middle sentence read "You know why the
+ * span mattered and what you will want back from it; the automatic brief reads the span
+ * alone and does not." That is flattery in the shape of an instruction: it tells the
+ * model it holds knowledge the runtime lacks at a moment when its actual grounds are a
+ * fold id, a kind and a 160-character head. sol-20260826-full2 priced the result. Agent
+ * briefs drew 3 correct against 9 wrong, the worst of every draw on the campaign, with
+ * the errors tracking the annotations, which is why postFoldNotice was defaulted false
+ * on 2026-08-28 rather than fixed. Shane, 2026-08-30: agent-provided briefs "spent
+ * tokens to confuse themselves", so the carrier should be "less of a suggestion to add
+ * briefs and more informatory".
  *
- * It is batched rather than continuous. One notice per cut is noise, and noise is how
- * guidance gets ignored; this one appears when enough folds are standing unbriefed to be
- * worth a turn's attention, and it is ephemeral, so it never accumulates.
+ * SO IT STATES AND DOES NOT ASK. Every sentence here is a fact the runtime measured:
+ * where the commit fires, how far away it is, what is staged, how much that frees, what
+ * is pinned and what the pin costs. The verbs are a REFERENCE LIST, seated last and
+ * carrying no argument for using any of them. The agent is told what is true and what it
+ * may do; it is not told that it knows something.
+ *
+ * IT SPEAKS ONCE PER APPROACH. The trigger is occupancy, not a fold count, and the caller
+ * latches it on the crossing, so a window that sits in the band for twenty passes gets
+ * one notice rather than twenty. It is ephemeral, so it never accumulates.
+ *
+ * THREE CORRECTIONS OF FACT the old copy could not carry, all of them load-bearing:
+ * pinning is not preservation (folding already preserves; a pin keeps bytes RAW AND IN
+ * VIEW and frees nothing), a staged span has not moved yet, and the headroom figure says
+ * whether it was measured or estimated rather than presenting either as the other.
  */
 export function foldNoticeText(input: {
-  unbriefed: ReadonlyArray<{ id: string; kind: string; tokens: number; brief?: string }>;
-  pending: number;
+  staged: ReadonlyArray<{ id: string; kind: string; tokens: number; brief?: string; briefed?: boolean }>;
+  freedTokens: number;
+  briefedCount: number;
+  pinnedEntries: number;
+  pinnedShare: number;
+  maxPinnedShare: number;
+  headroomTokens: number;
+  commitAtShare: number;
+  measured: boolean;
   toolName: string;
   brandNoun?: string;
 }): string {
   const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  // THE INSTRUCTION IS SEATED BEFORE THE LIST, and the list is what gives when the
-  // notice runs out of room. The first cut of this built one string with the ids in the
-  // opening line and handed the whole thing to the bound, so a seven-fold batch spent its
-  // budget on ids and lost "here is how to answer" off the end: the agent was told which
-  // folds were unbriefed and not told that briefing them was free, which is the only fact
-  // in here it cannot work out for itself. Fold count grows without limit and the
-  // instruction does not, so the instruction is fixed and the ids are the variable part.
-  const head = [
-    `[${brand} folds] ${input.unbriefed.length} of your ${input.pending} pending fold(s) carry ` +
-      "no brief yet. These spans are cut but NOT folded: every byte they cover is still in " +
-      "front of you exactly as it was, and they enter your window only when a commit " +
-      "applies them.",
-    `Give each one a sentence: ${input.toolName} {"action":"brief","id":"<fold-id>","brief":"..."}. ` +
-      "You know why the span mattered and what you will want back from it; the automatic " +
-      "brief reads the span alone and does not. Writing it now costs your window nothing, " +
-      "because the fold is not in your window yet.",
-    `Wrong boundary? ${input.toolName} {"action":"reboundary","ids":[...]} re-cuts it. ` +
-      `Should not be taken at all? ${input.toolName} {"action":"unmark","ids":["<fold-id>"]}.`,
-  ].join("\n");
+  const n = (value: number): string => Math.round(value).toLocaleString("en-US");
+  const pct = (share: number): string => `${Math.round(share * 100)}%`;
+  // THE STATUS IS SEATED BEFORE THE LIST, and the list is what gives when the notice runs
+  // out of room. Inherited unchanged from the solicitation, for the same reason: fold
+  // count grows without limit and the status does not, so a wide batch must not be able
+  // to push the facts off the end and leave a bare row of ids behind.
+  //
+  // MEASURED OR ESTIMATED, NAMED. The runtime's own law is that an estimate may schedule
+  // work and may not veto a request; scheduling this notice off an estimate is squarely
+  // inside that, but presenting an estimate as a count is not, so the basis rides along.
+  const status = [
+    `[${brand} folds] A commit fires at ${pct(input.commitAtShare)} of the serving budget: ` +
+      `about ${n(input.headroomTokens)} tokens of headroom left ` +
+      `(${input.measured ? "provider-measured" : "estimated; no provider count yet"}).`,
+    `Staged: ${n(input.staged.length)} fold${input.staged.length === 1 ? "" : "s"}` +
+      `, ${n(input.briefedCount)} carrying a brief you wrote` +
+      `, freeing about ${n(input.freedTokens)} tokens when the commit applies them.`,
+  ];
+  if (input.pinnedEntries > 0) {
+    status.push(`Pinned: ${n(input.pinnedEntries)} ` +
+      `entr${input.pinnedEntries === 1 ? "y" : "ies"} held raw, ` +
+      `${pct(input.pinnedShare)} of the window against a ${pct(input.maxPinnedShare)} cap.`);
+  }
+  status.push(
+    "Nothing has moved yet: every byte these spans cover is still in front of you, and a " +
+      "staged fold enters your window only when the commit applies it. Folded material " +
+      "stays exactly recoverable through peek. A pin holds an entry raw and in view and " +
+      "frees nothing toward the commit, so pinned mass makes the rest fold sooner.",
+    `Verbs: ${input.toolName} {"action":"status"} · {"action":"brief","id":"<fold-id>","brief":"..."} · ` +
+      '{"action":"reboundary","ids":[...]} · {"action":"unmark","ids":["<fold-id>"]} · ' +
+      '{"action":"pin","ids":["<entry-id>"]} · {"action":"unpin","ids":["<entry-id>"]}.',
+  );
+  const head = status.join("\n");
   // WHAT IT COULD NOT NAME, IT COUNTS (gate 136's law, and gate 115's shape one level
   // out): a list that stops early and says nothing reads as a complete list.
   // EACH ROW IDENTIFIES ITS SPAN. The pending mark carries the deterministic brief the
   // runtime cut it with, and a notice that withholds it makes the agent guess: the
   // dogfooded 1M session answered "I need to brief three pending folds. What are they?
   // Likely: ..." from memory, and a wrong guess writes an accurate-sounding brief onto
-  // the wrong fold. The head is the identification; the agent adds what it cannot know.
+  // the wrong fold. The row is the identification, and it now names EVERY staged fold
+  // rather than only the unbriefed ones, because this is a status: a list that silently
+  // omitted the briefed folds would understate what the commit is about to take.
   const NOTICE_ROW_CHARS = 160;
-  const entries = input.unbriefed
-    .map((fold) => `${fold.id} (${fold.kind}, ~${fold.tokens} tokens)` +
+  const entries = input.staged
+    .map((fold) => `${fold.id} (${fold.kind}, ~${fold.tokens} tokens` +
+      `${fold.briefed ? ", briefed" : ""})` +
       (fold.brief ? `: ${oneLine(fold.brief, NOTICE_ROW_CHARS)}` : ""));
   const overflowText = (seated: number) =>
-    `${input.toolName} {"action":"status"} lists the other ${input.unbriefed.length - seated}.`;
+    `${input.toolName} {"action":"status"} lists the other ${input.staged.length - seated}.`;
   let seated = entries.length;
-  let list = `Unbriefed: ${entries.join("; ")}.`;
-  while (seated > 0 && Buffer.byteLength(`${head}\n${list}`, "utf8") > FOLD_NOTICE_BYTES) {
-    seated -= 1;
-    list = seated === 0
-      ? overflowText(0)
-      : `Unbriefed: ${entries.slice(0, seated).join("; ")}. ${overflowText(seated)}`;
-  }
-  return boundReceiptText(`${head}\n${list}`, FOLD_NOTICE_BYTES,
-    `[${brand} folds] Pending folds are waiting for briefs; the list is unavailable this pass.`);
-}
-
-/**
- * THE WORKING MEMORY'S TABLE OF CONTENTS (Shane, 2026-08-26). One copy rides the
- * projection, refreshed at each commit by the carrier freeze: keys only, freshest first,
- * because the bodies live in state and are read on demand. The instruction is fixed and
- * the key list is the variable part, exactly as the fold notice above, and a list that
- * stops early counts what it dropped (gate 136's law). It shares FOLD_NOTICE_BYTES: both
- * are one-glance carriers and a second bound would be a knob with no second job.
- */
-export function memoryTocText(input: {
-  entries: ReadonlyArray<{ key: string; chars: number }>;
-  toolName: string;
-  brandNoun?: string;
-}): string {
-  const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  const head = [
-    `[${brand} memory] Your working memory holds ${input.entries.length} ` +
-      `entr${input.entries.length === 1 ? "y" : "ies"}, freshest first.`,
-    `Read any of them with ${input.toolName} {"action":"recall","keys":["<key>"]}. ` +
-      `Update an entry whose facts have changed, or add one, with ${input.toolName} ` +
-      '{"action":"remember","key":"<key>","body":"..."}; an empty body removes the entry.',
-  ].join("\n");
-  const rows = input.entries.map((entry) => `${entry.key} (${entry.chars} chars)`);
-  const overflowText = (seated: number) =>
-    `${input.toolName} {"action":"recall"} lists the other ${input.entries.length - seated}.`;
-  let seated = rows.length;
-  let list = `Entries: ${rows.join("; ")}.`;
+  let list = `Staged spans: ${entries.join("; ")}.`;
   while (seated > 0 && Buffer.byteLength(`${head}\n${list}`, "utf8") > FOLD_NOTICE_BYTES) {
     seated -= 1;
     list = seated === 0
       ? overflowText(0)
-      : `Entries: ${rows.slice(0, seated).join("; ")}. ${overflowText(seated)}`;
+      : `Staged spans: ${entries.slice(0, seated).join("; ")}. ${overflowText(seated)}`;
   }
   return boundReceiptText(`${head}\n${list}`, FOLD_NOTICE_BYTES,
-    `[${brand} memory] Working memory has entries; the list is unavailable this pass.`);
+    `[${brand} folds] A commit is approaching; the staged list is unavailable this pass.`);
 }
 
 export interface ContextReceipt {
@@ -213,3 +217,133 @@ export function receiptBlockText(input: {
   }
   return [header, ...kept, verbs].join("\n");
 }
+
+const STATUS_BAR_WIDTH = 24;
+
+/**
+ * /fold-status: THE TEXT VIEW, FOR A PERSON.
+ *
+ * What this replaced said, in full: "Active context: 12 fold(s), roots a1b2, c3d4. Use
+ * pi_fold_context status for exact recursive actions." Three things were wrong with it.
+ * It told a HUMAN to call an AGENT tool they have no way to invoke. It printed fold ids,
+ * which are addresses for a machine and noise for a reader. And it answered a question
+ * nobody asks (how many folds exist) while leaving the only ones they do ask unanswered:
+ * how full am I, when does something happen, and what can I do about it.
+ *
+ * The command survives rather than being deleted because it is the documented fallback
+ * when /fold-editor cannot open, which is any session without an interactive UI. That
+ * makes it the ONLY window view some deployments ever get, so it carries what the editor
+ * header carries and closes by naming the two commands that act.
+ *
+ * Occupancy is stated as the provider's own measurement when there is one, and as
+ * "not measured yet" when there is not. It is never guessed: a made-up percentage is
+ * worse than an absent one, and this runtime has already paid once for treating an
+ * estimate as though it were a fact.
+ */
+export function foldStatusText(input: {
+  brand?: string;
+  usedTokens: number | null;
+  budgetTokens: number;
+  commitAtShare: number;
+  aimShare: number;
+  roots: number;
+  totalFolds: number;
+  stagedMarks: number;
+  stagedTokens: number;
+  pinned: number;
+  suspended: string | null;
+  foldCommand: string;
+  editorCommand: string;
+}): string {
+  const brand = contextBrand(input.brand ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
+  const n = (value: number): string => Math.round(value).toLocaleString("en-US");
+  const lines: string[] = [`[${brand} status]`];
+
+  if (input.usedTokens === null || !(input.budgetTokens > 0)) {
+    // "provider" is infrastructure vocabulary and "sets it" names no observable event.
+    lines.push("  Window   not measured yet; the first model response will measure it.");
+  } else {
+    const share = input.usedTokens / input.budgetTokens;
+    const filled = Math.max(0, Math.min(STATUS_BAR_WIDTH, Math.round(share * STATUS_BAR_WIDTH)));
+    const bar = `${"▇".repeat(filled)}${"░".repeat(STATUS_BAR_WIDTH - filled)}`;
+    lines.push(`  Window   ${bar}  ${Math.round(share * 100)}%  ` +
+      `${n(input.usedTokens)} / ${n(input.budgetTokens)} tokens`);
+    const commitAt = input.commitAtShare * input.budgetTokens;
+    // The headroom is what a person actually wants: not the trigger's share, but how much
+    // further this session goes before anything happens to it.
+    //
+    // A SUSPENDED SESSION IS PROMISED NOTHING. This line used to say "the next pass folds
+    // down toward 20%" one line above "Automatic folding is suspended", so the surface
+    // contradicted itself about the only thing the reader opened it to find out.
+    lines.push(input.suspended
+      ? `           At the ${Math.round(input.commitAtShare * 100)}% commit point.`
+      : share >= input.commitAtShare
+        ? `           At the ${Math.round(input.commitAtShare * 100)}% commit point; ` +
+          `folding now targets ${Math.round(input.aimShare * 100)}%.`
+        // "Commits at 80%" reads for a beat as a plural noun, or as a verb with no
+        // subject, and the missing subject is the PRODUCT: no surface anywhere said the
+        // runtime folds BY ITSELF, so a reader assembling this line with "/fold commits
+        // them now" concludes they have installed a manual tool.
+        : `           Folds automatically at ${Math.round(input.commitAtShare * 100)}%; ` +
+          `${n(commitAt - input.usedTokens)} tokens away.`);
+  }
+  // THE STOP SITS DIRECTLY UNDER THE WINDOW, not below three rows of routine counts.
+  // The order answers the reader's questions in the order they ask them: are we at the
+  // threshold, will anything fold, and why not.
+  if (input.suspended) {
+    lines.push("  STOPPED  Automatic folding is suspended.");
+    lines.push(`           Reason: ${oneLine(input.suspended, 160)}`);
+  }
+
+  // VISIBLE FIRST, AND THE UNIT NAMED. The always-on line counts visible roots and this
+  // one led with the total, so the two surfaces looked like they disagreed about how many
+  // folds exist. "Top level" is tree-implementation language; "visible" is what a reader
+  // can check against the editor in front of them.
+  lines.push(input.totalFolds === 0
+    ? "  Folded   nothing yet."
+    // "Each keeps its exact source" says the bytes survive but never says a SUMMARY stands
+    // where they were, and the likeliest wrong model a reader forms is that folded
+    // material is simply gone. One clause teaches what a fold actually is.
+    : `  Folded   ${n(input.roots)} here, ${n(input.totalFolds)} with nesting; ` +
+      "each a summary over its exact source.");
+
+  if (input.stagedMarks > 0) {
+    // TWO CORRECTIONS IN ONE LINE.
+    //
+    // It said "holding about 28,400 tokens" about a number that is the sum of
+    // markFreedBytes: what a commit FREES, which is the same figure the editor header
+    // prints as "frees". One surface called it held and the other called it freed, and
+    // held was the wrong one.
+    //
+    // And the brief count is gone, input field and all. It counted provenance "supplied"
+    // or "augmented", and a brief the USER types on the editor's brief line is "supplied",
+    // so the row told a person the sentence they had just written was somebody else's.
+    // Nothing on any surface can add a brief to an already-staged mark either, so it was
+    // a number that could be wrong and could not be acted on.
+    //
+    // What remains leads with the fact that stops "staged" being read as "already
+    // applied", and fits inside 80 columns, where the old 105-character line wrapped with
+    // its continuation flush left inside the label field, reading as a fifth label.
+    lines.push(`  Staged   ${n(input.stagedMarks)} fold${input.stagedMarks === 1 ? "" : "s"}; ` +
+      `nothing moves until a commit frees about ${n(input.stagedTokens)} tokens.`);
+  }
+  if (input.pinned > 0) {
+    lines.push(`  Pinned   ${n(input.pinned)} entr${input.pinned === 1 ? "y" : "ies"} ` +
+      `stay${input.pinned === 1 ? "s" : ""} raw; ` +
+      `${input.pinned === 1 ? "it does" : "they do"} not free space.`);
+  }
+  // The closing line offers only what is actually available: proposing a commit with
+  // nothing staged is an instruction that does nothing, which is the failure the deleted
+  // fence made unforgivable.
+  // "commits them" took its antecedent from whichever row happened to come last, which is
+  // Pinned as often as Staged. Name the object.
+  lines.push(input.stagedMarks > 0
+    // 78, not 80: pi-tui wraps at width minus two, so an 80-column line still wraps on an
+    // 80-column terminal, and its continuation lands flush left in the label field.
+    ? `  ${input.foldCommand} commits the staged folds; ${input.editorCommand} opens the window to steer it.`
+    // THE FRESH SESSION IS WHERE THE WRONG MODEL FORMS, so this is the line that has to
+    // say folding is automatic. A reader who meets the package here and reads only
+    // command names concludes nothing happens unless they type one.
+    : `  Folding is automatic; ${input.editorCommand} shows the window and ${input.foldCommand} commits early.`);
+  return lines.join("\n");
+}