packages/contracts/src/model.test.ts (1)

61-65: Consider relocating backward-compatibility tests to a separate describe block.

These tests verify getDefaultModel and getModelOptions, but are nested under the resolveModelSlug describe block. Consider moving them to a dedicated describe("backward compatibility", ...) or describe("getModelOptions and getDefaultModel", ...) for better organization.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/contracts/src/model.test.ts` around lines 61 - 65, The three
assertions testing getDefaultModel and getModelOptions are misplaced inside the
resolveModelSlug describe block; extract them into a new describe block (e.g.,
describe("backward compatibility") or describe("getModelOptions and
getDefaultModel")) and place the it("keeps codex defaults for backward
compatibility", ...) test there so it’s grouped logically; ensure the test name
and assertions remain unchanged and that any shared setup/teardown used by
resolveModelSlug is still available or duplicated if needed.

packages/contracts/src/model.ts (1)

66-80: Note potential type unsoundness in normalizeModelSlug.

Line 79 casts any non-aliased trimmed string to ModelSlug, which could return an invalid slug string. While resolveModelSlug subsequently validates against MODEL_SLUG_SET_BY_PROVIDER, direct callers of normalizeModelSlug receive an unchecked ModelSlug.

If this is intentional (normalize = alias expansion only, resolve = validation), consider a brief doc comment clarifying that callers should use resolveModelSlug for validated slugs.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/contracts/src/model.ts` around lines 66 - 80, normalizeModelSlug
currently expands aliases via MODEL_SLUG_ALIASES_BY_PROVIDER but casts any
non-aliased trimmed string to ModelSlug without validating against
MODEL_SLUG_SET_BY_PROVIDER; update normalizeModelSlug's function-level doc
comment to state it only performs alias expansion (and may return an unvalidated
ModelSlug) and explicitly instruct callers to use resolveModelSlug when a
validated slug is required, referencing normalizeModelSlug, resolveModelSlug,
MODEL_SLUG_ALIASES_BY_PROVIDER and MODEL_SLUG_SET_BY_PROVIDER so future readers
understand the validation contract.

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

apps/server/src/orchestration/decider.projectScripts.test.ts (1)

153-155: Align provider/model in this test to provider-aware contracts.

Line 153 and Line 178 correctly add provider: "claudeCode", but Line 154/Line 179 still assert model: "gpt-5". That pairing can make this test semantically inconsistent with provider-aware model resolution. Prefer deriving the model from contracts for claudeCode (or use an explicit Claude slug) so the test remains stable as validation tightens.

Suggested patch

