From 0f182048ed812cb7741e1bb504a3e54c8763b73b Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:34:38 +0100
Subject: [PATCH 01/18] feat(claude): Ultracode is a toggle that works with any
 effort

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/claudeModelOptions.test.ts    | 20 +++++++++++++
 apps/server/src/claudeModelOptions.ts         | 12 ++++++--
 .../Adapters/ClaudeAdapterV2.test.ts          |  5 ++--
 .../server/src/provider/ClaudeModelCatalog.ts | 28 +++++++++++++++----
 .../textGeneration/ClaudeTextGeneration.ts    |  3 +-
 packages/client-runtime/src/modelTraits.ts    |  4 +++
 packages/shared/src/model.test.ts             | 28 +++++++++++++++++++
 packages/shared/src/model.ts                  | 27 ++++++++++++++++--
 8 files changed, 113 insertions(+), 14 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.test.ts b/apps/server/src/claudeModelOptions.test.ts
index 4a34d98a796bd..6e1986d7a5b18 100644
--- a/apps/server/src/claudeModelOptions.test.ts
+++ b/apps/server/src/claudeModelOptions.test.ts
@@ -30,6 +30,26 @@ describe("compileClaudeModelSelection", () => {
     });
   });
 
+  it("runs Ultracode at the chosen effort and reads the old Ultracode effort as xhigh", () => {
+    expect(
+      compileClaudeModelSelection(
+        selection("claude-opus-5-5", [
+          { id: "effort", value: "high" },
+          { id: "ultracode", value: true },
+        ]),
+      ),
+    ).toMatchObject({ effort: "high", settings: { ultracode: true } });
+    expect(
+      compileClaudeModelSelection(
+        selection("claude-opus-5-5", [{ id: "effort", value: "ultracode" }]),
+      ),
+    ).toMatchObject({ effort: "xhigh", settings: { ultracode: true } });
+    expect(
+      compileClaudeModelSelection(selection("claude-opus-5-5", [{ id: "effort", value: "high" }]))
+        .settings,
+    ).not.toHaveProperty("ultracode");
+  });
+
   it("uses the model default SDK effort alongside prompt-injected effort", () => {
     expect(
       compileClaudeModelSelection(
diff --git a/apps/server/src/claudeModelOptions.ts b/apps/server/src/claudeModelOptions.ts
index 06841da9bdb28..48b6e0d6115a4 100644
--- a/apps/server/src/claudeModelOptions.ts
+++ b/apps/server/src/claudeModelOptions.ts
@@ -9,7 +9,6 @@ import {
 import {
   BUNDLED_CLAUDE_MODEL_CATALOG,
   getClaudeCatalogModelCapabilities,
-  isClaudeCatalogUltracodeEffort,
   normalizeClaudeCatalogEffort,
   resolveClaudeCatalogApiModelId,
   resolveClaudeCatalogEffort,
@@ -29,7 +28,10 @@ export function compileClaudeModelSelection(
   catalog: ClaudeModelCatalog = BUNDLED_CLAUDE_MODEL_CATALOG,
 ): CompiledClaudeModelSelection {
   const capabilities = getClaudeCatalogModelCapabilities(catalog, selection.model);
-  const descriptors = getProviderOptionDescriptors({ caps: capabilities });
+  const descriptors = getProviderOptionDescriptors({
+    caps: capabilities,
+    selections: selection.options,
+  });
   const supportsBoolean = (id: string) =>
     descriptors.some((descriptor) => descriptor.type === "boolean" && descriptor.id === id);
   const rawEffort = getModelSelectionStringOptionValue(selection, "effort");
@@ -44,7 +46,11 @@ export function compileClaudeModelSelection(
   const settings = {
     ...(typeof thinking === "boolean" ? { alwaysThinkingEnabled: thinking } : {}),
     ...(typeof fastMode === "boolean" ? { fastMode } : {}),
-    ...(isClaudeCatalogUltracodeEffort(resolvedEffort) ? { ultracode: true } : {}),
+    ...(descriptors.some(
+      (descriptor) => descriptor.id === "ultracode" && descriptor.currentValue === true,
+    )
+      ? { ultracode: true }
+      : {}),
   };
   const apiModelId = resolveClaudeCatalogApiModelId(catalog, selection);
   const promptEffort = resolvePromptInjectedEffort(capabilities, rawEffort) ?? undefined;
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index ea5ee249a787f..d9e53bae17b64 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -4408,7 +4408,8 @@ describe("ClaudeAdapterV2 background wake turns", () => {
             turn(3, {
               ...normal,
               options: [
-                { id: "effort", value: "ultracode" },
+                { id: "effort", value: "high" },
+                { id: "ultracode", value: true },
                 { id: "fastMode", value: true },
               ],
             }),
@@ -4418,7 +4419,7 @@ describe("ClaudeAdapterV2 background wake turns", () => {
           yield* settle;
           assert.deepEqual(harness.liveSelectionChanges, [
             { model: "claude-opus-5-5" },
-            { effortLevel: "xhigh", fastMode: true, ultracode: true },
+            { effortLevel: "high", fastMode: true, ultracode: true },
             { model: "claude-sonnet-4-6" },
             { effortLevel: "high", fastMode: null, ultracode: null },
           ]);
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index f67628efb83a3..dc3adffb14589 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -47,8 +47,9 @@ function tryResolveClaudeModelCatalog(
     const profile = decodeClaudeProfileAdapter(entry.profileAdapter ?? {});
     const adapter = decodeClaudeModelAdapter(entry.adapter ?? {});
     if (Option.isNone(profile) || Option.isNone(adapter)) return null;
+    const model = ModelCatalog.catalogServerModel(resolved, entry);
     models.push({
-      model: ModelCatalog.catalogServerModel(resolved, entry),
+      model: { ...model, capabilities: withUltracodeToggle(model.capabilities) },
       runtime: profile.value.claudeCode ?? {},
       compatibility: adapter.value.claudeCode ?? {},
     });
@@ -59,6 +60,27 @@ function tryResolveClaudeModelCatalog(
   };
 }
 
+// The manifest keeps Ultracode as an effort level because released servers read it from main.
+function withUltracodeToggle(capabilities: ModelCapabilities | null): ModelCapabilities | null {
+  const descriptors = capabilities?.optionDescriptors ?? [];
+  const effortIndex = descriptors.findIndex(
+    (descriptor) =>
+      descriptor.id === "effort" &&
+      descriptor.type === "select" &&
+      descriptor.options.some((option) => option.id === "ultracode"),
+  );
+  const effort = descriptors[effortIndex];
+  if (effort?.type !== "select") return capabilities;
+  return {
+    optionDescriptors: descriptors.toSpliced(
+      effortIndex,
+      1,
+      { ...effort, options: effort.options.filter((option) => option.id !== "ultracode") },
+      { id: "ultracode", label: "Ultracode", type: "boolean" },
+    ),
+  };
+}
+
 /** Resolve the fallback on each read so its new-model badges can expire. */
 export function resolveClaudeModelCatalog(
   catalog: ModelCatalog.ProviderCatalog | undefined,
@@ -235,10 +257,6 @@ export function normalizeClaudeCatalogEffort(
   return effortMap[effort] ?? undefined;
 }
 
-export function isClaudeCatalogUltracodeEffort(effort: string | null | undefined): boolean {
-  return effort === "ultracode";
-}
-
 function resolveClaudeCatalogContextWindow(
   catalog: ClaudeModelCatalog,
   modelSelection: ModelSelection | undefined,
diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
index 8fa9ccb1c8094..e26e59bdd0807 100644
--- a/apps/server/src/textGeneration/ClaudeTextGeneration.ts
+++ b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
@@ -22,7 +22,6 @@ import {
   BUNDLED_CLAUDE_MODEL_CATALOG,
   type ClaudeModelCatalog,
   getClaudeCatalogModelCapabilities,
-  isClaudeCatalogUltracodeEffort,
   normalizeClaudeCatalogEffort,
   resolveClaudeCatalogApiModelId,
   resolveClaudeCatalogEffort,
@@ -159,7 +158,7 @@ export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(fu
       resolvedEffort,
       resolvedModelSelection.model,
     );
-    const ultracode = isClaudeCatalogUltracodeEffort(resolvedEffort);
+    const ultracode = findDescriptor("ultracode")?.currentValue === true;
     const thinkingDescriptor = findDescriptor("thinking");
     const fastModeDescriptor = findDescriptor("fastMode");
     // Only a chosen value; otherwise Claude Code's own default applies, as in chat turns.
diff --git a/packages/client-runtime/src/modelTraits.ts b/packages/client-runtime/src/modelTraits.ts
index 734a84c468aa0..ae8b21a021f45 100644
--- a/packages/client-runtime/src/modelTraits.ts
+++ b/packages/client-runtime/src/modelTraits.ts
@@ -127,6 +127,10 @@ export function buildTraitsTriggerDisplay(input: {
       fastModeFallbackLabel = speedLabel ?? "Normal";
       continue;
     }
+    if (descriptor.id === "ultracode" && descriptor.type === "boolean") {
+      if (descriptor.currentValue === true) labels.push(descriptor.label);
+      continue;
+    }
     if (
       input.provider === "codex" &&
       descriptor.id === "serviceTier" &&
diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index 396d4d9c86c26..5de287893e884 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -50,6 +50,34 @@ describe("descriptor helpers", () => {
     ).toEqual([{ id: "fastMode", value: true }]);
   });
 
+  it("reads the old Ultracode effort level as xhigh with the Ultracode toggle on", () => {
+    const caps = createModelCapabilities({
+      optionDescriptors: [
+        {
+          id: "effort",
+          label: "Reasoning",
+          type: "select",
+          options: [
+            { id: "high", label: "High", isDefault: true },
+            { id: "xhigh", label: "Extra High" },
+          ],
+        },
+        { id: "ultracode", label: "Ultracode", type: "boolean" },
+      ],
+    });
+    const selections = [{ id: "effort", value: "ultracode" }];
+
+    expect(
+      buildExplicitProviderOptionSelectionsFromDescriptors(
+        getProviderOptionDescriptors({ caps, selections }),
+        selections,
+      ),
+    ).toEqual([
+      { id: "effort", value: "xhigh" },
+      { id: "ultracode", value: true },
+    ]);
+  });
+
   it("compares complete model selections independent of option ordering", () => {
     const left = createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
       { id: "reasoningEffort", value: "high" },
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 51cc1430321d8..4886680aa951a 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -196,12 +196,33 @@ function withDescriptorCurrentValue(
   };
 }
 
+// Ultracode was a Claude effort level before it became its own toggle; that level ran at xhigh.
+function withLegacyUltracodeEffort(
+  descriptors: ReadonlyArray<ProviderOptionDescriptor>,
+  selections: ReadonlyArray<ProviderOptionSelection> | null | undefined,
+): ReadonlyArray<ProviderOptionSelection> | null | undefined {
+  if (
+    getRawSelectionValueById(selections, "effort") !== "ultracode" ||
+    !descriptors.some(
+      (descriptor) => descriptor.id === "ultracode" && descriptor.type === "boolean",
+    )
+  ) {
+    return selections;
+  }
+  return [
+    ...(selections ?? []).filter(({ id }) => id !== "effort" && id !== "ultracode"),
+    { id: "effort", value: "xhigh" },
+    { id: "ultracode", value: true },
+  ];
+}
+
 export function getProviderOptionDescriptors(input: {
   caps: ModelCapabilities;
   selections?: ReadonlyArray<ProviderOptionSelection> | null | undefined;
 }): ReadonlyArray<ProviderOptionDescriptor> {
-  const { caps, selections } = input;
+  const { caps } = input;
   const baseDescriptors = (caps.optionDescriptors ?? []).map(cloneDescriptor);
+  const selections = withLegacyUltracodeEffort(baseDescriptors, input.selections);
 
   return baseDescriptors.map((descriptor) =>
     withDescriptorCurrentValue(
@@ -312,7 +333,9 @@ export function buildExplicitProviderOptionSelectionsFromDescriptors(
   if (!selections || selections.length === 0) {
     return undefined;
   }
-  const explicitIds = new Set(selections.map((selection) => selection.id));
+  const explicitIds = new Set(
+    (withLegacyUltracodeEffort(descriptors ?? [], selections) ?? []).map(({ id }) => id),
+  );
   const normalized = buildProviderOptionSelectionsFromDescriptors(descriptors)?.filter(
     (selection) => explicitIds.has(selection.id),
   );

From 9bbf5c7608f1d77e997de1788f0989f84da42c04 Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Thu, 29 Oct 2026 17:41:00 +0100
Subject: [PATCH 02/18] fix(mcp): old Ultracode effort requests and explicit
 off still work

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/mcp/OrchestratorMcpService.test.ts    | 42 ++++++++++++++++---
 apps/server/src/mcp/OrchestratorMcpService.ts | 11 +++--
 packages/shared/src/model.test.ts             |  6 +++
 packages/shared/src/model.ts                  |  5 ++-
 4 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts
index 6450f9acac2cb..d25ec08c8e53d 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts
@@ -2526,6 +2526,18 @@ describe("OrchestratorMcpService provider resolution", () => {
             target: { providerInstanceId: peerId, options: { reasoningEffort: "max" } },
             expected: { instanceId: peerId, model: inherited.model, options: override },
           },
+          {
+            name: "old Ultracode effort level",
+            target: { model: "ultracode-model", options: { effort: "ultracode" } },
+            expected: {
+              instanceId: codexInstanceId,
+              model: "ultracode-model",
+              options: [
+                { id: "effort", value: "xhigh" },
+                { id: "ultracode", value: true },
+              ],
+            },
+          },
         ] as const;
         for (const testCase of cases) {
           const commands: Array<unknown> = [];
@@ -2567,12 +2579,30 @@ describe("OrchestratorMcpService provider resolution", () => {
                   driver,
                   model: inherited.model,
                 }),
-                models: [inherited.model, "other-model"].map((model) => ({
-                  slug: model,
-                  name: model,
-                  isCustom: false,
-                  capabilities: null,
-                })),
+                models: [
+                  ...[inherited.model, "other-model"].map((model) => ({
+                    slug: model,
+                    name: model,
+                    isCustom: false,
+                    capabilities: null,
+                  })),
+                  {
+                    slug: "ultracode-model",
+                    name: "ultracode-model",
+                    isCustom: false,
+                    capabilities: {
+                      optionDescriptors: [
+                        {
+                          id: "effort",
+                          label: "Reasoning",
+                          type: "select",
+                          options: [{ id: "xhigh", label: "Extra High" }],
+                        },
+                        { id: "ultracode", label: "Ultracode", type: "boolean" },
+                      ],
+                    },
+                  },
+                ],
               },
               providerSnapshot({ instanceId: peerId, driver, model: inherited.model }),
             ]),
diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
index d8dacb35a0617..77c077e3b440a 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.ts
@@ -63,7 +63,7 @@ import {
   ThreadId,
   isOrchestrationV2WorkActive,
 } from "@t3tools/contracts";
-import { getProviderOptionCurrentValue } from "@t3tools/shared/model";
+import { getProviderOptionCurrentValue, withLegacyUltracodeEffort } from "@t3tools/shared/model";
 import { runRanAfter } from "@t3tools/shared/orchestrationV2ThreadError";
 import { formatThreadLink } from "@t3tools/shared/threadLinks";
 import {
@@ -1354,10 +1354,13 @@ const make = Effect.gen(function* () {
       );
     }
 
-    const requestedOptions = input.target?.options;
+    const descriptors = provider.models.find((candidate) => candidate.slug === model)?.capabilities
+      ?.optionDescriptors;
+    const requestedOptions =
+      input.target?.options === undefined
+        ? undefined
+        : (withLegacyUltracodeEffort(descriptors ?? [], input.target.options) ?? []);
     if (requestedOptions !== undefined) {
-      const descriptors = provider.models.find((candidate) => candidate.slug === model)
-        ?.capabilities?.optionDescriptors;
       const invalid = invalidOptionSelections(requestedOptions, descriptors);
       if (invalid.length > 0) {
         return yield* failure(
diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index 5de287893e884..459f2028b14ad 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -76,6 +76,12 @@ describe("descriptor helpers", () => {
       { id: "effort", value: "xhigh" },
       { id: "ultracode", value: true },
     ]);
+    expect(
+      getProviderOptionDescriptors({
+        caps,
+        selections: [...selections, { id: "ultracode", value: false }],
+      }).find(({ id }) => id === "ultracode")?.currentValue,
+    ).toBe(false);
   });
 
   it("compares complete model selections independent of option ordering", () => {
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 4886680aa951a..52ef784126ef4 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -197,7 +197,7 @@ function withDescriptorCurrentValue(
 }
 
 // Ultracode was a Claude effort level before it became its own toggle; that level ran at xhigh.
-function withLegacyUltracodeEffort(
+export function withLegacyUltracodeEffort(
   descriptors: ReadonlyArray<ProviderOptionDescriptor>,
   selections: ReadonlyArray<ProviderOptionSelection> | null | undefined,
 ): ReadonlyArray<ProviderOptionSelection> | null | undefined {
@@ -209,10 +209,11 @@ function withLegacyUltracodeEffort(
   ) {
     return selections;
   }
+  const ultracode = getRawSelectionValueById(selections, "ultracode");
   return [
     ...(selections ?? []).filter(({ id }) => id !== "effort" && id !== "ultracode"),
     { id: "effort", value: "xhigh" },
-    { id: "ultracode", value: true },
+    { id: "ultracode", value: typeof ultracode === "boolean" ? ultracode : true },
   ];
 }
 

From 7ac00b9369bd5092ebd1fb515b1971a1d12aab9b Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Thu, 29 Oct 2026 18:54:14 +0100
Subject: [PATCH 03/18] fix(mcp): reject bad Ultracode values and keep it on
 old parents

Keep an explicit ultracode value as given so validation rejects a non-boolean one,
and migrate inherited options so an effort-only override keeps Ultracode on.
---
 .../src/mcp/OrchestratorMcpService.test.ts    | 27 ++++++++++++++++---
 apps/server/src/mcp/OrchestratorMcpService.ts |  4 ++-
 packages/shared/src/model.test.ts             |  6 +++++
 packages/shared/src/model.ts                  | 12 ++++++---
 4 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts
index d25ec08c8e53d..6eb736ec7628d 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts
@@ -2538,8 +2538,26 @@ describe("OrchestratorMcpService provider resolution", () => {
               ],
             },
           },
+          {
+            name: "effort override on an old Ultracode parent",
+            parent: {
+              instanceId: codexInstanceId,
+              model: "ultracode-model",
+              options: [{ id: "effort", value: "ultracode" }],
+            },
+            target: { options: { effort: "high" } },
+            expected: {
+              instanceId: codexInstanceId,
+              model: "ultracode-model",
+              options: [
+                { id: "effort", value: "high" },
+                { id: "ultracode", value: true },
+              ],
+            },
+          },
         ] as const;
         for (const testCase of cases) {
+          const parent = "parent" in testCase ? testCase.parent : inherited;
           const commands: Array<unknown> = [];
           const task = {
             id: taskId,
@@ -2559,7 +2577,7 @@ describe("OrchestratorMcpService provider resolution", () => {
               getThreadRecords: (threadId) =>
                 Effect.succeed(
                   threadId === parentThreadId
-                    ? parentProjection(commands.length > 0 ? [task] : [], inherited)
+                    ? parentProjection(commands.length > 0 ? [task] : [], parent)
                     : childProjection,
                 ),
               dispatch: (command) =>
@@ -2596,7 +2614,10 @@ describe("OrchestratorMcpService provider resolution", () => {
                           id: "effort",
                           label: "Reasoning",
                           type: "select",
-                          options: [{ id: "xhigh", label: "Extra High" }],
+                          options: [
+                            { id: "high", label: "High" },
+                            { id: "xhigh", label: "Extra High" },
+                          ],
                         },
                         { id: "ultracode", label: "Ultracode", type: "boolean" },
                       ],
@@ -2615,7 +2636,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           yield* Effect.gen(function* () {
             const service = yield* OrchestratorMcpService.OrchestratorMcpService;
             const capabilities = yield* service.capabilities(scope);
-            assert.deepEqual(capabilities.inheritedOptions, inherited.options);
+            assert.deepEqual(capabilities.inheritedOptions, parent.options);
             yield* service.delegateTask(scope, {
               task: "Review the change.",
               target: yield* decodeTarget(testCase.target),
diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
index 77c077e3b440a..6af669ff06e7f 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.ts
@@ -1372,7 +1372,9 @@ const make = Effect.gen(function* () {
 
     const inheritsOptions =
       instanceId === inheritedSelection.instanceId && model === inheritedSelection.model;
-    let options = inheritsOptions ? inheritedSelection.options : undefined;
+    let options = inheritsOptions
+      ? (withLegacyUltracodeEffort(descriptors ?? [], inheritedSelection.options) ?? undefined)
+      : undefined;
     if (requestedOptions !== undefined) {
       const selections = new Map(
         (requestedOptions.length === 0 ? [] : (options ?? [])).map((selection) => [
diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index 459f2028b14ad..b2a9c67643d7e 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -82,6 +82,12 @@ describe("descriptor helpers", () => {
         selections: [...selections, { id: "ultracode", value: false }],
       }).find(({ id }) => id === "ultracode")?.currentValue,
     ).toBe(false);
+    expect(
+      getProviderOptionDescriptors({
+        caps,
+        selections: [...selections, { id: "ultracode", value: "false" }],
+      }).find(({ id }) => id === "ultracode")?.currentValue,
+    ).toBeUndefined();
   });
 
   it("compares complete model selections independent of option ordering", () => {
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 52ef784126ef4..9e1fe36721653 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -209,11 +209,15 @@ export function withLegacyUltracodeEffort(
   ) {
     return selections;
   }
-  const ultracode = getRawSelectionValueById(selections, "ultracode");
   return [
-    ...(selections ?? []).filter(({ id }) => id !== "effort" && id !== "ultracode"),
-    { id: "effort", value: "xhigh" },
-    { id: "ultracode", value: typeof ultracode === "boolean" ? ultracode : true },
+    ...(selections ?? []).map((selection) =>
+      selection.id === "effort" && selection.value === "ultracode"
+        ? { id: "effort", value: "xhigh" }
+        : selection,
+    ),
+    ...(getRawSelectionValueById(selections, "ultracode") === undefined
+      ? [{ id: "ultracode", value: true }]
+      : []),
   ];
 }
 

From 9a82e08f0435a8c2ced721b94287cd7b8f4eadfa Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Thu, 29 Oct 2026 18:56:05 +0100
Subject: [PATCH 04/18] feat(web): show a Workflow icon for Ultracode in the
 composer

---
 apps/web/src/components/chat/TraitsPicker.tsx |  6 +++++-
 packages/client-runtime/src/modelTraits.ts    | 18 +++++++++++++-----
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/apps/web/src/components/chat/TraitsPicker.tsx b/apps/web/src/components/chat/TraitsPicker.tsx
index 79a29d293dc49..98849cd49ea8e 100644
--- a/apps/web/src/components/chat/TraitsPicker.tsx
+++ b/apps/web/src/components/chat/TraitsPicker.tsx
@@ -25,7 +25,7 @@ import {
   normalizeModelSlug,
 } from "@t3tools/shared/model";
 import { memo, type ReactNode, useRef } from "react";
-import { GaugeIcon, ZapIcon } from "lucide-react";
+import { GaugeIcon, WorkflowIcon, ZapIcon } from "lucide-react";
 import {
   Menu,
   MenuGroup,
@@ -586,6 +586,7 @@ export const TraitsPicker = memo(function TraitsPicker({
   const {
     label: triggerLabel,
     speedLabel,
+    ultracode,
     otherLabels,
   } = buildTraitsTriggerDisplay({
     provider,
@@ -688,6 +689,9 @@ export const TraitsPicker = memo(function TraitsPicker({
               {speedLabel === "Fast" || speedLabel === "Ultrafast" ? (
                 <FastBolt ultra={speedLabel === "Ultrafast"} />
               ) : null}
+              {ultracode ? (
+                <WorkflowIcon aria-hidden="true" data-composer-control-icon className="size-3" />
+              ) : null}
               {otherLabels.length > 0 ? (
                 <span
                   aria-hidden="true"
diff --git a/packages/client-runtime/src/modelTraits.ts b/packages/client-runtime/src/modelTraits.ts
index ae8b21a021f45..197a8b3fe64b1 100644
--- a/packages/client-runtime/src/modelTraits.ts
+++ b/packages/client-runtime/src/modelTraits.ts
@@ -114,12 +114,14 @@ export function buildTraitsTriggerDisplay(input: {
   label: string;
   /** "Fast" or "Ultrafast" when a speed option is on. */
   speedLabel: string | null;
-  /** Labels other than reasoning and speed, such as context window or thinking. */
+  ultracode: boolean;
+  /** Labels other than reasoning, speed, and Ultracode, such as context window or thinking. */
   otherLabels: ReadonlyArray<string>;
 } {
   let fastModeFallbackLabel: string | null = null;
   let speedLabel: string | null = null;
   let reasoningLabelIndex = -1;
+  let ultracodeLabelIndex = -1;
   const labels: Array<string> = [];
   for (const descriptor of input.descriptors) {
     if (descriptor.id === "fastMode" && descriptor.type === "boolean") {
@@ -128,7 +130,10 @@ export function buildTraitsTriggerDisplay(input: {
       continue;
     }
     if (descriptor.id === "ultracode" && descriptor.type === "boolean") {
-      if (descriptor.currentValue === true) labels.push(descriptor.label);
+      if (descriptor.currentValue === true) {
+        ultracodeLabelIndex = labels.length;
+        labels.push(descriptor.label);
+      }
       continue;
     }
     if (
@@ -177,9 +182,12 @@ export function buildTraitsTriggerDisplay(input: {
     }
   }
 
-  const otherLabels = labels.filter((_, index) => index !== reasoningLabelIndex);
+  const ultracode = ultracodeLabelIndex >= 0;
+  const otherLabels = labels.filter(
+    (_, index) => index !== reasoningLabelIndex && index !== ultracodeLabelIndex,
+  );
   if (labels.length === 0 && fastModeFallbackLabel !== null) {
-    return { label: fastModeFallbackLabel, speedLabel, otherLabels };
+    return { label: fastModeFallbackLabel, speedLabel, ultracode, otherLabels };
   }
   if (speedLabel) {
     if (reasoningLabelIndex >= 0) {
@@ -188,5 +196,5 @@ export function buildTraitsTriggerDisplay(input: {
       labels.push(speedLabel);
     }
   }
-  return { label: labels.join(" · "), speedLabel, otherLabels };
+  return { label: labels.join(" · "), speedLabel, ultracode, otherLabels };
 }

From e8bb4eb199f33558a82332090c0c46e1b82afdf1 Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Thu, 29 Oct 2026 19:37:20 +0100
Subject: [PATCH 05/18] fix(claude): custom models with an Ultracode effort get
 the toggle too

---
 apps/server/src/provider/ClaudeModelCatalog.test.ts | 8 ++++++++
 apps/server/src/provider/ClaudeModelCatalog.ts      | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/apps/server/src/provider/ClaudeModelCatalog.test.ts b/apps/server/src/provider/ClaudeModelCatalog.test.ts
index 2092429f6d556..76436f729fada 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.test.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.test.ts
@@ -4,6 +4,7 @@ import { ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts";
 import { resolveProviderCatalog, type ModelManifestData } from "./ModelManifest.ts";
 import {
   formatClaudeVersionUpgradeMessage,
+  getClaudeCatalogModelCapabilities,
   normalizeClaudeCatalogEffort,
   resolveClaudeCatalogApiModelId,
   resolveClaudeCatalogContextWindowTokens,
@@ -185,6 +186,7 @@ describe("Claude model catalog", () => {
               options: [
                 { id: "gentle", label: "Gentle", isDefault: true },
                 { id: "brutal", label: "Brutal" },
+                { id: "ultracode", label: "Ultracode" },
               ],
             },
           ],
@@ -205,6 +207,12 @@ describe("Claude model catalog", () => {
       resolveClaudeCatalogEffort(catalog, "claude-custom-tuned", "bogus"),
       "gentle",
     );
+    assert.deepStrictEqual(
+      getClaudeCatalogModelCapabilities(catalog, "claude-custom-tuned").optionDescriptors?.map(
+        ({ id, type }) => `${id}:${type}`,
+      ),
+      ["effort:select", "ultracode:boolean"],
+    );
     assert.strictEqual(
       normalizeClaudeCatalogEffort(catalog, "brutal", "claude-custom-tuned"),
       "brutal",
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index dc3adffb14589..736fffa068b61 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -126,7 +126,7 @@ export function scopeClaudeModelCatalog(
         slug: entry.slug,
         name: entry.name,
         isCustom: true,
-        capabilities: entry.capabilities,
+        capabilities: withUltracodeToggle(entry.capabilities),
       },
       runtime: {},
       compatibility: {},

From d242369a521ef6b2c5e96354f92423b9b2794f1a Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 07:04:42 +0000
Subject: [PATCH 06/18] test: cut takeover tests for #27034 to the Ultracode
 toggle behaviour

These are the takeover's tests for the Ultracode-as-toggle change.

- compileClaudeModelSelection: effort + Ultracode compiles as given, an old
  effort "ultracode" reads as xhigh with Ultracode on, and an explicit
  ultracode false is kept.
- delegate_task accepts an old effort "ultracode" request as xhigh + Ultracode.
- Custom Claude models with an Ultracode effort get the toggle.
- Live mid-session changes send the chosen effort with Ultracode.

Dropped the review-round cases: the shared helper test (covered through
compile) and the old-parent delegate override.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/claudeModelOptions.test.ts    | 12 ++++--
 .../src/mcp/OrchestratorMcpService.test.ts    | 22 +---------
 packages/shared/src/model.test.ts             | 40 -------------------
 3 files changed, 10 insertions(+), 64 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.test.ts b/apps/server/src/claudeModelOptions.test.ts
index 6e1986d7a5b18..8e1607115b774 100644
--- a/apps/server/src/claudeModelOptions.test.ts
+++ b/apps/server/src/claudeModelOptions.test.ts
@@ -44,10 +44,14 @@ describe("compileClaudeModelSelection", () => {
         selection("claude-opus-5-5", [{ id: "effort", value: "ultracode" }]),
       ),
     ).toMatchObject({ effort: "xhigh", settings: { ultracode: true } });
-    expect(
-      compileClaudeModelSelection(selection("claude-opus-5-5", [{ id: "effort", value: "high" }]))
-        .settings,
-    ).not.toHaveProperty("ultracode");
+    const legacyTurnedOff = compileClaudeModelSelection(
+      selection("claude-opus-5-5", [
+        { id: "effort", value: "ultracode" },
+        { id: "ultracode", value: false },
+      ]),
+    );
+    expect(legacyTurnedOff.effort).toBe("xhigh");
+    expect(legacyTurnedOff.settings).not.toHaveProperty("ultracode");
   });
 
   it("uses the model default SDK effort alongside prompt-injected effort", () => {
diff --git a/apps/server/src/mcp/OrchestratorMcpService.test.ts b/apps/server/src/mcp/OrchestratorMcpService.test.ts
index 6eb736ec7628d..6ec02c62990d4 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.test.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.test.ts
@@ -2538,26 +2538,8 @@ describe("OrchestratorMcpService provider resolution", () => {
               ],
             },
           },
-          {
-            name: "effort override on an old Ultracode parent",
-            parent: {
-              instanceId: codexInstanceId,
-              model: "ultracode-model",
-              options: [{ id: "effort", value: "ultracode" }],
-            },
-            target: { options: { effort: "high" } },
-            expected: {
-              instanceId: codexInstanceId,
-              model: "ultracode-model",
-              options: [
-                { id: "effort", value: "high" },
-                { id: "ultracode", value: true },
-              ],
-            },
-          },
         ] as const;
         for (const testCase of cases) {
-          const parent = "parent" in testCase ? testCase.parent : inherited;
           const commands: Array<unknown> = [];
           const task = {
             id: taskId,
@@ -2577,7 +2559,7 @@ describe("OrchestratorMcpService provider resolution", () => {
               getThreadRecords: (threadId) =>
                 Effect.succeed(
                   threadId === parentThreadId
-                    ? parentProjection(commands.length > 0 ? [task] : [], parent)
+                    ? parentProjection(commands.length > 0 ? [task] : [], inherited)
                     : childProjection,
                 ),
               dispatch: (command) =>
@@ -2636,7 +2618,7 @@ describe("OrchestratorMcpService provider resolution", () => {
           yield* Effect.gen(function* () {
             const service = yield* OrchestratorMcpService.OrchestratorMcpService;
             const capabilities = yield* service.capabilities(scope);
-            assert.deepEqual(capabilities.inheritedOptions, parent.options);
+            assert.deepEqual(capabilities.inheritedOptions, inherited.options);
             yield* service.delegateTask(scope, {
               task: "Review the change.",
               target: yield* decodeTarget(testCase.target),
diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index b2a9c67643d7e..396d4d9c86c26 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -50,46 +50,6 @@ describe("descriptor helpers", () => {
     ).toEqual([{ id: "fastMode", value: true }]);
   });
 
-  it("reads the old Ultracode effort level as xhigh with the Ultracode toggle on", () => {
-    const caps = createModelCapabilities({
-      optionDescriptors: [
-        {
-          id: "effort",
-          label: "Reasoning",
-          type: "select",
-          options: [
-            { id: "high", label: "High", isDefault: true },
-            { id: "xhigh", label: "Extra High" },
-          ],
-        },
-        { id: "ultracode", label: "Ultracode", type: "boolean" },
-      ],
-    });
-    const selections = [{ id: "effort", value: "ultracode" }];
-
-    expect(
-      buildExplicitProviderOptionSelectionsFromDescriptors(
-        getProviderOptionDescriptors({ caps, selections }),
-        selections,
-      ),
-    ).toEqual([
-      { id: "effort", value: "xhigh" },
-      { id: "ultracode", value: true },
-    ]);
-    expect(
-      getProviderOptionDescriptors({
-        caps,
-        selections: [...selections, { id: "ultracode", value: false }],
-      }).find(({ id }) => id === "ultracode")?.currentValue,
-    ).toBe(false);
-    expect(
-      getProviderOptionDescriptors({
-        caps,
-        selections: [...selections, { id: "ultracode", value: "false" }],
-      }).find(({ id }) => id === "ultracode")?.currentValue,
-    ).toBeUndefined();
-  });
-
   it("compares complete model selections independent of option ordering", () => {
     const left = createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
       { id: "reasoningEffort", value: "high" },

From ebaa59fcabd0df42765f79c05050648142873c78 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 07:12:05 +0000
Subject: [PATCH 07/18] refactor: tighten the legacy Ultracode effort helper

withLegacyUltracodeEffort now accepts missing descriptors and keeps the
caller's selection type, so its call sites drop the `?? []` and
`?? undefined` coercions. The compile path reads the Ultracode descriptor
directly, and the EffortGlyph comment says why the named Ultracode level
stays: older servers still offer it as an effort.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/claudeModelOptions.ts         |  4 +---
 apps/server/src/mcp/OrchestratorMcpService.ts |  7 ++-----
 apps/web/src/components/chat/EffortGlyph.tsx  |  2 +-
 packages/shared/src/model.ts                  | 14 ++++++++------
 4 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.ts b/apps/server/src/claudeModelOptions.ts
index 48b6e0d6115a4..17d55bad70128 100644
--- a/apps/server/src/claudeModelOptions.ts
+++ b/apps/server/src/claudeModelOptions.ts
@@ -46,9 +46,7 @@ export function compileClaudeModelSelection(
   const settings = {
     ...(typeof thinking === "boolean" ? { alwaysThinkingEnabled: thinking } : {}),
     ...(typeof fastMode === "boolean" ? { fastMode } : {}),
-    ...(descriptors.some(
-      (descriptor) => descriptor.id === "ultracode" && descriptor.currentValue === true,
-    )
+    ...(descriptors.find((descriptor) => descriptor.id === "ultracode")?.currentValue === true
       ? { ultracode: true }
       : {}),
   };
diff --git a/apps/server/src/mcp/OrchestratorMcpService.ts b/apps/server/src/mcp/OrchestratorMcpService.ts
index 6af669ff06e7f..ae7ccaaead931 100644
--- a/apps/server/src/mcp/OrchestratorMcpService.ts
+++ b/apps/server/src/mcp/OrchestratorMcpService.ts
@@ -1356,10 +1356,7 @@ const make = Effect.gen(function* () {
 
     const descriptors = provider.models.find((candidate) => candidate.slug === model)?.capabilities
       ?.optionDescriptors;
-    const requestedOptions =
-      input.target?.options === undefined
-        ? undefined
-        : (withLegacyUltracodeEffort(descriptors ?? [], input.target.options) ?? []);
+    const requestedOptions = withLegacyUltracodeEffort(descriptors, input.target?.options);
     if (requestedOptions !== undefined) {
       const invalid = invalidOptionSelections(requestedOptions, descriptors);
       if (invalid.length > 0) {
@@ -1373,7 +1370,7 @@ const make = Effect.gen(function* () {
     const inheritsOptions =
       instanceId === inheritedSelection.instanceId && model === inheritedSelection.model;
     let options = inheritsOptions
-      ? (withLegacyUltracodeEffort(descriptors ?? [], inheritedSelection.options) ?? undefined)
+      ? withLegacyUltracodeEffort(descriptors, inheritedSelection.options)
       : undefined;
     if (requestedOptions !== undefined) {
       const selections = new Map(
diff --git a/apps/web/src/components/chat/EffortGlyph.tsx b/apps/web/src/components/chat/EffortGlyph.tsx
index 2e033c6caa8da..a7ebd8d42a4e2 100644
--- a/apps/web/src/components/chat/EffortGlyph.tsx
+++ b/apps/web/src/components/chat/EffortGlyph.tsx
@@ -9,7 +9,7 @@ const BASELINE_INSET = 2;
 
 type SelectDescriptor = Extract<ProviderOptionDescriptor, { type: "select" }>;
 
-// Ultracode changes the workflow, not only intensity, so it keeps its name like Ultrathink.
+// Older servers offer Ultracode as a level. It changes the workflow, so it keeps its name.
 // Max is named too, so the full scale stops short of it.
 const NAMED_LEVELS = new Set(["ultracode", "max"]);
 const OFF_LEVELS = new Set(["off", "none"]);
diff --git a/packages/shared/src/model.ts b/packages/shared/src/model.ts
index 9e1fe36721653..0fdb2bc71ec4f 100644
--- a/packages/shared/src/model.ts
+++ b/packages/shared/src/model.ts
@@ -197,13 +197,15 @@ function withDescriptorCurrentValue(
 }
 
 // Ultracode was a Claude effort level before it became its own toggle; that level ran at xhigh.
-export function withLegacyUltracodeEffort(
-  descriptors: ReadonlyArray<ProviderOptionDescriptor>,
-  selections: ReadonlyArray<ProviderOptionSelection> | null | undefined,
-): ReadonlyArray<ProviderOptionSelection> | null | undefined {
+export function withLegacyUltracodeEffort<
+  Selections extends ReadonlyArray<ProviderOptionSelection> | null | undefined,
+>(
+  descriptors: ReadonlyArray<ProviderOptionDescriptor> | null | undefined,
+  selections: Selections,
+): Selections | Array<ProviderOptionSelection> {
   if (
     getRawSelectionValueById(selections, "effort") !== "ultracode" ||
-    !descriptors.some(
+    !descriptors?.some(
       (descriptor) => descriptor.id === "ultracode" && descriptor.type === "boolean",
     )
   ) {
@@ -339,7 +341,7 @@ export function buildExplicitProviderOptionSelectionsFromDescriptors(
     return undefined;
   }
   const explicitIds = new Set(
-    (withLegacyUltracodeEffort(descriptors ?? [], selections) ?? []).map(({ id }) => id),
+    withLegacyUltracodeEffort(descriptors, selections).map(({ id }) => id),
   );
   const normalized = buildProviderOptionSelectionsFromDescriptors(descriptors)?.filter(
     (selection) => explicitIds.has(selection.id),

From db134efc833dcb3660be13d8ca7662c9bff1b612 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 07:25:35 +0000
Subject: [PATCH 08/18] test(shared): old Ultracode effort dispatches as xhigh
 with the toggle

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/shared/src/model.test.ts | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/packages/shared/src/model.test.ts b/packages/shared/src/model.test.ts
index 396d4d9c86c26..af6af0254a94d 100644
--- a/packages/shared/src/model.test.ts
+++ b/packages/shared/src/model.test.ts
@@ -50,6 +50,32 @@ describe("descriptor helpers", () => {
     ).toEqual([{ id: "fastMode", value: true }]);
   });
 
+  it("dispatches an old Ultracode effort as Extra High with the Ultracode toggle", () => {
+    const legacy = [{ id: "effort", value: "ultracode" }];
+    const descriptors = getProviderOptionDescriptors({
+      caps: createModelCapabilities({
+        optionDescriptors: [
+          {
+            id: "effort",
+            label: "Reasoning",
+            type: "select",
+            options: [
+              { id: "high", label: "High", isDefault: true },
+              { id: "xhigh", label: "Extra High" },
+            ],
+          },
+          { id: "ultracode", label: "Ultracode", type: "boolean" },
+        ],
+      }),
+      selections: legacy,
+    });
+
+    expect(buildExplicitProviderOptionSelectionsFromDescriptors(descriptors, legacy)).toEqual([
+      { id: "effort", value: "xhigh" },
+      { id: "ultracode", value: true },
+    ]);
+  });
+
   it("compares complete model selections independent of option ordering", () => {
     const left = createModelSelection(ProviderInstanceId.make("codex"), "gpt-5.4", [
       { id: "reasoningEffort", value: "high" },

From e8931dafeb529664b3adcb32a06390040cfb8e9e Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 07:36:43 +0000
Subject: [PATCH 09/18] fix(client-runtime): old Ultracode threads keep their
 effort label

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/state/threadExecution.test.ts         | 35 +++++++++++++++++++
 .../src/state/threadExecution.ts              | 12 +++++--
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/packages/client-runtime/src/state/threadExecution.test.ts b/packages/client-runtime/src/state/threadExecution.test.ts
index 8ef37f959cd40..33aee2b40d63a 100644
--- a/packages/client-runtime/src/state/threadExecution.test.ts
+++ b/packages/client-runtime/src/state/threadExecution.test.ts
@@ -14,6 +14,7 @@ import {
   type OrchestrationV2RunStatus,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
+import { createModelCapabilities, createModelSelection } from "@t3tools/shared/model";
 import { usageLimitBlockedRun } from "@t3tools/shared/orchestrationV2ThreadError";
 import { describe, expect, it } from "vite-plus/test";
 
@@ -25,6 +26,7 @@ import {
   deriveRunlessWorkStartedAt,
   deriveThreadActivityRun,
   deriveThreadRuntime,
+  formatModelSelectionEffort,
   threadRuntimeHasInterruptibleRun,
 } from "./threadExecution.ts";
 
@@ -393,3 +395,36 @@ describe("provider-reported model selection", () => {
     ).toBeNull();
   });
 });
+
+describe("formatModelSelectionEffort", () => {
+  it("labels an old Ultracode effort by the effort it runs at", () => {
+    const models = [
+      {
+        slug: "claude-opus-5-5",
+        name: "Claude Opus 5.5",
+        isCustom: false,
+        capabilities: createModelCapabilities({
+          optionDescriptors: [
+            {
+              id: "effort",
+              label: "Reasoning",
+              type: "select",
+              options: [
+                { id: "high", label: "High", isDefault: true },
+                { id: "xhigh", label: "Extra High" },
+              ],
+            },
+            { id: "ultracode", label: "Ultracode", type: "boolean" },
+          ],
+        }),
+      },
+    ];
+    const selection = createModelSelection(
+      ProviderInstanceId.make("claudeAgent"),
+      "claude-opus-5-5",
+      [{ id: "effort", value: "ultracode" }],
+    );
+
+    expect(formatModelSelectionEffort(selection, models)).toBe("Extra High");
+  });
+});
diff --git a/packages/client-runtime/src/state/threadExecution.ts b/packages/client-runtime/src/state/threadExecution.ts
index ba87930bebbd5..ba17cfbffea37 100644
--- a/packages/client-runtime/src/state/threadExecution.ts
+++ b/packages/client-runtime/src/state/threadExecution.ts
@@ -22,7 +22,11 @@ import {
   backgroundWorkHoldsCompletion,
   derivePendingBackgroundWork,
 } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
-import { getProviderOptionCurrentLabel, getProviderOptionStatedValue } from "@t3tools/shared/model";
+import {
+  getProviderOptionCurrentLabel,
+  getProviderOptionStatedValue,
+  withLegacyUltracodeEffort,
+} from "@t3tools/shared/model";
 import { formatDuration } from "@t3tools/shared/orchestrationTiming";
 import * as DateTime from "effect/DateTime";
 
@@ -161,16 +165,18 @@ export function formatModelSelectionEffort(
 ): string | null {
   const caps = models.find((model) => model.slug === selection.model)?.capabilities;
   if (!caps) return null;
+  const options = withLegacyUltracodeEffort(caps.optionDescriptors, selection.options);
+  const current = options ? { ...selection, options } : selection;
   for (const id of REASONING_EFFORT_OPTION_IDS) {
     const descriptor = caps.optionDescriptors?.find((candidate) => candidate.id === id);
     if (descriptor?.type !== "select") continue;
-    const value = getProviderOptionStatedValue(id, selection, reportedSelection);
+    const value = getProviderOptionStatedValue(id, current, reportedSelection);
     if (value === undefined && id !== "variant") continue;
     if (typeof value === "boolean") continue;
     // Bypass picker normalization so an obsolete choice cannot become a catalog default.
     const label = getProviderOptionCurrentLabel(
       { ...descriptor, currentValue: value },
-      selection,
+      current,
       reportedSelection,
     );
     if (label) return label;

From 8100802afc1158a9d7a912c1240a0eafb6ba58b0 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 07:57:17 +0000
Subject: [PATCH 10/18] fix(claude): keep the Ultracode toggle to the bundled
 catalog

Custom model capabilities reach clients through the provider snapshot and
never through the scoped catalog, so converting them only there left text
generation disagreeing with what the picker showed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/provider/ClaudeModelCatalog.test.ts | 8 --------
 apps/server/src/provider/ClaudeModelCatalog.ts      | 2 +-
 2 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/apps/server/src/provider/ClaudeModelCatalog.test.ts b/apps/server/src/provider/ClaudeModelCatalog.test.ts
index 76436f729fada..2092429f6d556 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.test.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.test.ts
@@ -4,7 +4,6 @@ import { ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts";
 import { resolveProviderCatalog, type ModelManifestData } from "./ModelManifest.ts";
 import {
   formatClaudeVersionUpgradeMessage,
-  getClaudeCatalogModelCapabilities,
   normalizeClaudeCatalogEffort,
   resolveClaudeCatalogApiModelId,
   resolveClaudeCatalogContextWindowTokens,
@@ -186,7 +185,6 @@ describe("Claude model catalog", () => {
               options: [
                 { id: "gentle", label: "Gentle", isDefault: true },
                 { id: "brutal", label: "Brutal" },
-                { id: "ultracode", label: "Ultracode" },
               ],
             },
           ],
@@ -207,12 +205,6 @@ describe("Claude model catalog", () => {
       resolveClaudeCatalogEffort(catalog, "claude-custom-tuned", "bogus"),
       "gentle",
     );
-    assert.deepStrictEqual(
-      getClaudeCatalogModelCapabilities(catalog, "claude-custom-tuned").optionDescriptors?.map(
-        ({ id, type }) => `${id}:${type}`,
-      ),
-      ["effort:select", "ultracode:boolean"],
-    );
     assert.strictEqual(
       normalizeClaudeCatalogEffort(catalog, "brutal", "claude-custom-tuned"),
       "brutal",
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index 736fffa068b61..dc3adffb14589 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -126,7 +126,7 @@ export function scopeClaudeModelCatalog(
         slug: entry.slug,
         name: entry.name,
         isCustom: true,
-        capabilities: withUltracodeToggle(entry.capabilities),
+        capabilities: entry.capabilities,
       },
       runtime: {},
       compatibility: {},

From fb66fca9c433f0fce4d54f2bb2c24b05f0c052fc Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Fri, 30 Oct 2026 08:43:57 +0000
Subject: [PATCH 11/18] Revert "fix(claude): keep the Ultracode toggle to the
 bundled catalog"

Text generation reads custom models through the scoped catalog, so without
the toggle there a custom model's legacy Ultracode effort lost the Ultracode
flag it had on main.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/provider/ClaudeModelCatalog.test.ts | 8 ++++++++
 apps/server/src/provider/ClaudeModelCatalog.ts      | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/apps/server/src/provider/ClaudeModelCatalog.test.ts b/apps/server/src/provider/ClaudeModelCatalog.test.ts
index 2092429f6d556..76436f729fada 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.test.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.test.ts
@@ -4,6 +4,7 @@ import { ProviderDriverKind, ProviderInstanceId } from "@t3tools/contracts";
 import { resolveProviderCatalog, type ModelManifestData } from "./ModelManifest.ts";
 import {
   formatClaudeVersionUpgradeMessage,
+  getClaudeCatalogModelCapabilities,
   normalizeClaudeCatalogEffort,
   resolveClaudeCatalogApiModelId,
   resolveClaudeCatalogContextWindowTokens,
@@ -185,6 +186,7 @@ describe("Claude model catalog", () => {
               options: [
                 { id: "gentle", label: "Gentle", isDefault: true },
                 { id: "brutal", label: "Brutal" },
+                { id: "ultracode", label: "Ultracode" },
               ],
             },
           ],
@@ -205,6 +207,12 @@ describe("Claude model catalog", () => {
       resolveClaudeCatalogEffort(catalog, "claude-custom-tuned", "bogus"),
       "gentle",
     );
+    assert.deepStrictEqual(
+      getClaudeCatalogModelCapabilities(catalog, "claude-custom-tuned").optionDescriptors?.map(
+        ({ id, type }) => `${id}:${type}`,
+      ),
+      ["effort:select", "ultracode:boolean"],
+    );
     assert.strictEqual(
       normalizeClaudeCatalogEffort(catalog, "brutal", "claude-custom-tuned"),
       "brutal",
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index dc3adffb14589..736fffa068b61 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -126,7 +126,7 @@ export function scopeClaudeModelCatalog(
         slug: entry.slug,
         name: entry.name,
         isCustom: true,
-        capabilities: entry.capabilities,
+        capabilities: withUltracodeToggle(entry.capabilities),
       },
       runtime: {},
       compatibility: {},

From 10640b1f55d1dcb30cb11d44d57a00542c69e558 Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Fri, 30 Oct 2026 18:24:08 +0100
Subject: [PATCH 12/18] fix(claude): Ultracode off overrides an Ultracode
 launch setting

Send ultracode: false when the toggle is off, so a --settings launch argument
that turns Ultracode on no longer wins. An unset toggle still sends nothing.
---
 apps/server/src/claudeModelOptions.test.ts             | 6 +++++-
 apps/server/src/claudeModelOptions.ts                  | 5 ++---
 apps/server/src/textGeneration/ClaudeTextGeneration.ts | 4 ++--
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.test.ts b/apps/server/src/claudeModelOptions.test.ts
index 8e1607115b774..e41243814abce 100644
--- a/apps/server/src/claudeModelOptions.test.ts
+++ b/apps/server/src/claudeModelOptions.test.ts
@@ -51,7 +51,11 @@ describe("compileClaudeModelSelection", () => {
       ]),
     );
     expect(legacyTurnedOff.effort).toBe("xhigh");
-    expect(legacyTurnedOff.settings).not.toHaveProperty("ultracode");
+    expect(legacyTurnedOff.settings.ultracode).toBe(false);
+    expect(
+      compileClaudeModelSelection(selection("claude-opus-5-5", [{ id: "effort", value: "high" }]))
+        .settings,
+    ).not.toHaveProperty("ultracode");
   });
 
   it("uses the model default SDK effort alongside prompt-injected effort", () => {
diff --git a/apps/server/src/claudeModelOptions.ts b/apps/server/src/claudeModelOptions.ts
index 17d55bad70128..7d815f5f9af55 100644
--- a/apps/server/src/claudeModelOptions.ts
+++ b/apps/server/src/claudeModelOptions.ts
@@ -43,12 +43,11 @@ export function compileClaudeModelSelection(
   const thinking = supportsBoolean("thinking")
     ? getModelSelectionBooleanOptionValue(selection, "thinking")
     : undefined;
+  const ultracode = descriptors.find((descriptor) => descriptor.id === "ultracode")?.currentValue;
   const settings = {
     ...(typeof thinking === "boolean" ? { alwaysThinkingEnabled: thinking } : {}),
     ...(typeof fastMode === "boolean" ? { fastMode } : {}),
-    ...(descriptors.find((descriptor) => descriptor.id === "ultracode")?.currentValue === true
-      ? { ultracode: true }
-      : {}),
+    ...(typeof ultracode === "boolean" ? { ultracode } : {}),
   };
   const apiModelId = resolveClaudeCatalogApiModelId(catalog, selection);
   const promptEffort = resolvePromptInjectedEffort(capabilities, rawEffort) ?? undefined;
diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
index e26e59bdd0807..be8daac999653 100644
--- a/apps/server/src/textGeneration/ClaudeTextGeneration.ts
+++ b/apps/server/src/textGeneration/ClaudeTextGeneration.ts
@@ -158,7 +158,7 @@ export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(fu
       resolvedEffort,
       resolvedModelSelection.model,
     );
-    const ultracode = findDescriptor("ultracode")?.currentValue === true;
+    const ultracode = findDescriptor("ultracode")?.currentValue;
     const thinkingDescriptor = findDescriptor("thinking");
     const fastModeDescriptor = findDescriptor("fastMode");
     // Only a chosen value; otherwise Claude Code's own default applies, as in chat turns.
@@ -172,7 +172,7 @@ export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(fu
       disableAllHooks: true,
       ...(typeof thinking === "boolean" ? { alwaysThinkingEnabled: thinking } : {}),
       ...(fastMode ? { fastMode: true } : {}),
-      ...(ultracode ? { ultracode: true } : {}),
+      ...(typeof ultracode === "boolean" ? { ultracode } : {}),
     };
     const settingsJson = yield* encodeJsonForOperation(
       operation,

From ca16edac90758f839c03008dec89d2ad3f2ff0f7 Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Sun, 1 Nov 2026 16:08:48 +0100
Subject: [PATCH 13/18] feat(web,mobile): workflow hover cards show the model
 and effort

Workflow agents pass their reported effort and speed to the hover card, and a
workflow card falls back to the model it runs on instead of "Not reported".
Mobile agent rows show the same effort.
---
 .../src/features/threads/SubagentRow.tsx      | 15 ++++++++++-
 .../threads/thread-subagent-group.tsx         |  1 +
 .../threads/thread-workflow-opening.tsx       |  2 ++
 .../chat/SubagentTooltipContent.tsx           | 16 ++++++------
 .../chat/ThreadLineageWorkflowRow.tsx         |  8 +++---
 .../components/chat/WorkflowOpeningBlock.tsx  |  2 ++
 .../src/state/subagentDisplay.ts              |  6 +++--
 .../src/state/subagentRuntime.test.ts         | 25 +++++++++++++++++++
 .../src/state/subagentRuntime.ts              | 16 ++++++++++++
 9 files changed, 77 insertions(+), 14 deletions(-)

diff --git a/apps/mobile/src/features/threads/SubagentRow.tsx b/apps/mobile/src/features/threads/SubagentRow.tsx
index a888adb8273fb..9719a69668e65 100644
--- a/apps/mobile/src/features/threads/SubagentRow.tsx
+++ b/apps/mobile/src/features/threads/SubagentRow.tsx
@@ -1,7 +1,9 @@
 import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { resolveProviderInstanceDisplayName } from "@t3tools/client-runtime/state/provider-instance-display";
 import { resolveSubagentMetadata } from "@t3tools/client-runtime/state/subagent-display";
+import { formatModelSelectionEffort } from "@t3tools/client-runtime/state/thread-execution";
 import type { EnvironmentId, OrchestrationV2Subagent } from "@t3tools/contracts";
+import { resolveSelectableModel } from "@t3tools/shared/model";
 import type { ReactNode } from "react";
 import { View } from "react-native";
 
@@ -19,6 +21,7 @@ type SubagentRowSubagent = Pick<
   | "threadId"
   | "childThreadId"
   | "model"
+  | "modelSelection"
   | "driver"
   | "providerInstanceId"
   | "title"
@@ -113,14 +116,23 @@ function SubagentMetadata(props: {
     parent ? scopeProjectRef(environmentId, parent.projectId) : null,
   );
   const childProject = useProject(child ? scopeProjectRef(environmentId, child.projectId) : null);
-  const { modelLabel, workspace } = resolveSubagentMetadata({
+  const selection = subagent.modelSelection;
+  const { modelLabel, modelSlug, workspace } = resolveSubagentMetadata({
     model: subagent.model,
+    modelSelection: selection,
     provider,
     parentThread: parent,
     childThread: child,
     parentProject,
     childProject,
   });
+  const effort =
+    provider &&
+    selection &&
+    modelSlug &&
+    resolveSelectableModel(provider.driver, selection.model, provider.models) === modelSlug
+      ? formatModelSelectionEffort({ ...selection, model: modelSlug }, provider.models)
+      : null;
   return (
     <View className="min-w-0 flex-row items-center gap-1.5">
       <ProviderIcon
@@ -131,6 +143,7 @@ function SubagentMetadata(props: {
       <Text className="min-w-0 shrink text-xs text-foreground-muted" numberOfLines={1}>
         {provider ? `${resolveProviderInstanceDisplayName(provider)} · ` : ""}
         {modelLabel}
+        {effort ? ` · ${effort}` : ""}
       </Text>
       {workspace.map(({ label, value }) => (
         // Preserve the label against flattening without making it a separate accessibility stop.
diff --git a/apps/mobile/src/features/threads/thread-subagent-group.tsx b/apps/mobile/src/features/threads/thread-subagent-group.tsx
index cabd4eeb371bb..4889bf323287d 100644
--- a/apps/mobile/src/features/threads/thread-subagent-group.tsx
+++ b/apps/mobile/src/features/threads/thread-subagent-group.tsx
@@ -92,6 +92,7 @@ export function ThreadSubagentGroup(props: {
       result: live?.result ?? item.result,
       progress: live?.progress ?? item.progress,
       model: live?.model ?? null,
+      modelSelection: live?.modelSelection,
     };
   });
   const grouped = agents.length > 1;
diff --git a/apps/mobile/src/features/threads/thread-workflow-opening.tsx b/apps/mobile/src/features/threads/thread-workflow-opening.tsx
index b16a82b7190d9..9919e2e9854b7 100644
--- a/apps/mobile/src/features/threads/thread-workflow-opening.tsx
+++ b/apps/mobile/src/features/threads/thread-workflow-opening.tsx
@@ -2,6 +2,7 @@ import { useAtomValue } from "@effect/atom-react";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import {
   resolveWorkflowOpening,
+  workflowMemberModelSelection,
   workflowOpeningHeadline,
   workflowOpeningParentThreadId,
   type RuntimeSubagent,
@@ -63,6 +64,7 @@ function memberRowSubagent(
     threadId: coordinatorThreadId,
     childThreadId: member.childThreadId as ThreadId | null,
     model: member.model,
+    modelSelection: workflowMemberModelSelection(member, opening.providerInstanceId!),
     driver: opening.driver!,
     providerInstanceId: opening.providerInstanceId!,
     title: member.title,
diff --git a/apps/web/src/components/chat/SubagentTooltipContent.tsx b/apps/web/src/components/chat/SubagentTooltipContent.tsx
index a965e89efd728..5b5f8b3477420 100644
--- a/apps/web/src/components/chat/SubagentTooltipContent.tsx
+++ b/apps/web/src/components/chat/SubagentTooltipContent.tsx
@@ -50,16 +50,16 @@ export function SubagentTooltipContent(props: {
   result?: string | null | undefined;
   progress?: string | null | undefined;
 }) {
-  const { modelLabel, workspace: metadata } = resolveSubagentMetadata(props);
-  const preview = subagentDetailPreview(props);
-  const model = props.model?.trim();
-  const modelSlug = props.provider
-    ? resolveSelectableModel(props.provider.driver, model, props.provider.models)
-    : model;
-  const providerModel = props.provider?.models.find((candidate) => candidate.slug === modelSlug);
   const childSelection =
     props.modelSelection ??
     (props.origin === "app_owned" ? props.childThread?.modelSelection : undefined);
+  const {
+    modelLabel,
+    modelSlug,
+    workspace: metadata,
+  } = resolveSubagentMetadata({ ...props, modelSelection: childSelection });
+  const preview = subagentDetailPreview(props);
+  const providerModel = props.provider?.models.find((candidate) => candidate.slug === modelSlug);
   const childModel = props.provider
     ? (resolveSelectableModel(
         props.provider.driver,
@@ -69,7 +69,7 @@ export function SubagentTooltipContent(props: {
     : childSelection?.model.trim();
   const provider = props.provider;
   const matchingSelection =
-    childModel === (modelSlug ?? model) && childSelection?.instanceId === props.providerInstanceId
+    childModel === modelSlug && childSelection?.instanceId === props.providerInstanceId
       ? childSelection
       : undefined;
   const effort = REASONING_EFFORT_OPTION_IDS.map((id) =>
diff --git a/apps/web/src/components/chat/ThreadLineageWorkflowRow.tsx b/apps/web/src/components/chat/ThreadLineageWorkflowRow.tsx
index f1df96dd92133..adfd3453eeb64 100644
--- a/apps/web/src/components/chat/ThreadLineageWorkflowRow.tsx
+++ b/apps/web/src/components/chat/ThreadLineageWorkflowRow.tsx
@@ -1,6 +1,7 @@
-import type {
-  SubagentWorkflowGroup,
-  RuntimeSubagent,
+import {
+  workflowMemberModelSelection,
+  type SubagentWorkflowGroup,
+  type RuntimeSubagent,
 } from "@t3tools/client-runtime/state/subagentRuntime";
 import type { ProviderDriverKind, ProviderInstanceId, ServerProvider } from "@t3tools/contracts";
 import { ChevronDownIcon, SquareIcon } from "lucide-react";
@@ -95,6 +96,7 @@ function WorkflowMemberRow({
             model={member.model}
             providerInstanceId={providerInstanceId}
             origin="provider_native"
+            modelSelection={workflowMemberModelSelection(member, providerInstanceId)}
             provider={provider}
             providers={providers}
             driver={driver}
diff --git a/apps/web/src/components/chat/WorkflowOpeningBlock.tsx b/apps/web/src/components/chat/WorkflowOpeningBlock.tsx
index 3ab51f077e060..c6be9690e9940 100644
--- a/apps/web/src/components/chat/WorkflowOpeningBlock.tsx
+++ b/apps/web/src/components/chat/WorkflowOpeningBlock.tsx
@@ -1,6 +1,7 @@
 import { useAtomValue } from "@effect/atom-react";
 import {
   isTerminalSubagentStatus,
+  workflowMemberModelSelection,
   workflowOpeningHeadline,
   type RuntimeSubagent,
   type WorkflowOpening,
@@ -183,6 +184,7 @@ function WorkflowMemberRow(props: {
             model={member.model}
             providerInstanceId={props.providerInstanceId}
             origin="provider_native"
+            modelSelection={workflowMemberModelSelection(member, props.providerInstanceId)}
             provider={props.providers.find(
               (provider) => provider.instanceId === props.providerInstanceId,
             )}
diff --git a/packages/client-runtime/src/state/subagentDisplay.ts b/packages/client-runtime/src/state/subagentDisplay.ts
index 295e557fc8ff8..59db3cb13753b 100644
--- a/packages/client-runtime/src/state/subagentDisplay.ts
+++ b/packages/client-runtime/src/state/subagentDisplay.ts
@@ -1,4 +1,5 @@
 import type {
+  ModelSelection,
   OrchestrationV2TurnItemStatus,
   OrchestrationV2ThreadShell,
   OrchestrationProjectShell,
@@ -50,6 +51,7 @@ export function formatSubagentDisplayTitle(title: string): string {
 
 export function resolveSubagentMetadata(input: {
   readonly model: string | null;
+  readonly modelSelection?: Pick<ModelSelection, "model"> | undefined;
   readonly provider?: Pick<ServerProvider, "driver" | "models"> | null | undefined;
   readonly parentThread?:
     | Pick<OrchestrationV2ThreadShell, "projectId" | "worktreePath">
@@ -65,7 +67,7 @@ export function resolveSubagentMetadata(input: {
     | null
     | undefined;
 }) {
-  const model = input.model?.trim();
+  const model = input.model?.trim() || input.modelSelection?.model.trim();
   const slug = input.provider
     ? resolveSelectableModel(input.provider.driver, model, input.provider.models)
     : model;
@@ -108,7 +110,7 @@ export function resolveSubagentMetadata(input: {
         ]
       : []),
   ];
-  return { modelLabel, workspace };
+  return { modelLabel, modelSlug: slug ?? model ?? null, workspace };
 }
 
 export function subagentDetailPreview(input: {
diff --git a/packages/client-runtime/src/state/subagentRuntime.test.ts b/packages/client-runtime/src/state/subagentRuntime.test.ts
index c40c9fe42d81e..0bdc1e8e0eadb 100644
--- a/packages/client-runtime/src/state/subagentRuntime.test.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.test.ts
@@ -13,7 +13,9 @@ import {
   isWorkflowScriptMessage,
   projectedSubagentsToRuntime,
   resolveWorkflowOpening,
+  workflowMemberModelSelection,
 } from "./subagentRuntime.ts";
+import { resolveSubagentMetadata } from "./subagentDisplay.ts";
 
 const at = (iso: string) => DateTime.makeUnsafe(iso);
 
@@ -82,6 +84,29 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
     expect(settled?.speed).toBe("standard");
     expect(settled?.progress).toBe("Reply with exactly: A1");
     expect(settled?.usage).toEqual({ totalTokens: 71_141, toolUses: 3, durationMs: 1500 });
+    const instanceId = ProviderInstanceId.make("claudeAgent");
+    expect(workflowMemberModelSelection(settled!, instanceId)).toEqual({
+      instanceId,
+      model: "claude-opus-5[1m]",
+      options: [
+        { id: "effort", value: "xhigh" },
+        { id: "fastMode", value: false },
+      ],
+    });
+    expect(workflowMemberModelSelection({ model: null, effort: "xhigh" }, instanceId)).toBe(
+      undefined,
+    );
+  });
+
+  it("names a workflow by the model it runs on when the provider reports none", () => {
+    const [workflow] = projectedSubagentsToRuntime([subagent({ model: null })]);
+    expect(
+      resolveSubagentMetadata({
+        model: workflow!.model,
+        modelSelection: { model: "claude-opus-5-5" },
+      }).modelLabel,
+    ).toBe("Claude Opus 5.5");
+    expect(resolveSubagentMetadata({ model: workflow!.model }).modelLabel).toBe("Not reported");
   });
 
   it.each(["completed", "cancelled", "failed"] as const)(
diff --git a/packages/client-runtime/src/state/subagentRuntime.ts b/packages/client-runtime/src/state/subagentRuntime.ts
index e3807362fbdf6..fac58a029ce62 100644
--- a/packages/client-runtime/src/state/subagentRuntime.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.ts
@@ -1,6 +1,7 @@
 import { groupBy } from "effect/Array";
 import * as DateTime from "effect/DateTime";
 import type {
+  ModelSelection,
   OrchestrationV2AppThread,
   OrchestrationV2Subagent,
   OrchestrationV2SubagentWorkflow,
@@ -175,6 +176,21 @@ function workflowMembersToRuntime(
   });
 }
 
+export function workflowMemberModelSelection(
+  member: Pick<RuntimeSubagent, "model" | "effort" | "speed">,
+  instanceId: ModelSelection["instanceId"],
+): ModelSelection | undefined {
+  if (!member.model) return undefined;
+  return {
+    instanceId,
+    model: member.model,
+    options: [
+      ...(member.effort ? [{ id: "effort", value: member.effort }] : []),
+      ...(member.speed ? [{ id: "fastMode", value: member.speed === "fast" }] : []),
+    ],
+  };
+}
+
 export function projectedSubagentsToRuntime(
   subagents: ReadonlyArray<{
     readonly id: string;

From 87131ceb1986b2878759d19f8ebbcd48c3efd01e Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Sun, 1 Nov 2026 18:35:50 +0100
Subject: [PATCH 14/18] feat(web): Ultracode sits beside Standard and Fast in
 the model picker

The Ultracode switch moves from the effort column to the picker footer, as
one button next to the speed control. The effort column now lists only
reasoning levels.
---
 .../components/chat/ComposerModelEffort.tsx   | 34 +++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/apps/web/src/components/chat/ComposerModelEffort.tsx b/apps/web/src/components/chat/ComposerModelEffort.tsx
index 0661696436f8a..35fd11c98be7c 100644
--- a/apps/web/src/components/chat/ComposerModelEffort.tsx
+++ b/apps/web/src/components/chat/ComposerModelEffort.tsx
@@ -36,7 +36,7 @@ import {
 type SelectDescriptor = Extract<ProviderOptionDescriptor, { type: "select" }>;
 type BooleanDescriptor = Extract<ProviderOptionDescriptor, { type: "boolean" }>;
 
-/** Codex service tiers and Claude's Fast mode share the footer's speed control. */
+/** Codex service tiers, Claude's Fast mode, and Ultracode sit in the footer, not the column. */
 function splitSpeed(
   provider: TraitsSelectionInput["provider"],
   selects: ReadonlyArray<SelectDescriptor>,
@@ -47,11 +47,15 @@ function splitSpeed(
       ? (selects.find((descriptor) => descriptor.id === "serviceTier") ?? null)
       : null;
   const fastToggle = toggles.find((descriptor) => descriptor.id === "fastMode") ?? null;
+  const ultracodeToggle = toggles.find((descriptor) => descriptor.id === "ultracode") ?? null;
   return {
     speedSelect,
     fastToggle,
+    ultracodeToggle,
     columnSelects: selects.filter((descriptor) => descriptor !== speedSelect),
-    columnToggles: toggles.filter((descriptor) => descriptor !== fastToggle),
+    columnToggles: toggles.filter(
+      (descriptor) => descriptor !== fastToggle && descriptor !== ultracodeToggle,
+    ),
   };
 }
 
@@ -600,6 +604,31 @@ function SpeedControl(props: { traits: TraitsSelectionInput }) {
   );
 }
 
+function UltracodeControl(props: { traits: TraitsSelectionInput }) {
+  const traits = useTraitsSelection(props.traits);
+  const { ultracodeToggle } = splitSpeed(
+    props.traits.provider,
+    traits.selectDescriptors,
+    traits.booleanDescriptors,
+  );
+  if (traits.modelIsUnavailable || !ultracodeToggle) return null;
+  const on = ultracodeToggle.currentValue === true;
+  return (
+    <div className="flex rounded-lg bg-input/40 p-0.5">
+      <button
+        type="button"
+        aria-pressed={on}
+        data-checked={on || undefined}
+        className={FOOTER_SEGMENT}
+        onClick={() => traits.changeBoolean(ultracodeToggle.id, !on)}
+      >
+        <WorkflowIcon aria-hidden="true" className="size-3" />
+        {ultracodeToggle.label}
+      </button>
+    </div>
+  );
+}
+
 /** Permissions change rarely, so the footer names the mode and nests the choice in a menu. */
 function PermissionsMenu(props: {
   runtimeMode: RuntimeMode;
@@ -652,6 +681,7 @@ export function ComposerPickerFooter(props: {
   return (
     <div className="flex flex-wrap items-center gap-2 border-t border-border/70 bg-muted/40 px-3 py-2">
       {props.traits ? <SpeedControl traits={props.traits} /> : null}
+      {props.traits ? <UltracodeControl traits={props.traits} /> : null}
       <PermissionsMenu
         runtimeMode={props.runtimeMode}
         options={props.runtimeModeOptions}

From 01b9c2c214402d96dfe34c8c19110001fda42c52 Mon Sep 17 00:00:00 2001
From: Bil0000 <62337003+Bil0000@users.noreply.github.com>
Date: Mon, 2 Nov 2026 21:18:17 +0100
Subject: [PATCH 15/18] chore(claude): recommend Claude Code 2.1.284 for
 Ultracode at any effort

Claude Code 2.1.284 is the first release that runs Ultracode at an effort
other than xhigh. Versions from 2.1.280 stay supported.
---
 apps/server/src/provider/model-manifest.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/server/src/provider/model-manifest.json b/apps/server/src/provider/model-manifest.json
index 87ed61776ea9c..1506d8f9b8100 100644
--- a/apps/server/src/provider/model-manifest.json
+++ b/apps/server/src/provider/model-manifest.json
@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "updatedAt": "2026-10-28T08:10:39Z",
+  "updatedAt": "2026-11-02T20:15:39Z",
   "compatibility": [
     {
       "driver": "codex",
@@ -25,7 +25,7 @@
     {
       "driver": "claudeAgent",
       "t3CodeRange": ">=0.0.42",
-      "recommendedRange": ">=2.1.280",
+      "recommendedRange": ">=2.1.284",
       "ranges": [
         { "range": ">=2.1.280", "status": "supported" },
         { "range": ">=2.1.111 <2.1.280", "status": "graceful" },

From 193ad89c724604fa5ea81abd97e28801b14937fc Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Tue, 3 Nov 2026 18:28:28 +0000
Subject: [PATCH 16/18] fix(claude): custom models get the Ultracode toggle
 everywhere

Provider discovery now advertises custom Claude models with Ultracode as
a boolean option, as built-in models are. Main turns compile their model
selection against the catalog scoped to the instance's custom models, so
High + Ultracode on a custom model reaches the SDK as `ultracode: true`.

Mobile workflow member rows keep the reported effort when the model is a
raw API id such as `claude-opus-5[1m]` that the picker catalog lacks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/features/threads/SubagentRow.tsx      | 11 +---
 .../Adapters/ClaudeAdapterV2.test.ts          | 60 +++++++++++++++++++
 .../Adapters/ClaudeAdapterV2.ts               | 28 +++++----
 .../server/src/provider/ClaudeModelCatalog.ts |  4 +-
 apps/server/src/provider/ClaudeProvider.ts    | 24 ++++++--
 .../src/provider/ProviderRegistry.test.ts     | 46 ++++++++++++++
 .../src/state/subagentRuntime.test.ts         | 14 +++++
 .../src/state/threadExecution.ts              | 25 ++++++++
 8 files changed, 186 insertions(+), 26 deletions(-)

diff --git a/apps/mobile/src/features/threads/SubagentRow.tsx b/apps/mobile/src/features/threads/SubagentRow.tsx
index 31dd85f0ed8eb..7c71ac2680de1 100644
--- a/apps/mobile/src/features/threads/SubagentRow.tsx
+++ b/apps/mobile/src/features/threads/SubagentRow.tsx
@@ -5,9 +5,8 @@ import {
   shouldShowInstanceBadge,
 } from "@t3tools/client-runtime/state/provider-instance-display";
 import { resolveSubagentMetadata } from "@t3tools/client-runtime/state/subagent-display";
-import { formatModelSelectionEffort } from "@t3tools/client-runtime/state/thread-execution";
+import { formatSubagentEffort } from "@t3tools/client-runtime/state/thread-execution";
 import type { EnvironmentId, OrchestrationV2Subagent } from "@t3tools/contracts";
-import { resolveSelectableModel } from "@t3tools/shared/model";
 import type { ReactNode } from "react";
 import { View } from "react-native";
 
@@ -145,13 +144,7 @@ function SubagentMetadata(props: {
     parentProject,
     childProject,
   });
-  const effort =
-    provider &&
-    selection &&
-    modelSlug &&
-    resolveSelectableModel(provider.driver, selection.model, provider.models) === modelSlug
-      ? formatModelSelectionEffort({ ...selection, model: modelSlug }, provider.models)
-      : null;
+  const effort = formatSubagentEffort({ modelSlug, modelSelection: selection, provider });
   return (
     <View className="min-w-0 flex-row items-center gap-1.5">
       {showBadge ? (
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index 4a1bd1d9f0ad7..1505bc5d27d94 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -148,6 +148,26 @@ const CUSTOM_MODEL_CLAUDE_SETTINGS = Schema.decodeSync(ClaudeSettings)({
     },
   ],
 });
+const ULTRACODE_CUSTOM_MODEL_CLAUDE_SETTINGS = Schema.decodeSync(ClaudeSettings)({
+  customModels: [
+    {
+      slug: "claude-custom-tuned",
+      capabilities: {
+        optionDescriptors: [
+          {
+            id: "effort",
+            label: "Reasoning",
+            type: "select",
+            options: [
+              { id: "high", label: "High", isDefault: true },
+              { id: "ultracode", label: "Ultracode" },
+            ],
+          },
+        ],
+      },
+    },
+  ],
+});
 const CLAUDE_TEST_MODEL_SELECTION = {
   instanceId: ProviderInstanceId.make(ClaudeAdapterV2.CLAUDE_PROVIDER),
   model: "claude-sonnet-4-6",
@@ -14117,6 +14137,46 @@ describe("ClaudeAdapterV2 background wake turns", () => {
       ),
   );
 
+  it.effect("sends Ultracode with any effort on a custom model", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeWakeHarnessWithOptions({
+          settings: ULTRACODE_CUSTOM_MODEL_CLAUDE_SETTINGS,
+        });
+        yield* harness.runtime.startTurn(
+          makeClaudeTestTurnInput({
+            threadId: harness.threadId,
+            providerThread: harness.providerThread,
+            now: yield* DateTime.now,
+            attemptId: RunAttemptId.make("attempt-custom-ultracode"),
+            text: "Plan the work.",
+            attachments: [],
+            modelSelection: {
+              instanceId: ClaudeAdapterV2.CLAUDE_DEFAULT_INSTANCE_ID,
+              model: "claude-custom-tuned",
+              options: [
+                { id: "effort", value: "high" },
+                { id: "ultracode", value: true },
+              ],
+            },
+          }),
+        );
+        const options = harness.getOpenedOptions()!;
+        assert.equal(options.effort, "high");
+        assert.equal((options.settings as { ultracode?: boolean }).ultracode, true);
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            IdAllocator.layer,
+            McpProviderSessions.layer,
+            NodeServices.layer,
+            NodeCrypto.layer,
+          ),
+        ),
+      ),
+    ),
+  );
+
   it.effect("resolves a subagent's model and effort against the instance's custom models", () =>
     Effect.scoped(
       Effect.gen(function* () {
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index 674f55c524d75..52ed0e9d10016 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -1525,6 +1525,7 @@ const subagentDeviceInstructions: HookCallback = () =>
 
 export function makeClaudeQueryOptions(input: {
   readonly modelSelection: ModelSelection;
+  readonly modelCatalog?: ClaudeModelCatalog;
   readonly nativeThreadId: string;
   readonly title?: string;
   readonly resume: boolean;
@@ -1550,7 +1551,7 @@ export function makeClaudeQueryOptions(input: {
   // Flag settings, because a user's settings.json env beats the process env in Claude Code.
   readonly toolSearchOverride?: "true";
 }): ClaudeAgentSdkQueryOptions {
-  const compiledSelection = compileClaudeModelSelection(input.modelSelection);
+  const compiledSelection = compileClaudeModelSelection(input.modelSelection, input.modelCatalog);
   const {
     // claudeLaunchArgDirectories reads every --add-dir into additionalDirectories.
     "add-dir": _launchArgAddDir,
@@ -4616,7 +4617,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const serverSettings = yield* Effect.serviceOption(ServerSettings.ServerSettingsService);
   const { attachmentsDir, fileSystem, path, random, idAllocator, queryRunner } = adapterOptions;
-  const subagentModelCatalog = scopeClaudeModelCatalog(
+  const modelCatalog = scopeClaudeModelCatalog(
     BUNDLED_CLAUDE_MODEL_CATALOG,
     adapterOptions.settings.customModels,
   );
@@ -6527,7 +6528,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
             existingSubagent === undefined
               ? (input.effort ??
                 input.owner?.effort ??
-                compileClaudeModelSelection(input.context.input.modelSelection).effort)
+                compileClaudeModelSelection(input.context.input.modelSelection, modelCatalog)
+                  .effort)
               : existingSubagent.effort;
           const model = input.model ?? priorTask?.model ?? null;
           const task = {
@@ -6565,7 +6567,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
             ...(existingSubagent === undefined || existingSubagent.task.modelSelection !== undefined
               ? {
                   modelSelection: claudeSubagentModelSelection(
-                    subagentModelCatalog,
+                    modelCatalog,
                     input.context.input.modelSelection.instanceId,
                     model || input.context.input.modelSelection.model,
                     effort,
@@ -8995,7 +8997,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
             const model =
               snapshotModel.length === 0 || snapshotModel === "<synthetic>"
                 ? undefined
-                : canonicalClaudeSubagentModel(subagentModelCatalog, snapshotModel);
+                : canonicalClaudeSubagentModel(modelCatalog, snapshotModel);
             if (parentToolUseId !== null && model !== undefined) {
               const subagent = yield* resolveSubagentByToolUseId(context, parentToolUseId);
               if (subagent === undefined) {
@@ -9301,7 +9303,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
             const nativeToolInput = claudeNativeToolInputFromUnknown(toolUse.input);
             if (toolUse.name === "Agent") {
               rememberClaudeSubagentLaunch(
-                subagentModelCatalog,
+                modelCatalog,
                 context,
                 pendingSubagentLaunchesByToolUseId,
                 toolUse.id,
@@ -9889,7 +9891,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           const startToolCall = toolName !== "Agent" && options?.startToolCall !== false;
           if (toolName === "Agent") {
             rememberClaudeSubagentLaunch(
-              subagentModelCatalog,
+              modelCatalog,
               context,
               pendingSubagentLaunchesByToolUseId,
               nativeRequestId,
@@ -10392,7 +10394,10 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
               : { allowedTools: queryPolicy.allowedTools }),
           });
           const queryPolicyKey = claudeEffectiveQueryPolicyKey(queryPolicy, mcpOverrides);
-          const compiledSelection = compileClaudeModelSelection(turnInput.modelSelection);
+          const compiledSelection = compileClaudeModelSelection(
+            turnInput.modelSelection,
+            modelCatalog,
+          );
           const resumeSessionAt = yield* getNativeConversationHeadId(turnInput.providerThread);
           const existing = yield* Ref.get(queryContext);
           // Continuations drain existing output without prompting; retain the live process regardless of selection.
@@ -10507,6 +10512,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
           );
           const queryOptions = makeClaudeQueryOptions({
             modelSelection: turnInput.modelSelection,
+            modelCatalog,
             nativeThreadId,
             title: turnInput.appThread.title,
             resume: shouldResume,
@@ -10745,7 +10751,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
                 : yield* makeClaudeUserMessageWithAttachments({
                     text: applyClaudePromptEffortPrefix(
                       turnInput.message.text,
-                      compileClaudeModelSelection(turnInput.modelSelection).promptEffort,
+                      compileClaudeModelSelection(turnInput.modelSelection, modelCatalog)
+                        .promptEffort,
                     ),
                     attachments: turnInput.message.attachments,
                     attachmentsDir,
@@ -11193,7 +11200,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
             const userMessage = yield* makeClaudeUserMessageWithAttachments({
               text: applyClaudePromptEffortPrefix(
                 turnInput.message.text,
-                compileClaudeModelSelection(currentTurn.input.modelSelection).promptEffort,
+                compileClaudeModelSelection(currentTurn.input.modelSelection, modelCatalog)
+                  .promptEffort,
               ),
               attachments: turnInput.message.attachments,
               priority: "now",
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index 736fffa068b61..0e0c343f87047 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -61,7 +61,9 @@ function tryResolveClaudeModelCatalog(
 }
 
 // The manifest keeps Ultracode as an effort level because released servers read it from main.
-function withUltracodeToggle(capabilities: ModelCapabilities | null): ModelCapabilities | null {
+export function withUltracodeToggle(
+  capabilities: ModelCapabilities | null,
+): ModelCapabilities | null {
   const descriptors = capabilities?.optionDescriptors ?? [];
   const effortIndex = descriptors.findIndex(
     (descriptor) =>
diff --git a/apps/server/src/provider/ClaudeProvider.ts b/apps/server/src/provider/ClaudeProvider.ts
index a596f6131035c..0ec560d0a1ab0 100644
--- a/apps/server/src/provider/ClaudeProvider.ts
+++ b/apps/server/src/provider/ClaudeProvider.ts
@@ -2,6 +2,7 @@ import {
   type ClaudeSettings,
   type ModelCapabilities,
   type ServerProvider,
+  type ServerProviderModel,
   type ServerProviderSlashCommand,
   type ServerProviderResetCredits,
 } from "@t3tools/contracts";
@@ -51,12 +52,26 @@ import {
   formatClaudeVersionUpgradeMessage,
   resolveClaudeModelsForVersion,
   resolveClaudeUpdateRequiredModels,
+  withUltracodeToggle,
 } from "./ClaudeModelCatalog.ts";
 
 const DEFAULT_CLAUDE_MODEL_CAPABILITIES: ModelCapabilities = createModelCapabilities({
   optionDescriptors: [],
 });
 
+function claudeProviderModels(
+  builtInModels: ReadonlyArray<ServerProviderModel>,
+  customModels: ClaudeSettings["customModels"],
+): ReadonlyArray<ServerProviderModel> {
+  return providerModelsFromSettings(
+    builtInModels,
+    customModels,
+    DEFAULT_CLAUDE_MODEL_CAPABILITIES,
+  ).map((model) =>
+    model.isCustom ? { ...model, capabilities: withUltracodeToggle(model.capabilities) } : model,
+  );
+}
+
 const CLAUDE_PRESENTATION = {
   displayName: "Claude",
   showInteractionModeToggle: true,
@@ -466,10 +481,9 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
 > {
   const resolvedEnvironment = environment ?? process.env;
   const checkedAt = DateTime.formatIso(yield* DateTime.now);
-  const allModels = providerModelsFromSettings(
+  const allModels = claudeProviderModels(
     modelCatalog.models.map((entry) => entry.model),
     claudeSettings.customModels,
-    DEFAULT_CLAUDE_MODEL_CAPABILITIES,
   );
 
   if (!claudeSettings.enabled) {
@@ -557,10 +571,9 @@ export const checkClaudeProviderStatus = Effect.fn("checkClaudeProviderStatus")(
     });
   }
 
-  const models = providerModelsFromSettings(
+  const models = claudeProviderModels(
     resolveClaudeModelsForVersion(modelCatalog, parsedVersion),
     claudeSettings.customModels,
-    DEFAULT_CLAUDE_MODEL_CAPABILITIES,
   );
   const updateRequiredModels = resolveClaudeUpdateRequiredModels(modelCatalog, parsedVersion);
   const versionUpgradeMessage = formatClaudeVersionUpgradeMessage(modelCatalog, parsedVersion);
@@ -687,10 +700,9 @@ export const makePendingClaudeProvider = Effect.fn("ClaudeProvider.makePendingCl
     modelCatalog: ClaudeModelCatalog = BUNDLED_CLAUDE_MODEL_CATALOG,
   ): Effect.fn.Return<ServerProviderDraft> {
     const checkedAt = yield* nowIso;
-    const models = providerModelsFromSettings(
+    const models = claudeProviderModels(
       modelCatalog.models.map((entry) => entry.model),
       claudeSettings.customModels,
-      DEFAULT_CLAUDE_MODEL_CAPABILITIES,
     );
 
     if (!claudeSettings.enabled) {
diff --git a/apps/server/src/provider/ProviderRegistry.test.ts b/apps/server/src/provider/ProviderRegistry.test.ts
index 93fec081ebb9c..e0acf7227546d 100644
--- a/apps/server/src/provider/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/ProviderRegistry.test.ts
@@ -3142,5 +3142,51 @@ it.layer(
         ),
       ),
     );
+
+    it.effect("advertises Ultracode as a toggle on custom models", () =>
+      Effect.gen(function* () {
+        const status = yield* checkClaudeProviderStatus(
+          {
+            ...defaultClaudeSettings,
+            customModels: [
+              {
+                slug: "claude-custom-tuned",
+                capabilities: {
+                  optionDescriptors: [
+                    {
+                      id: "effort",
+                      label: "Reasoning",
+                      type: "select",
+                      options: [
+                        { id: "high", label: "High", isDefault: true },
+                        { id: "ultracode", label: "Ultracode" },
+                      ],
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          claudeCapabilities(),
+        );
+        const custom = status.models.find((model) => model.slug === "claude-custom-tuned");
+        assert.deepStrictEqual(
+          custom?.capabilities?.optionDescriptors?.map((descriptor) =>
+            descriptor.type === "select"
+              ? `${descriptor.id}:${descriptor.options.map((option) => option.id).join("|")}`
+              : `${descriptor.id}:${descriptor.type}`,
+          ),
+          ["effort:high", "ultracode:boolean"],
+        );
+      }).pipe(
+        Effect.provide(
+          layerMockSpawner((args) => {
+            const joined = args.join(" ");
+            if (joined === "--version") return { stdout: "1.0.0\n", stderr: "", code: 0 };
+            throw new Error(`Unexpected args: ${joined}`);
+          }),
+        ),
+      ),
+    );
   });
 });
diff --git a/packages/client-runtime/src/state/subagentRuntime.test.ts b/packages/client-runtime/src/state/subagentRuntime.test.ts
index 0bdc1e8e0eadb..93d15b016d755 100644
--- a/packages/client-runtime/src/state/subagentRuntime.test.ts
+++ b/packages/client-runtime/src/state/subagentRuntime.test.ts
@@ -16,6 +16,7 @@ import {
   workflowMemberModelSelection,
 } from "./subagentRuntime.ts";
 import { resolveSubagentMetadata } from "./subagentDisplay.ts";
+import { formatSubagentEffort } from "./threadExecution.ts";
 
 const at = (iso: string) => DateTime.makeUnsafe(iso);
 
@@ -96,6 +97,19 @@ describe("projectedSubagentsToRuntime workflow expansion", () => {
     expect(workflowMemberModelSelection({ model: null, effort: "xhigh" }, instanceId)).toBe(
       undefined,
     );
+    const provider = {
+      driver: ProviderDriverKind.make("claudeAgent"),
+      models: [
+        { slug: "claude-opus-5", name: "Claude Opus 5", isCustom: false, capabilities: null },
+      ],
+    };
+    const modelSelection = workflowMemberModelSelection(settled!, instanceId);
+    const { modelSlug } = resolveSubagentMetadata({
+      model: settled!.model,
+      modelSelection,
+      provider,
+    });
+    expect(formatSubagentEffort({ modelSlug, modelSelection, provider })).toBe("xhigh");
   });
 
   it("names a workflow by the model it runs on when the provider reports none", () => {
diff --git a/packages/client-runtime/src/state/threadExecution.ts b/packages/client-runtime/src/state/threadExecution.ts
index 1a7559f4adc2c..f4335256e98fb 100644
--- a/packages/client-runtime/src/state/threadExecution.ts
+++ b/packages/client-runtime/src/state/threadExecution.ts
@@ -13,6 +13,7 @@ import {
   type OrchestrationV2NotificationSource,
   type OrchestrationV2PendingBackgroundTask,
   type OrchestrationV2ProviderGoal,
+  type ServerProvider,
   type ServerProviderModel,
   type OrchestrationV2ExecutionNode,
   type OrchestrationV2ThreadProjection,
@@ -25,8 +26,10 @@ import {
   derivePendingBackgroundWork,
 } from "@t3tools/shared/orchestrationV2PendingBackgroundWork";
 import {
+  getModelSelectionStringOptionValue,
   getProviderOptionCurrentLabel,
   getProviderOptionStatedValue,
+  resolveSelectableModel,
   withLegacyUltracodeEffort,
 } from "@t3tools/shared/model";
 import { formatDuration } from "@t3tools/shared/orchestrationTiming";
@@ -187,6 +190,28 @@ export function formatModelSelectionEffort(
   return null;
 }
 
+/** A reported model the picker catalog does not know, such as `claude-opus-5[1m]`, keeps its raw effort. */
+export function formatSubagentEffort(input: {
+  readonly modelSlug: string | null;
+  readonly modelSelection: ModelSelection | undefined;
+  readonly provider: Pick<ServerProvider, "driver" | "models"> | undefined;
+}): string | null {
+  const { modelSlug, modelSelection: selection, provider } = input;
+  if (!provider || !selection || !modelSlug) return null;
+  const selectionSlug =
+    resolveSelectableModel(provider.driver, selection.model, provider.models) ??
+    selection.model.trim();
+  if (selectionSlug !== modelSlug) return null;
+  if (provider.models.some((model) => model.slug === modelSlug)) {
+    return formatModelSelectionEffort({ ...selection, model: modelSlug }, provider.models);
+  }
+  return (
+    REASONING_EFFORT_OPTION_IDS.map((id) => getModelSelectionStringOptionValue(selection, id)).find(
+      Boolean,
+    ) ?? null
+  );
+}
+
 const SUBAGENT_STATUS_LABELS: Record<OrchestrationV2ExecutionNode["status"], string> = {
   idle: "Idle",
   pending: "Working",

From 383166aba5c30599e31e231c630d5fc81078e701 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Tue, 3 Nov 2026 18:49:13 +0000
Subject: [PATCH 17/18] fix(claude): custom models that defaulted to Ultracode
 keep it on

A custom Claude model whose effort defaulted to the old `ultracode` level
kept `ultracode` as its effort after the level became a toggle, so turns
sent a retired effort to Claude Code without the Ultracode setting. The
toggle transform now moves that default to Extra High with Ultracode on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/claudeModelOptions.test.ts    | 32 +++++++++++++++++++
 .../server/src/provider/ClaudeModelCatalog.ts | 24 ++++++++++++--
 2 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.test.ts b/apps/server/src/claudeModelOptions.test.ts
index e41243814abce..894ed27b3932c 100644
--- a/apps/server/src/claudeModelOptions.test.ts
+++ b/apps/server/src/claudeModelOptions.test.ts
@@ -3,6 +3,10 @@ import { describe, expect, it } from "@effect/vitest";
 import { ProviderInstanceId, type ModelSelection } from "@t3tools/contracts";
 
 import { compileClaudeModelSelection } from "./claudeModelOptions.ts";
+import {
+  BUNDLED_CLAUDE_MODEL_CATALOG,
+  scopeClaudeModelCatalog,
+} from "./provider/ClaudeModelCatalog.ts";
 
 const selection = (
   model: string,
@@ -58,6 +62,34 @@ describe("compileClaudeModelSelection", () => {
     ).not.toHaveProperty("ultracode");
   });
 
+  it("keeps Ultracode on at Extra High for a custom model that defaulted to the old Ultracode effort", () => {
+    const catalog = scopeClaudeModelCatalog(BUNDLED_CLAUDE_MODEL_CATALOG, [
+      {
+        slug: "claude-custom-tuned",
+        name: "Tuned",
+        capabilities: {
+          optionDescriptors: [
+            {
+              id: "effort",
+              label: "Reasoning",
+              type: "select",
+              currentValue: "ultracode",
+              options: [
+                { id: "high", label: "High" },
+                { id: "xhigh", label: "Extra High" },
+                { id: "ultracode", label: "Ultracode", isDefault: true },
+              ],
+            },
+          ],
+        },
+      },
+    ]);
+
+    expect(
+      compileClaudeModelSelection(selection("claude-custom-tuned", []), catalog),
+    ).toMatchObject({ effort: "xhigh", settings: { ultracode: true } });
+  });
+
   it("uses the model default SDK effort alongside prompt-injected effort", () => {
     expect(
       compileClaudeModelSelection(
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index 0e0c343f87047..5968480d42477 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -73,12 +73,32 @@ export function withUltracodeToggle(
   );
   const effort = descriptors[effortIndex];
   if (effort?.type !== "select") return capabilities;
+  const { currentValue, ...rest } = effort;
+  const options = effort.options.filter((option) => option.id !== "ultracode");
+  const ultracodeByDefault =
+    (currentValue ?? effort.options.find((option) => option.isDefault)?.id) === "ultracode";
+  // A model that defaulted to Ultracode keeps it on, at the xhigh that level ran at.
+  const defaultEffort =
+    ultracodeByDefault && options.some((option) => option.id === "xhigh") ? "xhigh" : undefined;
   return {
     optionDescriptors: descriptors.toSpliced(
       effortIndex,
       1,
-      { ...effort, options: effort.options.filter((option) => option.id !== "ultracode") },
-      { id: "ultracode", label: "Ultracode", type: "boolean" },
+      ultracodeByDefault
+        ? {
+            ...rest,
+            ...(defaultEffort ? { currentValue: defaultEffort } : {}),
+            options: options.map(({ isDefault: _isDefault, ...option }) =>
+              option.id === defaultEffort ? { ...option, isDefault: true } : option,
+            ),
+          }
+        : { ...effort, options },
+      {
+        id: "ultracode",
+        label: "Ultracode",
+        type: "boolean",
+        ...(ultracodeByDefault ? { currentValue: true } : {}),
+      },
     ),
   };
 }

From 56c21922490c8921035329ca7415f86b945ae463 Mon Sep 17 00:00:00 2001
From: Julius Marminge <julius0216@outlook.com>
Date: Tue, 3 Nov 2026 19:11:41 +0000
Subject: [PATCH 18/18] fix(claude): custom models keep Extra High when
 Ultracode becomes a toggle

The old Ultracode effort level ran at xhigh. A custom model that offered
Ultracode but no standalone Extra High lost xhigh when the level became a
toggle, so old selections fell back to its default effort and
delegate_task rejected them. The toggle transform now keeps xhigh in its
place.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/server/src/claudeModelOptions.test.ts    | 53 +++++++++++--------
 .../server/src/provider/ClaudeModelCatalog.ts | 32 +++++------
 .../src/provider/ProviderRegistry.test.ts     |  2 +-
 3 files changed, 48 insertions(+), 39 deletions(-)

diff --git a/apps/server/src/claudeModelOptions.test.ts b/apps/server/src/claudeModelOptions.test.ts
index 894ed27b3932c..b69b20db7ec4d 100644
--- a/apps/server/src/claudeModelOptions.test.ts
+++ b/apps/server/src/claudeModelOptions.test.ts
@@ -62,32 +62,39 @@ describe("compileClaudeModelSelection", () => {
     ).not.toHaveProperty("ultracode");
   });
 
-  it("keeps Ultracode on at Extra High for a custom model that defaulted to the old Ultracode effort", () => {
-    const catalog = scopeClaudeModelCatalog(BUNDLED_CLAUDE_MODEL_CATALOG, [
-      {
-        slug: "claude-custom-tuned",
-        name: "Tuned",
-        capabilities: {
-          optionDescriptors: [
-            {
-              id: "effort",
-              label: "Reasoning",
-              type: "select",
-              currentValue: "ultracode",
-              options: [
-                { id: "high", label: "High" },
-                { id: "xhigh", label: "Extra High" },
-                { id: "ultracode", label: "Ultracode", isDefault: true },
-              ],
-            },
-          ],
-        },
+  it("keeps old Ultracode defaults and selections at Extra High on custom models", () => {
+    const customModel = (slug: string, choices: ReadonlyArray<string>) => ({
+      slug,
+      name: slug,
+      capabilities: {
+        optionDescriptors: [
+          {
+            id: "effort",
+            label: "Reasoning",
+            type: "select" as const,
+            currentValue: "ultracode",
+            options: choices.map((id) => ({ id, label: id, isDefault: id === "ultracode" })),
+          },
+        ],
       },
+    });
+    const catalog = scopeClaudeModelCatalog(BUNDLED_CLAUDE_MODEL_CATALOG, [
+      customModel("claude-custom-tuned", ["high", "xhigh", "ultracode"]),
+      customModel("claude-custom-no-xhigh", ["high", "ultracode"]),
     ]);
 
-    expect(
-      compileClaudeModelSelection(selection("claude-custom-tuned", []), catalog),
-    ).toMatchObject({ effort: "xhigh", settings: { ultracode: true } });
+    for (const model of ["claude-custom-tuned", "claude-custom-no-xhigh"]) {
+      expect(compileClaudeModelSelection(selection(model, []), catalog)).toMatchObject({
+        effort: "xhigh",
+        settings: { ultracode: true },
+      });
+      expect(
+        compileClaudeModelSelection(
+          selection(model, [{ id: "effort", value: "ultracode" }]),
+          catalog,
+        ),
+      ).toMatchObject({ effort: "xhigh", settings: { ultracode: true } });
+    }
   });
 
   it("uses the model default SDK effort alongside prompt-injected effort", () => {
diff --git a/apps/server/src/provider/ClaudeModelCatalog.ts b/apps/server/src/provider/ClaudeModelCatalog.ts
index 5968480d42477..9d783c0dde8e1 100644
--- a/apps/server/src/provider/ClaudeModelCatalog.ts
+++ b/apps/server/src/provider/ClaudeModelCatalog.ts
@@ -73,26 +73,28 @@ export function withUltracodeToggle(
   );
   const effort = descriptors[effortIndex];
   if (effort?.type !== "select") return capabilities;
-  const { currentValue, ...rest } = effort;
-  const options = effort.options.filter((option) => option.id !== "ultracode");
   const ultracodeByDefault =
-    (currentValue ?? effort.options.find((option) => option.isDefault)?.id) === "ultracode";
-  // A model that defaulted to Ultracode keeps it on, at the xhigh that level ran at.
-  const defaultEffort =
-    ultracodeByDefault && options.some((option) => option.id === "xhigh") ? "xhigh" : undefined;
+    (effort.currentValue ?? effort.options.find((option) => option.isDefault)?.id) === "ultracode";
+  const hasXhigh = effort.options.some((option) => option.id === "xhigh");
+  // Ultracode ran at xhigh, so a model that offered it keeps xhigh, and its default moves there.
+  const options = effort.options.flatMap(({ isDefault, ...option }) => {
+    if (option.id === "ultracode") {
+      return hasXhigh
+        ? []
+        : [{ id: "xhigh", label: "Extra High", ...(isDefault ? { isDefault } : {}) }];
+    }
+    if (ultracodeByDefault && option.id === "xhigh") return [{ ...option, isDefault: true }];
+    return [isDefault && !ultracodeByDefault ? { ...option, isDefault } : option];
+  });
   return {
     optionDescriptors: descriptors.toSpliced(
       effortIndex,
       1,
-      ultracodeByDefault
-        ? {
-            ...rest,
-            ...(defaultEffort ? { currentValue: defaultEffort } : {}),
-            options: options.map(({ isDefault: _isDefault, ...option }) =>
-              option.id === defaultEffort ? { ...option, isDefault: true } : option,
-            ),
-          }
-        : { ...effort, options },
+      {
+        ...effort,
+        ...(effort.currentValue === "ultracode" ? { currentValue: "xhigh" } : {}),
+        options,
+      },
       {
         id: "ultracode",
         label: "Ultracode",
diff --git a/apps/server/src/provider/ProviderRegistry.test.ts b/apps/server/src/provider/ProviderRegistry.test.ts
index e0acf7227546d..974c13eae89be 100644
--- a/apps/server/src/provider/ProviderRegistry.test.ts
+++ b/apps/server/src/provider/ProviderRegistry.test.ts
@@ -3176,7 +3176,7 @@ it.layer(
               ? `${descriptor.id}:${descriptor.options.map((option) => option.id).join("|")}`
               : `${descriptor.id}:${descriptor.type}`,
           ),
-          ["effort:high", "ultracode:boolean"],
+          ["effort:high|xhigh", "ultracode:boolean"],
         );
       }).pipe(
         Effect.provide(