dsh-switchman 1.11.5 → 1.11.6

package/host/context-trim/index.js

@@ -24,7 +24,8 @@
  *
  * Config fields (host/config.js, all volatile): trimEnabled, trimMode
  * ("off"|"advisory"|"auto"), trimGrowthTokens, trimIncrementTokens,
- * trimPressurePercent, trimEmergencyPercent, trimWindowTokens,
+ * trimPressurePercent, trimEmergencyPercent, trimAdvisoryPercent,
+ * trimAdvisoryCriticalPercent, trimWindowTokens,
  * trimProtectedTail, trimMaxFoldsPerHour, trimSideModel, trimFoldFallbackModel, trimStateDir,
  * trimLadderEnabled, trimLadderT2Tokens, trimLadderT2MinBlocks,
  * trimLadderT3Tokens, trimLadderT3MinBlocks.
@@ -32,7 +33,7 @@
 
 import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { buildView, estimateTokensOf, injectView, ledgerIsStale, messageTokens, rangeIsSegmentAligned, refOf, refPositions } from "./view.js";
+import { buildView, estimateTokensOf, injectView, isFoldSummaryMessage, ledgerIsStale, messageTokens, rangeIsSegmentAligned, refOf, refPositions } from "./view.js";
 import { computeFoldableRange, evaluateTrigger, EMERGENCY_COOLDOWN_MS } from "./trigger.js";
 import { LADDER_SYSTEM_PROMPT, mechanicalSummary, renderLadderMaterial, renderMaterial, summarizeWithModel } from "./summarizer.js";
 import { createStore } from "./state.js";
@@ -274,6 +275,44 @@ export const TRIM_PROTOCOL_TEXT = [
 	"- Tool-call pairs (an assistant tool call and its results) must always be folded together or not at all.",
 ].join("\n");
 
+// Advisory nudge thresholds: the default speak line (65%) deliberately sits
+// below the protocol's own 80% fold line so the model is nudged while it
+// still has comfortable headroom; critical wording escalates at 95%. At most
+// one nudge per session per 10 minutes (an instant re-nudge when the level
+// band changes). Both lines are config-tunable via trimAdvisoryPercent /
+// trimAdvisoryCriticalPercent.
+export const ADVISORY_NUDGE_PERCENT = 65;
+export const ADVISORY_NUDGE_CRITICAL_PERCENT = 95;
+export const ADVISORY_NUDGE_REPEAT_MS = 600_000;
+
+/** Effective advisory lines for one dispatch: config-tunable, falling back to
+ * the configured defaults (65/95) when absent, inverted, or out of range —
+ * a broken pair never silences the nudge. */
+function advisoryNudgeLines(config) {
+	const line = readNumber(config, "trimAdvisoryPercent", ADVISORY_NUDGE_PERCENT);
+	const critical = readNumber(config, "trimAdvisoryCriticalPercent", ADVISORY_NUDGE_CRITICAL_PERCENT);
+	const sane = (v) => Number.isFinite(v) && v > 0 && v <= 100;
+	if (!sane(line) || !sane(critical) || line >= critical) return { line: ADVISORY_NUDGE_PERCENT, critical: ADVISORY_NUDGE_CRITICAL_PERCENT };
+	return { line, critical };
+}
+
+/** Advisory-mode nudge text. Deliberate, bounded exception to the
+ * digit-free disclosure policy of TRIM_PROTOCOL_TEXT above: advisory mode has
+ * NO engine-initiated folds (the modeNow gate), so the model's own fold is
+ * the only relief channel. At threshold, the live-number instruction is
+ * appended to the session surface tail, not injected into the registered
+ * system section. */
+export function advisoryNudgeText(pressurePercent, critical, foldLine = ADVISORY_NUDGE_PERCENT, criticalLine = ADVISORY_NUDGE_CRITICAL_PERCENT) {
+	const action = critical
+		? `Pressure is CRITICAL (${pressurePercent}% ≥ ${criticalLine}%): fold down to under ~50% of the context IN THIS TURN.`
+		: `At ${pressurePercent}% (fold line ${foldLine}%): ${foldLine}–${foldLine + 9}% → fold roughly half of the older history now; ≥${foldLine + 10}% → fold down to under ~50%.`;
+	return [
+		'[SWITCHMAN:TRIM] Advisory nudge — pinned to the session tail until pressure falls below the fold line.',
+		`Live context pressure on this session has reached the fold line. ${action}`,
+		"Act now: call ctx_trim_status to list compressible ranges, pick one contiguous range, and fold it with ctx_trim_fold (tool-call pairs fold together or not at all; existing summaries stay). Do not wait for a routine moment.",
+	].join("\n");
+}
+
 /** Effective window for the pressure/emergency tier math:
  * min(model-resolved window, configured cap). Null only when BOTH inputs
  * are unusable — the trigger then skips those tiers (fail-open). */
