pi-fold 1.0.4 → 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,12 +33,10 @@ import {
   parsePendingMarks,
   pendingMarkKey,
 } from "./persistence.ts";
-import { currentTurnRefKeys } from "./transcript.ts";
 import {
-  EPOCH_MAX_TOPUP_MARKS,
   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";
@@ -59,66 +57,30 @@ import {
   partsForRange,
   peekedSourceFoldIds,
   selectAutomaticConsolidations,
+  selectAutomaticRefold,
   spanBytes,
   deterministicChapterCandidateBrief,
   deterministicConsolidationBrief,
   resultCall,
 } from "./selection.ts";
 
-/**
- * Two-phase fold scheduling.
- *
- * A provider prefix cache is positional: editing the middle of the window
- * invalidates every byte after the edit, so per-turn folding pays a full uncached
- * prefix over and over. Nothing here changes what a fold MEANS. A fold decision
- * becomes a MARK, which moves no projection byte, and a later COMMIT applies every
- * pending mark through the same preparation and commit machinery an immediate fold
- * uses, in one rewrite.
- *
- * Every function is deterministic: transcript ordinals and positions only, never a
- * wall clock and never randomness.
- */
-
-/** The empty read, shared and frozen, so a state with no marks allocates nothing. */
 const NO_PENDING_MARKS: readonly PendingMark[] = Object.freeze([]);
 
-/**
- * The pending marks as a READ VIEW, not a copy.
- *
- * Every caller here reads: membership tests, accounting sums, and filters that build
- * a fresh array anyway. The copy belongs on the WRITE path, and `withPendingMarks`
- * already takes it, so taking a second one on every read bought nothing and cost a
- * great deal: `markSpanRefs` calls this once per mark and is itself called once per
- * mark by the accounting, eligibility, staleness, current-turn and absorption
- * readings, which made a deep clone of the whole array quadratic in the mark count
- * per pass. Profiled at 21 percent of a 120-turn session, the single largest cost in
- * the runtime, ahead of every projection and hash.
- *
- * The view is safe because the state is replaced rather than edited: no code path
- * mutates `state.pendingMarks` in place, and the readonly type is what keeps it so.
- */
 export function pendingMarks(state: Pick<ActiveContextState, "pendingMarks">): readonly PendingMark[] {
   return state.pendingMarks ?? NO_PENDING_MARKS;
 }
 
-/**
- * Property ORDER matters here: the state digest is a stable stringify, so an
- * appended key would replay as digest drift. Rebuild the tail of the record in the
- * same order `parseActiveContextState` produces.
- */
 export function withPendingMarks(
   state: ActiveContextState,
   marks: readonly PendingMark[],
 ): ActiveContextState {
   const next = marks.length ? parsePendingMarks(clone(marks) as PendingMark[]) : [];
   const head = { ...state };
-  delete head.surfacing;
   delete head.pendingMarks;
   delete head.advisory;
   delete head.prepared;
   return {
     ...head,
-    ...(state.surfacing?.length ? { surfacing: clone(state.surfacing) } : {}),
     ...(next.length ? { pendingMarks: next } : {}),
     ...(state.advisory ? { advisory: clone(state.advisory) } : {}),
     ...(state.prepared ? { prepared: clone(state.prepared) } : {}),
@@ -131,7 +93,6 @@ export interface MarkAddition {
   reason: string | null;
 }
 
-/** Idempotent by mark key, bounded, and never silently dropping the oldest mark. */
 export function addPendingMark(state: ActiveContextState, mark: PendingMark): MarkAddition {
   const marks = pendingMarks(state);
   if (marks.some((existing) => pendingMarkKey(existing) === pendingMarkKey(mark))) {
@@ -151,43 +112,15 @@ export function estimatedTokens(sizeInBytes: number): number {
   return Math.max(0, Math.ceil(sizeInBytes / ESTIMATED_BYTES_PER_TOKEN));
 }
 
-/** Transcript-position ordering used for marks; identical to the surfacing ordinal. */
 export function markOrdinal(snapshot: Pick<ActiveContextSnapshot, "mapped">): number {
   return snapshot.mapped.length;
 }
 
 export interface MarkSpanRefs {
-  /** Every evidence ref the mark's parts resolve to against the state in hand. */
   refs: EvidenceRef[];
-  /**
-   * The first part naming a fold the state does not hold, or null when the span reads
-   * in full. `pending` is the difference between a defer and a drop: a mark still
-   * standing carries the id its committed fold will have, so that fold is about to
-   * exist, and where no mark names it nothing ever will.
-   */
   unresolved: { foldId: string; pending: boolean } | null;
 }
 
-/**
- * THE ONE READING OF A MARK'S SPAN, AND IT ANSWERS RATHER THAN THROWS.
- *
- * A mark's parts name folds by id. Between the mark and the commit the state can stop
- * holding one: `reboundary` dissolves a root while consulting only `fold.parentId`, so
- * nothing there consults the pending marks, and the mark is left naming a fold that is
- * gone. `candidateSourceRefs` answers that with `Missing candidate child`, which is
- * right for a candidate being prepared and wrong for every reading that merely reports
- * on a mark: accounting, eligibility, staleness, the current-turn guard, the claimed
- * keys and wedge absorption all ran that throw out of a status call or a commit pass,
- * on state the runtime itself produced (Shane 2026-08-10).
- *
- * So the readings share this, and it is total. Raw parts resolve; a held child is
- * flattened; an unheld child is REPORTED, with the refs either side of it still
- * collected, because a partial span is the honest reading of a partly resolvable mark
- * and a guard that can see half the evidence is better than one that sees none. A
- * repeated fold on the path reads as unresolved and not pending: a corrupt forest costs
- * one mark the ordinary drop rather than hanging the caller, which is the same stop the
- * apply order's `placing` set carries.
- */
 export function markSpanRefs(state: ActiveContextState, mark: PendingMark): MarkSpanRefs {
   const byId = new Map(state.folds.map((fold) => [fold.id, fold] as const));
   const marks = pendingMarks(state);
@@ -230,11 +163,6 @@ export function markSpanRefs(state: ActiveContextState, mark: PendingMark): Mark
   return { refs, unresolved };
 }
 
-/**
- * Estimated bytes a mark would remove from the projection. Fold marks use a
- * placeholder estimate rather than a trial fold: the number is presentational, so
- * paying a full preparation per mark on every status call is not worth exactness.
- */
 export function markFreedBytes(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -257,41 +185,6 @@ export function markFreedBytes(
   return Math.max(0, bytes(source) - placeholder);
 }
 
-/**
- * Whether a pending mark covers any evidence the current excursion just gathered.
- *
- * Read off whatever the span resolves to. A mark naming an unheld fold still answers
- * here, on the parts that DO resolve, so a span holding both fresh raw evidence and a
- * child that has not landed is guarded on the fresh evidence instead of throwing the
- * whole commit.
- */
-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)));
-}
-
-/**
- * The real staleness of a mark: the earliest window index its span covers, in branch
- * order.
- *
- * A mark's `ordinal` is the transcript position at MARK time, so across epochs it
- * carries when the DECISION was made and nothing about the age of what the decision
- * covers, and inside one epoch every mark shares one value. Ordering a release by it
- * therefore fell through to comparing mark ids, which are content hashes. Measured on the
- * sealed rep-3 state 2026-08-10: the bounded release held back the marks covering window
- * indices 101 and 111 and surrendered the one covering 117, the newest material on the
- * table, so the two marks the guard kept were not the two it exists to keep.
- *
- * A span that no longer maps sorts past the newest entry: there is no staleness to read
- * on material that has left the branch, and releasing such a mark frees no window byte.
- * A span that does not resolve in full sorts there too, for the same reason and by the
- * same number: while a named fold is missing there is no start to read, and the apply
- * order places such a mark off its naming rather than off this reading.
- */
 export function markSpanStart(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -308,71 +201,8 @@ export function markSpanStart(
   return indices.length ? Math.min(...indices) : snapshot.mapped.length;
 }
 
-/**
- * How many of the newest guarded marks the pressure waiver still protects. The agent's
- * MOST RECENT reads are the ones an in-flight excursion is about to work from, so they
- * are the last thing surrendered; everything older is fair game once the window is the
- * bigger risk.
- */
-export const GUARD_WAIVER_PROTECTED_MARKS = 2;
-
-/**
- * How many marks the guard must be holding before the pressure waiver releases any.
- * Without a floor the waiver degrades into exactly the per-pass folding epoch
- * scheduling exists to prevent: the batch drains, one new mark is guarded on the next
- * pass, and releasing that one mark buys a whole prefix invalidation. Below the fence
- * the waiver only ever releases a BATCH. The fence itself ignores this floor.
- */
-export const GUARD_WAIVER_MINIMUM_MARKS = 4;
-
-/**
- * Survivability outranks the guard.
- *
- * The current-turn guard is correct while there is room to wait, and fatal once there
- * is not: a workload that never emits a terminal assistant message has ONE turn, so
- * the boundary never advances and every mark is guarded forever. Measured 2026-08-06
- * (rep 11): 58 assistant messages, all stopReason "toolUse", ZERO terminal ones, so
- * the automatic commit applied nothing all run; the only marks that ever landed came
- * from the agent's own two explicit commits. The window reached 359,625 tokens and the
- * next request went out at ~458k estimated and was rejected by the provider.
- *
- * So: the guard holds in full while the commit has other work. It is waived only when
- * it would STARVE the commit -- no other mark could be applied -- and pressure has
- * reached the backstop, and then only for the OLDEST guarded marks. At the hard fence
- * every guarded mark is waived, because the only useful action left is the fold that
- * keeps the request transmissible.
- */
-export function guardWaiverCount(input: {
-  snapshot: ActiveContextSnapshot;
-  ratio: number | null;
-  guardedMarks: number;
-  /** Marks this commit can apply WITHOUT the waiver. While any exist, the guard holds. */
-  otherApplicableMarks: number;
-}): number {
-  const { snapshot, ratio, guardedMarks, otherApplicableMarks } = 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 || occupancy < snapshot.policy.refoldRatio || otherApplicableMarks > 0) 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";
 
-/**
- * Whether a pending mark can be applied right now.
- *
- * "protected" is a WAITING state, not a failure: the span is fresh or the agent
- * protected it, and both conditions expire. "unfulfillable" is terminal: the evidence
- * or the fold the mark names has left the branch, so no later commit can honour it.
- * Collapsing the two is what made a refusal look like a drop.
- *
- * A mark naming a fold the state does not hold is judged by the same two words, and
- * the classification is the whole answer: a fold another pending mark is about to mint
- * is a span still WAITING to be readable, and a fold nothing will mint has left the
- * branch exactly as lost evidence has. No third word (Shane 2026-08-10).
- */
 export function markEligibility(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -389,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";
 }
 
@@ -399,29 +227,20 @@ export interface MarkAccounting {
   pending: number;
   agentMarks: number;
   ladderMarks: number;
+  userMarks: number;
   freedBytes: number;
   freedTokens: number;
   freedBudgetShare: number;
   rewriteTokens: number;
-  /** Marks a commit could apply right now. */
   eligibleMarks: number;
-  /** Marks whose span is still fresh or protected, waiting rather than lost. */
   retainedMarks: number;
   eligibleFreedBytes: number;
   eligibleFreedTokens: number;
-  /** The ROI signal: eligible marked mass as a share of the truthful window. */
   eligibleFreedBudgetShare: number;
-  /** Raw peek mass no reclamation can take: pinned reads and protected results. */
   pinnedBytes: number;
-  /** How many peek results that mass is spread over. */
   pinnedResults: number;
 }
 
-/**
- * What a commit of the current marks would cost and free. `rewriteTokens` is the
- * prefix a commit invalidates: everything from the earliest marked message to the
- * end of the window, which is exactly what a positional cache must re-send.
- */
 export function markAccounting(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -458,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,
@@ -474,22 +294,6 @@ export function markAccounting(
   };
 }
 
-/**
- * THE commit trigger. There is exactly one.
- *
- * Occupancy of the serving budget reaches maxTarget and a commit fires. Nothing else
- * fires one automatically: the user command and the fence/recovery lane are the only
- * other paths into a commit, and both are authority rather than economics.
- *
- * Two arms used to sit here. The eligible-share arm asked whether accumulated marks
- * were worth a rewrite and fired 164 commits from ordinal 17 in rep 15, each a fresh
- * cache rebuild bought with marks that had not yet earned one; worse, it could fire
- * BELOW maxTarget, which is the quiet-runtime law it was sitting underneath. The
- * pressure arm read a window ratio against the refold rung, which after
- * re-denomination is simply a second line above this one. Both are gone. Marking is
- * doorless below the commit line and costs nothing, so what a pass accumulates is never a
- * reason to commit; crossing the band top is.
- */
 export function epochCommitDue(snapshot: ActiveContextSnapshot, ratio: number | null): boolean {
   const occupancy = budgetOccupancy(snapshot, ratio);
   return occupancy !== null && occupancy >= snapshot.thresholds.maxTarget;
@@ -505,8 +309,6 @@ export function foldMarkFor(input: {
   const { candidate } = input;
   return {
     mark: "fold",
-    // The same identity the committed fold will get, so a repeated decision is
-    // inert rather than a second fold of the same span.
     id: foldIdFor(candidate.kind, candidate.parts),
     kind: candidate.kind,
     parts: clone(candidate.parts),
@@ -517,25 +319,18 @@ export function foldMarkFor(input: {
   };
 }
 
-/** The deterministic brief a ladder decision would have folded with. */
 export function ladderBrief(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
   candidate: FoldCandidate,
 ): string {
   if (candidate.kind === "tool-result") return automaticToolBrief(snapshot, candidate);
-  if (candidate.kind === "consolidation") return deterministicConsolidationBrief(candidate, state);
+  if (candidate.kind === "consolidation") {
+    return deterministicConsolidationBrief(candidate, state, snapshot.toolName, snapshot);
+  }
   return deterministicChapterCandidateBrief(snapshot, candidate);
 }
 
-/**
- * The brief and provenance an automatic mark carries.
- *
- * A warmed chapter brief the runtime already paid a model call for is REUSED when the
- * prepared fold is exactly this candidate. Under epoch scheduling every automatic fold
- * arrives through a mark, so a preparation whose brief the mark path ignored would be a
- * model call spent on nothing.
- */
 export function automaticMarkBrief(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -548,11 +343,6 @@ export function automaticMarkBrief(
   return { brief: ladderBrief(snapshot, state, candidate), briefProvenance: { kind: "deterministic" } };
 }
 
-/**
- * Turn one automatic rung selection into a mark. Prepared chapters are excluded on
- * purpose: that rung only fires at the hard provider fence, which is already inside
- * a commit epoch, and deferring it would strand a model-generated brief.
- */
 export function ladderSelectionMark(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
@@ -574,24 +364,6 @@ export function ladderSelectionMark(input: {
   });
 }
 
-/**
- * PEEK COPIES ARE EPHEMERAL BY CONTRACT.
- *
- * A peek returns a fold's exact stored source, so the copy sits in the window as raw
- * mass beside that fold's own placeholder: the same bytes held twice, with the second
- * copy re-retrievable forever from the id the agent already used. So a completed peek
- * read is reclaimed at the NEXT commit rather than aging through the ladder, and the
- * window being append-only is why the reclaim can only happen at a commit boundary.
- *
- * Two survival paths, and only two. Expanding the fold it peeked means the agent asked
- * for those bytes in place, and pinning is the veto: a pin holds the copy raw through
- * every commit, exactly as it holds any other evidence, and lifting it hands the copy
- * back to the next commit. Both are read here at marking time, and a pin made AFTER the
- * mark exists still vetoes, because a protected mark waits instead of applying.
- *
- * These marks are minted at the last-call exposure as well as at the commit, so the
- * pending disposal is visible during the gated round the pin has to fit inside.
- */
 export function ephemeralPeekMarks(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
@@ -619,11 +391,9 @@ export function ephemeralPeekMarks(input: {
       .map(({ index }) => snapshot.mapped[index].ref!);
     const peeked = peekedSourceFoldIds(snapshot, refs);
     if (!peeked) continue;
-    // The agent committed to what it peeked: leave the read in the raw window.
     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 })),
@@ -633,8 +403,6 @@ export function ephemeralPeekMarks(input: {
       candidate,
       brief: automaticToolBrief(snapshot, candidate),
       briefProvenance: { kind: "deterministic" },
-      // A peek is an agent-initiated read; attributing its disposal to the ladder
-      // would deflate the agent-vs-ladder mark ratio the adjudication reads.
       origin: "agent",
       ordinal: input.ordinal,
     }));
@@ -650,12 +418,9 @@ 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);
 }
 
-/** Every evidence key already spoken for by a fold or a pending fold mark. */
 export function claimedRefKeys(state: ActiveContextState): Set<string> {
   const keys = new Set<string>();
   for (const fold of state.folds) {
@@ -668,35 +433,15 @@ export function claimedRefKeys(state: ActiveContextState): Set<string> {
   return keys;
 }
 
-/** What is still on the table after the marks in hand: the steering number and its parts. */
 export interface UnmarkedRemainder {
-  /** Tool results in a MEMBER batch that no fold and no pending mark owns. */
   spans: number;
   tokens: number;
-  /** Unmarked member tokens as a share of the member tool mass. The steering number. */
+  /** Raw bytes, which is what the fold frontier measures itself against. */
+  chars: number;
   share: number;
-  /** The largest few, by reclaim value, so the next batch is one read away. */
   candidates: Array<{ id: string; tokens: number }>;
 }
 
-/**
- * The unmarked remainder, as an AGGREGATE plus a bounded head.
- *
- * An exhaustive list is what the status index already is, and re-rendering it is what
- * this build removed from the projection. What an agent needs to decide the NEXT batch
- * is one percentage and the few largest names; everything else is a total.
- *
- * ONE DEFINITION OF STALE, AND IT IS THE SELECTOR'S OWN. The scope is class membership:
- * every result inside a batch `automaticToolBatches` admits, which is the same
- * enumeration `selectAutomaticToolBatch` picks its proposal out of. So the last call and
- * the deferred-commit record announce mass a commit can actually take, by construction
- * rather than by two filters kept in step. Counting whole-window tool results instead
- * announced material no rung could ever propose: rep 3 named 280k tokens while every
- * selector had nothing, which reads as a runtime refusing work it had just described.
- *
- * Membership is not ownership: the denominator is every member result, taken or not, so
- * the share reads as the fraction of reachable tool mass still unspoken for.
- */
 export function unmarkedRemainder(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -709,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;
@@ -724,29 +496,199 @@ 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)),
   };
 }
 
-/** Every fold id already spoken for by a pending refold mark. */
+/**
+ * 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);
   return ids;
 }
 
-/**
- * THE COUNT LAW, AS MARKS. Every parent the eligible-root count owes right now, all of
- * them, in the epoch that notices.
- *
- * Separate from the top-up on purpose. The top-up is pressure arithmetic: it stops the
- * moment the marks in hand reach the freeing target, which is the right rule for how
- * DEEP a commit cuts and the wrong rule entirely for a law that says a count of eligible
- * roots at or above the width is a state that must not persist. So this runs at every
- * commit epoch and it runs first, whatever the pressure and whatever the top-up would
- * have proposed (Shane 2026-08-10).
- */
 export function consolidationMarks(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
@@ -760,28 +702,16 @@ export function consolidationMarks(input: {
   }));
 }
 
-/**
- * Agent judgment leads; automation guarantees the floor. If the marks the agent made
- * would free less than the target share of the window, automation adds the stalest
- * unprotected eligible SPANS until they do: completed tool batches and raw narrative
- * chapters. Placeholders are not on that list any more; a placeholder gets a parent from
- * the count law above, which is not pressure arithmetic and does not stop at a target.
- */
 export function topUpMarks(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
   ordinal: number;
-  /** Freeing target as a share of the SERVING BUDGET. Required: there is no second default. */
   targetShare: number;
-  /** Evidence keys the top-up may never propose, e.g. the current excursion's reads. */
-  excludeRefKeys?: ReadonlySet<string>;
-  /** Measure progress against ELIGIBLE mass, so pinned or protected marks never count. */
   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 => {
@@ -789,7 +719,7 @@ export function topUpMarks(input: {
     return input.eligibleOnly ? accounting.eligibleFreedBudgetShare : accounting.freedBudgetShare;
   };
   let share = progress(state);
-  for (let attempt = 0; attempt < EPOCH_MAX_TOPUP_MARKS && share < target; attempt += 1) {
+  while (share < target) {
     const candidate = selectAutomaticSpan(snapshot, state, claimed);
     if (!candidate) break;
     const mark = foldMarkFor({
@@ -808,44 +738,64 @@ export function topUpMarks(input: {
   return marks;
 }
 
-/** One sliver a commit swallowed into its later neighbour, reported never inferred. */
+/**
+ * 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 {
-  /** The mark that grew backward to cover it. */
   intoMarkId: string;
-  /**
-   * The id that mark carried BEFORE it grew. A mark's id is derived from its span, so
-   * growing the span mints a new one; without this the trail from the decision the
-   * agent made to the fold that carries it is broken, and a mark appears to vanish.
-   */
   fromMarkId: string;
   startId: string;
   endId: string;
   entries: number;
   tokens: number;
+  chars: number;
 }
 
-/**
- * Wedge absorption. THE ANTI-LCM PIN LIVES HERE.
- *
- * A sliver of stale raw content hugging a fold boundary is a crumb nothing will ever
- * reclaim: it is below the minimum chapter size, so no chapter rung will take it, and
- * it is not a tool batch, so no tool rung will either. Absorbing it costs nothing
- * because it happens INSIDE a commit the epoch has already paid for -- it grows a
- * pending mark backward rather than performing a mutation of its own.
- *
- * What it must never do is erode deliberate non-sequential curation. An agent holding
- * folds at 10:20, 40:55 and 60:70 with raw spans between them chose that shape, and a
- * mechanism that swallowed those gaps would delete the curation element outright. So
- * the threshold is tiny, measured in the session's own calibrated tokens, and NOT
- * pressure-scaled: above it, a gap stays raw permanently no matter how full the window
- * gets or how ragged the projection looks.
- */
 export function absorbWedgeMarks(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
-  /** The session's measured serialized chars per token; never a fixed constant. */
   charsPerToken: number;
-  /** Evidence absorption may never touch, e.g. the current excursion's own reads. */
   excludeRefKeys?: ReadonlySet<string>;
 }): { state: ActiveContextState; absorbed: AbsorbedWedge[] } {
   const { snapshot } = input;
@@ -863,9 +813,7 @@ export function absorbWedgeMarks(input: {
       .filter((index): index is number => index !== undefined);
     return indices.length ? { start: Math.min(...indices), end: Math.max(...indices) } : null;
   };
-  // One pass, oldest first. Each absorption rewrites exactly one mark, and a mark that
-  // has already grown is not a candidate to grow again in the same commit.
-  for (let guard = 0; guard < MAX_PENDING_MARKS; guard += 1) {
+  for (;;) {
     const marks = pendingMarks(state);
     const occupied = [
       ...orderedRoots(state, snapshot).map((root) => ({ start: root.start, end: root.end })),
@@ -885,9 +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);
-      // The whole discriminator, in one line: above this, the gap is the agent's.
-      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) {
@@ -897,15 +852,19 @@ export function absorbWedgeMarks(input: {
       }
       if (!usable || !gapRefs.length) continue;
       if (refsProtected(gapRefs, state, snapshot)) continue;
-      // Structural safety: the grown span must still be a valid closed chapter, which
-      // is what keeps every tool call paired with its result in the projection.
       if (!chapterRangeIsUnitAligned(snapshot, gapStart, interval.end)) continue;
       const parts = partsForRange(snapshot, state, gapStart, interval.end, new Set<FoldKind>(["tool-result"]));
       if (!parts) continue;
+      // ELIGIBILITY, not truncation (Shane 2026-08-14): the grown fold's brief
+      // must name what it absorbed, and a brief already near the policy cap has
+      // no room for that sentence. Slicing dropped exactly the words that made
+      // the absorption honest, so a wedge whose truthful suffix does not fit is
+      // simply not absorbed; the gap stays raw for a later commit.
+      const absorbSuffix = ` It also holds ${gapRefs.length} short adjacent entry(s) absorbed at commit.`;
+      if (mark.brief.length + absorbSuffix.length > snapshot.policy.maxBriefChars) continue;
       const grown = foldMarkFor({
         candidate: { kind: "chapter", parts, sourceRefs: candidateSourceRefs(parts, state) },
-        brief: `${mark.brief} It also holds ${gapRefs.length} short adjacent entry(s) absorbed at commit.`
-          .slice(0, snapshot.policy.maxBriefChars),
+        brief: `${mark.brief}${absorbSuffix}`,
         briefProvenance: mark.briefProvenance,
         origin: mark.origin,
         ordinal: mark.ordinal,
@@ -920,6 +879,7 @@ export function absorbWedgeMarks(input: {
         endId: gapRefs.at(-1)!.entryId,
         entries: gapRefs.length,
         tokens: gapTokens,
+        chars: gapBytes,
       });
       applied = true;
       break;
@@ -941,7 +901,6 @@ export interface RefusedMark {
   id: string;
   origin: MarkOrigin;
   reason: string;
-  /** Whether the mark survives as pending rather than being discarded. */
   retained: boolean;
 }
 
@@ -950,98 +909,51 @@ export interface CommitEpochResult {
   applied: AppliedMark[];
   refused: RefusedMark[];
   retained: PendingMark[];
-  /** Guarded marks the pressure waiver released into this commit, oldest material first. */
-  waived: PendingMark[];
 }
 
-/**
- * Apply every pending mark. This is the ONE mutation of the epoch: it reuses
- * prepareFold/commitPreparedFold exactly as the immediate path does, so a committed
- * mark and an immediate fold produce the same fold record.
- */
 export async function commitPendingMarks(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
   generation: number;
   now?: () => number;
-  /**
-   * Keep marks the commit could not apply YET. A mark is a standing decision; dropping
-   * it because the span happened to be fresh at commit time silently discards the
-   * agent's judgment and leaves nothing for the next commit to act on.
-   */
   retainIneligible?: boolean;
   /**
-   * Never fold evidence the CURRENT excursion gathered. A commit that runs between
-   * an agent's read and its use of that read hands the agent a window where its own
-   * just-gathered evidence is a placeholder. Such marks stay pending for the next
-   * commit rather than being applied or dropped.
+   * 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.
    */
-  guardCurrentTurn?: boolean;
-  /**
-   * How many guarded marks the pressure waiver releases anyway, oldest material first. The
-   * guard protects an in-flight excursion; it may never cost the session its ability
-   * to send a request at all. See `guardWaiverCount`.
-   */
-  guardWaiver?: number;
+  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[] = [];
-  /**
-   * Whether the mark names a fold some other standing mark is about to mint. Until that
-   * fold exists there is no eligibility worth judging: the question is about material
-   * the child owns, and the apply loop is where it gets asked, after the child has
-   * landed. A mark naming a fold NOBODY will mint is not this case; it is judged
-   * normally, and the apply loop drops it by name.
-   */
   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);
-    }
-    // Oldest MATERIAL first: the newest reads are the ones the excursion is about to
-    // use, so they are the last evidence the waiver surrenders. Staleness is a property
-    // of the span, never of when the mark was proposed; see `markSpanStart`. The id
-    // comparison is the final tiebreak between marks covering the same start, and
-    // nothing else.
-    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) {
-      // A mark awaiting a child another mark will mint is not judged here. Its
-      // eligibility is a question about material the child fold owns, and that fold is
-      // what this commit is about to create. The apply loop asks it once the child has
-      // landed, and answers by name when it does not.
       if (!awaitingMintedChild(mark) &&
           markEligibility(input.snapshot, input.state, mark) === "protected") retained.push(mark);
       else applicable.push(mark);
@@ -1055,27 +967,9 @@ 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,
   }));
-  // CHILDREN BEFORE THE SPANS THAT ABSORB THEM, AND TRANSCRIPT ORDER IS NOT THAT ORDER.
-  //
-  // The invariant is real: a span whose parts name another mark's fold must find that
-  // fold in the forest when it applies. `foldMarkFor` gives a mark the id its committed
-  // fold will carry, so the naming is exact and readable off the parts. What it is NOT is
-  // geometry. A parent CONTAINS its child, so the earliest window index a parent covers
-  // is at or before its child's, and ordering oldest material first applies the parent
-  // FIRST in exactly the case the invariant exists for. The cost is not a reordering:
-  // `candidateSourceRefs` throws `Missing candidate child` on the unresolved part, the
-  // apply loop catches it, and the mark is refused with `retained: false`, so the parent
-  // applied one place too early loses the agent's decision outright rather than waiting.
-  //
-  // So the dependency is the law and the sort key is the tiebreak. Among marks with no
-  // such tie, real transcript order: the earliest window index the span covers, oldest
-  // material first, id last. The `ordinal` this used to sort on is the transcript position
-  // at MARK time, one value shared by every mark an epoch proposes, so within an epoch it
-  // decided nothing and the order fell through to comparing content hashes.
   const minting = new Map(marks.flatMap((mark) =>
     mark.mark === "fold" && !held.has(mark.id) ? [[mark.id, mark] as const] : []));
   const applyStart = new Map(marks.map((mark) =>
@@ -1088,9 +982,6 @@ export async function commitPendingMarks(input: {
   const placing = new Set<string>();
   const place = (mark: PendingMark): void => {
     const key = pendingMarkKey(mark);
-    // `placing` is the cycle stop. Fold ids are hashes OF the parts, so a cycle would
-    // need a hash to name its own ancestor; the guard is here so a corrupt state loses
-    // one mark to the ordinary refusal rather than hanging the commit.
     if (placed.has(key) || placing.has(key)) return;
     placing.add(key);
     if (mark.mark === "fold") {
@@ -1103,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 {
@@ -1117,15 +1042,6 @@ export async function commitPendingMarks(input: {
         continue;
       }
       const parts = clone(mark.parts);
-      // THE ANSWER TO A NAME THE STATE CANNOT RESOLVE, AND IT IS TWO ANSWERS.
-      //
-      // A mark still standing will mint the fold this one names, so the span becomes
-      // readable at the next commit: that is a DEFER, and the mark stays pending. This
-      // is the child a guard held while its parent was applicable, which the epoch used
-      // to discard outright. Nothing standing names it and it is a DROP: `reboundary`
-      // dissolved the fold, or the mark that would have minted it was itself refused,
-      // and no later commit can honour the decision. Same two words the eligibility
-      // reading uses, and the same receipt shape a dropped brief upgrade gets.
       const span = markSpanRefs(state, mark);
       if (span.unresolved) {
         const { foldId, pending } = span.unresolved;
@@ -1144,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({
@@ -1169,9 +1083,6 @@ export async function commitPendingMarks(input: {
         generation: input.generation,
       });
       applied.push({ mark: "fold", id: mark.id, origin: mark.origin, foldId: prepared.id });
-      // A warmed preparation the commit just materialized through its mark is spent:
-      // leaving it standing would hold a prepared fold whose id already exists in the
-      // forest, and every later drift check would refuse it by name.
       if (state.prepared && state.folds.some((fold) => fold.id === state.prepared!.id)) {
         state = clearPrepared(state);
       }
@@ -1185,17 +1096,13 @@ export async function commitPendingMarks(input: {
       });
     }
   }
-  // Deferrals rejoin the pending set. A mark the loop could not read yet is a standing
-  // decision exactly as a guard-held one is, and `retained` is what the commit record
-  // counts as deferred, so both live in the same list.
   if (deferred.length) {
     state = withPendingMarks(state, [...pendingMarks(state), ...deferred]);
     retained.push(...deferred);
   }
-  return { state, applied, refused, retained, waived };
+  return { state, applied, refused, retained };
 }
 
-/** The scheduling block reported by the status action. */
 export function schedulingStatus(input: {
   snapshot: ActiveContextSnapshot;
   state: ActiveContextState;
@@ -1203,16 +1110,11 @@ export function schedulingStatus(input: {
 }): Record<string, unknown> {
   const accounting = markAccounting(input.snapshot, input.state);
   return {
-    // A literal, not a setting: epoch is the only scheduler there is.
     mode: "epoch",
     ...accounting,
-    // The declared policy, reported never mutable.
     thresholds: { ...input.snapshot.thresholds },
     budgetTokens: input.snapshot.budgetTokens,
     commitDue: epochCommitDue(input.snapshot, input.ratio),
-    // One trigger, reported as one line. The eligible share is still reported above in
-    // the accounting because it is what a commit WOULD free; it is no longer a reason
-    // to fire one.
     commitTrigger: {
       mode: "band-top",
       commitOccupancy: input.snapshot.thresholds.maxTarget,