-import { CommandId, EventId, MessageId, ProjectId, ThreadId } from "@t3tools/contracts";
+import { CommandId, EventId, MessageId, ProjectId, ThreadId, getDefaultModel } from "@t3tools/contracts";
@@
 describe("decider project scripts", () => {
+  const claudeModel = getDefaultModel("claudeCode");
@@
-          model: "gpt-5",
+          model: claudeModel,
@@
-      model: "gpt-5",
+      model: claudeModel,

Also applies to: 178-180

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/decider.projectScripts.test.ts` around lines
153 - 155, The test in decider.projectScripts.test.ts hardcodes model: "gpt-5"
while specifying provider: "claudeCode", making the assertion
provider-inconsistent; update the assertions that set model (the occurrences
currently using model: "gpt-5") to instead derive the expected model from the
provider-aware contract/resolver used by the code under test (or replace with an
explicit Claude model slug consistent with your provider mapping) so the test
asserts the provider-correct model for provider: "claudeCode".

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts (1)

161-164: Consider hoisting resolveResumeCursorForSession outside the closure.

This function is recreated on every ensureSessionForThread call. Since it only depends on providerService (already in scope), moving it outside would avoid unnecessary function allocations.

♻️ Suggested refactor

+const resolveResumeCursorForSession = (
+  providerService: typeof ProviderService.Service,
+  sessionId: ProviderSessionId
+) =>
+  providerService.listSessions().pipe(
+    Effect.map((sessions) => sessions.find((session) => session.sessionId === sessionId)?.resumeCursor),
+  );
+
 const ensureSessionForThread = Effect.fnUntraced(function* (
   threadId: ThreadId,
   createdAt: string,
   options?: { ... },
 ) {
   // ... existing code ...
-  const resolveResumeCursorForSession = (sessionId: ProviderSessionId) =>
-    providerService.listSessions().pipe(
-      Effect.map((sessions) => sessions.find((session) => session.sessionId === sessionId)?.resumeCursor),
-    );
   // ...
-  const resumeCursor = yield* resolveResumeCursorForSession(existingSessionId);
+  const resumeCursor = yield* resolveResumeCursorForSession(providerService, existingSessionId);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/Layers/ProviderCommandReactor.ts` around lines
161 - 164, Hoist the resolveResumeCursorForSession function out of the
ensureSessionForThread closure so it isn't recreated on every call: move the
declaration to module scope (keeping its signature
resolveResumeCursorForSession(sessionId: ProviderSessionId)) and keep using
providerService from the outer scope, then replace the inline arrow in
ensureSessionForThread with a reference to the hoisted
resolveResumeCursorForSession; ensure imports/types (ProviderSessionId) remain
available and tests/types compile.

packages/contracts/src/provider.ts (1)

58-62: Constrain permissionMode to known values using Schema.Literals.

Claude Code supports a fixed set of permission modes: "default", "acceptEdits", "plan", and "bypassPermissions". Use Schema.Literals instead of TrimmedNonEmptyStringSchema for better type safety and validation, consistent with the pattern already used elsewhere in the codebase.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/contracts/src/provider.ts` around lines 58 - 62, The permissionMode
field in ClaudeCodeProviderStartOptions is currently using
TrimmedNonEmptyStringSchema; replace it with an optional Schema.Literals of the
allowed values to enforce the fixed set. Update ClaudeCodeProviderStartOptions
so permissionMode uses
Schema.optional(Schema.Literals("default","acceptEdits","plan","bypassPermissions")),
keeping the other fields unchanged and ensuring any necessary Schema/Literals
import is present.

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts (1)

125-125: Return a snapshot from listSessions to avoid shared mutable state leakage.

Returning the backing array directly can let callers mutate harness state implicitly.

Suggested change

-      listSessions: () => Effect.succeed(runtimeSessions),
+      listSessions: () => Effect.succeed([...runtimeSessions]),

Based on learnings: For integration tests, prefer deterministic inputs and explicit state checks.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts` at line
125, The test helper currently returns the backing array directly from
listSessions, allowing callers to mutate runtimeSessions; change listSessions
(the implementation returning Effect.succeed(runtimeSessions)) to return a
snapshot copy (e.g., a shallow copy via slice/Array.from/spread) so callers get
an immutable snapshot and the harness state cannot be mutated implicitly.

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

.plans/17-claude-code.md (1)

75-82: Add a brief migration-note item for contract consumers.

Since removed top-level provider fields are a breaking payload change, add an explicit migration note/checklist bullet here (even if compatibility is preserved for Codex defaults).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.plans/17-claude-code.md around lines 75 - 82, Add an explicit
migration-note bullet under the "### 1.4 Contract tests (completed)" section
that warns contract consumers about the breaking change of removed top-level
provider fields; mention that this affects payload shape validated by
packages/contracts/src/*.test.ts, list a short checklist such as: update
consumers to move provider info into the new nested location, verify
provider-aware model resolution, and run the updated contract tests, and
indicate any Codex-default compatibility caveats.

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Exported constant DEFAULT_PROVIDER_KIND is never used
  • Removed the unused DEFAULT_PROVIDER_KIND constant since it was dead code never imported or referenced anywhere in the codebase.

Or push these changes by commenting:

@cursor push 1ef62e98e4

diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
--- a/packages/contracts/src/orchestration.ts
+++ b/packages/contracts/src/orchestration.ts
@@ -31,7 +31,6 @@
 
 export const ProviderKind = Schema.Literals(["codex", "claudeCode"]);
 export type ProviderKind = typeof ProviderKind.Type;
-export const DEFAULT_PROVIDER_KIND: ProviderKind = "codex";
 export const ProviderApprovalPolicy = Schema.Literals([
   "untrusted",
   "on-failure",

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts (3)

45-50: Use a contract-derived provider type instead of hardcoded unions.

Line 49 and Line 225 duplicate provider literals ("codex" | "claudeCode"). Derive this from the contract type to avoid drift when providers expand.

Proposed refactor

 import type { ProviderRuntimeEvent, ProviderSession } from "@t3tools/contracts";
+type HarnessProviderName = ProviderSession["provider"];
 ...
 function createProviderServiceHarness(
   cwd: string,
   hasSession = true,
   sessionCwd = cwd,
-  providerName: "codex" | "claudeCode" = "codex",
+  providerName: HarnessProviderName = "codex",
 ) {
 ...
   async function createHarness(options?: {
     readonly hasSession?: boolean;
     readonly seedFilesystemCheckpoints?: boolean;
     readonly projectWorkspaceRoot?: string;
     readonly threadWorktreePath?: string | null;
     readonly providerSessionCwd?: string;
-    readonly providerName?: "codex" | "claudeCode";
+    readonly providerName?: HarnessProviderName;
   }) {

As per coding guidelines: apps/**/*.ts: Use Zod schemas and TypeScript contracts from packages/contracts for provider events, WebSocket protocol, and model/session types.

Also applies to: 225-233

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/Layers/CheckpointReactor.test.ts` around lines
45 - 50, The providerName parameter in createProviderServiceHarness (and the
duplicate literal type elsewhere) uses a hardcoded union ("codex" |
"claudeCode"); replace that with the canonical provider type exported from the
contracts package (import the provider enum/type/Zod-derived Type from
packages/contracts and use it for providerName and the other occurrence) so the
test derives allowed providers from the shared contract instead of duplicating
literals; update the function signature and any dependent variables to use that
imported contract type.

---

788-858: Add read-model and git-state assertions to the claudeCode revert test.

This test currently asserts rollback invocation only. It should also assert final thread/checkpoint/git state like the codex revert test to verify behavior, not just call intent.

Suggested parity assertions

     await waitForEvent(harness.engine, (event) => event.type === "thread.reverted");
+    const thread = await waitForThread(harness.engine, (entry) => entry.checkpoints.length === 1);
     expect(harness.provider.rollbackConversation).toHaveBeenCalledTimes(1);
     expect(harness.provider.rollbackConversation).toHaveBeenCalledWith({
       sessionId: asSessionId("sess-1"),
       numTurns: 1,
     });
+    expect(thread.latestTurnId).toBe("turn-claude-1");
+    expect(thread.checkpoints[0]?.checkpointTurnCount).toBe(1);
+    expect(fs.readFileSync(path.join(harness.cwd, "README.md"), "utf8")).toBe("v2\n");
+    expect(
+      gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 2)),
+    ).toBe(false);

Based on learnings: For integration tests, prefer deterministic inputs and explicit state checks, and assert on final state and side effects.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/Layers/CheckpointReactor.test.ts` around lines
788 - 858, The claudeCode revert test only checks that
harness.provider.rollbackConversation was called; update it to also assert the
final read-model, checkpoint and git-state like the codex revert test does:
after waitForEvent(harness.engine, (event) => event.type === "thread.reverted"),
fetch the thread and checkpoint state from the engine/read-model (using the same
read-model accessors used in the codex test) and assert the thread's turn
count/status and that the checkpoint for
checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 1) was
removed/updated; also assert repository/git-state changes (e.g., files/commit
state) to match expected post-revert state and keep the existing
expect(harness.provider.rollbackConversation).toHaveBeenCalledWith(...)
assertion. Ensure you reference createHarness, harness.engine.dispatch,
checkpointRefForThreadTurn, and harness.provider.rollbackConversation when
locating where to add these checks.

---

391-455: Strengthen the claudeCode checkpoint test with full end-state assertions.

This test currently proves event flow, but it only minimally checks checkpoint persistence. Mirror codex assertions (baseline ref/content + completion ref/content) so provider parity regressions are caught.

Suggested assertion additions

     expect(thread.checkpoints[0]?.checkpointTurnCount).toBe(1);
     expect(
+      gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 0)),
+    ).toBe(true);
+    expect(
       gitRefExists(harness.cwd, checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 1)),
     ).toBe(true);