@@ -359,8 +398,158 @@ export function applyContextTrim(ctx, config) {
 			return null;
 		}
 	};
+
+	// Advisory nudge state: sessionId -> { at, critical, seq }. Bounded like the
+	// other per-session registries (200 entries).
+	const advisoryNudgeBySession = new Map();
+
+	// Single-flight for nudge warm-ups: during resolveRawWindow's <=10s window
+	// every main dispatch would otherwise re-fire the same resolve. Entries
+	// self-delete on settle; the expiry is only a belt-and-suspenders bound.
+	const windowWarmupInFlight = new Map(); // "provider/model" -> expiresAt
+	function warmWindowOnce(model, now) {
+		const key = `${model.provider}/${model.model}`;
+		const until = windowWarmupInFlight.get(key);
+		if (until !== undefined && now < until) return;
+		windowWarmupInFlight.set(key, now + 15_000); // > resolveRawWindow's 10s ceiling
+		void windowTokensFor(model).catch(() => {}).finally(() => {
+			if (windowWarmupInFlight.get(key) === until) windowWarmupInFlight.delete(key);
+		});
+	}
+
+	/** Advisory-mode pressure nudge (text: advisoryNudgeText). Appends the live
+	 * instruction to the session surface tail once pressure crosses the fold
+	 * line. Pressure reuses the meter-duality bridge (wire preferred, view
+	 * estimate as floor) against the session model's window read from the SYNC
+	 * cache — a cache miss fires an async warm-up (windowTokensFor) and defers
+	 * the nudge to a later dispatch instead of blocking this one — and it only
+	 * reaches the wire on the NEXT dispatch (the current request is already
+	 * assembled). The speak is a pure suffix, so the prompt prefix stays
+	 * untouched; a later clear or upgrade prunes only the nudge nodes, so
+	 * cache reuse survives up to the nudge instead of invalidating the whole
+	 * prefix as the old system-head splice did. */
+	function deliverAdvisoryNudge(sessionId, viewTokens) {
+		if (modeNow() !== "advisory") return;
+		const model = capturedModelBySession.get(sessionId) ?? null;
+		if (model === null) {
+			decisionLog("advisory-nudge skip why=no-captured-model");
+			return;
+		}
+		if (typeof model.provider !== "string" || typeof model.model !== "string") {
+			decisionLog("advisory-nudge skip why=bad-model-shape");
+			return;
+		}
+		const cached = windowCache.get(model.provider + "/" + model.model);
+		let resolvedWindow; // model-resolved window, or the configured cap when unknown
+		if (cached === undefined) {
+			// Unknown: warm up single-flight but stay AUDIBLE — fall back to the
+			// configured cap (the same denominator the emergency tier uses), so a
+			// model whose metadata never resolves still gets nudged at the fold
+			// line instead of burning to force unseen (2026-11-14: window-unknown
+			// swallowed every nudge at 89% pressure).
+			warmWindowOnce(model, Date.now());
+			resolvedWindow = windowCapNow();
+		} else {
+			// Stale-but-known still gates correctly: effectiveWindowTokens binds to the
+			// configured cap for every model larger than it, so the pressure math is
+			// unchanged. Re-warm in the background instead of burning this boundary.
+			if (Date.now() - cached.at >= 600_000) warmWindowOnce(model, Date.now());
+			// Resolution failed inside the TTL: same cap fallback instead of going
+			// quiet (no retry hammering — the warm-up stays single-flight).
+			resolvedWindow = cached.windowTokens ?? windowCapNow();
+		}
+		// Bind the resolved window to the configured cap before computing pressure.
+		const windowTokens = effectiveWindowTokens(resolvedWindow, windowCapNow());
+		if (windowTokens === null) {
+			// Cap unavailable too (wmForceTokens=0 and no explicit cap): nothing to
+			// measure against — the one remaining legitimate silence.
+			decisionLog("advisory-nudge skip why=window-unknown");
+			return;
+		}
+		const wire = wireTokensOf(sessionId);
+		const mass = Math.max(Number.isFinite(wire) ? wire : 0, Number.isFinite(viewTokens) ? viewTokens : 0);
+		if (mass <= 0) return;
+		const pressurePercent = (mass / windowTokens) * 100;
+		const nudgeLines = advisoryNudgeLines(config);
+		const prior = advisoryNudgeBySession.get(sessionId);
+		if (pressurePercent < nudgeLines.line) {
+			// Below the line every live nudge must go. The sweep is NOT gated
+			// on `prior`: restarts and registry evictions lose the episode while
+			// the node stays visible. The recorded seq joins the union even when
+			// it fell out of the 50-node scan window; nudgePrune skips seqs a
+			// fold already consumed, so a vanished prior.seq cannot wedge this.
+			const seqs = new Set(surfacePass.nudgeScan(sessionId));
+			if (Number.isFinite(prior?.seq)) seqs.add(prior.seq);
+			if (seqs.size > 0) {
+				if (!surfacePass.nudgePrune(sessionId, [...seqs])) {
+					decisionLog("advisory-nudge skip why=prune-failed pressure=" + Math.round(pressurePercent) + "%");
+					return;
+				}
+				advisoryNudgeBySession.delete(sessionId);
+				decisionLog("advisory-nudge below-line pressure=" + Math.round(pressurePercent) + "% mass=" + Math.round(mass) + " resolved=" + cached.windowTokens + " cap=" + windowCapNow() + " pruned=" + seqs.size);
+			} else if (prior !== undefined) {
+				advisoryNudgeBySession.delete(sessionId); // nothing visible left; close the episode quietly
+			}
+			return; // fresh episode on the next crossing
+		}
+		const critical = pressurePercent >= nudgeLines.critical;
+		const now = Date.now();
+		// Any band CHANGE re-speaks immediately: escalation high->critical, and
+		// intentionally also a downgrade back into high after a partial fold.
+		if (prior !== undefined && prior.critical === critical && now - prior.at < ADVISORY_NUDGE_REPEAT_MS) return;
+		if (!surfacePass.nudgeSupported(sessionId)) {
+			decisionLog("advisory-nudge skip why=surface-unavailable pressure=" + Math.round(pressurePercent) + "%");
+			return;
+		}
+
+		// Replace the recorded prior nudge, or clear orphans a restart left
+		// behind, before speaking fresh. nudgePrune only touches seqs still
+		// live on the surface, so a prior a fold already consumed is a no-op.
+		const priorSeq = Number.isFinite(prior?.seq) ? prior.seq : null;
+		if (priorSeq !== null) {
+			if (!surfacePass.nudgePrune(sessionId, [priorSeq])) {
+				decisionLog("advisory-nudge skip why=prune-failed pressure=" + Math.round(pressurePercent) + "%");
+				return;
+			}
+		} else {
+			const orphans = surfacePass.nudgeScan(sessionId);
+			if (orphans.length > 0) {
+				if (!surfacePass.nudgePrune(sessionId, orphans)) {
+					decisionLog("advisory-nudge skip why=prune-failed pressure=" + Math.round(pressurePercent) + "%");
+					return;
+				}
+				decisionLog("advisory-nudge orphan-pruned seqs=" + orphans.length + " pressure=" + Math.round(pressurePercent) + "%");
+			}
+		}
+		const nudge = advisoryNudgeText(Math.round(pressurePercent), critical, nudgeLines.line, nudgeLines.critical);
+		const appended = surfacePass.nudgeAppend(sessionId, nudge);
+		if (appended.error !== null || !Number.isFinite(appended.seq)) {
+			advisoryNudgeBySession.delete(sessionId); // a pruned prior must not throttle the retry
+			decisionLog("advisory-nudge skip why=append-failed err=" + (appended.error ?? "unknown") + " pressure=" + Math.round(pressurePercent) + "%");
+			return;
+		}
+		const seq = appended.seq;
+		advisoryNudgeBySession.delete(sessionId); // re-insert: refresh recency so eviction drops the least recently nudged
+		advisoryNudgeBySession.set(sessionId, { at: now, critical, seq });
+		if (advisoryNudgeBySession.size > 200) advisoryNudgeBySession.delete(advisoryNudgeBySession.keys().next().value);
+		decisionLog("session=" + sessionId + " advisory-nudge pressure=" + Math.round(pressurePercent) + "% mass=" + Math.round(mass) + " window=" + windowTokens + " level=" + (critical ? "critical" : "high") + " seq=" + seq);
+	}
+
 	const captures = new Map(); // sessionId -> { messages, refs, viewTokens, model, at }
