pi-ui-extend 0.1.57 → 0.1.60

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

@@ -32,6 +32,10 @@ import {
 	getNudgeType,
 	detectCompressionCandidate,
 	detectMessageCompressionCandidates,
+	analyzeEmergencyCurrentTurn,
+	emergencyPressureState,
+	emergencyCurrentTurnMessageCandidates,
+	pruneEmergencyCurrentTurn,
 	appendConcreteNudgeGuidance,
 	applyAnchoredNudges,
 	clearDcpNudgeAnchors,
@@ -55,6 +59,10 @@ import { decideAutoCompress, createAutoCompressionBlock } from "./auto-compress.
 import { DCP_STATS_MESSAGE_TYPE, registerCommands } from "./commands.js"
 import { normalizeDcpContextUsage } from "./ui.js"
 import { safeGetContextUsage } from "../context-usage.js"
+import {
+	collectProviderToolResultEvidence,
+	providerPayloadIncludesToolResult,
+} from "./provider-tool-results.js"
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -224,6 +232,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 
 	// ── 2. Create state ───────────────────────────────────────────────────────
 	const state = createState()
+	const pendingProviderToolIds = new Set<string>()
 	const appendNudgeTelemetry = (
 		event: "emitted" | "upgraded" | "reapplied",
 		type: DcpNudgeType,
@@ -427,6 +436,8 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		let prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
 		let candidate = null as ReturnType<typeof detectCompressionCandidate>
 		let messageCandidates = [] as ReturnType<typeof detectMessageCompressionCandidates>
+		let emergencySelection = null as ReturnType<typeof analyzeEmergencyCurrentTurn> | null
+		let emergencyPruneResult = null as ReturnType<typeof pruneEmergencyCurrentTurn> | null
 
 		// In manual mode we still apply pruning strategies (if
 		// automaticStrategies is on) but skip routine autonomous nudges. Emergency
@@ -472,15 +483,27 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				thresholds.maxContextPercent += Math.min(summaryBonus, SUMMARY_BUFFER_MAX_CONTEXT_BONUS)
 			}
 
-			const contextLimitReached = contextPercent > thresholds.maxContextPercent
+			const emergencySettings = effectiveConfig.strategies.emergencyCurrentTurnPruning
+			const {
+				hardEmergencyReached,
+				contextLimitReached,
+				emergencyPressureReached,
+			} = emergencyPressureState(
+				contextPercent,
+				thresholds.maxContextPercent,
+				emergencySettings.hardContextPercent,
+			)
 			const routineNudgesAllowed = contextPercent > thresholds.minContextPercent
-			if (!contextLimitReached && !routineNudgesAllowed) {
+			if (!emergencyPressureReached && !routineNudgesAllowed) {
 				const clearedAnchors = clearDcpNudgeAnchors(state)
-				if (clearedAnchors > 0) await saveDcpState(ctx, state)
+				const resetEmergencyPasses = state.consecutiveIgnoredStrongNudges > 0
+				state.consecutiveIgnoredStrongNudges = 0
+				if (clearedAnchors > 0 || resetEmergencyPasses) await saveDcpState(ctx, state)
 				return finishContext("below-threshold", prunedMessages, {
 					contextPercent,
 					thresholds,
 					clearedAnchors,
+					resetEmergencyPasses,
 				})
 			}
 
@@ -505,8 +528,17 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				Number.isFinite(currentContextWindow) &&
 				currentContextWindow < previousContextWindow * 0.9 &&
 				contextPercent > thresholds.minContextPercent
+			const contextWindowChanged =
+				typeof previousContextWindow === "number" &&
+				Number.isFinite(previousContextWindow) &&
+				typeof currentContextWindow === "number" &&
+				Number.isFinite(currentContextWindow) &&
+				currentContextWindow !== previousContextWindow
+			if (contextWindowChanged) state.consecutiveIgnoredStrongNudges = 0
 
-			const nudgeType = windowDowngraded
+			const nudgeType = hardEmergencyReached && !contextLimitReached
+				? "context-strong"
+				: windowDowngraded
 				? "context-strong"
 				: getNudgeType(
 					contextPercent,
@@ -543,11 +575,37 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}, ctx)
 			}
 
