pi-fold 3.0.0 → 4.0.0

package/extensions/evidence.js

@@ -562,10 +562,6 @@ function mcpServerForTool(toolName, fallback) {
     : fallback;
 }
 
-function conventionalMcpTool(toolName) {
-  return mcpServerForTool(toolName, null) !== null;
-}
-
 export function registerEvidenceIngestion(pi, {
   entryTypePrefix = DEFAULT_ACTIVE_CONTEXT_ENTRY_TYPE_PREFIX,
 } = {}) {
@@ -626,7 +622,7 @@ export function registerEvidenceIngestion(pi, {
       return projectEvidenceText(text, descriptor, "utf8-head", truncation ? { truncation } : undefined);
     }
 
-    if (conventionalMcpTool(toolName)) {
+    if (mcpServerForTool(toolName, null) !== null) {
       const envelope = eventEnvelope(event);
       const serialized = `${stableStringify(envelope)}\n`;
       if (utf8Bytes(serialized) <= TOOL_RESULT_PROJECTION_BYTES) return;

package/extensions/index.js

@@ -10,7 +10,8 @@ export {
 } from "./settings.ts";
 
 const PUBLIC_OPTIONS = Object.freeze([
-  "thresholds", "providerInputBudget", "blacklistAutoFoldTools",
+  "thresholds", "providerInputBudget", "blacklistAutoFoldTools", "toolFoldThreshold",
+  "postFoldNotice",
 ]);
 
 const GENERATOR_DELETED = "the model brief generator is deleted (2026-08-14): across 15 sealed " +
@@ -24,11 +25,15 @@ 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, which is not optional: a fold the agent is never told about is one " +
-    "it can never brief",
+    "the post-fold notice. That notice has its own option, postFoldNotice, which defaults " +
+    "false: the deterministic shape is what the campaign measured",
   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/json.ts

@@ -194,8 +194,30 @@ export function isObjectRef(value: unknown): value is EvidenceRef {
     typeof sha256 === "string" && reflectApply(regexpTest, sha256Pattern, [sha256]);
 }
 
+// THE HOT PATH (issue #2, 2026-08-28). This is the most-called function in the package:
+// every mark, span, claim, eligibility and measurement pass keys its refs through it,
+// and a reporter profiling a 467KB window found the serializer under it at the top of a
+// V8 profile with the process pegged at 80 percent for forty minutes. The general
+// serializer earns its cost on arbitrary values, checking for proxies, cycles, accessors
+// and non-plain prototypes; none of that is in question for three strings off a ref.
+//
+// The output is IDENTICAL, not merely equivalent, and that is the whole design of this
+// shape: safeJson emits object keys in own-property order rather than sorted, so the
+// literal below is the same byte sequence its object form produced, and string escaping
+// is native JSON.stringify on both paths. It matters because these keys order
+// `protectionSha256`'s sort and reach `branchSha256`'s missing-digest, so a format that
+// merely round-trips would move digests that sealed sessions carry. Anything that is not
+// three strings falls through to the serializer, which owns every remaining case.
+// Measured 8.5x, 4.27us to 0.50us per call, over 2,000 refs. Gate 150 pins the identity.
 export function objectRefKey(ref: EvidenceRef): string {
-  return stableStringify({ sessionId: ref.sessionId, entryId: ref.entryId, role: ref.role });
+  const sessionId = ref.sessionId;
+  const entryId = ref.entryId;
+  const role = ref.role;
+  if (typeof sessionId === "string" && typeof entryId === "string" && typeof role === "string") {
+    return `{"sessionId":${jsonStringify(sessionId)},"entryId":${jsonStringify(entryId)},` +
+      `"role":${jsonStringify(role)}}`;
+  }
+  return stableStringify({ sessionId, entryId, role });
 }
 
 export function sameObjectIdentity(left: EvidenceRef, right: EvidenceRef): boolean {

package/extensions/lib/canonical.ts

@@ -15,6 +15,40 @@ export function bytes(value: unknown): number {
   return Buffer.byteLength(typeof value === "string" ? value : stableStringify(value), "utf8");
 }
 
+/**
+ * Does `heldText`, the serialization of the first `held` elements, stand as a prefix of
+ * `bodyText`, the serialization of the whole array?
+ *
+ * ARRAY SERIALIZATION IS PREFIX-FREE BY CONSTRUCTION, which is the whole reason this can be
+ * answered from a string the caller already has instead of by serializing a slice. `safeJson`
+ * emits `[`, then the elements separated by `,`, then `]`: no whitespace, no trailing comma.
+ * So the serialization of the first `held` elements is exactly the head of the whole one with
+ * `]` in place of the `,` that follows element `held - 1`.
+ *
+ * The two ends break that rule and are branched on rather than argued away. At `held` 0 the
+ * prefix is `[]` and there is no comma to match, so testing `"[," ` would be nonsense. At
+ * `held === length` there is no following element and the two strings are simply equal.
+ *
+ * The comma is the reason this is not a bare `startsWith`, and it is worth being exact about
+ * when it earns its place. JSON's object and string forms SELF-TERMINATE, with `}` and a
+ * closing quote, so for the message arrays this has one caller for, a bare `startsWith` would
+ * happen to agree. Numbers do not self-terminate: `[1]` is a leading substring of `[12]` and
+ * a bare `startsWith` accepts it. The separator is what makes the predicate correct for any
+ * array rather than for today's caller, and a false positive in that caller splices a stale
+ * head in front of a live tail. Gate 154 drives the numeric case for exactly this reason.
+ */
+export function serializedPrefixHolds(
+  bodyText: string,
+  heldText: string | null | undefined,
+  held: number,
+  length: number,
+): boolean {
+  if (heldText === null || heldText === undefined || length < held) return false;
+  if (held === 0) return heldText === "[]";
+  if (held === length) return bodyText === heldText;
+  return bodyText.startsWith(`${heldText.slice(0, -1)},`);
+}
+
 export function boundedUtf8(text: string, maximumBytes: number): string {
   const buffer = Buffer.from(text, "utf8");
   if (buffer.length <= maximumBytes) return text;

package/extensions/lib/curation.ts

@@ -1,4 +1,5 @@
 import { boundReceiptText } from "./measurement.ts";
+import { oneLine } from "./selection.ts";
 import {
   contextBrand,
   CONTEXT_RECEIPT_BLOCK_BYTES,
@@ -22,7 +23,7 @@ import {
  * worth a turn's attention, and it is ephemeral, so it never accumulates.
  */
 export function foldNoticeText(input: {
-  unbriefed: ReadonlyArray<{ id: string; kind: string; tokens: number }>;
+  unbriefed: ReadonlyArray<{ id: string; kind: string; tokens: number; brief?: string }>;
   pending: number;
   toolName: string;
   brandNoun?: string;
@@ -49,8 +50,15 @@ export function foldNoticeText(input: {
   ].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.
+  const NOTICE_ROW_CHARS = 160;
   const entries = input.unbriefed
-    .map((fold) => `${fold.id} (${fold.kind}, ~${fold.tokens} tokens)`);
+    .map((fold) => `${fold.id} (${fold.kind}, ~${fold.tokens} tokens)` +
+      (fold.brief ? `: ${oneLine(fold.brief, NOTICE_ROW_CHARS)}` : ""));
   const overflowText = (seated: number) =>
     `${input.toolName} {"action":"status"} lists the other ${input.unbriefed.length - seated}.`;
   let seated = entries.length;
@@ -65,6 +73,7 @@ export function foldNoticeText(input: {
     `[${brand} folds] Pending folds are waiting for briefs; the list is unavailable this pass.`);
 }
 
+
 export interface ContextReceipt {
   kind: string;
   ordinal: number;
@@ -76,8 +85,6 @@ export interface ContextReceipt {
   occupancyAfter: number | null;
   spansFolded: number;
   toolResultsFolded: number;
-  splitFolds: number;
-  splitFromChars: number;
   absorbedWedges: number;
   recovered: boolean;
   protectedBytes: number;
@@ -96,8 +103,6 @@ export function contextReceipt(input: Partial<ContextReceipt> & { kind: string;
     occupancyAfter: input.occupancyAfter ?? null,
     spansFolded: input.spansFolded ?? 0,
     toolResultsFolded: input.toolResultsFolded ?? 0,
-    splitFolds: input.splitFolds ?? 0,
-    splitFromChars: input.splitFromChars ?? 0,
     absorbedWedges: input.absorbedWedges ?? 0,
     recovered: input.recovered ?? false,
     protectedBytes: input.protectedBytes ?? 0,
@@ -128,9 +133,6 @@ export function receiptLine(receipt: ContextReceipt): string {
     `about ${receipt.freedTokens} tokens freed.`,
     occupancy,
     folded,
-    receipt.splitFolds
-      ? `A ${receipt.splitFromChars}-char span was split into ${receipt.splitFolds} bite-sized folds.`
-      : "",
     receipt.absorbedWedges
       ? `${receipt.absorbedWedges} short stale span(s) wedged between folds were absorbed into their ` +
         "later neighbour rather than left as crumbs."
@@ -176,3 +178,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");
+}

package/extensions/lib/editor-ui.ts

@@ -50,6 +50,9 @@ export interface FoldEditorData {
 		budgetTokens: number;
 		commitOccupancy: number;
 		commitDue: boolean;
+		/** Automatic folding has stopped. The editor is the surface a person opens in order
+		 *  to ACT, and without this it priced a countdown to a commit that cannot fire. */
+		suspended?: boolean;
 	};
 	/** Top-level blocks only: raw gaps and ROOT folds, in window order. */
 	blocks: FoldEditorBlock[];
@@ -72,13 +75,38 @@ export function occupancyBar(usedTokens: number | null, budgetTokens: number): s
 		? Math.max(0, Math.min(1, usedTokens / budgetTokens))
 		: 0;
 	const filled = Math.round(ratio * BAR_WIDTH);
-	return `${"█".repeat(filled)}${"·".repeat(BAR_WIDTH - filled)}`;
+	// THE SAME ALPHABET /fold-status USES. The editor drew its empty cells with the middle
+	// dot that also separates the fields on that very line, so the bar's tail and the
+	// line's punctuation were the same glyph doing two jobs.
+	return `${"▇".repeat(filled)}${"░".repeat(BAR_WIDTH - filled)}`;
 }
 
 function shortId(id: string): string {
 	return id.length > 12 ? id.slice(0, 12) : id;
 }
 
+/**
+ * MARK ORIGINS IN THE READER'S OWN WORDS. The state's names are for the state: "ladder"
+ * is this runtime's internal name for its own automatic marking pass, and a person
+ * reading a proposed row needs to know WHO proposed the fold, not which code path
+ * staged it. An unrecognized origin passes through rather than being hidden, because a
+ * name we do not have a word for is still better than a blank.
+ *
+ * ONE WORD FOR ONE THING (2026-08-28): the rows said PROPOSED while the header said
+ * staged, for the same marks on the same screen, which asks a reader to learn that two
+ * words mean one thing before they can read either line.
+ */
+const ORIGIN_WORDS: Record<string, string> = {
+	ladder: "automatic",
+	agent: "the model",
+	user: "you",
+};
+
+function originWord(origin: string | undefined): string {
+	if (!origin) return "staged";
+	return ORIGIN_WORDS[origin] ?? origin;
+}
+
 /**
  * Assemble the top-level window stream. Committed folds nest by containment (a fold
  * whose span sits inside another becomes a CHILD of the innermost container), so the
@@ -165,7 +193,9 @@ export function buildFoldEditorData(
 		if (block.type === "raw") {
 			const roles = new Map<string, number>();
 			for (const entry of block.entries) roles.set(entry.role, (roles.get(entry.role) ?? 0) + 1);
-			block.rolesSummary = [...roles.entries()].map(([role, count]) => `${role}×${count}`).join(" ");
+			// "user×2 assistant×3" put the count behind the same bare multiplication sign the
+			// fold rows just lost. Count first, noun second, like everything else here.
+			block.rolesSummary = [...roles.entries()].map(([role, count]) => `${count} ${role}`).join(", ");
 		}
 	}
 
@@ -326,12 +356,25 @@ export class FoldEditorView {
 		const foldKey = `${keyPrefix}${block.id}`;
 		const isOpen = this.expanded.has(foldKey);
 		const pad = "  ".repeat(depth);
-		const kindLabel = `${block.kind} \u00d7${block.sourceCount}`;
+		// THE ROW SAYS WHAT WAS FOLDED (2026-08-28). It read "fold fold_a1b2c3 chapter ×9":
+		// the word "fold" twice (the ▸ glyph is already the word), thirteen columns of an
+		// id nothing in this view accepts as input, and the brief that says what the fold
+		// COVERS hidden behind Enter. Twelve roots differed only by hex, which recreates
+		// inside the editor the exact defect /fold-status was rewritten to remove.
+		//
+		// The id is dropped rather than trailed: it is unusable here, the expanded state
+		// still carries it on the end bookend, and a trailing id is what truncation eats
+		// first anyway. "×9" becomes a counted noun, because ×9 could be entries, nesting
+		// depth or generations and the reader has no way to tell which.
+		const kindLabel = `${block.kind} · ${block.sourceCount} ` +
+			`${block.sourceCount === 1 ? "entry" : "entries"}`;
 		const marker = isOpen ? "\u25bc" : "\u25b8";
 		const foldCursor = this.selectedKey === foldKey ? "\u276f" : " ";
+		const [foldHead] = briefChunks(block.brief ?? "");
 		rows.push({
 			key: foldKey,
-			text: `${foldCursor}${this.color("success", `${pad}${marker} fold ${shortId(block.id)}`)} ${kindLabel}`,
+			text: `${foldCursor}${this.color("success", `${pad}${marker} ${kindLabel}`)}` +
+				`${foldHead ? ` · ${foldHead}` : ""}`,
 			toggleId: foldKey,
 		});
 		if (!isOpen) return;
@@ -391,10 +434,17 @@ export class FoldEditorView {
 			if (block.type === "proposed") {
 				const isLadder = block.origin === "ladder";
 				const color = isLadder ? "warning" : "accent";
-				const sizeNote = typeof block.tokens === "number" ? ` · ~${block.tokens.toLocaleString("en-US")} tok` : "";
+				const sizeNote = typeof block.tokens === "number"
+					? ` · frees ~${block.tokens.toLocaleString("en-US")} tokens` : "";
+				const [stagedHead] = briefChunks(block.brief ?? "");
 				rows.push({
 					key: block.id,
-					text: `${cursor}${this.color(color, `\u25c7 PROPOSED (${block.origin}) ${shortId(block.id)}`)} \u00d7${block.sourceCount}${sizeNote}${this.selectedKey === block.id ? " · u:withdraw" : ""}`,
+					// Same treatment as the fold row: no id, a counted noun, and the brief seated
+					// as the tail so it is what degrades if the terminal is narrow.
+					text: `${cursor}${this.color(color, `\u25c7 staged by ${originWord(block.origin)}`)}` +
+						` · ${block.sourceCount} ${block.sourceCount === 1 ? "entry" : "entries"}${sizeNote}` +
+						`${stagedHead ? ` · ${stagedHead}` : ""}` +
+						`${this.selectedKey === block.id ? " · u:withdraw" : ""}`,
 					toggleId: block.id,
 					proposedMarkId: block.id,
 				});
@@ -421,7 +471,8 @@ export class FoldEditorView {
 					}
 				}
 			} else {
-				const label = `\u00b7 raw \u00d7${block.sourceCount}` +
+				const label = `\u00b7 raw · ${block.sourceCount} ` +
+					`${block.sourceCount === 1 ? "entry" : "entries"}` +
 					`${block.rolesSummary ? ` ${block.rolesSummary}` : ""}`;
 				rows.push({
 					key: block.id,
@@ -675,29 +726,79 @@ export class FoldEditorView {
 		const lines: string[] = [];
 		const { occupancy, pending } = this.data;
 		lines.push(truncateToWidth(`── ${this.data.title} ──`, width));
-		const percent = occupancy.usedTokens !== null && occupancy.budgetTokens > 0
-			? ((occupancy.usedTokens / occupancy.budgetTokens) * 100).toFixed(1)
-			: "?";
-		const usedTokensText = occupancy.usedTokens !== null
-			? occupancy.usedTokens.toLocaleString("en-US")
-			: "?";
+		// UNMEASURED IS PROSE, NEVER A BAR. An empty bar beside "?%" reads to the eye as
+		// a window that is 0 percent full, which is a guess wearing the costume of a
+		// measurement: the exact failure the other three surfaces already refuse, on the
+		// one surface the rule was never checked against. Nothing here is estimated.
+		if (occupancy.usedTokens === null || !(occupancy.budgetTokens > 0)) {
+			lines.push(truncateToWidth(
+				"window not measured yet; the first model response will measure it", width));
+			for (const line of this.stagedLines()) lines.push(truncateToWidth(line, width));
+			return lines;
+		}
+		// A WHOLE PERCENT. The tenth was false precision on a figure that moves with every
+		// message, and it read as a measurement finer than the thing being measured. The
+		// other three human surfaces round, so this one does too. Past the guard above,
+		// both values are known, so neither can render as "?".
+		const percent = Math.round((occupancy.usedTokens / occupancy.budgetTokens) * 100);
+		const usedTokensText = occupancy.usedTokens.toLocaleString("en-US");
+		// The DISTANCE to the commit, not just the share it fires at. "commit at 80%" is
+		// a property of the configuration; "29,674 to go" is the answer to the question
+		// the reader actually has, and it is the same number /fold-status states.
+		const headroom = occupancy.usedTokens !== null && occupancy.budgetTokens > 0 && !occupancy.commitDue
+			? ` (${Math.round(occupancy.commitOccupancy * occupancy.budgetTokens - occupancy.usedTokens)
+				.toLocaleString("en-US")} to go)`
+			: "";
+		// Same ordering rule as the line below it: the raw token pair is the most
+		// expendable thing here, because the percentage in front of it already says what
+		// it says. At 80 columns the first draft cut the headroom instead.
+		// A STOPPED WINDOW IS TOLD SO, NOT GIVEN A COUNTDOWN. Every other surface reports
+		// the suspension and this one alone kept pricing the distance to a commit that
+		// will not happen, which is the one state here that can cost somebody a session.
+		const timing = occupancy.suspended
+			? " · FOLDING STOPPED"
+			: ` · commit at ${(occupancy.commitOccupancy * 100).toFixed(0)}%${headroom}` +
+				`${occupancy.commitDue ? " · COMMIT DUE" : ""}`;
 		lines.push(truncateToWidth(
 			`${occupancyBar(occupancy.usedTokens, occupancy.budgetTokens)} ` +
-			`${percent}% · ${usedTokensText}/${occupancy.budgetTokens.toLocaleString("en-US")} tokens · ` +
-			`commit at ${(occupancy.commitOccupancy * 100).toFixed(0)}%` +
-			`${occupancy.commitDue ? " · COMMIT DUE" : ""}`,
-			width,
-		));
-		lines.push(truncateToWidth(
-			`staged marks: ${pending.count} (${pending.agentMarks} agent, ${pending.ladderMarks} ladder` +
-			`${pending.userMarks > 0 ? `, ${pending.userMarks} you` : ""})` +
-			` · about ${pending.freedTokens.toLocaleString("en-US")} tokens freed when committed · ` +
-			`pinned: ${this.data.pinned.length}`,
+			`${percent}%${timing}` +
+			` · ${usedTokensText}/${occupancy.budgetTokens.toLocaleString("en-US")}`,
 			width,
 		));
+		for (const line of this.stagedLines()) lines.push(truncateToWidth(line, width));
 		return lines;
 	}
 
+	/**
+	 * ORDERED SO TRUNCATION COSTS THE LEAST. This line is cut to the terminal's width, and
+	 * at 100 columns the first draft lost the pin count off the end while spending its
+	 * width on who staged what. What the marks free and what is pinned are facts about the
+	 * window; the origin breakdown is colour, so it goes last.
+	 */
+	private stagedLines(): string[] {
+		const { pending } = this.data;
+		// The same vocabulary as ORIGIN_WORDS above, inflected for a count rather than a
+		// label: "1 automatic" and "2 by the model" read where "2 the model" does not.
+		// Only origins that actually staged something are listed, because a run of zeroes
+		// spends the line's width saying nothing happened three different ways.
+		const origins = [
+			pending.ladderMarks > 0 ? `${pending.ladderMarks} automatic` : "",
+			pending.agentMarks > 0 ? `${pending.agentMarks} by the model` : "",
+			pending.userMarks > 0 ? `${pending.userMarks} yours` : "",
+		].filter((part) => part !== "").join(", ");
+		// TWO LINES RATHER THAN ONE THAT RUNS OFF THE TERMINAL. At 97 characters the single
+		// line ended mid-phrase at "2 by the model" on any normal window; vertical space is
+		// cheaper than a sentence cut in half. The facts about the window come first and
+		// who staged what follows, so a narrow terminal still keeps the first line whole.
+		// "folds" not "marks": /fold-status and the always-on line both say folds, and one
+		// object carrying two nouns on adjacent surfaces is a thing to learn for nothing.
+		const staged = [`staged: ${pending.count} fold${pending.count === 1 ? "" : "s"}` +
+			` · frees ~${pending.freedTokens.toLocaleString("en-US")} tokens at commit` +
+			` · ${this.data.pinned.length} pinned`];
+		if (origins) staged.push(`staged by: ${origins}`);
+		return staged;
+	}
+
 	render(width: number): string[] {
 		const header = this.headerLines(width);
 		const rows = this.visibleRows();
@@ -707,7 +808,11 @@ export class FoldEditorView {
 		this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, rows.length - MAX_VISIBLE_ROWS)));
 		const body = rows
 			.slice(this.scroll, this.scroll + MAX_VISIBLE_ROWS)
-			.map((row) => truncateToWidth(row.text, width, ""));
+			// THE PROJECT'S OWN BOUNDING LAW (gate 136): "..." means content continues in the
+			// source and never appears when nothing was cut. Header lines already take the
+			// default marker; body rows passed "" and were cut mid-word in silence, so the
+			// display layer contradicted the rule the briefs it displays all obey.
+			.map((row) => truncateToWidth(row.text, width));
 		// THE WOULD-BE FOLD SIZE (Shane, 2026-08-23): while a span is being laid down,
 		// the footer states what the second mark point would commit, in the runtime's
 		// own token arithmetic -- the same numbers the staged mark will answer with.
@@ -733,7 +838,10 @@ export class FoldEditorView {
 			"",
 			...body,
 			...footers,
-			truncateToWidth("enter:expand/detail · arrows:navigate · m:mark raw span · esc:close", width, ""),
+			// p AND u CHANGE STATE AND WERE NAMED NOWHERE, while the header prints a pin count
+			// on every render. "raw span" stays: it is the word explaining why m does
+			// nothing on a fold row. The width comes out of enter and arrows instead.
+			truncateToWidth("enter:open · arrows:move · m:mark raw span · p:pin · u:withdraw · esc:close", width),
 		];
 	}
 }