@cydm/pie 1.0.15 → 1.0.17

package/dist/chunks/{chunk-R5LYKDKA.js → chunk-B4VUX6SD.js}

@@ -1471,36 +1471,66 @@ var DEFAULT_COMPACTION_CONFIG = {
   compactPrompt: COMPACT_PROMPT,
   summaryPrefix: SUMMARY_PREFIX
 };
+var APPROX_BYTES_PER_TOKEN = 4;
+var RESIZED_IMAGE_BYTES_ESTIMATE = 7373;
 function estimateTokens(message) {
-  if (message.role === "assistant") {
-    let chars = 0;
-    for (const block of message.content) {
-      if (block.type === "text") {
-        chars += block.text.length;
-      } else if (block.type === "thinking") {
-        chars += block.thinking.length;
-      } else if (block.type === "toolCall") {
-        chars += block.name.length + JSON.stringify(block.arguments).length;
-      }
-    }
-    return Math.ceil(chars / 4);
+  return approximateBytesAsTokens(estimateModelVisibleBytes(message));
+}
+function calculateTotalTokens(messages) {
+  return messages.reduce((sum, m) => sum + estimateTokens(m), 0);
+}
+function calculateContextTokens(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function getAssistantUsage(message) {
+  if (message.role !== "assistant") {
+    return void 0;
   }
-  if (message.role === "toolResult") {
-    let chars = 0;
-    for (const block of message.content) {
-      if (block.type === "text") {
-        chars += block.text.length;
-      } else if (block.type === "image") {
-        chars += 4800;
-      }
+  if (message.stopReason === "aborted" || message.stopReason === "error") {
+    return void 0;
+  }
+  if (calculateContextTokens(message.usage) <= 0) {
+    return void 0;
+  }
+  return message.usage;
+}
+function estimateContextTokens(messages) {
+  const localTokens = calculateTotalTokens(messages);
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const usage = getAssistantUsage(messages[i]);
+    if (!usage) {
+      continue;
     }
-    return Math.ceil(chars / 4);
+    const providerTokens = calculateContextTokens(usage);
+    const trailingTokens = calculateTotalTokens(messages.slice(i + 1));
+    const usageTokens = providerTokens;
+    return {
+      tokens: Math.max(providerTokens + trailingTokens, localTokens),
+      usageTokens,
+      providerTokens,
+      localTokens,
+      trailingTokens,
+      lastUsageIndex: i
+    };
   }
-  const text = getMessageText(message);
-  return Math.ceil(text.length / 4);
+  return {
+    tokens: localTokens,
+    usageTokens: 0,
+    providerTokens: 0,
+    localTokens,
+    trailingTokens: localTokens,
+    lastUsageIndex: null
+  };
 }
-function calculateTotalTokens(messages) {
-  return messages.reduce((sum, m) => sum + estimateTokens(m), 0);
+function getAutoCompactTokenLimit(contextWindow, reserveTokens, autoCompactTokenLimit) {
+  const explicitLimit = autoCompactTokenLimit !== void 0 && autoCompactTokenLimit > 0 ? Math.floor(autoCompactTokenLimit) : void 0;
+  if (!contextWindow || contextWindow <= 0) {
+    return explicitLimit;
+  }
+  const reserveLimit = reserveTokens >= contextWindow ? Math.floor(contextWindow * 0.8) : contextWindow - reserveTokens;
+  const windowLimit = Math.floor(contextWindow * 0.9);
+  const defaultLimit = Math.max(1, Math.min(reserveLimit, windowLimit));
+  return explicitLimit !== void 0 ? Math.min(defaultLimit, explicitLimit) : defaultLimit;
 }
 function isCompactSummaryMessage(message, summaryPrefix = SUMMARY_PREFIX) {
   return message.startsWith(`${summaryPrefix}
@@ -1603,10 +1633,17 @@ ${sections.join("\n\n")}` : "";
 }
 async function createCompactionSummary(messages, options = {}) {
   const { model, apiKey, systemPrompt, compactPrompt, signal } = options;
+  const throwIfAborted = () => {
+    if (signal?.aborted) {
+      throw new Error("Compaction aborted");
+    }
+  };
   if (!model) {
+    throwIfAborted();
     return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
   }
   try {
+    throwIfAborted();
     const response = await streamSimple(
       model,
       {
@@ -1625,8 +1662,10 @@ async function createCompactionSummary(messages, options = {}) {
         signal
       }
     ).result();
+    throwIfAborted();
     return appendFileOperationsToSummary(getAssistantText(response) || createSimpleSummary(messages), messages);
   } catch (error) {
+    throwIfAborted();
     console.warn("[Compaction] Failed to create Codex-style summary:", error);
     return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
   }
@@ -1692,6 +1731,138 @@ function appendFileOperationsToSummary(summary, messages) {
   const { readFiles, modifiedFiles } = computeFileLists(fileOps);
   return `${summary}${formatFileOperations(readFiles, modifiedFiles)}`;
 }
+function estimateModelVisibleBytes(message) {
+  const visibleMessage = normalizeModelVisibleMessage(message);
+  const wrapperBytes = utf8ByteLength(safeStringify(visibleMessage));
+  return wrapperBytes + estimateMessageMediaBytes(message);
+}
+function normalizeModelVisibleMessage(message) {
+  if (message.role === "user") {
+    return {
+      role: "user",
+      content: typeof message.content === "string" ? message.content : message.content.map(normalizeUserContentBlock)
+    };
+  }
+  if (message.role === "assistant") {
+    return {
+      role: "assistant",
+      content: message.content.map((block) => {
+        if (block.type === "text") {
+          return {
+            type: "text",
+            text: block.text,
+            ...block.textSignature ? { textSignature: block.textSignature } : {}
+          };
+        }
+        if (block.type === "thinking") {
+          return {
+            type: "thinking",
+            thinking: block.thinking,
+            ...block.thinkingSignature ? { thinkingSignature: block.thinkingSignature } : {}
+          };
+        }
+        if (block.type === "toolCall") {
+          return {
+            type: "toolCall",
+            id: block.id,
+            name: block.name,
+            arguments: block.arguments ?? {},
+            ...block.thoughtSignature ? { thoughtSignature: block.thoughtSignature } : {}
+          };
+        }
+        return block;
+      })
+    };
+  }
+  if (message.role === "toolResult") {
+    return {
+      role: "toolResult",
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      isError: message.isError,
+      content: message.content.map(normalizeUserContentBlock)
+    };
+  }
+  return {
+    role: String(message.role ?? "unknown"),
+    content: getMessageText(message)
+  };
+}
+function normalizeUserContentBlock(block) {
+  if (block.type === "text") {
+    return { type: "text", text: block.text };
+  }
+  if (block.type === "image") {
+    return { type: "image", mimeType: block.mimeType };
+  }
+  if (block.type === "audio") {
+    return { type: "audio", mimeType: block.mimeType };
+  }
+  if (block.type === "video") {
+    return { type: "video", mimeType: block.mimeType };
+  }
+  if (block.type === "fileRef") {
+    return {
+      type: "fileRef",
+      url: block.url,
+      mimeType: block.mimeType,
+      modality: block.modality
+    };
+  }
+  return block;
+}
+function estimateMessageMediaBytes(message) {
+  if (message.role === "user" && Array.isArray(message.content)) {
+    return message.content.reduce((sum, block) => sum + estimateUserContentBlockMediaBytes(block), 0);
+  }
+  if (message.role === "toolResult") {
+    return message.content.reduce((sum, block) => sum + estimateUserContentBlockMediaBytes(block), 0);
+  }
+  return 0;
+}
+function estimateUserContentBlockMediaBytes(block) {
+  if (block.type === "image") {
+    return estimateImageContentBytes(block);
+  }
+  if (block.type === "audio") {
+    return estimateInlineDataBytes(block);
+  }
+  if (block.type === "video") {
+    return estimateInlineDataBytes(block);
+  }
+  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);
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value ?? "");
+  }
+}
+var utf8Encoder = typeof globalThis.TextEncoder === "function" ? new globalThis.TextEncoder() : void 0;
+function utf8ByteLength(text) {
+  if (utf8Encoder) {
+    return utf8Encoder.encode(text).length;
+  }
+  let bytes = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint <= 127) bytes += 1;
+    else if (codePoint <= 2047) bytes += 2;
+    else if (codePoint <= 65535) bytes += 3;
+    else bytes += 4;
+  }
+  return bytes;
+}
 function isSyntheticUserEnvelope(text) {
   const trimmed = text.trimStart();
   return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("# AGENTS.md instructions") || trimmed.startsWith("## Project Context\nProject-specific instructions from AGENTS.md");
@@ -2807,13 +2978,21 @@ var AgentSessionAutoCompactScheduler = class {
   options;
   autoCompactTimer;
   pendingAutoCompact;
+  runningAutoCompact;
+  runningAbortController;
+  pendingWait;
+  resolvePendingWait;
   get hasPendingAutoCompact() {
-    return this.autoCompactTimer !== void 0;
+    return this.autoCompactTimer !== void 0 || this.pendingAutoCompact !== void 0 || this.runningAutoCompact !== void 0;
+  }
+  waitForAutoCompact() {
+    return this.pendingWait ?? Promise.resolve();
   }
   schedule(decision, delayMs = 0) {
     if (this.options.getRuntimeGuardTriggered()) {
       return;
     }
+    this.ensurePendingWait();
     this.pendingAutoCompact = decision;
     if (this.autoCompactTimer !== void 0) {
       return;
@@ -2824,6 +3003,7 @@ var AgentSessionAutoCompactScheduler = class {
       const pending = this.pendingAutoCompact;
       this.pendingAutoCompact = void 0;
       if (!pending || this.options.getDisposed()) {
+        this.resolvePending();
         return;
       }
       if (this.options.isStreaming()) {
@@ -2831,17 +3011,42 @@ var AgentSessionAutoCompactScheduler = class {
         this.schedule(pending, 100);
         return;
       }
-      void this.options.runAutoCompact(pending);
+      const abortController = new AbortController();
+      this.runningAbortController = abortController;
+      const running = this.options.runAutoCompact(pending, abortController.signal).catch(() => {
+      }).finally(() => {
+        if (this.runningAutoCompact === running) {
+          this.runningAutoCompact = void 0;
+          this.runningAbortController = void 0;
+          this.resolvePending();
+        }
+      });
+      this.runningAutoCompact = running;
     }, delayMs);
   }
   cancel() {
-    if (this.autoCompactTimer === void 0) {
-      return;
+    if (this.autoCompactTimer !== void 0) {
+      const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout;
+      clearTimer(this.autoCompactTimer);
+      this.autoCompactTimer = void 0;
     }
-    const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout;
-    clearTimer(this.autoCompactTimer);
-    this.autoCompactTimer = void 0;
     this.pendingAutoCompact = void 0;
+    this.runningAbortController?.abort();
+    this.runningAbortController = void 0;
+    this.runningAutoCompact = void 0;
+    this.resolvePending();
+  }
+  ensurePendingWait() {
+    if (this.pendingWait) return;
+    this.pendingWait = new Promise((resolve2) => {
+      this.resolvePendingWait = resolve2;
+    });
+  }
+  resolvePending() {
+    const resolve2 = this.resolvePendingWait;
+    this.pendingWait = void 0;
+    this.resolvePendingWait = void 0;
+    resolve2?.();
   }
 };
 
@@ -2858,15 +3063,24 @@ var AgentSessionAutoContinueController = class {
   }
   options;
   autoContinueTimer;
+  pendingAutoContinue;
+  resolvePendingAutoContinue;
+  get hasPendingAutoContinue() {
+    return this.autoContinueTimer !== void 0 || this.pendingAutoContinue !== void 0;
+  }
+  waitForAutoContinue() {
+    return this.pendingAutoContinue ?? Promise.resolve();
+  }
   schedule(messages) {
     if (!this.options.getAutoContinueMessage || this.options.getDisposed() || this.autoContinueTimer !== void 0) {
       return;
     }
+    this.ensurePending();
     const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout2;
     const snapshot = messages.slice();
     this.autoContinueTimer = setTimer(() => {
       this.autoContinueTimer = void 0;
-      void this.maybeScheduleAutoContinue(snapshot);
+      void this.maybeScheduleAutoContinue(snapshot).finally(() => this.resolvePending());
     }, 0);
   }
   cancel() {
@@ -2876,9 +3090,10 @@ var AgentSessionAutoContinueController = class {
     const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout2;
     clearTimer(this.autoContinueTimer);
     this.autoContinueTimer = void 0;
+    this.resolvePending();
   }
   async maybeScheduleAutoContinue(messages) {
-    if (!this.options.getAutoContinueMessage || this.options.getDisposed() || this.options.getRuntimeGuardTriggered() || this.options.hasQueuedMessages() || this.options.isStreaming()) {
+    if (!this.options.getAutoContinueMessage || this.options.getDisposed() || this.options.getRuntimeGuardTriggered() || this.options.isBlockedByRuntimePolicy() || this.options.hasQueuedMessages() || this.options.isStreaming()) {
       if (this.options.hasQueuedMessages()) {
         this.options.emit({ type: "auto_continue_skipped", reason: "queued_messages" });
       }
@@ -2902,21 +3117,36 @@ var AgentSessionAutoContinueController = class {
       this.options.emit({ type: "auto_continue_skipped", reason: reason ?? "no_message" });
       return;
     }
-    if (this.options.hasQueuedMessages() || this.options.isStreaming()) {
+    if (this.options.hasQueuedMessages() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
       this.options.emit({ type: "auto_continue_skipped", reason: "runtime_busy" });
       return;
     }
     this.options.emit({ type: "auto_continue_scheduled", reason });
     this.options.agent.followUp(message);
     const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout2;
-    this.autoContinueTimer = setTimer(() => {
-      this.autoContinueTimer = void 0;
-      if (this.options.getDisposed()) {
-        return;
-      }
-      void this.options.continueTurn().catch(() => {
-      });
-    }, 0);
+    await new Promise((resolve2) => {
+      this.autoContinueTimer = setTimer(() => {
+        this.autoContinueTimer = void 0;
+        if (this.options.getDisposed()) {
+          resolve2();
+          return;
+        }
+        void this.options.continueTurn().catch(() => {
+        }).finally(resolve2);
+      }, 0);
+    });
+  }
+  ensurePending() {
+    if (this.pendingAutoContinue) return;
+    this.pendingAutoContinue = new Promise((resolve2) => {
+      this.resolvePendingAutoContinue = resolve2;
+    });
+  }
+  resolvePending() {
+    const resolve2 = this.resolvePendingAutoContinue;
+    this.pendingAutoContinue = void 0;
+    this.resolvePendingAutoContinue = void 0;
+    resolve2?.();
   }
 };
 
@@ -2932,9 +3162,16 @@ async function runAgentSessionCompaction(params) {
   if (!params.compaction) {
     throw new Error("No compaction handler configured");
   }
+  const abortedResult = () => ({ aborted: true });
+  const isAborted = () => params.signal?.aborted === true;
   params.emit({ type: "auto_compaction_start", reason: params.reason, willRetry: params.willRetry });
   try {
-    if (params.reason === "overflow") {
+    if (isAborted()) {
+      const result2 = abortedResult();
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: result2 });
+      return result2;
+    }
+    if (params.willRetry) {
       params.removeTrailingAssistantError();
     }
     const result = await params.compaction.compact({
@@ -2943,22 +3180,43 @@ async function runAgentSessionCompaction(params) {
       agent: params.agent,
       sessionManager: params.sessionManager,
       messages: params.agent.state.messages.slice(),
-      cwd: params.cwd
+      cwd: params.cwd,
+      signal: params.signal
     });
+    if (isAborted() || result?.aborted) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     if (result?.summary && result.firstKeptEntryId) {
       params.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore);
       params.replaceMessagesAndMarkSynced(params.sessionManager.getMessages());
     } else if (result?.messages) {
       params.replaceMessagesAndMarkSynced(result.messages, { updateSession: true });
     }
+    if (isAborted()) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     params.markSyncedToAgentState();
     await params.sessionManager.save();
+    if (isAborted()) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     if (params.willRetry && !result?.aborted) {
       await params.continueTurn();
     }
     params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
     return result;
   } catch (error) {
+    if (isAborted()) {
+      const result = abortedResult();
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
+      return result;
+    }
     const errorMessage = error instanceof Error ? error.message : String(error);
     params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, errorMessage });
     throw error;
@@ -3028,6 +3286,27 @@ 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) {
+    return;
+  }
+  const decision = params.getAutoCompactDecision?.({
+    agent: params.agent,
+    sessionManager: params.sessionManager,
+    cwd: params.cwd,
+    messages: params.agent.state.messages.slice()
+  });
+  if (decision?.reason !== "threshold") {
+    return;
+  }
+  try {
+    await params.runAutoCompact();
+  } catch {
+    params.setRecoveryState("none");
+  }
+}
+
 // ../../packages/agent-framework/src/session/controller/queue.ts
 function cloneQueuedInput(input) {
   return {
@@ -3186,14 +3465,23 @@ var AgentSessionQueueDispatcher = class {
   }
   options;
   dispatchTimer;
+  pendingDispatch;
+  resolvePendingDispatch;
+  get hasPendingDispatch() {
+    return this.dispatchTimer !== void 0 || this.pendingDispatch !== void 0;
+  }
+  waitForDispatch() {
+    return this.pendingDispatch ?? Promise.resolve();
+  }
   schedule(delayMs = 0) {
     if (this.options.getDisposed() || this.options.getRuntimeGuardTriggered() || this.dispatchTimer !== void 0) {
       return;
     }
+    this.ensurePending();
     const setTimer = this.options.retry?.setTimeout ?? defaultSetTimeout3;
     this.dispatchTimer = setTimer(() => {
       this.dispatchTimer = void 0;
-      void this.dispatchNext();
+      void this.dispatchNext().finally(() => this.resolvePending());
     }, delayMs);
   }
   cancel() {
@@ -3203,6 +3491,7 @@ var AgentSessionQueueDispatcher = class {
     const clearTimer = this.options.retry?.clearTimeout ?? defaultClearTimeout3;
     clearTimer(this.dispatchTimer);
     this.dispatchTimer = void 0;
+    this.resolvePending();
   }
   async dispatchNext() {
     if (this.options.getDisposed() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
@@ -3230,6 +3519,11 @@ var AgentSessionQueueDispatcher = class {
       }
       return false;
     }
+    await this.options.runPreRequestAutoCompact();
+    if (this.options.getDisposed() || this.options.isStreaming() || this.options.isBlockedByRuntimePolicy()) {
+      this.schedule(100);
+      return false;
+    }
     const dispatched = this.options.queue.shift();
     if (!dispatched) {
       return false;
@@ -3259,8 +3553,56 @@ var AgentSessionQueueDispatcher = class {
     }
     return true;
   }
+  ensurePending() {
+    if (this.pendingDispatch) return;
+    this.pendingDispatch = new Promise((resolve2) => {
+      this.resolvePendingDispatch = resolve2;
+    });
+  }
+  resolvePending() {
+    const resolve2 = this.resolvePendingDispatch;
+    this.pendingDispatch = void 0;
+    this.resolvePendingDispatch = void 0;
+    resolve2?.();
+  }
 };
 
+// ../../packages/agent-framework/src/session/controller/failure-classification.ts
+function isAssistantFailureMessage(message) {
+  return message?.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted");
+}
+function isAssistantTerminalCompletion(message) {
+  if (message?.role !== "assistant") return false;
+  if (message.stopReason === "error" || message.stopReason === "aborted") return false;
+  if (message.stopReason === "toolUse") return false;
+  return !message.content.some((block) => block.type === "toolCall");
+}
+function createFailureClassification(context, retry, classifyFailure) {
+  const hostClassification = classifyFailure?.(context);
+  if (hostClassification) {
+    return hostClassification;
+  }
+  const retryable = retry?.isRetryableError(context.errorMessage) === true;
+  const userAbort = context.message?.role === "assistant" && context.message.stopReason === "aborted";
+  return {
+    kind: userAbort ? "user_abort" : retryable ? "provider_transient" : "unknown",
+    retryable: retryable && !userAbort,
+    compactable: false,
+    userAbort,
+    terminal: !retryable || userAbort,
+    message: context.errorMessage
+  };
+}
+function asTerminalFailure(failure, message = failure.message) {
+  return {
+    ...failure,
+    retryable: false,
+    compactable: false,
+    terminal: true,
+    message
+  };
+}
+
 // ../../packages/agent-framework/src/session/controller/retry-policy.ts
 function defaultSetTimeout4(callback, delay) {
   return setTimeout(callback, delay);
@@ -3269,42 +3611,49 @@ function defaultClearTimeout4(handle) {
   clearTimeout(handle);
 }
 var AgentSessionRetryController = class {
-  constructor(retry, emit, removeTrailingAssistantError2, continueTurn) {
+  constructor(retry, emit, removeTrailingAssistantError2, continueTurn, setRecoveryState) {
     this.retry = retry;
     this.emit = emit;
     this.removeTrailingAssistantError = removeTrailingAssistantError2;
     this.continueTurn = continueTurn;
+    this.setRecoveryState = setRecoveryState;
   }
   retry;
   emit;
   removeTrailingAssistantError;
   continueTurn;
+  setRecoveryState;
   retryAttempt = 0;
   retryTimer;
   pendingRetry;
   resolvePendingRetry;
+  get policy() {
+    return this.retry;
+  }
   get hasPendingRetry() {
     return this.retryTimer !== void 0 || this.pendingRetry !== void 0;
   }
   waitForRetry() {
     return this.pendingRetry ?? Promise.resolve();
   }
-  async handleTurnEnd(message) {
+  async handleTurnEnd(message, failure) {
     if (!this.retry || !message || message.role !== "assistant") {
       return;
     }
-    const errorMessage = message.stopReason === "error" ? message.errorMessage : void 0;
-    if (!errorMessage) {
+    if (!failure) {
       if (this.retryAttempt > 0) {
         this.emit({ type: "retry_succeeded", attempts: this.retryAttempt });
+        this.emit({ type: "turn_retry_succeeded", attempts: this.retryAttempt });
         this.retryAttempt = 0;
+        this.setRecoveryState("none");
         this.resolvePending();
       }
       return;
     }
-    if (!this.retry.isRetryableError(errorMessage)) {
+    if (!failure.retryable) {
       if (this.retryAttempt > 0) {
         this.retryAttempt = 0;
+        this.setRecoveryState("none");
         this.resolvePending();
       }
       return;
@@ -3312,28 +3661,41 @@ var AgentSessionRetryController = class {
     const maxRetries = this.retry.maxRetries ?? 3;
     this.retryAttempt += 1;
     if (this.retryAttempt > maxRetries) {
-      this.emit({ type: "retry_exhausted", errorMessage, maxRetries });
+      const terminalFailure = asTerminalFailure(failure);
+      this.emit({ type: "retry_exhausted", errorMessage: failure.message, maxRetries });
+      this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
+      this.emit({ type: "turn_settled" });
       this.retryAttempt = 0;
+      this.setRecoveryState("terminal");
       this.resolvePending();
       return;
     }
     const attempt = this.retryAttempt;
     const delayMs = (this.retry.baseDelayMs ?? 2e3) * 2 ** (attempt - 1);
     this.ensurePending();
-    this.emit({ type: "retry_scheduled", errorMessage, attempt, maxRetries, delayMs });
+    this.setRecoveryState("retry_pending");
+    this.emit({ type: "turn_recovery_pending", recovery: "retry", failure, attempt, maxRetries, delayMs });
+    this.emit({ type: "retry_scheduled", errorMessage: failure.message, attempt, maxRetries, delayMs });
     this.cancelTimerOnly();
     const setTimer = this.retry.setTimeout ?? defaultSetTimeout4;
     this.retryTimer = setTimer(() => {
       this.retryTimer = void 0;
+      this.setRecoveryState("retrying");
       this.emit({ type: "retry_start", attempt, maxRetries });
+      this.emit({ type: "turn_retry_started", attempt, maxRetries, failure });
       this.removeTrailingAssistantError();
       void this.continueTurn().catch((error) => {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const terminalFailure = asTerminalFailure(failure, errorMessage);
         this.emit({
           type: "retry_exhausted",
-          errorMessage: error instanceof Error ? error.message : String(error),
+          errorMessage,
           maxRetries
         });
+        this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
+        this.emit({ type: "turn_settled" });
         this.retryAttempt = 0;
+        this.setRecoveryState("terminal");
         this.resolvePending();
       });
     }, delayMs);
@@ -3370,6 +3732,9 @@ var AgentSessionRetryController = class {
 // ../../packages/agent-framework/src/session/controller/runtime-guard.ts
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS = 16384;
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS = 40;
+var TOOL_FAILURE_SIGNATURE_CHARS = 1e3;
+var TOOL_FAILURE_SIGNATURE_CONTEXT_LINES = 5;
+var FAILURE_DIAGNOSTIC_LINE_PATTERN = /\b(E2E_FAILED|AssertionError|TimeoutError|SyntaxError|ReferenceError|TypeError|Error):|(^|\b)(failed|failure|timed out|timeout|exit code|command failed|npm ERR!)/i;
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value) ?? String(value);
@@ -3388,6 +3753,20 @@ function summarizeToolResultForGuard(result) {
   const text = content.filter((block) => !!block && typeof block === "object" && "type" in block).filter((block) => block.type === "text").map((block) => block.text || "").join("\n").trim();
   return text || stableStringify(result);
 }
+function summarizeToolFailureSignature(result) {
+  const summary = summarizeToolResultForGuard(result).replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  if (!summary) {
+    return "";
+  }
+  const lines = summary.split("\n");
+  for (let index = lines.length - 1; index >= 0; index--) {
+    if (!FAILURE_DIAGNOSTIC_LINE_PATTERN.test(lines[index] ?? "")) {
+      continue;
+    }
+    return lines.slice(index, Math.min(lines.length, index + TOOL_FAILURE_SIGNATURE_CONTEXT_LINES)).join("\n").slice(0, TOOL_FAILURE_SIGNATURE_CHARS);
+  }
+  return summary.slice(-TOOL_FAILURE_SIGNATURE_CHARS);
+}
 var AgentSessionRuntimeGuard = class {
   constructor(trigger) {
     this.trigger = trigger;
@@ -3452,7 +3831,7 @@ var AgentSessionRuntimeGuard = class {
       }
       return;
     }
-    const resultSummary = summarizeToolResultForGuard(event.result).slice(0, 500);
+    const resultSummary = summarizeToolFailureSignature(event.result);
     const key = `${event.toolName}:${stableStringify(event.args)}:${resultSummary}`;
     const repeatCount = (this.repeatedToolFailures.get(key) ?? 0) + 1;
     this.repeatedToolFailures.set(key, repeatCount);
@@ -3464,6 +3843,33 @@ var AgentSessionRuntimeGuard = class {
   }
 };
 
+// ../../packages/agent-framework/src/session/controller/runtime-phase-policy.ts
+function classifyControllerRuntimeError(params) {
+  const errorMessage = params.error instanceof Error ? params.error.message : String(params.error);
+  return createFailureClassification({ errorMessage, phase: params.phase }, params.retry, params.classifyFailure);
+}
+async function runAgentSessionRuntimePhase(params) {
+  try {
+    return await params.action();
+  } catch (error) {
+    const failure = classifyControllerRuntimeError({
+      error,
+      phase: params.phase,
+      retry: params.retry,
+      classifyFailure: params.classifyFailure
+    });
+    if (failure.userAbort) {
+      params.setRecoveryState("cancelled");
+      params.emit({ type: "turn_cancelled", reason: failure.message });
+    } else {
+      params.setRecoveryState("terminal");
+      params.emit({ type: "turn_failed_terminal", failure: asTerminalFailure(failure) });
+    }
+    params.emit({ type: "turn_settled" });
+    throw error;
+  }
+}
+
 // ../../packages/agent-framework/src/session/controller/session-sync.ts
 function getConversationMessages(messages) {
   return messages.filter(
@@ -3568,6 +3974,163 @@ function reduceAgentSessionLifecycle(state, input) {
   }
 }
 
+// ../../packages/agent-framework/src/session/controller/turn-lifecycle-policy.ts
+function isAgentSessionRecoveryActive(state) {
+  return state === "retry_pending" || state === "retrying" || state === "compacting";
+}
+function createRuntimeGuardFailure(reason) {
+  return {
+    kind: "runtime_guard",
+    retryable: false,
+    compactable: false,
+    userAbort: false,
+    terminal: true,
+    message: reason
+  };
+}
+function classifyControllerTurnFailure(params) {
+  if (!isAssistantFailureMessage(params.message)) {
+    return void 0;
+  }
+  const errorMessage = params.message.errorMessage || (params.message.stopReason === "aborted" ? "Request was aborted" : "assistant response failed");
+  return createFailureClassification(
+    { errorMessage, message: params.message, phase: "stream" },
+    params.retry,
+    params.classifyFailure
+  );
+}
+async function handleAgentSessionTurnEndRuntimePolicies(params) {
+  if (params.disposed || params.runtimeGuardTriggered) {
+    return;
+  }
+  const failure = classifyControllerTurnFailure({
+    message: params.message,
+    retry: params.retry,
+    classifyFailure: params.classifyFailure
+  });
+  if (failure?.userAbort) {
+    params.cancelRetry();
+    params.setRecoveryState("cancelled");
+    params.emit({ type: "turn_cancelled", reason: failure.message, message: params.message });
+    params.emit({ type: "turn_settled" });
+    return;
+  }
+  const compactDecision = params.getAutoCompactDecision?.({
+    agent: params.agent,
+    sessionManager: params.sessionManager,
+    cwd: params.cwd,
+    message: params.message,
+    messages: params.agent.state.messages.slice()
+  });
+  if (failure?.compactable) {
+    params.scheduleAutoCompact(compactDecision ?? { reason: "overflow", willRetry: true }, failure);
+    return;
+  }
+  if (failure && compactDecision?.reason === "overflow") {
+    params.scheduleAutoCompact(compactDecision, failure);
+    return;
+  }
+  if (failure?.retryable && compactDecision?.reason === "threshold") {
+    params.scheduleAutoCompact({ reason: "threshold", willRetry: true }, failure);
+    return;
+  }
+  if (failure) {
+    if (failure.retryable) {
+      await params.handleRetryTurnEnd(params.message, failure);
+      return;
+    }
+    await params.handleRetryTurnEnd(params.message, failure);
+    params.setRecoveryState("terminal");
+    params.emit({ type: "turn_failed_terminal", failure: asTerminalFailure(failure), message: params.message });
+    params.emit({ type: "turn_settled" });
+    return;
+  }
+  await params.handleRetryTurnEnd(params.message);
+  if (isAssistantTerminalCompletion(params.message)) {
+    params.emit({ type: "turn_completed", message: params.message, toolResults: params.toolResults });
+    const postTurnCompactDecision = compactDecision ?? params.getAutoCompactDecision?.({
+      agent: params.agent,
+      sessionManager: params.sessionManager,
+      cwd: params.cwd,
+      message: params.message,
+      messages: params.agent.state.messages.slice()
+    });
+    if (postTurnCompactDecision?.reason === "threshold") {
+      params.scheduleAutoCompact(postTurnCompactDecision);
+      return;
+    }
+    params.setRecoveryState("none");
+    params.emit({ type: "turn_settled" });
+  }
+}
+async function runAgentSessionControllerAutoCompact(params) {
+  const emitSettled = params.emitSettled ?? true;
+  const runAfterAgentEndHook = params.runAfterAgentEndHook ?? true;
+  const cancelOnAbort = params.cancelOnAbort ?? true;
+  params.setRecoveryState("compacting");
+  params.emit({ type: "turn_compaction_started", reason: params.reason, willRetry: params.willRetry });
+  try {
+    const result = await runAgentSessionCompaction({
+      reason: params.reason,
+      willRetry: params.willRetry,
+      signal: params.signal,
+      compaction: params.compaction,
+      agent: params.agent,
+      sessionManager: params.sessionManager,
+      cwd: params.cwd,
+      emit: params.emit,
+      removeTrailingAssistantError: params.removeTrailingAssistantError,
+      replaceMessagesAndMarkSynced: params.replaceMessagesAndMarkSynced,
+      markSyncedToAgentState: params.markSyncedToAgentState,
+      continueTurn: params.continueTurn
+    });
+    if (!params.willRetry || result?.aborted) {
+      const alreadyCancelled = params.getRecoveryState?.() === "cancelled" || params.getDisposed?.() === true;
+      params.setRecoveryState(result?.aborted && cancelOnAbort ? "cancelled" : "none");
+      if (result?.aborted) {
+        params.cancelRetry();
+        if (cancelOnAbort && !alreadyCancelled) {
+          params.emit({ type: "turn_cancelled", reason: "compaction_aborted" });
+        }
+      }
+      if (emitSettled && !alreadyCancelled) {
+        params.emit({ type: "turn_settled" });
+      }
+      if (!result?.aborted && runAfterAgentEndHook) {
+        void params.handleAgentEndHook(params.agent.state.messages.slice());
+      }
+    }
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!params.willRetry && params.reason !== "overflow") {
+      params.setRecoveryState("none");
+      if (emitSettled) {
+        params.emit({ type: "turn_settled" });
+      }
+      if (runAfterAgentEndHook) {
+        void params.handleAgentEndHook(params.agent.state.messages.slice());
+      }
+      throw error;
+    }
+    const failure = asTerminalFailure(params.pendingFailure ?? {
+      kind: "internal_error",
+      retryable: false,
+      compactable: false,
+      userAbort: false,
+      terminal: true,
+      message: errorMessage
+    }, errorMessage);
+    params.cancelRetry();
+    params.setRecoveryState("terminal");
+    params.emit({ type: "turn_failed_terminal", failure });
+    params.emit({ type: "turn_settled" });
+    throw error;
+  } finally {
+    params.clearPendingFailure();
+  }
+}
+
 // ../../packages/agent-framework/src/session/controller.ts
 var AgentSessionController = class {
   agent;
@@ -3589,6 +4152,9 @@ var AgentSessionController = class {
   prepareTurn;
   afterAgentEnd;
   getAutoCompactDecision;
+  classifyFailure;
+  recoveryState = "none";
+  pendingCompactionFailure;
   lifecycleState = createInitialAgentSessionLifecycleState();
   constructor(options) {
     this.agent = options.agent;
@@ -3599,6 +4165,7 @@ var AgentSessionController = class {
     this.prepareTurn = options.prepareTurn;
     this.afterAgentEnd = options.afterAgentEnd;
     this.getAutoCompactDecision = options.getAutoCompactDecision;
+    this.classifyFailure = options.classifyFailure;
     if (options.onEvent) {
       this.listeners.add(options.onEvent);
     }
@@ -3614,15 +4181,18 @@ var AgentSessionController = class {
       options.retry,
       (event) => this.emit(event),
       () => this.removeTrailingAssistantError(),
-      () => this.continue()
+      () => this.continue(),
+      (state) => {
+        this.recoveryState = state;
+      }
     );
     this.autoCompact = new AgentSessionAutoCompactScheduler({
       retry: options.retry,
       getDisposed: () => this.disposed,
       getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
       isStreaming: () => this.isStreaming,
-      runAutoCompact: async (decision) => {
-        await this.runAutoCompact(decision.reason, decision.willRetry);
+      runAutoCompact: async (decision, signal) => {
+        await this.runAutoCompact(decision.reason, decision.willRetry, { signal });
       }
     });
     this.autoContinue = new AgentSessionAutoContinueController({
@@ -3634,6 +4204,7 @@ var AgentSessionController = class {
       emit: (event) => this.emit(event),
       getDisposed: () => this.disposed,
       getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
+      isBlockedByRuntimePolicy: () => this.isBlockedByRuntimePolicy(),
       hasQueuedMessages: () => this.hasQueuedMessages,
       isStreaming: () => this.isStreaming,
       continueTurn: () => this.continue()
@@ -3649,7 +4220,8 @@ var AgentSessionController = class {
       getDisposed: () => this.disposed,
       getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
       isStreaming: () => this.isStreaming,
-      isBlockedByRuntimePolicy: () => this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact,
+      isBlockedByRuntimePolicy: () => this.isBlockedByRuntimePolicy(),
+      runPreRequestAutoCompact: () => this.runPreRequestAutoCompactIfNeeded(),
       preparePromptMessages: (messages, promptOptions) => this.preparePromptMessages(messages, promptOptions),
       continueTurn: () => this.continue(),
       syncNewAgentMessages: () => this.syncNewAgentMessages()
@@ -3672,6 +4244,9 @@ var AgentSessionController = class {
   get queuedInputsSnapshot() {
     return this.queue.snapshot;
   }
+  get turnRecoveryState() {
+    return this.recoveryState;
+  }
   get activeSessionMetadata() {
     const metadata = this.sessionManager.getActiveSession()?.metadata;
     return metadata ? { ...metadata } : void 0;
@@ -3680,10 +4255,7 @@ var AgentSessionController = class {
     return this.lastSyncedMessageCount;
   }
   get runtimeContext() {
-    return {
-      systemPrompt: this.agent.state.systemPrompt,
-      tools: this.agent.state.tools.slice()
-    };
+    return { systemPrompt: this.agent.state.systemPrompt, tools: this.agent.state.tools.slice() };
   }
   getRuntimeSnapshot() {
     return {
@@ -3730,6 +4302,17 @@ var AgentSessionController = class {
   }
   async prompt(input, options) {
     const messages = normalizePromptInput(input);
+    if (this.isRecoveryActive()) {
+      this.queue.enqueue(messages, options?.streamingBehavior ?? "followUp", {
+        ...options,
+        streamingBehavior: options?.streamingBehavior ?? "followUp"
+      });
+      this.recordLifecycle({ type: "queued_input_added" });
+      return;
+    }
+    if (this.recoveryState === "terminal" || this.recoveryState === "cancelled") {
+      this.recoveryState = "none";
+    }
     if (options?.streamingBehavior) {
       this.queue.enqueue(messages, options.streamingBehavior, options);
       this.recordLifecycle({ type: "queued_input_added" });
@@ -3741,7 +4324,8 @@ var AgentSessionController = class {
     if (this.isStreaming) {
       throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
     }
-    const prepared = await this.preparePromptMessages(messages, options);
+    await this.runPreRequestAutoCompactIfNeeded();
+    const prepared = await this.runRuntimePhase("prepare", () => this.preparePromptMessages(messages, options));
     if (prepared.handled) {
       return;
     }
@@ -3749,23 +4333,30 @@ var AgentSessionController = class {
     if (prepared.systemPrompt !== void 0) {
       this.agent.setSystemPrompt(prepared.systemPrompt);
     }
-    await this.agent.prompt(prepared.messages);
-    await this.syncNewAgentMessages();
+    await this.runRuntimePhase("request", () => this.agent.prompt(prepared.messages));
+    await this.runRuntimePhase("post_turn", () => this.syncNewAgentMessages());
   }
   async continue() {
     if (this.isStreaming) {
       throw new Error("Agent is already processing. Wait for completion before continuing.");
     }
+    await this.runPreRequestAutoCompactIfNeeded();
     this.recordLifecycle({ type: "prompt_started" });
-    await this.agent.continue();
-    await this.syncNewAgentMessages();
+    await this.runRuntimePhase("request", () => this.agent.continue());
+    await this.runRuntimePhase("post_turn", () => this.syncNewAgentMessages());
   }
   abort() {
     this.recordLifecycle({ type: "abort" });
+    const cancelPendingRecovery = this.isRecoveryActive() && !this.isStreaming;
     this.retryController.cancel();
     this.autoCompact.cancel();
     this.queueDispatcher.cancel();
     this.autoContinue.cancel();
+    if (cancelPendingRecovery) {
+      this.recoveryState = "cancelled";
+      this.emit({ type: "turn_cancelled", reason: "user_abort" });
+      this.emit({ type: "turn_settled" });
+    }
     this.agent.abort();
   }
   waitForIdle() {
@@ -3774,25 +4365,40 @@ var AgentSessionController = class {
   async waitForSettled() {
     while (true) {
       await this.agent.waitForIdle();
-      if (!this.retryController.hasPendingRetry) {
+      if (!this.hasPendingRuntimePolicy()) {
         return;
       }
-      await this.retryController.waitForRetry();
+      await Promise.all([this.retryController.waitForRetry(), this.autoCompact.waitForAutoCompact(), this.autoContinue.waitForAutoContinue(), this.queueDispatcher.waitForDispatch()]);
     }
   }
-  async runAutoCompact(reason, willRetry = false) {
-    return runAgentSessionCompaction({
+  async runAutoCompact(reason, willRetry = false, options) {
+    return runAgentSessionControllerAutoCompact({
       reason,
       willRetry,
+      signal: options?.signal,
       compaction: this.compaction,
       agent: this.agent,
       sessionManager: this.sessionManager,
       cwd: this.cwd,
+      pendingFailure: this.pendingCompactionFailure,
       emit: (event) => this.emit(event),
+      setRecoveryState: (state) => {
+        this.recoveryState = state;
+      },
+      getRecoveryState: () => this.recoveryState,
+      getDisposed: () => this.disposed,
+      cancelRetry: () => this.retryController.cancel(),
+      clearPendingFailure: () => {
+        this.pendingCompactionFailure = void 0;
+      },
       removeTrailingAssistantError: () => this.removeTrailingAssistantError(),
-      replaceMessagesAndMarkSynced: (messages, options) => this.replaceMessagesAndMarkSynced(messages, options),
+      replaceMessagesAndMarkSynced: (messages, options2) => this.replaceMessagesAndMarkSynced(messages, options2),
       markSyncedToAgentState: () => this.markSyncedToAgentState(),
-      continueTurn: () => this.continue()
+      continueTurn: () => this.continue(),
+      handleAgentEndHook: (messages) => this.handleAgentEndHook(messages),
+      emitSettled: options?.emitSettled,
+      runAfterAgentEndHook: options?.runAfterAgentEndHook,
+      cancelOnAbort: options?.cancelOnAbort
     });
   }
   dispose() {
@@ -3814,9 +4420,23 @@ var AgentSessionController = class {
     this.queue.replaceText(search, replacement);
   }
   requestQueueDispatch() {
-    if (this.queue.length > 0) {
-      this.queueDispatcher.schedule();
-    }
+    if (this.queue.length > 0) this.queueDispatcher.schedule();
+  }
+  async runPreRequestAutoCompactIfNeeded() {
+    return runPreRequestAutoCompact({
+      disposed: this.disposed,
+      runtimeGuardTriggered: this.runtimeGuard.triggered,
+      isStreaming: this.isStreaming,
+      recoveryActive: this.isRecoveryActive(),
+      agent: this.agent,
+      sessionManager: this.sessionManager,
+      cwd: this.cwd,
+      getAutoCompactDecision: this.getAutoCompactDecision,
+      runAutoCompact: () => this.runAutoCompact("threshold", false, { emitSettled: false, runAfterAgentEndHook: false, cancelOnAbort: false }).then(() => void 0),
+      setRecoveryState: (state) => {
+        this.recoveryState = state;
+      }
+    });
   }
   handleAgentEvent(event) {
     this.emit({ type: "agent_event", event });
@@ -3837,7 +4457,7 @@ var AgentSessionController = class {
     if (event.type === "turn_end") {
       void this.syncNewAgentMessages();
       this.recordLifecycle({ type: "turn_end_success" });
-      void this.handleTurnEndRuntimePolicies(event.message);
+      void this.handleTurnEndRuntimePolicies(event.message, event.toolResults);
     }
     if (event.type === "agent_end") {
       this.recordLifecycle({ type: "agent_end" });
@@ -3874,31 +4494,29 @@ var AgentSessionController = class {
       replaceMessagesAndMarkSynced: (messages, options) => this.replaceMessagesAndMarkSynced(messages, options)
     });
   }
-  async handleTurnEndRuntimePolicies(message) {
-    if (this.disposed || this.runtimeGuard.triggered) {
-      return;
-    }
-    const assistantError = message?.role === "assistant" && message.stopReason === "error" && Boolean(message.errorMessage);
-    if (!assistantError) {
-      await this.retryController.handleTurnEnd(message);
-    }
-    const compactDecision = this.getAutoCompactDecision?.({
+  async handleTurnEndRuntimePolicies(message, toolResults = []) {
+    return handleAgentSessionTurnEndRuntimePolicies({
+      disposed: this.disposed,
+      runtimeGuardTriggered: this.runtimeGuard.triggered,
+      message,
+      toolResults,
       agent: this.agent,
       sessionManager: this.sessionManager,
       cwd: this.cwd,
-      message,
-      messages: this.agent.state.messages.slice()
+      getAutoCompactDecision: this.getAutoCompactDecision,
+      classifyFailure: this.classifyFailure,
+      retry: this.retryController.policy,
+      emit: (event) => this.emit(event),
+      setRecoveryState: (state) => {
+        this.recoveryState = state;
+      },
+      handleRetryTurnEnd: (turnMessage, failure) => this.retryController.handleTurnEnd(turnMessage, failure),
+      cancelRetry: () => this.retryController.cancel(),
+      scheduleAutoCompact: (decision, failure) => this.scheduleAutoCompact(decision, failure)
     });
-    if (compactDecision) {
-      this.scheduleAutoCompact(compactDecision);
-      return;
-    }
-    if (assistantError) {
-      await this.retryController.handleTurnEnd(message);
-    }
   }
   async handleAgentEndHook(messages) {
-    if (this.disposed || this.runtimeGuard.triggered) {
+    if (this.disposed || this.runtimeGuard.triggered || this.isBlockedByRuntimePolicy()) {
       return;
     }
     if (this.afterAgentEnd) {
@@ -3933,8 +4551,36 @@ var AgentSessionController = class {
   recordToolExecutionEndForGuard(event) {
     this.runtimeGuard.recordToolExecutionEnd(event);
   }
-  scheduleAutoCompact(decision) {
+  async runRuntimePhase(phase, action) {
+    return runAgentSessionRuntimePhase({
+      phase,
+      action,
+      retry: this.retryController.policy,
+      classifyFailure: this.classifyFailure,
+      emit: (event) => this.emit(event),
+      setRecoveryState: (state) => {
+        this.recoveryState = state;
+      }
+    });
+  }
+  isRecoveryActive() {
+    return isAgentSessionRecoveryActive(this.recoveryState);
+  }
+  isBlockedByRuntimePolicy() {
+    return this.recoveryState !== "none" || this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact;
+  }
+  hasPendingRuntimePolicy() {
+    return this.retryController.hasPendingRetry || this.autoCompact.hasPendingAutoCompact || this.autoContinue.hasPendingAutoContinue || this.queueDispatcher.hasPendingDispatch;
+  }
+  scheduleAutoCompact(decision, failure) {
     this.recordLifecycle({ type: "auto_compact_scheduled" });
+    if (failure) {
+      this.pendingCompactionFailure = failure;
+      this.recoveryState = "compacting";
+      this.emit({ type: "turn_recovery_pending", recovery: "compaction", failure });
+    } else if (decision.reason === "threshold") {
+      this.recoveryState = "compacting";
+    }
     this.autoCompact.schedule(decision);
   }
   triggerRuntimeGuard(toolName, repeatCount, reason) {
@@ -3946,7 +4592,13 @@ var AgentSessionController = class {
     this.autoCompact.cancel();
     this.queueDispatcher.cancel();
     this.autoContinue.cancel();
+    this.recoveryState = "terminal";
     this.emit({ type: "runtime_guard_triggered", toolName, repeatCount, reason });
+    this.emit({
+      type: "turn_failed_terminal",
+      failure: createRuntimeGuardFailure(reason)
+    });
+    this.emit({ type: "turn_settled" });
     this.agent.abort();
   }
   emit(event) {
@@ -5155,7 +5807,49 @@ function restoreLineEndings(text, ending) {
   return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
 function normalizeForFuzzyMatch(text) {
-  return text.split("\n").map((line) => line.trimEnd()).join("\n").replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+  return buildFuzzyIndexMap(text).normalized;
+}
+function normalizeCharForFuzzyMatch(char) {
+  if (/[\u2018\u2019\u201A\u201B]/.test(char)) return "'";
+  if (/[\u201C\u201D\u201E\u201F]/.test(char)) return '"';
+  if (/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/.test(char)) return "-";
+  if (/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/.test(char)) return " ";
+  return char;
+}
+function buildFuzzyIndexMap(text) {
+  const lines = text.split("\n");
+  let normalized = "";
+  const originalStartByNormalizedIndex = [];
+  const originalEndByNormalizedIndex = [];
+  let originalLineStart = 0;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex] ?? "";
+    const trimmedLine = line.trimEnd();
+    for (let index = 0; index < trimmedLine.length; index++) {
+      normalized += normalizeCharForFuzzyMatch(trimmedLine[index]);
+      originalStartByNormalizedIndex.push(originalLineStart + index);
+      originalEndByNormalizedIndex.push(originalLineStart + index + 1);
+    }
+    if (lineIndex < lines.length - 1) {
+      normalized += "\n";
+      originalStartByNormalizedIndex.push(originalLineStart + line.length);
+      originalEndByNormalizedIndex.push(originalLineStart + line.length + 1);
+    }
+    originalLineStart += line.length + (lineIndex < lines.length - 1 ? 1 : 0);
+  }
+  return { normalized, originalStartByNormalizedIndex, originalEndByNormalizedIndex };
+}
+function countOccurrences(content, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let index = 0;
+  while (true) {
+    const nextIndex = content.indexOf(needle, index);
+    if (nextIndex === -1) break;
+    count++;
+    index = nextIndex + needle.length;
+  }
+  return count;
 }
 function fuzzyFindText(content, oldText) {
   const exactIndex = content.indexOf(oldText);
@@ -5165,11 +5859,25 @@ function fuzzyFindText(content, oldText) {
       index: exactIndex,
       matchLength: oldText.length,
       usedFuzzyMatch: false,
-      contentForReplacement: content
+      contentForReplacement: content,
+      occurrences: countOccurrences(content, oldText),
+      matchKind: "exact"
     };
   }
-  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyMap = buildFuzzyIndexMap(content);
+  const fuzzyContent = fuzzyMap.normalized;
   const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  if (fuzzyOldText.length === 0) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content,
+      occurrences: 0,
+      matchKind: "none"
+    };
+  }
   const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
   if (fuzzyIndex === -1) {
     return {
@@ -5177,35 +5885,65 @@ function fuzzyFindText(content, oldText) {
       index: -1,
       matchLength: 0,
       usedFuzzyMatch: false,
-      contentForReplacement: content
+      contentForReplacement: content,
+      occurrences: 0,
+      matchKind: "none"
     };
   }
+  const endFuzzyIndex = fuzzyIndex + fuzzyOldText.length - 1;
+  const originalStart = fuzzyMap.originalStartByNormalizedIndex[fuzzyIndex];
+  const originalEnd = fuzzyMap.originalEndByNormalizedIndex[endFuzzyIndex];
   return {
     found: true,
-    index: fuzzyIndex,
-    matchLength: fuzzyOldText.length,
+    index: originalStart,
+    matchLength: originalEnd - originalStart,
     usedFuzzyMatch: true,
-    contentForReplacement: fuzzyContent
+    contentForReplacement: content,
+    occurrences: countOccurrences(fuzzyContent, fuzzyOldText),
+    matchKind: "fuzzy"
   };
 }
 function stripBom(content) {
   return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
-function generateDiffString(oldContent, newContent, _contextLines = 4) {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-  let firstChangedLine;
-  for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
-    if (oldLines[i] !== newLines[i]) {
-      firstChangedLine = i + 1;
-      break;
-    }
-  }
-  const diff = `--- old
-+++ new
-@@ -1,${oldLines.length} +1,${newLines.length} @@
-[Diff: ${oldLines.length} lines -> ${newLines.length} lines]`;
-  return { diff, firstChangedLine };
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  const oldLines = normalizeToLF(stripBom(oldContent).text).split("\n");
+  const newLines = normalizeToLF(stripBom(newContent).text).split("\n");
+  let prefixLength = 0;
+  while (prefixLength < oldLines.length && prefixLength < newLines.length && oldLines[prefixLength] === newLines[prefixLength]) {
+    prefixLength++;
+  }
+  if (prefixLength === oldLines.length && prefixLength === newLines.length) {
+    return { diff: "--- old\n+++ new\n", firstChangedLine: void 0 };
+  }
+  let oldSuffixIndex = oldLines.length - 1;
+  let newSuffixIndex = newLines.length - 1;
+  while (oldSuffixIndex >= prefixLength && newSuffixIndex >= prefixLength && oldLines[oldSuffixIndex] === newLines[newSuffixIndex]) {
+    oldSuffixIndex--;
+    newSuffixIndex--;
+  }
+  const beforeContext = Math.min(contextLines, prefixLength);
+  const removedCount = Math.max(0, oldSuffixIndex - prefixLength + 1);
+  const addedCount = Math.max(0, newSuffixIndex - prefixLength + 1);
+  const afterContext = Math.min(contextLines, oldLines.length - oldSuffixIndex - 1, newLines.length - newSuffixIndex - 1);
+  const hunkOldStart = Math.max(0, prefixLength - beforeContext);
+  const hunkNewStart = Math.max(0, prefixLength - beforeContext);
+  const hunkOldCount = beforeContext + removedCount + afterContext;
+  const hunkNewCount = beforeContext + addedCount + afterContext;
+  const lines = ["--- old", "+++ new", `@@ -${hunkOldStart + 1},${hunkOldCount} +${hunkNewStart + 1},${hunkNewCount} @@`];
+  for (let index = prefixLength - beforeContext; index < prefixLength; index++) {
+    lines.push(` ${oldLines[index] ?? ""}`);
+  }
+  for (let index = prefixLength; index <= oldSuffixIndex; index++) {
+    lines.push(`-${oldLines[index] ?? ""}`);
+  }
+  for (let index = prefixLength; index <= newSuffixIndex; index++) {
+    lines.push(`+${newLines[index] ?? ""}`);
+  }
+  for (let offset = 1; offset <= afterContext; offset++) {
+    lines.push(` ${oldLines[oldSuffixIndex + offset] ?? ""}`);
+  }
+  return { diff: lines.join("\n"), firstChangedLine: prefixLength + 1 };
 }
 
 // ../../packages/shared-headless-capabilities/src/builtin/fs/edit.ts
@@ -5227,7 +5965,7 @@ function validateEditArgs(path3, oldText, newText) {
     throw new Error("Invalid edit_file arguments: path, oldText, and newText must be real edit values, not tool-call markup.");
   }
 }
-function countOccurrences(content, needle) {
+function countOccurrences2(content, needle) {
   if (needle.length === 0) return 0;
   let count = 0;
   let index = 0;
@@ -5239,6 +5977,29 @@ function countOccurrences(content, needle) {
   }
   return count;
 }
+function createEditErrorResult(params) {
+  const detailLines = [
+    params.message,
+    params.recoveryHint,
+    params.alreadyAppliedCandidate ? "Diagnostic: newText already appears in the current file, but edit_file did not treat that as success because it may be an unrelated occurrence." : ""
+  ].filter(Boolean);
+  return {
+    content: [{ type: "text", text: detailLines.join("\n") }],
+    details: {
+      status: "error",
+      matchKind: params.matchKind,
+      changed: false,
+      diff: "",
+      oldTextOccurrences: params.oldTextOccurrences,
+      newTextOccurrences: params.newTextOccurrences,
+      errorReason: params.errorReason,
+      recoveryHint: params.recoveryHint,
+      staleBaseLikely: params.staleBaseLikely,
+      alreadyAppliedCandidate: params.alreadyAppliedCandidate
+    },
+    isError: true
+  };
+}
 function createEditTool(cwd, options) {
   const fs2 = getFileSystem();
   const rootSchema = buildRootParameterSchema(cwd, options);
@@ -5288,37 +6049,53 @@ function createEditTool(cwd, options) {
             const normalizedContent = normalizeToLF(content);
             const normalizedOldText = normalizeToLF(oldText);
             const normalizedNewText = normalizeToLF(newText);
+            const newTextOccurrences = countOccurrences2(normalizedContent, normalizedNewText);
             const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
             if (!matchResult.found) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `Could not find the exact text in ${path3}. The old text must match exactly including all whitespace and newlines.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `Could not find oldText in ${path3}.`,
+                  matchKind: "none",
+                  errorReason: "old_text_not_found",
+                  oldTextOccurrences: 0,
+                  newTextOccurrences,
+                  staleBaseLikely: newTextOccurrences > 0,
+                  alreadyAppliedCandidate: newTextOccurrences > 0,
+                  recoveryHint: newTextOccurrences > 0 ? "The replacement text already appears in the current file. Read the current file before retrying; this may be a stale oldText from an earlier edit in the same turn." : "Read the current file and retry with a larger exact block copied from the latest file contents."
+                })
               );
               return;
             }
-            const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
-            const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
-            const occurrences = countOccurrences(fuzzyContent, fuzzyOldText);
-            if (occurrences > 1) {
+            if (matchResult.occurrences > 1) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `Found ${occurrences} occurrences of the text in ${path3}. The text must be unique. Please provide more context to make it unique.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `Found ${matchResult.occurrences} occurrences of oldText in ${path3}. The text must be unique.`,
+                  matchKind: matchResult.matchKind,
+                  errorReason: "old_text_not_unique",
+                  oldTextOccurrences: matchResult.occurrences,
+                  newTextOccurrences,
+                  recoveryHint: "Read the current file and retry with a larger exact block that uniquely identifies the intended location."
+                })
               );
               return;
             }
             if (aborted) return;
-            const baseContent = matchResult.contentForReplacement;
+            const baseContent = normalizedContent;
             const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
             if (baseContent === newContent) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `No changes made to ${path3}. The replacement produced identical content.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `No changes made to ${path3}. The replacement produced identical content.`,
+                  matchKind: matchResult.matchKind,
+                  errorReason: "replacement_no_change",
+                  oldTextOccurrences: matchResult.occurrences,
+                  newTextOccurrences,
+                  recoveryHint: "Read the current file and verify whether the intended edit is already present or whether oldText/newText need a larger exact block.",
+                  alreadyAppliedCandidate: newTextOccurrences > 0
+                })
               );
               return;
             }
@@ -5328,16 +6105,24 @@ function createEditTool(cwd, options) {
             if (signal) {
               signal.removeEventListener("abort", onAbort);
             }
-            const diffResult = generateDiffString(content, finalContent);
+            const diffResult = generateDiffString(content, restoreLineEndings(newContent, originalEnding));
             resolve2({
               content: [
                 {
                   type: "text",
-                  text: `Successfully replaced text in ${path3}.`
+                  text: `Successfully replaced text in ${path3} using ${matchResult.matchKind} match.`
                 },
                 { type: "text", text: diffResult.diff }
               ],
-              details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+              details: {
+                status: "success",
+                matchKind: matchResult.matchKind,
+                changed: true,
+                diff: diffResult.diff,
+                firstChangedLine: diffResult.firstChangedLine,
+                oldTextOccurrences: matchResult.occurrences,
+                newTextOccurrences
+              }
             });
           } catch (error) {
             if (signal) {
@@ -6391,6 +7176,81 @@ function createEmptyRuntimeSummary() {
     toolErrors: 0
   };
 }
+function summarizeString(value, maxLength = 300) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+function summarizeMessage(message) {
+  if (!isRecord(message)) return typeof message;
+  if ("contentBlocks" in message && !("content" in message)) return message;
+  const content = Array.isArray(message.content) ? message.content : [];
+  const blockTypes = content.filter(isRecord).map((block) => String(block.type || "unknown")).slice(0, 10);
+  const text = getTextFromMessageContent(content);
+  return {
+    role: message.role,
+    stopReason: message.stopReason,
+    errorMessage: typeof message.errorMessage === "string" ? summarizeString(message.errorMessage) : void 0,
+    contentBlocks: content.length,
+    blockTypes,
+    textLength: text.length
+  };
+}
+function summarizeToolResults(value) {
+  if (isRecord(value) && typeof value.count === "number" && !Array.isArray(value)) return value;
+  if (!Array.isArray(value)) return typeof value;
+  let errors = 0;
+  const toolNames = [];
+  for (const result of value) {
+    if (!isRecord(result)) continue;
+    if (result.isError === true) errors++;
+    const toolName = typeof result.toolName === "string" ? result.toolName : typeof result.name === "string" ? result.name : void 0;
+    if (toolName && toolNames.length < 10) toolNames.push(toolName);
+  }
+  return { count: value.length, errors, toolNames };
+}
+function summarizeFailure(value) {
+  if (!isRecord(value)) return typeof value;
+  return {
+    kind: value.kind,
+    retryable: value.retryable,
+    compactable: value.compactable,
+    userAbort: value.userAbort,
+    terminal: value.terminal,
+    message: typeof value.message === "string" ? summarizeString(value.message) : void 0
+  };
+}
+function summarizeRuntimeEvent(value) {
+  if (!isRecord(value)) return typeof value;
+  const summary = {
+    type: value.type
+  };
+  if ("toolCallId" in value) summary.toolCallId = value.toolCallId;
+  if ("toolName" in value) summary.toolName = value.toolName;
+  if ("turnIndex" in value) summary.turnIndex = value.turnIndex;
+  if ("isError" in value) summary.isError = value.isError;
+  if ("errorMessage" in value && typeof value.errorMessage === "string") {
+    summary.errorMessage = summarizeString(value.errorMessage);
+  }
+  if ("message" in value) summary.message = summarizeMessage(value.message);
+  if ("toolResults" in value) summary.toolResults = summarizeToolResults(value.toolResults);
+  return summary;
+}
+function shouldRecordRuntimeEvent(type) {
+  const normalizedType = type.startsWith("runtime:") ? type.slice("runtime:".length) : type;
+  return normalizedType !== "agent_event" && normalizedType !== "semantic_event";
+}
+function recomputeRuntimeSummaryFromTimeline(events) {
+  const summary = createEmptyRuntimeSummary();
+  for (const event of events ?? []) {
+    if (/queue|queued_turn/.test(event.type)) summary.queuedTurnEvents++;
+    if (/retry/.test(event.type)) summary.retryEvents++;
+    if (/auto_compaction|auto_compact|compaction/.test(event.type)) summary.autoCompactionEvents++;
+    if (/runtime_guard|repeated_tool_error/.test(event.type)) summary.runtimeGuardEvents++;
+    if (/subagent/.test(event.type)) summary.subagentEvents++;
+    if (event.type === "tool_end" || event.type === "tool_error") summary.toolResults++;
+    if (event.type === "tool_error") summary.toolErrors++;
+  }
+  return summary;
+}
 function summarizeMeta(meta) {
   if (!isRecord(meta)) return meta;
   const summary = {};
@@ -6399,6 +7259,22 @@ function summarizeMeta(meta) {
       summary[key] = Array.isArray(value) ? { count: value.length } : typeof value;
       continue;
     }
+    if (key === "message") {
+      summary[key] = summarizeMessage(value);
+      continue;
+    }
+    if (key === "toolResults") {
+      summary[key] = summarizeToolResults(value);
+      continue;
+    }
+    if (key === "failure") {
+      summary[key] = summarizeFailure(value);
+      continue;
+    }
+    if (key === "event") {
+      summary[key] = summarizeRuntimeEvent(value);
+      continue;
+    }
     if (key === "queuedInput" && isRecord(value)) {
       summary[key] = {
         mode: value.mode,
@@ -6408,7 +7284,7 @@ function summarizeMeta(meta) {
       };
       continue;
     }
-    summary[key] = typeof value === "string" && value.length > 300 ? `${value.slice(0, 300)}...` : value;
+    summary[key] = typeof value === "string" ? summarizeString(value) : value;
   }
   return summary;
 }
@@ -6522,9 +7398,7 @@ function timelineEventFromTraceEvent(type, meta) {
       failure: typeof data.failureCategory === "string" && data.failureCategory.length > 0
     };
   }
-  if (normalizedType === "subagent_summary") {
-    return { type: "subagent_child_end", summary: `subagent summary count=${String(data.count ?? "?")}`, details: detail };
-  }
+  if (normalizedType === "subagent_summary") return null;
   return null;
 }
 function cloneTurn(turn) {
@@ -6565,6 +7439,9 @@ var SessionTraceController = class {
     if (!Array.isArray(this.trace.recentTimeline)) {
       this.trace.recentTimeline = [];
     }
+    this.trace.recentEvents = this.trace.recentEvents.slice(-this.recentEventsLimit);
+    this.trace.recentTimeline = this.trace.recentTimeline.slice(-this.recentEventsLimit);
+    this.trace.runtimeSummary = recomputeRuntimeSummaryFromTimeline(this.trace.recentTimeline);
   }
   trace;
   recentTurnsLimit;
@@ -6579,7 +7456,6 @@ var SessionTraceController = class {
     if (this.trace.recentEvents.length > this.recentEventsLimit) {
       this.trace.recentEvents = this.trace.recentEvents.slice(-this.recentEventsLimit);
     }
-    this.updateRuntimeSummary(type, meta);
     const timelineEvent = timelineEventFromTraceEvent(type, meta);
     if (timelineEvent) {
       this.pushTimeline(timelineEvent);
@@ -6594,17 +7470,7 @@ var SessionTraceController = class {
     if (this.trace.recentTimeline.length > this.recentEventsLimit) {
       this.trace.recentTimeline = this.trace.recentTimeline.slice(-this.recentEventsLimit);
     }
-  }
-  updateRuntimeSummary(type, meta) {
-    const summary = this.trace.runtimeSummary ?? createEmptyRuntimeSummary();
-    if (/queue|queued_turn/.test(type)) summary.queuedTurnEvents++;
-    if (/retry/.test(type)) summary.retryEvents++;
-    if (/auto_compaction|auto_compact|compaction/.test(type)) summary.autoCompactionEvents++;
-    if (/runtime_guard|repeated_tool_error/.test(type)) summary.runtimeGuardEvents++;
-    if (/subagent/.test(type)) summary.subagentEvents++;
-    if (type === "tool_end") summary.toolResults++;
-    if (type === "tool_end" && isRecord(meta) && meta.isError) summary.toolErrors++;
-    this.trace.runtimeSummary = summary;
+    this.trace.runtimeSummary = recomputeRuntimeSummaryFromTimeline(this.trace.recentTimeline);
   }
   nextTurnIndex() {
     if (this.trace.activeTurn) {
@@ -6676,6 +7542,7 @@ var SessionTraceController = class {
     this.touch();
   }
   noteRuntimeEvent(type, meta) {
+    if (!shouldRecordRuntimeEvent(type)) return;
     this.pushEvent(`runtime:${type}`, summarizeMeta(meta));
     this.touch();
   }
@@ -6700,7 +7567,6 @@ var SessionTraceController = class {
     if (!message || message.role !== "assistant" || !this.trace.activeTurn) return;
     this.trace.activeTurn.state = this.trace.activeTurn.toolCalls.some((tool) => tool.status === "running") ? "tool_running" : "streaming";
     this.trace.activeTurn.assistantText = getTextFromMessageContent(message.content);
-    this.pushEvent("assistant_update");
     this.touch();
   }
   startTool(toolCallId, toolName, args) {
@@ -9023,7 +9889,10 @@ export {
   ManageTodoListParamsSchema,
   executeManageTodoList,
   maybeAdvanceTodoExecutionState,
+  estimateTokens,
   calculateTotalTokens,
+  estimateContextTokens,
+  getAutoCompactTokenLimit,
   findFirstKeptEntryId,
   createCompactionSummary,
   createSessionManager,