+    expect(
+      gitShowFileAtRef(
+        harness.cwd,
+        checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 0),
+        "README.md",
+      ),
+    ).toBe("v1\n");
+    expect(
+      gitShowFileAtRef(
+        harness.cwd,
+        checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 1),
+        "README.md",
+      ),
+    ).toBe("v2\n");

Based on learnings: For integration tests, prefer deterministic inputs and explicit state checks, and assert on final state and side effects.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/orchestration/Layers/CheckpointReactor.test.ts` around lines
391 - 455, The test "captures pre-turn and completion checkpoints for claudeCode
runtime events" currently only checks checkpoint existence/count; update it to
assert the full end-state like the codex test by verifying both the baseline
(pre-turn) and completion checkpoint refs and their contents: use
checkpointRefForThreadTurn(ThreadId.makeUnsafe("thread-1"), 0) and (..., 1) with
gitRefExists(harness.cwd, ...) and read the git tree/workdir to assert README.md
content before and after the turn (use waitForGitRefExists to wait for refs,
then read the commit or filesystem snapshot to assert expected contents), and
also strengthen the thread assertion returned by waitForThread to verify the
checkpoint entries' metadata (e.g., checkpointTurnCount and any stored snapshot
ids) so provider parity regressions are caught.

apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts (2)

239-262: Event streaming test has potential race condition.

The test forks a fiber to wait for the first event, then emits the event. While this generally works due to Effect's cooperative scheduling, the fiber may not have subscribed to the queue before emitRuntimeEvent is called. Consider adding a small yield or using Effect.yieldNow() after forking to ensure the fiber has started listening.

🛡️ Suggested improvement

 it.effect("passes through canonical runtime events without remapping", () =>
   Effect.gen(function* () {
     const adapter = yield* ClaudeCodeAdapter;
     const firstEventFiber = yield* Stream.runHead(adapter.streamEvents).pipe(Effect.forkChild);
+    yield* Effect.yieldNow();
     const runtimeEvent: ProviderRuntimeEvent = {

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts` around lines 239 -
262, The test for ClaudeCodeAdapter can race because the forked fiber waiting on
Stream.runHead(adapter.streamEvents) may not be subscribed before
lifecycleRuntime.emitRuntimeEvent is called; after creating firstEventFiber via
Effect.forkChild, insert an Effect.yieldNow() (or another small cooperative
yield) to ensure the fiber is scheduled and listening before calling
lifecycleRuntime.emitRuntimeEvent(runtimeEvent), so the Stream subscription in
Stream.runHead actually receives the emitted event.

