@@ -64,6 +64,7 @@ export const OrchestrationEffectRequestV2 = Schema.Union([
     providerThreadId: ProviderThreadId,
     providerTurnId: ProviderTurnId,
     messageId: MessageId,
+    modelSelection: Schema.optional(ModelSelection),
   }),
   Schema.Struct({
     type: Schema.Literal("provider-turn.restart"),
 
@@ -314,9 +314,11 @@ export const layerExecutor: Layer.Layer<
                         text: message.text,
                         ...(message.context ? { context: message.context } : {}),
                         attachments: message.attachments,
-                        ...(message.delegatedCompletion === undefined
-                          ? {}
-                          : { modelSelection: run.modelSelection }),
+                        ...(error.steerDeclined && effect.request.modelSelection !== undefined
+                          ? { modelSelection: effect.request.modelSelection }
+                          : message.delegatedCompletion === undefined
+                            ? {}
+                            : { modelSelection: run.modelSelection }),
                         dispatchMode: {
                           type: queued ? "queue_after_active" : "start_immediately",
                         },
 
@@ -5639,6 +5639,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
             providerThreadId: providerThread.id,
             providerTurnId: providerTurn.id,
             messageId: input.messageId,
+            modelSelection: input.modelSelection,
           },
         } satisfies PendingOrchestrationEffectV2,
       ]);
 
@@ -1153,7 +1153,7 @@ it.effect("starts a steer that missed the turn on the saved next-turn selection"
   ),
 );
 
-it.effect.each(["complete", "stop-before-decline", "stop-after-decline"] as const)(
+it.effect.each(["complete", "stop-before-decline", "stop-after-decline", "queued-model"] as const)(
   "persists a declined steer without blocking the worker: %s",
   (timing) =>
     Effect.scoped(
@@ -1194,6 +1194,21 @@ it.effect.each(["complete", "stop-before-decline", "stop-after-decline"] as cons
             })
             .pipe(Effect.asVoid, Effect.orDie);
           if (timing === "stop-before-decline") beforeDecline = stop;
+          const steerSelection = { ...runSelection, model: "steer-model" };
+          if (timing === "queued-model") {
+            yield* orchestrator.dispatch({
+              type: "message.dispatch",
+              commandId: CommandId.make("queued-model"),
+              threadId,
+              messageId: MessageId.make("message:queued-model"),
+              text: "already queued",
+              attachments: [],
+              modelSelection: composerSelection,
+              dispatchMode: { type: "queue_after_active" },
+              createdBy: "user",
+              creationSource: "web",
+            });
+          }
           const messageId = MessageId.make("message:declined");
           yield* orchestrator.dispatch({
             type: "message.dispatch",
@@ -1202,13 +1217,16 @@ it.effect.each(["complete", "stop-before-decline", "stop-after-decline"] as cons
             messageId,
             text: "follow up",
             attachments: [],
+            ...(timing === "queued-model" ? { modelSelection: steerSelection } : {}),
             dispatchMode: { type: "steer_active", targetRunId: first.runId },
             createdBy: "user",
             creationSource: "web",
           });
           yield* worker.drain();
           const pending = yield* orchestrator.getThreadProjection(threadId);
-          const queued = pending.runs.find((run) => run.id !== first.runId);
+          const queued = pending.runs.find(
+            (run) => run.userMessageId === messageId && run.id !== first.runId,
+          );
           const effects = yield* (yield* EffectOutbox.EffectOutboxV2).listByCommandId(
             CommandId.make("steer"),
           );
@@ -1223,6 +1241,10 @@ it.effect.each(["complete", "stop-before-decline", "stop-after-decline"] as cons
           }
           assert.equal(queued?.status, "queued");
           assert.equal(queued?.userMessageId, messageId);
+          if (timing === "queued-model") {
+            assert.deepEqual(queued?.modelSelection, steerSelection);
+            return;
+          }
           if (timing === "stop-after-decline") {
             yield* stop;
             yield* worker.drain();
 
@@ -55,9 +55,11 @@ The adapter supports:
   final result.
 
 The public SDK does not currently expose native agent fork, conversation rollback, or interactive
-approval callbacks. A steer injects into the live run with `Run.steer` and leaves that run in place.
-When the SDK declines the injection, the same message is sent as the next turn after this run
-finishes. A provider or runtime change that has to apply immediately still interrupts and restarts the run.
+approval callbacks. A text-only steer injects into the live run with `Run.steer` and leaves that run
+in place. When the SDK declines the injection, the same message is queued for the next turn after
+this run finishes. If you press Stop, that follow-up stays held until you resume the queue. Steers
+with attachments and provider or runtime changes that must apply immediately interrupt and restart
+the run.
 Same-provider Cursor forks use the orchestrator's portable full-thread context handoff into a fresh
 Cursor agent. The SDK has in-process custom callback tools, but the V2 adapter intentionally uses the
 authenticated, thread-scoped MCP server instead.
 
@@ -584,7 +584,7 @@ export const makeCursorAgentSdkRunner = Effect.fn("makeCursorAgentSdkRunner")(fu
                 }),
               ),
             ),
-            steer: (text) =>
+            steer: Effect.fn("CursorAgentSdkRun.steer")((text: string) =>
               log({
                 direction: "outgoing",
                 stage: "decoded",
@@ -612,6 +612,7 @@ export const makeCursorAgentSdkRunner = Effect.fn("makeCursorAgentSdkRunner")(fu
                   }),
                 ),
               ),
+            ),
             cancel: log({
               direction: "outgoing",
               stage: "decoded",
 
@@ -2097,6 +2097,10 @@ describe("CursorAdapterV2", () => {
           modelSelection,
           runtimePolicy,
         });
+        assert.equal(
+          runtime.providerSession.capabilities.turns.activeSteeringAcceptsAttachments,
+          false,
+        );
         const providerThread = yield* runtime.ensureThread({
           threadId,
           modelSelection,
 
@@ -100,6 +100,7 @@ export const CursorProviderCapabilitiesV2 = {
     // A steer can move a foreground subagent to the background. Mailbox wakes
     // stay queued so a notification does not cut into the live turn.
     activeSteeringInterruptsTools: true,
+    activeSteeringAcceptsAttachments: false,
     supportsSteeringByInterruptRestart: true,
     supportsQueuedMessages: true,
     terminalStatusQuality: "strong",