pi-ui-extend 1.0.41 → 1.0.45

package/external/pi-tools-suite/src/dcp/index.ts

@@ -31,6 +31,7 @@ import {
 import {
 	applyPruning,
 	getNudgeType,
+	detectCompressionBlockConsolidationCandidate,
 	detectCompressionCandidate,
 	detectEmergencyCompressionCandidate,
 	detectMessageCompressionCandidates,
@@ -60,6 +61,11 @@ import {
 import { DCP_STATS_MESSAGE_TYPE, registerCommands } from "./commands.js"
 import { normalizeDcpContextUsage } from "./ui.js"
 import { safeGetContextUsage } from "../context-usage.js"
+import { FreshToolResultTracker } from "./fresh-tool-results.js"
+import { RoutinePressureTracker } from "./routine-pressure.js"
+import { canonicalMessageHash } from "./conversation-index.js"
+import { randomUUID } from "node:crypto"
+import { dcpRequestSnapshot } from "./diagnostics.js"
 import {
 	collectProviderToolResultEvidence,
 	providerPayloadIncludesToolResult,
@@ -68,23 +74,18 @@ import {
 	ProviderEvidenceTracker,
 } from "./provider-tool-results.js"
 import { rehydrateToolRecordsFromMessages } from "./recovery.js"
-import { inferDcpBlockedReason, planDcpBudget } from "./progress-controller.js"
+import { inferDcpBlockedReason, planDcpBudget, type DcpBlockedReason } from "./progress-controller.js"
 import { createBudgetedAutoCompressionBlock } from "./auto-compress-budget.js"
-import { outstandingCompressionTokens, resetCompressionProgress, routineRecoveryTokens, trackCompressionProgress } from "./compression-progress.js"
+import { compressionPlanningTokens, outstandingCompressionTokens, resetCompressionProgress, routineRecoveryTokens, trackCompressionProgress } from "./compression-progress.js"
 import { captureDcpTransactionGuard, cloneDcpTransactionState, runDcpStateTransaction, invalidateDcpStateOwner } from "./state-transaction.js"
 
+const PIX_DCP_RUNTIME_STATS_SYMBOL = Symbol.for("pix.dcp.runtime-stats")
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function annotateMessagesWithBranchEntryIds(messages: any[], ctx: ExtensionContext): void {
-	let branch: any[] = []
-	try {
-		branch = ctx.sessionManager.getBranch()
-	} catch {
-		return
-	}
-
+function annotateMessagesWithBranchEntryIds(messages: any[], branch: any[]): void {
 	const entries = branch.filter((entry) => entry?.type === "message" && entry.message)
 	let searchFrom = 0
 	for (const msg of messages) {
@@ -97,6 +98,7 @@ function annotateMessagesWithBranchEntryIds(messages: any[], ctx: ExtensionConte
 				Number.isFinite(msg?.timestamp) &&
 				entryMsg.timestamp !== msg.timestamp
 			) continue
+			if (canonicalMessageHash(stripStaleDcpMetadataFromMessage(entryMsg)) !== canonicalMessageHash(msg)) continue
 			msg._dcpEntryId = entry.id
 			searchFrom = i + 1
 			break
@@ -125,6 +127,20 @@ function isDcpControlPlaneMessage(message: any): boolean {
 	return message?.role === "custom" && DCP_CONTROL_PLANE_CUSTOM_TYPES.has(message.customType)
 }
 
+function withoutAutoSummaryModels(config: ReturnType<typeof loadConfig>): ReturnType<typeof loadConfig> {
+	return {
+		...config,
+		compress: {
+			...config.compress,
+			autoCompress: {
+				...config.compress.autoCompress,
+				summarizerModel: [],
+				summarizerFallbackModels: [],
+			},
+		},
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Module export
 // ---------------------------------------------------------------------------
@@ -132,6 +148,10 @@ function isDcpControlPlaneMessage(message: any): boolean {
 export default async function dcpModule(pi: ExtensionAPI, dependencies: { config?: ReturnType<typeof loadConfig>; state?: ReturnType<typeof createState> } = {}): Promise<void> {
 	// ── 1. Load config ────────────────────────────────────────────────────────
 	const config = dependencies.config ?? loadConfig()
+	const runtimeGlobals = globalThis as typeof globalThis & Record<symbol, unknown>
+	// Extension reloads may disable DCP. Clear any getter left by the previous
+	// module instance before deciding whether this instance is active.
+	runtimeGlobals[PIX_DCP_RUNTIME_STATS_SYMBOL] = undefined
 	const configForContext = (ctx: unknown) => resolveModelConfig(config, modelKeysFromContext(ctx))
 	const hasEnabledModelOverride = Object.values(config.modelOverrides).some(
 		(override) => override.enabled === true,
@@ -141,15 +161,33 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 	// ── 2. Create state ───────────────────────────────────────────────────────
 	const state = dependencies.state ?? createState()
+	// Pix ACP runs one pi process per session. Expose only this tiny live metric
+	// to the patched RPC session-stats surface; DCP state remains extension-owned.
+	runtimeGlobals[PIX_DCP_RUNTIME_STATS_SYMBOL] = () => ({ tokensSaved: state.tokensSaved })
 	let journalMirror: DcpJournalMirror | undefined
 	let journalSupported = false
 	let journalBlockedReason: string | undefined
 	let journalPersistent = false
 	const providerEvidenceTracker = new ProviderEvidenceTracker()
+	const freshToolResults = new FreshToolResultTracker()
+	const routinePressureTracker = new RoutinePressureTracker()
 	let providerEvidenceCommitQueue = Promise.resolve()
 	let latestProviderOpportunityAvailable = false
 	let latestProviderOpportunityKind: "routine" | "emergency" | undefined
 	let latestProviderReminder: string | undefined
+	let autoSummarizerDegraded = false
+	let lastProviderReadyProjectionEpoch: number | undefined
+	let diagnosticEpoch = randomUUID()
+	let diagnosticSnapshot: ReturnType<typeof dcpRequestSnapshot> | undefined
+	const diagnostic = (event: string, data: Record<string, unknown> = {}) => {
+		try { pi.appendEntry("dcp-diagnostic", { version: 1, event, epoch: diagnosticEpoch, ...data }) }
+		catch { /* Diagnostics must never affect a transaction or provider send. */ }
+	}
+	const resetDiagnostics = (reason: string) => {
+		diagnosticEpoch = randomUUID()
+		diagnosticSnapshot = undefined
+		diagnostic("epoch", { reason })
+	}
 	const warnedProgress = new Set<string>()
 	const isJournalSessionSupported = () => journalSupported && journalBlockedReason === undefined
 	const persistJournalState = async (
@@ -174,15 +212,18 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		entry?.type === "message" || entry?.type === "custom_message" || entry?.type === "compaction" || entry?.type === "branch_summary",
 	)
 	const loadJournalState = async (ctx: ExtensionContext, allowInitialize: boolean): Promise<void> => {
+		const epoch = state.sessionEpoch
 		journalMirror = undefined
 		journalSupported = false
-		journalBlockedReason = undefined
+		journalBlockedReason = "DCP journal load in progress"
 		journalPersistent = false
-		const branch = await readDcpJournalBranch(ctx)
 		const manager = ctx.sessionManager as any
 		const persistentSession = (typeof manager.isPersisted === "function" && manager.isPersisted())
 			|| (typeof manager.getSessionFile === "function" && Boolean(manager.getSessionFile()))
 		try {
+			const branch = await readDcpJournalBranch(ctx)
+			if (state.sessionEpoch !== epoch) return
+			journalBlockedReason = undefined
 			const replay = replayDcpJournal(branch, state)
 			if (replay.initialized && replay.lastOperationId) {
 				journalSupported = true
@@ -203,6 +244,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			// compatibility checkpoint from existing history.
 			journalSupported = false
 		} catch (error) {
+			if (state.sessionEpoch !== epoch) return
 			journalBlockedReason = error instanceof Error ? error.message : String(error)
 			journalSupported = false
 			journalMirror = undefined
@@ -242,12 +284,20 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	}
 	const invalidateOwner = () => {
 			invalidateDcpStateOwner(state)
+			routinePressureTracker.reset()
+			// Successful exposure belongs to the old provider/branch too, not only
+			// the pending attempt. The new owner must establish its own evidence.
+			state.providerSeenToolIds.clear()
+			freshToolResults.reset()
 			providerEvidenceTracker.reset()
 			latestProviderOpportunityAvailable = false
 			latestProviderOpportunityKind = undefined
 			latestProviderReminder = undefined
+			autoSummarizerDegraded = false
+			lastProviderReadyProjectionEpoch = undefined
 			resetCompressionProgress(state)
 			warnedProgress.clear()
+			resetDiagnostics("owner-changed")
 	}
 	pi.on("model_select", invalidateOwner)
 	pi.on("session_tree", async (_event, ctx) => {
@@ -304,13 +354,20 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	// ── 5. session_start: restore state from session entries ──────────────────
 	pi.on("session_start", async (event, ctx) => {
 		resetState(state)
+		routinePressureTracker.reset()
+		freshToolResults.reset()
+		lastProviderReadyProjectionEpoch = undefined
 		providerEvidenceTracker.reset()
 		latestProviderOpportunityAvailable = false
 		latestProviderOpportunityKind = undefined
 		latestProviderReminder = undefined
+		autoSummarizerDegraded = false
 		warnedProgress.clear()
 		if (config.manualMode.enabled) state.manualMode = true
+		const startingEpoch = state.sessionEpoch
 		await loadJournalState(ctx, event.reason === "new" || event.reason === "startup")
+		if (state.sessionEpoch !== startingEpoch) return
+		resetDiagnostics(event.reason)
 		writeDcpDebugLog(configForContext(ctx), "session_start.journal", {
 			reason: event.reason,
 			supported: journalSupported,
@@ -330,6 +387,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	// Journal operations are committed at the mutation boundary; shutdown does
 	// not write a full runtime snapshot.
 	pi.on("session_shutdown", async () => {
+		routinePressureTracker.reset()
+		freshToolResults.reset()
 		journalMirror = undefined
 		journalSupported = false
 		journalBlockedReason = undefined
@@ -355,6 +414,9 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 	// ── 8. tool_call: record input args for dedup / purge fingerprinting ───────
 	pi.on("tool_call", async (event, _ctx) => {
+		if (configForContext(_ctx).enabled && isJournalSessionSupported()) {
+			freshToolResults.toolCall(event.toolCallId, event.toolName, state.toolCalls.has(event.toolCallId))
+		}
 		if (!state.toolCalls.has(event.toolCallId)) {
 			state.toolCalls.set(event.toolCallId, {
 				toolCallId: event.toolCallId,
@@ -375,6 +437,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 	// ── 9. tool_result: finalise tool record with result info ─────────────────
 	pi.on("tool_result", async (event, _ctx) => {
+		freshToolResults.toolResult(event.toolCallId, event.toolName)
 		const record = state.toolCalls.get(event.toolCallId)
 
 		const outputText = event.content
@@ -414,7 +477,29 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		const contextMessages = event.messages
 			.filter((message: any) => !isUserVisibleOnlyMessage(message) && !isDcpControlPlaneMessage(message))
 			.map((message: any) => stripStaleDcpMetadataFromMessage(message))
-		const finishContext = (reason: string, messages: any[], details: Record<string, unknown> = {}) => {
+		const rawContextTokens = contextMessages.reduce((sum, message) => sum + estimateMessageTokens(message), 0)
+		const pressureOwner = JSON.stringify([contextEpoch, ...modelKeysFromContext(ctx), ctx.model?.contextWindow, ctx.model?.maxTokens])
+		const finishContext = (
+			reason: string,
+			messages: any[],
+			details: Record<string, unknown> = {},
+			providerReady = true,
+		) => {
+			if (state.sessionEpoch !== contextEpoch) throw new DcpJournalError("DCP projection belongs to a stale owner")
+			lastProviderReadyProjectionEpoch = providerReady ? state.sessionEpoch : undefined
+			const observedUsage = safeGetContextUsage(ctx)
+			diagnosticSnapshot = dcpRequestSnapshot(effectiveConfig, state, ctx.model,
+				observedUsage, contextMessages, messages, reason)
+			const routine = routinePressureTracker.estimate(pressureOwner,
+				normalizeDcpContextUsage(observedUsage)?.tokens,
+				contextMessages, rawContextTokens, diagnosticSnapshot.projectedTokens, state.compressionBlocks)
+			diagnosticSnapshot.routineProjectedTokens = routine.projectedTokens
+			diagnosticSnapshot.routineUsageAdjustmentTokens = routine.adjustmentTokens
+			if (diagnosticSnapshot.pressure === "routine" && routine.projectedTokens <= (diagnosticSnapshot.routineTokens ?? 0)) {
+				diagnosticSnapshot.pressure = "below routine threshold"
+			}
+			if (providerReady) routinePressureTracker.prepare(pressureOwner, rawContextTokens,
+				diagnosticSnapshot.projectedTokens, state.compressionBlocks)
 			writeDcpDebugLog(effectiveConfig, "context.result", {
 				reason,
 				inputMessages: event.messages.length,
@@ -434,6 +519,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		}, ctx)
 		latestProviderOpportunityAvailable = false
 		if (!effectiveConfig.enabled) {
+			routinePressureTracker.reset()
 			writeDcpDebugLog(effectiveConfig, "context.disabled", {
 				inputMessages: event.messages.length,
 				filteredMessages: contextMessages.length,
@@ -448,7 +534,12 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		}
 		latestProviderOpportunityKind = undefined
 		latestProviderReminder = undefined
-		annotateMessagesWithBranchEntryIds(contextMessages, ctx)
+		// Failed full-history reads must not reassign IDs or expose uncompressed
+		// source. Async work from an old session/model cannot publish a projection.
+		lastProviderReadyProjectionEpoch = undefined
+		const fullBranch = await readDcpJournalBranch(ctx)
+		if (state.sessionEpoch !== contextEpoch) throw new DcpJournalError("DCP context owner changed during history read")
+		annotateMessagesWithBranchEntryIds(contextMessages, fullBranch)
 		const rehydration = rehydrateToolRecordsFromMessages(contextMessages, state)
 		if (rehydration.recordsUpdated > 0) {
 			writeDcpDebugLog(effectiveConfig, "context.rehydrated_tool_records", { ...rehydration }, ctx)
@@ -458,6 +549,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		// projection must be committed before the request can use them.
 		await persistJournalState(ctx, state)
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
+		let blockConsolidationCandidate = null as ReturnType<typeof detectCompressionBlockConsolidationCandidate>
 		let emergencyCompressionCandidate = null as ReturnType<typeof detectEmergencyCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>
 		let emergencySelection = null as ReturnType<typeof analyzeEmergencyCurrentTurn> | null
@@ -466,8 +558,14 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		// Manual mode skips routine autonomous nudges and automatic summary
 		// creation. The bounded emergency safety path remains separate, matching
 		// the manual-mode prompt.
-		const nativeUsage = normalizeDcpContextUsage(safeGetContextUsage(ctx))
 		const ctxModel = (ctx as any).model
+		const observedUsage = normalizeDcpContextUsage(safeGetContextUsage(ctx))
+		// Model capacity is authoritative even while SDK usage still describes
+		// the preceding model. Keep its token count only as a conservative floor.
+		const modelWindow = Number.isFinite(ctxModel?.contextWindow) && ctxModel.contextWindow > 0 ? ctxModel.contextWindow : undefined
+		const nativeUsage = observedUsage && modelWindow
+			? { ...observedUsage, contextWindow: modelWindow, percent: observedUsage.tokens === null ? null : observedUsage.tokens / modelWindow * 100 }
+			: observedUsage
 		const fallbackContextWindow = nativeUsage?.contextWindow ?? (
 			typeof ctxModel?.contextWindow === "number" && Number.isFinite(ctxModel.contextWindow) && ctxModel.contextWindow > 0
 				? ctxModel.contextWindow
@@ -522,23 +620,34 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				estimatorMarginTokens,
 			})
 			thresholds.maxContextPercent = budget.softHeadroomTokens / usage.contextWindow
-			const contextPercent = budget.projectedBeforeTokens / usage.contextWindow
+			const budgetContextPercent = budget.projectedBeforeTokens / usage.contextWindow
 			const nativePressure = emergencyPressureState(
-				contextPercent,
+				budgetContextPercent,
 				thresholds.maxContextPercent,
 				emergencySettings.hardContextPercent,
 			)
 			const hardEmergencyReached = nativePressure.hardEmergencyReached || budget.hardPressure
 			const contextLimitReached = nativePressure.contextLimitReached || budget.pressured
 			const emergencyPressureReached = nativePressure.emergencyPressureReached || budget.pressured
+			const routinePressure = routinePressureTracker.estimate(pressureOwner, nativeUsage?.tokens,
+				contextMessages, rawContextTokens, repoProjectedTokens, state.compressionBlocks)
+			// Correct only routine policy. Capacity, strong pressure and emergency
+			// recovery retain the unadjusted conservative provider-native floor.
+			const policyTokens = emergencyPressureReached ? budget.projectedBeforeTokens : routinePressure.projectedTokens
+			const contextPercent = policyTokens / usage.contextWindow
 			const routineNudgesAllowed = contextPercent > thresholds.minContextPercent
 			if (!budget.capacityExceeded && state.progressRecovery) state.progressRecovery = undefined
 			if (!emergencyPressureReached && !routineNudgesAllowed) {
-				const clearedAnchors = clearDcpNudgeAnchors(state)
+				// Falling usage is not an intentional history rewrite. Replay a
+				// frozen reminder even after restart or a lower native sample; only
+				// discard anchors whose exact carrier is no longer present.
+				const anchorsBefore = state.nudgeAnchors.length
+				const replay = applyAnchoredNudges(prunedMessages, state, (anchor) => baseNudgeText(anchor.type))
+				const clearedAnchors = anchorsBefore - state.nudgeAnchors.length
 				const resetEmergencyPasses = state.consecutiveIgnoredStrongNudges > 0 || state.consecutiveIgnoredNudges > 0 || !!state.compressionProgress
 				resetCompressionProgress(state)
 				warnedProgress.clear()
-				if (clearedAnchors > 0) await persistJournalState(ctx, state)
+				if (replay.stateChanged) await persistJournalState(ctx, state)
 				return finishContext("below-threshold", prunedMessages, {
 					contextPercent,
 					thresholds,
@@ -578,10 +687,10 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 			const requestedRecoveryTokens = emergencyPressureReached
 				? budget.requiredSavingsTokens
-				: routineRecoveryTokens(budget.projectedBeforeTokens, usage.contextWindow, thresholds.minContextPercent)
+				: routineRecoveryTokens(policyTokens, usage.contextWindow, thresholds.minContextPercent)
 			const progressInput = {
 				projectedTokens: repoProjectedTokens,
-				observedTokens: budget.projectedBeforeTokens,
+				observedTokens: policyTokens,
 				contextWindow: usage.contextWindow,
 				requiredTokens: requestedRecoveryTokens,
 				kind: emergencyPressureReached ? "emergency" as const : "routine" as const,
@@ -592,9 +701,11 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				resetCompressionProgress(state)
 				warnedProgress.clear()
 			}
-			const planningRecoveryTokens = remainingRecoveryTokens !== undefined && remainingRecoveryTokens > 0
-				? state.compressionProgress?.kind === progressInput.kind ? remainingRecoveryTokens : Math.max(remainingRecoveryTokens, requestedRecoveryTokens)
-				: requestedRecoveryTokens
+			const planningRecoveryTokens = compressionPlanningTokens(
+				state,
+				progressInput,
+				remainingRecoveryTokens,
+			)
 			const routineEscalated = !state.manualMode && routineNudgesAllowed &&
 				state.consecutiveIgnoredNudges > Math.max(0, Math.floor(effectiveConfig.compress.autoCompress.patience))
 			const progressPressureReached = emergencyPressureReached || routineEscalated
@@ -630,7 +741,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					effectiveConfig,
 					contextPercent,
 					progressPressureReached
-						? { requiredSavingsTokens: planningRecoveryTokens }
+						? { requiredSavingsTokens: planningRecoveryTokens, allowCompressionBlocks: false }
 						: undefined,
 				)
 				messageCandidates = detectMessageCompressionCandidates(
@@ -639,12 +750,24 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					effectiveConfig,
 					contextPercent,
 				)
+				if (progressPressureReached) {
+					blockConsolidationCandidate = detectCompressionBlockConsolidationCandidate(
+						prunedMessages,
+						state,
+						effectiveConfig,
+						{
+							requiredSavingsTokens: planningRecoveryTokens,
+							estimatorMarginTokens,
+						},
+					)
+				}
 				writeDcpDebugLog(effectiveConfig, "context.candidates", {
 					contextPercent,
 					thresholds,
 					budget,
 					nudgeType,
 					candidate,
+					blockConsolidationCandidate,
 					messageCandidates,
 					state: summarizeDcpState(state, effectiveConfig),
 				}, ctx)
@@ -676,7 +799,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					effectiveConfig,
 					contextPercent,
 					planningThreshold,
-					{ requiredSavingsTokens: planningRecoveryTokens },
+					{ requiredSavingsTokens: planningRecoveryTokens, allowCompressionBlocks: false },
 				)
 				if (emergencyCompressionCandidate) {
 					writeDcpDebugLog(effectiveConfig, "context.emergency_compression_candidate", {
@@ -732,6 +855,11 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					`DCP cannot safely meet its compression goal: ${blockedReason}. Context has not been recovered.`)
 			}
 			if (blockedReason && budget.capacityExceeded) {
+				warnProgress(
+					ctx,
+					blockedReason,
+					`DCP cannot fit the next provider request safely (${budget.projectedBeforeTokens} projected input tokens > ${budget.inputCapacityTokens} input capacity): ${blockedReason}. The current agent operation is being stopped instead of sending an oversized request.`,
+				)
 				state.progressRecovery = {
 					blockedReason,
 					projectedBeforeTokens: budget.projectedBeforeTokens,
@@ -755,17 +883,17 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					blocked_reason: blockedReason,
 					handoff: abortSupported ? "abort-current-agent-operation" : "abort-unavailable",
 					budget,
-				})
+				}, false)
 			}
 			if (!manualEmergencyOnly && !emergencyPressureReached && !hasCompressionSuggestion) {
-				const clearedAnchors = clearDcpNudgeAnchors(state)
-				if (clearedAnchors > 0) await persistJournalState(ctx, state)
-				if (nudgeType || clearedAnchors > 0) {
+				// Candidate disappearance is not permission to erase a published
+				// reminder. Finalization replays it or drops an absent exact carrier.
+				if (nudgeType) {
 					writeDcpDebugLog(effectiveConfig, "context.no_compression_candidate", {
 						contextPercent,
 						thresholds,
 						nudgeType,
-						clearedAnchors,
+						clearedAnchors: 0,
 						state: summarizeDcpState(state, effectiveConfig),
 					}, ctx)
 				}
@@ -781,9 +909,13 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			if (routineEscalated && !effectiveConfig.compress.autoCompress.enabled) {
 				warnProgress(ctx, "auto-disabled", "DCP compression has not made enough progress. Automatic compression is disabled; use compress or enable compress.autoCompress explicitly.")
 			}
+			let autoCompressionFailure: { blockedReason?: DcpBlockedReason; error: string } | undefined
+			let partialAutoProjectionTokens: number | undefined
 			if (!manualEmergencyOnly) {
-				const autoCandidate = candidate ?? emergencyCompressionCandidate
-				const cacheSafeReminderAvailable = hasCacheSafeNudgeCarrier(prunedMessages)
+				const autoCandidate = blockConsolidationCandidate ?? candidate ?? emergencyCompressionCandidate
+				const cacheSafeReminderAvailable = hasCacheSafeNudgeCarrier(
+					prunedMessages, freshToolResults.eligibleIds, state.nudgeAnchors,
+				)
 				const autoDecision = decideAutoCompress(
 					state,
 					effectiveConfig,
@@ -809,22 +941,44 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					}, ctx)
 				}
 				if (autoDecision.shouldFire && autoCandidate) {
+					const modelSummaryConfigured =
+						effectiveConfig.compress.autoCompress.summarizerModel.length > 0 ||
+						effectiveConfig.compress.autoCompress.summarizerFallbackModels.length > 0
 					try {
 						const autoOperationEpoch = state.sessionEpoch
-						const largestSafeCandidate = candidate
-							? detectCompressionCandidate(prunedMessages, state, effectiveConfig, contextPercent)
-							: detectEmergencyCompressionCandidate(prunedMessages, state, effectiveConfig, contextPercent, planningThreshold)
+						const rawFallbackCandidate = candidate ?? emergencyCompressionCandidate
+						const largestSafeCandidate = blockConsolidationCandidate
+							? rawFallbackCandidate
+							: candidate
+							? detectCompressionCandidate(
+								prunedMessages,
+								state,
+								effectiveConfig,
+								contextPercent,
+								progressPressureReached ? { allowCompressionBlocks: false } : undefined,
+							)
+							: detectEmergencyCompressionCandidate(
+								prunedMessages,
+								state,
+								effectiveConfig,
+								contextPercent,
+								planningThreshold,
+								{ allowCompressionBlocks: false },
+							)
 						let preparedProjection: any[] | undefined
+						const autoConfig = autoSummarizerDegraded
+							? withoutAutoSummaryModels(effectiveConfig)
+							: effectiveConfig
 						const autoResult = await createBudgetedAutoCompressionBlock({
 							candidate: autoCandidate,
 							topic: "Auto-compressed slice",
 							state,
-							config: effectiveConfig,
+							config: autoConfig,
 							messages: prunedMessages,
 							modelRegistry: (ctx as any).modelRegistry,
 							signal: (ctx as any).signal,
 							cwd: (ctx as any).cwd,
-							requiredGainTokens: state.compressionProgress?.remainingTokens ?? planningRecoveryTokens,
+							requiredGainTokens: planningRecoveryTokens,
 							allowPartialGain: true,
 							persistState: (preparedState, publication) => persistJournalState(ctx, preparedState, publication),
 							prepareProjection: (preparedState) => {
@@ -839,6 +993,21 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 							// failed or mutate/nudge the replacement session.
 							return { messages: contextMessages }
 						}
+						if (
+							modelSummaryConfigured &&
+							!autoSummarizerDegraded &&
+							autoResult.summaryMode === "programmatic_fallback"
+						) {
+							// A successful deterministic commit can still prove that every
+							// configured summary model failed for this live session. Avoid paying
+							// the same model timeout on each subsequent autonomous attempt.
+							autoSummarizerDegraded = true
+							writeDcpDebugLog(effectiveConfig, "compress.auto_summarizer_degraded", {
+								reason: "model-summary-fallback",
+								summarizerAttempts: autoResult.summarizerAttempts,
+								nextMode: "deterministic-extractive",
+							}, ctx)
+						}
 						// Re-apply pruning so the new block takes effect on this
 						// same context pass instead of the next one.
 						prunedMessages = preparedProjection ?? applyPruning(contextMessages, state, effectiveConfig)
@@ -859,46 +1028,71 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 							clearedAnchors,
 							state: summarizeDcpState(state, effectiveConfig),
 						}, ctx)
-						return finishContext("compress.auto", prunedMessages, {
+						const projectedAfterAuto = prunedMessages.reduce(
+							(sum, message) => sum + estimateMessageTokens(message),
+							0,
+						)
+						const stillAboveInputCapacity =
+							budget.capacityExceeded && projectedAfterAuto > budget.inputCapacityTokens
+						if (!stillAboveInputCapacity) return finishContext("compress.auto", prunedMessages, {
 							candidate: autoResult.effectiveCandidate,
 							messageCandidates,
 							contextPercent,
 							thresholds,
 							clearedAnchors,
 						})
+
+						// A positive partial commit is useful progress, but it is not permission
+						// to send a request that still exceeds provider input capacity. Continue
+						// through the model-independent recovery floor in this same context pass;
+						// if that cannot make the request fit, the fail-closed handoff below wins.
+						partialAutoProjectionTokens = projectedAfterAuto
+						candidate = null
+						emergencyCompressionCandidate = null
+						if (emergencySettings.enabled) {
+							emergencySelection = analyzeEmergencyCurrentTurn(prunedMessages, state, effectiveConfig)
+							messageCandidates = emergencyCurrentTurnMessageCandidates(emergencySelection, effectiveConfig)
+						}
+						writeDcpDebugLog(effectiveConfig, "compress.auto_partial_capacity", {
+							projectedAfterAuto,
+							inputCapacityTokens: budget.inputCapacityTokens,
+							remainingCapacityGap: projectedAfterAuto - budget.inputCapacityTokens,
+							blockId: `b${autoResult.blockId}`,
+							state: summarizeDcpState(state, effectiveConfig),
+						}, ctx)
 					} catch (error) {
 						if (state.sessionEpoch !== contextEpoch || ctx.signal?.aborted) return { messages: contextMessages }
+						diagnostic("auto-rejected", { reason: error instanceof AutoCompressionBlockedError ? error.blockedReason : "preparation-failed" })
 						const autoBlockedReason = error instanceof AutoCompressionBlockedError
 							? error.blockedReason
 							: undefined
+						const autoError = error instanceof Error ? error.message : String(error)
+						autoCompressionFailure = { blockedReason: autoBlockedReason, error: autoError }
+						const summarizerFailure = error instanceof AutoCompressionBlockedError && (
+							error.blockedReason === "summarizer-unavailable" || error.summarizerFallbackUsed
+						)
+						if (modelSummaryConfigured && !autoSummarizerDegraded && summarizerFailure) {
+							autoSummarizerDegraded = true
+							writeDcpDebugLog(effectiveConfig, "compress.auto_summarizer_degraded", {
+								reason: error.summarizerFallbackUsed ? "model-summary-fallback" : autoBlockedReason ?? "auto-failed",
+								summarizerAttempts: error.summarizerAttempts,
+								nextMode: "deterministic-extractive",
+							}, ctx)
+						}
 						writeDcpDebugLog(effectiveConfig, "compress.auto_failed", {
 							trigger: autoDecision.reason,
 							phase: autoBlockedReason ? "blocked" : "degraded",
 							blocked_reason: autoBlockedReason,
-							error: error instanceof Error ? error.message : String(error),
+							error: autoError,
+							summarizerAttempts: error instanceof AutoCompressionBlockedError ? error.summarizerAttempts : undefined,
 							candidate: autoCandidate,
 							state: summarizeDcpState(state, effectiveConfig),
 						}, ctx)
-						if (routineEscalated) warnProgress(ctx, autoBlockedReason ?? "auto-failed",
-							`DCP automatic compression did not recover the context: ${autoBlockedReason ?? "preparation failed"}. The existing context was preserved.`)
-						if (autoBlockedReason && budget.capacityExceeded) {
-							state.progressRecovery = {
-								blockedReason: autoBlockedReason,
-								projectedBeforeTokens: budget.projectedBeforeTokens,
-								inputCapacityTokens: budget.inputCapacityTokens,
-								requiredSavingsTokens: budget.requiredSavingsTokens,
-								contextWindow: budget.contextWindow,
-								createdAt: Date.now(),
-							}
-							clearDcpNudgeAnchors(state)
-							await persistJournalState(ctx, state)
-							const abortSupported = typeof (ctx as any).abort === "function"
-							if (abortSupported) (ctx as any).abort()
-							return finishContext("progress.blocked_handoff", prunedMessages, {
-								blocked_reason: autoBlockedReason,
-								handoff: abortSupported ? "abort-current-agent-operation" : "abort-unavailable",
-								budget,
-							})
+						warnProgress(ctx, autoBlockedReason ?? "auto-failed",
+							`DCP automatic compression failed (${autoBlockedReason ?? "preparation failed"}). ${modelSummaryConfigured && autoSummarizerDegraded ? "Future attempts in this session will skip the summary model and use deterministic extraction. " : ""}The current context is preserved; emergency pruning will be attempted before any capacity abort.`)
+						if (budget.capacityExceeded && emergencySettings.enabled) {
+							emergencySelection = analyzeEmergencyCurrentTurn(prunedMessages, state, effectiveConfig)
+							messageCandidates = emergencyCurrentTurnMessageCandidates(emergencySelection, effectiveConfig)
 						}
 						// Recoverable failures fall through to normal nudge emission.
 					}
@@ -914,7 +1108,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			if (
 				emergencySettings.enabled &&
 				emergencyPressureReached &&
-				candidate === null &&
+				(candidate === null || autoCompressionFailure !== undefined) &&
 				emergencySelection &&
 				emergencySelection.eligible.length > 0 &&
 				(hardEmergencyReached || emergencyPatienceExceeded)
@@ -974,6 +1168,55 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				}
 			}
 
+			if (budget.capacityExceeded && (autoCompressionFailure || partialAutoProjectionTokens !== undefined)) {
+				const recoveredTokens = emergencyPruneResult?.estimatedTokensRecovered ?? 0
+				const projectedAfterRecovery = prunedMessages.reduce(
+					(sum, message) => sum + estimateMessageTokens(message),
+					0,
+				)
+				if (projectedAfterRecovery > budget.inputCapacityTokens) {
+					const finalBlockedReason = autoCompressionFailure?.blockedReason ?? "budget-exhausted"
+					const capacityGap = projectedAfterRecovery - budget.inputCapacityTokens
+					state.progressRecovery = {
+						blockedReason: finalBlockedReason,
+						projectedBeforeTokens: projectedAfterRecovery,
+						inputCapacityTokens: budget.inputCapacityTokens,
+						requiredSavingsTokens: capacityGap,
+						contextWindow: budget.contextWindow,
+						createdAt: Date.now(),
+					}
+					clearDcpNudgeAnchors(state)
+					await persistJournalState(ctx, state)
+					warnProgress(
+						ctx,
+						finalBlockedReason,
+						autoCompressionFailure
+							? `DCP recovery could not make the next request fit safely after auto-compression failed (${autoCompressionFailure.error}). ${projectedAfterRecovery} projected input tokens still exceed ${budget.inputCapacityTokens} input capacity by ${capacityGap}; the current agent operation is being stopped.`
+							: `DCP partial auto-compression made progress but the next request still does not fit safely. ${projectedAfterRecovery} projected input tokens exceed ${budget.inputCapacityTokens} input capacity by ${capacityGap}; the current agent operation is being stopped instead of sending an oversized request.`,
+					)
+					const abortSupported = typeof (ctx as any).abort === "function"
+					if (abortSupported) (ctx as any).abort()
+					writeDcpDebugLog(effectiveConfig, "context.progress_handoff", {
+						phase: "blocked",
+						blocked_reason: finalBlockedReason,
+						autoCompressionFailure,
+						recoveredTokens,
+						projectedAfterRecovery,
+						handoff: abortSupported ? "abort-current-agent-operation" : "abort-unavailable",
+						budget,
+						state: summarizeDcpState(state, effectiveConfig),
+					}, ctx)
+					return finishContext("progress.blocked_handoff", prunedMessages, {
+						blocked_reason: finalBlockedReason,
+						autoCompressionFailure,
+						recoveredTokens,
+						projectedAfterRecovery,
+						handoff: abortSupported ? "abort-current-agent-operation" : "abort-unavailable",
+						budget,
+					}, false)
+				}
+			}
+
 			if (nudgeType && !manualEmergencyOnly && (hasCompressionSuggestion || emergencyPressureReached)) {
 				latestProviderOpportunityAvailable = latestProviderOpportunityKind !== undefined
 				const nudgeText = appendConcreteNudgeGuidance(
@@ -987,7 +1230,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 					prunedMessages,
 					state,
 					nudgeType,
-					{ contextPercent, renderedReminder: nudgeText },
+					{ contextPercent, renderedReminder: nudgeText, freshToolResultIds: freshToolResults.eligibleIds },
 				)
 				if (anchorResult.anchor) {
 					if (anchorResult.updated) {
@@ -995,7 +1238,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 							anchorResult.created ? "emitted" : "upgraded",
 							nudgeType,
 							anchorResult.anchor,
-							usage,
+							{ ...usage, tokens: policyTokens, percent: contextPercent * 100 },
 							toolCallsSinceLastUser,
 						)
 						await persistJournalState(ctx, state)
@@ -1011,15 +1254,15 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 							"reapplied",
 							anchorResult.anchor.type,
 							anchorResult.anchor,
-							usage,
+							{ ...usage, tokens: policyTokens, percent: contextPercent * 100 },
 							toolCallsSinceLastUser,
 						)
 					}
 				} else {
 					// Do not rewrite an already-sent user message and do not create an
 					// ephemeral synthetic tail that disappears from the next provider
-					// continuation. The reminder is deferred until a fresh user tail; hard
-					// pressure is handled by the bounded emergency path above.
+					// continuation. Wait for a fresh user or proven-local tool result;
+					// hard pressure is handled by the bounded emergency path above.
 					writeDcpDebugLog(effectiveConfig, "nudge.deferred_for_cache", {
 						type: nudgeType,
 						contextPercent,
@@ -1069,12 +1312,36 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 	// ── 10b. provider lifecycle evidence ─────────────────────────────────────
 	pi.on("before_provider_request", async (event, ctx) => {
+		// Consume grants even on failed, retried, omitted-result or disabled sends.
+		// A completed-provider-response check here would be too late for caching.
+		freshToolResults.reset()
 		const effectiveConfig = configForContext(ctx)
 		if (!effectiveConfig.enabled) {
 			providerEvidenceTracker.reset()
 			return undefined
 		}
+		if (journalBlockedReason) throw new DcpJournalError(`DCP journal is blocked: ${journalBlockedReason}`)
+		if (isJournalSessionSupported() && lastProviderReadyProjectionEpoch !== state.sessionEpoch) {
+			const message =
+				`DCP blocked a provider request for session epoch ${state.sessionEpoch} because no provider-ready context projection ` +
+				"has completed in this epoch. This can happen after a session lifecycle reset between context construction and provider send; " +
+				"the raw session history will not be sent. Retry the turn so context can be rebuilt safely."
+			warnProgress(ctx, "stale-context-projection", message)
+			const abortSupported = typeof (ctx as any).abort === "function"
+			writeDcpDebugLog(effectiveConfig, "provider_payload.blocked_stale_projection", {
+				sessionEpoch: state.sessionEpoch,
+				lastProviderReadyProjectionEpoch,
+				handoff: abortSupported ? "abort-current-agent-operation" : "throw-before-provider-request",
+				state: summarizeDcpState(state, effectiveConfig),
+			}, ctx)
+			if (abortSupported) {
+				(ctx as any).abort()
+				return undefined
+			}
+			throw new Error(message)
+		}
 
+		freshToolResults.beforeProviderRequest()
 		const providerEvidence = collectProviderToolResultEvidence(event.payload)
 		const pendingToolIds = new Set<string>()
 		for (const meta of state.messageMetaSnapshot.values()) {
@@ -1099,6 +1366,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			opportunityAvailable: reminderDelivered,
 			opportunityKind: reminderDelivered ? latestProviderOpportunityKind : undefined,
 		})
+		routinePressureTracker.beforeRequest()
+		diagnostic("request", { id: `${diagnosticEpoch}:${pending.lastAttemptId}`, reminder: reminderDelivered, snapshot: diagnosticSnapshot })
 
 		writeDcpDebugLog(effectiveConfig, "provider_payload.message_ids", {
 			injected: false,
@@ -1152,6 +1421,7 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			model: typeof message.model === "string" ? message.model : undefined,
 			stopReason: typeof message.stopReason === "string" ? message.stopReason : undefined,
 		})
+		routinePressureTracker.complete(message, completion.status === "promote")
 		latestProviderOpportunityAvailable = false
 
 		if (completion.status !== "promote") {
@@ -1213,6 +1483,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				state.providerSeenToolIds = workingState.providerSeenToolIds
 				state.consecutiveIgnoredStrongNudges = workingState.consecutiveIgnoredStrongNudges
 				state.consecutiveIgnoredNudges = workingState.consecutiveIgnoredNudges
+				diagnostic("completion", { id: `${diagnosticEpoch}:${completion.lastAttemptId}`,
+					reminder: ignoredCompressionOpportunity, ignored: state.consecutiveIgnoredNudges })
 				writeDcpDebugLog(effectiveConfig, "provider_payload.tool_results_seen", {
 					attempts: completion.attempts,
 					newlySeenToolResults: newlySeen.length,