---

162-194: Consider using assertFailure for consistency.

The session error test manually checks result._tag === "Failure" and uses early returns, while the validation test uses assertFailure. Consider using a similar pattern or Cause.match for consistency and cleaner assertions.

♻️ Optional: Refactor to use pattern matching

-      assert.equal(result._tag, "Failure");
-      if (result._tag !== "Failure") {
-        return;
-      }
-
-      assert.equal(result.failure._tag, "ProviderAdapterSessionNotFoundError");
-      if (result.failure._tag !== "ProviderAdapterSessionNotFoundError") {
-        return;
-      }
-      assert.equal(result.failure.provider, "claudeCode");
-      assert.equal(result.failure.sessionId, "claude-sess-missing");
-      assert.instanceOf(result.failure.cause, Error);
+      assert.equal(result._tag, "Failure");
+      assert.equal(result.failure._tag, "ProviderAdapterSessionNotFoundError");
+      assert.equal(result.failure.provider, "claudeCode");
+      assert.equal(result.failure.sessionId, "claude-sess-missing");
+      assert.instanceOf(result.failure.cause, Error);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/provider/Layers/ClaudeCodeAdapter.test.ts` around lines 162 -
194, Replace the manual result tag checks and early returns in the
"ClaudeCodeAdapterLive session errors" test with the shared assertFailure helper
used elsewhere: call assertFailure(result) to assert it's a Failure and receive
the failure value, then assert on failure._tag ===
"ProviderAdapterSessionNotFoundError", failure.provider === "claudeCode",
failure.sessionId === "claude-sess-missing", and that failure.cause is an Error;
update the assertions in the sessionErrorLayer test (which uses
FakeClaudeRuntime, makeClaudeCodeAdapterLive, ClaudeCodeAdapter, asSessionId) to
use assertFailure instead of manual _tag checks to keep consistency and remove
early returns.

apps/server/src/provider/Layers/ClaudeCodeAdapter.ts (2)

71-91: String-based error detection is fragile.

The toSessionError function relies on substring matching of error messages ("unknown session", "session is closed") to determine error types. This approach is brittle and may break if the upstream runtime changes its error message format.

Consider defining error codes or structured error types in the runtime interface that can be matched more reliably. If that's not feasible now, document this coupling and consider adding the expected error messages as constants.

📝 Suggested improvement

+// Expected error message patterns from ClaudeCodeRuntime.
+// If the runtime changes these, update accordingly.
+const SESSION_NOT_FOUND_PATTERNS = ["unknown session", "unknown provider session"];
+const SESSION_CLOSED_PATTERN = "session is closed";
+
 function toSessionError(
   sessionId: ProviderSessionId,
   cause: unknown,
 ): ProviderAdapterSessionNotFoundError | ProviderAdapterSessionClosedError | undefined {
   const normalized = toMessage(cause, "").toLowerCase();
-  if (normalized.includes("unknown session") || normalized.includes("unknown provider session")) {
+  if (SESSION_NOT_FOUND_PATTERNS.some((p) => normalized.includes(p))) {
     return new ProviderAdapterSessionNotFoundError({

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/provider/Layers/ClaudeCodeAdapter.ts` around lines 71 - 91,
The toSessionError function currently uses fragile substring matching of
normalized message text from toMessage(cause, "") to decide between
ProviderAdapterSessionNotFoundError and ProviderAdapterSessionClosedError;
change this by (preferred) extending the runtime error contract to include a
stable errorCode or typed error (inspect cause for an error.code or a
discriminant and branch on that), or if changing the runtime isn't possible now,
extract the literal strings ("unknown session", "unknown provider session",
"session is closed") into named constants and add a clear comment documenting
the coupling, and update toSessionError (and any callers) to check those
constants (and error.code if present) rather than ad-hoc substring matches to
make detection reliable; reference toSessionError, toMessage, PROVIDER,
ProviderAdapterSessionNotFoundError, ProviderAdapterSessionClosedError, and
ProviderSessionId when implementing.

