@@ -3517,7 +3517,7 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
             activeAttemptId: null,
             status: "cancelled",
             requestedAt: nowIso,
-            startedAt: nowIso,
+            startedAt: null,
             completedAt: nowIso,
             checkpointId: null,
             contextHandoffId: null,
@@ -3646,6 +3646,48 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
         ),
       );
 
+      // A steer cancels the queued run before it starts while the steered run keeps writing, so
+      // the queued message leaves the window but its run is still the shell's latest run.
+      const steeredItemId = "turn-item:bounded-sql-history:steered-output";
+      const steeredRunId = RunId.make("run:bounded-sql-history:1000");
+      yield* sql`
+        INSERT INTO orchestration_v2_projection_turn_items (
+          turn_item_id, thread_id, run_id, node_id, provider_thread_id, provider_turn_id,
+          parent_item_id, ordinal, type, status, updated_at, payload_json
+        ) VALUES (
+          ${steeredItemId}, ${threadId}, ${steeredRunId}, NULL, NULL, NULL, NULL, 1203,
+          'command_execution', 'completed', ${nowIso},
+          ${encodeUnknownJsonString({
+            id: steeredItemId,
+            threadId,
+            runId: steeredRunId,
+            nodeId: null,
+            providerThreadId: null,
+            providerTurnId: null,
+            nativeItemRef: null,
+            parentItemId: null,
+            ordinal: 1203,
+            status: "completed",
+            title: "steered output",
+            input: "echo steered",
+            output: "steered",
+            exitCode: 0,
+            startedAt: nowIso,
+            completedAt: nowIso,
+            updatedAt: nowIso,
+            type: "command_execution",
+          })}
+        )
+      `;
+      const steeredSnapshot = yield* projectionStore.getThreadSnapshotWindow(threadId, {
+        rowLimit: sqlPageLimit,
+      });
+      assert.isFalse(
+        steeredSnapshot.projection.turnItems.some((item) => item.runId === cancelledRunId),
+      );
+      assert.isTrue(steeredSnapshot.projection.runs.some((run) => run.id === cancelledRunId));
+      yield* sql`DELETE FROM orchestration_v2_projection_turn_items WHERE turn_item_id = ${steeredItemId}`;
+
       const interruptRunId = RunId.make("run:bounded-sql-history:interrupt");
       const interruptNodeId = NodeId.make("node:bounded-sql-history:interrupt");
       const interruptRequestId = TurnItemId.make("turn-item:bounded-sql-history:interrupt-request");
 
