pi-fold 3.0.0 → 4.0.0

package/extensions/active-context.ts

@@ -6,10 +6,12 @@ import {
   stableStringify,
 } from "./json.ts";
 import {
+  contentText,
   bytes,
   clone,
   emptyActiveContextState,
   ownValue,
+  serializedPrefixHolds,
   sessionEntryMessages,
   uniqueMessageDigestAnchor,
 } from "./lib/canonical.ts";
@@ -44,6 +46,7 @@ import {
   explicitProtectedMass,
   budgetOccupancy,
   hardFenceRatio,
+  imageMass,
   latestProviderContextMeasurement,
   orderedRoots,
   parseNativeCompactionCompletion,
@@ -70,6 +73,7 @@ import {
   deriveFoldParents,
   flattenFoldRefs,
   foldIdFor,
+  foldRecordRef,
   makeFoldRecordEntry,
   makeStateCheckpoint,
   makeStateDelta,
@@ -102,8 +106,10 @@ import {
   resolveThresholds,
   servingBudgetTokens,
   ESTIMATED_BYTES_PER_TOKEN,
+  IMAGE_ESTIMATED_TOKENS,
   entryTypeNamespace,
   MAX_FOLD_SPAN_CHARS,
+  DEFAULT_TOOL_FOLD_THRESHOLD,
   MAX_PINNED_SHARE,
   PEEK_DEFAULT_MAX_BYTES,
   peekIsEphemeral,
@@ -118,11 +124,12 @@ import type {
   ActiveContextState,
   ActiveContextThresholds,
   ActiveContextToolAction,
+  BriefProvenance,
   FoldCandidate,
   FoldKind,
   FoldRecordEntry,
-  MarkOrigin,
   PreparedFold,
+  WorkingMemoryEntry,
 } from "./lib/policy.ts";
 import {
   absorbWedgeMarks,
@@ -131,6 +138,7 @@ import {
 import {
   contextReceipt,
   foldNoticeText,
+  foldStatusText,
   receiptBlockText,
   withReceipt,
 } from "./lib/curation.ts";
@@ -142,6 +150,7 @@ import {
   commitCoverage,
   windowClaims,
   commitPendingMarks,
+  toolClipAdditions,
   consolidationMarks,
   ephemeralPeekMarks,
   epochCommitDue,
@@ -149,6 +158,7 @@ import {
   foldMarkFor,
   ladderBrief,
   markAccounting,
+  markRewriteTokens,
   markFreedBytes,
   unmarkedRemainder,
   markClaimingRef,
@@ -211,38 +221,6 @@ export * from "./lib/scheduling.ts";
 export * from "./lib/selection.ts";
 export * from "./lib/transcript.ts";
 
-export interface BatchedMarkRequest {
-  ids: string[];
-  brief?: string;
-}
-
-export function batchedMarkRequests(params: Record<string, unknown>): BatchedMarkRequest[] {
-  const batched = params.marks;
-  if (batched === undefined) {
-    return [{
-      ids: stringIds(params.ids),
-      ...(typeof params.brief === "string" && params.brief.trim() ? { brief: params.brief } : {}),
-    }];
-  }
-  const values = denseOwnArrayValues(batched);
-  if (!values || !values.length || values.length > 64) {
-    throw new Error("marks must be a dense array of 1-64 {ids, brief} objects");
-  }
-  return values.map((value, index) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`marks[${index}] must be an object with ids and an optional brief`);
-    }
-    const brief = ownValue(value, "brief");
-    if (brief !== undefined && (typeof brief !== "string" || !brief.trim())) {
-      throw new Error(`marks[${index}].brief must be a nonempty string`);
-    }
-    return {
-      ids: stringIds(ownValue(value, "ids")),
-      ...(typeof brief === "string" && brief.trim() ? { brief } : {}),
-    };
-  });
-}
-
 export function registerActiveContext(pi: any, options: {
   toolName?: string;
   toolLabel?: string;
@@ -252,6 +230,21 @@ export function registerActiveContext(pi: any, options: {
   blacklistAutoFoldTools?: ReadonlySet<string>;
   providerInputBudget?: number;
   thresholds?: ActiveContextThresholds;
+  /** THE TOOL-CALL DIET's share point (2026-08-24; default 0.50 since 2026-08-28, Shane,
+   *  on the sol-20260826-full2 verdict): tool results in the oldest toolFoldThreshold
+   *  share of the projected window are clipped IN VIEW at each commit, identified head
+   *  kept, full bytes peek-recoverable behind the entry id the marker names. A share in
+   *  [0, 1), where 0 turns the diet off; 0.50 is what every fold repetition from 3 onward
+   *  ran, so the default is the value that was measured rather than the absence of one. */
+  toolFoldThreshold?: number;
+  /** THE INVITATION SWITCH (public since 2026-08-27; DEFAULT FALSE since 2026-08-28,
+   *  Shane, on the sol-20260826-full2 verdict). false is the deterministic shape the
+   *  campaign measured and the one it recommends: no carrier ever invites a brief and
+   *  every fold goes out with the runtime's own words, which drew 14, 14, 9 and 8 correct
+   *  against the invited condition's 3. true restores the standing invitation for the
+   *  agent to improve a brief. Either way the agent verbs stay on the tool, so an agent
+   *  that finds a fold can still annotate what it reads. */
+  postFoldNotice?: boolean;
 }): {
   projectionCandidates: (ctx: any) => Array<Record<string, unknown>>;
 } {
@@ -260,6 +253,19 @@ export function registerActiveContext(pi: any, options: {
   const brandNoun = options.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN;
   const entryTypePrefix = options.entryTypePrefix ?? DEFAULT_ACTIVE_CONTEXT_ENTRY_TYPE_PREFIX;
   const blacklistAutoFoldTools = options.blacklistAutoFoldTools ?? AUTO_FOLD_BLACKLIST_DEFAULT;
+  if (options.postFoldNotice !== undefined && typeof options.postFoldNotice !== "boolean") {
+    throw new Error("postFoldNotice must be a boolean: true keeps the post-fold invitation " +
+      "notice, false ships every fold with the runtime's deterministic brief and no " +
+      "carrier inviting the agent to improve it");
+  }
+  const postFoldNotice = options.postFoldNotice ?? false;
+  const toolFoldThreshold = options.toolFoldThreshold ?? DEFAULT_TOOL_FOLD_THRESHOLD;
+  if (typeof toolFoldThreshold !== "number" || !Number.isFinite(toolFoldThreshold) ||
+      toolFoldThreshold < 0 || toolFoldThreshold >= 1) {
+    throw new Error("toolFoldThreshold must be a share in [0, 1): it names the oldest " +
+      "fraction of the projected window whose tool results are clipped in view at each " +
+      "commit, and 0 turns the diet off");
+  }
   for (const removed of ["foldScheduling", "foldPeekResults", "toolActions"]) {
     if (Object.hasOwn(options, removed)) {
       throw new Error(`${removed} is no longer an option: epoch scheduling, peek foldability ` +
@@ -378,6 +384,7 @@ export function registerActiveContext(pi: any, options: {
     lastProviderMeasurement: null as ProviderContextMeasurement | null,
     descriptorWindow: null as number | null,
     lastProjectedChars: null as number | null,
+    lastProjectedImages: 0,
     projectionCalibrations: [] as Array<{ chars: number; tokens: number }>,
     lastProjectedEstimate: null as number | null,
     lastProjectedEstimateCalibrated: false,
@@ -386,6 +393,10 @@ export function registerActiveContext(pi: any, options: {
     projectionAnchor: null as {
       tokens: number;
       chars: number;
+      /** `chars` less the base64 of any image, which is what the delta is taken on. */
+      textChars: number;
+      /** Images inside the anchored prefix, each worth IMAGE_ESTIMATED_TOKENS. */
+      images: number;
       head: string;
       messageSha256: string;
       sessionId: string;
@@ -405,6 +416,10 @@ export function registerActiveContext(pi: any, options: {
     ledger: emptyLedger(),
     previousDigests: null as string[] | null,
     previousText: null as string | null,
+    // The image mass of `previousText`, kept beside it because the provider anchor is
+    // built from that text and has no access to the array it came from.
+    previousImages: 0,
+    previousImageChars: 0,
     lastChange: "append" as ProjectionChange,
     lastPreservedShare: null as number | null,
     sinceHandoff: [] as Array<{
@@ -468,9 +483,6 @@ export function registerActiveContext(pi: any, options: {
   };
 
   const advisory = {
-    hardFenceNoticeKey: null as string | null,
-    hardFenceReleaseSessionId: null as string | null,
-    hardFenceReleasedProjectionKeys: new Set<string>(),
   };
 
   // EPHEMERAL PEEK (Build 4b): tool call ids whose peek asked for one-read
@@ -573,10 +585,9 @@ export function registerActiveContext(pi: any, options: {
   };
 
   const PREFIX_MUTATING_KINDS: ReadonlySet<string> = new Set([
-    "context.commit", "context.fold", "context.absorb", "context.split", "context.recovery",
+    "context.commit", "context.fold", "context.absorb", "context.recovery",
   ]);
   const CACHE_ACTION_REQUEST_CLASS: Readonly<Record<string, string>> = Object.freeze({
-    fold: "after-mark",
     peek: "after-peek",
     expand: "after-expand",
     refold: "after-refold",
@@ -590,8 +601,6 @@ export function registerActiveContext(pi: any, options: {
       folds_committed: receipt.foldsCommitted,
       folds_created: receipt.foldsCreated,
       freed_tokens: receipt.freedTokens,
-      split_folds: receipt.splitFolds,
-      split_from_chars: receipt.splitFromChars,
       absorbed_wedges: receipt.absorbedWedges,
       recovered: receipt.recovered,
       protected_bytes: receipt.protectedBytes,
@@ -612,15 +621,43 @@ export function registerActiveContext(pi: any, options: {
     lifecycle.generation === expectedGeneration && persistence.state?.sessionId === sessionId &&
     (!ctx || contextSessionMatches(ctx, sessionId));
 
+  /**
+   * THE ONE LINE THAT IS ALWAYS ON SCREEN, so it answers the question a person actually
+   * has: how full am I, and is anything about to happen.
+   *
+   * It used to read `pi_fold_context folds: 3 · provider 187234/272000`. That led with the
+   * AGENT TOOL'S NAME, which a person cannot call and does not care about, and then spent
+   * its remaining width on two raw counts they would have to divide themselves. The brand
+   * leads now, occupancy is a percentage of the serving budget, and the commit point is
+   * named only when it is close enough to matter.
+   */
   const updateStatus = (ctx: any): void => {
     try {
       const roots = persistence.state && lifecycle.latestSnapshot ? orderedRoots(persistence.state, lifecycle.latestSnapshot).length : 0;
-      const prepared = persistence.state?.prepared ? " · brief ready" : ladder.preparing ? " · briefing" : "";
-      const usage = measurements.lastProviderMeasurement
-        ? ` · provider ${measurements.lastProviderMeasurement.tokens}/${measurements.lastProviderMeasurement.contextWindow}`
-        : " · provider usage unmeasured";
-      const suspended = ladder.automaticFailure ? " · automatic suspended" : "";
-      ctx.ui?.setStatus?.(entryTypePrefix, `${toolName} folds: ${roots}${prepared}${usage}${suspended}`);
+      const staged = persistence.state ? pendingMarks(persistence.state).length : 0;
+      const capacity = currentCapacity(ctx);
+      const used = measurements.lastProviderMeasurement?.tokens ?? null;
+      const share = used !== null && capacity.budgetTokens > 0 ? used / capacity.budgetTokens : null;
+      const parts: string[] = [];
+      // FAILURE LEADS. This line is cut to whatever width the host gives it, so the last
+      // segment is the first one a narrow terminal removes, and folding having stopped is
+      // the one state on this line a person has to act on. It was appended last.
+      if (ladder.automaticFailure) parts.push("FOLDING STOPPED");
+      // Unmeasured is stated, never guessed: an estimate rendered as a fact is the habit
+      // that cost a live session, and this line is the most-read surface there is.
+      parts.push(share === null ? "not measured" : `${Math.round(share * 100)}% full`);
+      const trigger = lifecycle.latestSnapshot?.thresholds.maxTarget ?? null;
+      // WHEN, not just how full. "68% full" only answers the second question a reader has
+      // if they already remember where the trigger sits; naming it answers both.
+      //
+      // NOT WHILE STOPPED, though: the line rendered "COMMIT DUE" and "FOLDING STOPPED"
+      // in one breath, promising the thing it was announcing would not happen.
+      if (share !== null && trigger !== null && !ladder.automaticFailure) {
+        parts.push(share >= trigger ? "COMMIT DUE" : `commit at ${Math.round(trigger * 100)}%`);
+      }
+      if (staged > 0) parts.push(`${staged} staged`);
+      if (roots > 0) parts.push(`${roots} fold${roots === 1 ? "" : "s"}`);
+      ctx.ui?.setStatus?.(entryTypePrefix, `${brandNoun} ${parts.join(" · ")}`);
     } catch { }
   };
 
@@ -759,6 +796,8 @@ export function registerActiveContext(pi: any, options: {
     instrumentation.ledger = emptyLedger();
     instrumentation.previousDigests = null;
     instrumentation.previousText = null;
+    instrumentation.previousImages = 0;
+    instrumentation.previousImageChars = 0;
     instrumentation.requests = 0;
     instrumentation.lastMutationRequest = 0;
     instrumentation.lastMutationTokens = null;
@@ -773,16 +812,11 @@ export function registerActiveContext(pi: any, options: {
     curation.lastRecovery = null;
     ladder.lastAutomaticAction = null;
     ladder.automaticFailure = null;
-    advisory.hardFenceNoticeKey = null;
     measurements.providerMeasurementReceipts.clear();
     measurements.providerMeasurementRevisionByMessageSha.clear();
     measurements.providerMeasurementByMessageSha.clear();
     measurements.providerMeasurementAnchorByMessageSha.clear();
     const sessionId = ctx.sessionManager.getSessionId();
-    if (advisory.hardFenceReleaseSessionId !== sessionId) {
-      advisory.hardFenceReleaseSessionId = sessionId;
-      advisory.hardFenceReleasedProjectionKeys.clear();
-    }
     let restored: ActiveContextState | null = null;
     let restoreError: unknown = null;
     let restoredPersistence: MaterializedStatePersistence | null = null;
@@ -897,15 +931,28 @@ export function registerActiveContext(pi: any, options: {
       if (next.folds.length > MAX_ACTIVE_FOLD_RECORDS) {
         throw new Error("Active-context fold closure exceeds persistence limit");
       }
+      // AN ALREADY-DURABLE FOLD NEEDS A DIGEST, NOT A RECORD (2026-08-28). This built the
+      // whole entry for every fold on every persist just to compare one hash and continue:
+      // `makeFoldRecordEntry` canonicalizes, hashes, then `parseFoldRecordEntry` re-validates,
+      // clones the fold again, recomputes `foldIdFor`, hashes a second time and stringifies
+      // for the wire cap. Replaying a real sealed session, 98.2 percent of 4,947 calls hit
+      // the `continue`, and 126 of 135 persists appended nothing while rebuilding all of it.
+      // `foldRecordRef` is the same digest by construction (`makeFoldRecordEntry` stores
+      // `canonicalFoldRecord`, and `stateFromFoldRefs` already matches records to refs on
+      // this equality at persistence.ts:809); gate 152 pins it. Equal digests mean
+      // byte-identical canonical bytes to a record that already passed
+      // `parseFoldRecordEntry`, so skipping the rebuild cannot reach a different verdict.
+      // Measured 85.0ms to 19.6ms at 400 folds.
       for (const fold of next.folds) {
-        const record = makeFoldRecordEntry(fold, sessionId);
-        const existing = persistence.persistedFoldRecords.get(record.foldId);
+        const ref = foldRecordRef(fold);
+        const existing = persistence.persistedFoldRecords.get(ref.id);
         if (existing) {
-          if (existing.recordSha256 !== record.recordSha256) {
-            throw new Error(`Conflicting durable active-context fold ${record.foldId}`);
+          if (existing.recordSha256 !== ref.sha256) {
+            throw new Error(`Conflicting durable active-context fold ${ref.id}`);
           }
           continue;
         }
+        const record = makeFoldRecordEntry(fold, sessionId);
         await pi.appendEntry(foldRecordEntryType, record);
         persistence.persistedFoldRecords.set(record.foldId, record);
         if (!sessionIdentityStillValid(ctx, sessionId, generationAtStart)) {
@@ -914,13 +961,20 @@ export function registerActiveContext(pi: any, options: {
         }
       }
       const wire = persistence.persistedWireVersion === 2 ? makeStateDelta(persistence.persisted, next) : makeStateCheckpoint(next);
-      if (persistence.persistedWireVersion === 2 && persistence.persistedStateSha256 !== semanticStateSha256(persistence.persisted)) {
+      // THE WIRE CARRIES BOTH DIGESTS IT JUST DERIVED (2026-08-28). `makeStateDelta` writes
+      // `baseStateSha256` from `persistence.persisted` and `stateSha256` from `next`, and
+      // nothing mutates either state between that call and here, so re-hashing two whole
+      // states was pure repetition at about 7ms per durable write. The drift check keeps its
+      // teeth: `baseStateSha256` is still derived from `persistence.persisted`, so a
+      // persisted digest that has drifted from the state it claims to describe still raises.
+      // Gate 152 pins both equalities.
+      if (wire.kind === "delta" && persistence.persistedStateSha256 !== wire.baseStateSha256) {
         throw new Error("Active-context durable base digest drift");
       }
       await pi.appendEntry(stateEntryType, wire);
       persistence.persisted = clone(next);
       persistence.persistedWireVersion = 2;
-      persistence.persistedStateSha256 = semanticStateSha256(next);
+      persistence.persistedStateSha256 = wire.stateSha256;
       persistence.state = lifecycle.shuttingDown ? null : clone(next);
       if (!sessionIdentityStillValid(ctx, sessionId, generationAtStart)) {
         if (ctx && !contextSessionMatches(ctx, sessionId)) load(ctx);
@@ -1148,7 +1202,6 @@ export function registerActiveContext(pi: any, options: {
 
   const persistManual = async (
     next: ActiveContextState,
-    action: Exclude<ActiveContextToolAction, "status">,
     ctx: any,
   ): Promise<void> => {
     const stateAtEntry = persistence.state ? clone(persistence.state) : null;
@@ -1279,53 +1332,6 @@ export function registerActiveContext(pi: any, options: {
     safeNotify(ctx, `Automatic context management suspended: ${message}`, "warning");
   };
 
-  const abortUnsafeHardContext = (
-    snapshot: ActiveContextSnapshot | null,
-    ctx: any,
-    allowUnmeasuredRevisionRelease = false,
-  ): boolean => {
-    if (measurements.latestRatio === null || measurements.latestRatio < hardFenceRatio(snapshot ?? undefined, ctx) || !persistence.state) return false;
-    const measuredRevision = measurements.lastProviderMeasurement
-      ? measurements.providerMeasurementRevisionByMessageSha.get(measurements.lastProviderMeasurement.messageSha256)
-      : undefined;
-    if (allowUnmeasuredRevisionRelease && !ladder.automaticFailure &&
-        measuredRevision !== undefined && measurements.lastProviderMeasurement &&
-        !durableProviderMeasurementMatches(measurements.lastProviderMeasurement)) {
-      const releaseKey = sha256Value({
-        sessionId: persistence.state.sessionId,
-        topologySha256: topologySha256(persistence.state),
-        protectionSha256: protectionSha256(persistence.state),
-        measuredRevision,
-        providerMessageSha256: measurements.lastProviderMeasurement?.messageSha256 ?? null,
-      });
-      if (!advisory.hardFenceReleasedProjectionKeys.has(releaseKey) &&
-          advisory.hardFenceReleasedProjectionKeys.size < 4_096) {
-        advisory.hardFenceReleasedProjectionKeys.add(releaseKey);
-        return false;
-      }
-    }
-    const key = ladder.automaticFailure?.key ?? sha256Value({
-      sessionId: snapshot?.sessionId ?? persistence.state.sessionId,
-      revision: persistence.state.revision,
-      providerMessageSha256: measurements.lastProviderMeasurement?.messageSha256 ?? null,
-      phase: "hard-provider-fence",
-    });
-    ladder.pendingContextNote = `Provider context reached the hard ${brandNoun} fence without a newly committed lossless fold. ` +
-      "The provider request was aborted before transmission; run /compact or make an explicit bounded context fold.";
-    if (advisory.hardFenceNoticeKey !== key) {
-      advisory.hardFenceNoticeKey = key;
-      safeNotify(
-        ctx,
-        "Provider request aborted at the hard context fence; run /compact or make an explicit bounded context fold.",
-        "error",
-      );
-    }
-    if (typeof ctx.abort !== "function") {
-      throw new Error(`Pi hard-fence abort capability is unavailable at ratio ${measurements.latestRatio}`);
-    }
-    ctx.abort();
-    return true;
-  };
 
   const PROJECTION_CALIBRATION_MIN_CHARS = 20_000;
   const PROJECTION_CALIBRATION_MIN_TOKENS = 5_000;
@@ -1346,6 +1352,12 @@ export function registerActiveContext(pi: any, options: {
     }
     const chars = measurements.lastProjectedChars;
     if (chars === null || chars < PROJECTION_CALIBRATION_MIN_CHARS) return;
+    // NEVER LEARN THE RATIO FROM A WINDOW HOLDING AN IMAGE. chars/token is a fact about
+    // prose; a projection carrying base64 has a far higher true ratio, and because
+    // projectionCharsPerToken takes the MINIMUM over the window such a sample is either
+    // discarded (leaving the over-read in place) or, once images dominate, poisons the
+    // ratio for the text around them. The clean rule is to calibrate on text alone.
+    if (measurements.lastProjectedImages > 0) return;
     if (!Number.isFinite(measurement.tokens) || measurement.tokens < PROJECTION_CALIBRATION_MIN_TOKENS) return;
     if (measurements.lastProjectedEstimate !== null && measurements.lastProjectedEstimateCalibrated &&
         measurement.tokens > 0) {
@@ -1379,13 +1391,26 @@ export function registerActiveContext(pi: any, options: {
       return;
     }
     const chars = bytes(text);
-    if (!(measurement.tokens > 0) || chars / measurement.tokens < PROJECTION_CHARS_PER_TOKEN_FLOOR) {
+    // The anchor is differenced against TEXT characters, so it must store them. The mass
+    // belongs to the same `previousText` this anchor is built from, recorded by
+    // noteProjection when that text was produced.
+    const textChars = Math.max(0, chars - instrumentation.previousImageChars);
+    const images = instrumentation.previousImages;
+    // The floor test reads TEXT against tokens: an image-heavy projection has a raw ratio
+    // far above any prose floor and would sail through a test that is meant to reject a
+    // measurement the text cannot explain.
+    if (!(measurement.tokens > 0) ||
+        (measurement.tokens > images * IMAGE_ESTIMATED_TOKENS &&
+          textChars / (measurement.tokens - images * IMAGE_ESTIMATED_TOKENS) <
+            PROJECTION_CHARS_PER_TOKEN_FLOOR)) {
       measurements.projectionAnchor = null;
       return;
     }
     measurements.projectionAnchor = {
       tokens: measurement.tokens,
       chars,
+      textChars,
+      images,
       head: text.slice(0, -1),
       messageSha256: measurement.messageSha256,
       sessionId: persistence.state.sessionId,
@@ -1393,33 +1418,61 @@ export function registerActiveContext(pi: any, options: {
     };
   };
 
-  const projectedTokenReading = (projected: unknown[]): {
+  // THE SERIALIZATION TRAVELS, THE READING DOES NOT (2026-08-28). Six whole-window
+  // serializations rode every provider request and four were the same string from the same
+  // unmutated array. Only the TEXT is threaded, never a finished reading: each site still
+  // re-reads `measurements.projectionAnchor` and `projectionCharsPerToken()` at its own
+  // time, so every emitted number stays what it was. That matters on the commit path, where
+  // `enforceProjectionBudget` awaits `attemptAutomaticCommit` and an `attributionChanged`
+  // can null the anchor between the last measurement and the read: threading a reading would
+  // freeze `basis` at "measured" where today it flips to "unmeasured". Roughly 50ms per
+  // request at a 467KB window, 100ms at 1MB, all of it blocking main-loop CPU. Honest
+  // framing: six become three, not one.
+  const projectedTokenReading = (projected: unknown[], serialized?: string): {
     tokens: number;
     basis: ProjectionReadingBasis;
     chars: number;
+    /** The image-corrected size of THIS projection, independent of any anchor. */
+    sizeTokens: number;
+    images: number;
     anchorTokens: number | null;
     deltaChars: number | null;
+    text: string;
   } => {
-    const text = stableStringify(projected);
+    const text = serialized ?? stableStringify(projected);
     const chars = Buffer.byteLength(text, "utf8");
     const charsPerToken = projectionCharsPerToken();
-    const estimate = Math.ceil(chars / charsPerToken);
+    // AN IMAGE IS NOT TEXT (2026-08-28, see imageMass). Its base64 leaves the character
+    // count and comes back as a flat per-image cost, because dividing base64 by a ratio
+    // learned from prose read one screenshot as 110,000 tokens against a true 1,500 and
+    // aborted a session that was less than half full.
+    const mass = imageMass(projected);
+    const textChars = Math.max(0, chars - mass.base64Chars);
+    const imageTokens = mass.images * IMAGE_ESTIMATED_TOKENS;
+    const estimate = Math.ceil(textChars / charsPerToken) + imageTokens;
     const anchor = measurements.projectionAnchor;
     if (!anchor || anchor.generation !== lifecycle.generation ||
         anchor.sessionId !== persistence.state?.sessionId) {
-      return { tokens: estimate, basis: "unmeasured", chars, anchorTokens: null, deltaChars: null };
+      return { tokens: estimate, basis: "unmeasured", chars, sizeTokens: estimate, images: mass.images, anchorTokens: null, deltaChars: null, text };
     }
     const separator = text.length > anchor.head.length ? text[anchor.head.length] : "";
     if (!text.startsWith(anchor.head) || (separator !== "," && separator !== "]")) {
-      return { tokens: estimate, basis: "rewritten", chars, anchorTokens: anchor.tokens, deltaChars: null };
+      return { tokens: estimate, basis: "rewritten", chars, sizeTokens: estimate, images: mass.images, anchorTokens: anchor.tokens, deltaChars: null, text };
     }
-    const deltaChars = chars - anchor.chars;
+    // The delta is taken on TEXT characters and images separately, so an image arriving
+    // after the anchor costs its own flat price rather than its base64 length.
+    const deltaChars = textChars - anchor.textChars;
+    const deltaImages = mass.images - anchor.images;
     return {
-      tokens: Math.max(0, anchor.tokens + Math.ceil(deltaChars / charsPerToken)),
+      tokens: Math.max(0, anchor.tokens + Math.ceil(deltaChars / charsPerToken) +
+        deltaImages * IMAGE_ESTIMATED_TOKENS),
       basis: "anchored",
       chars,
+      sizeTokens: estimate,
+      images: mass.images,
       anchorTokens: anchor.tokens,
       deltaChars,
+      text,
     };
   };
 
@@ -1450,7 +1503,7 @@ export function registerActiveContext(pi: any, options: {
     estimatorErrorShare() * estimate + expectedInflowTokens(),
   ));
 
-  const projectionExceedsBudget = (projected: unknown[], ctx: any): {
+  const projectionExceedsBudget = (projected: unknown[], ctx: any, serialized?: string): {
     tokens: number;
     sizeTokens: number;
     basis: ProjectionReadingBasis;
@@ -1458,14 +1511,15 @@ export function registerActiveContext(pi: any, options: {
     marginTokens: number;
     over: boolean;
     crowded: boolean;
+    text: string;
   } => {
     const capacity = currentCapacity(ctx);
     const budgetTokens = Number.isFinite(capacity.budgetTokens) && capacity.budgetTokens > 0
       ? capacity.budgetTokens
       : Number.POSITIVE_INFINITY;
-    const reading = projectedTokenReading(projected);
+    const reading = projectedTokenReading(projected, serialized);
     const tokens = reading.tokens;
-    const sizeTokens = Math.ceil(reading.chars / projectionCharsPerToken());
+    const sizeTokens = reading.sizeTokens;
     const marginTokens = Number.isFinite(budgetTokens)
       ? projectionMarginTokens(tokens, capacity.window)
       : 0;
@@ -1477,43 +1531,10 @@ export function registerActiveContext(pi: any, options: {
       marginTokens,
       over: tokens > budgetTokens,
       crowded: tokens + marginTokens > budgetTokens,
+      text: reading.text,
     };
   };
 
-  const abortOverBudgetProjection = (
-    tokens: number,
-    budgetTokens: number,
-    ctx: any,
-    recoveryAttempts = 0,
-  ): void => {
-    const key = sha256Value({
-      sessionId: persistence.state?.sessionId ?? null,
-      revision: persistence.state?.revision ?? null,
-      tokens,
-      budgetTokens,
-      phase: "projection-budget-fence",
-    });
-    ladder.pendingContextNote =
-      `The ${brandNoun} projection estimates ${tokens} tokens against a ${budgetTokens}-token serving budget` +
-      (recoveryAttempts
-        ? `, after ${recoveryAttempts} recovery attempt(s) that folded everything foldable. The remaining ` +
-          "inflow does not fit at any folding depth, which is an impossibility rather than a recoverable state."
-        : ".") +
-      " The provider request was aborted before transmission; run /compact or make an explicit bounded context fold.";
-    if (advisory.hardFenceNoticeKey !== key) {
-      advisory.hardFenceNoticeKey = key;
-      safeNotify(
-        ctx,
-        "Provider request aborted: the projection exceeds the serving budget. " +
-        "Run /compact or make an explicit bounded context fold.",
-        "error",
-      );
-    }
-    if (typeof ctx.abort !== "function") {
-      throw new Error(`Pi projection-budget abort capability is unavailable at ${tokens} estimated tokens`);
-    }
-    ctx.abort();
-  };
 
   // THE BAND TOP COMMITS ON ITS OWN (Shane, 2026-08-22).
   //
@@ -1626,9 +1647,13 @@ export function registerActiveContext(pi: any, options: {
    * and it does not: the rebuild reads the marks, not its own last text.
    */
   const appendFoldNotice = (projected: unknown[], snapshot: ActiveContextSnapshot): unknown[] => {
+    // The deterministic experiment condition: cuts stage and commits land exactly as
+    // ever, but nothing invites a brief, so briefs stay the runtime's own.
+    if (!postFoldNotice) return projected;
     if (!persistence.state) return projected;
     const held = pendingMarks(persistence.state);
-    const unbriefed = held.filter((mark) => mark.briefProvenance?.kind !== "supplied");
+    const unbriefed = held.filter((mark) =>
+      mark.briefProvenance?.kind !== "supplied" && mark.briefProvenance?.kind !== "augmented");
     // BATCHED, AND APPENDED ONCE. A notice per cut is noise, and noise is how guidance
     // gets ignored; the frontier cuts often and this speaks only when a batch has built
     // up. `carrierAdmitted` is what makes it an APPEND rather than a rewrite: once the
@@ -1649,6 +1674,7 @@ export function registerActiveContext(pi: any, options: {
         id: mark.id,
         kind: mark.kind,
         tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
+        brief: typeof mark.brief === "string" ? mark.brief : undefined,
       })),
       pending: held.length,
       toolName,
@@ -1673,6 +1699,7 @@ export function registerActiveContext(pi: any, options: {
     return projected;
   };
 
+
   const enforceBandTop = async (
     snapshot: ActiveContextSnapshot,
     ctx: any,
@@ -1711,10 +1738,10 @@ export function registerActiveContext(pi: any, options: {
     snapshot: ActiveContextSnapshot,
     projected: unknown[],
     ctx: any,
-  ): Promise<{ projected: unknown[]; aborted: boolean }> => {
+  ): Promise<{ projected: unknown[]; text: string }> => {
     let measured = projectionExceedsBudget(projected, ctx);
     const rejected = curation.pendingRejection !== null;
-    if (!measured.crowded && !rejected) return { projected, aborted: false };
+    if (!measured.crowded && !rejected) return { projected, text: measured.text };
     const trigger = measured;
     let reduced = projected;
     let attempts = 0;
@@ -1818,9 +1845,24 @@ export function registerActiveContext(pi: any, options: {
       }));
       curation.pendingRejection = null;
     }
-    if (!measured.over) return { projected: reduced, aborted: false };
-    abortOverBudgetProjection(measured.tokens, measured.budgetTokens, ctx, attempts);
-    return { projected: reduced, aborted: true };
+    // THE RUNTIME COMMITS AND TRANSMITS; ONLY THE PROVIDER REFUSES (Shane, 2026-08-28).
+    //
+    // This used to abort the request when the projection still read over budget after the
+    // loop. It was deleted because it let an ESTIMATE veto a request that ground truth
+    // would have accepted: a live session read 220,883 tokens where the provider counted
+    // 111,837, was refused before transmission, and could not be rescued, because the
+    // commit before the refusal had applied 28 marks and the next applied 0. The advice it
+    // printed, fold manually or run /compact, named the two things the mechanism had just
+    // proven it could not do.
+    //
+    // maxTarget is a TRIGGER meaning "commit now", not a bound meaning "refuse to
+    // proceed", and only the first is something an estimate can be right about. What
+    // remains is the loop above, which commits everything it can reach; the request then
+    // goes to the provider, and a genuine overflow is handled by the rejection path, which
+    // branches back, folds and retries on the provider's own count rather than ours.
+    // `measured` is recomputed on `reduced` at every turn of the loop, so its text is the
+    // serialization of the array this returns.
+    return { projected: reduced, text: measured.text };
   };
 
   const startPreparation = (snapshot: ActiveContextSnapshot, ratio: number | null, ctx: any): void => {
@@ -1984,25 +2026,34 @@ export function registerActiveContext(pi: any, options: {
       if (freeze.projection) carryWithdrawalIntoFreeze(freeze.projection, withdrawn);
     }
     const held = freeze.body?.length ?? 0;
-    freeze.active = freeze.projection !== null && body.length >= held &&
-      stableStringify(body.slice(0, held)) === freeze.bodyText;
+    // THE PREFIX IS READ OUT OF THE WHOLE SERIALIZATION (2026-08-28). This asked
+    // `stableStringify(body.slice(0, held)) === freeze.bodyText`, and in steady state `held`
+    // is `body.length` minus the couple of messages that just arrived, so it was a second
+    // full serialization of the window plus a slice allocation, beside the one below that
+    // every pass does anyway. `serializedPrefixHolds` carries why that is sound; a false
+    // POSITIVE here splices the previous pass's `freeze.projection` in front of the new tail
+    // and emits stale messages, which is a content bug rather than a slowdown, and gate 154
+    // drives the predicate itself rather than restating it.
+    const bodyText = stableStringify(body);
+    freeze.active = freeze.projection !== null &&
+      serializedPrefixHolds(bodyText, freeze.bodyText, held, body.length);
     const projected = freeze.active
       ? [...freeze.projection!, ...body.slice(held)]
       : [...body];
     if (!freeze.active) freeze.keys.clear();
     freeze.body = body;
-    freeze.bodyText = stableStringify(body);
+    freeze.bodyText = bodyText;
     appendReceipts(projected, snapshot);
     appendFoldNotice(projected, snapshot);
     return holdFrozen(projected);
   };
-  const noteProjection = (projected: unknown[]): void => {
+  const noteProjection = (projected: unknown[], serialized?: string): void => {
     const digests = messageDigests(projected);
     const comparison = compareProjections(instrumentation.previousDigests, digests);
     recordProjection(instrumentation.ledger, comparison, digests);
     instrumentation.previousDigests = digests;
     instrumentation.lastChange = comparison.change;
-    const text = stableStringify(projected);
+    const text = serialized ?? stableStringify(projected);
     const divergence = prefixDivergence(instrumentation.previousText, text);
     const previousChars = instrumentation.previousText?.length ?? 0;
     instrumentation.lastPreservedShare = previousChars > 0
@@ -2030,7 +2081,7 @@ export function registerActiveContext(pi: any, options: {
           : latestCacheActionClass
             ? latestCacheActionClass
             : divergence.index === null ? "steady-state" : "after-message";
-    const reading = projectedTokenReading(projected);
+    const reading = projectedTokenReading(projected, text);
     emit("context.projection", {
       change: comparison.change,
       previous_count: comparison.previousCount,
@@ -2076,6 +2127,7 @@ export function registerActiveContext(pi: any, options: {
     snapshot: ActiveContextSnapshot;
     candidate: FoldCandidate;
     brief?: string;
+    briefProvenance?: "supplied" | "deterministic" | BriefProvenance;
     ctx: any;
     signal?: AbortSignal;
     maximumSourceChars?: number;
@@ -2093,6 +2145,7 @@ export function registerActiveContext(pi: any, options: {
       state: baseState,
       generation: generationAtStart,
       brief: input.brief,
+      briefProvenance: input.briefProvenance,
       ctx: input.ctx,
       signal: input.signal,
     });
@@ -2226,6 +2279,10 @@ export function registerActiveContext(pi: any, options: {
     });
     state = wedges.state;
     const accounting = markAccounting(snapshot, state);
+    // Derived ONCE, here, against the pre-commit state both readers below report against.
+    // It left `MarkAccounting` because it serializes the whole marked tail and every other
+    // caller of `markAccounting` was paying for a number only this path reads.
+    const rewriteTokens = markRewriteTokens(snapshot, state);
     if (!accounting.pending) {
       const remainder = unmarkedRemainder(snapshot, state, projectionCharsPerToken());
       emit("context.commit", {
@@ -2328,6 +2385,24 @@ export function registerActiveContext(pi: any, options: {
           !closed.applied.some((appliedMark) => appliedMark.id === mark.id)), ...closed.retained],
       };
     }
+    // THE TOOL-CALL DIET RIDES THE SAME TRANSACTION (2026-08-24): clips are selected
+    // against the post-fold state and land in the same revision the commit minted, so
+    // the one paid rewrite carries both and no non-commit pass ever moves a byte. The
+    // full bytes stay in the transcript behind each clip's entry id.
+    let clippedResults = 0;
+    if (toolFoldThreshold > 0) {
+      const clipAdditions = toolClipAdditions({
+        snapshot,
+        state: result.state,
+        threshold: toolFoldThreshold,
+        blacklist: blacklistAutoFoldTools,
+      });
+      if (clipAdditions.length) {
+        clippedResults = clipAdditions.length;
+        result = { ...result, state: { ...result.state,
+          clips: [...(result.state.clips ?? []), ...clipAdditions] } };
+      }
+    }
     persistence.state = result.state;
     const bytesAfter = bytes(projectActiveContext(snapshot, persistence.state));
     const freedBytes = Math.max(0, bytesBefore - bytesAfter);
@@ -2362,9 +2437,10 @@ export function registerActiveContext(pi: any, options: {
       consolidation_marks: consolidationAdded,
       closing_consolidation_marks: closingAdded,
       absorbed_wedges: wedges.absorbed.length,
+      clipped_results: clippedResults,
       freed_bytes: freedBytes,
       freed_tokens: estimatedTokens(freedBytes),
-      rewrite_tokens: accounting.rewriteTokens,
+      rewrite_tokens: rewriteTokens,
       pinned_bytes: accounting.pinnedBytes,
       pinned_results: accounting.pinnedResults,
       protected_stale_bytes: pinHeld.bytes,
@@ -2436,7 +2512,7 @@ export function registerActiveContext(pi: any, options: {
       protectedStaleRefs: pinHeld.refs,
       retainedMarks: result.retained.length,
       eligibleMarks: accounting.eligibleMarks,
-      estimatedRewriteTokens: accounting.rewriteTokens,
+      estimatedRewriteTokens: rewriteTokens,
       estimatedFreedTokens: accounting.freedTokens,
       freedBudgetShare: accounting.freedBudgetShare,
       sourceBytesSaved: freedBytes,
@@ -2486,8 +2562,6 @@ export function registerActiveContext(pi: any, options: {
       occupancyAfter: occupancyBefore === null ? null : Math.max(0, occupancyBefore - freedTokens),
       spansFolded: epoch ? Number(epoch.foldedSpans ?? 0) : foldIds,
       toolResultsFolded: epoch ? Number(epoch.foldedToolResults ?? 0) : 0,
-      splitFolds: Number(action.splitFolds ?? 0),
-      splitFromChars: Number(action.splitFromChars ?? 0),
       absorbedWedges: Number(epoch?.absorbedWedges ?? 0),
       recovered: curation.recoveryAttempts > 0,
       protectedBytes: Number(epoch?.protectedStaleBytes ?? 0),
@@ -2759,11 +2833,6 @@ export function registerActiveContext(pi: any, options: {
       try { projected = projectWithAdvisory(snapshot); }
       catch (error) {
         suspendAutomatic(error, "projection", ctx);
-        abortUnsafeHardContext(snapshot, ctx);
-        return { messages: event.messages };
-      }
-      if (abortUnsafeHardContext(snapshot, ctx, true)) {
-        updateStatus(ctx);
         return { messages: event.messages };
       }
       // THE FRONTIER CUTS FIRST, and it costs the projection nothing to do so: a pending
@@ -2779,23 +2848,21 @@ export function registerActiveContext(pi: any, options: {
         try { projected = projectWithAdvisory(snapshot); }
         catch (error) {
           suspendAutomatic(error, "projection", ctx);
-          abortUnsafeHardContext(snapshot, ctx);
           return { messages: event.messages };
         }
       }
       const budgeted = await enforceProjectionBudget(snapshot, projected, ctx);
       projected = budgeted.projected;
-      const reading = projectedTokenReading(projected);
+      const reading = projectedTokenReading(projected, budgeted.text);
       measurements.lastProjectedChars = reading.chars;
+      measurements.lastProjectedImages = reading.images;
       measurements.lastProjectedEstimate = reading.tokens;
       measurements.lastProjectedEstimateBasis = reading.basis;
-      measurements.lastProjectedSizeTokens = Math.ceil(reading.chars / projectionCharsPerToken());
+      // The size is the reading's own image-corrected figure. Recomputing it from raw
+      // chars here is what fed base64 straight into the fence's own accounting.
+      measurements.lastProjectedSizeTokens = reading.sizeTokens;
       measurements.lastProjectedEstimateCalibrated = measurements.projectionCalibrations.length > 0;
-      if (budgeted.aborted) {
-        updateStatus(ctx);
-        return { messages: projected };
-      }
-      noteProjection(projected);
+      noteProjection(projected, budgeted.text);
       updateStatus(ctx);
       return { messages: projected };
     } catch (error) {
@@ -2808,7 +2875,6 @@ export function registerActiveContext(pi: any, options: {
         if (!persistedSucceeded) ladder.boundaryFailure = lifecycle.latestSnapshotError;
         suspendAutomatic(error, persistedSucceeded ? "post-persist-projection" : "context", ctx);
       }
-      abortUnsafeHardContext(lifecycle.latestSnapshot, ctx);
       return { messages: event.messages };
     }
   };
@@ -3255,15 +3321,6 @@ export function registerActiveContext(pi: any, options: {
     );
   };
 
-  /**
-   * THE ONE STAGING PATH FOR FOLD MARKS (2026-08-23). The tool's fold action and the
-   * /fold-editor's user marks run THIS code and nothing else: span snapping, claim
-   * refusal, brief contract, prepareFold, replacement of a standing mark over the
-   * same span. Only the ORIGIN differs -- "agent" for the model, "user" for a human
-   * laying marks in the editor -- and origin changes nothing mechanical: a user mark
-   * counts toward the commit's coverage, answers with its commit arithmetic, and
-   * folds at the epoch exactly as an agent mark does.
-   */
   /**
    * THE WITHDRAWAL PATH, shared by the tool's unmark action and the editor's
    * withdraw intent: same refusal for an unknown id, same persist, same status.
@@ -3275,7 +3332,7 @@ export function registerActiveContext(pi: any, options: {
     const removed = before.filter((mark) => requested.has(mark.id));
     const unknown = ids.filter((id) => !before.some((mark) => mark.id === id));
     if (unknown.length) throw new Error(`No pending mark named ${unknown.join(", ")}`);
-    await persistManual(withPendingMarks(persistence.state!, kept), "unmark", ctx);
+    await persistManual(withPendingMarks(persistence.state!, kept), ctx);
     updateStatus(ctx);
     return removed as Array<Record<string, unknown>>;
   };
@@ -3305,7 +3362,7 @@ export function registerActiveContext(pi: any, options: {
           "folding keeps entries exactly recoverable without pinning them.");
       }
     }
-    await persistManual(nextProtection, pin ? "pin" : "unpin", ctx);
+    await persistManual(nextProtection, ctx);
     emit("context.pin", {
       pin,
       ids: ids.join(","),
@@ -3316,140 +3373,140 @@ export function registerActiveContext(pi: any, options: {
     updateStatus(ctx);
   };
 
-  const stageFoldMarks = async (
-    requests: BatchedMarkRequest[],
-    origin: MarkOrigin,
+  /**
+   * THE ONE STAGING PATH FOR FOLD MARKS (2026-08-23). The /fold-editor's user marks
+   * run THIS code and nothing else: span snapping, claim refusal, brief contract,
+   * prepareFold, replacement of a standing mark over the same span. A user mark is
+   * mechanically an ordinary mark: it counts toward the commit's coverage, answers
+   * with its commit arithmetic, and folds at the epoch exactly as a runtime mark does.
+   */
+  const stageFoldMark = async (
+    ids: string[],
+    supplied: string | undefined,
     signal: AbortSignal,
     ctx: any,
     snapshot: ActiveContextSnapshot,
-  ): Promise<{ marks: Array<Record<string, unknown>>; corrections: SpanCorrection[]; staged: ActiveContextState }> => {
-      const resolved: Array<{
-        candidate: FoldCandidate;
-        brief?: string;
-        corrections: SpanCorrection[];
-        splitFrom: number;
-      }> = [];
-      for (const request of requests) {
-        const snapped = snapFoldCandidate(snapshot, persistence.state, request.ids, { allowProtected: true });
-        // AN AGENT'S SPAN IS TAKEN WHOLE (Shane, 2026-08-22). The bite-size cap was
-        // applied to manual marks too, and it was the only caller: the ladder never
-        // splits, because `selectAutomaticChapter` stops accumulating at the cap on its
-        // own. So the split existed solely to second-guess the one judgement the design
-        // wants to encourage, and it charged for it twice. One intended fold became five
-        // or ten placeholders, and every piece was handed the SAME brief, so each one
-        // claimed to describe a span it held a fraction of, while the correction text
-        // said "each with its own brief", which was never true.
-        //
-        // The cap stays for the ladder, where it was earned (2026-08-06 rep 6: one
-        // 60,432-byte chapter hid the fact the run needed). The difference is who chose
-        // the boundary. A ladder fold is a span nobody vouched for, so it is kept small
-        // enough to read back cheaply. An agent fold is a span the agent cut and wrote a
-        // brief for, and it stays navigable by a route that did not exist in 2026-08:
-        // peek takes offset and bytes, states the omitted middle, and reads any child id,
-        // so a large fold has a narrow read. An expand that will not fit is refused with
-        // a peek offered instead, so size costs a refusal rather than a window.
-        resolved.push({
-          candidate: snapped.candidate,
-          brief: request.brief,
-          corrections: snapped.corrections,
-          splitFrom: 0,
-        });
-      }
-      const corrections = resolved.flatMap((item) => item.corrections);
-      const marks: Array<Record<string, unknown>> = [];
-      let staged = persistence.state!;
-      for (const item of resolved) {
-        const { candidate } = item;
-        const alreadyPrepared = staged.folds.some((fold) =>
-          fold.id === foldIdFor(candidate.kind, candidate.parts));
-        const deferred = refsProtected(candidate.sourceRefs, staged, snapshot) ||
-          (candidate.kind === "tool-result" &&
-            refsProtected(candidate.sourceRefs, staged, snapshot));
-        // A MARK IS EDITABLE UNTIL IT COMMITS (Shane, 2026-08-21). Marking a span you
-        // already marked REPLACES the mark, so a brief written in haste is corrected by
-        // writing it again: the span is identical, the id derives from the span, and no
-        // byte has moved yet, so the correction costs nothing at all. After the commit
-        // the fold is standing and there is no rewrite verb, because rewriting a
-        // standing brief rewrites the projection at its placeholder; `reboundary`
-        // re-cuts the span instead, which was going to rewrite anyway.
-        const replacing = foldIdFor(candidate.kind, candidate.parts);
-        const claimed = markClaimingRef(staged, candidate.sourceRefs);
-        if (claimed && claimed.markId !== replacing) {
-          marks.push({
-            id: replacing,
-            kind: candidate.kind,
-            ok: false,
-            deferred: false,
-            reason: `Evidence ${claimed.entryId} is already held by pending mark ${claimed.markId}, ` +
-              `which folds at the next commit. Unmark ${claimed.markId} first if you want to ` +
-              "mark this span differently.",
-          });
-          continue;
-        }
-        const suppliedComplaint = item.brief === undefined
-          ? null
-          : briefContractComplaint(item.brief.trim(), snapshot.policy.maxBriefChars, snapshot.toolName);
-        if (suppliedComplaint !== null) {
-          marks.push({
-            id: foldIdFor(candidate.kind, candidate.parts),
-            kind: candidate.kind,
-            ok: false,
-            deferred: false,
-            reason: `Supplied brief rejected. ${suppliedComplaint}`,
-          });
-          continue;
-        }
-        const briefed = !deferred && !alreadyPrepared
-          ? await prepareFold({
-            candidate,
-            snapshot,
-            state: staged,
-            generation: lifecycle.generation,
-            brief: item.brief,
-            ctx,
-            signal,
-          })
-          : null;
-        const mark = foldMarkFor({
-          candidate,
-          brief: briefed?.fold.brief ?? item.brief ?? ladderBrief(snapshot, staged, candidate),
-          briefProvenance: briefed?.fold.provenance ??
-            (item.brief ? { kind: "supplied" } : { kind: "deterministic" }),
-          origin,
-          ordinal: markOrdinal(snapshot),
-        });
-        // Drop the standing mark over this exact span before adding, so a re-mark is a
-        // replacement rather than a duplicate refusal. `claimed` is this same mark by the
-        // check above, and the id is derived from the span, so the state after is the
-        // state a first mark with the new brief would have produced.
-        const replaced = claimed !== null;
-        if (replaced) {
-          staged = withPendingMarks(staged,
-            pendingMarks(staged).filter((standing) => standing.id !== replacing));
-        }
-        const addition = addPendingMark(staged, mark);
-        if (!addition.added) {
-          marks.push({ id: mark.id, kind: mark.kind, ok: false, deferred: false, reason: addition.reason });
-          continue;
-        }
-        staged = addition.state;
-        marks.push({
-          id: mark.id,
-          kind: mark.kind,
-          ok: true,
-          deferred,
-          ...(replaced ? { replaced: true } : {}),
-          ...(deferred
-            ? {
-              scheduled: "the span is still in the fresh window; this mark is held and folds at the " +
-                "first commit after it ages out",
-            }
-            : {}),
-          brief: mark.brief,
-          provenance: normalizeLegacyProvenance(mark.briefProvenance),
-        });
-      }
-      return { marks, corrections, staged };
+  ): Promise<{ mark: Record<string, unknown>; corrections: SpanCorrection[]; staged: ActiveContextState }> => {
+    const snapped = snapFoldCandidate(snapshot, persistence.state, ids, { allowProtected: true });
+    // AN AGENT'S SPAN IS TAKEN WHOLE (Shane, 2026-08-22). The bite-size cap was
+    // applied to manual marks too, and it was the only caller: the ladder never
+    // splits, because `selectAutomaticChapter` stops accumulating at the cap on its
+    // own. So the split existed solely to second-guess the one judgement the design
+    // wants to encourage, and it charged for it twice. One intended fold became five
+    // or ten placeholders, and every piece was handed the SAME brief, so each one
+    // claimed to describe a span it held a fraction of, while the correction text
+    // said "each with its own brief", which was never true.
+    //
+    // The cap stays for the ladder, where it was earned (2026-08-06 rep 6: one
+    // 60,432-byte chapter hid the fact the run needed). The difference is who chose
+    // the boundary. A ladder fold is a span nobody vouched for, so it is kept small
+    // enough to read back cheaply. An agent fold is a span the agent cut and wrote a
+    // brief for, and it stays navigable by a route that did not exist in 2026-08:
+    // peek takes offset and bytes, states the omitted middle, and reads any child id,
+    // so a large fold has a narrow read. An expand that will not fit is refused with
+    // a peek offered instead, so size costs a refusal rather than a window.
+    const candidate = snapped.candidate;
+    const corrections = snapped.corrections;
+    let staged = persistence.state!;
+    const alreadyPrepared = staged.folds.some((fold) =>
+      fold.id === foldIdFor(candidate.kind, candidate.parts));
+    const deferred = refsProtected(candidate.sourceRefs, staged, snapshot);
+    // A MARK IS EDITABLE UNTIL IT COMMITS (Shane, 2026-08-21). Marking a span you
+    // already marked REPLACES the mark, so a brief written in haste is corrected by
+    // writing it again: the span is identical, the id derives from the span, and no
+    // byte has moved yet, so the correction costs nothing at all. After the commit
+    // the fold is standing and there is no rewrite verb, because rewriting a
+    // standing brief rewrites the projection at its placeholder; `reboundary`
+    // re-cuts the span instead, which was going to rewrite anyway.
+    const replacing = foldIdFor(candidate.kind, candidate.parts);
+    const claimed = markClaimingRef(staged, candidate.sourceRefs);
+    if (claimed && claimed.markId !== replacing) {
+      return {
+        mark: {
+          id: replacing,
+          kind: candidate.kind,
+          ok: false,
+          deferred: false,
+          reason: `Evidence ${claimed.entryId} is already held by pending mark ${claimed.markId}, ` +
+            `which folds at the next commit. Unmark ${claimed.markId} first if you want to ` +
+            "mark this span differently.",
+        },
+        corrections,
+        staged,
+      };
+    }
+    const suppliedComplaint = supplied === undefined
+      ? null
+      : briefContractComplaint(supplied.trim(), snapshot.policy.agentBriefReserve, snapshot.toolName);
+    if (suppliedComplaint !== null) {
+      return {
+        mark: {
+          id: replacing,
+          kind: candidate.kind,
+          ok: false,
+          deferred: false,
+          reason: `Supplied brief rejected. ${suppliedComplaint}`,
+        },
+        corrections,
+        staged,
+      };
+    }
+    const briefed = !deferred && !alreadyPrepared
+      ? await prepareFold({
+        candidate,
+        snapshot,
+        state: staged,
+        generation: lifecycle.generation,
+        brief: supplied,
+        ctx,
+        signal,
+      })
+      : null;
+    const mark = foldMarkFor({
+      candidate,
+      brief: briefed?.fold.brief ?? supplied ?? ladderBrief(snapshot, staged, candidate),
+      briefProvenance: briefed?.fold.provenance ??
+        (supplied ? { kind: "supplied" } : { kind: "deterministic" }),
+      origin: "user",
+      ordinal: markOrdinal(snapshot),
+    });
+    // Drop the standing mark over this exact span before adding, so a re-mark is a
+    // replacement rather than a duplicate refusal. `claimed` is this same mark by the
+    // check above, and the id is derived from the span, so the state after is the
+    // state a first mark with the new brief would have produced.
+    const replaced = claimed !== null;
+    if (replaced) {
+      staged = withPendingMarks(staged,
+        pendingMarks(staged).filter((standing) => standing.id !== replacing));
+    }
+    const addition = addPendingMark(staged, mark);
+    if (!addition.added) {
+      return {
+        mark: { id: mark.id, kind: mark.kind, ok: false, deferred: false, reason: addition.reason },
+        corrections,
+        staged,
+      };
+    }
+    staged = addition.state;
+    return {
+      mark: {
+        id: mark.id,
+        kind: mark.kind,
+        ok: true,
+        deferred,
+        ...(replaced ? { replaced: true } : {}),
+        ...(deferred
+          ? {
+            scheduled: "the span is still in the fresh window; this mark is held and folds at the " +
+              "first commit after it ages out",
+          }
+          : {}),
+        brief: mark.brief,
+        provenance: normalizeLegacyProvenance(mark.briefProvenance),
+      },
+      corrections,
+      staged,
+    };
   };
 
   const executeAction = async (
@@ -3584,7 +3641,8 @@ export function registerActiveContext(pi: any, options: {
             id: mark.id,
             kind: mark.kind,
             tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
-            briefed: mark.briefProvenance?.kind === "supplied",
+            briefed: mark.briefProvenance?.kind === "supplied" ||
+              mark.briefProvenance?.kind === "augmented",
             brief: mark.brief ?? null,
             briefProvenance: mark.briefProvenance ? clone(mark.briefProvenance) : null,
           })),
@@ -3631,7 +3689,41 @@ export function registerActiveContext(pi: any, options: {
         "bytes",
       );
       const target = persistence.state.folds.find((item) => item.id === id);
-      if (!target) throw new Error(`Unknown active-context fold ${id}`);
+      // A CLIPPED RESULT ANSWERS TO ITS ENTRY ID (2026-08-24, the tool-call diet): the
+      // clip marker names the entry, and the full bytes are in the transcript rather
+      // than behind a fold, so the read serves them from the mapped message directly,
+      // through the same admission fence and the same slice bounds as a fold peek.
+      if (!target) {
+        const clip = (persistence.state.clips ?? []).find((item) =>
+          item.entryId === id || item.callId === id);
+        if (clip) {
+          const mapped = snapshot.mapped.find((item) => item.ref?.entryId === clip.entryId);
+          if (!mapped) throw new Error(`Clipped result ${id} is no longer on this branch`);
+          const full = contentText(snapshot.messages[mapped.index]);
+          admit({
+            action: "peek",
+            ctx,
+            foldId: clip.entryId,
+            requestedBytes: Math.max(0, Math.min(sliceBytes, full.length - offset)),
+            children: [],
+          });
+          const slice = full.slice(offset, offset + sliceBytes);
+          return toolPayload({
+            id: clip.entryId,
+            source: slice,
+            truncated: offset + slice.length < full.length,
+            sourceChars: full.length,
+            offset,
+            ...(peekIsEphemeral(params) ? {
+              ephemeral: "this result rides your context exactly until your next message; " +
+                "extract what your current task needs into that reply, which takes over its " +
+                "place. Peeking again is lossless and cheap; pass ephemeral false when you " +
+                "need these bytes standing for several turns",
+            } : { durable: "this result stays in your context like any other tool result" }),
+          });
+        }
+        throw new Error(`Unknown active-context fold ${id}`);
+      }
       admit({
         action: "peek",
         ctx,
@@ -3690,7 +3782,12 @@ export function registerActiveContext(pi: any, options: {
         for (const part of [recut]) {
           const durable = persistence.persistedFoldRecords.get(foldIdFor(part.kind, part.parts));
           const { preparedFold, nextState } = await prepareAndCommitExplicit({
-            snapshot, candidate: part, brief: durable ? durable.fold.brief : supplied, ctx, signal,
+            // A re-cut carries the durable fold's OWN brief and provenance: those words
+            // were validated when they were first accepted, and re-judging them as a
+            // fresh agent submission would refuse a deterministic or composed brief
+            // against the agent's reserve.
+            snapshot, candidate: part, brief: durable ? durable.fold.brief : supplied,
+            briefProvenance: durable ? durable.fold.provenance : undefined, ctx, signal,
           });
           persistence.state = nextState;
           if (durable && supplied) correctedBriefs[preparedFold.id] = supplied;
@@ -3706,7 +3803,7 @@ export function registerActiveContext(pi: any, options: {
             briefs: { ...(persistence.state.briefs ?? {}), ...correctedBriefs },
           };
         }
-        await persistManual(persistence.state, action, ctx);
+        await persistManual(persistence.state, ctx);
         updateStatus(ctx);
         return toolPayload({
           version: 1,
@@ -3744,7 +3841,7 @@ export function registerActiveContext(pi: any, options: {
       if (!Object.keys(briefs).length) delete next.briefs;
       const leases = { ...next.leases };
       delete leases[id];
-      await persistManual({ ...next, leases }, action, ctx);
+      await persistManual({ ...next, leases }, ctx);
       updateStatus(ctx);
       return toolPayload({
         version: 1,
@@ -3790,11 +3887,7 @@ export function registerActiveContext(pi: any, options: {
         delete leases[id];
         next = { ...next, leases };
       }
-      await persistManual(
-        next,
-        action,
-        ctx,
-      );
+      await persistManual(next, ctx);
       updateStatus(ctx);
       return toolPayload({
         version: 1,
@@ -3890,7 +3983,7 @@ export function registerActiveContext(pi: any, options: {
         );
       }
       const text = String(params.brief ?? "").trim();
-      const complaint = briefContractComplaint(text, snapshot.policy.maxBriefChars, snapshot.toolName);
+      const complaint = briefContractComplaint(text, snapshot.policy.agentBriefReserve, snapshot.toolName);
       if (complaint !== null) throw new Error(`Supplied brief rejected. ${complaint}`);
       const nextState = {
         ...persistence.state!,
@@ -3900,7 +3993,7 @@ export function registerActiveContext(pi: any, options: {
           : mark),
       };
       persistence.state = nextState;
-      await persistManual(nextState, action, ctx);
+      await persistManual(nextState, ctx);
       updateStatus(ctx);
       emit("context.brief", { id, chars: text.length, origin: "agent" });
       const accounting = markAccounting(snapshot, persistence.state!);
@@ -3916,7 +4009,8 @@ export function registerActiveContext(pi: any, options: {
         durableRevision: persistence.state!.revision,
         pendingMarks: accounting.pending,
         unbriefed: pendingMarks(persistence.state!)
-          .filter((mark) => mark.briefProvenance?.kind !== "supplied").map((mark) => mark.id),
+          .filter((mark) => mark.briefProvenance?.kind !== "supplied" &&
+            mark.briefProvenance?.kind !== "augmented").map((mark) => mark.id),
         unmarkedSpans: remainder.spans,
         unmarkedTokens: remainder.tokens,
         activation: "durable immediately, and it costs your window nothing: this fold is " +
@@ -3926,12 +4020,6 @@ export function registerActiveContext(pi: any, options: {
     }
     throw new Error(`Unknown ${toolName} action '${action}'`);
   };
-  const requestedMarkCount = (params: Record<string, unknown>): number => {
-    const batched = denseOwnArrayValues(params?.marks);
-    if (batched) return batched.length;
-    return params?.ids === undefined && params?.id === undefined ? 0 : 1;
-  };
-
   const toolHandler = async (
     toolCallId: string,
     params: Record<string, unknown>,
@@ -3948,7 +4036,6 @@ export function registerActiveContext(pi: any, options: {
           ok,
           error,
           tool_call_id: toolCallId,
-          marks_requested: requestedMarkCount(params),
           corrections_applied: corrections.length,
           arguments_sha256: sha256Value(params ?? {}),
           ...(action === "peek" ? { ephemeral: peekIsEphemeral(params) } : {}),
@@ -3986,12 +4073,24 @@ export function registerActiveContext(pi: any, options: {
     try {
       const snapshot = authoritativeSnapshotFor(ctx);
       const status = activeContextStatus(snapshot, persistence.state, 0, 40);
-      safeNotify(
-        ctx,
-        `Active context: ${status.totalFolds} fold(s), roots ${(status.roots as string[]).join(", ") || "none"}. ` +
-          `Use ${toolName} status for exact recursive actions.`,
-        "info",
-      );
+      const capacity = currentCapacity(ctx);
+      const staged = pendingMarks(persistence.state);
+      safeNotify(ctx, foldStatusText({
+        brand: brandNoun,
+        usedTokens: measurements.lastProviderMeasurement?.tokens ?? null,
+        budgetTokens: capacity.budgetTokens,
+        commitAtShare: snapshot.thresholds.maxTarget,
+        aimShare: snapshot.thresholds.minTarget,
+        roots: (status.roots as string[]).length,
+        totalFolds: Number(status.totalFolds ?? 0),
+        stagedMarks: staged.length,
+        stagedTokens: staged.reduce((total, mark) =>
+          total + estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)), 0),
+        pinned: persistence.state.protected.length,
+        suspended: ladder.automaticFailure?.message ?? null,
+        foldCommand: `/${commandNames.fold}`,
+        editorCommand: "/fold-editor",
+      }), "info");
     } catch (error) {
       safeNotify(ctx, `Active-context status unavailable; native Pi context is unchanged: ${String(error)}`, "warning");
     }
@@ -4131,12 +4230,15 @@ export function registerActiveContext(pi: any, options: {
         : null;
       const accounting = markAccounting(snapshot, state);
       return {
-        title: `pi-fold context editor · ${snapshot.sessionId.slice(0, 8)}`,
+        // NO SESSION ID. Eight hex characters of a value a person never types, on the
+        // title line of the surface, is the same defect the rows below it just lost.
+        title: `${brandNoun} window`,
         occupancy: {
           usedTokens: capacity.usedTokens,
           budgetTokens: capacity.budgetTokens,
           commitOccupancy: thresholds.maxTarget,
           commitDue: occupancy !== null && occupancy >= thresholds.maxTarget,
+          suspended: Boolean(ladder.automaticFailure),
         },
         blocks: buildFoldEditorData(snapshot, state, {
           foldRows: () => (state.folds ?? []).map((fold: any) => {
@@ -4234,20 +4336,13 @@ export function registerActiveContext(pi: any, options: {
       onStageMark: async (fromId: string, toId: string, brief?: string): Promise<void> => {
         await runQueued(async () => {
           const fresh = authoritativeSnapshotFor(ctx);
-          const request = brief && brief.trim()
-            ? { ids: [fromId, toId], brief: brief.trim() }
-            : { ids: [fromId, toId] };
-          const { marks, staged } = await stageFoldMarks(
-            batchedMarkRequests(request), "user",
+          const { mark, staged } = await stageFoldMark(
+            [fromId, toId], brief && brief.trim() ? brief.trim() : undefined,
             new AbortController().signal, ctx, fresh);
-          // Refuse BEFORE persisting: an all-refused batch leaves state untouched and
+          // Refuse BEFORE persisting: a refused mark leaves state untouched and
           // persisting it would be a no-op write against the same-state projection.
-          if (!marks.some((mark) => mark.ok === true)) {
-            const reason = marks.map((mark) => mark.reason).filter(Boolean).join("; ") ||
-              "the span was refused";
-            throw new Error(reason);
-          }
-          await persistManual(staged, "fold", ctx);
+          if (mark.ok !== true) throw new Error(String(mark.reason ?? "the span was refused"));
+          await persistManual(staged, ctx);
           updateStatus(ctx);
         });
         safeNotify(ctx, "Staged user mark(s); they apply at the next commit epoch.", "info");
@@ -4291,7 +4386,7 @@ export function registerActiveContext(pi: any, options: {
     label: toolLabel,
     allowedActions: allowedToolActions,
     fullSurface: true,
-    maxBriefChars: ACTIVE_CONTEXT_POLICY.maxBriefChars,
+    maxBriefChars: ACTIVE_CONTEXT_POLICY.agentBriefReserve,
     statusDetails: ["fold_candidates", "tree", "folds", "objects"],
     minPeekSliceBytes: PEEK_MIN_SLICE_BYTES,
     defaultPeekBytes: PEEK_DEFAULT_MAX_BYTES,