diff --git a/src/utils/handlePromptSubmit.ts b/src/utils/handlePromptSubmit.ts
index 7c2b35e22..e8c387167 100644
--- a/src/utils/handlePromptSubmit.ts
+++ b/src/utils/handlePromptSubmit.ts
@@ -25,6 +25,8 @@ import type { EffortValue } from './effort.js'
 import type { FileHistoryState } from './fileHistory.js'
 import { fileHistoryEnabled, fileHistoryMakeSnapshot } from './fileHistory.js'
 import { gracefulShutdownSync } from './gracefulShutdown.js'
+import { toError } from './errors.js'
+import { logError } from './log.js'
 import { enqueue } from './messageQueueManager.js'
 import { resolveSkillModelOverride } from './model/model.js'
 import {
@@ -464,6 +466,10 @@ async function executeUserInput(params: ExecuteUserInputParams): Promise<void> {
     commands = queuedAutonomyClaim.attachmentCommands
     const claimedAutonomyCommands = queuedAutonomyClaim.claimedCommands
     if (commands.length === 0) {
+      // Clear the abort controller published a few lines above so this turn's
+      // stale controller does not leak into the next turn when every claimed
+      // autonomy command was skipped as non-consumable.
+      setAbortController(null)
       return
     }
 
@@ -487,6 +493,7 @@ async function executeUserInput(params: ExecuteUserInputParams): Promise<void> {
     // context — isolated from the parent's continuation. A process-global
     // mutable slot would be clobbered at the detached closure's first
     // await by this function's synchronous return path. See state.ts.
+    let turnError: unknown
     try {
       await runWithWorkload(turnWorkload, async () => {
         for (let i = 0; i < commands.length; i++) {
@@ -618,37 +625,52 @@ async function executeUserInput(params: ExecuteUserInputParams): Promise<void> {
           }
         }
       }) // end runWithWorkload — ALS context naturally scoped, no finally needed
-      if (claimedAutonomyCommands.length) {
-        const finalizableCommands = claimedAutonomyCommands.filter(command => {
-          const runId = command.autonomy?.runId
-          return !runId || !deferredAutonomyRunIds.has(runId)
-        })
-        const nextCommands = await finalizeAutonomyCommandsForTurn({
-          commands: finalizableCommands,
-          outcome: { type: 'completed' },
-          currentDir: getCwd(),
-          priority: 'later',
-          workload: turnWorkload,
-        })
-        for (const nextCommand of nextCommands) {
-          enqueue(nextCommand)
+    } catch (error) {
+      turnError = error
+    }
+
+    // Finalize claimed autonomy commands as `completed` only if the turn
+    // body itself succeeded. Run the finalize call in its own try/catch so a
+    // failure there does not double-finalize the same commands as `failed`
+    // (which previously cancelled follow-up queue state after a successful
+    // turn).
+    if (claimedAutonomyCommands.length) {
+      const finalizableCommands = claimedAutonomyCommands.filter(command => {
+        const runId = command.autonomy?.runId
+        return !runId || !deferredAutonomyRunIds.has(runId)
+      })
+      if (turnError) {
+        try {
+          await finalizeAutonomyCommandsForTurn({
+            commands: finalizableCommands,
+            outcome: { type: 'failed', error: turnError },
+            currentDir: getCwd(),
+            priority: 'later',
+            workload: turnWorkload,
+          })
+        } catch (finalizeError) {
+          logError(toError(finalizeError))
+        }
+      } else {
+        try {
+          const nextCommands = await finalizeAutonomyCommandsForTurn({
+            commands: finalizableCommands,
+            outcome: { type: 'completed' },
+            currentDir: getCwd(),
+            priority: 'later',
+            workload: turnWorkload,
+          })
+          for (const nextCommand of nextCommands) {
+            enqueue(nextCommand)
+          }
+        } catch (finalizeError) {
+          logError(toError(finalizeError))
         }
       }
-    } catch (error) {
-      if (claimedAutonomyCommands.length) {
-        const finalizableCommands = claimedAutonomyCommands.filter(command => {
-          const runId = command.autonomy?.runId
-          return !runId || !deferredAutonomyRunIds.has(runId)
-        })
-        await finalizeAutonomyCommandsForTurn({
-          commands: finalizableCommands,
-          outcome: { type: 'failed', error },
-          currentDir: getCwd(),
-          priority: 'later',
-          workload: turnWorkload,
-        })
-      }
-      throw error
+    }
+
+    if (turnError) {
+      throw turnError
     }
   } finally {
     // Safety net: release the guard reservation if processUserInput threw
diff --git a/src/utils/processUserInput/processSlashCommand.tsx b/src/utils/processUserInput/processSlashCommand.tsx
index 5e6059702..da6763f7e 100644
--- a/src/utils/processUserInput/processSlashCommand.tsx
+++ b/src/utils/processUserInput/processSlashCommand.tsx
@@ -266,7 +266,14 @@ async function executeForkedSlashCommand(
       // this ordering, both land at `priority: 'later'` and the next autonomy
       // step can run before the main thread sees this worker's output.
       enqueueResult(`<scheduled-task-result command="/${commandName}">\n${resultText}\n</scheduled-task-result>`);
-      await finalizeDeferredAutonomyRunCompleted();
+      // The slash command itself succeeded; an error from the finalize call
+      // must not surface as a contradictory <scheduled-task-result status="failed">
+      // via the outer catch below. Log it locally and stop.
+      try {
+        await finalizeDeferredAutonomyRunCompleted();
+      } catch (finalizeError) {
+        logError(finalizeError);
+      }
     })().catch(async err => {
       logError(err);
       enqueueResult(
diff --git a/tests/mocks/auth.ts b/tests/mocks/auth.ts
index 805cc1fbd..7c0da17a7 100644
--- a/tests/mocks/auth.ts
+++ b/tests/mocks/auth.ts
@@ -10,8 +10,20 @@
  * surface stays consistent when `auth.ts` exports change.
  */
 export const authMock = () => ({
-  checkAndRefreshOAuthTokenIfNeeded: async () => {},
-  getClaudeAIOAuthTokens: () => ({ accessToken: 'token' }),
+  // Mirrors the production contract: src/utils/auth.ts returns
+  // Promise<boolean> ("did the access token change") and a token object that
+  // carries scopes, subscriptionType, expiresAt, etc. Tests that branch on
+  // these values must see the full shape so they can not silently drift away
+  // from production.
+  checkAndRefreshOAuthTokenIfNeeded: async () => false,
+  getClaudeAIOAuthTokens: () => ({
+    accessToken: 'token',
+    refreshToken: null,
+    expiresAt: null,
+    scopes: ['user:inference'],
+    subscriptionType: null,
+    rateLimitTier: null,
+  }),
   isClaudeAISubscriber: () => true,
   isProSubscriber: () => false,
   isMaxSubscriber: () => false,