@cydm/pie 1.0.14 → 1.0.16

package/dist/chunks/{chunk-LF5Q7BVU.js → chunk-7GAYJ6AF.js}

@@ -1,6 +1,8 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  Agent,
+  Agent
+} from "./chunk-VE2HDCNB.js";
+import {
   FileSystemGateway,
   Type,
   completeSimple,
@@ -8,7 +10,7 @@ import {
   getFileSystem,
   getPlatformConfig,
   streamSimple
-} from "./chunk-D7NAXU7F.js";
+} from "./chunk-5DA2D3K2.js";
 import {
   __require
 } from "./chunk-TG2EQLX2.js";
@@ -1469,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}
@@ -1690,6 +1722,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");
@@ -2805,13 +2969,20 @@ var AgentSessionAutoCompactScheduler = class {
   options;
   autoCompactTimer;
   pendingAutoCompact;
+  runningAutoCompact;
+  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;
@@ -2822,6 +2993,7 @@ var AgentSessionAutoCompactScheduler = class {
       const pending = this.pendingAutoCompact;
       this.pendingAutoCompact = void 0;
       if (!pending || this.options.getDisposed()) {
+        this.resolvePending();
         return;
       }
       if (this.options.isStreaming()) {
@@ -2829,17 +3001,33 @@ var AgentSessionAutoCompactScheduler = class {
         this.schedule(pending, 100);
         return;
       }
-      void this.options.runAutoCompact(pending);
+      this.runningAutoCompact = this.options.runAutoCompact(pending).catch(() => {
+      }).finally(() => {
+        this.runningAutoCompact = void 0;
+        this.resolvePending();
+      });
     }, 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.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?.();
   }
 };
 
@@ -2856,15 +3044,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() {
@@ -2874,9 +3071,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" });
       }
@@ -2900,21 +3098,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,7 +3145,7 @@ async function runAgentSessionCompaction(params) {
   }
   params.emit({ type: "auto_compaction_start", reason: params.reason, willRetry: params.willRetry });
   try {
-    if (params.reason === "overflow") {
+    if (params.willRetry) {
       params.removeTrailingAssistantError();
     }
     const result = await params.compaction.compact({
@@ -3026,6 +3239,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 {
@@ -3184,14 +3418,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() {
@@ -3201,6 +3444,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()) {
@@ -3228,6 +3472,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;
@@ -3257,8 +3506,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);
@@ -3267,59 +3564,99 @@ 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;
+    return this.retryTimer !== void 0 || this.pendingRetry !== void 0;
   }
-  async handleTurnEnd(message) {
+  waitForRetry() {
+    return this.pendingRetry ?? Promise.resolve();
+  }
+  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;
     }
     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.emit({ type: "retry_scheduled", errorMessage, attempt, maxRetries, delayMs });
+    this.ensurePending();
+    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(() => {
+      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,
+          maxRetries
+        });
+        this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
+        this.emit({ type: "turn_settled" });
+        this.retryAttempt = 0;
+        this.setRecoveryState("terminal");
+        this.resolvePending();
       });
     }, delayMs);
   }
   cancel() {
     this.cancelTimerOnly();
     this.retryAttempt = 0;
+    this.resolvePending();
   }
   cancelTimerOnly() {
     if (this.retryTimer === void 0) {
@@ -3329,6 +3666,20 @@ var AgentSessionRetryController = class {
     clearTimer(this.retryTimer);
     this.retryTimer = void 0;
   }
+  ensurePending() {
+    if (this.pendingRetry) {
+      return;
+    }
+    this.pendingRetry = new Promise((resolve2) => {
+      this.resolvePendingRetry = resolve2;
+    });
+  }
+  resolvePending() {
+    const resolve2 = this.resolvePendingRetry;
+    this.pendingRetry = void 0;
+    this.resolvePendingRetry = void 0;
+    resolve2?.();
+  }
 };
 
 // ../../packages/agent-framework/src/session/controller/runtime-guard.ts
@@ -3428,6 +3779,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(
@@ -3532,6 +3910,161 @@ 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,
+      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) {
+      params.setRecoveryState(result?.aborted && cancelOnAbort ? "cancelled" : "none");
+      if (result?.aborted) {
+        params.cancelRetry();
+        if (cancelOnAbort) {
+          params.emit({ type: "turn_cancelled", reason: "compaction_aborted" });
+        }
+      }
+      if (emitSettled) {
+        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;
@@ -3553,6 +4086,9 @@ var AgentSessionController = class {
   prepareTurn;
   afterAgentEnd;
   getAutoCompactDecision;
+  classifyFailure;
+  recoveryState = "none";
+  pendingCompactionFailure;
   lifecycleState = createInitialAgentSessionLifecycleState();
   constructor(options) {
     this.agent = options.agent;
@@ -3563,6 +4099,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);
     }
@@ -3578,7 +4115,10 @@ 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,
@@ -3598,6 +4138,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()
@@ -3613,7 +4154,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()
@@ -3636,6 +4178,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;
@@ -3644,10 +4189,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 {
@@ -3694,6 +4236,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" });
@@ -3705,7 +4258,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;
     }
@@ -3713,41 +4267,69 @@ 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() {
     return this.agent.waitForIdle();
   }
-  async runAutoCompact(reason, willRetry = false) {
-    return runAgentSessionCompaction({
+  async waitForSettled() {
+    while (true) {
+      await this.agent.waitForIdle();
+      if (!this.hasPendingRuntimePolicy()) {
+        return;
+      }
+      await Promise.all([this.retryController.waitForRetry(), this.autoCompact.waitForAutoCompact(), this.autoContinue.waitForAutoContinue(), this.queueDispatcher.waitForDispatch()]);
+    }
+  }
+  async runAutoCompact(reason, willRetry = false, options) {
+    return runAgentSessionControllerAutoCompact({
       reason,
       willRetry,
       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;
+      },
+      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() {
@@ -3769,9 +4351,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 });
@@ -3792,7 +4388,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" });
@@ -3829,25 +4425,29 @@ var AgentSessionController = class {
       replaceMessagesAndMarkSynced: (messages, options) => this.replaceMessagesAndMarkSynced(messages, options)
     });
   }
-  async handleTurnEndRuntimePolicies(message) {
-    if (this.disposed || this.runtimeGuard.triggered) {
-      return;
-    }
-    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;
-    }
-    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) {
@@ -3882,8 +4482,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) {
@@ -3895,7 +4523,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) {
@@ -8972,7 +9606,10 @@ export {
   ManageTodoListParamsSchema,
   executeManageTodoList,
   maybeAdvanceTodoExecutionState,
+  estimateTokens,
   calculateTotalTokens,
+  estimateContextTokens,
+  getAutoCompactTokenLimit,
   findFirstKeptEntryId,
   createCompactionSummary,
   createSessionManager,