feat(chat): threads show when you switch models or effort

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

@@ -15,7 +15,11 @@ import {
   enrichedSkillReference,
 } from "../../lib/enrichedLinkPresentation";
 import { ThreadContextDivider } from "./thread-context-divider";
-import { ThreadHandoffDivider, ThreadHandoffRow } from "./thread-handoff-row";
+import {
+  ThreadHandoffDivider,
+  ThreadHandoffRow,
+  ThreadModelSwitchDivider,
+} from "./thread-handoff-row";
 import { GuestBubbleTint, GuestMessageName } from "./guestMessageStyle";
 import { ThreadGuestPendingMessage, useThreadGuestShare } from "./ThreadGuestShareBar";
 import { LinkRequestCard } from "./LinkRequestCard";
@@ -3590,6 +3594,16 @@ export const ThreadFeed = memo(function ThreadFeed({
         workspaceRoot={props.workspaceRoot}
       >
         <ThreadMediaVisibility>
+          {info.item.type === "message" &&
+          !isCompactionCommandFeedEntry(info.item) &&
+          info.item.message.projectedItem?.item.type === "user_message" &&
+          info.item.message.projectedItem.item.modelSwitch ? (
+            <ThreadModelSwitchDivider
+              environmentId={props.environmentId}
+              modelSwitch={info.item.message.projectedItem.item.modelSwitch}
+              iconColor={iconSubtleColor}
+            />
+          ) : null}
           {renderFeedEntry(info, {
             userMessageGrouping: info.item.userMessageGrouping,
             environmentId: props.environmentId,

apps/mobile/src/features/threads/thread-context-divider.tsx

@@ -6,7 +6,7 @@ import { ShimmeringWorkContent } from "./thread-work-log";
 
 export function ThreadContextDivider(props: {
   label: string;
-  icon: AppSymbolName;
+  icon?: AppSymbolName;
   iconColor: ColorValue;
   active?: boolean;
   failed?: boolean;
@@ -16,7 +16,9 @@ export function ThreadContextDivider(props: {
     <View className="mb-3 flex-row items-center gap-3 px-1 py-1">
       <View className="h-px min-w-2 flex-1 bg-separator" />
       <View className="shrink flex-row flex-wrap items-center justify-center gap-1.5">
-        <SymbolView name={props.icon} size={12} tintColor={props.iconColor} type="monochrome" />
+        {props.icon ? (
+          <SymbolView name={props.icon} size={12} tintColor={props.iconColor} type="monochrome" />
+        ) : null}
         {props.active ? (
           <ShimmeringWorkContent
             className="flex-none"

apps/mobile/src/features/threads/thread-handoff-row.tsx

@@ -1,7 +1,11 @@
 import * as Dialog from "../../components/ui/Dialog";
 import { useAtomValue } from "@effect/atom-react";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
-import { resolveHandoffEndpoints, type HandoffEndpoints } from "@t3tools/client-runtime/handoff";
+import {
+  resolveHandoffEndpoints,
+  resolveModelSwitchChange,
+  type HandoffEndpoints,
+} from "@t3tools/client-runtime/handoff";
 import { resolveModelShortName } from "@t3tools/client-runtime/provider-clients";
 import {
   normalizeProviderAccentColor,
@@ -10,6 +14,8 @@ import {
 } from "@t3tools/client-runtime/state/provider-instance-display";
 import type {
   EnvironmentId,
+  ModelSelection,
+  OrchestrationV2ModelSwitch,
   OrchestrationV2ProjectedTurnItem,
   ProviderInstanceId,
   ServerProvider,
@@ -45,6 +51,33 @@ function handoffEndpointsAtom(
   });
 }
 
+/** A same-harness model or effort change. Shows only what changed. */
+export function ThreadModelSwitchDivider(props: {
+  environmentId: EnvironmentId;
+  modelSwitch: OrchestrationV2ModelSwitch;
+  iconColor: ColorValue;
+}) {
+  const providers = useAtomValue(serverEnvironment.providersValueAtom(props.environmentId)) ?? [];
+  const change = resolveModelSwitchChange(props.modelSwitch, providers);
+  if (change === null) return null;
+  const describe = (selection: ModelSelection, effort: string | undefined) => {
+    const provider = providers.find((candidate) => candidate.instanceId === selection.instanceId);
+    const model = provider?.models.find((candidate) => candidate.slug === selection.model);
+    const modelName =
+      (model ? resolveModelShortName(model, provider?.driver) : undefined) ??
+      model?.name ??
+      selection.model;
+    return [change.modelChanged ? modelName : null, effort].filter(Boolean).join(" ");
+  };
+  const { from, to } = props.modelSwitch;
+  return (
+    <ThreadContextDivider
+      label={`${describe(from, change.effort?.from)} → ${describe(to, change.effort?.to)}`}
+      iconColor={props.iconColor}
+    />
+  );
+}
+
 export function ThreadHandoffRow(props: {
   environmentId: EnvironmentId;
   projectedItem: OrchestrationV2ProjectedTurnItem;

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

@@ -269,7 +269,7 @@ vi.mock("./openExternalUrl", () => ({}));
 vi.mock("./attachmentDownload", () => ({}));
 vi.mock("./uuid", () => ({}));
 vi.mock("../features/threads/thread-context-divider", () => ({}));
-vi.mock("../features/threads/thread-handoff-row", () => ({}));
+vi.mock("../features/threads/thread-handoff-row", () => ({ ThreadModelSwitchDivider: () => null }));
 vi.mock("../features/threads/ThreadGuestShareBar", () => ({ useThreadGuestShare: () => null }));
 vi.mock("../features/threads/SecretRequestCard", () => ({}));
 vi.mock("../features/threads/LinkRequestCard", () => ({ LinkRequestCard: () => null }));

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

@@ -48,6 +48,7 @@ import {
   type OrchestrationV2ProviderThread,
   type OrchestrationV2ProviderTurn,
   type OrchestrationV2RemoteTaskChild,
+  type OrchestrationV2ModelSwitch,
   type OrchestrationV2Run,
   type OrchestrationV2RunAttempt,
   type OrchestrationV2ThreadShell,
@@ -75,6 +76,7 @@ import {
   managedRuntimeModeCeilingMessage,
 } from "@t3tools/contracts";
 import { modelSelectionsEqual } from "@t3tools/shared/model";
+import { modelSwitchSince } from "./modelSwitch.ts";
 import { recordThreadOpen } from "@t3tools/shared/paletteSearch";
 import {
   backgroundWorkHoldsCompletion,
@@ -2055,6 +2057,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         startedAt: now,
         completedAt: now,
         updatedAt: now,
+        ...(activeHandoff === null ? modelSwitchSince(projection, queuedRun.modelSelection) : {}),
       };
       const handoffTurnItem: OrchestrationV2TurnItem | null =
         activeHandoff === null
@@ -4796,6 +4799,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         readonly providerTurnId: typeof providerTurn.id | null;
         readonly providerThreadId: OrchestrationV2ProviderThread["id"];
         readonly providerInstanceId: ProviderInstanceId;
+        readonly modelSwitch?: OrchestrationV2ModelSwitch | undefined;
       }) {
         const message: OrchestrationV2ConversationMessage = {
           createdBy: input.createdBy,
@@ -4851,6 +4855,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
           text: input.text,
           attachments: input.attachments,
           ...(input.context ? { context: input.context } : {}),
+          ...(messageInput.modelSwitch === undefined
+            ? {}
+            : { modelSwitch: messageInput.modelSwitch }),
         };
         yield* emitEvent({
           type: "message.updated",
@@ -5311,6 +5318,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       providerTurnId: null,
       providerThreadId: restartProviderThread.id,
       providerInstanceId: input.modelSelection.instanceId,
+      // Measured on the pre-restart projection, so the rewritten run is not its own baseline.
+      ...(restartHandoff === null ? modelSwitchSince(input.projection, input.modelSelection) : {}),
     });
     const interruptedAttemptId = targetRun.activeAttemptId;
     if (interruptedAttemptId === null) {
@@ -6424,6 +6433,7 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         text: dispatchText,
         ...(command.context ? { context: command.context } : {}),
         attachments: command.attachments,
+        ...(run.contextHandoffId === null ? modelSwitchSince(projection, modelSelection) : {}),
       };
       const preparationTurnItem: OrchestrationV2TurnItem | null =
         dispatchMode.type === "defer_start"
@@ -7175,6 +7185,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
       text: dispatchText,
       ...(command.context ? { context: command.context } : {}),
       attachments: command.attachments,
+      ...(run.contextHandoffId === null
+        ? modelSwitchSince(projection, modelSelection, sourceRun?.modelSelection)
+        : {}),
     };
     const activeHandoff = portableForkHandoff ?? mergeBackHandoff ?? providerSwitchHandoff;
     const handoffSourceRuns =
@@ -9349,7 +9362,8 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
         "runtimeRequests",
         "subagents",
       ],
-      { turnItemTypes: [], messageRoles: ["user"] },
+      // User messages measure a restart's model switch.
+      { turnItemTypes: ["user_message"], messageRoles: ["user"] },
     );
     if (projection.thread.archivedAt !== null || projection.thread.deletedAt !== null) {
       return yield* new OrchestratorDispatchError({

apps/server/src/orchestration-v2/SelectionRestart.integration.test.ts

@@ -5,6 +5,7 @@ import {
   MessageId,
   type ModelSelection,
   type OrchestrationV2ProviderCapabilities,
+  type OrchestrationV2ThreadProjection,
   type OrchestrationV2ProviderSession,
   type OrchestrationV2ProviderThread,
   ProjectId,
@@ -47,6 +48,10 @@ const seedSelection = {
   instanceId: providerInstanceId,
   model: "seed-model",
 } satisfies ModelSelection;
+const modelSwitches = (projection: OrchestrationV2ThreadProjection) =>
+  projection.turnItems.flatMap((item) =>
+    item.type === "user_message" && item.modelSwitch !== undefined ? [item.modelSwitch] : [],
+  );
 const pooledCapabilities: OrchestrationV2ProviderCapabilities = CodexProviderCapabilitiesV2;
 const exclusiveCapabilities: OrchestrationV2ProviderCapabilities = {
   ...CodexProviderCapabilitiesV2,
@@ -407,6 +412,9 @@ it.live("retries a failed selection restart session open before completing", ()
         "selection restart supersede must not project hard-Stop interrupt items",
       );
       assert.equal(projection.runs.at(-1)?.modelSelection.model, replacementSelection.model);
+      assert.deepEqual(modelSwitches(projection), [
+        { from: initialSelection, to: replacementSelection },
+      ]);
       assert.equal(projection.runs.at(-1)?.status, "completed");
       assert.isTrue(captured.failedReplacementOpen);
       assert.equal(captured.closedSessionCount, 0);
@@ -690,6 +698,9 @@ it.live(
         const { projection, captured } = result;
         assert.lengthOf(projection.runs, 2);
         assert.equal(projection.runs[1]?.modelSelection.model, replacementSelection.model);
+        assert.deepEqual(modelSwitches(projection), [
+          { from: seedSelection, to: replacementSelection },
+        ]);
         assert.deepEqual(result.detachedSessionIds, [result.liveSessionId]);
         assert.equal(captured.closedSessionCount, 1);
         assert.deepEqual(

apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts

@@ -1175,6 +1175,55 @@ it.effect("steers a promoted queued message with the selection it was queued wit
   ),
 );
 
+it.effect("marks the model switch on a promoted message that restarts the turn", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const { started, layer, startFirstTurn } = yield* nextTurnSelectionHarness(
+        "promote-restart-switch",
+        true,
+        false,
+      );
+      const otherSelection = { ...runSelection, model: "other-model" };
+      yield* Effect.gen(function* () {
+        const orchestrator = yield* Orchestrator.OrchestratorV2;
+        const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;
+        const threadId = yield* startFirstTurn;
+        yield* orchestrator.dispatch({
+          type: "message.dispatch",
+          commandId: CommandId.make("queued"),
+          threadId,
+          messageId: MessageId.make("message:queued"),
+          text: "queued",
+          attachments: [],
+          modelSelection: otherSelection,
+          dispatchMode: { type: "queue_after_active" },
+          createdBy: "user",
+          creationSource: "web",
+        });
+        const queuedRun = (yield* orchestrator.getThreadProjection(threadId)).runs.find(
+          (run) => run.status === "queued",
+        )!;
+        yield* orchestrator.dispatch({
+          type: "queued-message.promote-to-steer",
+          commandId: CommandId.make("promote"),
+          threadId,
+          queuedRunId: queuedRun.id,
+          targetRunId: started[0]!.runId,
+        });
+        yield* worker.drain();
+
+        const promoted = (yield* orchestrator.getThreadProjection(threadId)).turnItems.find(
+          (item) => item.type === "user_message" && item.messageId === "message:queued",
+        );
+        assert.deepEqual(promoted?.type === "user_message" ? promoted.modelSwitch : undefined, {
+          from: runSelection,
+          to: otherSelection,
+        });
+      }).pipe(Effect.provide(layer));
+    }),
+  ),
+);
+
 it.effect("keeps a queued message queued when promoted into a run that Stop reached", () =>
   Effect.scoped(
     Effect.gen(function* () {

apps/server/src/orchestration-v2/modelSwitch.test.ts

@@ -0,0 +1,107 @@
+import {
+  ContextHandoffId,
+  MessageId,
+  ProviderInstanceId,
+  type OrchestrationV2ThreadProjection,
+} from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import { modelSwitchSince } from "./modelSwitch.ts";
+
+const instanceId = ProviderInstanceId.make("codex");
+const selection = (model: string) => ({ instanceId, model });
+const run = (
+  message: string,
+  ordinal: number,
+  model: string,
+  status: OrchestrationV2ThreadProjection["runs"][number]["status"] = "completed",
+) =>
+  ({
+    ordinal,
+    status,
+    completedAt: null,
+    contextHandoffId: null,
+    userMessageId: MessageId.make(message),
+    modelSelection: selection(model),
+  }) as OrchestrationV2ThreadProjection["runs"][number];
+const shown = (...messages: ReadonlyArray<string>) =>
+  messages.map((message) => ({
+    type: "user_message",
+    messageId: MessageId.make(message),
+    inputIntent: "turn_start",
+    status: "completed",
+    text: message,
+    attachments: [],
+  })) as unknown as OrchestrationV2ThreadProjection["turnItems"];
+
+describe("modelSwitchSince", () => {
+  it("measures from the latest run whose message is in the timeline", () => {
+    // B failed before it started; its message shows "a -> b", so the next one must show "b -> a".
+    expect(
+      modelSwitchSince(
+        {
+          runs: [
+            run("first", 1, "a"),
+            run("failed", 2, "b", "failed"),
+            run("queued", 3, "c", "queued"),
+            run("undone", 4, "d", "rolled_back"),
+          ],
+          turnItems: shown("first", "failed", "queued", "undone"),
+        },
+        selection("a"),
+      ),
+    ).toEqual({ modelSwitch: { from: selection("b"), to: selection("a") } });
+  });
+
+  it("skips messages clients hide", () => {
+    const [first, pending, compact, answer] = shown(
+      "first",
+      "pending",
+      "/compact",
+      "async-answer:question",
+    );
+    expect(
+      modelSwitchSince(
+        {
+          runs: [
+            run("first", 1, "a"),
+            run("pending", 2, "b", "cancelled"),
+            run("/compact", 3, "c"),
+            run("async-answer:question", 4, "d"),
+          ],
+          turnItems: [
+            first!,
+            { ...pending!, inputIntent: "queued_turn", status: "pending" },
+            compact!,
+            answer!,
+          ] as OrchestrationV2ThreadProjection["turnItems"],
+        },
+        selection("c"),
+      ),
+    ).toEqual({ modelSwitch: { from: selection("a"), to: selection("c") } });
+  });
+
+  it("counts a wake whose handoff row shows the swap", () => {
+    const wake = {
+      ...run("wake", 2, "other"),
+      contextHandoffId: ContextHandoffId.make("handoff"),
+    };
+    expect(
+      modelSwitchSince(
+        { runs: [run("first", 1, "a"), wake], turnItems: shown("first") },
+        selection("other"),
+      ),
+    ).toEqual({});
+  });
+
+  it("records nothing for a first run or an unchanged selection", () => {
+    expect(modelSwitchSince({ runs: [], turnItems: [] }, selection("a"))).toEqual({});
+    // A fork's first message compares with the run it forked from.
+    expect(modelSwitchSince({ runs: [], turnItems: [] }, selection("a"), selection("b"))).toEqual({
+      modelSwitch: { from: selection("b"), to: selection("a") },
+    });
+    expect(
+      modelSwitchSince({ runs: [run("first", 1, "a")], turnItems: shown("first") }, selection("a")),
+    ).toEqual({});
+  });
+});