diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
index a634e8882c6a6b09b658982ac04d7525d5908d25..07cfe01e704afb5babb4bf81860b4af4c999e494 100644
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -188,7 +188,7 @@ export interface OrchestrationIntegrationHarness {
 }
 
 interface MakeOrchestrationIntegrationHarnessOptions {
-  readonly provider?: "codex" | "claudeCode";
+  readonly provider?: "codex" | "cursor";
   readonly realCodex?: boolean;
 }
 
diff --git a/apps/server/integration/TestProviderAdapter.integration.ts b/apps/server/integration/TestProviderAdapter.integration.ts
index 25ce8773bd77ce3fd4dbb81c9dd6941a5e9ff8b1..e86b3e8491adfddadaa37504df5e8f56e2c5d3ec 100644
--- a/apps/server/integration/TestProviderAdapter.integration.ts
+++ b/apps/server/integration/TestProviderAdapter.integration.ts
@@ -35,7 +35,7 @@ export interface TestTurnResponse {
 export type FixtureProviderRuntimeEvent = {
   readonly type: string;
   readonly eventId: EventId;
-  readonly provider: "codex" | "claudeCode" | "cursor";
+  readonly provider: "codex" | "cursor";
   readonly createdAt: string;
   readonly threadId: string;
   readonly turnId?: string | undefined;
@@ -178,7 +178,7 @@ function normalizeFixtureEvent(rawEvent: Record<string, unknown>): ProviderRunti
 
 export interface TestProviderAdapterHarness {
   readonly adapter: ProviderAdapterShape<ProviderAdapterError>;
-  readonly provider: "codex" | "claudeCode";
+  readonly provider: "codex" | "cursor";
   readonly queueTurnResponse: (
     threadId: ThreadId,
     response: TestTurnResponse,
@@ -198,7 +198,7 @@ export interface TestProviderAdapterHarness {
 }
 
 interface MakeTestProviderAdapterHarnessOptions {
-  readonly provider?: "codex" | "claudeCode";
+  readonly provider?: "codex" | "cursor";
 }
 
 function nowIso(): string {
@@ -206,7 +206,7 @@ function nowIso(): string {
 }
 
 function sessionNotFound(
-  provider: "codex" | "claudeCode",
+  provider: "codex" | "cursor",
   threadId: ThreadId,
 ): ProviderAdapterSessionNotFoundError {
   return new ProviderAdapterSessionNotFoundError({
@@ -216,7 +216,7 @@ function sessionNotFound(
 }
 
 function missingSessionEffect(
-  provider: "codex" | "claudeCode",
+  provider: "codex" | "cursor",
   threadId: ThreadId,
 ): Effect.Effect<never, ProviderAdapterError> {
   return Effect.fail(sessionNotFound(provider, threadId));
diff --git a/apps/server/integration/orchestrationEngine.integration.test.ts b/apps/server/integration/orchestrationEngine.integration.test.ts
index 606087f0ac35bae6525d32f407a2ef5073183c2d..c8219b260a81eda498225587213ab1261cc3b3b8 100644
--- a/apps/server/integration/orchestrationEngine.integration.test.ts
+++ b/apps/server/integration/orchestrationEngine.integration.test.ts
@@ -32,7 +32,7 @@ const PROJECT_ID = asProjectId("project-1");
 const THREAD_ID = ThreadId.makeUnsafe("thread-1");
 const FIXTURE_TURN_ID = "fixture-turn";
 const APPROVAL_REQUEST_ID = asApprovalRequestId("req-approval-1");
-type IntegrationProvider = "codex" | "claudeCode";
+type IntegrationProvider = "codex" | "cursor";
 
 function nowIso() {
   return new Date().toISOString();
@@ -842,416 +842,3 @@ it.live(
       }),
     ),
 );
-
-it.live("starts a claudeCode session on first turn when provider is requested", () =>
-  withHarness(
-    (harness) =>
-      Effect.gen(function* () {
-        yield* seedProjectAndThread(harness);
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-start-1", "2026-02-24T10:10:00.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-start-2", "2026-02-24T10:10:00.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "Claude first turn.\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-start-3", "2026-02-24T10:10:00.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-initial",
-          messageId: "msg-user-claude-initial",
-          text: "Use Claude",
-          provider: "claudeCode",
-        });
-
-        const thread = yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) =>
-            entry.session?.providerName === "claudeCode" &&
-            entry.session.status === "ready" &&
-            entry.messages.some(
-              (message) => message.role === "assistant" && message.text === "Claude first turn.\n",
-            ),
-        );
-        assert.equal(thread.session?.providerName, "claudeCode");
-      }),
-    "claudeCode",
-  ),
-);
-
-it.live("recovers claudeCode sessions after provider stopAll using persisted resume state", () =>
-  withHarness(
-    (harness) =>
-      Effect.gen(function* () {
-        yield* seedProjectAndThread(harness);
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-recover-1", "2026-02-24T10:11:00.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-recover-2", "2026-02-24T10:11:00.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "Turn before restart.\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-recover-3", "2026-02-24T10:11:00.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-recover-1",
-          messageId: "msg-user-claude-recover-1",
-          text: "Before restart",
-          provider: "claudeCode",
-        });
-
-        yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) => entry.latestTurn?.turnId === "turn-1" && entry.session?.threadId === "thread-1",
-        );
-
-        yield* harness.providerService.stopAll();
-        yield* waitForSync(
-          () => harness.adapterHarness.listActiveSessionIds(),
-          (sessionIds) => sessionIds.length === 0,
-          "provider stopAll",
-        );
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-recover-4", "2026-02-24T10:11:01.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-recover-5", "2026-02-24T10:11:01.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "Turn after restart.\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-recover-6", "2026-02-24T10:11:01.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-recover-2",
-          messageId: "msg-user-claude-recover-2",
-          text: "After restart",
-        });
-        yield* waitForSync(
-          () => harness.adapterHarness.getStartCount(),
-          (count) => count === 2,
-          "claude provider recovery start",
-        );
-
-        const recoveredThread = yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) =>
-            entry.session?.providerName === "claudeCode" &&
-            entry.messages.some(
-              (message) => message.role === "user" && message.text === "After restart",
-            ) &&
-            !entry.activities.some((activity) => activity.kind === "provider.turn.start.failed"),
-        );
-        assert.equal(recoveredThread.session?.providerName, "claudeCode");
-        assert.equal(recoveredThread.session?.threadId, "thread-1");
-      }),
-    "claudeCode",
-  ),
-);
-
-it.live("forwards claudeCode approval responses to the provider session", () =>
-  withHarness(
-    (harness) =>
-      Effect.gen(function* () {
-        yield* seedProjectAndThread(harness);
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-approval-1", "2026-02-24T10:12:00.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "approval.requested",
-              ...runtimeBase("evt-claude-approval-2", "2026-02-24T10:12:00.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              requestId: APPROVAL_REQUEST_ID,
-              requestKind: "command",
-              detail: "Approve Claude tool call",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-approval-3", "2026-02-24T10:12:00.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-approval",
-          messageId: "msg-user-claude-approval",
-          text: "Need approval",
-          provider: "claudeCode",
-        });
-
-        const thread = yield* harness.waitForThread(THREAD_ID, (entry) =>
-          entry.activities.some((activity) => activity.kind === "approval.requested"),
-        );
-        assert.equal(thread.session?.threadId, "thread-1");
-
-        yield* harness.engine.dispatch({
-          type: "thread.approval.respond",
-          commandId: CommandId.makeUnsafe("cmd-claude-approval-respond"),
-          threadId: THREAD_ID,
-          requestId: APPROVAL_REQUEST_ID,
-          decision: "accept",
-          createdAt: nowIso(),
-        });
-
-        yield* harness.waitForPendingApproval(
-          "req-approval-1",
-          (row) => row.status === "resolved" && row.decision === "accept",
-        );
-
-        const approvalResponses = yield* waitForSync(
-          () => harness.adapterHarness.getApprovalResponses(THREAD_ID),
-          (responses) => responses.length === 1,
-          "claude provider approval response",
-        );
-        assert.equal(approvalResponses[0]?.decision, "accept");
-      }),
-    "claudeCode",
-  ),
-);
-
-it.live("forwards thread.turn.interrupt to claudeCode provider sessions", () =>
-  withHarness(
-    (harness) =>
-      Effect.gen(function* () {
-        yield* seedProjectAndThread(harness);
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-interrupt-1", "2026-02-24T10:13:00.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-interrupt-2", "2026-02-24T10:13:00.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "Long running output.\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-interrupt-3", "2026-02-24T10:13:00.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-interrupt",
-          messageId: "msg-user-claude-interrupt",
-          text: "Start long turn",
-          provider: "claudeCode",
-        });
-
-        const thread = yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) => entry.session?.threadId === "thread-1",
-        );
-        assert.equal(thread.session?.threadId, "thread-1");
-
-        yield* harness.engine.dispatch({
-          type: "thread.turn.interrupt",
-          commandId: CommandId.makeUnsafe("cmd-turn-interrupt-claude"),
-          threadId: THREAD_ID,
-          createdAt: nowIso(),
-        });
-        yield* harness.waitForDomainEvent((event) => event.type === "thread.turn-interrupt-requested");
-
-        const interruptCalls = yield* waitForSync(
-          () => harness.adapterHarness.getInterruptCalls(THREAD_ID),
-          (calls) => calls.length === 1,
-          "claude provider interrupt call",
-        );
-        assert.equal(interruptCalls.length, 1);
-      }),
-    "claudeCode",
-  ),
-);
-
-it.live("reverts claudeCode turns and rolls back provider conversation state", () =>
-  withHarness(
-    (harness) =>
-      Effect.gen(function* () {
-        yield* seedProjectAndThread(harness);
-
-        yield* harness.adapterHarness.queueTurnResponseForNextSession({
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-revert-1", "2026-02-24T10:14:00.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-revert-2", "2026-02-24T10:14:00.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "README -> v2\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-revert-3", "2026-02-24T10:14:00.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-          mutateWorkspace: ({ cwd }) =>
-            Effect.sync(() => {
-              fs.writeFileSync(path.join(cwd, "README.md"), "v2\n", "utf8");
-            }),
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-revert-1",
-          messageId: "msg-user-claude-revert-1",
-          text: "First Claude edit",
-          provider: "claudeCode",
-        });
-
-        yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) => entry.latestTurn?.turnId === "turn-1" && entry.session?.threadId === "thread-1",
-        );
-
-        yield* harness.adapterHarness.queueTurnResponse(THREAD_ID, {
-          events: [
-            {
-              type: "turn.started",
-              ...runtimeBase("evt-claude-revert-4", "2026-02-24T10:14:01.000Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-            },
-            {
-              type: "message.delta",
-              ...runtimeBase("evt-claude-revert-5", "2026-02-24T10:14:01.050Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              delta: "README -> v3\n",
-            },
-            {
-              type: "turn.completed",
-              ...runtimeBase("evt-claude-revert-6", "2026-02-24T10:14:01.100Z", "claudeCode"),
-              threadId: THREAD_ID,
-              turnId: FIXTURE_TURN_ID,
-              status: "completed",
-            },
-          ],
-          mutateWorkspace: ({ cwd }) =>
-            Effect.sync(() => {
-              fs.writeFileSync(path.join(cwd, "README.md"), "v3\n", "utf8");
-            }),
-        });
-
-        yield* startTurn({
-          harness,
-          commandId: "cmd-turn-start-claude-revert-2",
-          messageId: "msg-user-claude-revert-2",
-          text: "Second Claude edit",
-        });
-
-        yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) =>
-            entry.latestTurn?.turnId === "turn-2" &&
-            entry.checkpoints.length === 2 &&
-            entry.session?.providerName === "claudeCode",
-        );
-
-        yield* harness.engine.dispatch({
-          type: "thread.checkpoint.revert",
-          commandId: CommandId.makeUnsafe("cmd-checkpoint-revert-claude"),
-          threadId: THREAD_ID,
-          turnCount: 1,
-          createdAt: nowIso(),
-        });
-
-        const revertedThread = yield* harness.waitForThread(
-          THREAD_ID,
-          (entry) =>
-            entry.checkpoints.length === 1 && entry.checkpoints[0]?.checkpointTurnCount === 1,
-        );
-        assert.equal(revertedThread.checkpoints[0]?.checkpointTurnCount, 1);
-        assert.equal(
-          gitRefExists(harness.workspaceDir, checkpointRefForThreadTurn(THREAD_ID, 1)),
-          true,
-        );
-        assert.equal(
-          gitRefExists(harness.workspaceDir, checkpointRefForThreadTurn(THREAD_ID, 2)),
-          false,
-        );
-        assert.deepEqual(harness.adapterHarness.getRollbackCalls(THREAD_ID), [1]);
-      }),
-    "claudeCode",
-  ),
-);
diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
index 7910dbdcd2d678e9a5e2f0edd15f571854ea1a2f..3716a063099f8141c469b30478912f35c8a7b3a1 100644
--- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts
@@ -43,7 +43,7 @@ const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
 type LegacyProviderRuntimeEvent = {
   readonly type: string;
   readonly eventId: EventId;
-  readonly provider: "codex" | "claudeCode" | "cursor";
+  readonly provider: "codex" | "cursor";
   readonly createdAt: string;
   readonly threadId: ThreadId;
   readonly turnId?: string | undefined;
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
index 0b5967480ab010789974a2822125935c45856185..5bfabc2751270af551db57308b6fbc1ea8adf0d0 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -212,7 +212,6 @@ const make = Effect.gen(function* () {
     const desiredRuntimeMode = thread.runtimeMode;
     const currentProvider: ProviderKind | undefined =
       thread.session?.providerName === "codex" ||
-      thread.session?.providerName === "claudeCode" ||
       thread.session?.providerName === "cursor"
         ? thread.session.providerName
         : undefined;
diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
index 1bafe2889107124c0663fc4d573e4bab5a5c78d5..77a6578995262cf41f49fb284c28c6b8379f30cc 100644
--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts
@@ -41,7 +41,7 @@ const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
 type LegacyProviderRuntimeEvent = {
   readonly type: string;
   readonly eventId: EventId;
-  readonly provider: "codex" | "claudeCode" | "cursor";
+  readonly provider: "codex" | "cursor";
   readonly createdAt: string;
   readonly threadId: ThreadId;
   readonly turnId?: string | undefined;
diff --git a/apps/server/src/provider/Layers/CodexAdapter.test.ts b/apps/server/src/provider/Layers/CodexAdapter.test.ts
index eaba8097c718540d3c0c0d3a4ea6ffeda803a6b2..c26ccc74c68ee8219e18cecd27e888fe339bfb68 100644
--- a/apps/server/src/provider/Layers/CodexAdapter.test.ts
+++ b/apps/server/src/provider/Layers/CodexAdapter.test.ts
@@ -162,7 +162,7 @@ validationLayer("CodexAdapterLive validation", (it) => {
       const adapter = yield* CodexAdapter;
       const result = yield* adapter
         .startSession({
-          provider: "claudeCode",
+          provider: "cursor",
           threadId: asThreadId("thread-1"),
           runtimeMode: "full-access",
         })
@@ -174,7 +174,7 @@ validationLayer("CodexAdapterLive validation", (it) => {
         new ProviderAdapterValidationError({
           provider: "codex",
           operation: "startSession",
-          issue: "Expected provider 'codex' but received 'claudeCode'.",
+          issue: "Expected provider 'codex' but received 'cursor'.",
         }),
       );
       assert.equal(validationManager.startSessionImpl.mock.calls.length, 0);
diff --git a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
index b3911b14ba2bcca02c4ba3a385eb8f0c29f038bc..4f2c7f2c7e0421c95eb389a62edfc6e8aed3208e 100644
--- a/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
+++ b/apps/server/src/provider/Layers/ProviderAdapterRegistry.ts
@@ -1,7 +1,7 @@
 /**
  * ProviderAdapterRegistryLive - In-memory provider adapter lookup layer.
  *
- * Binds provider kinds (codex/claudeCode/...) to concrete adapter services.
+ * Binds provider kinds (codex/cursor/...) to concrete adapter services.
  * This layer only performs adapter lookup; it does not route session-scoped
  * calls or own provider lifecycle workflows.
  *
diff --git a/apps/server/src/provider/Layers/ProviderService.test.ts b/apps/server/src/provider/Layers/ProviderService.test.ts
index 08673c3cbf2d64f8413776d41d0c5363b7f68987..9c2d8278e3b27485ee007d2c26033516537246bb 100644
--- a/apps/server/src/provider/Layers/ProviderService.test.ts
+++ b/apps/server/src/provider/Layers/ProviderService.test.ts
@@ -51,7 +51,7 @@ const asTurnId = (value: string): TurnId => TurnId.makeUnsafe(value);
 type LegacyProviderRuntimeEvent = {
   readonly type: string;
   readonly eventId: EventId;
-  readonly provider: "codex" | "claudeCode" | "cursor";
+  readonly provider: "codex" | "cursor";
   readonly createdAt: string;
   readonly threadId: ThreadId;
   readonly turnId?: string | undefined;
diff --git a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
index a45cd87decf19a439aa394d0462e4dfddcdc03b9..e35103ea7d695164ee0ea175e7c470f4d3c99403 100644
--- a/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
+++ b/apps/server/src/provider/Layers/ProviderSessionDirectory.ts
@@ -25,7 +25,7 @@ function decodeProviderKind(
   providerName: string,
   operation: string,
 ): Effect.Effect<ProviderKind, ProviderSessionDirectoryPersistenceError> {
-  if (providerName === "codex" || providerName === "claudeCode" || providerName === "cursor") {
+  if (providerName === "codex" || providerName === "cursor") {
     return Effect.succeed(providerName);
   }
   return Effect.fail(
diff --git a/apps/web/src/appSettings.test.ts b/apps/web/src/appSettings.test.ts
index 5d5509ce102c0e9570e16574c39e040154a491a7..def5bf73239b9344167d6c4ee3f060e67663a7f2 100644
--- a/apps/web/src/appSettings.test.ts
+++ b/apps/web/src/appSettings.test.ts
@@ -16,11 +16,7 @@ describe("normalizeCustomModelSlugs", () => {
     ).toEqual(["custom/internal-model"]);
   });
 
-  it("normalizes provider-specific aliases for claude and cursor", () => {
-    expect(normalizeCustomModelSlugs(["sonnet"], "claudeCode")).toEqual([]);
-    expect(normalizeCustomModelSlugs(["claude/custom-sonnet"], "claudeCode")).toEqual([
-      "claude/custom-sonnet",
-    ]);
+  it("normalizes provider-specific aliases for cursor", () => {
     expect(normalizeCustomModelSlugs(["composer"], "cursor")).toEqual([]);
     expect(normalizeCustomModelSlugs(["cursor/custom-model"], "cursor")).toEqual([
       "cursor/custom-model",
@@ -53,9 +49,9 @@ describe("getAppModelOptions", () => {
   });
 
   it("keeps a saved custom provider model available as an exact slug option", () => {
-    const options = getAppModelOptions("claudeCode", ["claude/custom-opus"], "claude/custom-opus");
+    const options = getAppModelOptions("cursor", ["cursor/custom-model"], "cursor/custom-model");
 
-    expect(options.some((option) => option.slug === "claude/custom-opus" && option.isCustom)).toBe(
+    expect(options.some((option) => option.slug === "cursor/custom-model" && option.isCustom)).toBe(
       true,
     );
   });
@@ -85,10 +81,8 @@ describe("getSlashModelOptions", () => {
   });
 
   it("includes provider-specific custom slugs in non-codex model lists", () => {
-    const claudeOptions = getAppModelOptions("claudeCode", ["claude/custom-opus"]);
     const cursorOptions = getAppModelOptions("cursor", ["cursor/custom-model"]);
 
-    expect(claudeOptions.some((option) => option.slug === "claude/custom-opus")).toBe(true);
     expect(cursorOptions.some((option) => option.slug === "cursor/custom-model")).toBe(true);
   });
 });
diff --git a/apps/web/src/appSettings.ts b/apps/web/src/appSettings.ts
index fa09a909f8d4034591e0e965039c343c7a9e737a..1e37f1b39dc40350e69502139552481e71de4778 100644
--- a/apps/web/src/appSettings.ts
+++ b/apps/web/src/appSettings.ts
@@ -8,7 +8,6 @@ const MAX_CUSTOM_MODEL_COUNT = 32;
 export const MAX_CUSTOM_MODEL_LENGTH = 256;
 const BUILT_IN_MODEL_SLUGS_BY_PROVIDER: Record<ProviderKind, ReadonlySet<string>> = {
   codex: new Set(getModelOptions("codex").map((option) => option.slug)),
-  claudeCode: new Set(getModelOptions("claudeCode").map((option) => option.slug)),
   cursor: new Set(getModelOptions("cursor").map((option) => option.slug)),
 };
 
@@ -26,9 +25,6 @@ const AppSettingsSchema = Schema.Struct({
   customCodexModels: Schema.Array(Schema.String).pipe(
     Schema.withConstructorDefault(() => Option.some([])),
   ),
-  customClaudeModels: Schema.Array(Schema.String).pipe(
-    Schema.withConstructorDefault(() => Option.some([])),
-  ),
   customCursorModels: Schema.Array(Schema.String).pipe(
     Schema.withConstructorDefault(() => Option.some([])),
   ),
@@ -79,7 +75,6 @@ function normalizeAppSettings(settings: AppSettings): AppSettings {
   return {
     ...settings,
     customCodexModels: normalizeCustomModelSlugs(settings.customCodexModels, "codex"),
-    customClaudeModels: normalizeCustomModelSlugs(settings.customClaudeModels, "claudeCode"),
     customCursorModels: normalizeCustomModelSlugs(settings.customCursorModels, "cursor"),
   };
 }
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 0b892472c7612760531dfd6db80c2fdbe85fb7e7..695da69aadc0bb287ecb1f6c4335bd34881bde3f 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -77,6 +77,7 @@ import {
   findLatestProposedPlan,
   type PendingApproval,
   type PendingUserInput,
+  type ProviderPickerKind,
   PROVIDER_OPTIONS,
   deriveWorkLogEntries,
   hasToolActivityForTurn,
@@ -847,9 +848,8 @@ export default function ChatView({ threadId }: ChatViewProps) {
   }, [modelOptionsByProvider, selectedModelForPicker, selectedProvider]);
   const searchableModelOptions = useMemo(
     () =>
-      PROVIDER_OPTIONS.filter(
-        (option) =>
-          option.available && (lockedProvider === null || option.value === lockedProvider),
+      AVAILABLE_PROVIDER_OPTIONS.filter(
+        (option) => lockedProvider === null || option.value === lockedProvider,
       ).flatMap((option) =>
         modelOptionsByProvider[option.value].map(({ slug, name }) => ({
           provider: option.value,
@@ -5278,7 +5278,17 @@ const MessagesTimeline = memo(function MessagesTimeline({
   );
 });
 
-const AVAILABLE_PROVIDER_OPTIONS = PROVIDER_OPTIONS.filter((option) => option.available);
+function isAvailableProviderOption(
+  option: (typeof PROVIDER_OPTIONS)[number],
+): option is {
+  value: ProviderKind;
+  label: string;
+  available: true;
+} {
+  return option.available && option.value !== "claudeCode";
+}
+
+const AVAILABLE_PROVIDER_OPTIONS = PROVIDER_OPTIONS.filter(isAvailableProviderOption);
 const UNAVAILABLE_PROVIDER_OPTIONS = PROVIDER_OPTIONS.filter((option) => !option.available);
 const COMING_SOON_PROVIDER_OPTIONS = [
   { id: "opencode", label: "OpenCode", icon: OpenCodeIcon },
@@ -5287,13 +5297,11 @@ const COMING_SOON_PROVIDER_OPTIONS = [
 
 function getCustomModelOptionsByProvider(settings: {
   customCodexModels: readonly string[];
-  customClaudeModels: readonly string[];
   customCursorModels: readonly string[];
 }): Record<ProviderKind, ReadonlyArray<{ slug: string; name: string }>> {
   const cursorFamilyOptions = getCursorModelFamilyOptions();
   return {
     codex: getAppModelOptions("codex", settings.customCodexModels),
-    claudeCode: getAppModelOptions("claudeCode", settings.customClaudeModels),
     cursor: [
       ...cursorFamilyOptions,
       ...getAppModelOptions("cursor", settings.customCursorModels).filter(
@@ -5304,7 +5312,7 @@ function getCustomModelOptionsByProvider(settings: {
   };
 }
 
-const PROVIDER_ICON_BY_PROVIDER: Record<ProviderKind, Icon> = {
+const PROVIDER_ICON_BY_PROVIDER: Record<ProviderPickerKind, Icon> = {
   codex: OpenAI,
   claudeCode: ClaudeAI,
   cursor: CursorIcon,
@@ -5385,10 +5393,7 @@ const ProviderModelPicker = memo(function ProviderModelPicker(props: {
         <span className="flex min-w-0 items-center gap-2">
           <ProviderIcon
             aria-hidden="true"
-            className={cn(
-              "size-4 shrink-0",
-              props.provider === "claudeCode" ? "" : "text-muted-foreground/70",
-            )}
+            className="size-4 shrink-0 text-muted-foreground/70"
           />
           <span className="truncate">{selectedModelLabel}</span>
           <ChevronDownIcon aria-hidden="true" className="size-3 opacity-60" />
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index cec12faa6d90c75768c44bff80575cfb3006a160..4887e9bac883f846844346adcb1055c520bcfa29 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -208,7 +208,7 @@ function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
 }
 
 function normalizeProviderKind(value: unknown): ProviderKind | null {
-  return value === "codex" || value === "claudeCode" || value === "cursor" ? value : null;
+  return value === "codex" || value === "cursor" ? value : null;
 }
 
 function revokeObjectPreviewUrl(previewUrl: string): void {
diff --git a/apps/web/src/routes/_chat.settings.tsx b/apps/web/src/routes/_chat.settings.tsx
index 4193cb108fa3b2b824d4d3c921f14844924baa10..9fa15dd44800b1e14ff8b88ae5527f5342efd649 100644
--- a/apps/web/src/routes/_chat.settings.tsx
+++ b/apps/web/src/routes/_chat.settings.tsx
@@ -54,8 +54,6 @@ function getCustomModelsForProvider(
   provider: ProviderKind,
 ) {
   switch (provider) {
-    case "claudeCode":
-      return settings.customClaudeModels;
     case "cursor":
       return settings.customCursorModels;
     case "codex":
@@ -69,8 +67,6 @@ function getDefaultCustomModelsForProvider(
   provider: ProviderKind,
 ) {
   switch (provider) {
-    case "claudeCode":
-      return defaults.customClaudeModels;
     case "cursor":
       return defaults.customCursorModels;
     case "codex":
@@ -81,8 +77,6 @@ function getDefaultCustomModelsForProvider(
 
 function patchCustomModels(provider: ProviderKind, models: string[]) {
   switch (provider) {
-    case "claudeCode":
-      return { customClaudeModels: models };
     case "cursor":
       return { customCursorModels: models };
     case "codex":
@@ -101,7 +95,6 @@ function SettingsRouteView() {
     Record<ProviderKind, string>
   >({
     codex: "",
-    claudeCode: "",
     cursor: "",
   });
   const [customModelErrorByProvider, setCustomModelErrorByProvider] = useState<
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index adf0635f308b3162422de0d9d0bed4f363f362d5..ec83b7e2ebefea25fb9cb88ac0a5342757b99e48 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -10,8 +10,10 @@ import {
 
 import type { ChatMessage, ProposedPlan, SessionPhase, ThreadSession, TurnDiffSummary } from "./types";
 
+export type ProviderPickerKind = ProviderKind | "claudeCode";
+
 export const PROVIDER_OPTIONS: Array<{
-  value: ProviderKind;
+  value: ProviderPickerKind;
   label: string;
   available: boolean;
 }> = [
diff --git a/apps/web/src/store.test.ts b/apps/web/src/store.test.ts
index 1b279eea5720ee911366b74f1156a08d7d517870..90cbdc000eac2a17ed653c252692b23ffe8c2d3c 100644
--- a/apps/web/src/store.test.ts
+++ b/apps/web/src/store.test.ts
@@ -129,7 +129,7 @@ describe("store pure functions", () => {
 });
 
 describe("store read model sync", () => {
-  it("preserves claude model slugs without an active session", () => {
+  it("falls back to the codex default for unsupported provider models without an active session", () => {
     const initialState = makeState(makeThread());
     const readModel = makeReadModel(
       makeReadModelThread({
@@ -139,29 +139,7 @@ describe("store read model sync", () => {
 
     const next = syncServerReadModel(initialState, readModel);
 
-    expect(next.threads[0]?.model).toBe("claude-opus-4-6");
-  });
-
-  it("resolves claude aliases when session provider is claudeCode", () => {
-    const initialState = makeState(makeThread());
-    const readModel = makeReadModel(
-      makeReadModelThread({
-        model: "sonnet",
-        session: {
-          threadId: ThreadId.makeUnsafe("thread-1"),
-          status: "ready",
-          providerName: "claudeCode",
-          runtimeMode: "approval-required",
-          activeTurnId: null,
-          lastError: null,
-          updatedAt: "2026-02-27T00:00:00.000Z",
-        },
-      }),
-    );
-
-    const next = syncServerReadModel(initialState, readModel);
-
-    expect(next.threads[0]?.model).toBe("claude-sonnet-4-6");
+    expect(next.threads[0]?.model).toBe("gpt-5.3-codex");
   });
 
   it("resolves cursor aliases when session provider is cursor", () => {
diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
index 6fb5b30653751419b8516fa9a386630d3a59e7f4..48a6355e7818045e96e681a7503dd7e6b68f0da5 100644
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -145,19 +145,16 @@ function toLegacySessionStatus(
 }
 
 function toLegacyProvider(providerName: string | null): ProviderKind {
-  if (providerName === "codex" || providerName === "claudeCode" || providerName === "cursor") {
+  if (providerName === "codex" || providerName === "cursor") {
     return providerName;
   }
   return "codex";
 }
 
 const CODEX_MODEL_SLUGS = new Set<string>(getModelOptions("codex").map((option) => option.slug));
-const CLAUDE_MODEL_SLUGS = new Set<string>(getModelOptions("claudeCode").map((option) => option.slug));
 const CURSOR_MODEL_SLUGS = new Set<string>(getModelOptions("cursor").map((option) => option.slug));
 const CURSOR_DISTINCT_MODEL_SLUGS = new Set(
-  [...CURSOR_MODEL_SLUGS].filter(
-    (slug) => !CODEX_MODEL_SLUGS.has(slug) && !CLAUDE_MODEL_SLUGS.has(slug),
-  ),
+  [...CURSOR_MODEL_SLUGS].filter((slug) => !CODEX_MODEL_SLUGS.has(slug)),
 );
 
 function inferProviderForThreadModel(input: {
@@ -166,7 +163,6 @@ function inferProviderForThreadModel(input: {
 }): ProviderKind {
   if (
     input.sessionProviderName === "codex" ||
-    input.sessionProviderName === "claudeCode" ||
     input.sessionProviderName === "cursor"
   ) {
     return input.sessionProviderName;
@@ -175,10 +171,6 @@ function inferProviderForThreadModel(input: {
   if (normalizedCursor && CURSOR_DISTINCT_MODEL_SLUGS.has(normalizedCursor)) {
     return "cursor";
   }
-  const normalizedClaude = normalizeModelSlug(input.model, "claudeCode");
-  if (normalizedClaude && CLAUDE_MODEL_SLUGS.has(normalizedClaude)) {
-    return "claudeCode";
-  }
   const normalizedCodex = normalizeModelSlug(input.model, "codex");
   if (normalizedCodex && CODEX_MODEL_SLUGS.has(normalizedCodex)) {
     return "codex";
@@ -190,7 +182,7 @@ function inferProviderForThreadModel(input: {
   ) {
     return "cursor";
   }
-  return input.model.trim().startsWith("claude-") ? "claudeCode" : "codex";
+  return "codex";
 }
 
 function resolveWsHttpOrigin(): string {
diff --git a/packages/contracts/src/orchestration.test.ts b/packages/contracts/src/orchestration.test.ts
index 4282e1076ae4370e0d99dc7fcd0867616bf9e69e..d483f2669b9f73dc52d87ef6df877a64ef5a2871 100644
--- a/packages/contracts/src/orchestration.test.ts
+++ b/packages/contracts/src/orchestration.test.ts
@@ -128,11 +128,11 @@ it.effect("preserves explicit provider and runtime mode in thread.turn.start", (
         text: "hello",
         attachments: [],
       },
-      provider: "claudeCode",
+      provider: "cursor",
       runtimeMode: "full-access",
       createdAt: "2026-01-01T00:00:00.000Z",
     });
-    assert.strictEqual(parsed.provider, "claudeCode");
+    assert.strictEqual(parsed.provider, "cursor");
     assert.strictEqual(parsed.runtimeMode, "full-access");
     assert.strictEqual(parsed.interactionMode, DEFAULT_PROVIDER_INTERACTION_MODE);
   }),
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
index dd5996e9670be4bd380f9d0d0f4c156c40273261..e0150b18aef0d7d7397d15ac918397341b41f31a 100644
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -27,7 +27,7 @@ export const ORCHESTRATION_WS_CHANNELS = {
   domainEvent: "orchestration.domainEvent",
 } as const;
 
-export const ProviderKind = Schema.Literals(["codex", "claudeCode", "cursor"]);
+export const ProviderKind = Schema.Literals(["codex", "cursor"]);
 export type ProviderKind = typeof ProviderKind.Type;
 export const DEFAULT_PROVIDER_KIND: ProviderKind = "codex";
 export const RuntimeMode = Schema.Literals(["approval-required", "full-access"]);
diff --git a/packages/contracts/src/providerRuntime.test.ts b/packages/contracts/src/providerRuntime.test.ts
index 7f578c276eacf7392e4d0718c3e055c93e775d1f..8dad509aeef6b9483bb94d4524e292776230291c 100644
--- a/packages/contracts/src/providerRuntime.test.ts
+++ b/packages/contracts/src/providerRuntime.test.ts
@@ -10,7 +10,7 @@ describe("ProviderRuntimeEvent", () => {
     const parsed = decodeRuntimeEvent({
       type: "turn.plan.updated",
       eventId: "event-1",
-      provider: "claudeCode",
+      provider: "codex",
       sessionId: "runtime-session-1",
       createdAt: "2026-02-28T00:00:00.000Z",
       threadId: "thread-1",
@@ -56,7 +56,7 @@ describe("ProviderRuntimeEvent", () => {
     const parsed = decodeRuntimeEvent({
       type: "user-input.requested",
       eventId: "event-2",
-      provider: "claudeCode",
+      provider: "codex",
       sessionId: "runtime-session-2",
       createdAt: "2026-02-28T00:00:01.000Z",
       threadId: "thread-2",
@@ -94,7 +94,7 @@ describe("ProviderRuntimeEvent", () => {
     const parsed = decodeRuntimeEvent({
       type: "user-input.resolved",
       eventId: "event-3",
-      provider: "claudeCode",
+      provider: "codex",
       sessionId: "runtime-session-2",
       createdAt: "2026-02-28T00:00:02.000Z",
       threadId: "thread-2",
diff --git a/packages/contracts/src/providerRuntime.ts b/packages/contracts/src/providerRuntime.ts
index 66bd61fba9ec9d240858d536df4142bc186a8f04..6eefebfe39a0ba01325a12d2641580f8eb95f2ee 100644
--- a/packages/contracts/src/providerRuntime.ts
+++ b/packages/contracts/src/providerRuntime.ts
@@ -19,8 +19,6 @@ const RuntimeEventRawSource = Schema.Literals([
   "codex.app-server.notification",
   "codex.app-server.request",
   "codex.eventmsg",
-  "claude.sdk.message",
-  "claude.sdk.permission",
   "codex.sdk.thread-event",
   "cursor.acp.notification",
   "cursor.acp.request",
diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index 7e85d16a16b15cc2c5822619216b5d5c970a0639..5528ed3d58ddae1f6518c5f1d8e6ceff33fe2971 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -84,7 +84,6 @@ describe("resolveModelSlug", () => {
   it("keeps codex defaults for backward compatibility", () => {
     expect(getDefaultModel()).toBe(DEFAULT_MODEL);
     expect(getModelOptions()).toEqual(MODEL_OPTIONS);
-    expect(getModelOptions("claudeCode")).toEqual([]);
     expect(getModelOptions("cursor")).toEqual(MODEL_OPTIONS_BY_PROVIDER.cursor);
     expect(getCursorModelFamilyOptions()).toEqual(CURSOR_MODEL_FAMILY_OPTIONS);
   });