@cydm/pie 2.7.11 → 2.7.12

package/dist/chunks/{chunk-XIRBNP2S.js → chunk-AFPRX5XI.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import {
   Agent,
   getToolCallerIdentity
-} from "./chunk-XVF6V6Q5.js";
+} from "./chunk-2NBUFVUQ.js";
 import {
   AssistantMessageEventStream,
   FileSystemGateway,
@@ -12,7 +12,7 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-3VEIP2VY.js";
+} from "./chunk-EN47TIBG.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -1003,7 +1003,7 @@ var PLAN_POWERSHELL_READ_COMMANDS = new Set([
 ].map((name) => name.toLowerCase()));
 var PLAN_POWERSHELL_READ_ALIASES = /* @__PURE__ */ new Set(["cat", "ls", "pwd", "echo", "sort"]);
 var PLAN_POWERSHELL_SAFE_PARAMETERS = /^(?:-(?:Raw|TotalCount|Head|Tail|First|Last|Wait|LiteralPath|Path|Name|Pattern|Recurse|Filter|Include|Exclude|SimpleMatch|CaseSensitive|Quiet|Word|Line|Character|Encoding|ErrorAction|WarningAction))$/i;
-var PLAN_POWERSHELL_SEPARATORS = /[;\n\r\t]|[<>]{1,2}|\||&&|\|\|/;
+var PLAN_POWERSHELL_SEPARATORS = /[;\n\r\t&<>|]/;
 var PLAN_POWERSHELL_NON_ASCII = /[^\x20-\x7E]/;
 var PLAN_POWERSHELL_UNSAFE_TOKENS = /\$\(|`|%\{|[(){}\[\]]|\bsource\b|\.\s+[/~]|\b(bash|sh|zsh|pwsh|powershell|cmd|npm|npx|node|python3?)\b/i;
 function isPlanModeSafePowerShellCommand(command) {
@@ -1331,7 +1331,9 @@ var DEFAULT_COMPACTION_CONFIG = {
   summaryPrefix: SUMMARY_PREFIX
 };
 var APPROX_BYTES_PER_TOKEN = 4;
-var RESIZED_IMAGE_BYTES_ESTIMATE = 7373;
+var IMAGE_MEDIA_BYTES_ESTIMATE = 7373;
+var AUDIO_MEDIA_BYTES_ESTIMATE = 6800;
+var VIDEO_MEDIA_BYTES_ESTIMATE = 16e3;
 function estimateTokens(message) {
   return approximateBytesAsTokens(estimateModelVisibleBytes(message));
 }
@@ -1456,20 +1458,16 @@ function planRetainedTail(summaries, options = {}) {
   if (boundaries.length === 0) {
     return nonePlan("no-boundary");
   }
-  const prefix = new Array(summaries.length + 1).fill(0);
-  for (let i = 0; i < summaries.length; i++) {
-    prefix[i + 1] = prefix[i] + Math.max(0, Math.floor(summaries[i].estTokens || 0));
-  }
   const groupEnd = boundaries.map((_, index) => boundaries[index + 1] ?? summaries.length);
   const planFrom = (startIndex, reason) => ({
     retainedTail: { kind: "from-entry", entryId: summaries[startIndex].id },
     entryIds: summaries.slice(startIndex).map((summary) => summary.id),
-    tailTokens: prefix[summaries.length] - prefix[startIndex],
+    tailTokens: estimateRetainedTailTokens(summaries, { kind: "from-entry", entryId: summaries[startIndex].id }),
     reason
   });
   let accumulated = 0;
   for (let k = boundaries.length - 1; k >= 0; k--) {
-    const groupTokens = prefix[groupEnd[k]] - prefix[boundaries[k]];
+    const groupTokens = summaries.slice(boundaries[k], groupEnd[k]).reduce((sum, summary) => sum + Math.max(0, Math.floor(summary.estTokens || 0)), 0);
     if (groupTokens > budget) {
       if (accumulated === 0) {
         return nonePlan("single-group-over-budget");
@@ -1545,6 +1543,9 @@ function estimateCompactionGain(params) {
   const tokensBefore = Math.max(0, params.tokensBefore);
   const tokenSavings = Math.max(0, tokensBefore - projectedTokens);
   const estimate = { summaryTokens, tailTokens, projectedTokens, tokenSavings };
+  if (!Number.isFinite(projectedTokens)) {
+    return { ...estimate, ok: false, reason: "retained context has unknown model-visible size; supply a compaction modelView" };
+  }
   if (params.budgetTokens !== void 0 && params.budgetTokens > 0 && projectedTokens > params.budgetTokens) {
     return {
       ...estimate,
@@ -1825,7 +1826,7 @@ function normalizeUserContentBlock(block) {
     return { type: "text", text: block.text };
   }
   if (block.type === "hostContext") {
-    return { type: "text", text: "x".repeat(512) };
+    return { type: "hostContext" };
   }
   if (block.type === "image") {
     return { type: "image", mimeType: block.mimeType };
@@ -1857,22 +1858,16 @@ function estimateMessageMediaBytes(message) {
 }
 function estimateUserContentBlockMediaBytes(block) {
   if (block.type === "image") {
-    return estimateImageContentBytes(block);
+    return IMAGE_MEDIA_BYTES_ESTIMATE;
   }
   if (block.type === "audio") {
-    return estimateInlineDataBytes(block);
+    return AUDIO_MEDIA_BYTES_ESTIMATE;
   }
   if (block.type === "video") {
-    return estimateInlineDataBytes(block);
+    return VIDEO_MEDIA_BYTES_ESTIMATE;
   }
   return 0;
 }
-function estimateImageContentBytes(block) {
-  return Math.max(RESIZED_IMAGE_BYTES_ESTIMATE, estimateInlineDataBytes(block));
-}
-function estimateInlineDataBytes(block) {
-  return utf8ByteLength(block.data || "");
-}
 function approximateBytesAsTokens(bytes) {
   return Math.ceil(bytes / APPROX_BYTES_PER_TOKEN);
 }
@@ -4623,10 +4618,26 @@ function prepareSessionCompaction(params) {
   const agentOnlyFailure = excludedFailure === null && requireExclusion ? agentTail ?? null : null;
   const summaries = sessionManager.getActiveContextSummaries();
   const entries = sessionManager.getResidentContextEntries();
-  const effectiveSummaries = excludedFailure ? summaries.filter((summary) => summary.id !== excludedFailure.entryId) : summaries;
+  const sourceSummaries = excludedFailure ? summaries.filter((summary) => summary.id !== excludedFailure.entryId) : summaries;
   const effectiveEntries = excludedFailure ? entries.filter((entry) => entry.id !== excludedFailure.entryId) : entries;
   const summaryInput = excludedFailure || agentOnlyFailure ? messages.slice(0, -1) : messages;
-  const inputTokens = calculateTotalTokens(summaryInput);
+  const estimates = /* @__PURE__ */ new Map();
+  const estimate = (message) => {
+    const cached = estimates.get(message);
+    if (cached !== void 0) return cached;
+    const visible = params.modelView ? params.modelView(message) : message;
+    const unknown = visible.role === "user" && Array.isArray(visible.content) && visible.content.some((block) => block.type === "hostContext");
+    const tokens = unknown ? Infinity : estimateTokens(visible);
+    estimates.set(message, tokens);
+    return tokens;
+  };
+  const bodies = new Map(effectiveEntries.map((entry) => [entry.id, entry]));
+  const effectiveSummaries = sourceSummaries.map((summary) => {
+    const entry = bodies.get(summary.id);
+    return { ...summary, estTokens: entry?.message ? estimate(entry.message) : summary.type === "message" ? Infinity : summary.estTokens };
+  });
+  const inputEstimate = summaryInput.reduce((sum, message) => sum + estimate(message), 0);
+  const inputTokens = Number.isFinite(inputEstimate) ? inputEstimate : calculateTotalTokens(summaryInput);
   const reductionLimit = inputTokens >= 1e3 ? inputTokens - Math.ceil(inputTokens * 0.1) : Infinity;
   const contextLimit = Math.min(
     reductionLimit,
@@ -4640,7 +4651,7 @@ function prepareSessionCompaction(params) {
   let planned = planRetainedTail(effectiveSummaries, { ...params.compactionConfig, keepRecentTokens: tailBudget });
   if (planned.retainedTail.kind !== "none") {
     const validation = validateRetainedTailEntries({ entries: effectiveEntries, retainedTail: planned.retainedTail });
-    planned = validation.ok ? { ...planned, entryIds: validation.entryIds, tailTokens: validation.tailTokens } : { retainedTail: { kind: "none" }, entryIds: [], tailTokens: 0, reason: "pairing" };
+    planned = validation.ok ? { ...planned, entryIds: validation.entryIds, tailTokens: estimateRetainedTailTokens(effectiveSummaries, planned.retainedTail) } : { retainedTail: { kind: "none" }, entryIds: [], tailTokens: 0, reason: "pairing" };
   }
   return {
     sessionId: sessionManager.getActiveSessionId(),
@@ -4696,7 +4707,7 @@ function verifyPreparedCompactionCommit(params) {
   const gain = estimateCompactionGain({
     summary: checkpointSummary,
     tailTokens: estimateRetainedTailTokens(params.preparation.summaries, retainedTail),
-    tokensBefore: params.result.tokensBefore ?? params.preparation.inputTokens,
+    tokensBefore: params.preparation.inputTokens,
     budgetTokens: params.preparation.budgetTokens
   });
   if (!gain.ok) {
@@ -5176,7 +5187,13 @@ async function preparePromptMessages(params) {
 
 // ../../packages/agent-framework/src/session/controller/pre-request-policy.ts
 async function runPreRequestAutoCompact(params) {
-  if (params.disposed || params.runtimeGuardTriggered || params.isStreaming || params.recoveryActive || params.agent.state.messages.length === 0) {
+  const boundary = params.toolContinuation;
+  const cancelled = () => params.isCurrent?.() === false || boundary?.signal.aborted === true;
+  if (boundary) {
+    await boundary.sync();
+    if (cancelled()) return;
+  }
+  if (params.disposed || params.runtimeGuardTriggered || params.isStreaming && !boundary || params.recoveryActive() || params.agent.state.messages.length === 0) {
     return;
   }
   const decision = params.getAutoCompactDecision?.({
@@ -5185,12 +5202,13 @@ async function runPreRequestAutoCompact(params) {
     cwd: params.cwd,
     messages: params.agent.state.messages.slice()
   });
-  if (decision?.reason !== "threshold") {
+  if (cancelled() || decision?.reason !== "threshold") {
     return;
   }
   try {
     await params.runAutoCompact();
-  } catch {
+  } catch (error) {
+    if (boundary) throw error;
     if (params.isCurrent?.() !== false) params.setRecoveryState("none");
   }
 }
@@ -5444,12 +5462,7 @@ var AgentSessionQueueDispatcher = class {
       return false;
     }
     this.options.emit({ type: "queued_turn_dispatched", queuedInput: cloneQueuedInput(dispatched) });
-    if (dispatched.deliveredToAgent || this.options.agent.state.messages.at(-1)?.role === "assistant") {
-      if (!dispatched.deliveredToAgent) {
-        this.options.queue.deliverToAgent(dispatched);
-      }
-      await this.options.continueTurn();
-    } else {
+    if (!dispatched.deliveredToAgent) {
       const prepared = await this.options.preparePromptMessages(dispatched.messages, {
         source: dispatched.source,
         streamingBehavior: dispatched.mode,
@@ -5459,13 +5472,20 @@ var AgentSessionQueueDispatcher = class {
         visibility: dispatched.visibility
       });
       if (generation !== this.generation) return false;
-      if (!prepared.handled) {
-        if (prepared.systemPrompt !== void 0) {
-          this.options.agent.setSystemPrompt(prepared.systemPrompt);
-        }
-        await this.options.agent.prompt(prepared.messages);
-        await this.options.syncNewAgentMessages();
+      if (prepared.handled) return true;
+      if (prepared.systemPrompt !== void 0) {
+        this.options.agent.setSystemPrompt(prepared.systemPrompt);
+      }
+      dispatched.messages = prepared.messages;
+    }
+    if (dispatched.deliveredToAgent || this.options.agent.state.messages.at(-1)?.role === "assistant") {
+      if (!dispatched.deliveredToAgent) {
+        this.options.queue.deliverToAgent(dispatched);
       }
+      await this.options.continueTurn();
+    } else {
+      await this.options.agent.prompt(dispatched.messages);
+      await this.options.syncNewAgentMessages();
     }
     return true;
   }
@@ -5586,6 +5606,95 @@ var ReplayStallCircuit = class {
   }
 };
 
+// ../../packages/agent-framework/src/session/controller/retry-decision.ts
+function getAgentSessionRetryLimit(retry, failure) {
+  return Math.min(
+    (failure !== void 0 ? retry?.maxRetriesForFailure?.(failure) : void 0) ?? retry?.maxRetries ?? 3,
+    failure?.kind === "provider_confirmation" ? 1 : Infinity
+  );
+}
+var AgentSessionRetryEpisode = class {
+  constructor(retry) {
+    this.retry = retry;
+    this.replayCircuit = new ReplayStallCircuit(retry?.systemicReplayStallLimit);
+  }
+  retry;
+  retryAttempts = /* @__PURE__ */ new Map();
+  total = 0;
+  replayCircuit;
+  get totalRetryAttempts() {
+    return this.total;
+  }
+  /** A healthy response ends the current episode and proves endpoint liveness. */
+  succeed() {
+    this.replayCircuit.recordHealthyTurn();
+    const attempts = this.total;
+    this.resetAttempts();
+    return attempts;
+  }
+  /** Cancellation/invalidation resets counters, never the endpoint-health circuit. */
+  resetAttempts() {
+    this.retryAttempts.clear();
+    this.total = 0;
+  }
+  next(failure) {
+    if (!this.retry || !failure.retryable) {
+      if (failure.kind !== "unknown" && failure.kind !== "internal_error") {
+        this.replayCircuit.recordHealthyTurn();
+      }
+      const totalRetryAttempts2 = this.total;
+      this.resetAttempts();
+      return { action: "terminal", failure, totalRetryAttempts: totalRetryAttempts2 };
+    }
+    if (failure.replayExempt === true && this.replayCircuit.isOpen) {
+      const openFailure = asTerminalFailure(
+        failure,
+        `${failure.message} (replay circuit open: ${this.replayCircuit.consecutiveTurnStalls} consecutive turns ended by timeout-replay exhaustion)`
+      );
+      const totalRetryAttempts2 = this.total;
+      this.resetAttempts();
+      return { action: "exhausted", failure: openFailure, maxRetries: 0, totalRetryAttempts: totalRetryAttempts2, reason: "circuit_open" };
+    }
+    const maxRetries = getAgentSessionRetryLimit(this.retry, failure);
+    const kindAttempts = (this.retryAttempts.get(failure.kind) ?? 0) + 1;
+    this.retryAttempts.set(failure.kind, kindAttempts);
+    this.total += 1;
+    const totalRetryAttempts = this.total;
+    const totalBudget = this.retry.maxTotalRetries;
+    const kindExhausted = kindAttempts > maxRetries;
+    const totalExhausted = totalBudget !== void 0 && totalRetryAttempts > totalBudget;
+    const delayMs = resolveRetryDelay(
+      (this.retry.baseDelayMs ?? 2e3) * 2 ** (kindAttempts - 1),
+      this.retry.maxDelayMs,
+      failure.retryAfterMs
+    );
+    if (kindExhausted || totalExhausted || delayMs === void 0) {
+      const terminalFailure = asTerminalFailure(
+        failure,
+        delayMs === void 0 ? `${failure.message} (Retry-After exceeds the allowed wait; automatic recovery paused)` : failure.message
+      );
+      const circuit = failure.replayExempt === true ? this.replayCircuit.recordReplayExhaustion() : void 0;
+      this.resetAttempts();
+      return {
+        action: "exhausted",
+        failure: terminalFailure,
+        maxRetries: totalExhausted ? totalBudget : maxRetries,
+        totalRetryAttempts,
+        reason: delayMs === void 0 ? "retry_after" : totalExhausted ? "total_budget" : "kind_budget",
+        ...circuit ? { circuit } : {}
+      };
+    }
+    return {
+      action: "retry",
+      failure,
+      attempt: kindAttempts,
+      maxRetries,
+      delayMs,
+      totalRetryAttempts
+    };
+  }
+};
+
 // ../../packages/agent-framework/src/session/controller/retry-policy.ts
 function defaultSetTimeout4(callback, delay) {
   return setTimeout(callback, delay);
@@ -5600,21 +5709,14 @@ var AgentSessionRetryController = class {
     this.removeTrailingAssistantError = removeTrailingAssistantError2;
     this.continueTurn = continueTurn;
     this.setRecoveryState = setRecoveryState;
-    this.replayCircuit = new ReplayStallCircuit(retry?.systemicReplayStallLimit);
+    this.episode = new AgentSessionRetryEpisode(retry);
   }
   retry;
   emit;
   removeTrailingAssistantError;
   continueTurn;
   setRecoveryState;
-  /** Attempts consumed per failure KIND: budgets are granted per kind (a
-   *  10-attempt network budget must not be eaten by interleaved provider
-   *  errors, and vice versa), so each kind counts its own attempts. */
-  retryAttempts = /* @__PURE__ */ new Map();
-  /** Total attempts across kinds in this recovery episode, for reporting. */
-  totalRetryAttempts = 0;
-  /** L2 systemic-stall circuit (see replay-stall-circuit.ts). */
-  replayCircuit;
+  episode;
   retryTimer;
   retryEpoch = 0;
   pendingRetry;
@@ -5628,72 +5730,45 @@ var AgentSessionRetryController = class {
   waitForRetry() {
     return this.pendingRetry ?? Promise.resolve();
   }
-  /** L2 circuit: healthy turn (success or an actively-answered failure). */
-  noteEndpointHealthy() {
-    this.replayCircuit.recordHealthyTurn();
-  }
   async handleTurnEnd(message, failure) {
     if (!this.retry || !message || message.role !== "assistant") {
       this.settleStrandedRetry(failure);
       return;
     }
     if (!failure) {
-      this.noteEndpointHealthy();
-      if (this.totalRetryAttempts > 0) {
-        this.emit({ type: "retry_succeeded", attempts: this.totalRetryAttempts });
-        this.emit({ type: "turn_retry_succeeded", attempts: this.totalRetryAttempts });
-        this.resetAttempts();
+      const attempts = this.episode.succeed();
+      if (attempts > 0) {
+        this.emit({ type: "retry_succeeded", attempts });
+        this.emit({ type: "turn_retry_succeeded", attempts });
         this.setRecoveryState("none");
         this.resolvePending();
       }
       return;
     }
-    if (!failure.retryable) {
-      if (failure.kind !== "unknown" && failure.kind !== "internal_error") {
-        this.noteEndpointHealthy();
-      }
-      if (this.totalRetryAttempts > 0) {
-        this.resetAttempts();
+    const decision = this.episode.next(failure);
+    if (decision.action === "terminal") {
+      if (decision.totalRetryAttempts > 0) {
         this.setRecoveryState("none");
         this.resolvePending();
       }
       return;
     }
-    if (failure.replayExempt === true && this.replayCircuit.isOpen) {
-      const openFailure = asTerminalFailure(failure, `${failure.message} (replay circuit open: ${this.replayCircuit.consecutiveTurnStalls} consecutive turns ended by timeout-replay exhaustion)`);
-      this.emit({ type: "retry_exhausted", errorMessage: openFailure.message, maxRetries: 0 });
-      this.emit({ type: "turn_failed_terminal", failure: openFailure, message });
-      this.emit({ type: "turn_settled" });
-      this.resetAttempts();
-      this.setRecoveryState("terminal");
-      this.resolvePending();
-      return;
-    }
-    const maxRetries = Math.min(this.retry.maxRetriesForFailure?.(failure) ?? this.retry.maxRetries ?? 3, failure.kind === "provider_confirmation" ? 1 : Infinity);
-    const kindAttempts = (this.retryAttempts.get(failure.kind) ?? 0) + 1;
-    this.retryAttempts.set(failure.kind, kindAttempts);
-    this.totalRetryAttempts += 1;
-    const totalBudget = this.retry.maxTotalRetries;
-    const kindExhausted = kindAttempts > maxRetries;
-    const totalExhausted = totalBudget !== void 0 && this.totalRetryAttempts > totalBudget;
-    const delayMs = resolveRetryDelay((this.retry.baseDelayMs ?? 2e3) * 2 ** (kindAttempts - 1), this.retry.maxDelayMs, failure.retryAfterMs);
-    if (kindExhausted || totalExhausted || delayMs === void 0) {
-      const terminalFailure = asTerminalFailure(failure, delayMs === void 0 ? `${failure.message} (Retry-After exceeds the allowed wait; automatic recovery paused)` : failure.message);
-      if (failure.replayExempt === true) {
-        const outcome = this.replayCircuit.recordReplayExhaustion();
-        if (outcome.opened) {
-          this.emit({ type: "retry_exhausted", errorMessage: `systemic timeout-stall: ${outcome.consecutive} consecutive turns ended by timeout-replay exhaustion`, maxRetries: totalExhausted ? totalBudget : maxRetries });
-        }
+    if (decision.action === "exhausted") {
+      if (decision.circuit?.opened) {
+        this.emit({
+          type: "retry_exhausted",
+          errorMessage: `systemic timeout-stall: ${decision.circuit.consecutive} consecutive turns ended by timeout-replay exhaustion`,
+          maxRetries: decision.maxRetries
+        });
       }
-      this.emit({ type: "retry_exhausted", errorMessage: terminalFailure.message, maxRetries: totalExhausted ? totalBudget : maxRetries });
-      this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
+      this.emit({ type: "retry_exhausted", errorMessage: decision.failure.message, maxRetries: decision.maxRetries });
+      this.emit({ type: "turn_failed_terminal", failure: decision.failure, message });
       this.emit({ type: "turn_settled" });
-      this.resetAttempts();
       this.setRecoveryState("terminal");
       this.resolvePending();
       return;
     }
-    const attempt = kindAttempts;
+    const { attempt, maxRetries, delayMs } = decision;
     this.ensurePending();
     const epoch = this.retryEpoch;
     const pending = this.pendingRetry;
@@ -5720,7 +5795,7 @@ var AgentSessionRetryController = class {
         this.emit({ type: "retry_exhausted", errorMessage, maxRetries });
         this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
         this.emit({ type: "turn_settled" });
-        this.resetAttempts();
+        this.episode.resetAttempts();
         this.setRecoveryState("terminal");
         this.resolvePending(pending);
       });
@@ -5745,24 +5820,20 @@ var AgentSessionRetryController = class {
       userAbort: false,
       terminal: true
     });
-    const maxRetries = Math.min((failure !== void 0 ? this.retry?.maxRetriesForFailure?.(failure) : void 0) ?? this.retry?.maxRetries ?? 3, failure?.kind === "provider_confirmation" ? 1 : Infinity);
+    const maxRetries = getAgentSessionRetryLimit(this.retry, failure);
     this.emit({ type: "retry_exhausted", errorMessage: terminalFailure.message, maxRetries });
     this.emit({ type: "turn_failed_terminal", failure: terminalFailure });
     this.emit({ type: "turn_settled" });
-    this.resetAttempts();
+    this.episode.resetAttempts();
     this.setRecoveryState("terminal");
     this.resolvePending();
   }
   cancel() {
     this.retryEpoch++;
     this.cancelTimerOnly();
-    this.resetAttempts();
+    this.episode.resetAttempts();
     this.resolvePending();
   }
-  resetAttempts() {
-    this.retryAttempts.clear();
-    this.totalRetryAttempts = 0;
-  }
   cancelTimerOnly() {
     if (this.retryTimer === void 0) {
       return;
@@ -6101,7 +6172,8 @@ async function runAgentSessionCompaction(params) {
     const preparation = prepareSessionCompaction({
       sessionManager: params.sessionManager,
       messages: params.agent.state.messages,
-      budgetTokens: params.compactionBudgetTokens?.()
+      budgetTokens: params.compactionBudgetTokens?.(),
+      modelView: params.compaction.modelView
     });
     let result = await params.compaction.compact({
       reason: params.reason,
@@ -6380,6 +6452,8 @@ var AgentSessionController = class {
   autoContinue;
   unsubscribeAgent;
   unsubscribeSemantic;
+  unsubscribeToolContinuation;
+  compactionOwner;
   lastSyncedMessageCount = 0;
   disposed = false;
   transitioning = false;
@@ -6483,6 +6557,7 @@ var AgentSessionController = class {
     });
     this.syncFromActiveSession();
     this.unsubscribeAgent = this.agent.subscribe((event) => this.handleAgentEvent(event));
+    this.unsubscribeToolContinuation = this.agent.setBeforeToolContinuation((signal) => this.runPreRequestAutoCompactIfNeeded(signal));
     this.unsubscribeSemantic = this.agent.subscribeSemantic((event) => {
       this.emit({ type: "semantic_event", event });
     });
@@ -6533,6 +6608,7 @@ var AgentSessionController = class {
     this.transitioning = true;
     try {
       this.generation++;
+      if (this.isStreaming) this.agent.resetProcessingState();
       this.cancelScheduledWork();
       this.recoveryState = "none";
       this.pendingCompactionFailure = void 0;
@@ -6664,48 +6740,61 @@ var AgentSessionController = class {
     const generation = this.generation;
     if (this.disposed || this.transitioning) throw new Error("Controller disposed or transitioning");
     const isCurrent = () => generation === this.generation && !this.disposed;
-    return this.convergence.run(() => runAgentSessionControllerAutoCompact({
-      isCurrent,
-      reason,
-      willRetry,
-      signal: options?.signal,
-      compaction: this.compaction,
-      agent: this.agent,
-      sessionManager: this.sessionManager,
-      cwd: this.cwd,
-      pendingFailure: this.pendingCompactionFailure,
-      emit: (event) => {
-        if (isCurrent()) this.emit(event);
-      },
-      setRecoveryState: (state) => {
-        this.recoveryState = state;
-      },
-      getRecoveryState: () => this.recoveryState,
-      getDisposed: () => this.disposed,
-      cancelRetry: () => this.retryController.cancel(),
-      clearPendingFailure: () => {
-        this.pendingCompactionFailure = void 0;
-      },
-      getCompactionBudgetTokens: this.compactionSettings.getCompactionBudgetTokens,
-      removeTrailingAssistantError: () => this.removeTrailingAssistantError(),
-      replaceMessagesAndMarkSynced: (messages) => this.replaceMessagesAndMarkSynced(messages),
-      markSyncedToAgentState: () => this.markSyncedToAgentState(),
-      continueTurn: () => this.continue(),
-      handleAgentEndHook: (messages) => this.handleAgentEndHook(messages),
-      emitSettled: options?.emitSettled,
-      runAfterAgentEndHook: options?.runAfterAgentEndHook,
-      cancelOnAbort: options?.cancelOnAbort
-    }));
+    if (this.compactionOwner) throw new Error("Compaction already running");
+    const owner = this.compactionOwner = {};
+    try {
+      return await this.convergence.run(() => runAgentSessionControllerAutoCompact({
+        isCurrent,
+        reason,
+        willRetry,
+        signal: options?.signal,
+        compaction: this.compaction,
+        agent: this.agent,
+        sessionManager: this.sessionManager,
+        cwd: this.cwd,
+        pendingFailure: this.pendingCompactionFailure,
+        emit: (event) => {
+          if (isCurrent()) this.emit(event);
+        },
+        setRecoveryState: (state) => {
+          this.recoveryState = state;
+        },
+        getRecoveryState: () => this.recoveryState,
+        getDisposed: () => this.disposed,
+        cancelRetry: () => this.retryController.cancel(),
+        clearPendingFailure: () => {
+          this.pendingCompactionFailure = void 0;
+        },
+        getCompactionBudgetTokens: this.compactionSettings.getCompactionBudgetTokens,
+        removeTrailingAssistantError: () => this.removeTrailingAssistantError(),
+        replaceMessagesAndMarkSynced: (messages) => this.replaceMessagesAndMarkSynced(messages),
+        markSyncedToAgentState: () => this.markSyncedToAgentState(),
+        continueTurn: async () => {
+          if (!isCurrent() || options?.signal?.aborted) return;
+          if (this.compactionOwner === owner) this.compactionOwner = void 0;
+          this.recoveryState = "none";
+          await this.continue();
+        },
+        handleAgentEndHook: (messages) => this.handleAgentEndHook(messages),
+        emitSettled: options?.emitSettled,
+        runAfterAgentEndHook: options?.runAfterAgentEndHook,
+        cancelOnAbort: options?.cancelOnAbort
+      }));
+    } finally {
+      if (this.compactionOwner === owner) this.compactionOwner = void 0;
+    }
   }
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    if (this.isStreaming) this.agent.resetProcessingState();
     this.agent.releaseTransport?.();
     this.generation++;
     this.pendingEndOperations.clear();
     this.cancelScheduledWork();
     this.unsubscribeAgent?.();
     this.unsubscribeSemantic?.();
+    this.unsubscribeToolContinuation?.();
     this.queue.clear();
     this.convergence.invalidate("dispose");
     this.listeners.clear();
@@ -6729,19 +6818,26 @@ var AgentSessionController = class {
       });
     }
   }
-  async runPreRequestAutoCompactIfNeeded() {
+  async runPreRequestAutoCompactIfNeeded(signal) {
     const generation = this.generation;
     return runPreRequestAutoCompact({
       isCurrent: () => generation === this.generation && !this.disposed,
       disposed: this.disposed,
       runtimeGuardTriggered: this.runtimeGuard.triggered,
       isStreaming: this.isStreaming,
-      recoveryActive: this.isRecoveryActive(),
+      recoveryActive: () => this.isRecoveryActive(),
       agent: this.agent,
       sessionManager: this.sessionManager,
       cwd: this.cwd,
       getAutoCompactDecision: this.compactionSettings.getAutoCompactDecision,
-      runAutoCompact: () => this.runAutoCompact("threshold", false, { emitSettled: false, runAfterAgentEndHook: false, cancelOnAbort: false }).then(() => void 0),
+      toolContinuation: signal ? { signal, sync: async () => {
+        await this.pendingEndOperations.wait();
+        if (generation === this.generation && !this.disposed && !signal.aborted) await this.syncNewAgentMessages();
+      } } : void 0,
+      runAutoCompact: async () => {
+        const result = await this.runAutoCompact("threshold", false, { signal, emitSettled: false, runAfterAgentEndHook: false, cancelOnAbort: false });
+        if (signal && (!result || result.aborted)) throw new Error("Tool-continuation compaction was aborted");
+      },
       setRecoveryState: (state) => {
         this.recoveryState = state;
       }
@@ -6886,6 +6982,7 @@ var AgentSessionController = class {
     return this.recoveryState !== "none" || this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact;
   }
   cancelScheduledWork() {
+    this.compactionOwner = void 0;
     this.retryController.cancel();
     this.autoCompact.cancel();
     this.queueDispatcher.cancel();
@@ -8241,6 +8338,9 @@ function withSubagentRunContext(stream, hooks) {
 ${SUBAGENT_FINALIZATION_HINT}` } : context, options);
   };
 }
