shortcutxl 0.3.70 → 0.3.71

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.3.71]
+
+- **Responsive retry recovery** - CLI sessions now keep showing retry progress and can cancel an active retry without freezing.
+
 ## [0.3.70]
 
 - **GPT-5.6 Sol default** - ShortcutXL now defaults CLI and embedded sessions to GPT-5.6 Sol and shows clearer compact model labels.

package/dist/app/agent-session.d.ts

@@ -499,7 +499,7 @@ export declare class AgentSession {
         warnings: string[];
     }>;
     /** Cancel in-progress recovery. */
-    abortRetry(): void;
+    abortRetry(): Promise<void>;
     /** Whether error recovery is currently in progress */
     get isRetrying(): boolean;
     /** Whether auto-retry is enabled */

package/dist/app/agent-session.js

@@ -452,16 +452,8 @@ export class AgentSession {
             await this._extensions.extensionRunner.runPostTurnHandlers(turnIndex, event.message, event.toolResults);
         }
         // --- Step 5: Retry success tracking (sync) ---
-        // Resolve the retry promise only when the retried agent loop finishes
-        // successfully (agent_end with no error). Resolving on message_end was a
-        // race condition: session.prompt() would return while the retry loop was
-        // still executing tool calls, causing print-mode to exit and kill the
-        // in-flight tool execution.
-        if (event.type === 'agent_end' && this._recovery.attempt > 0) {
-            const lastAssistant = this._findLastAssistantInMessages(event.messages);
-            if (!lastAssistant || lastAssistant.stopReason !== 'error') {
-                this._recovery.onSuccess();
-            }
+        if (event.type === 'agent_end') {
+            this._recovery.settleAgentEnd(this._findLastAssistantInMessages(event.messages), this._checkContextOverflow);
         }
         // --- Step 6: Post-agent: stop hooks → retry → compaction (async, sequential, conditional) ---
         if (event.type === 'agent_end') {
@@ -1016,6 +1008,8 @@ export class AgentSession {
             await this.agent.prompt(messages);
             await this._agentEventQueue.catch(() => { });
             await this._recovery.wait();
+            // Keep prompt open until a cancelled continuation observes its abort signal.
+            await this.agent.waitForIdle();
         }
         finally {
             await this._agentEventQueue.catch(() => { });
@@ -1051,6 +1045,7 @@ export class AgentSession {
             await this.agent.prompt([buildGoalContinuationMessage(goal)]);
             await this._agentEventQueue.catch(() => { });
             await this._recovery.wait();
+            await this.agent.waitForIdle();
         }
         finally {
             await this._agentEventQueue.catch(() => { });
@@ -1434,8 +1429,13 @@ export class AgentSession {
     // Error Recovery (delegated to SessionErrorRecovery)
     // =========================================================================
     /** Cancel in-progress recovery. */
-    abortRetry() {
+    async abortRetry() {
+        const wasRetrying = this._recovery.isRetrying;
         this._recovery.abort();
+        if (!wasRetrying)
+            return;
+        this.agent.abort();
+        await this.agent.waitForIdle();
     }
     /** Whether error recovery is currently in progress */
     get isRetrying() {

package/dist/app/providers/shortcut-api-v2-transport.js

@@ -17,6 +17,7 @@ export function resolveShortcutApiV2Transport(modelId) {
     const normalized = modelId.trim().toLowerCase();
     // Shortcut-hosted "Pivot" and Fireworks GLM both speak OpenAI completions.
     if (normalized === SHORTCUT_MODEL_ID.Hosted ||
+        normalized === SHORTCUT_MODEL_ID.Grok45 ||
         normalized === SHORTCUT_MODEL_ID.Glm52Fireworks.toLowerCase() ||
         normalized.startsWith('accounts/fireworks/')) {
         return 'openai-completions';

package/dist/cli.js

@@ -283150,6 +283150,7 @@ var init_model_ids = __esm({
       ClaudeOpus48: "claude-opus-4-8",
       Glm52Fireworks: "accounts/fireworks/models/glm-5p2",
       Gpt56Sol: "gpt-5.6-sol",
+      Grok45: "grok-4.5",
       Hosted: "pivot",
       Gemini3Flash: "gemini-3-flash-preview",
       ClaudeHaiku45: "claude-haiku-4-5-20251001"
@@ -283159,6 +283160,7 @@ var init_model_ids = __esm({
       ClaudeOpus48: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.ClaudeOpus48}`,
       Glm52Fireworks: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Glm52Fireworks}`,
       Gpt56Sol: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Gpt56Sol}`,
+      Grok45: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Grok45}`,
       Hosted: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Hosted}`
     };
     SHORTCUT_OPENAI_MODEL_ID = SHORTCUT_MODEL_ID.Gpt56Sol;
@@ -323554,6 +323556,17 @@ var init_validation = __esm({
 });
 
 // src/contracts/model-stream.ts
+function isTerminalModelStreamErrorDetails(details) {
+  if (!details) return false;
+  if (details.status === 402) return true;
+  return details.code !== void 0 && TERMINAL_MODEL_STREAM_ERROR_CODE_SET.has(details.code);
+}
+function isInsufficientCreditsModelStreamFailure(details, message) {
+  return details?.status === 402 || details?.code === INSUFFICIENT_CREDITS_ERROR_CODE || message === INSUFFICIENT_CREDITS_SAFE_MESSAGE;
+}
+function isTerminalModelStreamFailure(details, message) {
+  return isTerminalModelStreamErrorDetails(details) || message === INSUFFICIENT_CREDITS_SAFE_MESSAGE;
+}
 function isRecord(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -323581,8 +323594,8 @@ function isShortcutXLModelStreamErrorDetails(value) {
   return true;
 }
 function safeModelStreamErrorMessage(details) {
-  if (details?.code === "insufficient_credits" || details?.status === 402) {
-    return "Insufficient credits. Purchase more credits to continue using paid models.";
+  if (isInsufficientCreditsModelStreamFailure(details, void 0)) {
+    return INSUFFICIENT_CREDITS_SAFE_MESSAGE;
   }
   if (details?.code === "context_overflow") {
     return "The conversation exceeded the model context window.";
@@ -323659,7 +323672,7 @@ function extractStructuredHttpErrorPayload(value) {
   }
   return void 0;
 }
-var LLMErrorMetadataHeaders, ShortcutXLModelStreamFetchStage, STREAM_ERROR_PROVIDER_TYPES, MODEL_ACCESS_DENIED_PROVIDER_ERROR_TYPE, MODEL_ACCESS_DENIED_MESSAGE_PATTERN;
+var LLMErrorMetadataHeaders, ShortcutXLModelStreamFetchStage, INSUFFICIENT_CREDITS_ERROR_CODE, INSUFFICIENT_CREDITS_SAFE_MESSAGE, TERMINAL_MODEL_STREAM_ERROR_CODES, TERMINAL_MODEL_STREAM_ERROR_CODE_SET, STREAM_ERROR_PROVIDER_TYPES, MODEL_ACCESS_DENIED_PROVIDER_ERROR_TYPE, MODEL_ACCESS_DENIED_MESSAGE_PATTERN;
 var init_model_stream = __esm({
   "src/contracts/model-stream.ts"() {
     "use strict";
@@ -323681,6 +323694,21 @@ var init_model_stream = __esm({
       /** Response started but the SSE read failed or idle-timed out mid-stream. */
       ResponseBody: "response_body"
     };
+    INSUFFICIENT_CREDITS_ERROR_CODE = "insufficient_credits";
+    INSUFFICIENT_CREDITS_SAFE_MESSAGE = "Insufficient credits. Purchase more credits to continue using paid models.";
+    TERMINAL_MODEL_STREAM_ERROR_CODES = [
+      INSUFFICIENT_CREDITS_ERROR_CODE,
+      "customer_credential_scope_required",
+      "customer_credential_resolution_failed",
+      "customer_credential_resolution_timeout",
+      "customer_credential_resolution_cancelled",
+      "customer_credential_unconfigured",
+      "unsupported_credential_mode",
+      "model_policy_rejected"
+    ];
+    TERMINAL_MODEL_STREAM_ERROR_CODE_SET = new Set(
+      TERMINAL_MODEL_STREAM_ERROR_CODES
+    );
     STREAM_ERROR_PROVIDER_TYPES = /* @__PURE__ */ new Set([
       "overloaded",
       "rate_limit",
@@ -324045,10 +324073,7 @@ function getErrorDetails(message) {
 }
 function classifyStructuredError(details) {
   if (!details) return null;
-  if (details.code !== void 0 && TERMINAL_GATEWAY_ERROR_CODES.has(details.code)) {
-    return "terminal";
-  }
-  if (details.status === 402) return "terminal";
+  if (isTerminalModelStreamErrorDetails(details)) return "terminal";
   if (details.providerErrorType === "unauthorized" || details.status === 401) return "auth_error";
   if (details.providerErrorType === "rate_limit" || details.status === 429) return "rate_limit";
   if (details.providerErrorType === "overloaded" || details.status === 529) return "overloaded";
@@ -324060,22 +324085,28 @@ function classifyStructuredError(details) {
   }
   return null;
 }
-function classifyError(message, isContextOverflow2) {
-  if (message.stopReason !== "error") return null;
-  if (!message.errorMessage) return null;
-  if (isContextOverflow2(message)) return "context_overflow";
-  const structuredCategory = classifyStructuredError(getErrorDetails(message));
+function classifyErrorDisposition(message, isContextOverflow2) {
+  if (message.stopReason !== "error") return { kind: "none" };
+  if (!message.errorMessage) return { kind: "none" };
+  if (isContextOverflow2(message)) return { kind: "categorized", category: "context_overflow" };
+  const details = getErrorDetails(message);
+  const structuredCategory = classifyStructuredError(details);
   if (structuredCategory === "terminal") {
-    return null;
+    return { kind: "terminal" };
   }
-  if (structuredCategory) return structuredCategory;
+  if (structuredCategory) return { kind: "categorized", category: structuredCategory };
   const err = message.errorMessage;
-  if (AUTH_ERROR_PATTERN.test(err)) return "auth_error";
-  if (RATE_LIMIT_PATTERN.test(err)) return "rate_limit";
-  if (OVERLOADED_PATTERN.test(err)) return "overloaded";
-  if (SERVER_ERROR_PATTERN.test(err)) return "server_error";
-  if (CONNECTION_ERROR_PATTERN.test(err)) return "server_error";
-  return "unknown";
+  if (isTerminalModelStreamFailure(details, err)) return { kind: "terminal" };
+  if (AUTH_ERROR_PATTERN.test(err)) return { kind: "categorized", category: "auth_error" };
+  if (RATE_LIMIT_PATTERN.test(err)) return { kind: "categorized", category: "rate_limit" };
+  if (OVERLOADED_PATTERN.test(err)) return { kind: "categorized", category: "overloaded" };
+  if (SERVER_ERROR_PATTERN.test(err)) return { kind: "categorized", category: "server_error" };
+  if (CONNECTION_ERROR_PATTERN.test(err)) return { kind: "categorized", category: "server_error" };
+  return { kind: "categorized", category: "unknown" };
+}
+function classifyError(message, isContextOverflow2) {
+  const disposition = classifyErrorDisposition(message, isContextOverflow2);
+  return disposition.kind === "categorized" ? disposition.category : null;
 }
 function computeDelay(config2, attempt) {
   if (config2.baseDelayMs === 0) return 0;
@@ -324087,26 +324118,17 @@ function computeDelay(config2, attempt) {
 function getCompactionKeepRecentTokens(attempt) {
   return COMPACTION_ESCALATION[Math.min(attempt - 1, COMPACTION_ESCALATION.length - 1)];
 }
-var AUTH_ERROR_PATTERN, RATE_LIMIT_PATTERN, OVERLOADED_PATTERN, SERVER_ERROR_PATTERN, CONNECTION_ERROR_PATTERN, TERMINAL_GATEWAY_ERROR_CODES, SERVER_ERROR_MAX_ATTEMPTS, STRATEGY_CONFIGS, COMPACTION_ESCALATION, SessionErrorRecovery;
+var AUTH_ERROR_PATTERN, RATE_LIMIT_PATTERN, OVERLOADED_PATTERN, SERVER_ERROR_PATTERN, CONNECTION_ERROR_PATTERN, SERVER_ERROR_MAX_ATTEMPTS, STRATEGY_CONFIGS, COMPACTION_ESCALATION, SessionErrorRecovery;
 var init_session_error_recovery = __esm({
   "src/core/session/session-error-recovery.ts"() {
     "use strict";
+    init_model_stream();
     init_sleep();
     AUTH_ERROR_PATTERN = /\b401\b|invalid.?api.?key|unauthorized|authentication.?failed/i;
     RATE_LIMIT_PATTERN = /rate.?limit|too many requests|\b429\b/i;
     OVERLOADED_PATTERN = /overloaded|\b529\b/i;
     SERVER_ERROR_PATTERN = /\b500\b|\b502\b|\b503\b|\b504\b|\b524\b|service.?unavailable|server error|internal error/i;
     CONNECTION_ERROR_PATTERN = /connection.?error|connection.?refused|other side closed|fetch failed|failed to fetch|upstream.?connect|reset before headers|terminated|retry delay|peer closed|complete message body|load failed|network.?error|internet connection appears to be offline/i;
-    TERMINAL_GATEWAY_ERROR_CODES = /* @__PURE__ */ new Set([
-      "insufficient_credits",
-      "customer_credential_scope_required",
-      "customer_credential_resolution_failed",
-      "customer_credential_resolution_timeout",
-      "customer_credential_resolution_cancelled",
-      "customer_credential_unconfigured",
-      "unsupported_credential_mode",
-      "model_policy_rejected"
-    ]);
     SERVER_ERROR_MAX_ATTEMPTS = 5;
     STRATEGY_CONFIGS = {
       rate_limit: {
@@ -324195,11 +324217,13 @@ var init_session_error_recovery = __esm({
       _emit(event) {
         this._listener?.(event);
       }
-      async _continueRecovery(category, attempt, actions) {
-        try {
-          await actions.continue();
-          return true;
-        } catch (error2) {
+      _continueRecovery(category, attempt, actions) {
+        const activeRecovery = this._promise;
+        void Promise.resolve().then(() => {
+          if (!activeRecovery || this._promise !== activeRecovery) return;
+          return actions.continue();
+        }).catch((error2) => {
+          if (!activeRecovery || this._promise !== activeRecovery) return;
           this._emit({
             type: "recovery_end",
             category,
@@ -324208,17 +324232,37 @@ var init_session_error_recovery = __esm({
             finalError: error2 instanceof Error ? error2.message : String(error2)
           });
           this._reset();
-          return false;
-        }
+        });
+        return true;
       }
       /** Reset all state to idle. */
       _reset() {
+        this._abortController = void 0;
         this._attempt = 0;
         this._category = null;
         this._resolve?.();
         this._resolve = void 0;
         this._promise = void 0;
       }
+      /** Emit a cancellation event once for an active, visible recovery. */
+      _emitCancelledRecovery() {
+        if (!this._promise || this._attempt <= 0 || !this._category) return;
+        this._emit({
+          type: "recovery_end",
+          category: this._category,
+          success: false,
+          attempt: this._attempt,
+          finalError: "Recovery cancelled"
+        });
+      }
+      /** Cancel recovery state and any in-progress backoff sleep. */
+      _cancelRecovery() {
+        const abortController = this._abortController;
+        this._abortController = void 0;
+        this._emitCancelledRecovery();
+        this._reset();
+        abortController?.abort();
+      }
       /**
        * Create the recovery promise synchronously when an agent_end event arrives.
        *
@@ -324256,6 +324300,15 @@ var init_session_error_recovery = __esm({
         }
         const config2 = STRATEGY_CONFIGS[category];
         if (config2.maxAttempts === 0) {
+          if (this._attempt > 0 || this._promise) {
+            this._emit({
+              type: "recovery_end",
+              category: this._category ?? category,
+              success: false,
+              attempt: this._attempt,
+              finalError: message.errorMessage
+            });
+          }
           this._reset();
           return false;
         }
@@ -324379,6 +324432,7 @@ var init_session_error_recovery = __esm({
       }
       /** Handle abort during sleep. */
       _handleAbort(category) {
+        if (!this._promise) return false;
         const attempt = this._attempt;
         this._abortController = void 0;
         this._emit({
@@ -324406,10 +324460,37 @@ var init_session_error_recovery = __esm({
         });
         this._reset();
       }
+      /**
+       * Called when a continuation turn reaches an unrecoverable assistant error.
+       * This resolves the in-flight recovery as failed instead of treating the
+       * terminal, non-retryable failure as a successful retry.
+       */
+      onTerminalFailure(finalError) {
+        if (this._attempt <= 0) return;
+        const category = this._category ?? "unknown";
+        this._emit({
+          type: "recovery_end",
+          category,
+          success: false,
+          attempt: this._attempt,
+          finalError
+        });
+        this._reset();
+      }
+      /** Settle recovery when a continuation agent loop reaches agent_end. */
+      settleAgentEnd(lastAssistant, isContextOverflow2) {
+        if (this._attempt <= 0) return;
+        if (!lastAssistant || lastAssistant.stopReason !== "error") {
+          this.onSuccess();
+          return;
+        }
+        if (classifyErrorDisposition(lastAssistant, isContextOverflow2).kind === "terminal") {
+          this.onTerminalFailure(lastAssistant.errorMessage);
+        }
+      }
       /** Cancel in-progress recovery. */
       abort() {
-        this._abortController?.abort();
-        this._reset();
+        this._cancelRecovery();
       }
       /** Wait for any in-progress recovery to complete. */
       async wait() {
@@ -431129,7 +431210,8 @@ function cloneShortcutModelDefinition(model) {
   return {
     ...model,
     input: [...model.input],
-    cost: { ...model.cost }
+    cost: { ...model.cost },
+    ...model.compat ? { compat: { ...model.compat } } : {}
   };
 }
 function createShortcutPublicModelDefinitions() {
@@ -431174,6 +431256,21 @@ var init_shortcut_model_catalog = __esm({
         contextWindow: 1e6,
         maxTokens: 128e3
       },
+      {
+        id: SHORTCUT_MODEL_ID.Grok45,
+        name: "Grok 4.5",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+        contextWindow: 5e5,
+        maxTokens: 128e3,
+        compat: {
+          supportsStore: false,
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: true,
+          maxTokensField: "max_completion_tokens"
+        }
+      },
       {
         id: SHORTCUT_MODEL_ID.Glm52Fireworks,
         name: "GLM 5.2",
@@ -431583,7 +431680,7 @@ var init_google_vertex_gateway = __esm({
 // src/app/providers/shortcut-api-v2-transport.ts
 function resolveShortcutApiV2Transport(modelId) {
   const normalized = modelId.trim().toLowerCase();
-  if (normalized === SHORTCUT_MODEL_ID.Hosted || normalized === SHORTCUT_MODEL_ID.Glm52Fireworks.toLowerCase() || normalized.startsWith("accounts/fireworks/")) {
+  if (normalized === SHORTCUT_MODEL_ID.Hosted || normalized === SHORTCUT_MODEL_ID.Grok45 || normalized === SHORTCUT_MODEL_ID.Glm52Fireworks.toLowerCase() || normalized.startsWith("accounts/fireworks/")) {
     return "openai-completions";
   }
   if (normalized.startsWith("claude-")) {
@@ -453414,9 +453511,6 @@ function operationKindToFailureCategory(kind, message) {
       return RunFailureCategory.LlmStreamFailed;
   }
 }
-function isInsufficientCreditsFailure(details) {
-  return details?.status === 402 || details?.code === "insufficient_credits";
-}
 function createOperationFailureCause(input) {
   const category = operationKindToFailureCategory(input.opKind, input.errorMessage);
   return {
@@ -453430,6 +453524,17 @@ function createOperationFailureCause(input) {
   };
 }
 function classifyModelStreamFailure(details, message) {
+  if (isInsufficientCreditsModelStreamFailure(details, message)) {
+    return {
+      category: RunFailureCategory.BillingInsufficientCredits,
+      source: RunFailureSource.Billing,
+      httpStatus: details?.status,
+      errorCode: details?.code ?? INSUFFICIENT_CREDITS_ERROR_CODE,
+      retryable: details?.retryable,
+      retryAfterMs: details?.retryAfterMs,
+      transportFailureStage: details?.transportFailureStage
+    };
+  }
   if (details) {
     if (details.providerErrorType === "model_access_denied" || details.code === "model_access_denied") {
       return {
@@ -453472,17 +453577,6 @@ function classifyModelStreamFailure(details, message) {
         transportFailureStage: details.transportFailureStage
       };
     }
-    if (isInsufficientCreditsFailure(details)) {
-      return {
-        category: RunFailureCategory.BillingInsufficientCredits,
-        source: RunFailureSource.Billing,
-        httpStatus: details.status,
-        errorCode: details.code ?? "insufficient_credits",
-        retryable: details.retryable,
-        retryAfterMs: details.retryAfterMs,
-        transportFailureStage: details.transportFailureStage
-      };
-    }
     if (details.providerErrorType === "network" && details.transportFailureStage === ShortcutXLModelStreamFetchStage.BeforeResponse) {
       return {
         category: RunFailureCategory.LlmFetchFailed,
@@ -453603,7 +453697,7 @@ var init_run_failure = __esm({
     init_error_classification();
     init_session_error_recovery();
     SAFE_MESSAGE_BY_CATEGORY = {
-      [RunFailureCategory.BillingInsufficientCredits]: "Insufficient credits. Purchase more credits to continue using paid models.",
+      [RunFailureCategory.BillingInsufficientCredits]: INSUFFICIENT_CREDITS_SAFE_MESSAGE,
       [RunFailureCategory.CompactionFailed]: "Context compaction failed.",
       [RunFailureCategory.CompactionTimeout]: "Context compaction timed out.",
       [RunFailureCategory.ContextTooLong]: "The conversation exceeded the model context window.",
@@ -473984,11 +474078,11 @@ ${budgetText}` : budgetText;
             event.toolResults
           );
         }
-        if (event.type === "agent_end" && this._recovery.attempt > 0) {
-          const lastAssistant = this._findLastAssistantInMessages(event.messages);
-          if (!lastAssistant || lastAssistant.stopReason !== "error") {
-            this._recovery.onSuccess();
-          }
+        if (event.type === "agent_end") {
+          this._recovery.settleAgentEnd(
+            this._findLastAssistantInMessages(event.messages),
+            this._checkContextOverflow
+          );
         }
         if (event.type === "agent_end") {
           const stopHookContinued = await this._runStopHooks(event.messages);
@@ -474516,6 +474610,7 @@ ${budgetText}` : budgetText;
           await this._agentEventQueue.catch(() => {
           });
           await this._recovery.wait();
+          await this.agent.waitForIdle();
         } finally {
           await this._agentEventQueue.catch(() => {
           });
@@ -474551,6 +474646,7 @@ ${budgetText}` : budgetText;
           await this._agentEventQueue.catch(() => {
           });
           await this._recovery.wait();
+          await this.agent.waitForIdle();
         } finally {
           await this._agentEventQueue.catch(() => {
           });
@@ -474939,8 +475035,12 @@ ${budgetText}` : budgetText;
       // Error Recovery (delegated to SessionErrorRecovery)
       // =========================================================================
       /** Cancel in-progress recovery. */
-      abortRetry() {
+      async abortRetry() {
+        const wasRetrying = this._recovery.isRetrying;
         this._recovery.abort();
+        if (!wasRetrying) return;
+        this.agent.abort();
+        await this.agent.waitForIdle();
       }
       /** Whether error recovery is currently in progress */
       get isRetrying() {
@@ -540208,7 +540308,7 @@ ${message}`, ["Yes", "No"], opts);
       handleRecoveryStartEvent(event) {
         this.retryEscapeHandler = this.defaultEditor.onEscape;
         this.defaultEditor.onEscape = () => {
-          this.session.abortRetry();
+          void this.session.abortRetry();
         };
         const retryChildren = this.chatContainer.children;
         for (let i2 = retryChildren.length - 1; i2 >= 0; i2--) {
@@ -540240,7 +540340,9 @@ ${message}`, ["Yes", "No"], opts);
           this.retryLoader = void 0;
           this.statusContainer.clear();
         }
-        if (!event.success) {
+        if (!event.success && event.finalError === "Recovery cancelled") {
+          this.showStatus("Recovery cancelled");
+        } else if (!event.success) {
           this.showError(
             `Recovery failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`
           );
@@ -544779,7 +544881,7 @@ async function runRpcMode(session) {
         return success2(id, "set_auto_retry");
       }
       case "abort_retry": {
-        session.abortRetry();
+        await session.abortRetry();
         return success2(id, "abort_retry");
       }
       // =================================================================

package/dist/contracts/model-stream.d.ts

@@ -136,6 +136,10 @@ export interface ShortcutXLModelStreamFetchTrace {
     readonly effortLevel?: ShortcutXLModelStreamEffortLevel;
     readonly speed?: 'fast' | 'standard';
     readonly thinkingType?: ShortcutXLModelStreamThinkingType;
+    /** Runtime run id when the host can safely correlate this fetch to an active run. */
+    readonly runId?: string;
+    /** Conversation/thread id when the host can safely correlate this fetch to a thread. */
+    readonly threadId?: string;
     readonly sessionId?: string;
     readonly userMessageId?: string;
     readonly messageCount?: number;
@@ -200,6 +204,12 @@ export interface ShortcutXLModelStreamErrorDetails {
     /** Client-side transport stage when the browser fetch failed outside HTTP. */
     readonly transportFailureStage?: ShortcutXLModelStreamFetchStage;
 }
+export declare const INSUFFICIENT_CREDITS_ERROR_CODE = "insufficient_credits";
+export declare const INSUFFICIENT_CREDITS_SAFE_MESSAGE = "Insufficient credits. Purchase more credits to continue using paid models.";
+export declare const TERMINAL_MODEL_STREAM_ERROR_CODES: readonly ["insufficient_credits", "customer_credential_scope_required", "customer_credential_resolution_failed", "customer_credential_resolution_timeout", "customer_credential_resolution_cancelled", "customer_credential_unconfigured", "unsupported_credential_mode", "model_policy_rejected"];
+export declare function isTerminalModelStreamErrorDetails(details: ShortcutXLModelStreamErrorDetails | undefined): boolean;
+export declare function isInsufficientCreditsModelStreamFailure(details: ShortcutXLModelStreamErrorDetails | undefined, message: string | undefined): boolean;
+export declare function isTerminalModelStreamFailure(details: ShortcutXLModelStreamErrorDetails | undefined, message: string | undefined): boolean;
 export interface ShortcutXLAgentAssistantMessage {
     readonly api: string;
     readonly content: readonly ShortcutXLAgentAssistantContent[];

package/dist/contracts/model-stream.js

@@ -86,6 +86,34 @@ export const ShortcutXLModelStreamFetchStage = {
     /** Response started but the SSE read failed or idle-timed out mid-stream. */
     ResponseBody: 'response_body'
 };
+export const INSUFFICIENT_CREDITS_ERROR_CODE = 'insufficient_credits';
+export const INSUFFICIENT_CREDITS_SAFE_MESSAGE = 'Insufficient credits. Purchase more credits to continue using paid models.';
+export const TERMINAL_MODEL_STREAM_ERROR_CODES = [
+    INSUFFICIENT_CREDITS_ERROR_CODE,
+    'customer_credential_scope_required',
+    'customer_credential_resolution_failed',
+    'customer_credential_resolution_timeout',
+    'customer_credential_resolution_cancelled',
+    'customer_credential_unconfigured',
+    'unsupported_credential_mode',
+    'model_policy_rejected'
+];
+const TERMINAL_MODEL_STREAM_ERROR_CODE_SET = new Set(TERMINAL_MODEL_STREAM_ERROR_CODES);
+export function isTerminalModelStreamErrorDetails(details) {
+    if (!details)
+        return false;
+    if (details.status === 402)
+        return true;
+    return details.code !== undefined && TERMINAL_MODEL_STREAM_ERROR_CODE_SET.has(details.code);
+}
+export function isInsufficientCreditsModelStreamFailure(details, message) {
+    return (details?.status === 402 ||
+        details?.code === INSUFFICIENT_CREDITS_ERROR_CODE ||
+        message === INSUFFICIENT_CREDITS_SAFE_MESSAGE);
+}
+export function isTerminalModelStreamFailure(details, message) {
+    return (isTerminalModelStreamErrorDetails(details) || message === INSUFFICIENT_CREDITS_SAFE_MESSAGE);
+}
 function isRecord(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -189,8 +217,8 @@ export function networkErrorDetails(transportFailureStage) {
     };
 }
 export function safeModelStreamErrorMessage(details) {
-    if (details?.code === 'insufficient_credits' || details?.status === 402) {
-        return 'Insufficient credits. Purchase more credits to continue using paid models.';
+    if (isInsufficientCreditsModelStreamFailure(details, undefined)) {
+        return INSUFFICIENT_CREDITS_SAFE_MESSAGE;
     }
     if (details?.code === 'context_overflow') {
         return 'The conversation exceeded the model context window.';

package/dist/core/run-failure.js

@@ -1,9 +1,9 @@
 import { RunFailureCategory, RunFailureSource } from '../contracts/agent-failure.js';
-import { ShortcutXLModelStreamFetchStage } from '../contracts/model-stream.js';
+import { INSUFFICIENT_CREDITS_ERROR_CODE, INSUFFICIENT_CREDITS_SAFE_MESSAGE, isInsufficientCreditsModelStreamFailure, ShortcutXLModelStreamFetchStage } from '../contracts/model-stream.js';
 import { classifyAgentError, getAgentErrorMessage } from './error-classification.js';
 import { getErrorDetails } from './session/session-error-recovery.js';
 const SAFE_MESSAGE_BY_CATEGORY = {
-    [RunFailureCategory.BillingInsufficientCredits]: 'Insufficient credits. Purchase more credits to continue using paid models.',
+    [RunFailureCategory.BillingInsufficientCredits]: INSUFFICIENT_CREDITS_SAFE_MESSAGE,
     [RunFailureCategory.CompactionFailed]: 'Context compaction failed.',
     [RunFailureCategory.CompactionTimeout]: 'Context compaction timed out.',
     [RunFailureCategory.ContextTooLong]: 'The conversation exceeded the model context window.',
@@ -59,9 +59,6 @@ function operationKindToFailureCategory(kind, message) {
             return RunFailureCategory.LlmStreamFailed;
     }
 }
-function isInsufficientCreditsFailure(details) {
-    return details?.status === 402 || details?.code === 'insufficient_credits';
-}
 export function createOperationFailureCause(input) {
     const category = operationKindToFailureCategory(input.opKind, input.errorMessage);
     return {
@@ -75,6 +72,17 @@ export function createOperationFailureCause(input) {
     };
 }
 function classifyModelStreamFailure(details, message) {
+    if (isInsufficientCreditsModelStreamFailure(details, message)) {
+        return {
+            category: RunFailureCategory.BillingInsufficientCredits,
+            source: RunFailureSource.Billing,
+            httpStatus: details?.status,
+            errorCode: details?.code ?? INSUFFICIENT_CREDITS_ERROR_CODE,
+            retryable: details?.retryable,
+            retryAfterMs: details?.retryAfterMs,
+            transportFailureStage: details?.transportFailureStage
+        };
+    }
     if (details) {
         if (details.providerErrorType === 'model_access_denied' ||
             details.code === 'model_access_denied') {
@@ -118,17 +126,6 @@ function classifyModelStreamFailure(details, message) {
                 transportFailureStage: details.transportFailureStage
             };
         }
-        if (isInsufficientCreditsFailure(details)) {
-            return {
-                category: RunFailureCategory.BillingInsufficientCredits,
-                source: RunFailureSource.Billing,
-                httpStatus: details.status,
-                errorCode: details.code ?? 'insufficient_credits',
-                retryable: details.retryable,
-                retryAfterMs: details.retryAfterMs,
-                transportFailureStage: details.transportFailureStage
-            };
-        }
         if (details.providerErrorType === 'network' &&
             details.transportFailureStage === ShortcutXLModelStreamFetchStage.BeforeResponse) {
             return {

package/dist/core/session/session-error-recovery.d.ts

@@ -19,7 +19,7 @@
  */
 import type { AssistantMessage } from '../../ai/types.js';
 import type { RuntimeErrorRecoverySettings } from '../../contracts/agent-settings.js';
-import type { ShortcutXLModelStreamErrorDetails } from '../../contracts/model-stream.js';
+import { type ShortcutXLModelStreamErrorDetails } from '../../contracts/model-stream.js';
 /**
  * Error categories for multi-strategy recovery.
  *
@@ -84,6 +84,22 @@ export type RuntimeAssistantMessage = AssistantMessage & {
 };
 /** Accessor for the runtime-only `errorDetails` field on a owned AI assistant message. */
 export declare function getErrorDetails(message: AssistantMessage): ShortcutXLModelStreamErrorDetails | undefined;
+export type ErrorClassificationDisposition = {
+    kind: 'none';
+} | {
+    kind: 'terminal';
+} | {
+    kind: 'categorized';
+    category: ErrorCategory;
+};
+/**
+ * Classify an assistant message into an explicit recovery disposition.
+ *
+ * MUST remain synchronous — called from the sync _handleAgentLoopEvent handler
+ * before async queue processing, to ensure the recovery promise exists
+ * before waitForRetry() is called.
+ */
+export declare function classifyErrorDisposition(message: AssistantMessage, isContextOverflow: ContextOverflowChecker): ErrorClassificationDisposition;
 /**
  * Classify an error into a recovery category.
  *
@@ -141,6 +157,10 @@ export declare class SessionErrorRecovery {
     private _continueRecovery;
     /** Reset all state to idle. */
     private _reset;
+    /** Emit a cancellation event once for an active, visible recovery. */
+    private _emitCancelledRecovery;
+    /** Cancel recovery state and any in-progress backoff sleep. */
+    private _cancelRecovery;
     /**
      * Create the recovery promise synchronously when an agent_end event arrives.
      *
@@ -178,6 +198,14 @@ export declare class SessionErrorRecovery {
      * Resets state and resolves the promise.
      */
     onSuccess(): void;
+    /**
+     * Called when a continuation turn reaches an unrecoverable assistant error.
+     * This resolves the in-flight recovery as failed instead of treating the
+     * terminal, non-retryable failure as a successful retry.
+     */
+    onTerminalFailure(finalError: string | undefined): void;
+    /** Settle recovery when a continuation agent loop reaches agent_end. */
+    settleAgentEnd(lastAssistant: AssistantMessage | undefined, isContextOverflow: ContextOverflowChecker): void;
     /** Cancel in-progress recovery. */
     abort(): void;
     /** Wait for any in-progress recovery to complete. */

package/dist/core/session/session-error-recovery.js

@@ -17,6 +17,7 @@
  * classifyError + promise creation happens synchronously in _handleAgentLoopEvent,
  * strategy dispatch happens asynchronously in the queued _processAgentLoopEvent.
  */
+import { isTerminalModelStreamErrorDetails, isTerminalModelStreamFailure } from '../../contracts/model-stream.js';
 import { sleep } from '../../utils/sleep.js';
 /** Accessor for the runtime-only `errorDetails` field on a owned AI assistant message. */
 export function getErrorDetails(message) {
@@ -43,23 +44,10 @@ const SERVER_ERROR_PATTERN = /\b500\b|\b502\b|\b503\b|\b504\b|\b524\b|service.?u
 //   - Chrome/Node:    "Failed to fetch", "network error", and the
 //                     already-listed connection/reset strings
 const CONNECTION_ERROR_PATTERN = /connection.?error|connection.?refused|other side closed|fetch failed|failed to fetch|upstream.?connect|reset before headers|terminated|retry delay|peer closed|complete message body|load failed|network.?error|internet connection appears to be offline/i;
-const TERMINAL_GATEWAY_ERROR_CODES = new Set([
-    'insufficient_credits',
-    'customer_credential_scope_required',
-    'customer_credential_resolution_failed',
-    'customer_credential_resolution_timeout',
-    'customer_credential_resolution_cancelled',
-    'customer_credential_unconfigured',
-    'unsupported_credential_mode',
-    'model_policy_rejected'
-]);
 function classifyStructuredError(details) {
     if (!details)
         return null;
-    if (details.code !== undefined && TERMINAL_GATEWAY_ERROR_CODES.has(details.code)) {
-        return 'terminal';
-    }
-    if (details.status === 402)
+    if (isTerminalModelStreamErrorDetails(details))
         return 'terminal';
     if (details.providerErrorType === 'unauthorized' || details.status === 401)
         return 'auth_error';
@@ -78,45 +66,59 @@ function classifyStructuredError(details) {
     return null;
 }
 /**
- * Classify an error into a recovery category.
+ * Classify an assistant message into an explicit recovery disposition.
  *
  * MUST remain synchronous — called from the sync _handleAgentLoopEvent handler
  * before async queue processing, to ensure the recovery promise exists
  * before waitForRetry() is called.
- *
- * @returns ErrorCategory if error is classifiable, null if not an error
  */
-export function classifyError(message, isContextOverflow) {
+export function classifyErrorDisposition(message, isContextOverflow) {
     if (message.stopReason !== 'error')
-        return null;
+        return { kind: 'none' };
     if (!message.errorMessage)
-        return null;
+        return { kind: 'none' };
     // Context overflow has highest priority — exclusive path
     if (isContextOverflow(message))
-        return 'context_overflow';
-    const structuredCategory = classifyStructuredError(getErrorDetails(message));
+        return { kind: 'categorized', category: 'context_overflow' };
+    const details = getErrorDetails(message);
+    const structuredCategory = classifyStructuredError(details);
     if (structuredCategory === 'terminal') {
-        return null;
+        return { kind: 'terminal' };
     }
     if (structuredCategory)
-        return structuredCategory;
+        return { kind: 'categorized', category: structuredCategory };
     const err = message.errorMessage;
+    if (isTerminalModelStreamFailure(details, err))
+        return { kind: 'terminal' };
     // Auth errors — must check before server errors (401 overlaps)
     if (AUTH_ERROR_PATTERN.test(err))
-        return 'auth_error';
+        return { kind: 'categorized', category: 'auth_error' };
     // Rate limits
     if (RATE_LIMIT_PATTERN.test(err))
-        return 'rate_limit';
+        return { kind: 'categorized', category: 'rate_limit' };
     // Overloaded
     if (OVERLOADED_PATTERN.test(err))
-        return 'overloaded';
+        return { kind: 'categorized', category: 'overloaded' };
     // Server errors
     if (SERVER_ERROR_PATTERN.test(err))
-        return 'server_error';
+        return { kind: 'categorized', category: 'server_error' };
     // Connection errors → server_error (transient infrastructure)
     if (CONNECTION_ERROR_PATTERN.test(err))
-        return 'server_error';
-    return 'unknown';
+        return { kind: 'categorized', category: 'server_error' };
+    return { kind: 'categorized', category: 'unknown' };
+}
+/**
+ * Classify an error into a recovery category.
+ *
+ * MUST remain synchronous — called from the sync _handleAgentLoopEvent handler
+ * before async queue processing, to ensure the recovery promise exists
+ * before waitForRetry() is called.
+ *
+ * @returns ErrorCategory if error is classifiable, null if not an error
+ */
+export function classifyError(message, isContextOverflow) {
+    const disposition = classifyErrorDisposition(message, isContextOverflow);
+    return disposition.kind === 'categorized' ? disposition.category : null;
 }
 /**
  * Server-error retry budget. 5 attempts × exponential backoff (1s, 2s, 4s,
@@ -238,20 +240,26 @@ export class SessionErrorRecovery {
     _emit(event) {
         this._listener?.(event);
     }
-    async _continueRecovery(category, attempt, actions) {
-        try {
-            // Keep the recovery promise armed until the continuation turn emits its
-            // own terminal agent_end. Otherwise callers can submit into a still-live
-            // retry and trip the "previous turn is still streaming" guard.
-            //
-            // Contract: `actions.continue` is wired in compose.ts to `agent.continue()`,
-            // which resolves only after the next turn reaches agent_end (or rejects on
-            // failure). See `createEmbeddedRecoveryWiring` callsite in
-            // `embedded-agent/compose.ts`.
-            await actions.continue();
-            return true;
-        }
-        catch (error) {
+    _continueRecovery(category, attempt, actions) {
+        // Launch the continuation without awaiting it here. CLI AgentSession calls
+        // handleError() from its serialized event queue; awaiting agent.continue()
+        // would hold that queue until the entire retry finishes, starving the
+        // retry's own agent_start/message/tool events and leaving the UI frozen on
+        // the recovery loader. The recovery promise remains armed until the
+        // continuation's agent_end is processed by settleAgentEnd().
+        const activeRecovery = this._promise;
+        void Promise.resolve()
+            .then(() => {
+            // Cancellation can race the end of the backoff delay. Re-check before
+            // starting so an already-cancelled retry cannot launch invisibly.
+            if (!activeRecovery || this._promise !== activeRecovery)
+                return;
+            return actions.continue();
+        })
+            .catch((error) => {
+            // Ignore completion from a continuation that was cancelled or replaced.
+            if (!activeRecovery || this._promise !== activeRecovery)
+                return;
             this._emit({
                 type: 'recovery_end',
                 category,
@@ -260,17 +268,38 @@ export class SessionErrorRecovery {
                 finalError: error instanceof Error ? error.message : String(error)
             });
             this._reset();
-            return false;
-        }
+        });
+        return true;
     }
     /** Reset all state to idle. */
     _reset() {
+        this._abortController = undefined;
         this._attempt = 0;
         this._category = null;
         this._resolve?.();
         this._resolve = undefined;
         this._promise = undefined;
     }
+    /** Emit a cancellation event once for an active, visible recovery. */
+    _emitCancelledRecovery() {
+        if (!this._promise || this._attempt <= 0 || !this._category)
+            return;
+        this._emit({
+            type: 'recovery_end',
+            category: this._category,
+            success: false,
+            attempt: this._attempt,
+            finalError: 'Recovery cancelled'
+        });
+    }
+    /** Cancel recovery state and any in-progress backoff sleep. */
+    _cancelRecovery() {
+        const abortController = this._abortController;
+        this._abortController = undefined;
+        this._emitCancelledRecovery();
+        this._reset();
+        abortController?.abort();
+    }
     /**
      * Create the recovery promise synchronously when an agent_end event arrives.
      *
@@ -314,6 +343,15 @@ export class SessionErrorRecovery {
         const config = STRATEGY_CONFIGS[category];
         // No retry for non-retryable categories
         if (config.maxAttempts === 0) {
+            if (this._attempt > 0 || this._promise) {
+                this._emit({
+                    type: 'recovery_end',
+                    category: this._category ?? category,
+                    success: false,
+                    attempt: this._attempt,
+                    finalError: message.errorMessage
+                });
+            }
             this._reset();
             return false;
         }
@@ -448,6 +486,10 @@ export class SessionErrorRecovery {
     }
     /** Handle abort during sleep. */
     _handleAbort(category) {
+        // abort() emits and resets synchronously. If the aborted sleep rejects
+        // afterward, do not emit a second recovery_end event.
+        if (!this._promise)
+            return false;
         const attempt = this._attempt;
         this._abortController = undefined;
         this._emit({
@@ -476,10 +518,39 @@ export class SessionErrorRecovery {
         });
         this._reset();
     }
+    /**
+     * Called when a continuation turn reaches an unrecoverable assistant error.
+     * This resolves the in-flight recovery as failed instead of treating the
+     * terminal, non-retryable failure as a successful retry.
+     */
+    onTerminalFailure(finalError) {
+        if (this._attempt <= 0)
+            return;
+        const category = this._category ?? 'unknown';
+        this._emit({
+            type: 'recovery_end',
+            category,
+            success: false,
+            attempt: this._attempt,
+            finalError
+        });
+        this._reset();
+    }
+    /** Settle recovery when a continuation agent loop reaches agent_end. */
+    settleAgentEnd(lastAssistant, isContextOverflow) {
+        if (this._attempt <= 0)
+            return;
+        if (!lastAssistant || lastAssistant.stopReason !== 'error') {
+            this.onSuccess();
+            return;
+        }
+        if (classifyErrorDisposition(lastAssistant, isContextOverflow).kind === 'terminal') {
+            this.onTerminalFailure(lastAssistant.errorMessage);
+        }
+    }
     /** Cancel in-progress recovery. */
     abort() {
-        this._abortController?.abort();
-        this._reset();
+        this._cancelRecovery();
     }
     /** Wait for any in-progress recovery to complete. */
     async wait() {

package/dist/embedded-agent/anthropic-messages-transport.js

@@ -362,9 +362,11 @@ function toShortcutXLErrorReason(stopReason) {
         : ShortcutXLModelStreamStopReason.Error;
 }
 function toShortcutXLAssistantMessage(message) {
+    const errorDetails = message.errorDetails;
     return {
         api: message.api,
         content: message.content.map((content) => toShortcutXLAssistantContent(content)),
+        ...(errorDetails ? { errorDetails } : {}),
         errorMessage: message.errorMessage,
         model: message.model,
         provider: message.provider,

package/dist/embedded-agent/host-tools/mode-host-tools.js

@@ -5,7 +5,7 @@
  */
 import { ACTION_TOOL_NAMES } from './action-tool-names.js';
 import { buildHostToolList } from './build-tool-list.js';
-import { BASH_COMMAND, EXECUTE_CODE, EXECUTE_TOOL, GET_TOOL_INFO, MCP, READ_SKILL, SEND_MESSAGE, SWITCH_MODE, TAKE_SCREENSHOT, TASK } from './tool-names.js';
+import { BASH_COMMAND, EXECUTE_CODE, EXECUTE_TOOL, GET_TOOL_INFO, MCP, MODIFY_SKILL, READ_SKILL, SEND_MESSAGE, SWITCH_MODE, TAKE_SCREENSHOT, TASK } from './tool-names.js';
 /** First-class tool names exposed to the LLM per agent mode. */
 export const TOOLS_BY_MODE_NAMES = {
     action: ACTION_TOOL_NAMES,
@@ -17,6 +17,7 @@ export const TOOLS_BY_MODE_NAMES = {
         TAKE_SCREENSHOT,
         MCP,
         READ_SKILL,
+        MODIFY_SKILL,
         TASK,
         SEND_MESSAGE
     ],

package/dist/embedded-agent/model-registry.d.ts

@@ -14,6 +14,7 @@ export declare const ShortcutXLAgentModelId: {
     readonly ClaudeFable5: "claude-fable-5";
     readonly ClaudeOpus48: "claude-opus-4-8";
     readonly Glm52Fireworks: "accounts/fireworks/models/glm-5p2";
+    readonly Grok45: "grok-4.5";
     readonly OpenAIReasoning: "gpt-5.6-sol";
     /** Low-cost Shortcut-hosted model. */
     readonly Hosted: "pivot";

package/dist/embedded-agent/model-registry.js

@@ -9,6 +9,7 @@ export const ShortcutXLAgentModelId = {
     ClaudeFable5: SHORTCUT_MODEL_ID.ClaudeFable5,
     ClaudeOpus48: SHORTCUT_MODEL_ID.ClaudeOpus48,
     Glm52Fireworks: SHORTCUT_MODEL_ID.Glm52Fireworks,
+    Grok45: SHORTCUT_MODEL_ID.Grok45,
     OpenAIReasoning: SHORTCUT_OPENAI_MODEL_ID,
     /** Low-cost Shortcut-hosted model. */
     Hosted: SHORTCUT_MODEL_ID.Hosted

package/dist/embedded-agent/recovery-wiring.js

@@ -1,5 +1,5 @@
 import { isContextOverflow } from '../core/session/context-overflow.js';
-import { classifyError, SessionErrorRecovery } from '../core/session/session-error-recovery.js';
+import { classifyErrorDisposition, SessionErrorRecovery } from '../core/session/session-error-recovery.js';
 function findLastAssistant(messages) {
     for (let i = messages.length - 1; i >= 0; i -= 1) {
         const message = messages[i];
@@ -31,9 +31,14 @@ function removeLastErrorGroup(agent, sessionStore, funnel) {
 /** Build the embedded equivalent of CLI `SessionErrorRecovery`. */
 export function createEmbeddedRecoveryWiring(options) {
     const recovery = new SessionErrorRecovery({ sleep: options.recoverySleep });
-    if (options.onRecoveryEvent) {
-        recovery.onEvent(options.onRecoveryEvent);
-    }
+    let recoverySucceeded;
+    recovery.onEvent((event) => {
+        if (event.type === 'recovery_start')
+            recoverySucceeded = undefined;
+        if (event.type === 'recovery_end')
+            recoverySucceeded = event.success;
+        options.onRecoveryEvent?.(event);
+    });
     const isOverflow = (message) => isContextOverflow(message, options.agent.state.model?.contextWindow ?? 0);
     return {
         abort() {
@@ -46,8 +51,12 @@ export function createEmbeddedRecoveryWiring(options) {
             // Embedded context-overflow recovery is already owned by compactionWiring,
             // which can compact persisted entries and continue the agent. Do not arm
             // SessionErrorRecovery for the same event or the two systems race.
-            if (lastAssistant && classifyError(lastAssistant, isOverflow) === 'context_overflow')
-                return;
+            if (lastAssistant) {
+                const disposition = classifyErrorDisposition(lastAssistant, isOverflow);
+                if (disposition.kind === 'categorized' && disposition.category === 'context_overflow') {
+                    return;
+                }
+            }
             recovery.prepareForAgentEnd(lastAssistant, isOverflow, options.getSettings());
         },
         async handleAgentEnd(event) {
@@ -59,20 +68,33 @@ export function createEmbeddedRecoveryWiring(options) {
                     recovery.onSuccess();
                 return false;
             }
-            const category = classifyError(lastAssistant, isOverflow);
-            if (category === 'context_overflow')
+            const disposition = classifyErrorDisposition(lastAssistant, isOverflow);
+            if (disposition.kind === 'categorized' && disposition.category === 'context_overflow') {
                 return false;
-            if (!category) {
+            }
+            if (disposition.kind === 'none') {
                 if (recovery.attempt > 0)
                     recovery.onSuccess();
                 return false;
             }
-            return recovery.handleError(lastAssistant, category, options.getSettings(), {
+            if (disposition.kind === 'terminal') {
+                if (recovery.attempt > 0)
+                    recovery.onTerminalFailure(lastAssistant.errorMessage);
+                return false;
+            }
+            const initiated = await recovery.handleError(lastAssistant, disposition.category, options.getSettings(), {
                 removeLastAssistantMessage: () => removeLastErrorGroup(options.agent, options.sessionStore, options.funnel),
                 continue: options.continueAgent,
                 runCompaction: async () => false,
                 switchToFallbackModel: async () => false
             });
+            // Embedded recovery runs outside a serialized agent-event queue, so it
+            // can retain its completion-ordering contract without starving events.
+            // CLI AgentSession instead relies on recovery.wait() from prompt().
+            if (!initiated)
+                return false;
+            await recovery.wait();
+            return recoverySucceeded === true;
         },
         wait() {
             return recovery.wait();

package/dist/model-ids.d.ts

@@ -4,6 +4,7 @@ export declare const SHORTCUT_MODEL_ID: {
     readonly ClaudeOpus48: "claude-opus-4-8";
     readonly Glm52Fireworks: "accounts/fireworks/models/glm-5p2";
     readonly Gpt56Sol: "gpt-5.6-sol";
+    readonly Grok45: "grok-4.5";
     readonly Hosted: "pivot";
     readonly Gemini3Flash: "gemini-3-flash-preview";
     readonly ClaudeHaiku45: "claude-haiku-4-5-20251001";
@@ -13,6 +14,7 @@ export declare const SHORTCUT_MODEL_REF: {
     readonly ClaudeOpus48: "shortcut/claude-opus-4-8";
     readonly Glm52Fireworks: "shortcut/accounts/fireworks/models/glm-5p2";
     readonly Gpt56Sol: "shortcut/gpt-5.6-sol";
+    readonly Grok45: "shortcut/grok-4.5";
     readonly Hosted: "shortcut/pivot";
 };
 export declare const SHORTCUT_OPENAI_MODEL_ID: "gpt-5.6-sol";

package/dist/model-ids.js

@@ -4,6 +4,7 @@ export const SHORTCUT_MODEL_ID = {
     ClaudeOpus48: 'claude-opus-4-8',
     Glm52Fireworks: 'accounts/fireworks/models/glm-5p2',
     Gpt56Sol: 'gpt-5.6-sol',
+    Grok45: 'grok-4.5',
     Hosted: 'pivot',
     Gemini3Flash: 'gemini-3-flash-preview',
     ClaudeHaiku45: 'claude-haiku-4-5-20251001'
@@ -13,6 +14,7 @@ export const SHORTCUT_MODEL_REF = {
     ClaudeOpus48: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.ClaudeOpus48}`,
     Glm52Fireworks: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Glm52Fireworks}`,
     Gpt56Sol: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Gpt56Sol}`,
+    Grok45: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Grok45}`,
     Hosted: `${SHORTCUT_PROVIDER_ID}/${SHORTCUT_MODEL_ID.Hosted}`
 };
 export const SHORTCUT_OPENAI_MODEL_ID = SHORTCUT_MODEL_ID.Gpt56Sol;

package/dist/rpc/rpc-mode.js

@@ -246,7 +246,7 @@ export async function runRpcMode(session) {
                 return success(id, 'set_auto_retry');
             }
             case 'abort_retry': {
-                session.abortRetry();
+                await session.abortRetry();
                 return success(id, 'abort_retry');
             }
             // =================================================================

package/dist/shared/files/file-content.d.ts

@@ -1,4 +1,3 @@
-export declare function readFilePrefix(filePath: string, maxBytes?: number): Promise<Buffer>;
 export declare function detectFileMimeTypeFromBuffer(sample: Uint8Array): Promise<string | null>;
 export declare function isLikelyUtf8TextFile(options: {
     sample: Uint8Array;

package/dist/shared/files/file-content.js

@@ -1,19 +1,6 @@
 import { fileTypeFromBuffer } from 'file-type';
-import { open } from 'node:fs/promises';
 import { TextDecoder } from 'node:util';
-const FILE_TYPE_SNIFF_BYTES = 8192;
 const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
-export async function readFilePrefix(filePath, maxBytes = FILE_TYPE_SNIFF_BYTES) {
-    const fileHandle = await open(filePath, 'r');
-    try {
-        const buffer = Buffer.alloc(maxBytes);
-        const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
-        return buffer.subarray(0, bytesRead);
-    }
-    finally {
-        await fileHandle.close();
-    }
-}
 export async function detectFileMimeTypeFromBuffer(sample) {
     const detected = sample.length > 0 ? await fileTypeFromBuffer(sample) : undefined;
     return detected?.mime ?? null;

package/dist/shell/interactive/interactive-mode.js

@@ -2529,7 +2529,7 @@ export class InteractiveMode {
     handleRecoveryStartEvent(event) {
         this.retryEscapeHandler = this.defaultEditor.onEscape;
         this.defaultEditor.onEscape = () => {
-            this.session.abortRetry();
+            void this.session.abortRetry();
         };
         const retryChildren = this.chatContainer.children;
         for (let i = retryChildren.length - 1; i >= 0; i--) {
@@ -2556,7 +2556,10 @@ export class InteractiveMode {
             this.retryLoader = undefined;
             this.statusContainer.clear();
         }
-        if (!event.success) {
+        if (!event.success && event.finalError === 'Recovery cancelled') {
+            this.showStatus('Recovery cancelled');
+        }
+        else if (!event.success) {
             this.showError(`Recovery failed after ${event.attempt} attempts: ${event.finalError || 'Unknown error'}`);
         }
         this.ui.requestRender();

package/dist/shortcut-model-catalog.d.ts

@@ -1,5 +1,5 @@
 import type { Api, Model } from './ai/types.js';
-export type ShortcutModelDefinition = Pick<Model<Api>, 'id' | 'name' | 'reasoning' | 'input' | 'cost' | 'contextWindow' | 'maxTokens'>;
+export type ShortcutModelDefinition = Pick<Model<Api>, 'id' | 'name' | 'reasoning' | 'input' | 'cost' | 'contextWindow' | 'maxTokens' | 'compat'>;
 export declare const DEFAULT_SHORTCUT_MODEL_ID: "gpt-5.6-sol";
 export declare function createShortcutPublicModelDefinitions(): ShortcutModelDefinition[];
 export declare function createShortcutHostedModelDefinitions(): ShortcutModelDefinition[];

package/dist/shortcut-model-catalog.js

@@ -28,6 +28,21 @@ const SHORTCUT_PUBLIC_MODEL_DEFINITIONS = [
         contextWindow: 1_000_000,
         maxTokens: 128000
     },
+    {
+        id: SHORTCUT_MODEL_ID.Grok45,
+        name: 'Grok 4.5',
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+        contextWindow: 500_000,
+        maxTokens: 128000,
+        compat: {
+            supportsStore: false,
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: true,
+            maxTokensField: 'max_completion_tokens'
+        }
+    },
     {
         id: SHORTCUT_MODEL_ID.Glm52Fireworks,
         name: 'GLM 5.2',
@@ -75,7 +90,8 @@ function cloneShortcutModelDefinition(model) {
     return {
         ...model,
         input: [...model.input],
-        cost: { ...model.cost }
+        cost: { ...model.cost },
+        ...(model.compat ? { compat: { ...model.compat } } : {})
     };
 }
 export function createShortcutPublicModelDefinitions() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shortcutxl",
-  "version": "0.3.70",
+  "version": "0.3.71",
   "license": "MIT",
   "type": "module",
   "types": "./dist/index.d.ts",