@cydm/pie 1.0.15 → 1.0.17

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   getSettingsPath,
   getThemesDir,
   migrateConfigFromAgentDir
-} from "./chunks/chunk-55RUSXEA.js";
+} from "./chunks/chunk-4MIOCDBV.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -37,11 +37,14 @@ import {
   createSharedFileSystemTools,
   createSharedWebSearchTool,
   createTodoWidgetView,
+  estimateContextTokens,
+  estimateTokens,
   evaluateTodoClosureAfterAbort,
   evaluateTodoClosureAfterCompletedTurn,
   evaluateTodoClosureAfterFailedTurn,
   findFirstKeptEntryId,
   formatSkillSummariesForPrompt,
+  getAutoCompactTokenLimit,
   hasInteractionHandler,
   maybeAdvanceTodoExecutionState,
   modalityForReadFileUnderstandingKind,
@@ -52,7 +55,7 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-R5LYKDKA.js";
+} from "./chunks/chunk-B4VUX6SD.js";
 import "./chunks/chunk-VE2HDCNB.js";
 import {
   Deref,
@@ -59547,6 +59550,26 @@ ${theme.fg("muted", "Receiving edit parameters...")}`;
 
 ${theme.fg("error", errorText)}`;
         }
+      } else if (this.result?.details?.diff && rawPath) {
+        const diff = this.result.details.diff;
+        const firstChangedLine = this.result.details.firstChangedLine;
+        if (firstChangedLine) {
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path27 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+        }
+        const lines = diff.split("\n");
+        const maxLines = this.expanded ? lines.length : 15;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += "\n\n" + displayLines.map((line) => {
+          if (line.startsWith("+")) return theme.fg("success", line);
+          if (line.startsWith("-")) return theme.fg("error", line);
+          if (line.startsWith("@@")) return theme.fg("warning", line);
+          return theme.fg("toolOutput", line);
+        }).join("\n");
+        if (remaining > 0) {
+          text += theme.fg("muted", `
+... (${remaining} more lines, press Ctrl+O to expand)`);
+        }
       } else if (hasOldText && hasNewText && rawPath) {
         const diff = generateEditDiff(oldText, newText, rawPath);
         const firstChangedLine = findFirstChangedLine(oldText, newText);
@@ -61388,7 +61411,7 @@ function bindInteractiveRuntimeEvents(host) {
           lastStopReason: host.agent.state.messages.at(-1)?.role === "assistant" ? host.agent.state.messages.at(-1).stopReason : void 0
         });
         const lastMessage = host.agent.state.messages[host.agent.state.messages.length - 1];
