Extend Orchestra to Codex models

Orchestra already worked end-to-end on Codex (resolvedEffort maps it to xhigh,
which Codex accepts, and CodexAppServerBackend forwards appendSystemPrompt as
developerInstructions); it was only held back by a deliberate Claude-only UI gate.
Drops supportsOrchestra and the menu gating so the mode is offered for every model,
and simplifies clampedEffort to always preserve Orchestra (it's an orchestration
mode, not an API level).

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

Sources/NucleicApp/HomeView.swift

@@ -294,14 +294,13 @@ struct HomeView: View {
                 }
             }
             // Orchestra sits below the API levels, set apart: it isn't an effort level but an
-            // orchestration mode (xhigh + standing consent to fan out to subagents). Offered
-            // only for Claude models — it's a Claude Code feature.
-            if ModelCatalog.supportsOrchestra(effectiveModel) {
+            // orchestration mode (xhigh + standing consent to fan out to subagents). Available
+            // for every model — Claude and Codex alike (the consent rides in as the backend's
+            // appended system prompt either way).
             Divider()
             Button { effortOverride = ModelCatalog.orchestraEffort } label: {
                 orchestraMenuItem
             }
-            }
         } label: {
             if isOrchestra {
                 OrchestraEffortLabel()

Sources/NucleicApp/ModelCatalog.swift

@@ -38,13 +38,11 @@ enum ModelCatalog {
 
     /// Clamp `effort` to what `sku` supports, so switching to a model with a lower cap can't
     /// leave an unsupported level selected (e.g. "max" carried onto a Codex model → "xhigh").
-    /// Orchestra is preserved on the Claude models that support it, but drops to the model's
-    /// top API level on a model that doesn't (Codex), mirroring the menu's per-model gating.
+    /// Orchestra is an orchestration mode, not an API level — valid for every model (it
+    /// resolves to a supported effort, `xhigh`, on the host), so it's always preserved.
     static func clampedEffort(_ effort: String, for sku: String) -> String {
+        if isOrchestra(effort) { return effort }
         let supported = efforts(for: sku)
-        if isOrchestra(effort) {
-            return supportsOrchestra(sku) ? effort : (supported.last ?? fallbackEffort)
-        }
         return supported.contains(effort) ? effort : (supported.last ?? fallbackEffort)
     }
 
@@ -53,12 +51,6 @@ enum ModelCatalog {
         BackendID.forModel(sku) == .codex ? "Reasoning" : "Effort"
     }
 
-    /// Whether `sku` can run in orchestra (orchestration) mode. It's a Claude-Code feature
-    /// (xhigh + standing fan-out consent), so it's offered only for Claude models, not Codex.
-    static func supportsOrchestra(_ sku: String) -> Bool {
-        BackendID.forModel(sku) != .codex
-    }
-
     /// The SKUs that run on `backend` — for the in-session model menu, where the backend is
     /// fixed at creation and can't change. (The home composer offers all SKUs, since the model
     /// chooses the backend.)

Sources/NucleicApp/SessionDetailView.swift

@@ -275,13 +275,11 @@ struct SessionDetailView: View {
             }
             // Orchestra is an orchestration mode, not an API level — set it apart below the
             // canonical efforts (xhigh + standing consent to fan out to parallel subagents).
-            // Offered only for Claude models — it's a Claude Code feature.
-            if ModelCatalog.supportsOrchestra(effectiveModel) {
+            // Available for every model — Claude and Codex alike.
             Divider()
             Button { Task { await store.setOpenSessionEffort(ModelCatalog.orchestraEffort) } } label: {
                 orchestraMenuItem
             }
-            }
         } label: {
             Group {
                 if isOrchestra {