-	const inFlight = new Set(); // sessionIds with a fold running
+	// sessionId -> generation token of the running fold cycle. A plain Set
+	// pinned a session forever once a cycle's await never settled; the
+	// maybeFold watchdog swaps the token so wedged cycles release the lock.
+	const inFlight = new Map();
+	// Fold-cycle watchdog: a cycle still "in flight" after this long logs a
+	// cycle-stuck row, releases the lock, and lets the next trigger retry.
+	// The ceiling must exceed the worst LEGITIMATE cycle — a raw fold can
+	// summarize on side AND fallback routes (2 x SUMMARY_TIMEOUT_MS = 240s) —
+	// so a healthy slow cycle is never preempted.
+	const CYCLE_WATCHDOG_MS = 300_000;
+	// Hard ceiling for one host model-info lookup: some llm builds never
+	// settle resolveModelInfo for unresolvable routes, and that wedged
+	// await used to pin the whole fold cycle until restart.
+	const WINDOW_RESOLVE_TIMEOUT_MS = 10_000;
 	const windowCache = new Map(); // "provider/model" -> { windowTokens, at }
 	const lastEmergencyAtBySession = new Map(); // sessionId -> epoch ms of last emergency fold (per-session cooldown)
 	const lastStreamCheckAt = new Map(); // sessionId -> epoch ms of last stream-path fold check (throttle)