+function isRetryableSubagentFailure(message) {
+  return isRetryableSubagentFailureFrom({ errorMessage: message });
+}
 function isRetryableSubagentFailureFrom(facts) {
   if (facts.retryable === false) return false;
   if (facts.replayClass === "stream_lost" || facts.replayClass === "stream_lost_partial") return true;
@@ -8262,90 +8362,366 @@ function cancellableBackoff(ms, signal) {
     if (signal?.aborted) finish();
   });
 }
+function factsFromMessage(message) {
+  return {
+    errorMessage: message.errorMessage,
+    retryable: message.retryable,
+    replayClass: message.replayClass,
+    replayEligible: message.replayEligible,
+    remoteFailure: message.remoteFailure,
+    stopReason: message.stopReason
+  };
+}
 function factsOf(error) {
   if (error instanceof Error) {
     const carrier = error;
-    return { errorMessage: error.message, retryable: carrier.retryable, replayClass: carrier.replayClass };
+    return {
+      errorMessage: carrier.subagentFailure?.errorMessage ?? error.message,
+      retryable: carrier.subagentFailure?.retryable ?? carrier.retryable,
+      replayClass: carrier.subagentFailure?.replayClass ?? carrier.replayClass,
+      replayEligible: carrier.subagentFailure?.replayEligible ?? carrier.replayEligible,
+      remoteFailure: carrier.subagentFailure?.remoteFailure ?? carrier.remoteFailure,
+      stopReason: carrier.subagentFailure?.stopReason ?? carrier.stopReason ?? (carrier.subagentFailure?.classification?.userAbort ? "aborted" : "error")
+    };
   }
-  return { errorMessage: String(error) };
+  return { errorMessage: String(error), stopReason: "error" };
 }
