pi-ui-extend 0.1.56 → 0.1.59

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

@@ -17,6 +17,36 @@ export interface MessageCompressionCandidate {
   reason: string;
 }
 
+export interface EmergencyCurrentTurnStats {
+  totalPairs: number;
+  totalPairTokens: number;
+  eligiblePairs: number;
+  eligibleTokens: number;
+  eligibleRecoverableTokens: number;
+  preservedPairs: number;
+  preservedTokens: number;
+  preservedRecentPairs: number;
+  preservedRecentTokens: number;
+  preservedUnseenPairs: number;
+  preservedUnseenTokens: number;
+  preservedProtectedPairs: number;
+  preservedProtectedTokens: number;
+}
+
+export interface EmergencyCurrentTurnOutput {
+  toolCallId: string;
+  messageId?: string;
+  toolName: string;
+  tokenEstimate: number;
+  recoverableTokens: number;
+  resultIndex: number;
+}
+
+export interface EmergencyCurrentTurnSelection {
+  eligible: EmergencyCurrentTurnOutput[];
+  stats: EmergencyCurrentTurnStats;
+}
+
 export type DcpNudgeType = "context-strong" | "context-soft" | "turn" | "iteration";
 
 export interface NudgeThresholds {

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

@@ -12,10 +12,18 @@ import {
 
 export type {
   CompressionCandidate,
+  EmergencyCurrentTurnSelection,
+  EmergencyCurrentTurnStats,
   MessageCompressionCandidate,
   MessagePriority,
   NudgeThresholds,
 } from "./pruner-types.js";
+export {
+  analyzeEmergencyCurrentTurn,
+  emergencyPressureState,
+  emergencyCurrentTurnMessageCandidates,
+  pruneEmergencyCurrentTurn,
+} from "./pruner-emergency.js";
 export {
   estimateTokens,
   getActiveSummaryTokenEstimate,

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

@@ -145,6 +145,8 @@ export interface DcpState {
   prunedToolIds: Set<string>
   /** toolCallId → reason used for human-readable pruning placeholders/stats. */
   prunedToolReasons: Map<string, string>
+  /** Tool results included in at least one provider request. */
+  providerSeenToolIds: Set<string>
 
   // ── Compression ────────────────────────────────────────────────────────────
   /** All compression blocks (both active and soft-deleted) */
@@ -228,12 +230,10 @@ export interface DcpState {
    */
   lastContextWindow?: number
   /**
-   * How many consecutive `context-strong` nudges have been emitted without a
-   * subsequent successful `compress` (model- or DCP-initiated). When this
-   * reaches `compress.autoCompress.patience` while context is above the
-   * emergency threshold, the auto-compress fallback creates a block without
-   * waiting for the model. Reset to 0 on any successful compression, when
-   * pressure drops below the emergency threshold, or on a window change.
+   * How many consecutive emergency context reminders have been delivered
+   * without a successful compression or emergency prune. This advances even
+   * when no normal compression candidate exists so current-turn fallback
+   * patience cannot be reset by the exact condition it is designed to handle.
    */
   consecutiveIgnoredStrongNudges: number
 }
@@ -248,6 +248,7 @@ export function createState(): DcpState {
     toolCalls: new Map(),
     prunedToolIds: new Set(),
     prunedToolReasons: new Map(),
+    providerSeenToolIds: new Set(),
     compressionBlocks: [],
     nextBlockId: 1,
     messageIdSnapshot: new Map(),
@@ -279,6 +280,7 @@ export function resetState(state: DcpState): void {
   state.toolCalls.clear()
   state.prunedToolIds.clear()
   state.prunedToolReasons.clear()
+  state.providerSeenToolIds.clear()
   state.compressionBlocks = []
   state.nextBlockId = 1
   state.messageIdSnapshot.clear()
@@ -401,6 +403,8 @@ export interface SerializedDcpState {
   nextBlockId: number
   prunedToolIds: string[]
   prunedToolReasons: Array<[string, string]>
+  /** Tool result IDs known to have appeared in a provider request. */
+  providerSeenToolIds?: string[]
   /** Full tool records — present in legacy snapshots. */
   toolCalls?: ToolRecord[]
   /** Compact tool records — present in new compact snapshots. */
@@ -597,11 +601,16 @@ export function serializeState(state: DcpState): SerializedDcpState {
     seen.add(record.toolCallId)
   }
 
+  const persistedToolCallIds = new Set(compactToolCalls.map((record) => record.toolCallId))
+  const providerSeenToolIds = Array.from(state.providerSeenToolIds)
+    .filter((toolCallId) => persistedToolCallIds.has(toolCallId))
+
   return {
     compressionBlocks: state.compressionBlocks,
     nextBlockId: state.nextBlockId,
     prunedToolIds: Array.from(state.prunedToolIds),
     prunedToolReasons: Array.from(state.prunedToolReasons.entries()),
+    providerSeenToolIds,
     compactToolCalls,
     totalToolCallCount: allRecords.length,
     tokensSaved: state.tokensSaved,
@@ -661,6 +670,12 @@ export function restoreState(state: DcpState, data: unknown): void {
     )
   }
 
+  if (Array.isArray(saved.providerSeenToolIds)) {
+    state.providerSeenToolIds = new Set(
+      saved.providerSeenToolIds.filter((id): id is string => typeof id === "string"),
+    )
+  }
+
   if (Array.isArray(saved.compactToolCalls)) {
     // New compact format: restore CompactToolRecords as ToolRecords with
     // synthetic inputArgs derived from inputStringValues.

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -38,6 +38,20 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
     "debug": false,
     "debugLog": { "maxBytes": 5242880, "maxBackups": 3 },
     "manualMode": { "enabled": false, "automaticStrategies": true },
+    "strategies": {
+      "emergencyCurrentTurnPruning": {
+        // Disabling this turns off same-turn candidates and lossy pruning;
+        // non-destructive emergency reminders remain active.
+        "enabled": true,
+        "hardContextPercent": 0.82,
+        "targetContextPercent": 0.70,
+        "patience": 2,
+        "keepRecentToolPairs": 8,
+        "minOutputTokens": 500,
+        "maxSuggestions": 8,
+        "protectedTools": []
+      }
+    },
     "modelOverrides": {
       "openai-codex/gpt-5*": {
         "compress": {

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

@@ -9,8 +9,7 @@ type ExtensionModule = {
 	default: ExtensionFactory;
 };
 
-const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
-	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },
+export const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "coding-discipline", load: () => import("./coding-discipline/index") },
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },
@@ -28,6 +27,9 @@ const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
 	{ name: "skill-installer", load: () => import("./skill-installer/index") },
 	{ name: "telegram-mirror", load: () => import("./telegram-mirror/index") },
+	// Keep this last: its before_provider_request handler is the final payload
+	// sanitizer after DCP and any other provider-payload modifiers.
+	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },
 ];
 
 export default async function piToolsSuite(pi: ExtensionAPI) {

package/external/pi-tools-suite/src/telegram-mirror/events.ts

@@ -18,7 +18,11 @@ export interface RendererSink {
 }
 
 export function registerPixEventHandlers(pi: ExtensionAPI, hooks: PixMirrorHooks): void {
+	let turnActive = false;
+
 	pi.on("agent_start", (_event, ctx) => {
+		if (turnActive) return;
+		turnActive = true;
 		hooks.getRenderer()?.push({ kind: "turn_start", instance: hooks.describeInstance(ctx as ExtensionContext | undefined) });
 	});
 
@@ -33,16 +37,18 @@ export function registerPixEventHandlers(pi: ExtensionAPI, hooks: PixMirrorHooks
 		// user-visible assistant answer, not internal reasoning/tools.
 	});
 
-	pi.on("agent_end", () => {
+	pi.on("agent_settled", () => {
+		if (!turnActive) return;
+		turnActive = false;
 		hooks.getRenderer()?.push({ kind: "turn_end", reason: "end" });
-		hooks.notifyAgentEnd();
+		hooks.notifyAgentSettled();
 	});
 }
 
 export interface PixMirrorHooks {
 	getRenderer(): RendererSink | undefined;
 	describeInstance(ctx: ExtensionContext | undefined): RendererInstance | undefined;
-	notifyAgentEnd(): void;
+	notifyAgentSettled(): void;
 }
 
 export function captureAbortableContext(ctx: ExtensionContext | undefined, hooks: ContextCapture): void {
@@ -59,4 +65,3 @@ export interface ContextCapture {
 	capturePending(fn: () => boolean): void;
 	captureCompact(fn: () => void): void;
 }
-

package/external/pi-tools-suite/src/telegram-mirror/index.ts

@@ -166,7 +166,7 @@ export default function telegramMirror(pi: ExtensionAPI): void {
 	const hooks: PixMirrorHooks = {
 		getRenderer: () => eventSink,
 		describeInstance: (ctx) => describeInstance(ctx),
-		notifyAgentEnd: () => undefined,
+		notifyAgentSettled: () => undefined,
 	};
 
 	registerPixEventHandlers(pi, hooks);

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

@@ -10,16 +10,6 @@ import { getState, replaceState } from "./state/store.js";
 import { activateTodoStateScope, DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
 import type { Task, TaskMutationParams } from "./tool/types.js";
 
-/**
- * Renderer-relayed signal that the session is in an auto-retry cycle.
- * Payload: `{ active: boolean }`. The SDK does not forward retry state to
- * extensions, so the renderer emits this on the extension event bus. We use it
- * to suppress the auto-nudge on intermediate retry agent_end events: nudging
- * then races the pending retry continuation and surfaces a benign
- * "Agent is already processing" extension error in other tabs.
- */
-const RETRY_ACTIVE_EVENT = "pix:retry-active";
-
 type AgentMessageLike = { role?: unknown; stopReason?: unknown; content?: unknown };
 
 const TODO_NUDGE_LIMIT = 8;
@@ -144,10 +134,10 @@ export default function (pi: ExtensionAPI) {
 	const pendingAskUserToolCallIds = new Set<string>();
 	let suppressNextNudgeForThinkingSwitch = false;
 	let inProgressAtAgentStart = new Set<number>();
-	// True while the session is in an auto-retry cycle (relayed via the
-	// extension event bus). Suppresses the auto-nudge on intermediate retry
-	// agent_end events so it doesn't race the pending retry continuation.
-	let retryActive = false;
+	// agent_end may be followed by an automatic retry, compaction, or queued
+	// continuation. Remember only whether its terminal assistant reply was a
+	// successful visible response; schedule a nudge later on agent_settled.
+	let settledNudgeEligible = false;
 
 	function registerTodoToolWithCurrentPrompt(): void {
 		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
@@ -336,9 +326,6 @@ export default function (pi: ExtensionAPI) {
 		const delayMs = attempt === 0 ? TODO_NUDGE_INITIAL_DELAY_MS : TODO_NUDGE_IDLE_RETRY_DELAY_MS;
 		nudgeTimer = setTimeout(() => {
 			nudgeTimer = undefined;
-			// A retry-start signal may have arrived after the agent_end that
-			// scheduled this nudge. Bail out so we don't nudge mid-retry.
-			if (retryActive) return;
 			try {
 				activateTodoStateScope(ctx);
 				if (!ctx.isIdle()) {
@@ -358,9 +345,8 @@ export default function (pi: ExtensionAPI) {
 				if (nudge.signature === lastNudgedSignature) return;
 				lastNudgedSignature = nudge.signature;
 
-				// agent_end fires before Pi is fully back in idle dispatch. Sending as a
-				// normal user message on the next idle tick reliably starts a fresh turn;
-				// queueing followUp from inside agent_end can be too late to be drained.
+				// agent_settled means retries, compaction, and queued continuations are
+				// finished. Send on the next idle tick as a fresh turn.
 				pi.sendUserMessage(nudge.message);
 			} catch (err) {
 				if (isAgentBusyRaceError(err)) {
@@ -413,12 +399,6 @@ export default function (pi: ExtensionAPI) {
 		clearNudgeTimer();
 	});
 
-	pi.events.on(RETRY_ACTIVE_EVENT, (data: unknown) => {
-		const active = data != null && typeof data === "object" && (data as { active?: unknown }).active === true;
-		retryActive = active;
-		if (active) clearNudgeTimer();
-	});
-
 	pi.on("model_select", async (event) => {
 		currentModel = event.model;
 		if (todoThinkingEnabled) registerTodoToolWithCurrentPrompt();
@@ -439,7 +419,7 @@ export default function (pi: ExtensionAPI) {
 	pi.on("agent_start", async (_event, ctx) => {
 		activateTodoStateScope(ctx);
 		pendingAskUserToolCallIds.clear();
-		retryActive = false;
+		settledNudgeEligible = false;
 		inProgressAtAgentStart = new Set(selectVisibleTasks(getState()).filter((task) => task.status === "in_progress").map((task) => task.id));
 	});
 
@@ -455,26 +435,42 @@ export default function (pi: ExtensionAPI) {
 	pi.on("agent_end", async (event, ctx) => {
 		activateTodoStateScope(ctx);
 		const completedAssistantReply = hasCompletedAssistantReply((event as { messages?: readonly unknown[] } | undefined)?.messages);
+		settledNudgeEligible = completedAssistantReply;
 
 		if (suppressNextNudgeForThinkingSwitch) {
 			suppressNextNudgeForThinkingSwitch = false;
 			if (!completedAssistantReply) {
+				settledNudgeEligible = false;
 				clearNudgeTimer();
 				return;
 			}
 		}
 
 		if (pendingAskUserToolCallIds.size > 0) {
+			settledNudgeEligible = false;
 			clearNudgeTimer();
 			return;
 		}
 
 		if (completedAssistantReply && maybeRecoverCompletedCurrentTask((event as { messages?: readonly unknown[] } | undefined)?.messages, ctx)) {
+			settledNudgeEligible = false;
 			lastNudgedSignature = undefined;
 			clearNudgeTimer();
 			return;
 		}
+	});
 
+	pi.on("agent_settled", async (_event, ctx) => {
+		activateTodoStateScope(ctx);
+		if (!settledNudgeEligible) {
+			clearNudgeTimer();
+			return;
+		}
+		settledNudgeEligible = false;
+		if (pendingAskUserToolCallIds.size > 0) {
+			clearNudgeTimer();
+			return;
+		}
 		const nudge = getUnfinishedTodoNudge();
 		if (!nudge) {
 			lastNudgedSignature = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.56",
+  "version": "0.1.59",
   "private": false,
   "type": "module",
   "bin": {