@@ -505,6 +694,7 @@ export function applyContextTrim(ctx, config) {
 		ladderT2MinBlocks: readNumber(config, "trimLadderT2MinBlocks", 3),
 		ladderT3Tokens: readNumber(config, "trimLadderT3Tokens", 6_000),
 		ladderT3MinBlocks: readNumber(config, "trimLadderT3MinBlocks", 2),
+		protectTaskIntent: readBool(config, "trimProtectTaskIntent", true),
 	});
 	const ladderEnabledNow = () => readBool(config, "trimLadderEnabled", true);
 	/** CJK-aware summary-mass estimator for the ladder census (same units
@@ -573,20 +763,41 @@ export function applyContextTrim(ctx, config) {
 		return effectiveWindowTokens(resolved, windowCapNow());
 	}
 
-	/** Async raw-window resolution (fills the cache; null when unknown). */
+	/** Async raw-window resolution (fills the cache; null when unknown).
+	 * Two fixes over the historical behavior: the host contract is
+	 * resolveModelInfo(provider, model) — two strings; passing the model
+	 * object threw NO_ADAPTER on every route, so every decision row ran on
+	 * the cap fallback. And the lookup is raced against a hard timeout:
+	 * a never-settling promise must not pin the fold cycle. */
 	async function resolveRawWindow(model, key, now) {
+		let timer = null;
 		try {
 			const llm = ctx.get("llm", false);
-			const info = await llm?.resolveModelInfo?.(model);
+			const lookup = Promise.resolve(llm?.resolveModelInfo?.(model.provider, model.model));
+			const info = await Promise.race([
+				lookup,
+				new Promise((_, reject) => {
+					timer = setTimeout(() => reject(new Error(`no settle within ${WINDOW_RESOLVE_TIMEOUT_MS}ms`)), WINDOW_RESOLVE_TIMEOUT_MS);
+					timer.unref?.();
+				}),
+			]);
 			const windowTokens = info?.context?.contextWindow;
 			const value = Number.isFinite(windowTokens) && windowTokens > 0 ? windowTokens : null;
+			if (value === null) decisionLog(`window-resolve-failed key=${key} why=no context metadata`);
 			windowCache.set(key, { windowTokens: value, at: now });
 			if (windowCache.size > 200) windowCache.delete(windowCache.keys().next().value);
+			if (value !== null) decisionLog(`window-resolved key=${key} window=${value}`);
 			return value;
-		} catch {
+		} catch (error) {
 			windowCache.set(key, { windowTokens: null, at: now });
 			if (windowCache.size > 200) windowCache.delete(windowCache.keys().next().value);
+			// One row per model per 10-min cache window (plus rare concurrent
+			// misses inside the 10s race window): a silently failing resolution
+			// is what hid the wrong-arity call for months.
+			decisionLog(`window-resolve-failed key=${key} why=${error?.message ?? error}`);
 			return null;
+		} finally {
+			if (timer !== null) clearTimeout(timer);
 		}
 	}
 
