pi-fold 2.0.0 → 3.0.0

package/extensions/lib/scheduling.ts

@@ -12,6 +12,7 @@ import {
   prepareFold,
   renderFold,
   renderFoldParts,
+  selectAutomaticChapter,
   selectAutomaticSpan,
   setFoldProjectionState,
 } from "./folding.ts";
@@ -19,11 +20,10 @@ import type { AutomaticRungSelection } from "./folding.ts";
 import {
   foldInterval,
   budgetOccupancy,
-  hardFenceRatio,
   mappedByKey,
   orderedRoots,
+  protectedStaleMass,
   refsProtected,
-  toolRefsProtected,
 } from "./measurement.ts";
 import {
   childFoldIds,
@@ -33,11 +33,10 @@ import {
   parsePendingMarks,
   pendingMarkKey,
 } from "./persistence.ts";
-import { currentTurnRefKeys } from "./transcript.ts";
 import {
   ESTIMATED_BYTES_PER_TOKEN,
-  MAX_WEDGE_ABSORB_TOKENS,
   ESTIMATED_PLACEHOLDER_OVERHEAD_BYTES,
+  MAX_FRONTIER_CUTS_PER_PASS,
   MAX_PENDING_MARKS,
   MAX_UNMARKED_CANDIDATES,
 } from "./policy.ts";
@@ -58,6 +57,7 @@ import {
   partsForRange,
   peekedSourceFoldIds,
   selectAutomaticConsolidations,
+  selectAutomaticRefold,
   spanBytes,
   deterministicChapterCandidateBrief,
   deterministicConsolidationBrief,
@@ -185,15 +185,6 @@ export function markFreedBytes(
   return Math.max(0, bytes(source) - placeholder);
 }
 
-export function markTouchesCurrentTurn(
-  state: ActiveContextState,
-  mark: PendingMark,
-  currentTurn: ReadonlySet<string>,
-): boolean {
-  if (!currentTurn.size) return false;
-  return markSpanRefs(state, mark).refs.some((ref) => currentTurn.has(objectRefKey(ref)));
-}
-
 export function markSpanStart(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -210,46 +201,6 @@ export function markSpanStart(
   return indices.length ? Math.min(...indices) : snapshot.mapped.length;
 }
 
-export const GUARD_WAIVER_PROTECTED_MARKS = 2;
-
-export const GUARD_WAIVER_MINIMUM_MARKS = 4;
-
-export function guardWaiverCount(input: {
-  snapshot: ActiveContextSnapshot;
-  ratio: number | null;
-  guardedMarks: number;
-  otherApplicableMarks: number;
-  /**
-   * THE BOUNDARY IS ITS OWN SIGNAL, and a better one than the occupancy anchor.
-   *
-   * The anchor exists to answer "is this session in enough trouble to spend the open
-   * turn's own evidence": a proxy, because nothing else was asking. At a compaction
-   * boundary Pi has already answered it. Cancelling the compaction and then applying
-   * nothing hands Pi's own threshold a byte-identical projection, which is worse than
-   * letting it compact, because compaction would at least have shed something.
-   *
-   * Measured on the sol-20260813 smoke: the boundary fired, cancelled the compaction and
-   * retained all seven marks at 0.20 occupancy, freeing nothing. The full run reaches the
-   * anchor 12,576 tokens past its own trigger, so it self-corrects there and this is
-   * about what happens in between; a smoke, or any session whose budget it never
-   * approaches, never corrects at all.
-   *
-   * Everything else about the waiver is unchanged, and deliberately: the newest marks
-   * still stay raw, a small guarded set still holds whole, and other applicable work
-   * still takes precedence over spending the open turn.
-   */
-  boundary?: boolean;
-}): number {
-  const { snapshot, ratio, guardedMarks, otherApplicableMarks, boundary } = input;
-  if (guardedMarks <= 0 || typeof ratio !== "number" || !Number.isFinite(ratio)) return 0;
-  if (ratio >= hardFenceRatio(snapshot)) return guardedMarks;
-  const occupancy = budgetOccupancy(snapshot, ratio);
-  if (occupancy === null || otherApplicableMarks > 0) return 0;
-  if (occupancy < snapshot.policy.refoldRatio && !boundary) return 0;
-  if (guardedMarks < GUARD_WAIVER_MINIMUM_MARKS) return 0;
-  return Math.max(1, guardedMarks - GUARD_WAIVER_PROTECTED_MARKS);
-}
-
 export type MarkEligibility = "eligible" | "protected" | "unfulfillable";
 
 export function markEligibility(
@@ -268,9 +219,7 @@ export function markEligibility(
   if (!refs.length) return "unfulfillable";
   const mapped = new Set(snapshot.mapped.flatMap((item) => item.ref ? [objectRefKey(item.ref)] : []));
   if (refs.some((ref) => !mapped.has(objectRefKey(ref)))) return "unfulfillable";
-  const blocked = mark.kind === "tool-result"
-    ? toolRefsProtected(refs, state, snapshot)
-    : refsProtected(refs, state, snapshot);
+  const blocked = refsProtected(refs, state, snapshot);
   return blocked ? "protected" : "eligible";
 }
 
@@ -278,6 +227,7 @@ export interface MarkAccounting {
   pending: number;
   agentMarks: number;
   ladderMarks: number;
+  userMarks: number;
   freedBytes: number;
   freedTokens: number;
   freedBudgetShare: number;
@@ -327,6 +277,7 @@ export function markAccounting(
     pending: marks.length,
     agentMarks: marks.filter((mark) => mark.origin === "agent").length,
     ladderMarks: marks.filter((mark) => mark.origin === "ladder").length,
+    userMarks: marks.filter((mark) => mark.origin === "user").length,
     freedBytes,
     freedTokens,
     freedBudgetShare: snapshot.budgetTokens > 0 ? freedTokens / snapshot.budgetTokens : 0,
@@ -442,8 +393,7 @@ export function ephemeralPeekMarks(input: {
     if (!peeked) continue;
     if (peeked.some((id) => state.expanded.includes(id) || peekedFoldProtected(snapshot, state, id))) continue;
     if (refs.some((ref) => claimed.has(objectRefKey(ref))) ||
-        refs.length > snapshot.policy.maxFoldSourceRefs ||
-        toolRefsProtected(refs, state, snapshot)) continue;
+        refsProtected(refs, state, snapshot)) continue;
     const candidate: FoldCandidate = {
       kind: "tool-result",
       parts: refs.map((ref) => ({ kind: "raw" as const, ref })),
@@ -468,9 +418,7 @@ function peekedFoldProtected(
   const fold = state.folds.find((item) => item.id === foldId);
   if (!fold) return false;
   const refs = flattenFoldRefs(fold, state);
-  return fold.kind === "tool-result"
-    ? toolRefsProtected(refs, state, snapshot)
-    : refsProtected(refs, state, snapshot);
+  return refsProtected(refs, state, snapshot);
 }
 
 export function claimedRefKeys(state: ActiveContextState): Set<string> {
@@ -488,6 +436,8 @@ export function claimedRefKeys(state: ActiveContextState): Set<string> {
 export interface UnmarkedRemainder {
   spans: number;
   tokens: number;
+  /** Raw bytes, which is what the fold frontier measures itself against. */
+  chars: number;
   share: number;
   candidates: Array<{ id: string; tokens: number }>;
 }
@@ -504,6 +454,33 @@ export function unmarkedRemainder(
   for (const batch of automaticToolBatches(snapshot, state)) {
     for (const index of batch.indices) members.add(index);
   }
+  // CHAPTERS ARE FOLDABLE MASS TOO (Shane, 2026-08-23).
+  //
+  // The population used to be tool batches alone, while `selectAutomaticSpan` proposes a
+  // chapter whenever no batch is available, so on a chapter-heavy session this reported a
+  // remainder of zero over material automatic folding was about to take. It is the reading
+  // a deferred commit uses to say whether its mass is HELD or simply absent, which is the
+  // one distinction that record exists to draw, and it was answering "absent" for mass in
+  // plain view. It also broke the frontier's first cut, which gated on this number before
+  // the threshold moved into the selector where it belongs.
+  //
+  // Walked with the selector rather than re-derived, so the population is what automatic
+  // folding can actually reach and cannot drift from it. Walked from an EMPTY claim set,
+  // because this is the DENOMINATOR: a chapter already claimed by a mark is still foldable
+  // mass, it is just mass that is already spoken for, and the numerator below is what
+  // subtracts it. Bounded by the mapped length, which no terminating walk can exceed since
+  // every pass claims at least one ref.
+  const indexed = mappedByKey(snapshot);
+  const walked = new Set<string>();
+  for (let pass = 0; pass < snapshot.mapped.length; pass += 1) {
+    const chapter = selectAutomaticChapter(snapshot, state, walked);
+    if (!chapter) break;
+    for (const ref of chapter.sourceRefs) {
+      walked.add(objectRefKey(ref));
+      const item = indexed.get(objectRefKey(ref));
+      if (item) members.add(item.index);
+    }
+  }
   const candidates: Array<{ id: string; tokens: number }> = [];
   let unmarkedBytes = 0;
   let memberBytes = 0;
@@ -519,11 +496,193 @@ export function unmarkedRemainder(
   return {
     spans: candidates.length,
     tokens: Math.ceil(unmarkedBytes / perToken),
+    chars: unmarkedBytes,
     share: memberBytes > 0 ? unmarkedBytes / memberBytes : 0,
     candidates: candidates.slice(0, Math.max(0, limit)),
   };
 }
 
+/**
+ * THE FOLD FRONTIER: THE RUNTIME CUTS, AND THE AGENT EDITS WHAT IT CUT
+ * (Shane, 2026-08-23).
+ *
+ * The ladder used to stage nothing between commits, and before that it staged a mark on
+ * every measured response. Both were answers to the same question, WHEN SHOULD THE AGENT
+ * CURATE, and both got it wrong in the same way: they asked the agent to CHOOSE SPANS.
+ * Eager staging chose them first and crowded the agent out; standing down left the choice
+ * open until the commit, by which time the material was long out of view and the only
+ * information available was staleness, which the runtime already has.
+ *
+ * So the choice moves. As raw material accumulates past `minFoldChars`, the runtime cuts
+ * it, stalest first, exactly as a commit would. The cut is a PENDING MARK and pending
+ * marks are byte-inert: nothing moves, the projection does not change, the prefix cache is
+ * untouched, and the agent keeps seeing the raw material until a commit applies it. What
+ * the agent gets is a fold to annotate while the content is still fresh, which is the one
+ * thing it knows that the runtime does not.
+ *
+ * The loop bounds itself twice over. It stops when the unmarked remainder falls under the
+ * threshold, and it stops when the selector runs out of members, so a window whose whole
+ * remainder is pinned or blacklisted stages nothing and says so by returning empty rather
+ * than spinning.
+ */
+export function frontierMarks(input: {
+  snapshot: ActiveContextSnapshot;
+  state: ActiveContextState;
+  ordinal: number;
+}): PendingFoldMark[] {
+  const { snapshot } = input;
+  const claimed = claimedRefKeys(input.state);
+  const marks: PendingFoldMark[] = [];
+  let state = input.state;
+  while (marks.length < MAX_FRONTIER_CUTS_PER_PASS) {
+    // THE THRESHOLD IS THE SELECTOR'S OWN, which is `minFoldChars`, and it is read there
+    // rather than counted here. The first cut of this measured the unmarked remainder
+    // instead, and that reads TOOL BATCHES ONLY: a chapter-only session had a remainder of
+    // zero however much raw prose it held, so the frontier never fired on it at all and
+    // gate 7's fixture produced no cut. One threshold, in the one place that knows every
+    // span kind.
+    const candidate = selectAutomaticSpan(snapshot, state, claimed);
+    if (!candidate) break;
+    const mark = foldMarkFor({
+      candidate,
+      ...automaticMarkBrief(snapshot, state, candidate),
+      origin: "ladder",
+      ordinal: input.ordinal,
+    });
+    const addition = addPendingMark(state, mark);
+    if (!addition.added) break;
+    state = addition.state;
+    marks.push(mark);
+    for (const ref of candidate.sourceRefs) claimed.add(objectRefKey(ref));
+  }
+  return marks;
+}
+
+/**
+ * The pending mark that already holds a piece of this evidence, if any.
+ *
+ * The commit fills from the stale end and the depth bound retains what it does not
+ * reach, so a ladder mark routinely outlives the commit that staged it. An agent
+ * marking the same evidence afterwards would stand a second owner over one span and
+ * lose at apply time with a forest invariant for a message. Refusing at the tool says
+ * so while the agent can still act on it.
+ */
+export function markClaimingRef(
+  state: ActiveContextState,
+  refs: readonly EvidenceRef[],
+): { markId: string; entryId: string } | null {
+  for (const mark of pendingMarks(state)) {
+    if (mark.mark !== "fold") continue;
+    const claimed = new Set(markSpanRefs(state, mark).refs.map(objectRefKey));
+    for (const ref of refs) {
+      if (claimed.has(objectRefKey(ref))) return { markId: mark.id, entryId: ref.entryId };
+    }
+  }
+  return null;
+}
+
+export interface WindowClaims {
+  /** Tokens standing marks will free at the next commit. */
+  markedTokens: number;
+  /** Tokens the agent pinned raw: a claim that frees nothing and is never taken. */
+  pinnedTokens: number;
+  pinnedRefs: number;
+  /** Pinned mass as a share of the serving budget, against its cap. */
+  pinnedShare: number;
+  /** Completed units neither marked nor pinned: what the ladder takes by age. */
+  unclaimedTokens: number;
+  unclaimedSpans: number;
+}
+
+/**
+ * A PIN IS A CLAIM, NOT A FOLD (Shane, 2026-08-22: "if they do a pin on raw span I think
+ * we also treat that as a marked fold but a pinned one").
+ *
+ * Read as accounting, that is exactly right and already half true: pinned evidence is
+ * refused to every automatic rung, skipped by wedge absorption, and excluded from the
+ * unmarked remainder, so the ladder cannot take it and it is never reported as an
+ * oversight. What was missing is that the agent could not SEE it, and the whole point of
+ * asking an agent to account for its window is that the gaps become visible.
+ *
+ * A pin cannot count toward the DROP, and that is not a technicality. Pinned bytes stay
+ * in the window, so they free nothing; if they counted, an agent could "cover" a commit
+ * with pins, the commit would still be short, and it would fold something else anyway.
+ * The number would be a lie at the moment it mattered most. So the three buckets are
+ * reported side by side and only one of them pays.
+ */
+export function windowClaims(input: {
+  snapshot: ActiveContextSnapshot;
+  state: ActiveContextState;
+  budgetTokens: number;
+  charsPerToken: number;
+}): WindowClaims {
+  const { snapshot, state, budgetTokens } = input;
+  const accounting = markAccounting(snapshot, state);
+  const remainder = unmarkedRemainder(snapshot, state, input.charsPerToken);
+  const pinned = protectedStaleMass(snapshot, state);
+  const pinnedTokens = estimatedTokens(pinned.bytes);
+  return {
+    markedTokens: Math.round(accounting.eligibleFreedBudgetShare * budgetTokens),
+    pinnedTokens,
+    pinnedRefs: pinned.refs,
+    pinnedShare: budgetTokens > 0 ? pinnedTokens / budgetTokens : 0,
+    unclaimedTokens: remainder.tokens,
+    unclaimedSpans: remainder.spans,
+  };
+}
+
+export interface CommitCoverage {
+  /** The share of the serving budget the next commit is sized to free. */
+  targetShare: number;
+  targetTokens: number;
+  /** What the standing marks will actually free when that commit runs. */
+  markedShare: number;
+  markedTokens: number;
+  /** What the ladder will take by staleness unless the agent marks it first. */
+  remainingTokens: number;
+  covered: boolean;
+}
+
+/**
+ * WHAT THE NEXT COMMIT NEEDS, AND HOW MUCH OF IT THE AGENT HAS COVERED.
+ *
+ * One definition, read by three callers that used to reason about the drop separately:
+ * the commit fill that sizes itself to it, the advisory that warns before it, and the
+ * mark response that tells the agent where it stands. An agent asked to govern its own
+ * context cannot do it against a number nobody tells it.
+ *
+ * The marked side is the ELIGIBLE share, not every standing mark, because a mark over
+ * protected evidence frees nothing at this commit however good it is. That makes
+ * `remainingTokens` the honest answer to "what will fold without me".
+ *
+ * `targetShare` moves as the window grows: it is measured from occupancy NOW, and two
+ * large results landing after the reading raise it again. Callers that render it say so.
+ */
+export function commitCoverage(input: {
+  snapshot: ActiveContextSnapshot;
+  state: ActiveContextState;
+  usedTokens: number | null;
+  budgetTokens: number;
+}): CommitCoverage {
+  const { snapshot, state, usedTokens, budgetTokens } = input;
+  const targetShare = usedTokens === null || !(budgetTokens > 0)
+    ? 0
+    : Math.max(0, (usedTokens - snapshot.thresholds.minTarget * budgetTokens) / budgetTokens);
+  const accounting = markAccounting(snapshot, state);
+  const markedShare = accounting.eligibleFreedBudgetShare;
+  const targetTokens = Math.round(targetShare * budgetTokens);
+  const markedTokens = Math.round(markedShare * budgetTokens);
+  const remainingTokens = Math.max(0, targetTokens - markedTokens);
+  return {
+    targetShare,
+    targetTokens,
+    markedShare,
+    markedTokens,
+    remainingTokens,
+    covered: remainingTokens === 0,
+  };
+}
+
 export function markedFoldIds(state: ActiveContextState): Set<string> {
   const ids = new Set<string>();
   for (const mark of pendingMarks(state)) if (mark.mark === "refold") ids.add(mark.id);
@@ -548,13 +707,11 @@ export function topUpMarks(input: {
   state: ActiveContextState;
   ordinal: number;
   targetShare: number;
-  excludeRefKeys?: ReadonlySet<string>;
   eligibleOnly?: boolean;
 }): PendingFoldMark[] {
   const { snapshot } = input;
   const target = input.targetShare;
   const claimed = claimedRefKeys(input.state);
-  for (const key of input.excludeRefKeys ?? []) claimed.add(key);
   const marks: PendingFoldMark[] = [];
   let state = input.state;
   const progress = (value: ActiveContextState): number => {
@@ -581,6 +738,50 @@ export function topUpMarks(input: {
   return marks;
 }
 
+/**
+ * REFOLD AS THE LAST FILL, NOT THE FIRST (Shane, 2026-08-21).
+ *
+ * An expanded fold is stale mass sitting in the window, so the commit may reclaim it,
+ * but only after raw stale material has been spent. An agent that expands a fold is
+ * reading it; taking it back while there is still unfolded material to take is hostile
+ * for no gain. Pin holds a span past that point, and a live lease holds it for the
+ * generations right after the expand. Stalest first, and never past the freeing target.
+ */
+export function refoldMarks(input: {
+  snapshot: ActiveContextSnapshot;
+  state: ActiveContextState;
+  ordinal: number;
+  targetShare: number;
+  eligibleOnly?: boolean;
+}): PendingMark[] {
+  const { snapshot } = input;
+  const marks: PendingMark[] = [];
+  let state = input.state;
+  const claimedFoldIds = markedFoldIds(state);
+  const progress = (value: ActiveContextState): number => {
+    const accounting = markAccounting(snapshot, value);
+    return input.eligibleOnly ? accounting.eligibleFreedBudgetShare : accounting.freedBudgetShare;
+  };
+  let share = progress(state);
+  while (share < input.targetShare) {
+    const foldId = selectAutomaticRefold(snapshot, state, claimedFoldIds);
+    if (!foldId) break;
+    const mark: PendingMark = {
+      mark: "refold",
+      id: foldId,
+      origin: "ladder",
+      ordinal: input.ordinal,
+    };
+    const addition = addPendingMark(state, mark);
+    if (!addition.added) break;
+    state = addition.state;
+    marks.push(mark);
+    claimedFoldIds.add(foldId);
+    share = progress(state);
+  }
+  return marks;
+}
+
 export interface AbsorbedWedge {
   intoMarkId: string;
   fromMarkId: string;
@@ -588,6 +789,7 @@ export interface AbsorbedWedge {
   endId: string;
   entries: number;
   tokens: number;
+  chars: number;
 }
 
 export function absorbWedgeMarks(input: {
@@ -631,8 +833,16 @@ export function absorbWedgeMarks(input: {
       const gapEnd = interval.start - 1;
       if (gapStart < 0 || gapEnd < gapStart) continue;
       if (absorbed.some((item) => item.intoMarkId === mark.id)) continue;
-      const gapTokens = Math.ceil(spanBytes(snapshot, gapStart, gapEnd + 1) / charsPerToken);
-      if (gapTokens > MAX_WEDGE_ABSORB_TOKENS) continue;
+      // THE GAP FLOOR IS THE FOLD FLOOR (Shane, 2026-08-21). A gap between two folds
+      // that could not stand as a fold on its own has no business staying raw: it costs
+      // its own bytes and buys nothing, and the neighbour beside it can hold it for the
+      // price of one sentence in the brief. So anything under minFoldChars is absorbed
+      // and anything at or over it is left alone, because at that size it is a fold the
+      // ladder will take on its own terms. This replaced MAX_WEDGE_ABSORB_TOKENS, a
+      // separate 256-token constant that let 1,024-char slivers survive between folds.
+      const gapBytes = spanBytes(snapshot, gapStart, gapEnd + 1);
+      if (gapBytes >= snapshot.thresholds.minFoldChars) continue;
+      const gapTokens = Math.ceil(gapBytes / charsPerToken);
       const gapRefs = [];
       let usable = true;
       for (let index = gapStart; index <= gapEnd; index += 1) {
@@ -669,6 +879,7 @@ export function absorbWedgeMarks(input: {
         endId: gapRefs.at(-1)!.entryId,
         entries: gapRefs.length,
         tokens: gapTokens,
+        chars: gapBytes,
       });
       applied = true;
       break;
@@ -698,7 +909,6 @@ export interface CommitEpochResult {
   applied: AppliedMark[];
   refused: RefusedMark[];
   retained: PendingMark[];
-  waived: PendingMark[];
 }
 
 export async function commitPendingMarks(input: {
@@ -707,48 +917,40 @@ export async function commitPendingMarks(input: {
   generation: number;
   now?: () => number;
   retainIneligible?: boolean;
-  guardCurrentTurn?: boolean;
-  guardWaiver?: number;
+  /**
+   * How many bytes this commit needs to free. Marks past it are RETAINED, not applied.
+   *
+   * This bound did not exist before the frontier (Shane, 2026-08-23), and it did not need
+   * to: staging was sized to the drop by `topUpMarks`, so every pending mark was one the
+   * commit had already decided it wanted. The frontier stages as material ARRIVES, which
+   * is the whole point of it, so by the time a commit fires the pending set is everything
+   * the window holds. Applying all of it would cut the window to nothing at the first
+   * commit, which is neither what the budget asks for nor what the agent is owed: what it
+   * is owed is that material stays raw for as long as there is room for it.
+   *
+   * Undefined means no bound, which is what the emergency lanes want: a fence or a
+   * rollback is not housekeeping and takes everything it can.
+   */
+  applyTargetBytes?: number;
 }): Promise<CommitEpochResult> {
+  // THE CURRENT-TURN GUARD IS DELETED (Shane, 2026-08-23: "you're using turns as the
+  // boundaries, which should not be the case. It should be at the most granular level,
+  // which is events"). The guard retained every mark touching a toolResult newer than
+  // the last terminal assistant stop, and a terminal stop is a TURN artifact: the first
+  // live session (sol-20260823-live rep 1) ran its whole workload as one turn, every
+  // assistant response stopping "toolUse", so the guard's "current turn" was the entire
+  // window, four band-top commits applied nothing, and the projection fence swept 18
+  // marks at 0.958 occupancy down to a 0.031 landing against a 0.40 aim. The waiver
+  // machinery existed only to bail the guard out at the fence and the boundary, so it
+  // is deleted with it. What protects the working set now is structural and event-level:
+  // an incomplete batch is never proposable, the depth bound stops the routine commit at
+  // the aim, and the stalest-first cut order leaves the newest events raw.
   const marks = pendingMarks(input.state);
   const retained: PendingMark[] = [];
-  const waived: PendingMark[] = [];
-  const guardReasons = new Map<string, string>();
   const held = new Set(input.state.folds.map((fold) => fold.id));
   const deferred: PendingMark[] = [];
   const awaitingMintedChild = (mark: PendingMark): boolean =>
     markSpanRefs(input.state, mark).unresolved?.pending === true;
-  const currentTurn = input.guardCurrentTurn
-    ? currentTurnRefKeys(input.snapshot)
-    : new Set<string>();
-  if (input.guardCurrentTurn) {
-    const applicable: PendingMark[] = [];
-    const guarded: PendingMark[] = [];
-    for (const mark of marks) {
-      if (markTouchesCurrentTurn(input.state, mark, currentTurn)) guarded.push(mark);
-      else applicable.push(mark);
-    }
-    const guardedStart = new Map(guarded.map((mark) =>
-      [pendingMarkKey(mark), markSpanStart(input.snapshot, input.state, mark)] as const));
-    guarded.sort((left, right) =>
-      guardedStart.get(pendingMarkKey(left))! - guardedStart.get(pendingMarkKey(right))! ||
-      left.id.localeCompare(right.id));
-    const waiverCount = Math.max(0, Math.min(guarded.length, Math.trunc(input.guardWaiver ?? 0)));
-    for (const [index, mark] of guarded.entries()) {
-      if (index < waiverCount) {
-        waived.push(mark);
-        applicable.push(mark);
-        continue;
-      }
-      retained.push(mark);
-      guardReasons.set(
-        pendingMarkKey(mark),
-        "evidence was gathered in the current turn; the mark stays pending until the turn closes",
-      );
-    }
-    marks.length = 0;
-    marks.push(...applicable);
-  }
   if (input.retainIneligible) {
     const applicable: PendingMark[] = [];
     for (const mark of marks) {
@@ -765,8 +967,7 @@ export async function commitPendingMarks(input: {
     mark: mark.mark,
     id: mark.id,
     origin: mark.origin,
-    reason: guardReasons.get(pendingMarkKey(mark)) ??
-      "span is still fresh or protected; the mark stays pending until it is eligible",
+    reason: "span is still fresh or protected; the mark stays pending until it is eligible",
     retained: true,
   }));
   const minting = new Map(marks.flatMap((mark) =>
@@ -793,6 +994,40 @@ export async function commitPendingMarks(input: {
     placed.add(key);
     ordered.push(mark);
   };
+  // THE DEPTH CUT, STALEST FIRST. `base` is already in span order, so taking a prefix of
+  // it takes the oldest material and leaves the newest raw, which is the ordering the
+  // agent would choose if it were asked. A mark left over here is RETAINED rather than
+  // refused: it is still pending, still briefable, still editable, and the next commit
+  // that needs depth will reach it.
+  const bounded: PendingMark[] = [];
+  if (input.applyTargetBytes !== undefined && input.applyTargetBytes > 0) {
+    let freed = 0;
+    for (const mark of base) {
+      if (freed >= input.applyTargetBytes) {
+        bounded.push(mark);
+        continue;
+      }
+      freed += markFreedBytes(input.snapshot, input.state, mark);
+    }
+    if (bounded.length) {
+      const spare = new Set(bounded.map((mark) => pendingMarkKey(mark)));
+      const kept = base.filter((mark) => !spare.has(pendingMarkKey(mark)));
+      base.length = 0;
+      base.push(...kept);
+      for (const mark of bounded) {
+        retained.push(mark);
+        refused.push({
+          mark: mark.mark,
+          id: mark.id,
+          origin: mark.origin,
+          reason: "the commit reached its target before this mark; it stays pending and " +
+            "the span stays raw until a later commit needs the depth",
+          retained: true,
+        });
+      }
+      state = withPendingMarks(input.state, retained);
+    }
+  }
   for (const mark of base) place(mark);
   for (const mark of ordered) {
     try {
@@ -825,13 +1060,11 @@ export async function commitPendingMarks(input: {
         continue;
       }
       const sourceRefs = span.refs;
-      const blocked = mark.kind === "tool-result"
-        ? toolRefsProtected(sourceRefs, state, input.snapshot)
-        : refsProtected(sourceRefs, state, input.snapshot);
+      const blocked = refsProtected(sourceRefs, state, input.snapshot);
       if (blocked) {
         throw new Error(
           `pending fold mark ${mark.id} covers protected or fresh evidence; ` +
-          "unprotect that evidence and mark it again",
+          "unpin that evidence and mark it again",
         );
       }
       const prepared = await prepareFold({
@@ -867,7 +1100,7 @@ export async function commitPendingMarks(input: {
     state = withPendingMarks(state, [...pendingMarks(state), ...deferred]);
     retained.push(...deferred);
   }
-  return { state, applied, refused, retained, waived };
+  return { state, applied, refused, retained };
 }
 
 export function schedulingStatus(input: {