Infer provider from model for requested turns

- Resolve turn provider from explicit provider or model hint before canonicalizing selection
- Tighten projector test assertions for thread shape
- Use non-mutating key sorting in model selection equality

Author: BunsDev

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts

@@ -270,6 +270,16 @@ const make = Effect.gen(function* () {
     return readModel.threads.find((entry) => entry.id === threadId);
   });
 
+  const resolveRequestedTurnProvider = (input: {
+    readonly threadSelection: ModelSelection;
+    readonly provider?: ProviderKind;
+    readonly model?: string;
+  }): ProviderKind =>
+    input.provider ??
+    (input.model !== undefined
+      ? inferProviderForModel(input.model, input.threadSelection.provider)
+      : input.threadSelection.provider);
+
   const ensureSessionForThread = Effect.fnUntraced(function* (
     threadId: ThreadId,
     createdAt: string,
@@ -294,11 +304,16 @@ const make = Effect.gen(function* () {
       ? thread.session.providerName
       : undefined;
     const threadSelection = resolveThreadModelSelection(thread);
+    const requestedProvider = resolveRequestedTurnProvider({
+      threadSelection,
+      ...(options?.provider !== undefined ? { provider: options.provider } : {}),
+      ...(options?.model !== undefined ? { model: options.model } : {}),
+    });
     const requestedSelection =
       options?.modelSelection ??
       (options?.provider || options?.model || options?.modelOptions
         ? toCanonicalModelSelection(
-            options?.provider ?? threadSelection.provider,
+            requestedProvider,
             options?.model ?? threadSelection.model,
             options?.modelOptions ?? getModelSelectionOptions(threadSelection),
           )

apps/server/src/orchestration/projector.test.ts

@@ -72,27 +72,30 @@ describe("orchestration projector", () => {
     );
 
     expect(next.snapshotSequence).toBe(1);
-    expect(next.threads).toEqual([
-      {
-        id: "thread-1",
-        projectId: "project-1",
-        title: "demo",
+    expect(next.threads).toHaveLength(1);
+    expect(next.threads[0]).toMatchObject({
+      id: "thread-1",
+      projectId: "project-1",
+      title: "demo",
+      model: "gpt-5-codex",
+      modelSelection: {
+        provider: "codex",
         model: "gpt-5-codex",
-        runtimeMode: "full-access",
-        interactionMode: "chat",
-        branch: null,
-        worktreePath: null,
-        latestTurn: null,
-        createdAt: now,
-        updatedAt: now,
-        deletedAt: null,
-        messages: [],
-        proposedPlans: [],
-        activities: [],
-        checkpoints: [],
-        session: null,
       },
-    ]);
+      runtimeMode: "full-access",
+      interactionMode: "chat",
+      branch: null,
+      worktreePath: null,
+      latestTurn: null,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null,
+    });
+    expect(next.threads[0]?.session ?? null).toBeNull();
+    expect(next.threads[0]?.messages).toEqual([]);
+    expect(next.threads[0]?.proposedPlans).toEqual([]);
+    expect(next.threads[0]?.activities).toEqual([]);
+    expect(next.threads[0]?.checkpoints).toEqual([]);
   });
 
   it("fails when event payload cannot be decoded by runtime schema", async () => {

packages/shared/src/modelSelection.ts

@@ -75,8 +75,8 @@ export function modelSelectionsAreEqual(
   const bOpts = b.options ?? null;
   if (aOpts === null && bOpts === null) return true;
   if (aOpts === null || bOpts === null) return false;
-  const aKeys = Object.keys(aOpts).sort();
-  const bKeys = Object.keys(bOpts).sort();
+  const aKeys = Object.keys(aOpts).toSorted();
+  const bKeys = Object.keys(bOpts).toSorted();
   if (aKeys.join(",") !== bKeys.join(",")) return false;
   return aKeys.every(
     (k) => (aOpts as Record<string, unknown>)[k] === (bOpts as Record<string, unknown>)[k],