---

193-208: Rollback validation is correct but consider upper bound.

The validation ensures numTurns >= 1 and is an integer, which is correct. However, there's no upper bound validation. If the runtime doesn't handle excessively large values gracefully, consider adding a reasonable upper limit.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/server/src/provider/Layers/ClaudeCodeAdapter.ts` around lines 193 - 208,
The rollbackThread implementation currently validates numTurns >= 1 but lacks an
upper bound; add a MAX_TURNS constant (e.g., MAX_TURNS = <reasonable limit>) and
update the validation in ClaudeCodeAdapter.rollbackThread to also reject values
> MAX_TURNS by returning a ProviderAdapterValidationError (same shape as
existing error, operation "rollbackThread", issue like "numTurns must be an
integer between 1 and MAX_TURNS"). Ensure the new check runs before calling
runtime.rollbackThread; leave the existing Effect.tryPromise call and
toRequestError handling unchanged so runtime.rollbackThread is only invoked for
values within the allowed range.

apps/web/src/components/ChatView.tsx (1)

2823-2830: Avoid hardcoded provider guards in ProviderPicker.

Line 2829 hardcodes "codex"/"claudeCode", so newly added providers could appear in the dropdown but never be selectable. Prefer validating against the same filtered PROVIDER_OPTIONS source you render.

♻️ Proposed refactor

 const ProviderPicker = memo(function ProviderPicker(props: {
   provider: ProviderKind;
   onProviderChange: (provider: ProviderKind) => void;
 }) {
+  const availableProviders = PROVIDER_OPTIONS.filter((option) => option.available);
+  const isAvailableProvider = (value: string): value is ProviderKind =>
+    availableProviders.some((option) => option.value === value);
+
   return (
     <Select
-      items={PROVIDER_OPTIONS.filter((option) => option.available).map((option) => ({
+      items={availableProviders.map((option) => ({
         label: option.label,
         value: option.value,
       }))}
       value={props.provider}
-      onValueChange={(value) =>
-        value === "codex" || value === "claudeCode" ? props.onProviderChange(value) : undefined
-      }
+      onValueChange={(value) => (value && isAvailableProvider(value) ? props.onProviderChange(value) : undefined)}
     >
       <SelectTrigger size="sm" variant="ghost">
         <SelectValue />
       </SelectTrigger>
       <SelectPopup alignItemWithTrigger={false}>
-        {PROVIDER_OPTIONS.filter((option) => option.available).map(({ value, label }) => (
+        {availableProviders.map(({ value, label }) => (
           <SelectItem key={value} value={value}>
             {label}
           </SelectItem>
         ))}
       </SelectPopup>
     </Select>
   );
 });

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/web/src/components/ChatView.tsx` around lines 2823 - 2830, The
ProviderPicker currently prevents selection by checking hardcoded provider
values ("codex"/"claudeCode") in the onValueChange handler; update it to
validate against the same PROVIDER_OPTIONS source used for items instead: lookup
the selected value in PROVIDER_OPTIONS (or in PROVIDER_OPTIONS.filter(o =>
o.available)) and only call props.onProviderChange(value) if a matching option
with available === true exists (use the option.value and option.available checks
to locate the entry), ensuring new providers shown in the dropdown can be
selected.

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Bugbot Autofix prepared fixes for all 3 issues found in the latest run.

