Fix provider session logic bugs: Claude Code availability, optional provider field, persisted resume cursor

cursoragent · cursoragent · commit 6d4ef60128a8 · 2026-02-27T17:29:18.000Z
- Set claudeCode available: false in PROVIDER_OPTIONS since server runtime is unconfigured
- Make provider field conditional in turn start command to avoid unnecessary session restarts
- Read resume cursor from persisted ProviderSessionDirectory instead of live adapter sessions
- Update test mocks and layer wiring to provide ProviderSessionDirectory to ProviderCommandReactor
diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -222,7 +222,7 @@ export const makeOrchestrationIntegrationHarness = (
     Layer.provide(ProviderSessionRuntimeRepositoryLive),
   );
   const providerLayer = makeProviderServiceLive().pipe(
-    Layer.provide(providerSessionDirectoryLayer),
+    Layer.provideMerge(providerSessionDirectoryLayer),
     Layer.provide(Layer.succeed(ProviderAdapterRegistry, registry)),
   );
   const checkpointStoreLayer = CheckpointStoreLive.pipe(Layer.provide(NodeServices.layer));
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -10,7 +10,7 @@ import {
   ThreadId,
   TurnId,
 } from "@t3tools/contracts";
-import { Effect, Exit, Layer, ManagedRuntime, PubSub, Scope, Stream } from "effect";
+import { Effect, Exit, Layer, ManagedRuntime, Option, PubSub, Scope, Stream } from "effect";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";
@@ -20,6 +20,7 @@ import {
   ProviderService,
   type ProviderServiceShape,
 } from "../../provider/Services/ProviderService.ts";
+import { ProviderSessionDirectory } from "../../provider/Services/ProviderSessionDirectory.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
 import { ProviderCommandReactorLive } from "./ProviderCommandReactor.ts";
