pi-fold 3.1.0 → 4.0.0

package/extensions/index.js

@@ -11,7 +11,7 @@ export {
 
 const PUBLIC_OPTIONS = Object.freeze([
   "thresholds", "providerInputBudget", "blacklistAutoFoldTools", "toolFoldThreshold",
-  "workingMemory", "postFoldNotice",
+  "postFoldNotice",
 ]);
 
 const GENERATOR_DELETED = "the model brief generator is deleted (2026-08-14): across 15 sealed " +
@@ -25,6 +25,10 @@ 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 " +

package/extensions/lib/curation.ts

@@ -73,41 +73,6 @@ export function foldNoticeText(input: {
     `[${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("; ")}.`;
-  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)}`;
-  }
-  return boundReceiptText(`${head}\n${list}`, FOLD_NOTICE_BYTES,
-    `[${brand} memory] Working memory has entries; the list is unavailable this pass.`);
-}
 
 export interface ContextReceipt {
   kind: string;
@@ -213,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),
 		];
 	}
 }

package/extensions/lib/measurement.ts

@@ -570,3 +570,50 @@ export function parseNativeCompactionCompletion(value: unknown, expectedSessionI
   }
   return { ...(clone(value) as unknown as NativeCompactionCompletionReceipt), decision };
 }
+
+/**
+ * AN IMAGE IS NOT TEXT, AND MEASURING IT AS TEXT KILLS SESSIONS (2026-08-28).
+ *
+ * The projection is sized by serializing it and counting UTF-8 bytes, which is right for
+ * prose and catastrophically wrong for an image: a content block carries its pixels as
+ * base64, so a screenshot lands as several hundred thousand characters that the estimator
+ * then divides by a chars-per-token ratio learned from PROSE. A live session read three
+ * PNGs of 364,801, 631,045 and 827,513 bytes; the projection went 636,687 chars to
+ * 1,268,275 in one step and the estimate went 110,687 tokens to 220,883, while the
+ * provider's own count for that same request came back 111,837. Every token of the
+ * 109,046 difference was base64 counted as if it were sentences.
+ *
+ * The calibration cannot learn its way out, and that is the part worth understanding.
+ * `projectionCharsPerToken` takes the MINIMUM ratio over its window so the estimate never
+ * under-reads. An image pushes the true ratio UP, so the minimum discards exactly the
+ * sample that would have corrected it and keeps dividing base64 by the prose ratio. The
+ * conservative rule that protects against under-reading is what locks in the over-read.
+ *
+ * So image payload is removed from the character count and replaced by a flat per-image
+ * token cost. The count cannot be exact across providers, and it does not need to be: it
+ * needs to be the right order of magnitude instead of wrong by seventy times, and the
+ * provider anchor corrects the remainder the moment a real measurement lands.
+ */
+export function imageMass(projected: unknown[]): { base64Chars: number; images: number } {
+  let base64Chars = 0;
+  let images = 0;
+  for (const message of projected) {
+    const content = ownValue(message, "content");
+    const blocks = denseOwnArrayValues(content);
+    if (!blocks) continue;
+    for (const block of blocks) {
+      if (ownValue(block, "type") !== "image") continue;
+      images += 1;
+      // Two shapes reach here: the flat `data` a Pi tool result carries, and the nested
+      // `source.data` of a provider-native block. Both are counted; neither is required.
+      const direct = ownValue(block, "data");
+      const nested = ownValue(ownValue(block, "source"), "data");
+      const payload = typeof direct === "string" ? direct
+        : typeof nested === "string" ? nested : "";
+      // The serialization counts the JSON-escaped string, and base64 has no character
+      // JSON escapes, so its byte length in the serialized form is its own length.
+      base64Chars += bytes(payload);
+    }
+  }
+  return { base64Chars, images };
+}

package/extensions/lib/persistence.ts

@@ -36,7 +36,6 @@ import type {
   BriefOverride,
   BriefProvenance,
   ToolClip,
-  WorkingMemoryEntry,
   FoldKind,
   FoldPart,
   FoldRecordEntry,
@@ -330,6 +329,10 @@ export function parseActiveContextState(
   const hasPinnedPeeks = recordLike && Object.prototype.hasOwnProperty.call(value, "pinnedPeeks");
   const hasBriefs = recordLike && Object.prototype.hasOwnProperty.call(value, "briefs");
   const hasClips = recordLike && Object.prototype.hasOwnProperty.call(value, "clips");
+  // Read and dropped, never stored (2026-08-28): the working memory is deleted, and a
+  // sealed state that carries it must still load. Tolerating the key while discarding the
+  // value is the legacy-rider treatment, not the retired-field refusal: sol-20260826-full2
+  // reps 4 and 6 ran with it, and a campaign this package still cites has to stay readable.
   const hasMemory = recordLike && Object.prototype.hasOwnProperty.call(value, "memory");
   // Read and dropped, never stored: see legacyRiderStateSha256. A v1 state has no digest
   // to reproduce, so here the tolerance is the whole of it.
@@ -377,7 +380,6 @@ export function parseActiveContextState(
   }
   const briefs = hasBriefs ? parseBriefOverrides(ownValue(value, "briefs"), ids) : {};
   const clips = hasClips ? parseToolClips(ownValue(value, "clips")) : [];
-  const memory = hasMemory ? parseWorkingMemory(ownValue(value, "memory")) : [];
   const source = clone(value) as unknown as ActiveContextState;
   return {
     version: 1,
@@ -393,7 +395,6 @@ export function parseActiveContextState(
     ...(marks.length ? { pendingMarks: marks } : {}),
     ...(Object.keys(briefs).length ? { briefs } : {}),
     ...(clips.length ? { clips } : {}),
-    ...(memory.length ? { memory } : {}),
     ...(hasAdvisory
       ? { advisory: clone(source.advisory!) }
       : defaultAdvisory ? { advisory: { highWater: 0, delivered: {} } } : {}),
@@ -418,30 +419,6 @@ function parseToolClips(value: unknown): ToolClip[] {
   return clips;
 }
 
-function parseWorkingMemory(value: unknown): WorkingMemoryEntry[] {
-  const entries = denseOwnArrayValues(value);
-  if (!entries) throw new Error("Invalid active-context working memory");
-  const memory = entries.map((entry) => {
-    const key = ownValue(entry, "key");
-    const body = ownValue(entry, "body");
-    const ordinal = ownValue(entry, "ordinal");
-    if (!exactRecord(entry, ["key", "body", "ordinal"]) ||
-        typeof key !== "string" || !key || key.length > MEMORY_KEY_CHARS ||
-        typeof body !== "string" || !body || body.length > MEMORY_BODY_CHARS ||
-        !Number.isSafeInteger(ordinal) || Number(ordinal) < 0) {
-      throw new Error("Invalid active-context working-memory entry");
-    }
-    return { key, body, ordinal: Number(ordinal) };
-  });
-  if (memory.length > MEMORY_KEYS_MAX) {
-    throw new Error(`Invalid active-context working memory: over ${MEMORY_KEYS_MAX} entries`);
-  }
-  if (new Set(memory.map((entry) => entry.key)).size !== memory.length) {
-    throw new Error("Invalid active-context working memory: duplicate key");
-  }
-  return memory;
-}
-
 export function clearPrepared(state: ActiveContextState): ActiveContextState {
   const next = { ...state };
   delete next.prepared;
@@ -557,7 +534,6 @@ export function sameStateProjection(left: ActiveContextState, right: ActiveConte
     if (normalizedState.pendingMarks && normalizedState.pendingMarks.length === 0) delete normalizedState.pendingMarks;
     if (normalizedState.briefs && !Object.keys(normalizedState.briefs).length) delete normalizedState.briefs;
     if (normalizedState.clips && normalizedState.clips.length === 0) delete normalizedState.clips;
-    if (normalizedState.memory && normalizedState.memory.length === 0) delete normalizedState.memory;
     return normalizedState;
   };
   return stableStringify(normalized(left)) === stableStringify(normalized(right));
@@ -711,7 +687,6 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
   );
   if (hasWireClips) parseToolClips(ownValue(value, "clips"));
   if (hasAddClips) parseToolClips(ownValue(value, "addClips"));
-  if (hasWireMemory) parseWorkingMemory(ownValue(value, "memory"));
   if (hasClipBase) {
     const base = ownValue(value, "clipBase");
     if (!Number.isSafeInteger(base) || Number(base) < 0) throw new Error("Invalid active-context clip base");
@@ -837,7 +812,7 @@ export function stateFromFoldRefs(
   wire: Pick<
     ActiveContextCheckpointV2,
     "sessionId" | "revision" | "expanded" | "protected" | "prepared" | "advisory" |
-      "tokensSinceToolFold" | "leases" | "pendingMarks" | "briefs" | "clips" | "memory"
+      "tokensSinceToolFold" | "leases" | "pendingMarks" | "briefs" | "clips"
   >,
   refs: FoldRecordRef[],
   records: Map<string, FoldRecordEntry>,
@@ -862,7 +837,6 @@ export function stateFromFoldRefs(
     ...(wire.pendingMarks?.length ? { pendingMarks: clone(wire.pendingMarks) } : {}),
     ...(wire.briefs && Object.keys(wire.briefs).length ? { briefs: clone(wire.briefs) } : {}),
     ...(wire.clips?.length ? { clips: clone(wire.clips) } : {}),
-    ...(wire.memory?.length ? { memory: clone(wire.memory) } : {}),
     ...(wire.advisory === undefined ? {} : { advisory: clone(wire.advisory) }),
     ...(wire.prepared === null || wire.prepared === undefined ? {} : { prepared: clone(wire.prepared) }),
   };
@@ -1082,7 +1056,6 @@ export function materializeStatePersistence(
           briefs: Object.keys(briefs).length ? briefs : undefined,
           pendingMarks: marks.length ? marks : undefined,
           clips: clips.length ? clips : undefined,
-          memory: wire.memory?.length ? clone(wire.memory) : undefined,
         },
         [...byId.values()],
         records,
@@ -1143,7 +1116,6 @@ export function makeStateCheckpoint(state: ActiveContextState): ActiveContextChe
     ...(state.pendingMarks?.length ? { pendingMarks: clone(state.pendingMarks) } : {}),
     ...(state.briefs && Object.keys(state.briefs).length ? { briefs: clone(state.briefs) } : {}),
     ...(state.clips?.length ? { clips: clone(state.clips) } : {}),
-    ...(state.memory?.length ? { memory: clone(state.memory) } : {}),
     ...(state.advisory ? { advisory: clone(state.advisory) } : {}),
     stateSha256: semanticStateSha256(state),
   }, state.sessionId) as ActiveContextCheckpointV2;
@@ -1234,9 +1206,6 @@ export function makeStateDelta(previous: ActiveContextState, next: ActiveContext
     ...(Object.keys(addBriefs).length ? { addBriefs } : {}),
     ...(removeBriefIds.length ? { removeBriefIds } : {}),
     ...(clipsTravel ? { clipBase: clipBase, ...(addClips.length ? { addClips: clone(addClips) } : {}) } : {}),
-    // The memory travels whole when it exists: bounded at MEMORY_KEYS_MAX entries and
-    // edited in place, so the change encodings above have nothing to save here.
-    ...(next.memory?.length ? { memory: clone(next.memory) } : {}),
     ...(next.advisory ? { advisory: clone(next.advisory) } : {}),
     stateSha256: semanticStateSha256(next),
   }, next.sessionId) as ActiveContextDeltaV2;