@@ -595,7 +806,8 @@ export function applyContextTrim(ctx, config) {
 	function captureOf(sessionId, messages, model, viewTokens) {
 		captures.set(sessionId, { messages: messages.slice(), model, viewTokens, at: Date.now() });
 		if (model !== null && typeof model === "object" && typeof model.provider === "string" && typeof model.model === "string") {
-			capturedModelBySession.set(sessionId, { provider: model.provider, model: model.model, at: Date.now() });
+		capturedModelBySession.set(sessionId, { provider: model.provider, model: model.model, at: Date.now() });
+		if (!windowCache.has(model.provider + "/" + model.model)) warmWindowOnce(model, Date.now());
 			if (capturedModelBySession.size > 200) capturedModelBySession.delete(capturedModelBySession.keys().next().value);
 		}
 		// keep the capture map bounded (200 sessions)
@@ -744,7 +956,7 @@ export function applyContextTrim(ctx, config) {
 
 	/** Run one fold cycle for a session (called at the idle boundary ONLY).
 	 * Returns a short outcome string for logging. */
-	async function runFoldCycle(sessionId, decision, cycleStartedAt) {
+	async function runFoldCycle(sessionId, decision, cycleStartedAt, cycleToken) {
 		const capture = captures.get(sessionId);
 		if (capture === undefined) return "no-capture";
 		const { protectedTail } = thresholdsNow();
@@ -770,6 +982,7 @@ export function applyContextTrim(ctx, config) {
 			// Ladder folds never degrade to mechanical (docs/ladder-fold.md):
 			// after both routes fail the cycle stays fail-open with backoff.
 			if (summary === null) return disposedSince(cycleStartedAt) ? "reload-aborted" : "summary-unavailable"; // skip cycle, fail-open; a dispose cut is not a model failure
+			if (inFlight.get(sessionId) !== cycleToken) return "superseded"; // watchdog released us; a retry owns the session
 			const result = store.commitFold(
 				sessionId,
 				{ consumes: decision.consumes.slice(), summary, kind: "summary", tier: decision.tier === "ladder-3" ? 3 : 2, approxTokens },
@@ -828,6 +1041,7 @@ export function applyContextTrim(ctx, config) {
 			if (summary === null) return disposedSince(cycleStartedAt) ? "reload-aborted" : "summary-unavailable"; // skip cycle, fail-open; a dispose cut is not a model failure
 		}
 		const positions = refPositions(capture.messages);
+		if (inFlight.get(sessionId) !== cycleToken) return "superseded"; // watchdog released us; a retry owns the session
 		const result = store.commitFold(
 			sessionId,
 			{ refRange: { firstId: refs[0], lastId: refs[refs.length - 1] }, count, approxTokens, summary, kind, tier: decision.tier },
@@ -874,15 +1088,28 @@ export function applyContextTrim(ctx, config) {
 			decisionLog(`session=${sessionId} via=${via} action=none reason=injection-unavailable view=${Math.round(capture.viewTokens)}`);
 			return;
 		}
-		inFlight.add(sessionId);
 		const cycleStartedAt = Date.now();
+		// Generation token lock (was a plain Set): a cycle wedged on an await
+		// that never settles used to pin this session's fold path until
+		// restart. The watchdog logs the wedge and releases the lock; an
+		// abandoned cycle returns "superseded" at its commit guard, and its
+		// finally can no longer delete a retry's entry.
+		const cycleToken = {};
+		inFlight.set(sessionId, cycleToken);
+		const cycleWatchdog = setTimeout(() => {
+			if (inFlight.get(sessionId) !== cycleToken) return;
+			inFlight.delete(sessionId);
+			decisionLog(`session=${sessionId} via=${via} outcome=cycle-stuck elapsedMs=${Date.now() - cycleStartedAt}`);
+			warn(`[context-trim] ${sessionId}: fold cycle stuck >${CYCLE_WATCHDOG_MS}ms — lock released for the next trigger`);
+		}, CYCLE_WATCHDOG_MS);
+		cycleWatchdog.unref?.();
 		// Hoisted for the catch below: a dispose-cut throw may land before the
 		// trigger ever ran, and the catch must not touch a dead binding.
 		let decision = null;
 		try {
-			const { protectedTail, ...thresholds } = thresholdsNow();
+			const { protectedTail, protectTaskIntent, ...thresholds } = thresholdsNow();
 			const ledger = store.ledgerOf(sessionId);
-			const foldable = computeFoldableRange(capture.messages, ledger, protectedTail);
+			const foldable = computeFoldableRange(capture.messages, ledger, protectedTail, { protectTaskIntent });
 			const windowTokens = await windowTokensFor(capture.model);
 			// Pressure tiers run on the REAL prompt size when the tally is known:
 			// max(view, wire). The view estimate misses the system/context
@@ -905,12 +1132,15 @@ export function applyContextTrim(ctx, config) {
 			});
 			decisionLog(`session=${sessionId} via=${via} action=${decision.action} tier=${decision.tier ?? "-"} reason=${decision.reason || "-"} view=${Math.round(capture.viewTokens)}${wireTokens === null ? "" : ` wire=${wireTokens}`} window=${windowTokens ?? "null"}`);
 			if (decision.action === "none") return;
-			const outcome = await runFoldCycle(sessionId, decision, cycleStartedAt);
+			const outcome = await runFoldCycle(sessionId, decision, cycleStartedAt, cycleToken);
 			// Failure ladder: commit resets it; a summarize/commit failure
 			// climbs it (the no-backoff loop this closes — those outcomes
 			// advance no cadence gate on their own). A ladder run whose
 			// consumed blocks vanished between trigger and commit is the same
 			// family: without backoff it would re-fire at every boundary.
+			// "superseded" (watchdog released the lock mid-cycle) and neutral
+			// skips advance no ladder either — the retry that owns the session
+			// is judged alone.
 			if (outcome.startsWith("folded:")) clearFoldFailure(sessionId);
 			else if (outcome === "summary-unavailable" || outcome.startsWith("commit-rejected:") || outcome === "ladder-consumed-missing") recordFoldFailure(sessionId);
 			// Outcome lands in the decision log too: warn() has no reachable
@@ -927,7 +1157,10 @@ export function applyContextTrim(ctx, config) {
 				warn(`[context-trim] fold cycle failed: ${error?.message ?? error}`);
 			}
 		} finally {
-			inFlight.delete(sessionId);
+			clearTimeout(cycleWatchdog);
+			// Only the cycle owning the CURRENT token may release the lock —
+			// a watchdog-superseded wedged cycle must not delete a retry's entry.
+			if (inFlight.get(sessionId) === cycleToken) inFlight.delete(sessionId);
 		}
 	}
 
@@ -1037,19 +1270,27 @@ export function applyContextTrim(ctx, config) {
 			name: "ctx_trim_status",
 			description: "List this session's compressible context ranges with their true sizes: the fold ledger, the raw range a fold would cover, and distillation targets. Read-only. Contains sizes only — never progress percentages.",
 			parameters: { type: "object", properties: {}, additionalProperties: false },
-			required: [],
+			// Register-level shape: bare ctx.tools.register runs no defineTool DSL
+			// compilation and REJECTS a definition without an output block — the
+			// missing block silently killed both tools in every session (native
+			// and PTC). The execute bodies return plain strings, rendered as one
+			// text block.
+			output: {
+				schema: { type: "string" },
+				render: (_args, value) => [{ type: "text", text: value }],
+			},
 			async execute() {
 				const sessionId = sessionIdOf({});
 				if (sessionId === null) return "No session context available.";
 				if (!enabledNow()) return "Context trimming is disabled for this deployment.";
 				const ledger = store.ledgerOf(sessionId);
 				const capture = captures.get(sessionId);
-				const { protectedTail } = thresholdsNow();
+				const { protectedTail, protectTaskIntent } = thresholdsNow();
 				const lines = [`ctx_trim_status — mode: ${modeNow()} (enabled: ${enabledNow()})`];
 				lines.push(...renderStatusLedger(ledger));
 				// The raw range a fold would cover next, with its true size.
 				if (capture !== undefined) {
-					const foldable = computeFoldableRange(capture.messages, ledger, protectedTail);
+					const foldable = computeFoldableRange(capture.messages, ledger, protectedTail, { protectTaskIntent });
 					if (foldable !== null) {
 						const firstRef = refOf(capture.messages[foldable.startIdx], foldable.startIdx);
 						const lastRef = refOf(capture.messages[foldable.endIdx], foldable.endIdx);
@@ -1087,6 +1328,11 @@ export function applyContextTrim(ctx, config) {
 				required: ["firstId", "lastId", "count", "summary"],
 				additionalProperties: false,
 			},
+			// Register-level output block — see ctx_trim_status above.
+			output: {
+				schema: { type: "string" },
+				render: (_args, value) => [{ type: "text", text: value }],
+			},
 			async execute(args) {
 				const sessionId = sessionIdOf({});
 				if (sessionId === null) return "No session context available.";
@@ -1110,6 +1356,15 @@ export function applyContextTrim(ctx, config) {
 				}
 				if (firstIdx < 0) { firstIdx = firstList[0]; lastIdx = lastList[lastList.length - 1]; }
 				if (lastIdx < firstIdx) return "lastId sorts before firstId in the current history.";
+				// Prior fold summaries are never raw-fold material: a T1 fold
+				// covering an acp_summary_* node would shadow the replacement
+				// node and break the ladder's consumed-run bookkeeping.
+				// Summaries consolidate only through ladder T2/T3 distillation.
+				for (let i = firstIdx; i <= lastIdx; i++) {
+					if (isFoldSummaryMessage(capture.messages[i])) {
+						return "Range covers a previous fold's summary (acp_summary_*) — summaries are preserved and consolidate via T2/T3 ladder; pick a range that excludes them.";
+					}
+				}
 				const { protectedTail } = thresholdsNow();
 				if (lastIdx >= capture.messages.length - Math.max(0, protectedTail)) return `Range reaches into the protected tail (last ${protectedTail} messages are never folded).`;
 				if (!rangeIsSegmentAligned(capture.messages, firstIdx, lastIdx)) return "Range splits a tool-call pair — fold whole assistant/tool segments (extend firstId/lastId to the segment boundaries).";
@@ -1134,7 +1389,18 @@ export function applyContextTrim(ctx, config) {
 				const lowLedger = store.ledgerOf(sessionId);
 				const lowView = estimateTokensOf(buildView(capture.messages, lowLedger, { protectedTail: thresholdsNow().protectedTail }).messages);
 				store.recordFoldBaseline(sessionId, capture.viewTokens, lowView);
-				return `Folded ${count} messages into block ${result.block.id}. The view applies on the next model call.`;
+				// Ship the fresh block onto the session surface NOW instead of waiting for
+				// the next idle/turn-stopping boundary: a fold committed mid-turn used to
+				// stay meter-only for the rest of the turn (2026-11-14 live test: two
+				// tool-path folds left the wire carrying raw history for ~11 min at 97%
+				// pressure — injected=none on frozen dispatches, both blocks pending).
+				// The sweep's own guards (enabled flag, capable session, compaction lock,
+				// per-block validation) fail closed to pending; the boundary sweeps
+				// remain the closure pass.
+				void surfacePass.sweep(sessionId, "fold-commit").catch((error) => {
+					decisionLog(`session=${sessionId} surface-replace failed via=fold-commit why=${error?.message ?? error}`);
+				});
+				return `Folded ${count} messages into block ${result.block.id}. An immediate surface ship was queued (via=fold-commit): when it lands, even frozen dispatches carry the reduced history; if the surface cannot accept it right now the block stays pending and the boundary sweeps retry.`;
 			},
 		});
 	} catch (error) {
@@ -1152,6 +1418,16 @@ export function applyContextTrim(ctx, config) {
 				if (applied !== null) {
 					viewTokens = applied.viewTokens;
 					mainDispatch = applied.sideDispatch !== true;
+					if (mainDispatch) {
+						// Advisory pressure nudge (modeNow gates inside): the model's
+						// own fold is advisory mode's ONLY relief channel — speak at
+						// the fold line. Fail-open, never breaks the dispatch.
+						try {
+							deliverAdvisoryNudge(applied.sessionId, applied.viewTokens);
+						} catch (error) {
+							decisionLog(`advisory-nudge-failed why=${error?.message ?? error}`);
+						}
+					}
 				}
 			}
 		} catch (error) {
@@ -1239,5 +1515,5 @@ export function applyContextTrim(ctx, config) {
 		warn(`[context-trim] ctx.inject(llm) failed: ${error?.message ?? error}`);
 	}
 
-	return { store, metrics, captures, inFlight, maybeFold, maybeInherit, applyViewToOptions, surfacePass };
+	return { store, metrics, captures, inFlight, windowCache, advisoryNudgeBySession, maybeFold, maybeInherit, applyViewToOptions, surfacePass };
 }