@@ -3378,6 +3378,12 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
               AND (status IN ('queued','preparing','starting','running','waiting')
                 OR run_id IN (SELECT value FROM json_each(${cohortRunIds}))
                 OR run_id = ${window.requiredRunId ?? null}
+                ${
+                  // The shell's latest run, even a steer-cancelled one outside the newest window.
+                  window.anchorItemId === undefined && window.requiredRunId === undefined
+                    ? sql`OR run_id = ${presentedShellRunId(sql`${threadId}`)}`
+                    : sql``
+                }
                 -- Queued or cancelled turns must not hide the latest actual session.
                 OR run_id = ${latestTodoList?.run_id ?? null}
                 OR run_id = (
@@ -6192,6 +6198,19 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
         )
       )`;
     };
+    // The newest run not waiting in a held queue, matching latestUnheldRun.
+    const presentedShellRunId = (threadId: Statement.Fragment) => sql`(
+      SELECT candidate.run_id
+      FROM orchestration_v2_projection_runs candidate
+      WHERE candidate.thread_id = ${threadId}
+        AND NOT (
+          candidate.status = 'queued'
+          AND json_extract(candidate.payload_json, '$.queueHeld') IS 1
+        )
+        AND NOT ${isSilentShellRun("candidate")}
+      ORDER BY candidate.ordinal DESC, candidate.run_id DESC
+      LIMIT 1
+    )`;
 
     const selectShellThreadRows = (
       threadId?: ThreadId,
@@ -6359,19 +6378,8 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
               ORDER BY r.ordinal DESC, r.run_id DESC
               LIMIT 1
             )
-            -- The newest run not waiting in a held queue, matching latestUnheldRun.
-            LEFT JOIN orchestration_v2_projection_runs presented ON presented.run_id = (
-              SELECT candidate.run_id
-              FROM orchestration_v2_projection_runs candidate
-              WHERE candidate.thread_id = t.thread_id
-                AND NOT (
-                  candidate.status = 'queued'
-                  AND json_extract(candidate.payload_json, '$.queueHeld') IS 1
-                )
-                AND NOT ${isSilentShellRun("candidate")}
-              ORDER BY candidate.ordinal DESC, candidate.run_id DESC
-              LIMIT 1
-            )
+            LEFT JOIN orchestration_v2_projection_runs presented
+              ON presented.run_id = ${presentedShellRunId(sql.literal("t.thread_id"))}
             LEFT JOIN orchestration_v2_projection_runs blocked ON blocked.run_id = (
               SELECT candidate.run_id
               FROM orchestration_v2_projection_runs candidate
 
@@ -380,6 +380,7 @@ import type { CodexArtifactTemplate } from "@t3tools/shared/codexArtifactTemplat
 const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = [];
 const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];
 const EMPTY_TURN_ITEMS: ThreadStructure["turnItems"] = [];
+const EMPTY_RUNS: ThreadStructure["runs"] = [];
 const EMPTY_AUTO_UPDATE_ENVIRONMENTS: ReadonlyArray<EnvironmentPresentation> = [];
 const EMPTY_COMPOSER_BANNER_ITEMS: ReadonlyArray<ComposerBannerStackItem> = [];
 
@@ -3575,6 +3576,7 @@ export default function ChatView(props: ChatViewProps) {
                                 draftId={draftId}
                                 activeThreadId={activeThreadId}
                                 activeThread={activeThread}
+                                activeThreadRuns={serverProjection?.runs ?? EMPTY_RUNS}
                                 promptHistoryEntries={timelineEntries}
                                 forceExpandedOnMobile={
                                   forceExpandedMobileComposer && isDraftHeroState
 
@@ -187,7 +187,11 @@ import { useThreadContextDrop, threadContextDropTargetProps } from "./threadCont
 import { readThreadShell } from "~/state/entities";
 import { useLinkedEnvironments } from "~/state/peerLinks";
 import { encodeComposerContextFragment } from "@t3tools/shared/composerContextClipboard";
-import type { ComposerContextRecord, ThreadPullRequestLink } from "@t3tools/contracts";
+import type {
+  ComposerContextRecord,
+  OrchestrationV2Run,
+  ThreadPullRequestLink,
+} from "@t3tools/contracts";
 import { threadContextAttachment } from "~/lib/threadContextAttachment";
 import {
   type ComposerCommandItem,
@@ -353,6 +357,7 @@ export interface ChatComposerProps {
 
   activeThreadId: ThreadId | null;
   activeThread: Thread | undefined;
+  activeThreadRuns: ReadonlyArray<OrchestrationV2Run>;
   promptHistoryEntries: ReadonlyArray<TimelineEntry>;
   forceExpandedOnMobile: boolean;
   projectSelectionRequired: boolean;
@@ -499,6 +504,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     onMultipleModelSelectionsChange: setMultipleModelSelections,
     activeThreadId,
     activeThread,
+    activeThreadRuns,
     promptHistoryEntries,
     forceExpandedOnMobile,
     projectSelectionRequired,
@@ -2258,6 +2264,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const { suggestion: promptSuggestion, dismiss: dismissPromptSuggestion } = usePromptSuggestion(
     environmentId,
     activeThread,
+    activeThreadRuns,
   );
   // After /clear the next message starts a fresh session that cannot see what the suggestion refers to.
   const freshSessionArmed = useFreshSessionArmed(scopedThreadKey(routeThreadRef));
 
@@ -0,0 +1,71 @@
+import {
+  MessageId,
+  type OrchestrationV2Run,
+  ProviderInstanceId,
+  RunId,
+  ThreadId,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import { describe, expect, it } from "vite-plus/test";
+
+import { offeredPromptSuggestion } from "./usePromptSuggestion";
+
+const now = DateTime.makeUnsafe("2026-06-20T00:00:00.000Z");
+const run = (
+  id: RunId,
+  ordinal: number,
+  status: OrchestrationV2Run["status"],
+  started = true,
+): OrchestrationV2Run => ({
+  id,
+  threadId: ThreadId.make("thread-1"),
+  ordinal,
+  providerInstanceId: ProviderInstanceId.make("claudeAgent"),
+  modelSelection: { instanceId: ProviderInstanceId.make("claudeAgent"), model: "claude-haiku-4-5" },
+  providerThreadId: null,
+  userMessageId: MessageId.make(`message-${ordinal}`),
+  rootNodeId: null,
+  activeAttemptId: null,
+  status,
+  requestedAt: now,
+  startedAt: started ? now : null,
+  completedAt: now,
+  checkpointId: null,
+  contextHandoffId: null,
+});
+const summary = (value: OrchestrationV2Run) => ({
+  runId: value.id,
+  status: value.status,
+  requestedAt: null,
+  startedAt: value.startedAt === null ? null : "2026-06-20T00:00:00.000Z",
+  completedAt: "2026-06-20T00:00:00.000Z",
+  assistantMessageId: null,
+});
+
+describe("offeredPromptSuggestion", () => {
+  it("offers the finished turn's suggestion after a queued message was promoted to Steer", () => {
+    const turn = run(RunId.make("run-1"), 1, "completed");
+    const steered = run(RunId.make("run-2"), 2, "cancelled", false);
+    const suggestion = { runId: turn.id, text: "run the tests" };
+
+    expect(offeredPromptSuggestion(suggestion, summary(steered), [turn, steered])).toBe(suggestion);
+
+    // A later run that did start still replaces the earlier turn's suggestion.
+    const stopped = run(RunId.make("run-2"), 2, "cancelled");
+    expect(offeredPromptSuggestion(suggestion, summary(stopped), [turn, stopped])).toBeNull();
+
+    // Several never-started runs in a row still fall back to the turn that ran.
+    const removed = run(RunId.make("run-3"), 3, "cancelled", false);
+    expect(offeredPromptSuggestion(suggestion, summary(removed), [turn, steered, removed])).toBe(
+      suggestion,
+    );
+
+    // A newer turn that completed behind the cancelled run owns the suggestion slot.
+    const next = run(RunId.make("run-2"), 2, "completed");
+    expect(offeredPromptSuggestion(suggestion, summary(removed), [turn, next, removed])).toBeNull();
+
+    // Cached detail that predates the shell's cancelled run cannot vouch for what ran in between.
+    const unseen = run(RunId.make("run-3"), 3, "cancelled", false);
+    expect(offeredPromptSuggestion(suggestion, summary(unseen), [turn])).toBeNull();
+  });
+});
@@ -1,11 +1,12 @@
-import type { EnvironmentId, RunId } from "@t3tools/contracts";
+import type { EnvironmentId, OrchestrationV2Run, RunId } from "@t3tools/contracts";
 import { useSyncExternalStore } from "react";
 
 import type { Thread } from "../../types";
 import { useMediaQuery } from "../../hooks/useMediaQuery";
 import { useServerConfigs } from "../../state/entities";
 import { orchestrationEnvironment } from "../../state/orchestration";
 import { useEnvironmentQuery } from "../../state/query";
+import { announcedRun } from "./threadActivityAnnouncement";
 
 // Dismissed suggestions, keyed by environment and run, shared by every mounted composer and kept
 // across remounts. Run ids derive from thread ids, which can repeat across environments.
@@ -18,13 +19,43 @@ const subscribeDismissed = (listener: () => void) => {
 const readDismissed = () => dismissedKeys;
 const dismissKey = (environmentId: EnvironmentId, runId: RunId) => `${environmentId}\u0000${runId}`;
 
+/**
+ * The suggestion while the run that produced it is the thread's latest completed run. A message
+ * promoted to Steer leaves its queued run cancelled before it started, still the latest run, so
+ * the comparison skips to the last run that ran. Detail can lag the shell, so it skips only once
+ * the runs include that cancelled run.
+ */
+export function offeredPromptSuggestion<Suggestion extends { readonly runId: RunId }>(
+  suggestion: Suggestion | null | undefined,
+  latestRun: Thread["latestRun"] | undefined,
+  runs: ReadonlyArray<OrchestrationV2Run>,
+): Suggestion | null {
+  const run = announcedRun(latestRun ?? null, runs);
+  const skippedUnseenRun =
+    latestRun != null &&
+    run?.runId !== latestRun.runId &&
+    !runs.some(
+      (candidate) =>
+        candidate.id === latestRun.runId &&
+        candidate.status === "cancelled" &&
+        candidate.startedAt === null,
+    );
+  return suggestion &&
+    !skippedUnseenRun &&
+    run?.runId === suggestion.runId &&
+    run.status === "completed"
+    ? suggestion
+    : null;
+}
+
 /**
  * The provider's predicted next prompt, while the run that produced it is the thread's latest
  * completed run and Escape has not dismissed it.
  */
 export function usePromptSuggestion(
   environmentId: EnvironmentId,
   thread: Thread | undefined,
+  runs: ReadonlyArray<OrchestrationV2Run>,
 ): { readonly suggestion: string | null; readonly dismiss: () => void } {
   // Older servers decode the missing setting as false, so true also proves the method exists.
   const enabled = useServerConfigs().get(environmentId)?.settings.promptSuggestionsEnabled === true;
@@ -40,9 +71,7 @@ export function usePromptSuggestion(
       : null,
   );
   const dismissed = useSyncExternalStore(subscribeDismissed, readDismissed);
-  const latestRun = thread?.latestRun;
-  const offered =
-    data && latestRun?.runId === data.runId && latestRun.status === "completed" ? data : null;
+  const offered = offeredPromptSuggestion(data, thread?.latestRun, runs);
   return {
     suggestion:
       offered && !dismissed.has(dismissKey(environmentId, offered.runId)) ? offered.text : null,