-			const hasCompressionSuggestion =
+			const hasNormalCompressionSuggestion =
+				candidate !== null || messageCandidates.length > 0
+			if (
+				emergencySettings.enabled &&
+				emergencyPressureReached &&
+				!manualEmergencyOnly &&
+				!hasNormalCompressionSuggestion
+			) {
+				emergencySelection = analyzeEmergencyCurrentTurn(
+					prunedMessages,
+					state,
+					effectiveConfig,
+				)
+				messageCandidates = emergencyCurrentTurnMessageCandidates(
+					emergencySelection,
+					effectiveConfig,
+				)
+				writeDcpDebugLog(effectiveConfig, "context.strong_nudge_without_candidate", {
+					contextPercent,
+					thresholds,
+					nudgeType,
+					emergencyCandidates: messageCandidates.length,
+					...emergencySelection.stats,
+					state: summarizeDcpState(state),
+				}, ctx)
+			}
+
+			let hasCompressionSuggestion =
 				candidate !== null || messageCandidates.length > 0
-			if (!manualEmergencyOnly && !hasCompressionSuggestion) {
+			if (!manualEmergencyOnly && !emergencyPressureReached && !hasCompressionSuggestion) {
 				const clearedAnchors = clearDcpNudgeAnchors(state)
-				state.consecutiveIgnoredStrongNudges = 0
 				if (clearedAnchors > 0) await saveDcpState(ctx, state)
 				if (nudgeType || clearedAnchors > 0) {
 					writeDcpDebugLog(effectiveConfig, "context.no_compression_candidate", {
@@ -560,19 +618,11 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}
 			}
 
-			// Track consecutive ignored context-strong nudges for the
-			// auto-compress fallback. A strong nudge is "ignored" if it fires
-			// again on a later context event without a successful compress in
-			// between. Reset on non-strong nudges and when pressure drops below
-			// the emergency threshold (handled by the below-threshold early
-			// return above, which clears anchors; counter is also reset on any
-			// successful compress in the compress tool).
-			if (
-				hasCompressionSuggestion &&
-				(nudgeType === "context-strong" || nudgeType === "context-soft")
-			) {
+			// Emergency pressure must advance even when normal candidates are
+			// absent; otherwise the current-turn fallback can never reach patience.
+			if (emergencyPressureReached) {
 				state.consecutiveIgnoredStrongNudges += 1
-			} else if (nudgeType === null || !hasCompressionSuggestion) {
+			} else {
 				state.consecutiveIgnoredStrongNudges = 0
 			}
 
@@ -587,6 +637,17 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 					thresholds.maxContextPercent,
 					candidate,
 				)
+				if (contextLimitReached && candidate === null) {
+					writeDcpDebugLog(effectiveConfig, "compress.auto_blocked_no_candidate", {
+						autoCompressEnabled: effectiveConfig.compress.autoCompress.enabled,
+						decisionReason: autoDecision.reason,
+						contextPercent,
+						thresholds,
+						consecutiveEmergencyPasses: state.consecutiveIgnoredStrongNudges,
+						...(emergencySelection?.stats ?? {}),
+						state: summarizeDcpState(state),
+					}, ctx)
+				}
 				if (autoDecision.shouldFire && candidate) {
 					try {
 						const autoResult = await createAutoCompressionBlock({
@@ -635,7 +696,64 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				}
 			}
 
-			if (nudgeType && !manualEmergencyOnly && hasCompressionSuggestion) {
+			// Model-independent safety floor for an unfinished active turn. Only
+			// result bodies are replaced; user messages and structural tool pairs
+			// stay intact. Fresh results are ineligible until before_provider_request
+			// records that the model has had a chance to consume them.
+			const emergencyPatienceExceeded =
+				state.consecutiveIgnoredStrongNudges > Math.max(0, Math.floor(emergencySettings.patience))
+			if (
+				emergencySettings.enabled &&
+				emergencyPressureReached &&
+				candidate === null &&
+				emergencySelection &&
+				emergencySelection.eligible.length > 0 &&
+				(hardEmergencyReached || emergencyPatienceExceeded)
+			) {
+				const selectionStatsBeforePrune = emergencySelection.stats
+				const configuredTarget = Math.max(0, Math.min(1, emergencySettings.targetContextPercent))
+				const emergencyMarginTarget = Math.max(0, thresholds.maxContextPercent * 0.9)
+				const targetContextPercent = Math.min(configuredTarget, emergencyMarginTarget)
+				const targetRecoveryTokens = Math.max(
+					1,
+					Math.ceil((contextPercent - targetContextPercent) * usage.contextWindow),
+				)
+				emergencyPruneResult = pruneEmergencyCurrentTurn(
+					emergencySelection,
+					state,
+					targetRecoveryTokens,
+				)
+				if (emergencyPruneResult.prunedToolCallIds.length > 0) {
+					prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
+					state.consecutiveIgnoredStrongNudges = 0
+					emergencySelection = analyzeEmergencyCurrentTurn(prunedMessages, state, effectiveConfig)
+					messageCandidates = emergencyCurrentTurnMessageCandidates(emergencySelection, effectiveConfig)
+					hasCompressionSuggestion = candidate !== null || messageCandidates.length > 0
+					await saveDcpState(ctx, state)
+					writeDcpDebugLog(effectiveConfig, "prune.emergency_current_turn", {
+						trigger: hardEmergencyReached ? "hard-context-percent" : "ignored-emergency-reminders",
+						contextPercent,
+						thresholds,
+						targetContextPercent,
+						targetRecoveryTokens,
+						prunedOutputs: emergencyPruneResult.prunedToolCallIds.length,
+						estimatedTokensRecovered: emergencyPruneResult.estimatedTokensRecovered,
+						estimatedContextPercentAfter: Math.max(
+							0,
+							((usage.tokens ?? contextPercent * usage.contextWindow) -
+								emergencyPruneResult.estimatedTokensRecovered) /
+							usage.contextWindow,
+						),
+						targetMet: emergencyPruneResult.estimatedTokensRecovered >= targetRecoveryTokens,
+						eligibleExhausted:
+							emergencyPruneResult.prunedToolCallIds.length >= selectionStatsBeforePrune.eligiblePairs,
+						...selectionStatsBeforePrune,
+						state: summarizeDcpState(state),
+					}, ctx)
+				}
+			}
+
+			if (nudgeType && !manualEmergencyOnly && (hasCompressionSuggestion || emergencyPressureReached)) {
 				const nudgeText = appendConcreteNudgeGuidance(
 					baseNudgeText(nudgeType),
 					candidate,
@@ -685,6 +803,10 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 			} else {
 				state.nudgeCounter++
 			}
+
+			// Persist patience/window changes even when an existing anchor was only
+			// re-applied (that path intentionally emits telemetry without updating it).
+			await saveDcpState(ctx, state)
 		}
 
 		if (state.manualMode) {
@@ -699,25 +821,65 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		return finishContext("complete", prunedMessages, {
 			candidate,
 			messageCandidates,
+			emergencyCurrentTurn: emergencySelection?.stats,
+			emergencyPrune: emergencyPruneResult,
 		})
 	})
 
 	// ── 10b. before_provider_request: inject DCP IDs outside transcript ────────
 	pi.on("before_provider_request", async (event, ctx) => {
 		const effectiveConfig = configForContext(ctx)
+		pendingProviderToolIds.clear()
 		if (!effectiveConfig.enabled) return undefined
 
+		const providerEvidence = collectProviderToolResultEvidence(event.payload)
+		for (const meta of state.messageMetaSnapshot.values()) {
+			if (meta.role !== "toolResult") continue
+			if (!meta.toolCallId || state.prunedToolIds.has(meta.toolCallId)) continue
+			if (state.providerSeenToolIds.has(meta.toolCallId)) continue
+			const record = state.toolCalls.get(meta.toolCallId)
+			if (record && providerPayloadIncludesToolResult(providerEvidence, record)) {
+				pendingProviderToolIds.add(meta.toolCallId)
+			}
+		}
+
 		const controlText = buildMessageIdControlText(state)
 		if (!controlText) return undefined
 
 		const payload = appendDcpControlToProviderPayload(event.payload, controlText)
 		writeDcpDebugLog(effectiveConfig, "provider_payload.message_ids", {
 			injected: payload !== event.payload,
+			pendingToolResults: pendingProviderToolIds.size,
 			state: summarizeDcpState(state),
 		}, ctx)
 		return payload === event.payload ? undefined : payload
 	})
 
+	// Promote pending IDs only after the provider accepted the exact payload.
+	// Failed/aborted requests leave results fresh and therefore ineligible.
+	pi.on("after_provider_response", async (event, ctx) => {
+		const effectiveConfig = configForContext(ctx)
+		const accepted = event.status >= 200 && event.status < 300
+		let newlySeenToolResults = 0
+		if (effectiveConfig.enabled && accepted) {
+			for (const toolCallId of pendingProviderToolIds) {
+				if (!state.providerSeenToolIds.has(toolCallId)) {
+					state.providerSeenToolIds.add(toolCallId)
+					newlySeenToolResults++
+				}
+			}
+			if (newlySeenToolResults > 0) await saveDcpState(ctx, state)
+		}
+		writeDcpDebugLog(effectiveConfig, "provider_payload.tool_results_seen", {
+			status: event.status,
+			accepted,
+			pendingToolResults: pendingProviderToolIds.size,
+			newlySeenToolResults,
+			state: summarizeDcpState(state),
+		}, ctx)
+		pendingProviderToolIds.clear()
+	})
+
 	// ── 11. agent_end: persist state after each agent run ────────────────────
 	pi.on("agent_end", async (_event, ctx) => {
 		await saveDcpState(ctx, state)

package/external/pi-tools-suite/src/dcp/provider-tool-results.ts

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import type { ToolRecord } from "./state.js";
+
+export interface ProviderToolResultEvidence {
+  ids: Set<string>;
+  anonymousSignatures: Set<string>;
+}
+
+function responseText(response: unknown): string | undefined {
+  if (typeof response === "string") return response;
+  if (!response || typeof response !== "object") return undefined;
+  const record = response as Record<string, unknown>;
+  if (typeof record.output === "string") return record.output;
+  if (typeof record.error === "string") return record.error;
+  return undefined;
+}
+
+function signature(toolName: string, outputText: string): string {
+  return createHash("sha256")
+    .update(toolName)
+    .update("\u0000")
+    .update(outputText)
+    .digest("hex");
+}
+
+/** Collect only tool-result evidence, never assistant tool-call IDs. */
+export function collectProviderToolResultEvidence(payload: unknown): ProviderToolResultEvidence {
+  const evidence: ProviderToolResultEvidence = {
+    ids: new Set<string>(),
+    anonymousSignatures: new Set<string>(),
+  };
+  const visited = new Set<object>();
+
+  function visit(value: unknown): void {
+    if (!value || typeof value !== "object") return;
+    if (visited.has(value)) return;
+    visited.add(value);
+
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item);
+      return;
+    }
+
+    const record = value as Record<string, unknown>;
+    if (record.role === "toolResult" && typeof record.toolCallId === "string") {
+      evidence.ids.add(record.toolCallId);
+    }
+    if (record.role === "tool" && typeof record.tool_call_id === "string") {
+      evidence.ids.add(record.tool_call_id);
+    }
+    if (record.type === "function_call_output" && typeof record.call_id === "string") {
+      evidence.ids.add(record.call_id);
+    }
+    if (record.type === "tool_result" && typeof record.tool_use_id === "string") {
+      evidence.ids.add(record.tool_use_id);
+    }
+
+    const functionResponse = record.functionResponse;
+    if (functionResponse && typeof functionResponse === "object") {
+      const responseRecord = functionResponse as Record<string, unknown>;
+      if (typeof responseRecord.id === "string") evidence.ids.add(responseRecord.id);
+      const outputText = responseText(responseRecord.response);
+      if (typeof responseRecord.name === "string" && outputText !== undefined) {
+        evidence.anonymousSignatures.add(signature(responseRecord.name, outputText));
+      }
+    }
+
+    for (const nested of Object.values(record)) visit(nested);
+  }
+
+  visit(payload);
+  return evidence;
+}
+
+export function providerPayloadIncludesToolResult(
+  evidence: ProviderToolResultEvidence,
+  record: ToolRecord,
+): boolean {
+  if (evidence.ids.has(record.toolCallId)) return true;
+  for (const id of evidence.ids) {
+    if (record.toolCallId.startsWith(`${id}|`)) return true;
+  }
+  return typeof record.outputText === "string" &&
+    evidence.anonymousSignatures.has(signature(record.toolName, record.outputText));
+}

package/external/pi-tools-suite/src/dcp/pruner-emergency.ts

@@ -0,0 +1,254 @@
+import type { DcpConfig } from "./config.js";
+import { estimateMessageTokens, extractBlockId, messageText } from "./pruner-metadata.js";
+import type {
+  EmergencyCurrentTurnOutput,
+  EmergencyCurrentTurnSelection,
+  MessageCompressionCandidate,
+} from "./pruner-types.js";
+import {
+  EMERGENCY_CURRENT_TURN_PLACEHOLDER,
+  isToolRecordProtected,
+  markToolPruned,
+} from "./pruner-tools.js";
+import type { DcpState } from "./state.js";
+
+function emptySelection(): EmergencyCurrentTurnSelection {
+  return {
+    eligible: [],
+    stats: {
+      totalPairs: 0,
+      totalPairTokens: 0,
+      eligiblePairs: 0,
+      eligibleTokens: 0,
+      eligibleRecoverableTokens: 0,
+      preservedPairs: 0,
+      preservedTokens: 0,
+      preservedRecentPairs: 0,
+      preservedRecentTokens: 0,
+      preservedUnseenPairs: 0,
+      preservedUnseenTokens: 0,
+      preservedProtectedPairs: 0,
+      preservedProtectedTokens: 0,
+    },
+  };
+}
+
+export function emergencyPressureState(
+  contextPercent: number,
+  maxContextPercent: number,
+  hardContextPercent: number,
+): { hardEmergencyReached: boolean; contextLimitReached: boolean; emergencyPressureReached: boolean } {
+  const hardEmergencyReached = contextPercent >= Math.max(0, Math.min(1, hardContextPercent));
+  const contextLimitReached = contextPercent > maxContextPercent;
+  return {
+    hardEmergencyReached,
+    contextLimitReached,
+    emergencyPressureReached: hardEmergencyReached || contextLimitReached,
+  };
+}
+
+function isRealUserMessage(message: any): boolean {
+  if (message?.role !== "user") return false;
+  const text = messageText(message);
+  return !text.includes("<dcp-system-reminder>") && extractBlockId(text) === undefined;
+}
+
+function assistantToolCallIds(message: any): string[] {
+  if (message?.role !== "assistant" || !Array.isArray(message.content)) return [];
+  return message.content
+    .filter((part: any) => part?.type === "toolCall" && typeof part.id === "string")
+    .map((part: any) => part.id as string);
+}
+
+function messageIdForResult(message: any, state: DcpState): string | undefined {
+  for (const [id, meta] of state.messageMetaSnapshot) {
+    if (
+      meta.blockId === undefined &&
+      meta.toolCallId === message.toolCallId &&
+      meta.role === message.role &&
+      meta.timestamp === message.timestamp
+    ) return id;
+  }
+  return undefined;
+}
+
+function hasProtectedTag(message: any, config: DcpConfig): boolean {
+  return config.compress.protectTags && /<protect\b[^>]*>[\s\S]*?<\/protect>/i.test(messageText(message));
+}
+
+export function analyzeEmergencyCurrentTurn(
+  messages: any[],
+  state: DcpState,
+  config: DcpConfig,
+): EmergencyCurrentTurnSelection {
+  const settings = config.strategies.emergencyCurrentTurnPruning;
+  if (!settings.enabled) return emptySelection();
+  let latestUserIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (isRealUserMessage(messages[index])) {
+      latestUserIndex = index;
+      break;
+    }
+  }
+
+  if (latestUserIndex < 0) {
+    return emptySelection();
+  }
+
+  const pairedCallIds = new Set<string>();
+  for (let index = latestUserIndex + 1; index < messages.length; index++) {
+    for (const toolCallId of assistantToolCallIds(messages[index])) pairedCallIds.add(toolCallId);
+  }
+
+  const pairs: Array<EmergencyCurrentTurnOutput & { message: any }> = [];
+  for (let index = latestUserIndex + 1; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== "toolResult") continue;
+    if (typeof message.toolCallId !== "string" || !pairedCallIds.has(message.toolCallId)) continue;
+    const record = state.toolCalls.get(message.toolCallId);
+    const tokenEstimate = Math.max(record?.tokenEstimate ?? 0, estimateMessageTokens(message));
+    const placeholderEstimate = estimateMessageTokens({
+      ...message,
+      content: [{ type: "text", text: EMERGENCY_CURRENT_TURN_PLACEHOLDER }],
+    });
+    pairs.push({
+      toolCallId: message.toolCallId,
+      messageId: messageIdForResult(message, state),
+      toolName: record?.toolName ?? message.toolName ?? "",
+      tokenEstimate,
+      recoverableTokens: Math.max(0, tokenEstimate - placeholderEstimate),
+      resultIndex: index,
+      message,
+    });
+  }
+
+  const keepRecent = Math.max(0, Math.floor(settings.keepRecentToolPairs));
+  const recentIds = new Set(pairs.slice(Math.max(0, pairs.length - keepRecent)).map((pair) => pair.toolCallId));
+  const eligible: EmergencyCurrentTurnOutput[] = [];
+  const preservedIds = new Set<string>();
+  let preservedTokens = 0;
+  let preservedRecentPairs = 0;
+  let preservedRecentTokens = 0;
+  let preservedUnseenPairs = 0;
+  let preservedUnseenTokens = 0;
+  let preservedProtectedPairs = 0;
+  let preservedProtectedTokens = 0;
+
+  const preserve = (
+    pair: EmergencyCurrentTurnOutput,
+    reason: "recent" | "unseen" | "protected" | "other",
+  ): void => {
+    if (!preservedIds.has(pair.toolCallId)) {
+      preservedIds.add(pair.toolCallId);
+      preservedTokens += pair.tokenEstimate;
+    }
+    if (reason === "recent") {
+      preservedRecentPairs++;
+      preservedRecentTokens += pair.tokenEstimate;
+    } else if (reason === "unseen") {
+      preservedUnseenPairs++;
+      preservedUnseenTokens += pair.tokenEstimate;
+    } else if (reason === "protected") {
+      preservedProtectedPairs++;
+      preservedProtectedTokens += pair.tokenEstimate;
+    }
+  };
+
+  for (const pair of pairs) {
+    if (recentIds.has(pair.toolCallId)) {
+      preserve(pair, "recent");
+      continue;
+    }
+    if (!state.providerSeenToolIds.has(pair.toolCallId)) {
+      preserve(pair, "unseen");
+      continue;
+    }
+    const record = state.toolCalls.get(pair.toolCallId);
+    if (
+      !record ||
+      isToolRecordProtected(record, config, settings.protectedTools) ||
+      hasProtectedTag(pair.message, config)
+    ) {
+      preserve(pair, "protected");
+      continue;
+    }
+    if (
+      state.prunedToolIds.has(pair.toolCallId) ||
+      pair.tokenEstimate < Math.max(1, settings.minOutputTokens) ||
+      pair.recoverableTokens <= 0
+    ) {
+      preserve(pair, "other");
+      continue;
+    }
+    eligible.push({
+      toolCallId: pair.toolCallId,
+      messageId: pair.messageId,
+      toolName: pair.toolName,
+      tokenEstimate: pair.tokenEstimate,
+      recoverableTokens: pair.recoverableTokens,
+      resultIndex: pair.resultIndex,
+    });
+  }
+
+  eligible.sort((a, b) =>
+    a.resultIndex - b.resultIndex ||
+    b.tokenEstimate - a.tokenEstimate ||
+    a.toolCallId.localeCompare(b.toolCallId),
+  );
+  return {
+    eligible,
+    stats: {
+      totalPairs: pairs.length,
+      totalPairTokens: pairs.reduce((sum, pair) => sum + pair.tokenEstimate, 0),
+      eligiblePairs: eligible.length,
+      eligibleTokens: eligible.reduce((sum, pair) => sum + pair.tokenEstimate, 0),
+      eligibleRecoverableTokens: eligible.reduce((sum, pair) => sum + pair.recoverableTokens, 0),
+      preservedPairs: preservedIds.size,
+      preservedTokens,
+      preservedRecentPairs,
+      preservedRecentTokens,
+      preservedUnseenPairs,
+      preservedUnseenTokens,
+      preservedProtectedPairs,
+      preservedProtectedTokens,
+    },
+  };
+}
+
+export function emergencyCurrentTurnMessageCandidates(
+  selection: EmergencyCurrentTurnSelection,
+  config: DcpConfig,
+): MessageCompressionCandidate[] {
+  const settings = config.strategies.emergencyCurrentTurnPruning;
+  if (!settings.enabled) return [];
+  const maxSuggestions = Math.max(1, Math.floor(settings.maxSuggestions));
+  const highTokens = Math.max(1, config.compress.messageMode.highTokens);
+  return selection.eligible
+    .filter((output) => output.messageId !== undefined)
+    .slice(0, maxSuggestions)
+    .map((output) => ({
+      messageId: output.messageId!,
+      role: "toolResult",
+      estimatedTokens: output.tokenEstimate,
+      priority: output.tokenEstimate >= highTokens ? "high" : "medium",
+      reason: `old same-turn tool output; newest ${settings.keepRecentToolPairs} complete pair(s) preserved`,
+    }));
+}
+
+export function pruneEmergencyCurrentTurn(
+  selection: EmergencyCurrentTurnSelection,
+  state: DcpState,
+  targetRecoveryTokens: number,
+): { prunedToolCallIds: string[]; estimatedTokensRecovered: number } {
+  const prunedToolCallIds: string[] = [];
+  let estimatedTokensRecovered = 0;
+  const target = Math.max(1, Math.ceil(targetRecoveryTokens));
+  for (const output of selection.eligible) {
+    if (estimatedTokensRecovered >= target) break;
+    if (markToolPruned(state, output.toolCallId, "emergency-current-turn", output.recoverableTokens)) {
+      prunedToolCallIds.push(output.toolCallId);
+      estimatedTokensRecovered += output.recoverableTokens;
+    }
+  }
+  return { prunedToolCallIds, estimatedTokensRecovered };
+}

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

@@ -2,6 +2,9 @@ import type { DcpConfig } from "./config.js";
 import type { DcpState, ToolRecord } from "./state.js";
 import { estimateMessageTokens } from "./pruner-metadata.js";
 
+export const EMERGENCY_CURRENT_TURN_PLACEHOLDER =
+  "[Older tool output removed during current-turn context emergency; re-run the tool if exact content is needed]";
+
 // Tool outputs that must never be auto-pruned unless a future explicit user
 // action intentionally changes that policy. They mutate state or control DCP.
 const ALWAYS_PROTECTED_TOOLS = new Set(["compress", "write", "edit"]);
@@ -238,6 +241,9 @@ function placeholderForPrunedTool(msg: any, state: DcpState): string {
   if (reason === "manual-sweep") {
     return "[Output removed by /dcp sweep to save context]";
   }
+  if (reason === "emergency-current-turn") {
+    return EMERGENCY_CURRENT_TURN_PLACEHOLDER;
+  }
   if (reason === "old-error" || msg.isError) {
     return "[Error output removed - tool failed more than the configured number of turns ago]";
   }