diff --git a/packages/junior-dashboard/e2e/conversations-mobile.spec.ts b/packages/junior-dashboard/e2e/conversations-mobile.spec.ts
index a2bab7bcbd..b4f76d65f4 100644
--- a/packages/junior-dashboard/e2e/conversations-mobile.spec.ts
+++ b/packages/junior-dashboard/e2e/conversations-mobile.spec.ts
@@ -289,7 +289,9 @@ test("opens and closes a conversation on mobile", async ({
 
   const composer = page.getByPlaceholder("Message Junior…");
   await expect(composer).toBeVisible();
-  await expect(page.getByRole("button", { name: "Send" })).toBeVisible();
+  await expect(
+    page.getByRole("button", { name: "Send", exact: true }),
+  ).toBeVisible();
   await composer.focus();
   await expect(composer).toBeFocused();
 
diff --git a/packages/junior-dashboard/e2e/conversations.spec.ts b/packages/junior-dashboard/e2e/conversations.spec.ts
index d19f2f68ff..9f04ac40ab 100644
--- a/packages/junior-dashboard/e2e/conversations.spec.ts
+++ b/packages/junior-dashboard/e2e/conversations.spec.ts
@@ -137,14 +137,18 @@ test("keeps cached conversation and draft available through reconnect", async ({
   await expect(
     page.getByText("Connect to send. Your draft is saved."),
   ).toBeVisible();
-  await expect(page.getByRole("button", { name: "Send" })).toBeDisabled();
+  await expect(
+    page.getByRole("button", { name: "Send", exact: true }),
+  ).toBeDisabled();
 
   await context.setOffline(false);
   await expect(
     page.getByText("You’re offline. Drafts stay on this device."),
   ).toBeHidden();
   await expect(composer).toHaveValue("Keep this draft through reconnect");
-  await expect(page.getByRole("button", { name: "Send" })).toBeEnabled();
+  await expect(
+    page.getByRole("button", { name: "Send", exact: true }),
+  ).toBeEnabled();
 });
 
 test("shows the repo name for one annotation scope on mobile", async ({
diff --git a/packages/junior-dashboard/src/client/conversations/ConversationComposer.tsx b/packages/junior-dashboard/src/client/conversations/ConversationComposer.tsx
index ce04620afe..d00df69e7b 100644
--- a/packages/junior-dashboard/src/client/conversations/ConversationComposer.tsx
+++ b/packages/junior-dashboard/src/client/conversations/ConversationComposer.tsx
@@ -79,7 +79,9 @@ export const ConversationComposer = memo(function ConversationComposer(
   // New-conversation create holds the send control until accept settles so a
   // failed restore cannot race a later submit.
   const [createPending, setCreatePending] = useState(false);
-  const [canSend, setCanSend] = useState(() => Boolean(initialDraft.text.trim()));
+  const [canSend, setCanSend] = useState(() =>
+    Boolean(initialDraft.text.trim()),
+  );
   const online = useDashboardOnline();
   const id = useId();
   const textareaRef = useRef<HTMLTextAreaElement>(null);
@@ -302,7 +304,9 @@ export const ConversationComposer = memo(function ConversationComposer(
         <div
           className={cn(
             "flex min-w-0 items-center gap-3 px-2 py-1.5 md:px-3 md:py-2",
-            props.footerStart ? "justify-between" : "justify-end md:justify-between",
+            props.footerStart
+              ? "justify-between"
+              : "justify-end md:justify-between",
           )}
         >
           <div className="flex min-w-0 items-center gap-3">
@@ -313,24 +317,26 @@ export const ConversationComposer = memo(function ConversationComposer(
               </div>
             )}
           </div>
-          <Button
-            aria-label={sendLocked ? "Sending message" : props.submitLabel}
-            className="!border-0 !bg-transparent hover:!border-0 hover:!bg-white/[0.06] focus-visible:outline focus-visible:outline-1 focus-visible:outline-cyan-300/55 disabled:hover:!border-0 disabled:hover:!bg-transparent"
-            disabled={!canSend || !online || sendLocked}
-            title={
-              !online
-                ? "Connect to send"
-                : sendLocked
-                  ? "Sending message"
-                  : props.submitLabel
-            }
-            type="submit"
-          >
-            <Send aria-hidden="true" size={14} />
-            <span className="hidden md:inline">
-              {sendLocked ? "Sending…" : props.submitLabel}
-            </span>
-          </Button>
+          <div className="flex items-center gap-1">
+            <Button
+              aria-label={sendLocked ? "Sending message" : props.submitLabel}
+              className="!border-0 !bg-transparent hover:!border-0 hover:!bg-white/[0.06] focus-visible:outline focus-visible:outline-1 focus-visible:outline-cyan-300/55 disabled:hover:!border-0 disabled:hover:!bg-transparent"
+              disabled={!canSend || !online || sendLocked}
+              title={
+                !online
+                  ? "Connect to send"
+                  : sendLocked
+                    ? "Sending message"
+                    : props.submitLabel
+              }
+              type="submit"
+            >
+              <Send aria-hidden="true" size={14} />
+              <span className="hidden md:inline">
+                {sendLocked ? "Sending…" : props.submitLabel}
+              </span>
+            </Button>
+          </div>
         </div>
       </form>
     </div>
diff --git a/packages/junior-dashboard/src/client/conversations/ConversationPage.tsx b/packages/junior-dashboard/src/client/conversations/ConversationPage.tsx
index 1419709b72..bcf0b2ef50 100644
--- a/packages/junior-dashboard/src/client/conversations/ConversationPage.tsx
+++ b/packages/junior-dashboard/src/client/conversations/ConversationPage.tsx
@@ -18,6 +18,8 @@ import {
   useArchiveConversation,
   useCancelConversationPendingMessages,
   useConversationData,
+  usePromoteConversationPendingMessage,
+  useStopConversationTurn,
   type PendingArchiveConversationUpdate,
 } from "./queries";
 import type { ConversationMailboxMessage } from "./conversationOutbox";
@@ -44,6 +46,7 @@ import {
   conversationFromDetail,
   visualStatusForConversation,
 } from "../format";
+import { Button } from "../components/Button";
 import { Card } from "../components/layout/Card";
 import { ChatLayout } from "./ChatLayout";
 import { ComposerDock } from "./ComposerDock";
@@ -284,6 +287,7 @@ export function ConversationPage(props: {
               // every 2s; a prop would bust footer memo while the reader types.
               pendingGeneratedAtRef={pendingGeneratedAtRef}
               pendingMessages={detail.pendingMessages}
+              active={live}
             />
           ) : undefined
         }
@@ -304,6 +308,7 @@ export function ConversationPage(props: {
  * footer tree. Fast chat UIs isolate the composer the same way.
  */
 const ConversationReplyFooter = memo(function ConversationReplyFooter(props: {
+  active: boolean;
   committedMessageIds: readonly string[];
   conversationId: string;
   onPinRequest: () => void;
@@ -315,6 +320,10 @@ const ConversationReplyFooter = memo(function ConversationReplyFooter(props: {
   const cancelPendingMessages = useCancelConversationPendingMessages(
     props.conversationId,
   );
+  const promotePendingMessage = usePromoteConversationPendingMessage(
+    props.conversationId,
+  );
+  const stopTurn = useStopConversationTurn(props.conversationId);
   // Keep submit identity stable across mutation status flips so the memoized
   // composer does not re-render while the reader is still typing.
   const appendMessageRef = useRef(appendMessage);
@@ -366,6 +375,12 @@ const ConversationReplyFooter = memo(function ConversationReplyFooter(props: {
   const cancellableMessageIds = props.pendingMessages
     .filter((message) => message.clientStatus === undefined)
     .map((message) => message.inboundMessageId);
+  const onPromoteMessage = useCallback(
+    (message: ConversationMailboxMessage) => {
+      promotePendingMessage.mutate(message.inboundMessageId);
+    },
+    [promotePendingMessage],
+  );
   const onCancelMessage = useCallback(
     (message: ConversationMailboxMessage) => {
       const receivedBefore = props.pendingGeneratedAtRef.current;
@@ -412,13 +427,39 @@ const ConversationReplyFooter = memo(function ConversationReplyFooter(props: {
             messages={props.pendingMessages}
             onCancelMessage={onCancelMessage}
             onLayoutChange={onMailboxLayoutChange}
+            onPromoteMessage={props.active ? onPromoteMessage : undefined}
             onRetry={onRetry}
+            promoteErrorMessageId={
+              promotePendingMessage.error
+                ? promotePendingMessage.variables
+                : undefined
+            }
+            promotePendingMessageId={
+              promotePendingMessage.isPending
+                ? promotePendingMessage.variables
+                : undefined
+            }
           />
         </>
       }
     >
       <ConversationComposer
         draftId={props.conversationId}
+        error={stopTurn.error ? "Could not stop the active turn." : undefined}
+        footerStart={
+          props.active ? (
+            <Button
+              aria-label="Stop active turn"
+              disabled={stopTurn.isPending}
+              onClick={() => stopTurn.mutate()}
+              title="Stop active turn"
+              tone="danger"
+            >
+              <span aria-hidden="true" className="size-2.5 bg-current" />
+              {stopTurn.isPending ? "Stopping…" : "Stop"}
+            </Button>
+          ) : undefined
+        }
         label="Continue this conversation"
         submitLabel="Send"
         onFocus={onComposerFocus}
diff --git a/packages/junior-dashboard/src/client/conversations/PendingMailboxStack.tsx b/packages/junior-dashboard/src/client/conversations/PendingMailboxStack.tsx
index 86be22b43f..e5c11f9e64 100644
--- a/packages/junior-dashboard/src/client/conversations/PendingMailboxStack.tsx
+++ b/packages/junior-dashboard/src/client/conversations/PendingMailboxStack.tsx
@@ -12,6 +12,7 @@ import {
   LoaderCircle,
   SkipForward,
   X,
+  Zap,
   type LucideIcon,
 } from "lucide-react";
 
@@ -61,6 +62,8 @@ function PendingMetaIcons(props: {
   cancelPending: boolean;
   message: ConversationMailboxMessage;
   onCancel?: () => void;
+  onPromote?: () => void;
+  promotePending: boolean;
   showSlack: boolean;
 }) {
   const delivery = pendingDeliveryMeta(props.message);
@@ -83,6 +86,28 @@ function PendingMetaIcons(props: {
           strokeWidth={2.2}
         />
       </PendingMetaIcon>
+      {props.onPromote ? (
+        <Tooltip content="Steer into active turn" placement="above">
+          <button
+            aria-label="Steer queued message"
+            className="inline-flex cursor-pointer items-center gap-1 rounded border-0 bg-transparent px-1 py-0.5 font-sans text-xs font-medium text-amber-100/80 transition-colors hover:bg-amber-300/[0.08] hover:text-amber-50 focus-visible:outline focus-visible:outline-1 focus-visible:outline-amber-200/55 disabled:cursor-default disabled:opacity-50"
+            disabled={props.promotePending}
+            onClick={props.onPromote}
+            type="button"
+          >
+            {props.promotePending ? (
+              <LoaderCircle
+                aria-hidden="true"
+                className="animate-spin"
+                size={12}
+              />
+            ) : (
+              <Zap aria-hidden="true" size={12} />
+            )}
+            Steer
+          </button>
+        </Tooltip>
+      ) : null}
       {props.onCancel ? (
         <Tooltip content="Remove queued message" placement="above">
           <button
@@ -118,7 +143,10 @@ function PendingRow(props: {
   cancelPending: boolean;
   message: ConversationMailboxMessage;
   onCancel?(message: ConversationMailboxMessage): void;
+  onPromote?(message: ConversationMailboxMessage): void;
   onRetry?(message: ConversationMailboxMessage): void;
+  promoteError: boolean;
+  promotePending: boolean;
 }) {
   const text = props.message.text ?? "";
   const redacted = Boolean(props.message.redacted);
@@ -149,6 +177,12 @@ function PendingRow(props: {
             onCancel={
               props.onCancel ? () => props.onCancel?.(props.message) : undefined
             }
+            onPromote={
+              props.onPromote
+                ? () => props.onPromote?.(props.message)
+                : undefined
+            }
+            promotePending={props.promotePending}
             showSlack={showSlack}
           />
         }
@@ -176,9 +210,11 @@ function PendingRow(props: {
           </button>
         </div>
       ) : null}
-      {props.cancelError ? (
+      {props.cancelError || props.promoteError ? (
         <p className="m-0 font-sans text-xs text-amber-100/75">
-          Could not remove. Try again.
+          {props.promoteError
+            ? "Could not steer. Try again."
+            : "Could not remove. Try again."}
         </p>
       ) : null}
     </article>
@@ -231,6 +267,9 @@ export const PendingMailboxStack = memo(function PendingMailboxStack(props: {
   committedMessageIds?: readonly string[];
   messages: readonly ConversationMailboxMessage[];
   onCancelMessage?: (message: ConversationMailboxMessage) => void;
+  onPromoteMessage?: (message: ConversationMailboxMessage) => void;
+  promoteErrorMessageId?: string;
+  promotePendingMessageId?: string;
   /** Fires after expand/collapse changes the stack height above the composer. */
   onLayoutChange?: () => void;
   onRetry?(message: ConversationMailboxMessage): void;
@@ -290,7 +329,19 @@ export const PendingMailboxStack = memo(function PendingMailboxStack(props: {
                   ? props.onCancelMessage
                   : undefined
               }
+              onPromote={
+                message.clientStatus === undefined &&
+                message.delivery === "defer"
+                  ? props.onPromoteMessage
+                  : undefined
+              }
               onRetry={props.onRetry}
+              promoteError={
+                props.promoteErrorMessageId === message.inboundMessageId
+              }
+              promotePending={
+                props.promotePendingMessageId === message.inboundMessageId
+              }
             />
           ))}
         </div>
@@ -313,7 +364,18 @@ export const PendingMailboxStack = memo(function PendingMailboxStack(props: {
                 ? props.onCancelMessage
                 : undefined
             }
+            onPromote={
+              message.clientStatus === undefined && message.delivery === "defer"
+                ? props.onPromoteMessage
+                : undefined
+            }
             onRetry={props.onRetry}
+            promoteError={
+              props.promoteErrorMessageId === message.inboundMessageId
+            }
+            promotePending={
+              props.promotePendingMessageId === message.inboundMessageId
+            }
           />
         ))
       )}
diff --git a/packages/junior-dashboard/src/client/conversations/conversationOutbox.ts b/packages/junior-dashboard/src/client/conversations/conversationOutbox.ts
index 4ac4b08f15..42eeddffc2 100644
--- a/packages/junior-dashboard/src/client/conversations/conversationOutbox.ts
+++ b/packages/junior-dashboard/src/client/conversations/conversationOutbox.ts
@@ -3,6 +3,7 @@ import type { ConversationPendingMessage } from "@sentry/junior/api/schema";
 /** Client-owned mailbox row waiting on accept or retry. */
 export type ConversationOutboxMessage = {
   createdAt: string;
+  delivery: "defer" | "interrupt";
   idempotencyKey: string;
   message: string;
   messageId: string;
@@ -22,6 +23,7 @@ export function conversationOutboxQueryKey(conversationId: string | undefined) {
 
 /** Build one optimistic outbox row for a composer submit. */
 export function conversationOutboxMessageForSubmit(input: {
+  delivery?: "defer" | "interrupt";
   idempotencyKey: string;
   message: string;
   now?: string;
@@ -29,6 +31,7 @@ export function conversationOutboxMessageForSubmit(input: {
   const createdAt = input.now ?? new Date().toISOString();
   return {
     createdAt,
+    delivery: input.delivery ?? "defer",
     idempotencyKey: input.idempotencyKey,
     message: input.message,
     messageId: `client:${input.idempotencyKey}`,
@@ -43,7 +46,7 @@ export function mailboxMessageFromOutbox(
   return {
     clientStatus: message.status,
     createdAt: message.createdAt,
-    delivery: "defer",
+    delivery: message.delivery,
     idempotencyKey: message.idempotencyKey,
     inboundMessageId: message.messageId,
     messageId: message.messageId,
@@ -72,7 +75,9 @@ export function mergeConversationMailboxMessages(
   const outboxMessages = outbox ?? [];
   let next: readonly ConversationMailboxMessage[] = serverMessages;
   if (outboxMessages.length > 0) {
-    const serverIds = new Set(serverMessages.map((message) => message.messageId));
+    const serverIds = new Set(
+      serverMessages.map((message) => message.messageId),
+    );
     const extras = outboxMessages
       .filter((message) => !serverIds.has(message.messageId))
       .map(mailboxMessageFromOutbox);
diff --git a/packages/junior-dashboard/src/client/conversations/queries.ts b/packages/junior-dashboard/src/client/conversations/queries.ts
index 55c853a0c9..141e31c8ad 100644
--- a/packages/junior-dashboard/src/client/conversations/queries.ts
+++ b/packages/junior-dashboard/src/client/conversations/queries.ts
@@ -21,6 +21,8 @@ import {
   conversationDetailReportSchema,
   conversationEventPageSchema,
   conversationPendingMessagesReportSchema,
+  promoteConversationPendingMessageResponseSchema,
+  stopConversationTurnResponseSchema,
 } from "@sentry/junior/api/schema";
 
 import {
@@ -240,6 +242,79 @@ export function useAppendConversationMessage(conversationId: string) {
   });
 }
 
+/** Request that the active Conversation Turn stop. */
+export function useStopConversationTurn(conversationId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () =>
+      post(
+        stopConversationTurnResponseSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/stop`,
+        {},
+      ),
+    onSettled: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ["dashboard", "conversations"],
+        }),
+        queryClient.invalidateQueries({
+          exact: true,
+          queryKey: conversationDetailQueryKey(conversationId),
+        }),
+      ]);
+    },
+  });
+}
+
+/** Promote one accepted queued Message into the active Turn. */
+export function usePromoteConversationPendingMessage(conversationId: string) {
+  const queryClient = useQueryClient();
+  const pendingQueryKey = conversationPendingMessagesQueryKey(conversationId);
+  return useMutation({
+    mutationFn: (inboundMessageId: string) =>
+      post(
+        promoteConversationPendingMessageResponseSchema,
+        `/api/conversations/${encodeURIComponent(conversationId)}/pending-messages/promote`,
+        { inboundMessageId },
+      ),
+    onMutate: async (inboundMessageId) => {
+      await queryClient.cancelQueries({
+        exact: true,
+        queryKey: pendingQueryKey,
+      });
+      const previousPending =
+        queryClient.getQueryData<ConversationPendingMessagesReport>(
+          pendingQueryKey,
+        );
+      if (previousPending) {
+        queryClient.setQueryData<ConversationPendingMessagesReport>(
+          pendingQueryKey,
+          {
+            ...previousPending,
+            messages: previousPending.messages.map((message) =>
+              message.inboundMessageId === inboundMessageId
+                ? { ...message, delivery: "interrupt" }
+                : message,
+            ),
+          },
+        );
+      }
+      return { previousPending };
+    },
+    onError: (_error, _inboundMessageId, context) => {
+      if (context?.previousPending) {
+        queryClient.setQueryData(pendingQueryKey, context.previousPending);
+      }
+    },
+    onSettled: async () => {
+      await queryClient.invalidateQueries({
+        exact: true,
+        queryKey: pendingQueryKey,
+      });
+    },
+  });
+}
+
 /** Cancel accepted human-facing mailbox rows for the open conversation. */
 export function useCancelConversationPendingMessages(conversationId: string) {
   const queryClient = useQueryClient();
diff --git a/packages/junior-dashboard/tests/conversation-outbox.test.ts b/packages/junior-dashboard/tests/conversation-outbox.test.ts
index 9189487bdf..9f0a853797 100644
--- a/packages/junior-dashboard/tests/conversation-outbox.test.ts
+++ b/packages/junior-dashboard/tests/conversation-outbox.test.ts
@@ -19,6 +19,7 @@ describe("conversation outbox", () => {
       }),
     ).toEqual({
       createdAt: "2026-01-01T00:00:00.000Z",
+      delivery: "defer",
       idempotencyKey: "attempt-1",
       message: "Continue in Junior",
       messageId: "client:attempt-1",
@@ -26,6 +27,18 @@ describe("conversation outbox", () => {
     });
   });
 
+  it("keeps interrupt delivery on the optimistic row", () => {
+    expect(
+      mailboxMessageFromOutbox(
+        conversationOutboxMessageForSubmit({
+          delivery: "interrupt",
+          idempotencyKey: "attempt-steer",
+          message: "change course",
+        }),
+      ).delivery,
+    ).toBe("interrupt");
+  });
+
   it("keeps failed outbox rows in the mailbox after accept fails", () => {
     const outbox = [
       conversationOutboxMessageForSubmit({
diff --git a/packages/junior-dashboard/tests/pending-mailbox-stack.test.tsx b/packages/junior-dashboard/tests/pending-mailbox-stack.test.tsx
index 4433078b90..ae87add6ed 100644
--- a/packages/junior-dashboard/tests/pending-mailbox-stack.test.tsx
+++ b/packages/junior-dashboard/tests/pending-mailbox-stack.test.tsx
@@ -20,7 +20,7 @@ function message(
   };
 }
 
-describe("PendingMailboxStack remove control", () => {
+describe("PendingMailboxStack controls", () => {
   it("shows remove only for an accepted mailbox row", () => {
     const accepted = renderToStaticMarkup(
       <PendingMailboxStack
@@ -45,6 +45,24 @@ describe("PendingMailboxStack remove control", () => {
     expect(localOnly).not.toContain("Remove queued message");
   });
 
+  it("shows Steer only for an accepted queued row", () => {
+    const queued = renderToStaticMarkup(
+      <PendingMailboxStack
+        messages={[message()]}
+        onPromoteMessage={() => undefined}
+      />,
+    );
+    const promoted = renderToStaticMarkup(
+      <PendingMailboxStack
+        messages={[message({ delivery: "interrupt" })]}
+        onPromoteMessage={() => undefined}
+      />,
+    );
+
+    expect(queued).toContain('aria-label="Steer queued message"');
+    expect(promoted).not.toContain('aria-label="Steer queued message"');
+  });
+
   it("keeps remove available for accepted rows while a local send is pending", () => {
     const html = renderToStaticMarkup(
       <PendingMailboxStack
diff --git a/packages/junior/src/api/conversations/promote-pending-message.ts b/packages/junior/src/api/conversations/promote-pending-message.ts
new file mode 100644
index 0000000000..3949bff4df
--- /dev/null
+++ b/packages/junior/src/api/conversations/promote-pending-message.ts
@@ -0,0 +1,65 @@
+import type { User } from "@sentry/junior-plugin-api";
+import { getConversationStore, getDb } from "@/chat/db";
+import {
+  ensureConversationWake,
+  promoteHumanFacingPendingMessage,
+} from "@/chat/task-execution/store";
+import { getVercelConversationWorkQueue } from "@/chat/task-execution/vercel-queue";
+import { throwApiError } from "../http";
+import type {
+  PromoteConversationPendingMessageBody,
+  PromoteConversationPendingMessageResponse,
+} from "../schema/conversation";
+import { readConversationAccessFromSql } from "./access";
+
+/** Promote one queued Message into the active Turn for a participant. */
+export async function promoteConversationPendingMessageForViewer(
+  viewer: User,
+  conversationId: string,
+  body: PromoteConversationPendingMessageBody,
+): Promise<PromoteConversationPendingMessageResponse> {
+  const conversation = await getConversationStore().get({ conversationId });
+  if (!conversation) throwApiError(404, "Conversation not found.");
+
+  const access = await readConversationAccessFromSql(
+    getDb(),
+    [conversationId],
+    viewer,
+  );
+  if (!access.get(conversationId)?.isParticipant) {
+    throwApiError(
+      403,
+      "Only conversation participants can steer queued messages.",
+    );
+  }
+
+  const nowMs = Date.now();
+  let result: Awaited<ReturnType<typeof promoteHumanFacingPendingMessage>>;
+  try {
+    result = await promoteHumanFacingPendingMessage({
+      conversationId,
+      inboundMessageId: body.inboundMessageId,
+      conversationStore: getConversationStore(),
+      nowMs,
+    });
+    if (result.status === "promoted") {
+      await ensureConversationWake({
+        conversationId,
+        conversationStore: getConversationStore(),
+        idempotencyKey: `steer:${body.inboundMessageId}:${nowMs}`,
+        nowMs,
+        queue: getVercelConversationWorkQueue(),
+      });
+    }
+  } catch (error) {
+    throwApiError(500, "Unable to steer queued message.", error);
+  }
+  if (result.status === "not_found") {
+    throwApiError(404, "Queued message not found.");
+  }
+  return {
+    conversationId,
+    inboundMessageId: body.inboundMessageId,
+    status: "promoted",
+  };
+}
diff --git a/packages/junior/src/api/conversations/routes.ts b/packages/junior/src/api/conversations/routes.ts
index 152b15c07b..f2a8740a92 100644
--- a/packages/junior/src/api/conversations/routes.ts
+++ b/packages/junior/src/api/conversations/routes.ts
@@ -20,6 +20,9 @@ import {
   conversationStatsReportSchema,
   createConversationBodySchema,
   createConversationMessageBodySchema,
+  promoteConversationPendingMessageBodySchema,
+  promoteConversationPendingMessageResponseSchema,
+  stopConversationTurnResponseSchema,
 } from "../schema/conversation";
 import { validateRequest } from "../validation";
 import { requireViewer } from "../viewer";
@@ -37,7 +40,9 @@ import { readConversationEvents } from "./event-list";
 import { readConversationFeed } from "./list";
 import { cancelConversationPendingMessagesForViewer } from "./cancel-pending-messages";
 import { requireConversationPendingMessages } from "./pending-messages";
+import { promoteConversationPendingMessageForViewer } from "./promote-pending-message";
 import { readConversationStats } from "./stats";
+import { stopConversationTurnForViewer } from "./stop";
 
 /** Create the HTTP routes owned by the conversations API. */
 export function createConversationRoutes(options: {
@@ -113,6 +118,24 @@ export function createConversationRoutes(options: {
     },
   );
 
+  app.post(
+    "/:conversationId/stop",
+    requireViewer,
+    validateRequest(
+      "param",
+      conversationParamsSchema,
+      "Invalid route parameters.",
+    ),
+    async (context) => {
+      const viewer = context.get("viewer");
+      const { conversationId } = context.req.valid("param");
+      return jsonResponse(
+        stopConversationTurnResponseSchema,
+        await stopConversationTurnForViewer(viewer, conversationId),
+      );
+    },
+  );
+
   app.patch(
     "/:conversationId/archive",
     requireViewer,
@@ -181,6 +204,34 @@ export function createConversationRoutes(options: {
     },
   );
 
+  app.post(
+    "/:conversationId/pending-messages/promote",
+    requireViewer,
+    validateRequest(
+      "param",
+      conversationParamsSchema,
+      "Invalid route parameters.",
+    ),
+    validateRequest(
+      "json",
+      promoteConversationPendingMessageBodySchema,
+      "Invalid request body.",
+    ),
+    async (context) => {
+      const viewer = context.get("viewer");
+      const { conversationId } = context.req.valid("param");
+      const body = context.req.valid("json");
+      return jsonResponse(
+        promoteConversationPendingMessageResponseSchema,
+        await promoteConversationPendingMessageForViewer(
+          viewer,
+          conversationId,
+          body,
+        ),
+      );
+    },
+  );
+
   app.delete(
     "/:conversationId/pending-messages",
     requireViewer,
diff --git a/packages/junior/src/api/conversations/stop.ts b/packages/junior/src/api/conversations/stop.ts
new file mode 100644
index 0000000000..3658cc1963
--- /dev/null
+++ b/packages/junior/src/api/conversations/stop.ts
@@ -0,0 +1,40 @@
+import type { User } from "@sentry/junior-plugin-api";
+import { stopConversationTurn } from "@/chat/conversations/stop";
+import { getConversationStore, getDb } from "@/chat/db";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import { getVercelConversationWorkQueue } from "@/chat/task-execution/vercel-queue";
+import { throwApiError } from "../http";
+import type { StopConversationTurnResponse } from "../schema/conversation";
+import { readConversationAccessFromSql } from "./access";
+
+/** Stop the active Turn for one conversation participant. */
+export async function stopConversationTurnForViewer(
+  viewer: User,
+  conversationId: string,
+  options?: { queue?: ConversationWorkQueue },
+): Promise<StopConversationTurnResponse> {
+  const conversation = await getConversationStore().get({ conversationId });
+  if (!conversation) {
+    throwApiError(404, "Conversation not found.");
+  }
+
+  const access = await readConversationAccessFromSql(
+    getDb(),
+    [conversationId],
+    viewer,
+  );
+  if (!access.get(conversationId)?.isParticipant) {
+    throwApiError(403, "Only conversation participants can stop this turn.");
+  }
+
+  try {
+    const result = await stopConversationTurn({
+      conversationId,
+      conversationStore: getConversationStore(),
+      queue: options?.queue ?? getVercelConversationWorkQueue(),
+    });
+    return { conversationId, status: result.status };
+  } catch (error) {
+    throwApiError(500, "Unable to stop the active turn.", error);
+  }
+}
diff --git a/packages/junior/src/api/schema.ts b/packages/junior/src/api/schema.ts
index de11ea2d36..7537346f14 100644
--- a/packages/junior/src/api/schema.ts
+++ b/packages/junior/src/api/schema.ts
@@ -43,6 +43,9 @@ export {
   conversationSummaryReportSchema,
   createConversationBodySchema,
   createConversationMessageBodySchema,
+  promoteConversationPendingMessageBodySchema,
+  promoteConversationPendingMessageResponseSchema,
+  stopConversationTurnResponseSchema,
 } from "./schema/conversation";
 export type {
   AcceptedConversationMessage,
@@ -66,6 +69,7 @@ export type {
   ConversationReportStatus,
   ConversationTurnFailureCode,
   ConversationTurnFailureReason,
+  StopConversationTurnResponse,
   ConversationMetricDay,
   ConversationModelUsage,
   ConversationParams,
@@ -77,6 +81,8 @@ export type {
   ConversationUsage,
   CreateConversationBody,
   CreateConversationMessageBody,
+  PromoteConversationPendingMessageBody,
+  PromoteConversationPendingMessageResponse,
   GuardianMetricDay,
   GuardianStats,
 } from "./schema/conversation";
diff --git a/packages/junior/src/api/schema/conversation.ts b/packages/junior/src/api/schema/conversation.ts
index a2a3c245dc..663ae2c556 100644
--- a/packages/junior/src/api/schema/conversation.ts
+++ b/packages/junior/src/api/schema/conversation.ts
@@ -102,6 +102,14 @@ export const acceptedConversationMessageSchema = z
   })
   .strict();
 
+/** Result of requesting that the active Conversation Turn stop. */
+export const stopConversationTurnResponseSchema = z
+  .object({
+    conversationId: z.string().min(1),
+    status: z.enum(["no_work", "requested"]),
+  })
+  .strict();
+
 export const actorIdentitySchema = z
   .object({
     email: z.string().optional(),
@@ -166,6 +174,20 @@ export const conversationPendingMessagesReportSchema = z
   })
   .strict();
 
+/** Select one queued Message to promote into the active Turn. */
+export const promoteConversationPendingMessageBodySchema = z
+  .object({ inboundMessageId: z.string().min(1) })
+  .strict();
+
+/** Result of promoting one queued Message. */
+export const promoteConversationPendingMessageResponseSchema = z
+  .object({
+    conversationId: z.string().min(1),
+    inboundMessageId: z.string().min(1),
+    status: z.literal("promoted"),
+  })
+  .strict();
+
 /** Optional filters for cancelling accepted mailbox rows. */
 export const cancelConversationPendingMessagesBodySchema = z
   .object({
@@ -897,6 +919,9 @@ export type CreateConversationMessageBody = z.infer<
 export type AcceptedConversationMessage = z.infer<
   typeof acceptedConversationMessageSchema
 >;
+export type StopConversationTurnResponse = z.infer<
+  typeof stopConversationTurnResponseSchema
+>;
 export type ConversationPendingMessageDelivery = z.infer<
   typeof conversationPendingMessageDeliverySchema
 >;
@@ -906,6 +931,12 @@ export type ConversationPendingMessage = z.infer<
 export type ConversationPendingMessagesReport = z.infer<
   typeof conversationPendingMessagesReportSchema
 >;
+export type PromoteConversationPendingMessageBody = z.infer<
+  typeof promoteConversationPendingMessageBodySchema
+>;
+export type PromoteConversationPendingMessageResponse = z.infer<
+  typeof promoteConversationPendingMessageResponseSchema
+>;
 export type CancelConversationPendingMessagesBody = z.infer<
   typeof cancelConversationPendingMessagesBodySchema
 >;
diff --git a/packages/junior/src/chat/conversations/web-mailbox.ts b/packages/junior/src/chat/conversations/web-mailbox.ts
index c9b318840a..270c5c05e8 100644
--- a/packages/junior/src/chat/conversations/web-mailbox.ts
+++ b/packages/junior/src/chat/conversations/web-mailbox.ts
@@ -11,6 +11,7 @@ export const legacyWebMailboxMetadataSchema = z
     authorUserName: z.string().min(1).optional(),
     kind: z.literal("api_turn"),
     messageId: z.string().min(1),
+    steeredAtMs: z.number().finite().optional(),
   })
   .strict();
 
diff --git a/packages/junior/src/chat/task-execution/state.ts b/packages/junior/src/chat/task-execution/state.ts
index a1307281e0..35ec9ab2ee 100644
--- a/packages/junior/src/chat/task-execution/state.ts
+++ b/packages/junior/src/chat/task-execution/state.ts
@@ -1827,6 +1827,55 @@ export async function completeConversationStop(args: {
   });
 }
 
+/** Promote one human-facing pending Message into the active Turn. */
+export async function promoteHumanFacingPendingMessage(args: {
+  conversationId: string;
+  inboundMessageId: string;
+  nowMs?: number;
+  state?: StateAdapter;
+}): Promise<{ status: "not_found" | "promoted" }> {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) return { status: "not_found" };
+
+    let promoted = false;
+    const pendingMessages = current.execution.pendingMessages.map((message) => {
+      if (
+        message.inboundMessageId !== args.inboundMessageId ||
+        !isHumanFacingMessage(message)
+      ) {
+        return message;
+      }
+      promoted = true;
+      if (message.delivery === "interrupt") return message;
+      return {
+        ...message,
+        delivery: "interrupt" as const,
+        input: {
+          ...message.input,
+          metadata: {
+            ...message.input.metadata,
+            steeredAtMs: nowMs,
+          },
+        },
+      };
+    });
+    if (!promoted) return { status: "not_found" };
+
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        { ...current.execution, pendingMessages },
+        nowMs,
+      ),
+    );
+    return { status: "promoted" };
+  });
+}
+
 /** Cancel human-facing pending mailbox rows without requiring a worker lease. */
 export async function cancelHumanFacingPendingMessages(args: {
   conversationId: string;
diff --git a/packages/junior/src/chat/task-execution/store.ts b/packages/junior/src/chat/task-execution/store.ts
index b2dc648e11..e7c542e80f 100644
--- a/packages/junior/src/chat/task-execution/store.ts
+++ b/packages/junior/src/chat/task-execution/store.ts
@@ -489,6 +489,19 @@ export async function ackMessages(args: {
   return result;
 }
 
+/** Promote one human-facing pending Message into the active Turn. */
+export async function promoteHumanFacingPendingMessage(args: {
+  conversationId: string;
+  inboundMessageId: string;
+  conversationStore?: ConversationStore;
+  nowMs?: number;
+  state?: StateAdapter;
+}) {
+  const result = await workState.promoteHumanFacingPendingMessage(args);
+  if (result.status === "promoted") await recordExecutionMetadata(args);
+  return result;
+}
+
 /** Cancel human-facing pending mailbox rows without requiring a worker lease. */
 export async function cancelHumanFacingPendingMessages(args: {
   conversationId: string;
diff --git a/packages/junior/src/chat/task-execution/worker.ts b/packages/junior/src/chat/task-execution/worker.ts
index 03937b019f..913bfef98a 100644
--- a/packages/junior/src/chat/task-execution/worker.ts
+++ b/packages/junior/src/chat/task-execution/worker.ts
@@ -123,6 +123,14 @@ function selectAttemptMessages(work: ConversationWorkState): InboundMessage[] {
     : selectContiguousTurnBatch(messages);
 }
 
+function messageWasSteeredDuringAttempt(
+  message: InboundMessage,
+  startedAtMs: number,
+): boolean {
+  const steeredAtMs = message.input.metadata?.steeredAtMs;
+  return typeof steeredAtMs === "number" && steeredAtMs >= startedAtMs;
+}
+
 function nudgeIdempotencyKey(
   reason: string,
   conversationId: string,
@@ -478,13 +486,14 @@ async function processConversationWorkInContext(
       conversationStore: options.conversationStore,
       handle: async (messages) => {
         // Pending work that was not selected when the attempt started belongs
-        // to a later actor-scoped attempt. Selected or newly arrived
-        // interrupts remain eligible for this attempt's drain.
+        // to a later actor-scoped attempt. Selected, newly arrived, or newly
+        // steered interrupts remain eligible for this attempt's drain.
         const candidates = messages.filter(
           (message) =>
             message.delivery === "interrupt" &&
             (attemptSelectedMessageIds.has(message.inboundMessageId) ||
-              !attemptStartMessageIds.has(message.inboundMessageId)),
+              !attemptStartMessageIds.has(message.inboundMessageId) ||
+              messageWasSteeredDuringAttempt(message, startedAtMs)),
         );
         if (candidates.length === 0) {
           return [];
diff --git a/packages/junior/tests/component/task-execution/conversation-work.test.ts b/packages/junior/tests/component/task-execution/conversation-work.test.ts
index 534c7494a3..055c7a6d3c 100644
--- a/packages/junior/tests/component/task-execution/conversation-work.test.ts
+++ b/packages/junior/tests/component/task-execution/conversation-work.test.ts
@@ -20,6 +20,7 @@ import {
   listActiveConversationIds,
   listConversationsByActivity,
   ackMessages,
+  promoteHumanFacingPendingMessage,
   recordConversationActivity,
   requestAnotherSlice,
   requestConversationWork,
@@ -2238,6 +2239,63 @@ describe("conversation work execution", () => {
     expect(injected).toEqual([["m1"], ["m2"]]);
   });
 
+  it("injects an older queued Message after it is steered", async () => {
+    const queue = createConversationWorkQueueTestAdapter();
+    let currentNowMs = 1_500;
+    await appendInboundMessage({ message: inboundMessage("m1"), nowMs: 1_000 });
+    await appendInboundMessage({
+      message: inboundMessage("m2", {
+        delivery: "defer",
+        source: "web",
+      }),
+      nowMs: 1_100,
+    });
+    await appendInboundMessage({
+      message: inboundMessage("m3", {
+        input: { authorId: "U456", text: "message m3" },
+      }),
+      nowMs: 1_200,
+    });
+    const injected: string[][] = [];
+    let runs = 0;
+
+    await expect(
+      processConversationWork(conversationQueueMessage(), {
+        nowMs: () => currentNowMs,
+        queue,
+        run: async (context) => {
+          runs += 1;
+          if (runs > 1) {
+            await context.attempt.ack();
+            return { status: "completed" };
+          }
+          const first = await context.attempt.drain(async () => {});
+          injected.push(first.map((message) => message.inboundMessageId));
+          currentNowMs = 2_000;
+          await promoteHumanFacingPendingMessage({
+            conversationId: CONVERSATION_ID,
+            inboundMessageId: "m2",
+            nowMs: currentNowMs,
+          });
+          await promoteHumanFacingPendingMessage({
+            conversationId: CONVERSATION_ID,
+            inboundMessageId: "m3",
+            nowMs: currentNowMs,
+          });
+          const second = await context.attempt.drain(async () => {});
+          injected.push(second.map((message) => message.inboundMessageId));
+          return { status: "completed" };
+        },
+      }),
+    ).resolves.toEqual({ status: "completed" });
+
+    expect(injected).toEqual([["m1"], ["m2"]]);
+    expect(runs).toBe(2);
+    await expect(
+      getConversationWorkState({ conversationId: CONVERSATION_ID }),
+    ).resolves.toMatchObject({ messages: [] });
+  });
+
   it("clears the run marker after draining messages that arrived during active execution", async () => {
     const queue = createConversationWorkQueueTestAdapter();
     await appendInboundMessage({ message: inboundMessage("m1"), nowMs: 1_000 });
diff --git a/packages/junior/tests/integration/api/conversations/turn-controls.test.ts b/packages/junior/tests/integration/api/conversations/turn-controls.test.ts
new file mode 100644
index 0000000000..8511e7a6e4
--- /dev/null
+++ b/packages/junior/tests/integration/api/conversations/turn-controls.test.ts
@@ -0,0 +1,148 @@
+import { Hono } from "hono";
+import { afterEach, describe, expect, it } from "vitest";
+import { createJuniorApi, type JuniorApiVariables } from "@/api";
+import { stopConversationTurnForViewer } from "@/api/conversations/stop";
+import {
+  acceptedConversationMessageSchema,
+  conversationPendingMessagesReportSchema,
+  promoteConversationPendingMessageResponseSchema,
+  stopConversationTurnResponseSchema,
+} from "@/api/schema";
+import { createAndEnqueueConversation } from "@/chat/conversations/web-input";
+import { closeDb } from "@/chat/db";
+import {
+  getConversation,
+  startConversationWork,
+} from "@/chat/task-execution/store";
+import {
+  closeConversationFixture,
+  createConversationFixture,
+} from "../../../fixtures/conversation";
+import { testViewer } from "../../../fixtures/user";
+
+function authenticatedApi(email: string) {
+  const app = new Hono<{ Variables: JuniorApiVariables }>();
+  app.use("*", async (context, next) => {
+    context.set("viewer", testViewer(email));
+    await next();
+  });
+  app.route("/", createJuniorApi());
+  return app;
+}
+
+describe("conversation turn controls API", () => {
+  afterEach(async () => {
+    await closeConversationFixture();
+    await closeDb();
+  });
+
+  it("promotes a queued dashboard message into the active turn", async () => {
+    const { actor, conversationStore, queue, state } =
+      await createConversationFixture();
+    const created = await createAndEnqueueConversation(
+      {
+        actor,
+        idempotencyKey: "steer-root",
+        message: "first",
+      },
+      { conversationStore, queue, state },
+    );
+    const app = authenticatedApi(actor.email);
+
+    const response = await app.request(
+      `http://localhost/api/conversations/${encodeURIComponent(created.conversationId)}/messages`,
+      {
+        body: JSON.stringify({
+          idempotencyKey: "steer-next",
+          message: "change course",
+        }),
+        headers: { "content-type": "application/json" },
+        method: "POST",
+      },
+    );
+    expect(response.status).toBe(200);
+    acceptedConversationMessageSchema.parse(await response.json());
+
+    const pendingResponse = await app.request(
+      `http://localhost/api/conversations/${encodeURIComponent(created.conversationId)}/pending-messages`,
+    );
+    const pending = conversationPendingMessagesReportSchema.parse(
+      await pendingResponse.json(),
+    );
+    const queued = pending.messages.at(-1);
+    expect(queued).toMatchObject({
+      delivery: "defer",
+      source: "web",
+      text: "change course",
+    });
+
+    const promoteResponse = await app.request(
+      `http://localhost/api/conversations/${encodeURIComponent(created.conversationId)}/pending-messages/promote`,
+      {
+        body: JSON.stringify({
+          inboundMessageId: queued?.inboundMessageId,
+        }),
+        headers: { "content-type": "application/json" },
+        method: "POST",
+      },
+    );
+    expect(promoteResponse.status).toBe(200);
+    expect(
+      promoteConversationPendingMessageResponseSchema.parse(
+        await promoteResponse.json(),
+      ),
+    ).toMatchObject({
+      inboundMessageId: queued?.inboundMessageId,
+      status: "promoted",
+    });
+
+    const promotedResponse = await app.request(
+      `http://localhost/api/conversations/${encodeURIComponent(created.conversationId)}/pending-messages`,
+    );
+    const promoted = conversationPendingMessagesReportSchema.parse(
+      await promotedResponse.json(),
+    );
+    expect(promoted.messages.at(-1)).toMatchObject({
+      delivery: "interrupt",
+      text: "change course",
+    });
+  });
+
+  it("requests that an active dashboard turn stop", async () => {
+    const { actor, conversationStore, queue, state } =
+      await createConversationFixture();
+    const created = await createAndEnqueueConversation(
+      {
+        actor,
+        idempotencyKey: "stop-root",
+        message: "first",
+      },
+      { conversationStore, queue, state },
+    );
+    const lease = await startConversationWork({
+      conversationId: created.conversationId,
+      nowMs: 2_000,
+      state,
+    });
+    expect(lease.status).toBe("acquired");
+    if (lease.status !== "acquired") throw new Error("Expected work lease");
+
+    expect(
+      stopConversationTurnResponseSchema.parse(
+        await stopConversationTurnForViewer(
+          testViewer(actor.email),
+          created.conversationId,
+          { queue },
+        ),
+      ),
+    ).toEqual({
+      conversationId: created.conversationId,
+      status: "requested",
+    });
+    await expect(
+      getConversation({ conversationId: created.conversationId, state }),
+    ).resolves.toMatchObject({
+      execution: { stop: { runId: expect.any(String) } },
+    });
+  });
+});