fix(orchestration): fork from a response a steer cut off

apps/mobile/src/features/threads/ThreadFeed.tsx

@@ -161,6 +161,7 @@ import {
 } from "@t3tools/mobile-markdown-text/links";
 import {
   failedFeedRunIds,
+  terminalFeedAssistantMessageIds,
   deriveThreadFeedPresentation,
   threadFeedRunIsUnsettled,
   isContextCompactionActivityGroup,
@@ -321,6 +322,8 @@ function AssistantForkButton(props: {
   readonly environmentId: EnvironmentId;
   readonly iconColor: ColorValue;
   readonly projectedItem: OrchestrationV2ProjectedTurnItem;
+  /** A later response in the run follows, so the fork cuts at this item. */
+  readonly midRun: boolean;
   readonly sourceTitle: string;
 }) {
   const support = useV2ItemSupport({
@@ -354,6 +357,7 @@ function AssistantForkButton(props: {
             sourceThreadId: props.projectedItem.sourceThreadId,
             targetThreadId,
             runId,
+            ...(props.midRun ? { turnItemId: props.projectedItem.item.id } : {}),
             title: `${props.sourceTitle} fork`,
             creationSource: "mobile",
           },
@@ -1525,7 +1529,7 @@ function renderFeedEntry(
     readonly expandedWorkRows: Record<string, boolean>;
     readonly workRowSizing: ReturnType<typeof deriveThreadWorkLogSizing>;
     readonly workGroupScrollPositions: Map<string, ThreadWorkGroupScrollPosition>;
-    readonly terminalAssistantMessageIds: ReadonlySet<string>;
+    readonly terminalAssistantMessageIds: ReturnType<typeof terminalFeedAssistantMessageIds>;
     readonly unsettledTurnId: RunId | null;
     readonly failedRunIds: ReadonlySet<RunId>;
     readonly onCopyWorkRow: (rowId: string, value: string) => void;
@@ -1694,7 +1698,7 @@ function renderFeedEntry(
       message.runId === props.unsettledTurnId;
     const showAssistantMeta =
       message.role === "assistant" &&
-      props.terminalAssistantMessageIds.has(message.id) &&
+      props.terminalAssistantMessageIds.terminalIds.has(message.id) &&
       !assistantTurnStillInProgress &&
       !message.streaming;
 
@@ -1966,6 +1970,7 @@ function renderFeedEntry(
                 environmentId={props.environmentId}
                 iconColor={iconSubtleColor}
                 projectedItem={message.projectedItem}
+                midRun={props.terminalAssistantMessageIds.midRunIds.has(message.id)}
                 sourceTitle={props.threadTitle}
               />
             ) : null}
@@ -2761,15 +2766,10 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) {
     () => failedFeedRunIds(props.feed, props.latestRun),
     [props.feed, props.latestRun],
   );
-  const terminalAssistantMessageIds = useMemo(() => {
-    const terminalIdsByTurn = new Map<RunId, string>();
-    for (const entry of props.feed) {
-      if (entry.type === "message" && entry.message.role === "assistant" && entry.message.runId) {
-        terminalIdsByTurn.set(entry.message.runId, entry.message.id);
-      }
-    }
-    return new Set(terminalIdsByTurn.values());
-  }, [props.feed]);
+  const terminalAssistantMessageIds = useMemo(
+    () => terminalFeedAssistantMessageIds(props.feed),
+    [props.feed],
+  );
   useEffect(() => {
     const previous = previousLatestTurnRef.current;
     previousLatestTurnRef.current = props.latestRun;

apps/mobile/src/lib/threadActivity.test.ts

@@ -31,6 +31,7 @@ import {
   deriveThreadFeedPresentation,
   threadFeedActivityIsVisible,
   threadFeedRunIsUnsettled,
+  terminalFeedAssistantMessageIds,
   type ThreadFeedActivity,
   type ThreadFeedEntry,
   togglePendingUserInputOptionSelection,
@@ -2028,6 +2029,56 @@ const multiSelectQuestion = {
   multiSelect: true,
 } as const;
 
+describe("terminalFeedAssistantMessageIds", () => {
+  const runId = RunId.make("steered-run");
+  const message = (
+    id: string,
+    role: "user" | "assistant",
+    inputIntent?: "turn_start" | "steer",
+  ): ThreadFeedEntry => ({
+    type: "message",
+    id,
+    createdAt: "2026-04-01T00:00:00.000Z",
+    message: {
+      id: MessageId.make(id),
+      role,
+      text: id,
+      attachments: [],
+      runId,
+      streaming: false,
+      ...(inputIntent === undefined ? {} : { inputIntent }),
+      visibility: "local",
+      sourceThreadId: ThreadId.make("thread"),
+      createdAt: "2026-04-01T00:00:00.000Z",
+      updatedAt: "2026-04-01T00:00:00.000Z",
+    },
+  });
+
+  it("ends a response at each steer and marks only the cut-off one as mid-run", () => {
+    const ids = terminalFeedAssistantMessageIds([
+      message("prompt", "user", "turn_start"),
+      message("commentary", "assistant"),
+      message("cut-off", "assistant"),
+      message("steer", "user", "steer"),
+      message("final", "assistant"),
+    ]);
+
+    expect([...ids.terminalIds]).toEqual(["cut-off", "final"]);
+    expect([...ids.midRunIds]).toEqual(["cut-off"]);
+  });
+
+  it("keeps one terminal message for an unsteered run", () => {
+    const ids = terminalFeedAssistantMessageIds([
+      message("prompt", "user", "turn_start"),
+      message("commentary", "assistant"),
+      message("final", "assistant"),
+    ]);
+
+    expect([...ids.terminalIds]).toEqual(["final"]);
+    expect(ids.midRunIds.size).toBe(0);
+  });
+});
+
 describe("pending user input answers", () => {
   it("preserves exact editor text, including a deliberately cleared answer", () => {
     const question = { ...singleSelectQuestion, initialAnswer: "  Proposed message\n" };

apps/mobile/src/lib/threadActivity.ts

@@ -1048,6 +1048,31 @@ export function failedFeedRunIds(
   return failed;
 }
 
+/**
+ * The assistant messages that end a stretch of output and so carry metadata:
+ * each run's last one, plus the last one before a later user message in the
+ * same run (a steer). Forking from one in `midRunIds` must cut inside its run.
+ */
+export function terminalFeedAssistantMessageIds(feed: ReadonlyArray<ThreadFeedEntry>) {
+  const lastIdBySegment = new Map<string, string>();
+  const lastIdByRun = new Map<RunId, string>();
+  const segmentByRun = new Map<RunId, number>();
+  for (const entry of feed) {
+    if (entry.type !== "message" || !entry.message.runId) continue;
+    const runId = entry.message.runId;
+    if (entry.message.role === "user") {
+      segmentByRun.set(runId, (segmentByRun.get(runId) ?? 0) + 1);
+      continue;
+    }
+    lastIdByRun.set(runId, entry.message.id);
+    lastIdBySegment.set(`${runId}:${segmentByRun.get(runId) ?? 0}`, entry.message.id);
+  }
+  const terminalIds = new Set(lastIdBySegment.values());
+  const runEndIds = new Set(lastIdByRun.values());
+  const midRunIds = new Set([...terminalIds].filter((id) => !runEndIds.has(id)));
+  return { terminalIds, midRunIds };
+}
+
 /**
  * A prompt without a run (a provider-native subagent, or a turn imported from
  * V1) folds its response like a run. `runlessWorkActive` keeps the latest

apps/server/src/mcp/toolkits/thread/tools.ts

@@ -203,7 +203,7 @@ const transferResult = Schema.Struct({ sequence: NonNegativeInt, targetThreadId:
 const ThreadForkTool = Tool.make("t3_thread_fork", {
   ...commandTool,
   description:
-    "Fork a thread from a stable run or checkpoint using the existing fork command. Omit threadId to fork this thread. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",
+    "Fork a thread from a stable run, a checkpoint, or one finished assistant response (turn_item, which leaves out the rest of its run such as a steer) using the existing fork command. Omit threadId to fork this thread. The fork inherits the source configuration. Acceptance does not mean a provider turn has completed.",
   parameters: Schema.Struct({
     threadId: Schema.optional(ThreadId),
     sourcePoint: OrchestrationV2ThreadForkSourcePoint,

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts

@@ -27,6 +27,7 @@ import {
   RunAttemptId,
   RunId,
   ThreadId,
+  TurnItemId,
 } from "@t3tools/contracts";
 import { assert, describe, it } from "@effect/vitest";
 import * as Context from "effect/Context";
@@ -1759,6 +1760,43 @@ describe("ClaudeAdapterV2 native fork", () => {
         assert.equal(forkedProviderThread.forkedFrom?.providerThreadId, sourceProviderThread.id);
         assert.equal(forkedProviderThread.forkedFrom?.providerTurnId, providerTurnId);
 
+        // A response a steer cut off is mid-turn: its assistant item carries the
+        // SDK message uuid, which forkSession takes as an inclusive cut.
+        yield* runtime.forkThread({
+          sourceProviderThread,
+          sourceProviderTurns: [],
+          providerTurnId,
+          throughTurnItem: {
+            id: TurnItemId.make("turn-item-claude-cut-off"),
+            threadId: sourceThreadId,
+            runId: RunId.make("run-claude-steered"),
+            nodeId: null,
+            providerThreadId: sourceProviderThread.id,
+            providerTurnId,
+            nativeItemRef: {
+              driver: ClaudeAdapterV2.CLAUDE_PROVIDER,
+              nativeId: "cut-off-assistant-uuid",
+              strength: "strong",
+            },
+            parentItemId: null,
+            ordinal: 2,
+            status: "completed",
+            title: null,
+            startedAt: now,
+            completedAt: now,
+            updatedAt: now,
+            type: "assistant_message",
+            messageId: MessageId.make("message-claude-cut-off"),
+            text: "cut off by a steer",
+            streaming: false,
+          },
+          targetThreadId: ThreadId.make("thread-claude-fork-steered-target"),
+        });
+        assert.deepEqual(forkCalls[1]?.options, {
+          dir: "/workspace",
+          upToMessageId: "cut-off-assistant-uuid",
+        });
+
         yield* runtime.startTurn({
           appThread: {
             createdBy: "user",

apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts

@@ -196,6 +196,7 @@ export const ClaudeProviderCapabilitiesV2 = {
     canRollbackThread: true,
     canForkThread: true,
     canForkFromTurn: true,
+    canForkFromItem: true,
     canForkFromSubagentThread: false,
     exposesNativeThreadId: true,
   },
@@ -1226,6 +1227,25 @@ const getNativeConversationHeadId = Effect.fnUntraced(function* (
 
 const resolveClaudeForkUpToMessageId = Effect.fn("ClaudeAdapterV2.resolveForkUpToMessageId")(
   function* (input: ProviderAdapter.ProviderAdapterV2ForkThreadInput) {
+    // Assistant items carry the SDK message uuid, which forkSession accepts as
+    // an inclusive cut, so a fork can end before a steer in the same turn.
+    const throughItem = input.throughTurnItem;
+    if (throughItem !== undefined) {
+      const nativeId = throughItem.nativeItemRef?.nativeId;
+      if (
+        throughItem.type !== "assistant_message" ||
+        throughItem.nativeItemRef?.driver !== CLAUDE_PROVIDER ||
+        nativeId === undefined ||
+        nativeId === null
+      ) {
+        return yield* new ProviderAdapter.ProviderAdapterForkThreadError({
+          driver: CLAUDE_PROVIDER,
+          providerThreadId: input.sourceProviderThread.id,
+          cause: `Cannot fork Claude thread at item ${throughItem.id}: it has no SDK assistant message id.`,
+        });
+      }
+      return nativeId;
+    }
     if (input.providerTurnId === undefined || input.sourceProviderTurns === undefined) {
       return undefined;
     }

apps/server/src/orchestration-v2/CommandPolicy.ts

@@ -197,6 +197,7 @@ export interface CommandPolicyV2Shape {
   readonly ensureNativeFork: (
     input: CapabilityCheckInput & {
       readonly fromSpecificTurn: boolean;
+      readonly fromSpecificItem?: boolean;
     },
   ) => Effect.Effect<void, CommandPolicyV2Error>;
   readonly decideForkExecution: (
@@ -205,6 +206,8 @@ export interface CommandPolicyV2Shape {
       readonly hasStrongNativeSource: boolean;
       readonly sourceRunStatus: OrchestrationV2Run["status"];
       readonly fromSpecificTurn: boolean;
+      /** The fork ends at a response inside the run, e.g. one a steer cut off. */
+      readonly fromSpecificItem?: boolean;
     },
   ) => Effect.Effect<ForkExecutionPolicyV2, CommandPolicyV2Error>;
   readonly ensureRollback: (
@@ -291,6 +294,11 @@ const ensureNativeFork: CommandPolicyV2Shape["ensureNativeFork"] = (input) => {
       ),
     );
   }
+  if (input.fromSpecificItem === true && input.capabilities.threads.canForkFromItem !== true) {
+    return Effect.fail(
+      unsupported(input, "fork_from_turn", "providerInstanceId cannot fork inside a turn"),
+    );
+  }
   if (input.capabilities.identity.nativeThreadIds !== "strong") {
     return Effect.fail(
       unsupported(
@@ -371,6 +379,8 @@ const decideForkExecution: CommandPolicyV2Shape["decideForkExecution"] = (input)
     input.hasStrongNativeSource &&
     input.capabilities.threads.canForkThread &&
     (!input.fromSpecificTurn || input.capabilities.threads.canForkFromTurn) &&
+    // A native fork that can only cut at turn ends would keep a steer made after the response.
+    (input.fromSpecificItem !== true || input.capabilities.threads.canForkFromItem === true) &&
     input.capabilities.identity.nativeThreadIds === "strong";
 
   if (canForkNatively) {