• ✅ Fixed: Claude Code enabled in UI but server runtime unconfigured
  • Set claudeCode to available: false with label "Claude Code (soon)" in PROVIDER_OPTIONS since makeClaudeCodeAdapterLive() has no runtime configured and falls through to makeUnavailableRuntime().
• ✅ Fixed: Provider always sent, breaking optional field semantics
  • Changed the provider field in the turn start command to only be included when the user has explicitly selected a provider via selectedProviderByThread, preventing unnecessary session restarts for threads with null providerName.
• ✅ Fixed: Resume cursor read from live sessions not persisted state
  • Changed resolveResumeCursorForSession to read from persisted ProviderSessionDirectory.getBinding() instead of live providerService.listSessions(), ensuring the resume cursor survives adapter-level session loss.

Or push these changes by commenting:

@cursor push 6d4ef60128

diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -222,7 +222,7 @@
     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
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -10,7 +10,7 @@
   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 @@
   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 @@
       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
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -15,6 +15,7 @@
 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 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 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
--- a/apps/server/src/serverLayers.ts
+++ b/apps/server/src/serverLayers.ts
@@ -23,6 +23,7 @@
 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 { NodePtyAdapterLive } from "./terminal/Layers/NodePTY";
 
 export function makeServerProviderLayer(): Layer.Layer<
-  ProviderService,
+  ProviderService | ProviderSessionDirectory,
   ProviderUnsupportedError,
   SqlClient.SqlClient | ServerConfig
 > {
@@ -55,7 +56,7 @@
     );
     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
