[Bug]: Codex fast-mode/model change kills running turn (shared session cwd ≠ thread worktree) #34119

import { assert, it } from "@effect/vitest";
import {
  ProviderDriverKind,
  ProviderInstanceId,
  ProviderSessionId,
  ThreadId,
  type OrchestrationV2ThreadProjection,
} from "@t3tools/contracts";
import { turnScopedSelectionTransition } from "@t3tools/provider-core/server/selectionTransition";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
import * as ProviderSwitch from "./ProviderSwitchService.ts";

const driver = ProviderDriverKind.make("codex");
const instanceId = ProviderInstanceId.make("codex");

const layer = ProviderSwitch.layer.pipe(
  Layer.provide(
    Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({
      get: () =>
        Effect.succeed({
          instanceId,
          driver,
          getCapabilities: () => Effect.succeed(CodexProviderCapabilitiesV2),
          planSelectionTransition: () => Effect.succeed(turnScopedSelectionTransition()),
          openSession: () => Effect.die("not used"),
        }),
      list: () => Effect.succeed([instanceId]),
      getMetadata: () =>
        Effect.succeed({
          driver,
          continuationKey: "codex:instance:codex",
          enabled: true,
          capabilities: CodexProviderCapabilitiesV2,
        }),
    }),
  ),
);

const projectionWithSessionCwd = (sessionCwd: string) =>
  ({
    thread: {
      id: ThreadId.make("thread_b"),
      modelSelection: { instanceId, model: "gpt-6.1-sol" },
      runtimeMode: "full-access",
      interactionMode: "default",
      worktreePath: "/worktrees/thread-b",
    },
    providerSessions: [
      {
        id: ProviderSessionId.make("provider-session:provider-instance:codex:shared"),
        providerInstanceId: instanceId,
        status: "ready",
        cwd: sessionCwd,
        capabilities: CodexProviderCapabilitiesV2,
        updatedAt: DateTime.makeUnsafe("2026-11-11T00:00:00.000Z"),
      },
    ],
    providerThreads: [],
  }) as unknown as OrchestrationV2ThreadProjection;

const fastModeOn = {
  instanceId,
  model: "gpt-6.1-sol",
  options: [{ id: "fastMode", value: true }],
};

it.effect.each([
  ["the thread's own worktree", "/worktrees/thread-b"],
  ["another thread's directory", "/scratch/thread-a"],
])("turning on fast mode applies next turn when the shared session cwd is %s", ([, cwd]) =>
  Effect.gen(function* () {
    const service = yield* ProviderSwitch.ProviderSwitchServiceV2;
    const plan = yield* service.plan({
      projection: projectionWithSessionCwd(cwd!),
      targetModelSelection: fastModeOn,
    });
    assert.equal(plan.transition.type, "switch_model_in_session");
    assert.deepEqual(plan.releaseProviderSessionIds, []);
  }).pipe(Effect.provide(layer)),
);