-function withSubagentResponseRecovery(stream, backoffMs = 2e3, onRetry, onActivity, hooks) {
+function assistantFromFacts(facts) {
+  return {
+    role: "assistant",
+    api: "unknown",
+    provider: "unknown",
+    model: "unknown",
+    content: [],
+    timestamp: 0,
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    stopReason: facts.stopReason ?? "error",
+    errorMessage: facts.errorMessage,
+    ...facts.retryable !== void 0 ? { retryable: facts.retryable } : {},
+    ...facts.replayClass !== void 0 ? { replayClass: facts.replayClass } : {},
+    ...facts.replayEligible !== void 0 ? { replayEligible: facts.replayEligible } : {},
+    ...facts.remoteFailure !== void 0 ? { remoteFailure: facts.remoteFailure } : {}
+  };
+}
+function boundedClassification(failure) {
+  return { ...failure, message: failure.message.slice(0, 2e3) };
+}
+function failureDetails(facts, classification, recovery) {
+  return {
+    errorMessage: (classification.message || facts.errorMessage || "Subagent response failed").slice(0, 2e3),
+    ...facts.retryable !== void 0 ? { retryable: facts.retryable } : {},
+    ...facts.replayClass !== void 0 ? { replayClass: facts.replayClass } : {},
+    ...facts.replayEligible !== void 0 ? { replayEligible: facts.replayEligible } : {},
+    ...facts.remoteFailure !== void 0 ? {
+      remoteFailure: {
+        category: facts.remoteFailure.category,
+        ...typeof facts.remoteFailure.retryAfterMs === "number" && Number.isFinite(facts.remoteFailure.retryAfterMs) && facts.remoteFailure.retryAfterMs >= 0 ? { retryAfterMs: facts.remoteFailure.retryAfterMs } : {}
+      }
+    } : {},
+    ...facts.stopReason === "aborted" ? { stopReason: facts.stopReason } : {},
+    classification: boundedClassification(classification),
+    recovery
+  };
+}
+function legacyRecovery(backoffMs) {
+  return {
+    policy: {
+      isRetryableError: (message) => isRetryableSubagentFailure(message),
+      maxRetries: 2,
+      baseDelayMs: backoffMs
+    },
+    classifyFailure: (context) => {
+      const facts = context.message?.role === "assistant" ? factsFromMessage(context.message) : { errorMessage: context.errorMessage, stopReason: "error" };
+      const retryable = isRetryableSubagentFailureFrom({ ...facts, errorMessage: context.errorMessage });
+      return {
+        kind: retryable ? "provider_transient" : "unknown",
+        retryable,
+        compactable: false,
+        userAbort: false,
+        terminal: !retryable,
+        message: context.errorMessage
+      };
+    }
+  };
+}
+function resolveRecovery(options, backoffMs) {
+  if (!options) return legacyRecovery(backoffMs);
+  const fallback = legacyRecovery(backoffMs);
+  return {
+    policy: options.policy ?? fallback.policy,
+    // An explicitly supplied policy without a classifier must reach its own
+    // isRetryableError predicate, exactly as in the main controller. Only the
+    // no-host compatible default installs the legacy prose classifier.
+    classifyFailure: options.classifyFailure ?? (options.policy ? void 0 : fallback.classifyFailure)
+  };
+}
+function classify(facts, recovery) {
+  const message = assistantFromFacts(facts);
+  return createFailureClassification({
+    message,
+    errorMessage: facts.errorMessage ?? "Subagent response failed",
+    phase: "stream"
+  }, recovery.policy, recovery.classifyFailure);
+}
+var DEFAULT_ITERATOR_CLEANUP_MS = 2e3;
+async function closeIterator(iterator, hooks, signal) {
+  const cleanup = Promise.resolve().then(() => iterator.return?.()).then(() => void 0).catch(() => void 0);
+  const remaining = hooks?.hardDeadlineAt === void 0 ? DEFAULT_ITERATOR_CLEANUP_MS : Math.max(0, hooks.hardDeadlineAt - Date.now());
+  const waitMs = Math.min(DEFAULT_ITERATOR_CLEANUP_MS, remaining);
+  if (waitMs <= 0 || signal?.aborted) return;
+  let timer;
+  let onAbort;
+  try {
+    await Promise.race([
+      cleanup,
+      new Promise((resolve2) => {
+        timer = setTimeout(resolve2, waitMs);
+        onAbort = () => resolve2();
+        signal?.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
+  }
+}
+function singleResponse(message) {
+  const result = new AssistantMessageEventStream();
+  if (message.stopReason === "error" || message.stopReason === "aborted") {
+    result.push({ type: "error", reason: message.stopReason, error: { ...message, content: [] } });
+  } else {
+    result.push({ type: "done", reason: message.stopReason, message });
+  }
+  result.end();
+  return result;
+}
+function throwWithDetails(error, details) {
+  const failure = new Error(details.classification?.message ?? (error instanceof Error ? error.message : String(error)));
+  failure.cause = error;
+  failure.subagentFailure = details;
+  throw failure;
+}
+function withSubagentResponseRecovery(stream, backoffMs = 2e3, onRetry, onActivity, hooks, recoveryOptions) {
+  const recovery = resolveRecovery(recoveryOptions, backoffMs);
+  const episode = recoveryOptions?.episode ?? hooks?.recoveryEpisode ?? new AgentSessionRetryEpisode(recovery.policy);
+  if (hooks) hooks.recoveryEpisode = episode;
   return async (model, context, options) => {
-    for (let attempt = 0; ; attempt++) {
-      if (hooks) {
-        hooks.terminalText = void 0;
-        hooks.terminalStopReason = void 0;
-      }
-      if (options?.signal?.aborted) throw new Error("Subagent aborted by parent");
-      if (hooks?.hardDeadlineAt !== void 0 && Date.now() >= hooks.hardDeadlineAt) throw new Error("Subagent hard deadline reached");
-      let message;
-      const finishUsage = hooks?.usage ? beginSubagentUsage(hooks.usage, model) : void 0;
-      try {
-        const response = await stream(model, context, options);
-        let terminal;
-        const iterator = response[Symbol.asyncIterator]();
+    let attempts = 0;
+    let retries = 0;
+    if (hooks) hooks.failure = void 0;
+    try {
+      for (; ; ) {
+        if (hooks) {
+          hooks.terminalText = void 0;
+          hooks.terminalStopReason = void 0;
+        }
+        if (options?.signal?.aborted) {
+          episode.resetAttempts();
+          throw new Error("Subagent aborted by parent");
+        }
+        if (hooks?.hardDeadlineAt !== void 0 && Date.now() >= hooks.hardDeadlineAt) throw new Error("Subagent hard deadline reached");
+        let message;
+        const finishUsage = hooks?.usage ? beginSubagentUsage(hooks.usage, model) : void 0;
+        attempts += 1;
         try {
-          while (true) {
-            const next = await iterator.next();
-            if (next.done) break;
-            try {
-              onActivity?.(next.value.type);
-            } catch {
-            }
-            if (next.value.type === "done") {
-              terminal = next.value.message;
-              finishUsage?.(terminal);
-            }
-            if (next.value.type === "error") {
-              terminal = next.value.error;
-              finishUsage?.(terminal);
-            }
-            if (hooks && (next.value.type === "done" || next.value.type === "error")) {
-              const reportTerminal = terminal && ["stop", "length", "error", "aborted"].includes(terminal.stopReason) && !terminal.content.some((block) => block.type === "toolCall");
-              hooks.terminalStopReason = reportTerminal && terminal ? terminal.stopReason : void 0;
-              hooks.terminalText = reportTerminal && terminal ? terminal.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").slice(0, 24001) : void 0;
+          const response = await stream(model, context, options);
+          let terminal;
+          const iterator = response[Symbol.asyncIterator]();
+          try {
+            for (; ; ) {
+              const next = await iterator.next();
+              if (next.done) break;
+              try {
+                onActivity?.(next.value.type);
+              } catch {
+              }
+              if (next.value.type === "done") {
+                terminal = next.value.message;
+                finishUsage?.(terminal);
+              }
+              if (next.value.type === "error") {
+                terminal = next.value.error;
+                finishUsage?.(terminal);
+              }
+              if (next.value.type === "done" || next.value.type === "error") {
+                if (hooks && terminal) {
+                  const reportTerminal = ["stop", "length", "error", "aborted"].includes(terminal.stopReason) && !terminal.content.some((block) => block.type === "toolCall");
+                  hooks.terminalStopReason = reportTerminal ? terminal.stopReason : void 0;
+                  hooks.terminalText = reportTerminal ? terminal.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").slice(0, 24001) : void 0;
+                }
+                break;
+              }
             }
+          } finally {
+            await closeIterator(iterator, hooks, options?.signal);
           }
-        } finally {
-          try {
-            await iterator.return?.();
-          } catch {
+          if (!terminal) throw new Error("Provider protocol error: response ended without a terminal event");
+          message = terminal;
+        } catch (error) {
+          finishUsage?.();
+          if (options?.signal?.aborted) {
+            episode.resetAttempts();
+            throw error;
           }
-        }
-        if (!terminal) throw new Error("Provider protocol error: response ended without a terminal event");
-        message = terminal;
-      } catch (error) {
-        finishUsage?.();
-        if (!options?.signal?.aborted && attempt < 2 && isRetryableSubagentFailureFrom(factsOf(error))) {
-          try {
-            onRetry?.();
-          } catch {
+          const facts2 = factsOf(error);
+          if (facts2.stopReason === "aborted") {
+            episode.resetAttempts();
+            const classification3 = {
+              kind: "user_abort",
+              retryable: false,
+              compactable: false,
+              userAbort: true,
+              terminal: true,
+              message: facts2.errorMessage ?? "Subagent aborted"
+            };
+            const details = failureDetails(facts2, classification3, { outcome: "terminal", attempts, retries, reason: "cancelled" });
+            if (hooks) hooks.failure = details;
+            throwWithDetails(error, details);
           }
-          await cancellableBackoff(backoffMs * (attempt + 1), options?.signal);
-          continue;
+          const classification2 = classify(facts2, recovery);
+          const failure2 = await resolveFailure({
+            facts: facts2,
+            classification: classification2,
+            attempts,
+            retries,
+            episode,
+            hooks,
+            onRetry,
+            options
+          });
+          if (failure2.retry) {
+            retries += 1;
+            continue;
+          }
+          throwWithDetails(error, failure2.details);
         }
-        throw error;
-      }
-      if (options?.signal?.aborted) throw new Error("Subagent aborted by parent");
-      if (message.stopReason === "error" && attempt < 2 && isRetryableSubagentFailureFrom({ errorMessage: message.errorMessage, retryable: message.retryable, replayClass: message.replayClass })) {
-        try {
-          onRetry?.();
-        } catch {
+        if (options?.signal?.aborted) {
+          episode.resetAttempts();
+          throw new Error("Subagent aborted by parent");
         }
-        await cancellableBackoff(backoffMs * (attempt + 1), options?.signal);
-        continue;
-      }
-      const result = new AssistantMessageEventStream();
-      if (message.stopReason === "error" || message.stopReason === "aborted") {
-        result.push({ type: "error", reason: message.stopReason, error: { ...message, content: [] } });
-      } else {
-        result.push({ type: "done", reason: message.stopReason, message });
+        if (hooks?.hardDeadlineAt !== void 0 && Date.now() >= hooks.hardDeadlineAt) {
+          episode.resetAttempts();
+          throw new Error("Subagent hard deadline reached");
+        }
+        if (message.stopReason !== "error" && message.stopReason !== "aborted") {
+          episode.succeed();
+          if (hooks) hooks.failure = void 0;
+          return singleResponse(message);
+        }
+        if (message.stopReason === "aborted") {
+          episode.resetAttempts();
+          if (hooks) hooks.failure = void 0;
+          return singleResponse(message);
+        }
+        const facts = factsFromMessage(message);
+        const classification = classify(facts, recovery);
+        const failure = await resolveFailure({
+          facts,
+          classification,
+          attempts,
+          retries,
+          episode,
+          hooks,
+          onRetry,
+          options
+        });
+        if (failure.retry) {
+          retries += 1;
+          continue;
+        }
+        const finalMessage = failure.details.classification?.message && failure.details.classification.message !== message.errorMessage ? { ...message, errorMessage: failure.details.classification.message } : message;
+        return singleResponse(finalMessage);
       }
-      result.end();
-      return result;
+    } finally {
+      episode.resetAttempts();
     }
   };
 }
+async function resolveFailure(params) {
+  const { facts, classification, attempts, retries, episode, hooks, onRetry, options } = params;
+  if (options?.signal?.aborted) {
+    episode.resetAttempts();
+    throw new Error("Subagent aborted by parent");
+  }
+  if (classification.userAbort) {
+    episode.resetAttempts();
+    const cancellation = {
+      ...classification,
+      kind: "user_abort",
+      retryable: false,
+      compactable: false,
+      userAbort: true,
+      terminal: true
+    };
+    const details2 = failureDetails({ ...facts, stopReason: "aborted" }, cancellation, {
+      outcome: "terminal",
+      attempts,
+      retries,
+      reason: "cancelled"
+    });
+    if (hooks) hooks.failure = details2;
+    return { retry: false, details: details2 };
+  }
+  if (classification.compactable) {
+    const details2 = failureDetails(facts, classification, {
+      outcome: "overflow",
+      attempts,
+      retries,
+      reason: "compaction_unavailable"
+    });
+    if (hooks) hooks.failure = details2;
+    return { retry: false, details: details2 };
+  }
+  let decision = episode.next(classification);
+  if (decision.action === "retry") {
+    const remaining = hooks?.hardDeadlineAt === void 0 ? Infinity : hooks.hardDeadlineAt - Date.now();
+    if (remaining <= 0) {
+      episode.resetAttempts();
+      throw new Error("Subagent hard deadline reached");
+    }
+    if (decision.delayMs > remaining) {
+      const deadlineClassification = {
+        ...classification,
+        retryable: false,
+        terminal: true,
+        message: `${classification.message} (recovery delay ${decision.delayMs}ms exceeds the remaining subagent deadline ${Math.max(0, Math.round(remaining))}ms)`
+      };
+      const details2 = failureDetails(facts, deadlineClassification, {
+        outcome: "exhausted",
+        attempts,
+        retries,
+        maxRetries: decision.maxRetries,
+        reason: "deadline"
+      });
+      if (hooks) hooks.failure = details2;
+      return { retry: false, details: details2 };
+    }
+    try {
+      onRetry?.();
+    } catch {
+    }
+    await cancellableBackoff(decision.delayMs, options?.signal);
+    if (options?.signal?.aborted) {
+      episode.resetAttempts();
+      throw new Error("Subagent aborted by parent");
+    }
+    if (hooks?.hardDeadlineAt !== void 0 && Date.now() >= hooks.hardDeadlineAt) {
+      episode.resetAttempts();
+      throw new Error("Subagent hard deadline reached");
+    }
+    return { retry: true };
+  }
+  const finalClassification = decision.action === "exhausted" ? decision.failure : classification;
+  const details = failureDetails(facts, finalClassification, {
+    outcome: decision.action === "exhausted" ? "exhausted" : "terminal",
+    attempts,
+    retries,
+    ...decision.action !== "terminal" ? { maxRetries: decision.maxRetries } : {},
+    ...decision.action === "exhausted" ? { reason: decision.reason } : {}
+  });
+  if (hooks) hooks.failure = details;
+  return { retry: false, details };
+}
 
 // ../../packages/shared-headless-capabilities/src/subagent-sessions.ts
 var SUBAGENT_SESSION_RECORD_VERSION = 1;
@@ -8525,14 +8901,14 @@ function lastPipelineCommand(command) {
   const segments = command.split("|").map((part) => part.trim()).filter(Boolean);
   return segments[segments.length - 1] || command;
 }
-function splitShellSegments(command) {
+function splitShellSegments(command, shell = "bash") {
   const segments = [];
   let current = "";
   let quote;
   for (let index = 0; index < command.length; index += 1) {
     const char = command[index];
     if (quote) {
-      if (quote === '"' && char === "\\" && index + 1 < command.length) {
+      if (quote === '"' && char === (shell === "powershell" ? "`" : "\\") && index + 1 < command.length) {
         current += char;
         current += command[index + 1];
         index += 1;
@@ -8547,13 +8923,13 @@ function splitShellSegments(command) {
       current += char;
       continue;
     }
-    if (char === "\\" && index + 1 < command.length) {
+    if (char === (shell === "powershell" ? "`" : "\\") && index + 1 < command.length) {
       current += char;
       current += command[index + 1];
       index += 1;
       continue;
     }
-    if (char === "&" || char === "|" || char === ";" || char === "\n") {
+    if (char === "&" || char === "|" || char === ";" || char === "\n" || shell === "powershell" && /[(){}]/.test(char)) {
       if ((char === "&" || char === "|") && command[index + 1] === char) {
         index += 1;
       }
@@ -8566,7 +8942,7 @@ function splitShellSegments(command) {
   segments.push(current);
   return segments.map((part) => part.trim()).filter(Boolean);
 }
-function splitShellWords(segment) {
+function splitShellWords(segment, shell = "bash") {
   const words = [];
   let current = "";
   let quote;
@@ -8575,7 +8951,7 @@ function splitShellWords(segment) {
     if (quote) {
       if (char === quote) {
         quote = void 0;
-      } else if (quote === '"' && char === "\\" && index + 1 < segment.length) {
+      } else if (quote === '"' && char === (shell === "powershell" ? "`" : "\\") && index + 1 < segment.length) {
         current += segment[index + 1];
         index += 1;
       } else {
@@ -8587,7 +8963,7 @@ function splitShellWords(segment) {
       quote = char;
       continue;
     }
-    if (char === "\\") {
+    if (char === (shell === "powershell" ? "`" : "\\")) {
       if (index + 1 >= segment.length) return void 0;
       current += segment[index + 1];
       index += 1;
@@ -8796,7 +9172,7 @@ function classifyShellCommand(command, shell = "bash", options) {
   const warnings = [];
   let commandClass = "unknown_shell";
   let destructive = false;
-  const destructivePatterns = shell === "powershell" ? [...POWERSHELL_DESTRUCTIVE_PATTERNS, ...DESTRUCTIVE_PATTERNS] : shell === "cmd" ? [...CMD_DESTRUCTIVE_PATTERNS, ...DESTRUCTIVE_PATTERNS] : DESTRUCTIVE_PATTERNS;
+  const destructivePatterns = shell === "cmd" ? [...CMD_DESTRUCTIVE_PATTERNS, ...DESTRUCTIVE_PATTERNS] : DESTRUCTIVE_PATTERNS;
   const removeWarnings = recursiveRemoveWarnings(command);
   if (removeWarnings.length > 0) {
     if (shell === "bash" && isStaticallyScopedRecursiveForceRemove(command, options)) {
@@ -8813,6 +9189,37 @@ function classifyShellCommand(command, shell = "bash", options) {
     commandClass = "unknown_shell";
     destructive = true;
   }
+  if (shell === "powershell") {
+    const segments = splitShellSegments(command, shell);
+    const simple = !/[$`#@{}()[\]=<>]/.test(command) && segments.every((segment) => {
+      const words2 = splitShellWords(segment, shell);
+      if (!words2?.length) return false;
+      const head = words2[0] === "." ? words2[1] : words2[0];
+      return !!head && /^[A-Za-z0-9_.\\/][A-Za-z0-9_.\\/:-]*$/.test(head) && !/^(?:return|throw|exit|if|elseif|else|switch|foreach|for|while|do|until|try|catch|finally|function|filter|class|begin|process|end|trap|data|using|workflow|configuration|break|continue|inlinescript|parallel|sequence)$/i.test(head);
+    });
+    if (!simple) {
+      for (const entry of POWERSHELL_DESTRUCTIVE_PATTERNS) {
+        if (!entry.pattern.test(command)) continue;
+        warnings.push(entry.warning);
+        commandClass = entry.commandClass;
+        destructive = true;
+      }
+    }
+    for (const segment of segments) {
+      const words2 = splitShellWords(segment, shell) ?? segment.split(/\s+/);
+      if (words2[0] === ".") words2.shift();
+      if (!words2[0]) continue;
+      words2[0] = executableName(words2[0]);
+      for (const entry of POWERSHELL_DESTRUCTIVE_PATTERNS) {
+        const pattern = new RegExp(`^(?:${entry.pattern.source})`, entry.pattern.flags);
+        if (pattern.test(words2.join(" "))) {
+          warnings.push(entry.warning);
+          commandClass = entry.commandClass;
+          destructive = true;
+        }
+      }
+    }
+  }
   for (const entry of destructivePatterns) {
     if (entry.pattern.test(command)) {
       warnings.push(entry.warning);
@@ -8828,8 +9235,6 @@ function classifyShellCommand(command, shell = "bash", options) {
   const primary = words[0] || firstWord(normalized);
   if (shell === "powershell" && /\b(invoke-webrequest|iwr|invoke-restmethod|irm)\b/.test(normalized)) {
     commandClass = "network";
-  } else if (shell === "powershell" && /\b(new-item|set-content|add-content|copy-item|move-item|rename-item)\b/.test(normalized)) {
-    commandClass = "filesystem_write";
   } else if (shell === "cmd" && /\b(curl|bitsadmin|certutil)\b/.test(normalized)) {
     commandClass = "network";
   } else if (shell === "cmd" && /\b(copy|xcopy|robocopy|move|mkdir|md|ren|rename)\b/.test(normalized)) {
@@ -9131,7 +9536,7 @@ function createAgentInstance(deps, systemPrompt, tools, model, apiKey, thinkingL
       hooks.observation.lastWorkAt = Date.now();
       hooks.observation.lastActivity = "response_event";
     }
-  }, hooks);
+  }, hooks, deps.recovery);
   if (deps.createAgent) {
     const agent2 = deps.createAgent({
       streamFn,
@@ -9605,10 +10010,21 @@ ${DELEGATION_REPORT_INSTRUCTION}`;
         throw new Error(`Subagent output token limit reached (stopReason=length): the provider cut the final response before the report was produced${messages.some(messageHasOwnText) ? " (earlier-turn narration discarded)" : ", no text response"}. The output/thinking budget was too small for this task at its reasoning level. Rerun with a narrower task or a lower thinkingLevel.`);
       }
       const detail = terminalError ? `: ${terminalError.slice(0, 200)}` : "";
-      const failure = new Error(`Subagent response failed (provider/transport failure before the report was produced, stopReason=${terminalStopReason ?? "none"}${collectedResponse ? ", partial transcript discarded" : ", no text response"})${detail}`);
+      const hooks2 = agentRunHooks.get(subagent);
+      const fallbackFailure = lastAssistant && (lastAssistant.retryable !== void 0 || lastAssistant.replayClass !== void 0 || lastAssistant.replayEligible !== void 0 || lastAssistant.remoteFailure !== void 0) ? {
+        errorMessage: terminalError,
+        retryable: lastAssistant.retryable,
+        replayClass: lastAssistant.replayClass,
+        replayEligible: lastAssistant.replayEligible,
+        remoteFailure: lastAssistant.remoteFailure
+      } : void 0;
+      const subagentFailure = hooks2?.failure ?? fallbackFailure;
+      const overflow = subagentFailure?.recovery?.outcome === "overflow";
+      const failure = new Error(overflow ? `Subagent context overflow requires compaction, but no subagent compactor is configured${detail}` : `Subagent response failed (provider/transport failure before the report was produced, stopReason=${terminalStopReason ?? "none"}${collectedResponse ? ", partial transcript discarded" : ", no text response"})${detail}`);
       const carrier = failure;
-      carrier.retryable = lastAssistant?.retryable;
-      carrier.replayClass = lastAssistant?.replayClass;
+      carrier.retryable = subagentFailure?.retryable;
+      carrier.replayClass = subagentFailure?.replayClass;
+      carrier.subagentFailure = subagentFailure;
       throw failure;
     }
     let response;
@@ -9655,8 +10071,15 @@ ${DELEGATION_REPORT_INSTRUCTION}`;
     phaseProgress(task.observation.phase);
     task.error = errorMessage.slice(0, 2e3);
     const failureCarrier = error;
-    if (failureCarrier && (failureCarrier.retryable !== void 0 || failureCarrier.replayClass !== void 0)) {
-      task.failure = { ...failureCarrier.retryable !== void 0 ? { retryable: failureCarrier.retryable } : {}, ...failureCarrier.replayClass !== void 0 ? { replayClass: failureCarrier.replayClass } : {} };
+    if (failureCarrier?.subagentFailure) {
+      task.failure = failureCarrier.subagentFailure;
+    } else if (failureCarrier && (failureCarrier.retryable !== void 0 || failureCarrier.replayClass !== void 0 || failureCarrier.replayEligible !== void 0 || failureCarrier.remoteFailure !== void 0)) {
+      task.failure = {
+        ...failureCarrier.retryable !== void 0 ? { retryable: failureCarrier.retryable } : {},
+        ...failureCarrier.replayClass !== void 0 ? { replayClass: failureCarrier.replayClass } : {},
+        ...failureCarrier.replayEligible !== void 0 ? { replayEligible: failureCarrier.replayEligible } : {},
+        ...failureCarrier.remoteFailure !== void 0 ? { remoteFailure: failureCarrier.remoteFailure } : {}
+      };
     } else {
       task.failure = void 0;
     }
@@ -9741,6 +10164,11 @@ function buildParallelResult(tasks, totalDuration) {
 `;
     if (task.observation) resultText += `Tools: ${task.observation.toolStarts} started, ${task.observation.toolEnds} ended, ${task.observation.toolErrors} errors
 `;
+    if (task.failure?.recovery) {
+      const recovery = task.failure.recovery;
+      resultText += `Recovery: ${task.failure.classification?.kind ?? "unclassified"}; outcome=${recovery.outcome}${recovery.reason ? ` (${recovery.reason})` : ""}; attempts=${recovery.attempts}; retries=${recovery.retries}${recovery.maxRetries !== void 0 ? `; budget=${recovery.maxRetries}` : ""}
+`;
+    }
     if (task.status === "completed" && task.result) {
       resultText += `${task.result}
 `;
@@ -9992,40 +10420,8 @@ ${SPAWN_USAGE_HINT}` }],
       toolContext.log?.(`Spawning ${tasks.length} parallel subagents: ${tasks.map((task) => task.name).join(", ")}`);
       toolContext.reportProgress?.({ message: `Launching ${tasks.length} parallel subagents...`, increment: 5 });
       const startTime = Date.now();
-      const runTask = async (task) => {
-        await run(task, toolContext.reportProgress, signal);
-        if (task.wasRecall || task.mode !== "read" || task.status !== "failed" || !task.error) return;
-        if (signal?.aborted) return;
-        if (!isRetryableSubagentFailureFrom({ errorMessage: task.error, retryable: task.failure?.retryable, replayClass: task.failure?.replayClass })) return;
-        observeDelegationPhase(task.observation, "task_replay");
-        const settleMs = Math.max(0, (deps.transientRetryBackoffMs ?? 2e3) * 10);
-        toolContext.reportProgress?.({ message: `[${task.name}] Provider/transport failure \u2014 replaying the read task once after ${Math.round(settleMs / 1e3)}s`, increment: 0 });
-        await cancellableBackoff(settleMs, signal);
-        if (signal.aborted) {
-          task.status = "cancelled";
-          task.error = "Subagent cancelled during replay backoff";
-          task.failure = void 0;
-          observeDelegationPhase(task.observation, "cancelled");
-          task.completedAt = Date.now();
-          return;
-        }
-        task.evidence = [];
-        task.confidenceSignals = [];
-        task.runtimeEvidence = [];
-        task.reportedEvidence = [];
-        task.error = void 0;
-        task.failure = void 0;
-        task.report = void 0;
-        task.result = void 0;
-        task.details = void 0;
-        task.parentHandoffRequired = false;
-        task.sessionId = void 0;
-        task.requestedMode = void 0;
-        task.wasRecall = void 0;
-        await run(task, toolContext.reportProgress, signal);
-      };
       const batch = Promise.resolve().then(() => runWithConcurrencyLimit(
-        tasks.map((task) => () => runTask(task)),
+        tasks.map((task) => () => run(task, toolContext.reportProgress, signal)),
         Math.max(1, deps.maxConcurrentSubagents ?? DEFAULT_MAX_CONCURRENT_SUBAGENTS)
       ));
       pending.add(batch);
@@ -10068,9 +10464,8 @@ ${SPAWN_USAGE_HINT}` }],
             observation: task.observation,
             parentHandoffRequired: task.parentHandoffRequired,
             failureReason: task.error,
-            // Structured provider verdict so the parent model can distinguish
-            // stream loss (safe to re-dispatch; no tool calls executed) from hard
-            // provider vetoes (auth/quota/config — not recoverable here).
+            // Structured provider facts plus the actual recovery outcome. Failed-
+            // response tool calls never execute; do not infer their absence.
             failure: task.failure,
             details: task.details
           })),
@@ -10293,7 +10688,11 @@ function executeManageTodoList(args, currentTodos) {
       };
     }
     default:
-      return rejectTodoAction("read", `unknown action: ${args.action}`, safeCurrentTodos);
+      return rejectTodoAction(
+        "read",
+        `unknown action: ${args.action}. Valid actions: create, read, complete_current, clear.`,
+        safeCurrentTodos
+      );
   }
 }
 
@@ -11142,6 +11541,7 @@ var resolveToCwd = resolveInSandbox;
 var resolveReadPath = resolveInSandbox;
 
 // ../../packages/shared-headless-capabilities/src/builtin/fs/schema-utils.ts
+var SCOPE_BASELINE_SENTENCE = "Absolute paths outside the sandbox are accepted only within configured access roots or when the current runtime mode's allowlist permits them; the effective scope is stated in the runtime-mode context, not in this description.";
 function formatPrefixes(prefixes) {
   if (!prefixes || prefixes.length === 0) {
     return "";
@@ -11151,6 +11551,11 @@ function formatPrefixes(prefixes) {
     return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
   }).join(", ");
 }
+function arraysEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  return a.every((value, index) => value === b[index]);
+}
 function buildRootParameterSchema(sandboxRoot, options) {
   const roots = getAvailableRoots(options);
   if (roots.length === 0) {
@@ -11174,8 +11579,11 @@ function buildRootParameterSchema(sandboxRoot, options) {
 function buildPathResolutionDescription(sandboxRoot, options) {
   const roots = getAvailableRoots(options);
   const allowlistedDirs = options?.allowlistedDirs ?? [];
-  const hasGlobalAllowlist = allowlistedDirs.some((dir) => dir.trim() === "/");
-  const allowlistSentence = hasGlobalAllowlist ? "Absolute paths anywhere on the local filesystem are accepted in the current runtime mode." : allowlistedDirs.length > 0 ? `Absolute paths inside allowlisted directories are accepted: ${allowlistedDirs.join(", ")}.` : "";
+  const descriptionOverride = options?.descriptionAllowlistedDirs;
+  const describedAllowlist = descriptionOverride ?? allowlistedDirs;
+  const viewsEqual = arraysEqual(describedAllowlist, allowlistedDirs);
+  const hasGlobalAllowlist = describedAllowlist.some((dir) => dir.trim() === "/") && viewsEqual;
+  const allowlistSentence = hasGlobalAllowlist ? "Absolute paths anywhere on the local filesystem are accepted in the current runtime mode." : viewsEqual ? describedAllowlist.length > 0 ? `Absolute paths inside allowlisted directories are accepted: ${describedAllowlist.join(", ")}.` : "" : SCOPE_BASELINE_SENTENCE;
   if (roots.length === 0) {
     return ["Relative paths resolve against the workspace root.", allowlistSentence].filter(Boolean).join(" ");
   }
@@ -11700,9 +12108,10 @@ Focus: ${question.trim()}` : ""}` },
                 return;
               }
               if (magicInfo?.kind === "image") {
+                const inlineSupported = INLINE_IMAGE_MIME_TYPES.has(magicInfo.mimeType);
                 resolve2({
-                  content: [{ type: "text", text: `Cannot attach image file ${path3}: unsupported image payload ${magicInfo.mimeType}.` }],
-                  details: { understanding: { kind: "image", mimeType: magicInfo.mimeType, fallbackReason: "unsupported inline image format" } },
+                  content: [{ type: "text", text: inlineSupported ? `Cannot attach image file ${path3}: the host filesystem bridge returned no usable image data for ${magicInfo.mimeType} (see logs for readImageInfo diagnostics).` : `Cannot attach image file ${path3}: unsupported image payload ${magicInfo.mimeType}.` }],
+                  details: { understanding: { kind: "image", mimeType: magicInfo.mimeType, fallbackReason: inlineSupported ? "image bridge read failed" : "unsupported inline image format" } },
                   isError: true
                 });
                 return;
@@ -12109,11 +12518,10 @@ function detectTextOnlyBinary(input, filePath, prefixMayBeTruncated) {
 async function readImageInfo(path3, fs2) {
   try {
     let base64 = "";
-    const size = (await fs2.stat(path3).catch(() => void 0))?.size ?? 0;
     if (typeof fs2.readFile === "function") {
       base64 = await fs2.readFile(path3, "base64").catch(() => "");
     }
-    if (!base64 && size > 0 && typeof fs2.readFileSync === "function") {
+    if (!base64 && typeof fs2.readFileSync === "function") {
       base64 = fs2.readFileSync(path3, "base64");
     }
     if (!base64) {
@@ -12141,6 +12549,8 @@ async function readImageInfo(path3, fs2) {
     if (bytes.length >= 12 && asciiAt(bytes, 0, 4) === "RIFF" && asciiAt(bytes, 8, 12 - 8) === "WEBP") {
       return { mimeType: "image/webp", base64, ...parseWebpDimensions(bytes) };
     }
+    console.error(`[pie] readImageInfo decoded ${bytes.length} bytes for ${path3} but no known image signature matched`);
+    return void 0;
   } catch (error) {
     console.error(`[pie] readImageInfo failed for ${path3}: ${error instanceof Error ? error.message : String(error)}`);
     return void 0;
@@ -12148,7 +12558,7 @@ async function readImageInfo(path3, fs2) {
   return void 0;
 }
 function decodeBase64ToBytes(base64) {
-  if (typeof Buffer !== "undefined") {
+  if (hasUsableNodeBuffer()) {
     return Buffer.from(base64, "base64");
   }
   const clean = base64.replace(/[^A-Za-z0-9+/=]/g, "");
@@ -12167,6 +12577,17 @@ function decodeBase64ToBytes(base64) {
   }
   return bytes.subarray(0, at);
 }
+function hasUsableNodeBuffer() {
+  if (typeof Buffer === "undefined" || typeof Buffer.from !== "function") {
+    return false;
+  }
+  try {
+    const probe = Buffer.from("aGk=", "base64");
+    return probe.length === 2 && probe[0] === 104;
+  } catch {
+    return false;
+  }
+}
 function readUIntBE(bytes, offset, length) {
   let value = 0;
   for (let i = 0; i < length; i += 1) {