@@ -141,9 +142,26 @@ describe("ProviderCommandReactor", () => {
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
       Layer.provide(SqlitePersistenceMemory),
     );
+    const sessionDirectoryMock = Layer.succeed(ProviderSessionDirectory, {
+      upsert: () => Effect.void,
+      getProvider: () => Effect.die(new Error("not implemented in test")),
+      getBinding: (sessionId: ProviderSessionId) => {
+        const session = runtimeSessions.find((s) => s.sessionId === sessionId);
+        if (!session) return Effect.succeed(Option.none());
+        return Effect.succeed(Option.some({
+          sessionId: session.sessionId,
+          provider: session.provider,
+          resumeCursor: session.resumeCursor,
+        }));
+      },
+      getThreadId: () => Effect.succeed(Option.none()),
+      remove: () => Effect.void,
+      listSessionIds: () => Effect.succeed([]),
+    });
     const layer = ProviderCommandReactorLive.pipe(
       Layer.provideMerge(orchestrationLayer),
       Layer.provideMerge(Layer.succeed(ProviderService, service)),
+      Layer.provideMerge(sessionDirectoryMock),
     );
     runtime = ManagedRuntime.make(layer);
     const engine = await runtime.runPromise(Effect.service(OrchestrationEngineService));
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -15,6 +15,7 @@ import {
 import { Cache, Cause, Duration, Effect, Layer, Option, Queue, Stream } from "effect";
 
 import { resolveThreadWorkspaceCwd } from "../../checkpointing/Utils.ts";
+import { ProviderSessionDirectory } from "../../provider/Services/ProviderSessionDirectory.ts";
 import { ProviderService } from "../../provider/Services/ProviderService.ts";
 import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";
 import {
@@ -70,6 +71,7 @@ const DEFAULT_SANDBOX_MODE: ProviderSandboxMode = "workspace-write";
 const make = Effect.gen(function* () {
   const orchestrationEngine = yield* OrchestrationEngineService;
   const providerService = yield* ProviderService;
+  const sessionDirectory = yield* ProviderSessionDirectory;
   const handledTurnStartKeys = yield* Cache.make<string, true>({
     capacity: HANDLED_TURN_START_KEY_MAX,
     timeToLive: HANDLED_TURN_START_KEY_TTL,
@@ -161,8 +163,9 @@ const make = Effect.gen(function* () {
     });
 
     const resolveResumeCursorForSession = (sessionId: ProviderSessionId) =>
-      providerService.listSessions().pipe(
-        Effect.map((sessions) => sessions.find((session) => session.sessionId === sessionId)?.resumeCursor),
+      sessionDirectory.getBinding(sessionId).pipe(
+        Effect.map((binding) => Option.getOrUndefined(binding)?.resumeCursor),
+        Effect.orElseSucceed(() => undefined),
       );
 
     const startProviderSession = (input?: {
diff --git a/apps/server/src/serverLayers.ts b/apps/server/src/serverLayers.ts
@@ -23,6 +23,7 @@ import { makeCodexAdapterLive } from "./provider/Layers/CodexAdapter";
 import { ProviderAdapterRegistryLive } from "./provider/Layers/ProviderAdapterRegistry";
 import { makeProviderServiceLive } from "./provider/Layers/ProviderService";
 import { ProviderSessionDirectoryLive } from "./provider/Layers/ProviderSessionDirectory";
+import { ProviderSessionDirectory } from "./provider/Services/ProviderSessionDirectory";
 import { ProviderService } from "./provider/Services/ProviderService";
 
 import { TerminalManagerLive } from "./terminal/Layers/Manager";
@@ -36,7 +37,7 @@ import { BunPtyAdapterLive } from "./terminal/Layers/BunPTY";
 import { NodePtyAdapterLive } from "./terminal/Layers/NodePTY";
 
 export function makeServerProviderLayer(): Layer.Layer<
-  ProviderService,
+  ProviderService | ProviderSessionDirectory,
   ProviderUnsupportedError,
   SqlClient.SqlClient | ServerConfig
 > {
@@ -55,7 +56,7 @@ export function makeServerProviderLayer(): Layer.Layer<
     );
     return makeProviderServiceLive({
       canonicalEventLogPath: path.join(providerLogsDir, "provider-canonical.ndjson"),
-    }).pipe(Layer.provide(adapterRegistryLayer), Layer.provide(providerSessionDirectoryLayer));
+    }).pipe(Layer.provide(adapterRegistryLayer), Layer.provideMerge(providerSessionDirectoryLayer));
   }).pipe(Layer.unwrap);
 }
 
diff --git a/apps/server/src/wsServer.test.ts b/apps/server/src/wsServer.test.ts
@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { Effect, Exit, Layer, PubSub, Scope, Stream } from "effect";
+import { Effect, Exit, Layer, Option, PubSub, Scope, Stream } from "effect";
 import { describe, expect, it, afterEach, vi } from "vitest";
 import { createServer } from "./wsServer";
 import WebSocket from "ws";
@@ -42,6 +42,7 @@ import { TerminalManager, type TerminalManagerShape } from "./terminal/Services/
 import { makeSqlitePersistenceLive, SqlitePersistenceMemory } from "./persistence/Layers/Sqlite";
 import { SqlClient } from "effect/unstable/sql";
 import { ProviderService, type ProviderServiceShape } from "./provider/Services/ProviderService";
+import { ProviderSessionDirectory } from "./provider/Services/ProviderSessionDirectory";
 import { Open, type OpenShape } from "./open";
 import { GitManager, type GitManagerShape } from "./git/Services/GitManager.ts";
 import type { GitCoreShape } from "./git/Services/GitCore.ts";
@@ -331,7 +332,7 @@ describe("WebSocket Server", () => {
       devUrl?: string;
       authToken?: string;
       stateDir?: string;
-      providerLayer?: Layer.Layer<ProviderService, never>;
+      providerLayer?: Layer.Layer<ProviderService | ProviderSessionDirectory, never>;
       open?: OpenShape;
       gitManager?: GitManagerShape;
       gitCore?: Pick<GitCoreShape, "listBranches" | "initRepo" | "pullCurrentBranch">;
@@ -1007,7 +1008,17 @@ describe("WebSocket Server", () => {
       stopAll: () => Effect.void,
       streamEvents: Stream.fromPubSub(runtimeEventPubSub),
     };
-    const providerLayer = Layer.succeed(ProviderService, providerService);
+    const providerLayer = Layer.mergeAll(
+      Layer.succeed(ProviderService, providerService),
+      Layer.succeed(ProviderSessionDirectory, {
+        upsert: () => Effect.void,
+        getProvider: () => Effect.die(new Error("not implemented in test")),
+        getBinding: () => Effect.succeed(Option.none()),
+        getThreadId: () => Effect.succeed(Option.none()),
+        remove: () => Effect.void,
+        listSessionIds: () => Effect.succeed([]),
+      }),
+    );
 
     server = await createTestServer({
       cwd: "/test",
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
@@ -1560,7 +1560,9 @@ export default function ChatView({ threadId }: ChatViewProps) {
           attachments: turnAttachments,
         },
         model: selectedModel || undefined,
-        provider: selectedProvider,
+        ...(selectedProviderByThread[threadIdForSend]
+          ? { provider: selectedProviderByThread[threadIdForSend] }
+          : {}),
         effort: selectedEffort || undefined,
         assistantDeliveryMode: settings.enableAssistantStreaming ? "streaming" : "buffered",
         approvalPolicy,
diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.ts
@@ -128,12 +128,12 @@ describe("deriveWorkLogEntries", () => {
 });
 
 describe("PROVIDER_OPTIONS", () => {
-  it("marks claudeCode as available", () => {
+  it("marks claudeCode as unavailable until runtime is configured", () => {
     const claude = PROVIDER_OPTIONS.find((option) => option.value === "claudeCode");
     expect(claude).toEqual({
       value: "claudeCode",
-      label: "Claude Code",
-      available: true,
+      label: "Claude Code (soon)",
+      available: false,
     });
   });
 });
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
@@ -13,7 +13,7 @@ export const PROVIDER_OPTIONS: Array<{
   available: boolean;
 }> = [
   { value: "codex", label: "Codex", available: true },
-  { value: "claudeCode", label: "Claude Code", available: true },
+  { value: "claudeCode", label: "Claude Code (soon)", available: false },
 ];
 
 export interface WorkLogEntry {