-        if (lastMessage?.role === "assistant" && lastMessage?.stopReason === "error") {
+        if (!hasControllerTurnAuthority(host) && lastMessage?.role === "assistant" && lastMessage?.stopReason === "error") {
           host.sessionTrace.abortTurn(String(lastMessage?.errorMessage || "agent_end"));
         }
         host.isProcessing = false;
@@ -61433,6 +61456,12 @@ function handleSemanticAgentEvent(host, event) {
       break;
     }
     case "turn_completed": {
+      if (hasControllerTurnAuthority(host)) {
+        host.logDebug("semantic:turn_completed_ignored_controller_authority", {
+          turnIndex: host._semanticTurnIndex
+        });
+        break;
+      }
       host.clearContinuationTimeout("turn_completed");
       host.emitExtensionEvent({
         type: "turn:completed",
@@ -61460,6 +61489,13 @@ function handleSemanticAgentEvent(host, event) {
       break;
     }
     case "turn_failed": {
+      if (hasControllerTurnAuthority(host)) {
+        host.logDebug("semantic:turn_failed_ignored_controller_authority", {
+          turnIndex: host._semanticTurnIndex,
+          recoveryState: host.agentSessionController?.turnRecoveryState
+        });
+        break;
+      }
       host.clearContinuationTimeout("turn_failed");
       host.emitExtensionEvent({
         type: "turn:failed",
@@ -61488,6 +61524,9 @@ function handleSemanticAgentEvent(host, event) {
     }
     case "status_snapshot_changed": {
       const snapshot = event.snapshot;
+      if (isControllerRecovering(host)) {
+        break;
+      }
       if (snapshot.phase === "idle" && !snapshot.hasPendingToolContinuation) {
         host.clearContinuationTimeout("status_idle");
         const outcome = host.executionState.markAwaitingContinuationStalled();
@@ -61509,6 +61548,13 @@ function handleSemanticAgentEvent(host, event) {
     }
   }
 }
+function hasControllerTurnAuthority(host) {
+  return host.agentSessionController?.turnRecoveryState !== void 0;
+}
+function isControllerRecovering(host) {
+  const state = host.agentSessionController?.turnRecoveryState;
+  return state === "retry_pending" || state === "retrying" || state === "compacting";
+}
 function handleMessageStart(host, event) {
   if (event.message?.role === "assistant") {
     host.clearContinuationTimeout("assistant_message_start");
@@ -64044,9 +64090,110 @@ function buildCliSystemPrompt(options) {
   ].filter(Boolean).join("\n\n");
 }
 
+// src/runtime/cli-auto-compaction.ts
+function calculateCliContextUsage(params) {
+  const messages = stripStaleUsageBeforeCompaction(
+    params.messages,
+    params.latestCompactionTimestamp ?? null
+  );
+  const estimate = estimateContextTokens(messages);
+  const usageMessage = estimate.lastUsageIndex !== null ? messages[estimate.lastUsageIndex] : void 0;
+  const usage = usageMessage?.role === "assistant" ? usageMessage.usage : void 0;
+  return {
+    tokens: estimate.tokens,
+    input: usage?.input ?? 0,
+    output: usage?.output ?? 0,
+    cacheRead: usage?.cacheRead ?? 0,
+    cacheWrite: usage?.cacheWrite ?? 0,
+    cost: usage?.cost.total ?? 0
+  };
+}
+function createCliAutoCompactDecision(params) {
+  const errorMessage3 = params.message?.role === "assistant" ? params.message.errorMessage : void 0;
+  if (errorMessage3 && params.isContextOverflowError(errorMessage3)) {
+    return { reason: "overflow", willRetry: true };
+  }
+  if (!params.autoCompactEnabled || params.contextWindow <= 0) {
+    return void 0;
+  }
+  const usage = calculateCliContextUsage({
+    messages: params.messages,
+    latestCompactionTimestamp: params.latestCompactionTimestamp
+  });
+  if (!usage.tokens) {
+    return void 0;
+  }
+  const tokenLimit = getAutoCompactTokenLimit(params.contextWindow, params.reserveTokens);
+  if (tokenLimit === void 0) {
+    return void 0;
+  }
+  return usage.tokens > tokenLimit ? { reason: "threshold", willRetry: false } : void 0;
+}
+function shouldCliAutoCompactTokens(params) {
+  if (!params.tokens || params.contextWindow <= 0) {
+    return false;
+  }
+  const tokenLimit = getAutoCompactTokenLimit(params.contextWindow, params.reserveTokens);
+  return tokenLimit !== void 0 && params.tokens > tokenLimit;
+}
+async function createCliAutoCompactionResult(params) {
+  if (params.context.signal?.aborted) {
+    return { aborted: true };
+  }
+  const activeEntryId = params.context.sessionManager.getActiveEntryId();
+  if (!activeEntryId) {
+    return { aborted: true };
+  }
+  const pathEntries = params.context.sessionManager.getPathToEntry(activeEntryId);
+  const firstKeptEntryId = findFirstKeptEntryId(pathEntries);
+  if (!firstKeptEntryId) {
+    return { aborted: true };
+  }
+  const compactOptions = {
+    model: params.model,
+    apiKey: params.apiKey,
+    systemPrompt: params.systemPrompt,
+    signal: params.context.signal
+  };
+  const summary = await createCompactionSummary(params.context.messages, compactOptions);
+  if (params.context.signal?.aborted) {
+    return { aborted: true };
+  }
+  return {
+    summary,
+    firstKeptEntryId,
+    tokensBefore: calculateTotalTokens(params.context.messages)
+  };
+}
+function stripStaleUsageBeforeCompaction(messages, latestCompactionTimestamp) {
+  if (latestCompactionTimestamp === null) {
+    return messages;
+  }
+  return messages.map((message) => {
+    if (message.role !== "assistant" || message.timestamp > latestCompactionTimestamp) {
+      return message;
+    }
+    return {
+      ...message,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      }
+    };
+  });
+}
+
 // src/runtime/retry-policy.ts
-var TRANSIENT_MODEL_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|sse stream aborted|sse stream closed before end|sse stream ended before response completed/i;
-var USER_ABORT_PATTERN = /request was aborted/i;
+var TRANSIENT_NETWORK_ERROR_PATTERN = /sse stream aborted|sse stream closed before end|sse stream ended before response completed|(?:read\s+)?ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|socket hang up|request timeout|client network socket disconnected before secure TLS connection was established|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated/i;
+var PROVIDER_TRANSIENT_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|\b429\b|\b500\b|\b502\b|\b503\b|\b504\b|service.?unavailable|server error|internal error|retry delay/i;
+var USER_ABORT_PATTERN = /request was aborted|local abort signal|user abort|user_interrupt|interrupted by user|esc pressed|ctrl\+c/i;
+var AUTH_CONFIG_PATTERN = /missing api key|invalid api key|api key.*invalid|unauthorized|\b401\b|\b403\b|forbidden|authentication failed|no configured model|no models? are configured/i;
+var INVALID_FILE_REFERENCE_PATTERN = /not the owner of this file|owner of this file|invalid_authentication_error/i;
+var INVALID_REQUEST_PATTERN = /bad request|\b400\b|invalid request|invalid schema|schema validation|invalid parameter|unsupported parameter|malformed/i;
 var CLI_RETRY_MAX_RETRIES = 3;
 var CLI_RETRY_BASE_DELAY_MS = 2e3;
 function isCliContextOverflowError(errorMessage3) {
@@ -64054,14 +64201,56 @@ function isCliContextOverflowError(errorMessage3) {
     errorMessage3
   );
 }
-function isCliRetryableError(errorMessage3) {
+function createClassification(kind, message, overrides) {
+  return {
+    kind,
+    message,
+    retryable: false,
+    compactable: false,
+    userAbort: false,
+    terminal: true,
+    ...overrides
+  };
+}
+function classifyCliFailure(context) {
+  const errorMessage3 = typeof context === "string" ? context : context.errorMessage;
   if (isCliContextOverflowError(errorMessage3)) {
-    return false;
+    return createClassification("context_overflow", errorMessage3, {
+      compactable: true,
+      terminal: false
+    });
   }
   if (USER_ABORT_PATTERN.test(errorMessage3)) {
-    return false;
+    return createClassification("user_abort", errorMessage3, {
+      userAbort: true,
+      terminal: false
+    });
+  }
+  if (INVALID_FILE_REFERENCE_PATTERN.test(errorMessage3)) {
+    return createClassification("invalid_file_reference", errorMessage3);
+  }
+  if (AUTH_CONFIG_PATTERN.test(errorMessage3)) {
+    return createClassification("auth_config", errorMessage3);
   }
-  return TRANSIENT_MODEL_ERROR_PATTERN.test(errorMessage3);
+  if (TRANSIENT_NETWORK_ERROR_PATTERN.test(errorMessage3)) {
+    return createClassification("transient_network", errorMessage3, {
+      retryable: true,
+      terminal: false
+    });
+  }
+  if (PROVIDER_TRANSIENT_ERROR_PATTERN.test(errorMessage3)) {
+    return createClassification("provider_transient", errorMessage3, {
+      retryable: true,
+      terminal: false
+    });
+  }
+  if (INVALID_REQUEST_PATTERN.test(errorMessage3)) {
+    return createClassification("invalid_request", errorMessage3);
+  }
+  return createClassification("unknown", errorMessage3);
+}
+function isCliRetryableError(errorMessage3) {
+  return classifyCliFailure(errorMessage3).retryable;
 }
 function getCliRetryBaseDelayMs() {
   const override = process.env.PIE_TEST_CLI_RETRY_BASE_DELAY_MS;
@@ -64078,78 +64267,13 @@ function calculateContextUsage(host) {
   if (messages.length === 0) {
     return { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
   }
-  let lastAssistantIndex = -1;
-  let lastUsage = null;
-  const latestCompactionTimestamp = host.sessionManager.getLatestCompactionTimestamp();
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "assistant") {
-      const assistantMsg = msg;
-      if (latestCompactionTimestamp !== null && assistantMsg.timestamp <= latestCompactionTimestamp) {
-        continue;
-      }
-      if (assistantMsg.usage && assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error") {
-        lastAssistantIndex = i;
-        lastUsage = assistantMsg.usage;
-        break;
-      }
-    }
-  }
-  if (!lastUsage || lastAssistantIndex < 0) {
-    const estimated = messages.reduce((sum, msg) => sum + estimateMessageTokens(msg), 0);
-    return { tokens: estimated, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-  }
-  const usageTokens = lastUsage.totalTokens || lastUsage.input + lastUsage.output + lastUsage.cacheRead + lastUsage.cacheWrite;
-  if (usageTokens <= 0) {
-    const estimated = messages.reduce((sum, msg) => sum + estimateMessageTokens(msg), 0);
-    return {
-      tokens: estimated,
-      input: lastUsage.input,
-      output: lastUsage.output,
-      cacheRead: lastUsage.cacheRead,
-      cacheWrite: lastUsage.cacheWrite,
-      cost: lastUsage.cost.total
-    };
-  }
-  let trailingTokens = 0;
-  for (let i = lastAssistantIndex + 1; i < messages.length; i++) {
-    trailingTokens += estimateMessageTokens(messages[i]);
-  }
-  return {
-    tokens: usageTokens + trailingTokens,
-    input: lastUsage.input,
-    output: lastUsage.output,
-    cacheRead: lastUsage.cacheRead,
-    cacheWrite: lastUsage.cacheWrite,
-    cost: lastUsage.cost.total
-  };
+  return calculateCliContextUsage({
+    messages,
+    latestCompactionTimestamp: host.sessionManager.getLatestCompactionTimestamp()
+  });
 }
 function estimateMessageTokens(msg) {
-  let chars = 0;
-  if (msg.role === "user") {
-    const content = msg.content;
-    if (typeof content === "string") {
-      chars = content.length;
-    } else if (Array.isArray(content)) {
-      for (const block of content) {
-        if (block.type === "text" && block.text) {
-          chars += block.text.length;
-        }
-      }
-    }
-  } else if (msg.role === "assistant") {
-    const assistant = msg;
-    for (const block of assistant.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 estimateTokens(msg);
 }
 function buildSystemPrompt(host) {
   const tools = (host.agent?.state?.tools ?? host.options.tools ?? []).filter((tool) => typeof tool.name === "string").map((tool) => ({
@@ -64299,9 +64423,8 @@ function isContextOverflowError(errorMessage3) {
 }
 function shouldAutoCompact(host, contextTokens, contextWindow) {
   if (!host.options.settingsManager.getAutoCompactEnabled()) return false;
-  if (!contextTokens || contextWindow <= 0) return false;
   const reserveTokens = host.options.settingsManager.getAutoCompactReserveTokens();
-  return contextTokens > contextWindow - reserveTokens;
+  return shouldCliAutoCompactTokens({ tokens: contextTokens, contextWindow, reserveTokens });
 }
 function isRetryableError(errorMessage3) {
   return isCliRetryableError(errorMessage3);
@@ -64746,28 +64869,6 @@ async function prepareAgentTurn(host, context) {
     messages: result.messages?.length ? [...context.messages, ...result.messages] : context.messages
   };
 }
-async function createAutoCompactionResult(host, messages) {
-  const activeEntryId = host.sessionManager.getActiveEntryId();
-  if (!activeEntryId) {
-    return { aborted: true };
-  }
-  const pathEntries = host.sessionManager.getPathToEntry(activeEntryId);
-  const firstKeptEntryId = findFirstKeptEntryId(pathEntries);
-  if (!firstKeptEntryId) {
-    return { aborted: true };
-  }
-  const compactOptions = {
-    model: host.options.model,
-    apiKey: host.options.apiKey,
-    systemPrompt: host.agent.state.systemPrompt
-  };
-  const summary = await createCompactionSummary(messages, compactOptions);
-  return {
-    summary,
-    firstKeptEntryId,
-    tokensBefore: calculateTotalTokens(messages)
-  };
-}
 function createInteractiveAgentSessionController(host) {
   return new AgentSessionController({
     agent: host.agent,
@@ -64787,14 +64888,16 @@ function createInteractiveAgentSessionController(host) {
       }
       return { allowed: true };
     },
-    getAutoCompactDecision: ({ message }) => {
+    getAutoCompactDecision: ({ message, messages }) => {
       if (message?.role === "assistant" && message.stopReason === "error" && message.errorMessage) {
         if (host._isContextOverflowError(message.errorMessage)) {
           return { reason: "overflow", willRetry: true };
         }
-        return void 0;
       }
-      const contextUsage = host.calculateContextUsage();
+      const contextUsage = calculateCliContextUsage({
+        messages,
+        latestCompactionTimestamp: host.sessionManager.getLatestCompactionTimestamp()
+      });
       const contextWindow = host.options.model?.contextWindow ?? 0;
       if (host._shouldAutoCompact(contextUsage.tokens, contextWindow)) {
         return { reason: "threshold", willRetry: false };
@@ -64802,13 +64905,19 @@ function createInteractiveAgentSessionController(host) {
       return void 0;
     },
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
+    classifyFailure: (context) => classifyCliFailure(context),
     retry: {
       isRetryableError: (errorMessage3) => !host._isContextOverflowError(errorMessage3) && isCliRetryableError(errorMessage3),
       maxRetries: CLI_RETRY_MAX_RETRIES,
       baseDelayMs: getCliRetryBaseDelayMs()
     },
     compaction: {
-      compact: async ({ messages }) => createAutoCompactionResult(host, messages)
+      compact: async (context) => createCliAutoCompactionResult({
+        context,
+        model: host.options.model,
+        apiKey: host.options.apiKey,
+        systemPrompt: host.agent.state.systemPrompt
+      })
     },
     onEvent: (event) => {
       host.sessionTrace.noteRuntimeEvent(event.type, event);
@@ -64831,11 +64940,15 @@ function createInteractiveAgentSessionController(host) {
           reason: event.reason,
           queueLength: host.agentSessionController?.pendingMessageCount ?? 0
         });
-      } else if (event.type === "retry_scheduled") {
-        host.showStatus(`Rate limited. Retrying in ${event.delayMs / 1e3}s... (attempt ${event.attempt}/${event.maxRetries})`);
-      } else if (event.type === "retry_start") {
+      } else if (event.type === "turn_recovery_pending") {
+        if (event.recovery === "retry") {
+          host.showStatus(`Transient request error. Retrying in ${(event.delayMs ?? 0) / 1e3}s... (attempt ${event.attempt}/${event.maxRetries})`);
+        } else {
+          host.showStatus(event.failure.kind === "context_overflow" ? "Context overflow detected, compacting..." : "Auto-compacting context before retry...");
+        }
+      } else if (event.type === "turn_retry_started") {
         host.showStatus(`Retrying request (attempt ${event.attempt}/${event.maxRetries})...`);
-      } else if (event.type === "retry_succeeded") {
+      } else if (event.type === "turn_retry_succeeded") {
         const outcome = host.executionState.resumePausedTodo();
         if (outcome.changed) {
           host.sessionTrace.noteRuntimeEvent("todo_resumed_after_retry", {
@@ -64846,12 +64959,80 @@ function createInteractiveAgentSessionController(host) {
           void host.refreshTodoWidget();
         }
         host.showStatus("Retry succeeded");
-      } else if (event.type === "retry_exhausted") {
+      } else if (event.type === "turn_completed") {
+        host.clearContinuationTimeout("turn_completed");
+        host.emitExtensionEvent({
+          type: "turn:completed",
+          turnIndex: host._semanticTurnIndex,
+          message: event.message,
+          toolResults: event.toolResults
+        });
+        const outcome = host.executionState.advanceFromCompletedTurn(event.message, event.toolResults || []);
+        host.logDebug("execution:turn_completed", {
+          turnIndex: host._semanticTurnIndex,
+          changed: outcome.changed,
+          currentStepId: host.executionState.read().currentStepId,
+          lifecycle: host.executionState.read().lifecycle,
+          reason: outcome.cleared ? `cleared_${outcome.terminalStatus}` : outcome.changed ? "completed_turn" : "unchanged"
+        });
+        if (outcome.changed) {
+          host.persistExecutionState();
+          void host.refreshTodoWidget();
+        }
+        if (outcome.terminalSummary) {
+          host.appendWarningSummary(outcome.terminalSummary);
+        }
+        host.sessionTrace.completeTurn(event.message, false);
+        host._semanticTurnIndex++;
+      } else if (event.type === "turn_failed_terminal") {
+        host.clearContinuationTimeout("turn_failed_terminal");
+        if (event.message) {
+          host.emitExtensionEvent({
+            type: "turn:failed",
+            turnIndex: host._semanticTurnIndex,
+            message: event.message,
+            toolResults: []
+          });
+        }
+        const outcome = host.executionState.handleTurnFailed();
+        host.logDebug("execution:turn_failed_terminal", {
+          turnIndex: host._semanticTurnIndex,
+          changed: outcome.changed,
+          currentStepId: host.executionState.read().currentStepId,
+          lifecycle: host.executionState.read().lifecycle,
+          kind: event.failure.kind
+        });
+        if (outcome.changed) {
+          host.persistExecutionState();
+          void host.refreshTodoWidget();
+        }
+        if (outcome.terminalSummary) {
+          host.appendWarningSummary(outcome.terminalSummary);
+        }
+        if (event.message) {
+          host.sessionTrace.completeTurn(event.message, true);
+        }
+        host._semanticTurnIndex++;
         const state = host.executionState.read();
         if (state.mode === "todo" && state.lifecycle === "paused" && state.steps.length > 0) {
           host.showStatus("Todo list preserved. Send 'continue' when you want to resume it.");
         }
-        host.showError(`Request failed after ${event.maxRetries} retries: ${event.errorMessage}`);
+        host.showError(event.failure.message);
+      } else if (event.type === "turn_cancelled") {
+        const outcome = host.executionState.abort();
+        host.logDebug("execution:turn_cancelled", {
+          turnIndex: host._semanticTurnIndex,
+          cleared: outcome.cleared,
+          lifecycle: host.executionState.read().lifecycle,
+          reason: event.reason
+        });
+        if (outcome.cleared || outcome.terminalSummary) {
+          host.persistExecutionState();
+          void host.refreshTodoWidget();
+        }
+        if (outcome.terminalSummary) {
+          host.appendWarningSummary(outcome.terminalSummary);
+        }
       } else if (event.type === "runtime_guard_triggered") {
         host.sessionTrace.noteStalled("runtime_guard_triggered", {
           toolName: event.toolName,
@@ -67497,16 +67678,38 @@ async function runPrintMode(params) {
       maxRetries: CLI_RETRY_MAX_RETRIES,
       baseDelayMs: getCliRetryBaseDelayMs()
     },
+    getAutoCompactDecision: ({ message, messages }) => createCliAutoCompactDecision({
+      message,
+      messages,
+      contextWindow: runtime.model.contextWindow ?? 0,
+      autoCompactEnabled: runtime.settingsManager.getAutoCompactEnabled(),
+      reserveTokens: runtime.settingsManager.getAutoCompactReserveTokens(),
+      latestCompactionTimestamp: runtime.sessionManager.getLatestCompactionTimestamp(),
+      isContextOverflowError: isCliContextOverflowError
+    }),
+    compaction: {
+      compact: async (context) => createCliAutoCompactionResult({
+        context,
+        model: runtime.model,
+        apiKey: runtime.apiKey,
+        systemPrompt: agent?.state.systemPrompt ?? baseSystemPrompt
+      })
+    },
+    classifyFailure: (context) => classifyCliFailure(context),
     onEvent: (event) => {
       sessionTrace.noteRuntimeEvent(event.type, event);
-      if (event.type === "retry_scheduled") {
-        console.error(`Transient request error: ${event.errorMessage}. Retrying in ${event.delayMs / 1e3}s (${event.attempt}/${event.maxRetries}).`);
-      } else if (event.type === "retry_start") {
+      if (event.type === "turn_recovery_pending" && event.recovery === "retry") {
+        console.error(`Transient request error: ${event.failure.message}. Retrying in ${(event.delayMs ?? 0) / 1e3}s (${event.attempt}/${event.maxRetries}).`);
+      } else if (event.type === "turn_recovery_pending" && event.recovery === "compaction") {
+        console.error(event.failure.kind === "context_overflow" ? "Context overflow detected, compacting..." : "Auto-compacting context before retry...");
+      } else if (event.type === "auto_compaction_start") {
+        console.error(event.reason === "overflow" ? "Context overflow detected, compacting..." : "Auto-compacting context...");
+      } else if (event.type === "turn_retry_started") {
         console.error(`Retrying request (${event.attempt}/${event.maxRetries})...`);
-      } else if (event.type === "retry_succeeded") {
+      } else if (event.type === "turn_retry_succeeded") {
         console.error(`Retry succeeded after ${event.attempts} attempt${event.attempts === 1 ? "" : "s"}.`);
-      } else if (event.type === "retry_exhausted") {
-        console.error(`Request failed after ${event.maxRetries} retries: ${event.errorMessage}`);
+      } else if (event.type === "turn_failed_terminal" && (event.failure.kind === "transient_network" || event.failure.kind === "provider_transient")) {
+        console.error(`Request failed after ${CLI_RETRY_MAX_RETRIES} retries: ${event.failure.message}`);
       }
     }
   });
@@ -67665,8 +67868,12 @@ function assistantTextFromAgent(agent) {
   const messages = agent?.state.messages ?? [];
   const lastMessage = messages[messages.length - 1];
   if (lastMessage?.role !== "assistant") return "";
+  return assistantTextFromMessage(lastMessage);
+}
+function assistantTextFromMessage(message) {
+  if (message.role !== "assistant") return "";
   let text = "";
-  for (const content of lastMessage.content) {
+  for (const content of message.content) {
     if (content.type === "text") {
       text += content.text;
     }
@@ -67818,6 +68025,24 @@ async function runJsonEventsMode(params) {
       chunk
     });
   }
+  function bufferAssistantOutput(chunk) {
+    if (!activeTurn || !chunk) return;
+    activeTurn.pendingAssistantOutput += chunk;
+    touch();
+  }
+  function clearPendingAssistantOutput() {
+    if (activeTurn) {
+      activeTurn.pendingAssistantOutput = "";
+    }
+  }
+  function flushAssistantOutput(fallbackText = "") {
+    if (!activeTurn) return;
+    const chunk = activeTurn.pendingAssistantOutput || fallbackText;
+    activeTurn.pendingAssistantOutput = "";
+    if (chunk) {
+      display(chunk);
+    }
+  }
   function finalize(kind, detail) {
     const turn = activeTurn;
     if (!turn || turn.finalized) return;
@@ -67837,11 +68062,23 @@ async function runJsonEventsMode(params) {
         break;
     }
   }
+  function rememberTerminal(kind, detail, options) {
+    if (!activeTurn || activeTurn.finalized) return;
+    if (activeTurn.pendingTerminal && options?.overwrite === false) return;
+    activeTurn.pendingTerminal = { kind, detail };
+    touch();
+  }
+  function finalizePendingTerminal() {
+    if (!activeTurn || activeTurn.finalized) return;
+    const pending = activeTurn.pendingTerminal;
+    if (!pending) return;
+    finalize(pending.kind, pending.detail);
+  }
   function handleSemanticEvent(event) {
     if (!activeTurn || activeTurn.finalized) return;
     switch (event.type) {
       case "assistant_response_delta":
-        display(event.delta);
+        bufferAssistantOutput(event.delta);
         break;
       case "tool_started":
         touch();
@@ -67883,26 +68120,48 @@ async function runJsonEventsMode(params) {
   }
   function handleControllerEvent(event) {
     trace?.noteRuntimeEvent(event.type, event);
+    if (event.type === "turn_settled" && activeTurn) {
+      finalizePendingTerminal();
+      writeEvent({
+        type: "turn.settled",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId
+      });
+      return;
+    }
     if (!activeTurn || activeTurn.finalized) return;
-    if (event.type === "retry_scheduled") {
+    if (event.type === "turn_recovery_pending" && event.recovery === "retry") {
       lastRetryEvent = {
-        attempt: event.attempt,
-        maxRetries: event.maxRetries,
+        attempt: event.attempt ?? 0,
+        maxRetries: event.maxRetries ?? CLI_RETRY_MAX_RETRIES,
         delayMs: event.delayMs,
-        error: event.errorMessage
+        error: event.failure.message
       };
       touch();
       writeEvent({
-        type: "turn.retry.scheduled",
+        type: "turn.recovery.pending",
         sessionId: activeTurn.sessionId,
         turnId: activeTurn.turnId,
+        recovery: event.recovery,
         attempt: event.attempt,
         maxRetries: event.maxRetries,
         delayMs: event.delayMs,
-        error: event.errorMessage
+        error: event.failure.message
       });
-    } else if (event.type === "retry_start") {
+    } else if (event.type === "turn_recovery_pending" && event.recovery === "compaction") {
       activeTurn.summary = "";
+      clearPendingAssistantOutput();
+      touch();
+      writeEvent({
+        type: "turn.recovery.pending",
+        sessionId: activeTurn.sessionId,
+        turnId: activeTurn.turnId,
+        recovery: event.recovery,
+        error: event.failure.message
+      });
+    } else if (event.type === "turn_retry_started") {
+      activeTurn.summary = "";
+      clearPendingAssistantOutput();
       lastRetryEvent = {
         attempt: event.attempt,
         maxRetries: event.maxRetries,
@@ -67919,7 +68178,7 @@ async function runJsonEventsMode(params) {
         delayMs: lastRetryEvent.delayMs,
         error: lastRetryEvent.error
       });
-    } else if (event.type === "retry_succeeded") {
+    } else if (event.type === "turn_retry_succeeded") {
       touch();
       writeEvent({
         type: "turn.retry.succeeded",
@@ -67931,18 +68190,40 @@ async function runJsonEventsMode(params) {
         error: lastRetryEvent?.error
       });
       lastRetryEvent = void 0;
-    } else if (event.type === "retry_exhausted") {
+    } else if (event.type === "turn_compaction_started") {
+      if (event.willRetry) {
+        activeTurn.summary = "";
+        clearPendingAssistantOutput();
+      }
       touch();
       writeEvent({
-        type: "turn.retry.exhausted",
+        type: "turn.compaction.started",
         sessionId: activeTurn.sessionId,
         turnId: activeTurn.turnId,
-        attempt: lastRetryEvent?.attempt ?? event.maxRetries,
-        maxRetries: event.maxRetries,
-        delayMs: lastRetryEvent?.delayMs,
-        error: event.errorMessage
+        reason: event.reason,
+        willRetry: event.willRetry
       });
-      lastRetryEvent = void 0;
+    } else if (event.type === "turn_completed") {
+      const text = assistantTextFromMessage(event.message);
+      flushAssistantOutput(text);
+      rememberTerminal("completed", text || activeTurn.summary.trim());
+    } else if (event.type === "turn_failed_terminal") {
+      touch();
+      if (lastRetryEvent) {
+        writeEvent({
+          type: "turn.retry.exhausted",
+          sessionId: activeTurn.sessionId,
+          turnId: activeTurn.turnId,
+          attempt: lastRetryEvent.attempt,
+          maxRetries: lastRetryEvent.maxRetries,
+          delayMs: lastRetryEvent.delayMs,
+          error: event.failure.message
+        });
+        lastRetryEvent = void 0;
+      }
+      rememberTerminal("failed", event.failure.message);
+    } else if (event.type === "turn_cancelled") {
+      rememberTerminal("cancelled", event.reason, { overwrite: false });
     }
   }
   async function ensureRuntime() {
@@ -68006,6 +68287,24 @@ async function runJsonEventsMode(params) {
         maxRetries: CLI_RETRY_MAX_RETRIES,
         baseDelayMs: getCliRetryBaseDelayMs()
       },
+      getAutoCompactDecision: ({ message, messages }) => createCliAutoCompactDecision({
+        message,
+        messages,
+        contextWindow: runtime.model.contextWindow ?? 0,
+        autoCompactEnabled: runtime.settingsManager.getAutoCompactEnabled(),
+        reserveTokens: runtime.settingsManager.getAutoCompactReserveTokens(),
+        latestCompactionTimestamp: runtime.sessionManager.getLatestCompactionTimestamp(),
+        isContextOverflowError: isCliContextOverflowError
+      }),
+      compaction: {
+        compact: async (context) => createCliAutoCompactionResult({
+          context,
+          model: runtime.model,
+          apiKey: runtime.apiKey,
+          systemPrompt: agent?.state.systemPrompt ?? baseSystemPrompt
+        })
+      },
+      classifyFailure: (context) => classifyCliFailure(context),
       onEvent: handleControllerEvent
     });
     trace = new SessionTraceWriter(runtime.paths.sessionsDir, runtime.sessionManager);
@@ -68042,7 +68341,8 @@ async function runJsonEventsMode(params) {
       interrupted: false,
       stalled: false,
       finalized: false,
-      summary: ""
+      summary: "",
+      pendingAssistantOutput: ""
     };
     const turn = activeTurn;
     writeEvent({ type: "turn.started", sessionId: activeTurn.sessionId, turnId: activeTurn.turnId });
@@ -68099,6 +68399,7 @@ async function runJsonEventsMode(params) {
       trace?.noteWaitForIdleStart({ mode: "json-events" });
       await controller.waitForSettled();
       trace?.noteWaitForIdleSettled({ mode: "json-events" });
+      finalizePendingTerminal();
       if (!activeTurn?.finalized) {
         const finalError = assistantErrorFromAgent(agent);
         if (activeTurn?.interrupted) {
@@ -68110,9 +68411,7 @@ async function runJsonEventsMode(params) {
           return;
         }
         const text = assistantTextFromAgent(agent);
-        if (!activeTurn?.summary && text) {
-          display(text);
-        }
+        flushAssistantOutput(text);
         finalize("completed", text || activeTurn?.summary.trim());
       }
     } catch (error) {
@@ -68176,7 +68475,11 @@ async function runJsonEventsMode(params) {
       if (activeTurn && !activeTurn.finalized) {
         activeTurn.interrupted = true;
         controller?.abort();
-        finalize("cancelled", message.reason || "shutdown");
+        if (!controller) {
+          finalize("cancelled", message.reason || "shutdown");
+        } else {
+          rememberTerminal("cancelled", message.reason || "shutdown");
+        }
       }
       break;
     }