pi-fold 3.1.0 → 4.1.0

package/extensions/lib/folding.ts

@@ -31,6 +31,7 @@ import {
   refsProtected,
 } from "./measurement.ts";
 import {
+  assertFoldForestValid,
   childFoldIds,
   clearPrepared,
   flattenFoldRefs,
@@ -908,7 +909,7 @@ export function projectActiveContext(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
 ): unknown[] {
-  validateFoldForest(state.folds);
+  assertFoldForestValid(state.folds);
   const replacements = new Map<number, { end: number; messages: unknown[] }>();
   for (const root of orderedRoots(state, snapshot)) {
     const rendered = renderFold(root.fold, state, snapshot);
@@ -921,7 +922,24 @@ export function projectActiveContext(
       output.push(...replacement.messages);
       index = replacement.end + 1;
     } else {
-      output.push(clone(snapshot.messages[index]));
+      // A PASS-THROUGH MESSAGE IS SHARED, NOT COPIED (gate 158, 2026-08-29). This used to
+      // push `clone(...)`, which was in the first commit of the runtime and never load
+      // bearing: `snapshot.messages` is ALREADY `clone(input.eventMessages)`
+      // (transcript.ts:531), against an array Pi itself structuredClones before it calls
+      // any handler, so the copy was a third generation guarding objects the host never
+      // sees. It cost 54.3ms of a 298.5ms projection, 18 percent, on a sealed 3,364
+      // message session, and it is the only remaining per-message cost of that size.
+      //
+      // What makes sharing indistinguishable from copying: NOTHING writes a field into a
+      // projected message at any depth. Every rewrite builds a fresh object and replaces
+      // an array SLOT, here in `applyToolClips` and in `withdrawConsumedEphemeralPeeks`
+      // and `carryWithdrawalIntoFreeze` one layer up, so a shared element is never the
+      // thing that gets edited. Gate 158 pins that by deep-freezing `snapshot.messages`
+      // and driving the readers against it, so a future in-place write throws in the
+      // suite instead of silently corrupting every later projection through the frozen
+      // prefix. Folded spans keep their own copies: line 796 and `renderFoldParts` still
+      // clone, because those objects are built for the projection rather than read from it.
+      output.push(snapshot.messages[index]);
       index += 1;
     }
   }

package/extensions/lib/instrumentation.ts

@@ -94,10 +94,12 @@ export type ContextEventKind =
   | "context.absorb"
   | "context.recovery"
   | "context.suspend"
+  | "context.settings"
   | "context.rollback"
   | "context.projection"
   | "context.usage"
-  | "context.prefix";
+  | "context.prefix"
+  | "context.anchor";
 
 export function prefixDivergence(
   previous: string | null,

package/extensions/lib/live-settings.ts

@@ -0,0 +1,73 @@
+// THE CHANNEL FROM /fold-settings TO THE RUNNING RUNTIME.
+//
+// THE NEED, from a live session (2026-08-29). /fold-settings wrote the file and nothing
+// else: `registerPiFold` resolves thresholds, toolFoldThreshold and the notice settings
+// ONCE at registration, so a session kept the settings pi booted with while the screen showed
+// what the person had just chosen. Shane's terminal held both at once, "Start folding at
+// 40%" on the screen over "commit at 90%" on the status line, and neither surface said
+// why. The file was the durable truth and the running session was not reading it.
+//
+// The two halves are registered independently, `registerFoldSettings(pi)` and
+// `registerPiFold(pi, settings)`, in either order, and neither returns a handle the other
+// can hold. What they do share is the HOST OBJECT, so that is the channel: the runtime
+// hangs an applier off `pi` under a registry symbol, and the settings screen looks for it
+// when a person saves an edit, which is long after both registrations have run. Late
+// binding is what makes the order irrelevant.
+//
+// A MODULE-LEVEL SLOT WAS THE OTHER CANDIDATE AND IT IS WORSE: the applier would then be
+// process-global, every gate that registers a runtime would leave one standing, and a
+// screen in one host could push settings into a runtime in another. Keeping it on the
+// host means an unregistered host simply has no applier, which is a state the screen can
+// read and state honestly rather than a state it has to guess at.
+//
+// Symbol.for, not a fresh Symbol: the global registry keys by string, so a package loaded
+// twice through different module caches (jiti in the suite, pi's own loader in the
+// deployment) still agrees on the property.
+
+import type { ActiveContextThresholds } from "./policy.ts";
+
+/**
+ * What the settings screen hands the runtime: exactly the settings FILE's shape, where an
+ * absent field means the package default rather than "leave it alone". The runtime
+ * resolves it the same way it resolves its registration options, through one code path,
+ * so a value cannot mean one thing at boot and another at an edit.
+ */
+export interface LiveFoldSettings {
+	thresholds?: ActiveContextThresholds;
+	toolFoldThreshold?: number;
+	preCommitNotice?: boolean;
+	noticeLeadShare?: number;
+}
+
+/** Refuses by throwing, exactly as registration does, and leaves the runtime untouched. */
+export type LiveSettingsApplier = (settings: LiveFoldSettings, ctx?: unknown) => void;
+
+const LIVE_SETTINGS = Symbol.for("pi-fold.live-settings");
+
+export function publishLiveSettings(host: any, apply: LiveSettingsApplier): void {
+	// A HOST THAT REFUSES THE PROPERTY IS NOT A FAILURE. Nothing about folding depends on
+	// this channel: without it the file is still written and the next start still reads
+	// it, which is the behaviour every build before this one had.
+	try { host[LIVE_SETTINGS] = apply; } catch { }
+}
+
+/** Whether an edit saved now would reach a running runtime. The settings screen states
+ *  which of the two it is instead of promising the one it cannot deliver. */
+export function liveSettingsReachable(host: any): boolean {
+	try { return typeof host?.[LIVE_SETTINGS] === "function"; }
+	catch { return false; }
+}
+
+/**
+ * Push settings into the runtime registered on this host. Returns false when there is
+ * none, and lets the applier's own refusal THROW: the caller decides what a refusal
+ * means, and swallowing it here would leave a screen believing it had applied a value
+ * the runtime rejected.
+ */
+export function applyLiveSettings(host: any, settings: LiveFoldSettings, ctx?: unknown): boolean {
+	let apply: LiveSettingsApplier | undefined;
+	try { apply = host?.[LIVE_SETTINGS]; } catch { return false; }
+	if (typeof apply !== "function") return false;
+	apply(settings, ctx);
+	return true;
+}

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

@@ -22,9 +22,6 @@ import {
   EXPAND_LEASE_GENERATIONS,
   MAX_EXPAND_LEASES,
   MAX_PENDING_MARKS,
-  MEMORY_BODY_CHARS,
-  MEMORY_KEY_CHARS,
-  MEMORY_KEYS_MAX,
 } from "./policy.ts";
 import type {
   ActiveContextCheckpointV2,
@@ -36,7 +33,6 @@ import type {
   BriefOverride,
   BriefProvenance,
   ToolClip,
-  WorkingMemoryEntry,
   FoldKind,
   FoldPart,
   FoldRecordEntry,
@@ -315,6 +311,43 @@ export function validateFoldForest(folds: ActiveFold[]): ActiveFold[] {
   return values;
 }
 
+// A FOREST THAT VALIDATED ONCE IS NOT VALIDATED AGAIN (gate 160, 2026-08-29). Profiling
+// twelve projections of a sealed 681-fold session put 51.2 percent of ALL self time on one
+// call path, and caller attribution found every serialization sample on it:
+//
+//   projectActiveContext -> validateFoldForest -> sha256Value -> stableStringify -> safeJson
+//
+// The cost is this function's closing digest-drift loop, which flattens every fold's refs
+// (for a consolidation parent, the union of all descendants) and hashes the array. The
+// projection opens with `validateFoldForest(state.folds)` on EVERY context event and throws
+// the result away: it wants the throw, not the normalized array. So it paid a full forest
+// rehash per event to re-prove something it had already proven.
+//
+// THIS WRAPPER IS THE ONLY THING THAT CHANGES. `validateFoldForest` is untouched, still
+// clones, still normalizes, still returns; the three callers that CONSUME its return value
+// (parseActiveContextState, stateFromFoldRefs, commitPreparedFold) still call it directly
+// and are unaffected. Each of those hands it a freshly built array anyway, so a memo could
+// never have hit there; the projection is the one caller that reads the same array again
+// and again, which is exactly why it is the one that pays.
+//
+// KEYED ON THE INPUT ARRAY, and sound because a state is rebuilt immutably: a changed
+// forest is always a new array, and nothing anywhere mutates a folds array in place (no
+// push, splice, sort, reverse or slot assignment on any `.folds` in extensions/). Nothing
+// is shared out, because nothing is returned, so this carries none of gate 158's aliasing
+// question.
+//
+// THE ONE COST, stated rather than hidden: a folds array mutated IN PLACE keeps its first
+// verdict and a corruption introduced that way would go unreported. Gate 160 asserts that
+// cost directly rather than pretending it away, and still requires a corrupt NEW forest to
+// raise on first sight.
+const VALIDATED_FORESTS = new WeakSet<readonly ActiveFold[]>();
+
+export function assertFoldForestValid(folds: ActiveFold[]): void {
+  if (VALIDATED_FORESTS.has(folds)) return;
+  validateFoldForest(folds);
+  VALIDATED_FORESTS.add(folds);
+}
+
 export function parseActiveContextState(
   value: unknown,
   sessionId: string,
@@ -330,6 +363,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 +414,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 +429,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 +453,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 +568,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 +721,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 +846,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 +871,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 +1090,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 +1150,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 +1240,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;

package/extensions/lib/policy.ts

@@ -34,14 +34,37 @@ export const ACTIVE_CONTEXT_STATE_ENTRY = `${DEFAULT_ACTIVE_CONTEXT_ENTRY_TYPE_P
 export const ACTIVE_CONTEXT_FOLD_RECORD_ENTRY = `${DEFAULT_ACTIVE_CONTEXT_ENTRY_TYPE_PREFIX}-fold-record`;
 export const PROVIDER_CONTEXT_MEASUREMENT_ENTRY = `${DEFAULT_ENTRY_NAMESPACE}-provider-context-measurement`;
 /**
- * How many unbriefed pending folds stand before the runtime says so.
+ * THE NOTICE'S DEFAULT LEAD, as a share of the serving budget below the commit trigger
+ * (Shane, 2026-08-22: "around 10% from the commit threshold"; built 2026-08-30).
  *
- * A CONSTANT, not a threshold the deployment can turn (Shane's KISS rule): it is a
- * batching size, and the only thing a knob here would buy is a deployment that never
- * speaks. Three is the smallest batch that reads as a batch rather than as a running
- * commentary on every cut.
+ * A DISTANCE, NOT A POINT. Expressed as how far BELOW maxTarget the notice speaks, so it
+ * tracks a band that moves: a deployment that drops its trigger to 0.40 gets its notice
+ * at 0.30 without touching this, where an absolute 0.70 would have put the warning after
+ * the thing it warns about. The fire point is `maxTarget - noticeLeadShare`, floored at
+ * zero, so a lead wider than the trigger means "speak from the first measurement".
+ *
+ * IT REPLACED A COUNT. Until 2026-08-30 the notice fired at UNBRIEFED_FOLDS_BEFORE_NOTICE
+ * = 3 unbriefed pending folds, which is a batching size and not an occasion: the frontier
+ * cuts continuously and ungated by occupancy, so three folds stand within a few turns of
+ * a session's start and the notice spoke a long way from any commit. The share is the
+ * occasion, and the edge latch is what batches it: one notice per approach.
  */
-export const UNBRIEFED_FOLDS_BEFORE_NOTICE = 3;
+export const DEFAULT_NOTICE_LEAD_SHARE = 0.10;
+
+/**
+ * The lead is a share of the serving budget, so it is bounded the way every other share
+ * on this surface is: strictly inside 0 and 1. Zero would mean the notice fires exactly
+ * at the trigger, which is the same pass the commit fires on and therefore never a
+ * warning; 1 and above is not a share.
+ */
+export function resolveNoticeLeadShare(value: unknown): number {
+  if (value === undefined) return DEFAULT_NOTICE_LEAD_SHARE;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value >= 1) {
+    throw new Error("noticeLeadShare must be a share above 0 and below 1: how far below the " +
+      "commit trigger, as a fraction of the serving budget, the notice speaks");
+  }
+  return value;
+}
 
 /**
  * How many spans the frontier cuts on one projection pass.
@@ -91,9 +114,7 @@ export const RETIRED_TOOL_ACTIONS: Readonly<Record<string, string>> = Object.fre
     "peek already carries losslessly. Write the brief you want when you mark the span, or " +
     "use reboundary to re-cut it.",
 });
-export type ActiveContextToolAction =
-  | typeof ACTIVE_CONTEXT_TOOL_ACTIONS[number]
-  | typeof WORKING_MEMORY_TOOL_ACTIONS[number];
+export type ActiveContextToolAction = typeof ACTIVE_CONTEXT_TOOL_ACTIONS[number];
 export const USER_RESCUE_MAX_SOURCE_CHARS = 512_000;
 export const DEFAULT_CONTEXT_WINDOW = 272_000;
 export const EXPAND_LEASE_GENERATIONS = 8;
@@ -263,6 +284,22 @@ export function servingBudgetTokens(window: number): number {
 
 export const MAX_PENDING_MARKS = 256;
 export const ESTIMATED_BYTES_PER_TOKEN = 4;
+
+/**
+ * What one image in the window is worth, in tokens, for estimation only.
+ *
+ * A provider prices an image from its DIMENSIONS, not its byte size: Anthropic bills
+ * about width x height / 750, which puts a 2000x563 screenshot near 1,500 tokens, and a
+ * large image caps close to this number once the long edge is scaled to the 1568px limit.
+ * The exact figure differs per provider and cannot be known from the base64 alone.
+ *
+ * It does not need to be exact. The value it replaces was the image's base64 length
+ * divided by a prose chars-per-token ratio, which read one screenshot as 110,000 tokens
+ * against a true cost near 1,500. Being within an order of magnitude ends the failure;
+ * the provider anchor corrects the rest as soon as a real measurement lands. A constant
+ * rather than an option, because nobody can tune this better than the anchor can.
+ */
+export const IMAGE_ESTIMATED_TOKENS = 1_600;
 export const ESTIMATED_PLACEHOLDER_OVERHEAD_BYTES = 240;
 
 export const PEEK_MIN_SLICE_BYTES = 1_024;
@@ -273,15 +310,35 @@ export const MAX_CONTEXT_RECEIPTS = 3;
 export const CONTEXT_RECEIPT_BLOCK_BYTES = 900;
 
 /**
- * The post-fold notice's bound, and its own rather than the receipt block's.
+ * The pre-commit notice's bound, and its own rather than the receipt block's.
  *
- * It is larger because it carries a variable-length list the receipt does not: three
- * fixed sentences of instruction plus one entry per unbriefed fold, and the pending set
- * grows past MAX_FRONTIER_CUTS_PER_PASS whenever the frontier stages faster than the
- * agent answers. 1,200 seats the instruction and roughly eight folds; past that the list
- * gives way and states how many it could not name.
+ * It is larger because it carries a variable-length list the receipt does not: the fixed
+ * status and verb block plus one entry per staged fold, and the pending set grows past
+ * MAX_FRONTIER_CUTS_PER_PASS whenever the frontier stages faster than a commit lands.
+ * 1,200 seated the old instruction and roughly eight folds; past the bound the list gives
+ * way and states how many it could not name.
  */
 export const FOLD_NOTICE_BYTES = 2_400;
+/**
+ * WHAT ONE /fold-editor ROW SUMMARIZES, and what one page of its detail serves
+ * (2026-08-30).
+ *
+ * The editor's whole reading of a message was 300 characters of its first text block,
+ * with a detail row that sliced to 480 and therefore could never bind. Two numbers replace
+ * it because they answer two different questions. EDITOR_ROW_PREVIEW_CHARS is a SUMMARY
+ * on a line that also carries a role, an id and a badge, so it is generous enough that a
+ * reader can tell two rows apart and no more. EDITOR_DETAIL_PAGE_CHARS is a READ, served
+ * a page at a time by an injected accessor with `total` and `hasMore` travelling beside
+ * it, so depth is bounded by the reader's patience rather than by a constant: there is no
+ * ceiling on what the editor can reach, only on what it hands over at once.
+ *
+ * THIS IS A READER'S BOUND, NOT A WINDOW'S. Nothing here reaches the projection: paging
+ * an entry to its end in the editor moves no bytes and the model never learns it
+ * happened. `maxSourceChars` 200,000 is the bound on a read that DOES reach the agent.
+ */
+export const EDITOR_ROW_PREVIEW_CHARS = 240;
+export const EDITOR_DETAIL_PAGE_CHARS = 4_000;
+
 export const CONTEXT_STATUS_RESPONSE_BYTES = 24_000;
 export const MAX_UNMARKED_CANDIDATES = 3;
 
@@ -310,34 +367,6 @@ export function peekIsEphemeral(params: Record<string, unknown> | undefined | nu
 
 export const PEEK_READ_ONLY_CONTEXT_ACTIONS: ReadonlySet<string> = new Set(["status", "peek", "recall"]);
 
-/**
- * THE WORKING MEMORY (Shane, 2026-08-26). A session-scoped ordered dictionary the agent
- * maintains beside the fold index: keys list in a table of contents the projection
- * carries, bodies live in state and are read on demand with `recall`. It exists because
- * the campaign measured a structural gap, not a tuning one: a maintained digest (running
- * tallies, current totals) is a different operation from a lossless index, and blending
- * digest prose into the index's briefs was measured making BOTH worse (sol-20260826-full2
- * rep 4: nine confident wrong end-block answers against the deterministic arm's zero).
- * The digest gets its own channel and the index stays mechanical.
- *
- * Three constants, not knobs. The key cap keeps the table of contents a table of
- * contents; the body cap is deliberately larger than a brief because a digest is
- * maintained prose, not an index row; the entry cap bounds the whole store at a size
- * whose table of contents stays one glance.
- */
-export const MEMORY_KEY_CHARS = 64;
-export const MEMORY_BODY_CHARS = 4_000;
-export const MEMORY_KEYS_MAX = 24;
-
-export const WORKING_MEMORY_TOOL_ACTIONS = Object.freeze(["remember", "recall"] as const);
-
-export interface WorkingMemoryEntry {
-  key: string;
-  body: string;
-  /** Write counter at last update; the table of contents lists freshest first. */
-  ordinal: number;
-}
-
 /** "user" is a mark laid down by the human through /fold-editor; it stages and
  *  commits through the same validated path as an agent mark and counts toward the
  *  commit's coverage the same way. */
@@ -457,8 +486,6 @@ export interface ActiveContextState {
     armed?: { milestone: AdvisoryMilestone; threshold: number; scheduleKey: string };
   };
   rider?: { epoch: number; text: string };
-  /** The working memory's entries, in write order; absent when empty. */
-  memory?: WorkingMemoryEntry[];
 }
 
 export interface FoldRecordRef {
@@ -488,7 +515,6 @@ export interface ActiveContextCheckpointV2 {
   pendingMarks?: PendingMark[];
   briefs?: Record<string, BriefOverride>;
   clips?: ToolClip[];
-  memory?: WorkingMemoryEntry[];
   advisory?: NonNullable<ActiveContextState["advisory"]>;
   rider?: NonNullable<ActiveContextState["rider"]>;
   lastCall?: NonNullable<ActiveContextState["lastCall"]>;
@@ -530,11 +556,6 @@ export interface ActiveContextDeltaV2 {
   clips?: ToolClip[];
   clipBase?: number;
   addClips?: ToolClip[];
-  // `memory` on a delta is the WHOLE array. It is bounded by MEMORY_KEYS_MAX entries and
-  // edited in place by key, so a change form would have to restate the key order the way
-  // the marks do while saving at most a handful of bounded bodies: the whole array is the
-  // cheaper wire. Absent means empty, by the same discriminator rule as the marks.
-  memory?: WorkingMemoryEntry[];
   advisory?: NonNullable<ActiveContextState["advisory"]>;
   rider?: NonNullable<ActiveContextState["rider"]>;
   lastCall?: NonNullable<ActiveContextState["lastCall"]>;

package/extensions/lib/selection.ts

@@ -1,4 +1,6 @@
 import type { EvidenceRef } from "../json.ts";
+import { boundedSubject, oneLine, seatSubjects, toolClipHead } from "./brief-text.ts";
+export { oneLine, seatSubjects, toolClipHead };
 import {
   denseOwnArrayValues,
   objectRefKey,
@@ -397,13 +399,6 @@ function assistantNoteText(message: unknown): string {
 // "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.
-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 deterministicConsolidationBrief(
   candidate: FoldCandidate,
@@ -467,29 +462,16 @@ export function deterministicConsolidationBrief(
   const noteCount = notes.length;
   const subjects = [...childSubjects, ...notes];
   if (!subjects.length) return "Grouped completed context covering no readable folds.";
-  const separator = " | ";
   const lead = noteCount
     ? `Grouped completed context covering ${foldCount} folds and ${noteCount} agent notes: `
     : `Grouped completed context covering ${subjects.length} folds: `;
-  const room = ACTIVE_CONTEXT_POLICY.maxBriefChars - lead.length - 1;
-  const named = Math.max(1, Math.min(subjects.length,
-    Math.floor((room + separator.length) / (MIN_SUBJECT_CHARS + separator.length))));
-  const omitted = subjects.length - named;
-  // With notes in the division, what the slice drops may be a note rather than
-  // a fold, so the tail only claims folds when folds are all it holds.
-  const tail = omitted ? `${separator}${omitted} more ${noteCount ? "in this group" : "folds in this group"}` : "";
-  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();
+  // With notes in the division, what the count-slice drops may be a note rather
+  // than a fold, so the tail only claims folds when folds are all it holds.
+  return seatSubjects(subjects, lead, {
+    total: ACTIVE_CONTEXT_POLICY.maxBriefChars,
+    minSubjectChars: MIN_SUBJECT_CHARS,
+    omittedNoun: noteCount ? "in this group" : "folds in this group",
+  });
 }
 
 export const ALL_FOLD_KINDS: ReadonlySet<FoldKind> =
@@ -1106,23 +1088,6 @@ export function manualFoldCandidate(
 // 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 oneLine(value: string, maximum: number): string {
-  return boundedSubject(value.replace(/\s+/g, " ").trim(), maximum);
-}
 
 export function deterministicChapterBrief(
   refs: EvidenceRef[],