--- a/apps/server/src/wsServer.test.ts
+++ b/apps/server/src/wsServer.test.ts
@@ -4,7 +4,7 @@
 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 { 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 @@
       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 @@
       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
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -1560,7 +1560,9 @@
           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
--- a/apps/web/src/session-logic.test.ts
+++ b/apps/web/src/session-logic.test.ts
@@ -128,12 +128,12 @@
 });
 
 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
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -13,7 +13,7 @@
   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 {

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Exported ClaudeCodeAdapterLive constant is never imported
  • Removed the unused ClaudeCodeAdapterLive constant export since all consumers use the makeClaudeCodeAdapterLive() factory function instead.

Or push these changes by commenting:

@cursor push 209b86105e

diff --git a/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts b/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
--- a/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
+++ b/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
@@ -98,8 +98,6 @@
   streamEvents: Stream.empty as Stream.Stream<ProviderRuntimeEvent>,
 } satisfies ClaudeCodeAdapterShape);
 
-export const ClaudeCodeAdapterLive = Layer.effect(ClaudeCodeAdapter, makeClaudeCodeAdapter);
-
 export function makeClaudeCodeAdapterLive() {
   return Layer.effect(ClaudeCodeAdapter, makeClaudeCodeAdapter);
 }

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Hardcoded provider prefixes silently drop model selections
  • Replaced hardcoded startsWith("codex:") and startsWith("claudeCode:") checks with a generic indexOf(":") split that works for any provider prefix, making the handler extensible without coordinated changes.

Or push these changes by commenting:

@cursor push 7bb9501a87

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -2826,25 +2826,14 @@
     <Select
       items={items}
       value={`${props.provider}:${props.model}`}
-      onValueChange={(value) =>
-        value
-          ? (() => {
-              if (value.startsWith("codex:")) {
-                props.onProviderModelChange(
-                  "codex",
-                  resolveModelSlugForProvider("codex", value.slice("codex:".length)),
-                );
-                return;
-              }
-              if (value.startsWith("claudeCode:")) {
-                props.onProviderModelChange(
-                  "claudeCode",
-                  resolveModelSlugForProvider("claudeCode", value.slice("claudeCode:".length)),
-                );
-              }
-            })()
-          : undefined
-      }
+      onValueChange={(value) => {
+        if (!value) return;
+        const colonIdx = value.indexOf(":");
+        if (colonIdx === -1) return;
+        const provider = value.slice(0, colonIdx) as ProviderKind;
+        const slug = value.slice(colonIdx + 1);
+        props.onProviderModelChange(provider, resolveModelSlugForProvider(provider, slug));
+      }}
     >
       <SelectTrigger size="sm" variant="ghost">
         <span className="flex min-w-0 items-center gap-2">

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Provider not inferred from thread model without session
  • Exported inferProviderForThreadModel from store.ts and used it in ChatView's selectedProvider derivation to infer the correct provider from the thread's model slug before falling back to the hardcoded 'codex' default.

Or push these changes by commenting:

@cursor push 62e136dcc8

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -51,7 +51,7 @@
   formatTimestamp,
 } from "../session-logic";
 import { isScrollContainerNearBottom } from "../chat-scroll";
