dsh-switchman 1.10.3 → 1.11.1

package/host/context-trim/trigger.js

@@ -3,21 +3,31 @@
  * The trigger half of the port (design §4/§5): decides whether a fold
  * should run NOW. Called only at idle boundaries (agent/status idle) —
  * never inside llm/stream, never while a fold for the same session is in
- * flight. Three tiers, checked emergency-first:
+ * flight. Tiers, checked emergency-first:
  *
  * - emergency  : view usage >= trimEmergencyPercent of the context window.
- *                Forced MECHANICAL fold (no side-model round trip — at 95%
- *                the session cannot afford the latency or the failure).
- * - pressure   : view usage >= trimPressurePercent. Side-model fold.
+ *                Forced MECHANICAL T1 fold (no side-model round trip — at
+ *                95% the session cannot afford the latency or the failure).
+ * - pressure   : view usage >= trimPressurePercent. Side-model T1 fold.
  * - growth     : growth since the last fold's post-fold low (the anchor
  *                that keeps the gate armed after folds committing at high
  *                view points) > trimGrowthTokens AND the contiguous
  *                compressible increment >= trimIncrementTokens. The
  *                primary, cache-friendly gate (the bili heuristic).
+ * - ladder T3  : active-T2 summary mass/count gates met (docs/ladder-fold.md).
+ * - ladder T2  : active-T1 summary mass/count gates met.
+ *
+ * The ladder (T2/T3 distillation) is a MAINTENANCE path: raw T1 folds stay
+ * the primary cadence and ladder folds only fire when the summary
+ * population itself has grown worth reclaiming (mass gates — bili #379:
+ * block count is not a need signal; the count floor only filters
+ * degenerate runs). A ladder fold rewrites the wire from its first consumed
+ * summary onward (bili #1249), so the mass gates keep it rare.
  *
  * Side-model folds are additionally throttled by trimMaxFoldsPerHour and a
  * hard minimum interval between folds; emergency folds have their own
- * cooldown so a stuck-at-95% session folds at most once per window.
+ * cooldown so a stuck-at-95% session folds at most once per window; ladder
+ * folds observe a longer interval (LADDER_MIN_INTERVAL_MS) after ANY fold.
  * Everything is derived from measured inputs — no clock, no host access —
  * which keeps the decision unit-testable (golden thresholds).
  */
@@ -30,10 +40,18 @@ export const FOLD_MIN_INTERVAL_MS = 60_000;
 /** Minimum interval between emergency (mechanical) folds. */
 export const EMERGENCY_COOLDOWN_MS = 90_000;
 
+/** Minimum wall-clock interval between ladder (T2/T3 distillation) folds,
+ * measured from ANY fold: every fold rebuilds the serialized view, and
+ * interleaving a distillation between raw folds would churn the tail twice
+ * per minute for marginal reclaim. */
+export const LADDER_MIN_INTERVAL_MS = 120_000;
+
 /** The foldable span of a captured messages array for one ledger: from the
- * first segment boundary strictly after the frontier to the last segment
- * end that still clears the protected tail. Returns { startIdx, endIdx }
- * or null when nothing is foldable (empty history, everything folded, or
+ * first segment boundary strictly after the frontier AND after the task
+ * intent (the first user message — bili's protected zone: the session's
+ * opening task statement is never folded) to the last segment end that
+ * still clears the protected tail. Returns { startIdx, endIdx } or null
+ * when nothing is foldable (empty history, everything folded, or
  * protected tail covers it all). */
 export function computeFoldableRange(messages, ledger, protectedTail) {
 	if (!Array.isArray(messages) || messages.length === 0) return null;
@@ -54,9 +72,22 @@ export function computeFoldableRange(messages, ledger, protectedTail) {
 	// system/message over exactly that node). Covers both the frontier-null
 	// first fold and any frontier-set fold that lands on the head.
 	if (messages[0]?.role === "system") startFrom = Math.max(startFrom, 1);
+	// Task-intent protection: the first user message states the task; the
+	// segment containing it is never folded (its summary would become the
+	// only carrier of the task for the rest of the session — the dominant
+	// early-drift failure this guard prevents).
+	const firstUserIdx = messages.findIndex((message) => message?.role === "user");
+	if (firstUserIdx >= 0) {
+		for (const [start, end] of segmentBounds(messages)) {
+			if (start <= firstUserIdx && firstUserIdx <= end) {
+				startFrom = Math.max(startFrom, end + 1);
+				break;
+			}
+		}
+	}
 	let best = null;
 	for (const [start, end] of segmentBounds(messages)) {
-		if (start < startFrom) continue; // behind the frontier
+		if (start < startFrom) continue; // behind the frontier / intent
 		if (end >= tailStart) break; // segment would cut into the protected tail
 		if (best === null) best = { startIdx: start, endIdx: end };
 		else best.endIdx = end; // extend the contiguous span
@@ -64,66 +95,154 @@ export function computeFoldableRange(messages, ledger, protectedTail) {
 	return best;
 }
 
+/** The best ladder RUN for one tier from precomputed runs
+ * (index.js: ladderRunsOf — maximal ledger-consecutive runs of active
+ * same-tier blocks with their summary mass). Picks the run with the
+ * largest mass among those meeting the count floor; null when none does. */
+function bestLadderRun(runs, minBlocks) {
+	let best = null;
+	for (const run of Array.isArray(runs) ? runs : []) {
+		if (!Number.isFinite(run?.mass) || !Array.isArray(run?.consumes) || run.consumes.length === 0) continue;
+		if (run.consumes.length < minBlocks) continue;
+		if (best === null || run.mass > best.mass) best = run;
+	}
+	return best;
+}
+
 /** Evaluate the trigger. input: {
  *   foldable: { startIdx, endIdx } | null,  // computeFoldableRange result
  *   messages,        // captured raw messages (increment measurement)
  *   viewTokens,      // outbound-view token estimate of the current history
  *   windowTokens,    // context window size, or null when unknown
- *   thresholds: { growthTokens, incrementTokens, pressurePercent, emergencyPercent, maxFoldsPerHour },
+ *   thresholds: { growthTokens, incrementTokens, pressurePercent, emergencyPercent, maxFoldsPerHour,
+ *                 ladderT2Tokens, ladderT2MinBlocks, ladderT3Tokens, ladderT3MinBlocks },
  *   now, lastFoldAt, foldsThisHour, lastEmergencyAt,
+ *   ledger,          // the session ledger (growth anchor fields)
+ *   ladderRuns: { t2: [{ consumes, mass, count }], t3: [...] },  // census runs
  * }.
- * Returns { action: "none"|"fold"|"emergency", tier, reason, startIdx, endIdx, incrementTokens }. */
+ * Returns { action: "none"|"fold"|"emergency", kind: "raw"|"ladder", tier,
+ * reason, startIdx, endIdx, incrementTokens, consumes? }. */
 export function evaluateTrigger(input) {
-	const none = { action: "none", tier: null, reason: "", startIdx: -1, endIdx: -1, incrementTokens: 0 };
-	const foldable = input?.foldable ?? null;
-	if (foldable === null) return { ...none, reason: "nothing-foldable" };
-	const { startIdx, endIdx } = foldable;
+	const none = { action: "none", kind: "raw", tier: null, reason: "", startIdx: -1, endIdx: -1, incrementTokens: 0, consumes: null };
 	const thresholds = input?.thresholds ?? {};
 	const now = Number.isFinite(input?.now) ? input.now : Date.now();
-	const incrementTokens = estimateTokensOf(input?.messages ?? [], startIdx, endIdx);
-	if (incrementTokens < 1) return { ...none, reason: "empty-increment" };
-
-	// Tier c — emergency: window pressure, mechanical, cooldown-gated.
-	const windowTokens = Number.isFinite(input?.windowTokens) && input.windowTokens > 0 ? input.windowTokens : null;
-	const emergencyPercent = Number.isFinite(thresholds.emergencyPercent) && thresholds.emergencyPercent > 0 ? thresholds.emergencyPercent : 95;
-	if (windowTokens !== null) {
-		const usagePct = (input.viewTokens / windowTokens) * 100;
-		if (usagePct >= emergencyPercent) {
-			const lastEmergencyAt = Number.isFinite(input?.lastEmergencyAt) ? input.lastEmergencyAt : 0;
-			if (now - lastEmergencyAt < EMERGENCY_COOLDOWN_MS) return { ...none, reason: "emergency-cooldown" };
-			return { action: "emergency", tier: "emergency", reason: `usage ${usagePct.toFixed(1)}% >= ${emergencyPercent}%`, startIdx, endIdx, incrementTokens };
-		}
-	}
+	const foldable = input?.foldable ?? null;
+	const incrementTokens = foldable === null ? 0 : estimateTokensOf(input?.messages ?? [], foldable.startIdx, foldable.endIdx);
 
-	// Side-model folds (pressure + growth) share the cadence gates.
+	// Side-model folds (pressure + growth + ladder) share the cadence gates.
 	const lastFoldAt = Number.isFinite(input?.lastFoldAt) ? input.lastFoldAt : 0;
 	const hourly = Array.isArray(input?.foldsThisHour) ? input.foldsThisHour.filter((ts) => now - ts < 3_600_000).length : 0;
-	const maxFoldsPerHour = Number.isInteger(thresholds.maxFoldsPerHour) && thresholds.maxFoldsPerHour > 0 ? thresholds.maxFoldsPerHour : 6;
-	if (hourly >= maxFoldsPerHour) return { ...none, reason: "hourly-cap" };
-	if (now - lastFoldAt < FOLD_MIN_INTERVAL_MS) return { ...none, reason: "min-interval" };
+	const maxFoldsPerHour = Number.isInteger(thresholds.maxFoldsPerHour) && thresholds.maxFoldsPerHour > 0 ? thresholds.maxFoldsPerHour : 30;
+	const hourlyBlocked = hourly >= maxFoldsPerHour;
 
-	// Tier b — pressure: soft window threshold, side-model.
-	const pressurePercent = Number.isFinite(thresholds.pressurePercent) && thresholds.pressurePercent > 0 ? thresholds.pressurePercent : 60;
-	if (windowTokens !== null) {
-		const usagePct = (input.viewTokens / windowTokens) * 100;
-		if (usagePct >= pressurePercent) {
-			return { action: "fold", tier: "pressure", reason: `usage ${usagePct.toFixed(1)}% >= ${pressurePercent}%`, startIdx, endIdx, incrementTokens };
+	if (foldable !== null && incrementTokens >= 1) {
+		const { startIdx, endIdx } = foldable;
+		// Tier c — emergency: window pressure, mechanical, cooldown-gated.
+		const windowTokens = Number.isFinite(input?.windowTokens) && input.windowTokens > 0 ? input.windowTokens : null;
+		const emergencyPercent = Number.isFinite(thresholds.emergencyPercent) && thresholds.emergencyPercent > 0 ? thresholds.emergencyPercent : 95;
+		if (windowTokens !== null) {
+			const usagePct = (input.viewTokens / windowTokens) * 100;
+			if (usagePct >= emergencyPercent) {
+				const lastEmergencyAt = Number.isFinite(input?.lastEmergencyAt) ? input.lastEmergencyAt : 0;
+				if (now - lastEmergencyAt < EMERGENCY_COOLDOWN_MS) {
+					// [2026-11-07]-[fix ladder starvation under sustained emergency
+					// pressure]-[when usage stays above the emergency line the 90 s
+					// cooldown returned "none" every boundary and the lower-priority
+					// ladder never ran — the summary population grew unbounded,
+					// defeating T2/T3's aging goal. During cooldown a READY ladder
+					// is the only side-model path that can relieve pressure, so it
+					// cuts in here; every other case keeps the exact
+					// "emergency-cooldown" row. Inlined on purpose: the main ladder
+					// section below keeps its original position and semantics.]
+					const runs = input?.ladderRuns ?? {};
+					const t3R = bestLadderRun(runs.t3, Number.isInteger(thresholds.ladderT3MinBlocks) && thresholds.ladderT3MinBlocks > 0 ? thresholds.ladderT3MinBlocks : 2);
+					const t2R = bestLadderRun(runs.t2, Number.isInteger(thresholds.ladderT2MinBlocks) && thresholds.ladderT2MinBlocks > 0 ? thresholds.ladderT2MinBlocks : 3);
+					const t3M = Number.isFinite(thresholds.ladderT3Tokens) && thresholds.ladderT3Tokens > 0 ? thresholds.ladderT3Tokens : 6_000;
+					const t2M = Number.isFinite(thresholds.ladderT2Tokens) && thresholds.ladderT2Tokens > 0 ? thresholds.ladderT2Tokens : 8_000;
+					const pick = t3R !== null && t3R.mass >= t3M && (t2R === null || t2R.mass < t2M || t3R.mass >= t2R.mass) ? t3R
+						: (t2R !== null && t2R.mass >= t2M ? t2R : null);
+					// The 120 s LADDER_MIN_INTERVAL_MS is NOT applied here on
+					// purpose: the emergency fold that opened this cooldown just
+					// advanced lastFoldAt, so the interval (120 s) always exceeds
+					// the remaining cooldown (90 s) and the cut-in could never
+					// fire — a structural starvation loop (observed live). Inside
+					// the cooldown the hourly cap is the only cadence gate; the
+					// cooldown itself is the spacing.
+					if (pick !== null && !hourlyBlocked) {
+						return {
+							action: "fold",
+							kind: "ladder",
+							tier: pick === t3R ? "ladder-3" : "ladder-2",
+							reason: `ladder mass ~${Math.round(pick.mass)} blocks=${pick.consumes.length} (emergency-cooldown cut-in)`,
+							startIdx: -1,
+							endIdx: -1,
+							incrementTokens: 0,
+							consumes: pick.consumes.slice(),
+						};
+					}
+					return { ...none, reason: "emergency-cooldown" };
+				}
+				return { action: "emergency", kind: "raw", tier: "emergency", reason: `usage ${usagePct.toFixed(1)}% >= ${emergencyPercent}%`, startIdx, endIdx, incrementTokens, consumes: null };
+			}
+		}
+		if (!hourlyBlocked && now - lastFoldAt >= FOLD_MIN_INTERVAL_MS) {
+			// Tier b — pressure: soft window threshold, side-model.
+			const pressurePercent = Number.isFinite(thresholds.pressurePercent) && thresholds.pressurePercent > 0 ? thresholds.pressurePercent : 65;
+			if (windowTokens !== null) {
+				const usagePct = (input.viewTokens / windowTokens) * 100;
+				if (usagePct >= pressurePercent) {
+					return { action: "fold", kind: "raw", tier: "pressure", reason: `usage ${usagePct.toFixed(1)}% >= ${pressurePercent}%`, startIdx, endIdx, incrementTokens, consumes: null };
+				}
+			}
+			// Tier a — growth gate: the primary cache-friendly heuristic.
+			const growthTokens = Number.isFinite(thresholds.growthTokens) && thresholds.growthTokens > 0 ? thresholds.growthTokens : 22_500;
+			const incrementGate = Number.isFinite(thresholds.incrementTokens) && thresholds.incrementTokens > 0 ? thresholds.incrementTokens : 25_000;
+			// Growth anchor: the post-fold low when known (keeps the gate armed
+			// after folds that commit at high view points), else the pre-fold
+			// view for ledgers written before lastFoldLowTokens existed.
+			const anchor = Number.isFinite(input?.ledger?.lastFoldLowTokens) && input.ledger.lastFoldLowTokens > 0
+				? input.ledger.lastFoldLowTokens
+				: Number.isFinite(input?.ledger?.lastFoldViewTokens) ? input.ledger.lastFoldViewTokens : 0;
+			const growth = input.viewTokens - anchor;
+			if (growth > growthTokens && incrementTokens >= incrementGate) {
+				return { action: "fold", kind: "raw", tier: "growth", reason: `growth ~${Math.round(growth)} > ${growthTokens} and increment ~${incrementTokens} >= ${incrementGate}`, startIdx, endIdx, incrementTokens, consumes: null };
+			}
 		}
 	}
 
-	// Tier a — growth gate: the primary cache-friendly heuristic.
-	const growthTokens = Number.isFinite(thresholds.growthTokens) && thresholds.growthTokens > 0 ? thresholds.growthTokens : 22_500;
-	const incrementGate = Number.isFinite(thresholds.incrementTokens) && thresholds.incrementTokens > 0 ? thresholds.incrementTokens : 50_000;
-	// Growth anchor: the post-fold low when known (keeps the gate armed
-	// after folds that commit at high view points), else the pre-fold
-	// view for ledgers written before lastFoldLowTokens existed.
-	const anchor = Number.isFinite(input?.ledger?.lastFoldLowTokens) && input.ledger.lastFoldLowTokens > 0
-		? input.ledger.lastFoldLowTokens
-		: Number.isFinite(input?.ledger?.lastFoldViewTokens) ? input.ledger.lastFoldViewTokens : 0;
-	const growth = input.viewTokens - anchor;
-	if (growth > growthTokens && incrementTokens >= incrementGate) {
-		return { action: "fold", tier: "growth", reason: `growth ~${Math.round(growth)} > ${growthTokens} and increment ~${incrementTokens} >= ${incrementGate}`, startIdx, endIdx, incrementTokens };
+	// Ladder maintenance tiers (T3 before T2 — the deeper distillation is
+	// the larger reclaim when both are ready). Mass gates carry bili #198's
+	// minimum-benefit idea: a sub-threshold distill never fires, so the
+	// trigger cannot enter a zero-yield reset loop.
+	const ladderRuns = input?.ladderRuns ?? {};
+	const t3Blocks = Number.isInteger(thresholds.ladderT3MinBlocks) && thresholds.ladderT3MinBlocks > 0 ? thresholds.ladderT3MinBlocks : 2;
+	const t3MassGate = Number.isFinite(thresholds.ladderT3Tokens) && thresholds.ladderT3Tokens > 0 ? thresholds.ladderT3Tokens : 6_000;
+	const t2Blocks = Number.isInteger(thresholds.ladderT2MinBlocks) && thresholds.ladderT2MinBlocks > 0 ? thresholds.ladderT2MinBlocks : 3;
+	const t2MassGate = Number.isFinite(thresholds.ladderT2Tokens) && thresholds.ladderT2Tokens > 0 ? thresholds.ladderT2Tokens : 8_000;
+	const t3Run = bestLadderRun(ladderRuns.t3, t3Blocks);
+	const t2Run = bestLadderRun(ladderRuns.t2, t2Blocks);
+	if (t3Run !== null || t2Run !== null) {
+		if (now - lastFoldAt < LADDER_MIN_INTERVAL_MS) return { ...none, reason: "ladder-min-interval" };
+		if (hourlyBlocked) return { ...none, reason: "hourly-cap" };
+		const run = t3Run !== null && (t2Run === null || t3Run.mass >= t2Run.mass) ? t3Run : t2Run;
+		const tier = t3Run !== null && (t2Run === null || t3Run.mass >= t2Run.mass) ? "ladder-3" : "ladder-2";
+		const gate = tier === "ladder-3" ? t3MassGate : t2MassGate;
+		// The run passed its count floor; the mass gate decides readiness.
+		if (run.mass < gate) return { ...none, reason: "below-thresholds" };
+		return {
+			action: "fold",
+			kind: "ladder",
+			tier,
+			reason: `ladder mass ~${Math.round(run.mass)} >= ${gate} blocks=${run.consumes.length}`,
+			startIdx: -1,
+			endIdx: -1,
+			incrementTokens: 0,
+			consumes: run.consumes.slice(),
+		};
 	}
 
+	if (foldable === null) return { ...none, reason: "nothing-foldable" };
+	if (incrementTokens < 1) return { ...none, reason: "empty-increment" };
+	if (hourlyBlocked) return { ...none, reason: "hourly-cap" };
 	return { ...none, reason: "below-thresholds" };
 }

package/host/context-trim/view.js

@@ -8,6 +8,15 @@
  * (the golden test pins this), because a stable serialized prefix between
  * folds is exactly what keeps provider prompt-cache hits alive.
  *
+ * LADDER VIEW (docs/ladder-fold.md): the rebuild is a deterministic
+ * three-pass overlay. Pass 1 locates every T1 block — active AND consumed —
+ * on the raw messages (a consumed T1 summary is the ladder's raw material,
+ * so it must render). Pass 2 replaces each active T2 block's consumed-run
+ * summary messages with the T2 summary; pass 3 does the same for active T3
+ * blocks over the T2 summaries. Fail-open: a ladder block whose consumed
+ * run is missing, non-adjacent, or already covered is skipped for this
+ * view, never guessed.
+ *
  * Message refs: messages at the llm/stream boundary are plain JSON-ish
  * objects ({id?, role, content blocks / text}). An explicit id is trusted
  * only when it looks addressable (short, no whitespace/control chars — the
@@ -25,6 +34,13 @@
 
 import { createHash } from "node:crypto";
 
+/** Ladder-block probe, inlined to keep the state.js ⇄ view.js import graph
+ * acyclic (state.js imports this module's estimators). A ladder block is
+ * an active distillation of other blocks: tier 2 or 3, no raw refRange. */
+function isLadderBlock(block) {
+	return block !== null && typeof block === "object" && (block.tier === 2 || block.tier === 3);
+}
+
 /** Cheap char → token estimate (the brief's char/4 heuristic). Applies to
  *  ASCII/latin text; CJK text tokenizes far denser (see below). */
 export const TOKENS_PER_CHAR = 1 / 4;
@@ -226,14 +242,18 @@ export function rangeIsSegmentAligned(messages, startIdx, endIdx) {
 
 // ---- fold blocks ------------------------------------------------------------
 
-/** Deterministic wire text of one fold block's synthetic message. */
+/** Deterministic wire text of one fold block's synthetic message. The
+ * [SWITCHMAN:TRIM] content prefix is the downstream recognition anchor
+ * (surface.js, session tooling) and stays IDENTICAL for every tier — the
+ * ladder lives in the ledger, not in the wire text shape. */
 export function renderSummaryText(block) {
 	return `[SWITCHMAN:TRIM] ${block.summary}`;
 }
 
 /** The ONE synthetic message replacing a folded range (brief: synthetic
  * user message; id carries the acp_summary_ prefix downstream tooling
- * skips). Pure — same block, same bytes. */
+ * skips). Pure — same block, same bytes. The ladder replaces messages BY
+ * this id (id-suffix = block id), which is why ids must stay stable. */
 export function summaryMessageOf(block) {
 	return {
 		id: `acp_summary_${block.id}`,
@@ -284,20 +304,107 @@ function locateBlock(positions, block, afterIdx) {
 	return span === expected ? [firstIdx, lastIdx] : null;
 }
 
+// ---- ladder passes ------------------------------------------------------------
+
+/** Summary-id positions of one intermediate view: id suffix (the block id)
+ * -> index, for every synthetic message. One index per id (a block renders
+ * at most once — single consumption). */
+function summaryPositionsOf(messages) {
+	const prefix = "acp_summary_";
+	const positions = new Map();
+	messages.forEach((message, index) => {
+		const id = message?.id;
+		if (typeof id !== "string" || !id.startsWith(prefix)) return;
+		positions.set(id.slice(prefix.length), index);
+	});
+	return positions;
+}
+
+/** Validate one ladder block's consumed run against a positions map: every
+ * consumed id present, indices strictly consecutive ascending. Returns
+ * [firstIdx, lastIdx] or null (fail-open skip). */
+function locateLadderRun(positions, block) {
+	const consumes = Array.isArray(block?.consumes) ? block.consumes : [];
+	if (consumes.length === 0) return null;
+	let prev = null;
+	let firstIdx = -1;
+	for (const id of consumes) {
+		const at = positions.get(id);
+		if (at === undefined) return null;
+		if (prev !== null && at !== prev + 1) return null;
+		prev = at;
+		if (firstIdx < 0) firstIdx = at;
+	}
+	return [firstIdx, prev];
+}
+
+/** Apply one tier's ladder pass to the working view. Participation (docs/
+ * ladder-fold.md): ACTIVE tier-`tier` blocks replace their consumed runs —
+ * AND inactive tier-`tier` blocks consumed by an ACTIVE tier-`tier+1` block
+ * render their summary as pure ANCHOR material (a T3's consumed T2 summary
+ * must exist in the intermediate view or the T3 pass could never locate
+ * its run). Anchors replaced by the next pass do not double-count
+ * `applied`. Entries that fail their adjacency/completeness check are
+ * skipped (never guessed); valid runs are disjoint by construction (single
+ * consumption) and applied from the highest start index backward, so
+ * earlier indices stay valid while splicing. Returns the new array. */
+function applyLadderTier(messages, ladderBlocks, tier, state) {
+	if (ladderBlocks.length === 0) return messages;
+	const participants = [];
+	for (const block of ladderBlocks) {
+		if (block.tier !== tier) continue;
+		if (block.active === true) {
+			participants.push(block);
+			continue;
+		}
+		// Inactive block: an anchor only when an ACTIVE next-tier block
+		// directly consumed it.
+		const consumedByActive = ladderBlocks.some((other) => other.active === true && other.tier === tier + 1 && Array.isArray(other.consumes) && other.consumes.includes(block.id));
+		if (consumedByActive) participants.push(block);
+	}
+	if (participants.length === 0) return messages;
+	const positions = summaryPositionsOf(messages);
+	const runs = [];
+	for (const block of participants) {
+		const run = locateLadderRun(positions, block);
+		if (run === null) continue;
+		runs.push({ block, firstIdx: run[0], lastIdx: run[1] });
+	}
+	runs.sort((a, b) => b.firstIdx - a.firstIdx); // apply back-to-front
+	const out = messages.slice();
+	for (const run of runs) {
+		if (run.lastIdx >= out.length) continue;
+		// Splice the run out and drop the ladder summary in its place.
+		out.splice(run.firstIdx, run.lastIdx - run.firstIdx + 1, summaryMessageOf(run.block));
+		if (run.block.active === true) state.applied += 1;
+	}
+	return out;
+}
+
 /** Build the outbound view: apply every applicable fold block to a copy of
  * the messages array. Pure (never mutates the input; the assembly splices
- * the result into the live request array). Blocks apply in positional
- * order; a block that cannot be located, overlaps an already-applied one,
- * or reaches into the last protectedTail messages is skipped. Returns
- * { messages, applied, foldedMessages } (foldedMessages = live messages
- * the applied blocks replaced). */
+ * the result into the live request array). The rebuild is deterministic
+ * three-pass ladder overlay (docs/ladder-fold.md):
+ * 1. every T1 block — active AND consumed — locates on raw messages and
+ *    splices its summary (consumed T1 summaries are the ladder's material);
+ * 2. active T2 blocks replace their consumed runs of T1 summaries;
+ * 3. active T3 blocks replace their consumed runs of T2 summaries.
+ * A block that cannot be located, overlaps an already-applied one, or
+ * reaches into the last protectedTail messages is skipped. Returns
+ * { messages, applied, foldedMessages, unlocated } (foldedMessages = live
+ * raw messages the applied T1 blocks replaced). */
 export function buildView(messages, ledger, options = {}) {
 	const protectedTail = Number.isInteger(options.protectedTail) && options.protectedTail > 0 ? options.protectedTail : 0;
 	const blocks = Array.isArray(ledger?.blocks) ? ledger.blocks : [];
+	const t1Blocks = blocks.filter((block) => block !== null && typeof block === "object" && block.refRange !== null);
+	// Ladder blocks participate regardless of active: ACTIVE ones replace
+	// their consumed runs; INACTIVE ones may be pure anchors for the next
+	// tier's pass (applyLadderTier decides per block).
+	const ladderBlocks = blocks.filter((block) => block !== null && typeof block === "object" && isLadderBlock(block));
 	const positions = refPositions(messages);
 	const located = [];
 	let unlocated = 0;
-	for (const block of blocks) {
+	for (const block of t1Blocks) {
 		const range = locateBlock(positions, block, -1);
 		if (range !== null) located.push({ block, firstIdx: range[0], lastIdx: range[1] });
 		else unlocated += 1;
@@ -322,17 +429,26 @@ export function buildView(messages, ledger, options = {}) {
 		applied += 1;
 	}
 	for (let i = at; i < messages.length; i++) out.push(messages[i]);
-	return { messages: out, applied, foldedMessages, unlocated };
+	// Ladder passes, ascending tier (T3 anchors are T2 summaries that only
+	// exist after the T2 pass ran).
+	const ladderState = { applied };
+	let ladderOut = applyLadderTier(out, ladderBlocks, 2, ladderState);
+	ladderOut = applyLadderTier(ladderOut, ladderBlocks, 3, ladderState);
+	applied = ladderState.applied;
+	return { messages: ladderOut, applied, foldedMessages, unlocated };
 }
 
-/** Epoch-boundary detection: every block failed to LOCATE inside the current
- * re-send — the host replaced history (its own compaction) and the ledger
- * aged out as a whole. The fail-open skip stays correct, but a growth
- * baseline carried over from the previous epoch does not: the caller
- * re-anchors it exactly once per epoch. */
+/** Epoch-boundary detection: every T1 block failed to LOCATE inside the
+ * current re-send — the host replaced history (its own compaction) and the
+ * ledger aged out as a whole. Only raw-range blocks count (ladder blocks
+ * locate through their consumed T1 summaries, which the T1 pass renders);
+ * a ladder-only ledger can never read stale on its own. The fail-open skip
+ * stays correct, but a growth baseline carried over from the previous epoch
+ * does not: the caller re-anchors it exactly once per epoch. */
 export function ledgerIsStale(view, ledger) {
-	const blocksCount = Array.isArray(ledger?.blocks) ? ledger.blocks.length : 0;
-	return blocksCount > 0 && view.applied === 0 && view.unlocated === blocksCount;
+	const blocks = Array.isArray(ledger?.blocks) ? ledger.blocks : [];
+	const t1Count = blocks.filter((block) => block !== null && typeof block === "object" && block.refRange !== null).length;
+	return t1Count > 0 && view.applied === 0 && view.unlocated === t1Count;
 }
 
 /** Install the built view for one dispatch. Host immutability varies: probe