-import { useStore } from "../store";
+import { inferProviderForThreadModel, useStore } from "../store";
 import { truncateTitle } from "../truncateTitle";
 import {
   DEFAULT_THREAD_TERMINAL_ID,
@@ -413,7 +413,12 @@
   const selectedProvider: ProviderKind =
     (activeThread?.id ? selectedProviderByThread[activeThread.id] : undefined) ??
     sessionProvider ??
-    "codex";
+    (activeThread?.model
+      ? inferProviderForThreadModel({
+          model: activeThread.model,
+          sessionProviderName: activeThread.session?.provider ?? null,
+        })
+      : "codex");
   const selectedModel = resolveModelSlugForProvider(
     selectedProvider,
     activeThread?.model ?? activeProject?.model ?? getDefaultModel(selectedProvider) ?? DEFAULT_MODEL,

diff --git a/apps/web/src/store.ts b/apps/web/src/store.ts
--- a/apps/web/src/store.ts
+++ b/apps/web/src/store.ts
@@ -198,7 +198,7 @@
 const CODEX_MODEL_SLUGS = new Set(getModelOptions("codex").map((option) => option.slug));
 const CLAUDE_MODEL_SLUGS = new Set(getModelOptions("claudeCode").map((option) => option.slug));
 
-function inferProviderForThreadModel(input: {
+export function inferProviderForThreadModel(input: {
   readonly model: string;
   readonly sessionProviderName: string | null;
 }): "codex" | "claudeCode" {

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Detached fiber bypasses adapter scope management
  • Replaced Effect.runFork(runSdkStream(context)) with yield* Effect.forkDetach(runSdkStream(context)) to inherit provided services, stored the fiber in ClaudeSessionContext.streamFiber, and added Fiber.interrupt in stopSessionInternal for deterministic cleanup before queue shutdown.

Or push these changes by commenting:

@cursor push 4e4055c7f0

diff --git a/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts b/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
--- a/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
+++ b/apps/server/src/provider/Layers/ClaudeCodeAdapter.ts
@@ -31,7 +31,18 @@
   ProviderThreadId,
   ProviderTurnId,
 } from "@t3tools/contracts";
-import { Cause, DateTime, Deferred, Effect, Layer, Queue, Random, Ref, Stream } from "effect";
+import {
+  Cause,
+  DateTime,
+  Deferred,
+  Effect,
+  Fiber,
+  Layer,
+  Queue,
+  Random,
+  Ref,
+  Stream,
+} from "effect";
 
 import {
   ProviderAdapterProcessError,
@@ -99,6 +110,7 @@
   lastAssistantUuid: string | undefined;
   lastThreadStartedId: ProviderThreadId | undefined;
   stopped: boolean;
+  streamFiber: Fiber.RuntimeFiber<void> | undefined;
 }
 
 interface ClaudeQueryRuntime extends AsyncIterable<SDKMessage> {
@@ -117,9 +129,7 @@
 }
 
 function isUuid(value: string): boolean {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
-    value,
-  );
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
 }
 
 function toMessage(cause: unknown, fallback: string): string {
@@ -695,6 +705,11 @@
 
         context.stopped = true;
 
+        if (context.streamFiber) {
+          yield* Fiber.interrupt(context.streamFiber);
+          context.streamFiber = undefined;
+        }
+
         for (const [requestId, pending] of context.pendingApprovals) {
           yield* Deferred.succeed(pending.decision, "cancel");
           const stamp = yield* makeEventStamp();
@@ -967,6 +982,7 @@
           lastAssistantUuid: resumeState?.resumeSessionAt,
           lastThreadStartedId: undefined,
           stopped: false,
+          streamFiber: undefined,
         };
         yield* Ref.set(contextRef, context);
         sessions.set(sessionId, context);
@@ -981,7 +997,7 @@
           threadId,
         });
 
-        Effect.runFork(runSdkStream(context));
+        context.streamFiber = yield* Effect.forkDetach(runSdkStream(context));
 
         return {
           ...session,

Bugbot Autofix prepared a fix for the issue found in the latest run.

• ✅ Fixed: Cross-provider resume cursor forwarded on provider switch
  • When providerChanged is true, resumeCursor is now set to undefined instead of resolving the old provider's opaque cursor, preventing cross-provider cursor misinterpretation.

Or push these changes by commenting:

@cursor push 966209c2b5

diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
@@ -211,7 +211,7 @@
         return existingSessionId;
       }
 
-      const resumeCursor = yield* resolveResumeCursorForSession(existingSessionId);
+      const resumeCursor = providerChanged ? undefined : (yield* resolveResumeCursorForSession(existingSessionId));
       const restartedSession = yield* startProviderSession({
         ...(resumeCursor !== undefined ? { resumeCursor } : {}),
         ...(options?.provider !== undefined ? { provider: options.provider } : {}),