coder
diff --git a/‎src/browser/features/Settings/Sections/AdvisorToolExperimentConfig.tsx‎
Lines changed: 134 additions & 13 deletions b/‎src/browser/features/Settings/Sections/AdvisorToolExperimentConfig.tsx‎
Lines changed: 134 additions & 13 deletions
diff --git a/‎src/browser/features/Settings/Sections/ExperimentsSection.advisor.test.tsx‎
Lines changed: 23 additions & 2 deletions b/‎src/browser/features/Settings/Sections/ExperimentsSection.advisor.test.tsx‎
Lines changed: 23 additions & 2 deletions
diff --git a/‎src/common/config/schemas/appConfigOnDisk.ts‎
Lines changed: 1 addition & 0 deletions b/‎src/common/config/schemas/appConfigOnDisk.ts‎
Lines changed: 1 addition & 0 deletions
@@ -25,18 +25,24 @@ import { getErrorMessage } from "@/common/utils/errors";
 import { enforceThinkingPolicy, getThinkingPolicyForModel } from "@/common/utils/thinking/policy";
 
 const DEFAULT_LIMITED_MAX_USES = ADVISOR_DEFAULT_MAX_USES_PER_TURN;
+const DEFAULT_LIMITED_MAX_OUTPUT_TOKENS = 16000;
 
 assert(
   Number.isInteger(DEFAULT_LIMITED_MAX_USES) && DEFAULT_LIMITED_MAX_USES > 0,
   "Advisor limited mode must seed a positive default"
 );
+assert(
+  Number.isInteger(DEFAULT_LIMITED_MAX_OUTPUT_TOKENS) && DEFAULT_LIMITED_MAX_OUTPUT_TOKENS > 0,
+  "Advisor limited output tokens mode must seed a positive default"
+);
 
 type AdvisorMode = "limited" | "unlimited";
 
 interface AdvisorSettingsState {
   advisorModelString: string | null;
   advisorThinkingLevel: ThinkingLevel;
   advisorMaxUsesPerTurn: number | null;
+  advisorMaxOutputTokens: number | null;
 }
 
 interface AdvisorSavePayload extends AdvisorSettingsState {
@@ -60,6 +66,14 @@ function normalizeAdvisorMaxUsesPerTurn(value: number | null | undefined): numbe
   return value;
 }
 
+function normalizeAdvisorMaxOutputTokens(value: number | null | undefined): number | null {
+  if (!Number.isInteger(value) || value == null || value <= 0) {
+    return null;
+  }
+
+  return value;
+}
+
 function parsePositiveInteger(value: string): number | null {
   const trimmedValue = value.trim();
   if (!/^\d+$/.test(trimmedValue)) {
@@ -80,39 +94,50 @@ function normalizeAdvisorDraft(params: {
   maxUsesMode: AdvisorMode;
   limitedDraft: string;
   lastValidLimitedValue: number;
+  maxOutputTokensMode: AdvisorMode;
+  outputTokensDraft: string;
+  lastValidOutputTokensValue: number;
 }): AdvisorSettingsState {
   const normalizedModelString = normalizeAdvisorModelString(params.advisorModelString);
   const normalizedThinkingLevel = enforceThinkingPolicy(
     normalizedModelString ?? "",
     params.advisorThinkingLevel
   );
 
-  if (params.maxUsesMode === "unlimited") {
-    return {
-      advisorModelString: normalizedModelString,
-      advisorThinkingLevel: normalizedThinkingLevel,
-      advisorMaxUsesPerTurn: null,
-    };
+  let normalizedMaxUsesPerTurn: number | null = null;
+  if (params.maxUsesMode === "limited") {
+    assert(
+      Number.isInteger(params.lastValidLimitedValue) && params.lastValidLimitedValue > 0,
+      "Advisor limited mode must keep a positive saved value"
+    );
+    normalizedMaxUsesPerTurn =
+      parsePositiveInteger(params.limitedDraft) ?? params.lastValidLimitedValue;
   }
 
-  assert(
-    Number.isInteger(params.lastValidLimitedValue) && params.lastValidLimitedValue > 0,
-    "Advisor limited mode must keep a positive saved value"
-  );
+  let normalizedMaxOutputTokens: number | null = null;
+  if (params.maxOutputTokensMode === "limited") {
+    assert(
+      Number.isInteger(params.lastValidOutputTokensValue) && params.lastValidOutputTokensValue > 0,
+      "Advisor limited max output tokens mode must keep a positive saved value"
+    );
+    normalizedMaxOutputTokens =
+      parsePositiveInteger(params.outputTokensDraft) ?? params.lastValidOutputTokensValue;
+  }
 
   return {
     advisorModelString: normalizedModelString,
     advisorThinkingLevel: normalizedThinkingLevel,
-    advisorMaxUsesPerTurn:
-      parsePositiveInteger(params.limitedDraft) ?? params.lastValidLimitedValue,
+    advisorMaxUsesPerTurn: normalizedMaxUsesPerTurn,
+    advisorMaxOutputTokens: normalizedMaxOutputTokens,
   };
 }
 
 function areAdvisorSettingsEqual(a: AdvisorSettingsState, b: AdvisorSettingsState): boolean {
   return (
     a.advisorModelString === b.advisorModelString &&
     a.advisorThinkingLevel === b.advisorThinkingLevel &&
-    a.advisorMaxUsesPerTurn === b.advisorMaxUsesPerTurn
+    a.advisorMaxUsesPerTurn === b.advisorMaxUsesPerTurn &&
+    a.advisorMaxOutputTokens === b.advisorMaxOutputTokens
   );
 }
 
@@ -126,6 +151,13 @@ export function AdvisorToolExperimentConfig() {
   const [maxUsesMode, setMaxUsesMode] = useState<AdvisorMode>("limited");
   const [limitedDraft, setLimitedDraft] = useState(String(DEFAULT_LIMITED_MAX_USES));
   const [lastValidLimitedValue, setLastValidLimitedValue] = useState(DEFAULT_LIMITED_MAX_USES);
+  const [maxOutputTokensMode, setMaxOutputTokensMode] = useState<AdvisorMode>("unlimited");
+  const [outputTokensDraft, setOutputTokensDraft] = useState(
+    String(DEFAULT_LIMITED_MAX_OUTPUT_TOKENS)
+  );
+  const [lastValidOutputTokensValue, setLastValidOutputTokensValue] = useState(
+    DEFAULT_LIMITED_MAX_OUTPUT_TOKENS
+  );
 
   const [loaded, setLoaded] = useState(false);
   const [loadFailed, setLoadFailed] = useState(false);
@@ -167,23 +199,36 @@ export function AdvisorToolExperimentConfig() {
         const normalizedThinkingLevel =
           coerceThinkingLevel(cfg.advisorThinkingLevel) ?? THINKING_LEVEL_OFF;
         const normalizedMaxUsesPerTurn = normalizeAdvisorMaxUsesPerTurn(cfg.advisorMaxUsesPerTurn);
+        const normalizedMaxOutputTokens = normalizeAdvisorMaxOutputTokens(
+          cfg.advisorMaxOutputTokens
+        );
         // Match the backend starter cap when the setting is unset; only an explicit null is
         // the user's Unlimited opt-in.
         const nextMaxUsesMode: AdvisorMode =
           cfg.advisorMaxUsesPerTurn === null ? "unlimited" : "limited";
         const nextLimitedValue = normalizedMaxUsesPerTurn ?? DEFAULT_LIMITED_MAX_USES;
         const nextMaxUsesPerTurn = nextMaxUsesMode === "unlimited" ? null : nextLimitedValue;
+        const nextMaxOutputTokensMode: AdvisorMode =
+          cfg.advisorMaxOutputTokens == null ? "unlimited" : "limited";
+        const nextOutputTokensValue =
+          normalizedMaxOutputTokens ?? DEFAULT_LIMITED_MAX_OUTPUT_TOKENS;
+        const nextMaxOutputTokens =
+          nextMaxOutputTokensMode === "unlimited" ? null : nextOutputTokensValue;
 
         taskSettingsRef.current = normalizedTaskSettings;
         setAdvisorModelString(normalizedModelString ?? "");
         setAdvisorThinkingLevel(normalizedThinkingLevel);
         setMaxUsesMode(nextMaxUsesMode);
         setLimitedDraft(String(nextLimitedValue));
         setLastValidLimitedValue(nextLimitedValue);
+        setMaxOutputTokensMode(nextMaxOutputTokensMode);
+        setOutputTokensDraft(String(nextOutputTokensValue));
+        setLastValidOutputTokensValue(nextOutputTokensValue);
         lastSyncedRef.current = {
           advisorModelString: normalizedModelString,
           advisorThinkingLevel: normalizedThinkingLevel,
           advisorMaxUsesPerTurn: nextMaxUsesPerTurn,
+          advisorMaxOutputTokens: nextMaxOutputTokens,
         };
         setLoadFailed(false);
         setLoaded(true);
@@ -226,6 +271,9 @@ export function AdvisorToolExperimentConfig() {
       maxUsesMode,
       limitedDraft,
       lastValidLimitedValue,
+      maxOutputTokensMode,
+      outputTokensDraft,
+      lastValidOutputTokensValue,
     });
     const lastSynced = lastSyncedRef.current;
 
@@ -264,12 +312,14 @@ export function AdvisorToolExperimentConfig() {
             advisorModelString: payload.advisorModelString,
             advisorThinkingLevel: payload.advisorThinkingLevel,
             advisorMaxUsesPerTurn: payload.advisorMaxUsesPerTurn,
+            advisorMaxOutputTokens: payload.advisorMaxOutputTokens,
           })
           .then(() => {
             lastSyncedRef.current = {
               advisorModelString: payload.advisorModelString,
               advisorThinkingLevel: payload.advisorThinkingLevel,
               advisorMaxUsesPerTurn: payload.advisorMaxUsesPerTurn,
+              advisorMaxOutputTokens: payload.advisorMaxOutputTokens,
             };
             if (isMountedRef.current) {
               setSaveError(null);
@@ -304,6 +354,9 @@ export function AdvisorToolExperimentConfig() {
     loaded,
     maxUsesMode,
     lastValidLimitedValue,
+    maxOutputTokensMode,
+    outputTokensDraft,
+    lastValidOutputTokensValue,
   ]);
 
   useEffect(() => {
@@ -342,6 +395,7 @@ export function AdvisorToolExperimentConfig() {
           advisorModelString: payload.advisorModelString,
           advisorThinkingLevel: payload.advisorThinkingLevel,
           advisorMaxUsesPerTurn: payload.advisorMaxUsesPerTurn,
+          advisorMaxOutputTokens: payload.advisorMaxOutputTokens,
         })
         .catch(() => undefined)
         .finally(() => {
@@ -388,6 +442,41 @@ export function AdvisorToolExperimentConfig() {
     setLastValidLimitedValue(normalizedValue);
   };
 
+  const setAdvisorMaxOutputTokensMode = (value: string) => {
+    if (value !== "unlimited" && value !== "limited") {
+      return;
+    }
+    if (value === "limited") {
+      const nextValue = parsePositiveInteger(outputTokensDraft) ?? lastValidOutputTokensValue;
+      assert(
+        Number.isInteger(nextValue) && nextValue > 0,
+        "Advisor limited max output tokens needs a positive restored value"
+      );
+      setLastValidOutputTokensValue(nextValue);
+      setOutputTokensDraft(String(nextValue));
+    }
+    setMaxOutputTokensMode(value);
+  };
+
+  const handleOutputTokensDraftChange = (rawValue: string) => {
+    setOutputTokensDraft(rawValue);
+    const parsedValue = parsePositiveInteger(rawValue);
+    if (parsedValue == null) {
+      return;
+    }
+    setLastValidOutputTokensValue(parsedValue);
+  };
+
+  const handleOutputTokensDraftBlur = () => {
+    const normalizedValue = parsePositiveInteger(outputTokensDraft) ?? lastValidOutputTokensValue;
+    assert(
+      Number.isInteger(normalizedValue) && normalizedValue > 0,
+      "Advisor output tokens draft must resolve to a positive integer"
+    );
+    setOutputTokensDraft(String(normalizedValue));
+    setLastValidOutputTokensValue(normalizedValue);
+  };
+
   const effectiveAdvisorModelStringForThinking =
     normalizeAdvisorModelString(advisorModelString) ?? "";
   const allowedThinkingLevels = getThinkingPolicyForModel(effectiveAdvisorModelStringForThinking);
@@ -507,6 +596,38 @@ export function AdvisorToolExperimentConfig() {
         </div>
       </div>
 
+      <div className="flex items-center justify-between gap-4">
+        <div className="flex-1">
+          <div className="text-foreground text-sm">Max Output Tokens</div>
+          <div className="text-muted text-xs">Per advisor response.</div>
+        </div>
+        <div className="flex items-center justify-end gap-2">
+          <Select value={maxOutputTokensMode} onValueChange={setAdvisorMaxOutputTokensMode}>
+            <SelectTrigger className="border-border-medium bg-modal-bg h-9 w-32">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="unlimited">Unlimited</SelectItem>
+              <SelectItem value="limited">Limited</SelectItem>
+            </SelectContent>
+          </Select>
+          {maxOutputTokensMode === "limited" ? (
+            <Input
+              aria-label="Advisor max output tokens"
+              type="number"
+              min={1}
+              step={1}
+              value={outputTokensDraft}
+              onChange={(event: React.ChangeEvent<HTMLInputElement>) =>
+                handleOutputTokensDraftChange(event.target.value)
+              }
+              onBlur={handleOutputTokensDraftBlur}
+              className="border-border-medium bg-modal-bg h-9 w-28"
+            />
+          ) : null}
+        </div>
+      </div>
+
       {saveError ? <div className="text-danger-light text-xs">{saveError}</div> : null}
     </div>
   );
 
@@ -1,5 +1,5 @@
 import React from "react";
-import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
+import { cleanup, fireEvent, render, waitFor, within } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import * as ActualSelectPrimitiveModule from "@/browser/components/SelectPrimitive/SelectPrimitive";
@@ -14,13 +14,15 @@ interface MockConfig {
   advisorModelString: string | null;
   advisorThinkingLevel: ThinkingLevel | null | undefined;
   advisorMaxUsesPerTurn: number | null | undefined;
+  advisorMaxOutputTokens: number | null | undefined;
 }
 
 interface SaveConfigInput {
   taskSettings: TaskSettings;
   advisorModelString?: string | null;
   advisorThinkingLevel?: ThinkingLevel | null;
   advisorMaxUsesPerTurn?: number | null;
+  advisorMaxOutputTokens?: number | null;
 }
 
 interface MockAPIClient {
@@ -204,6 +206,7 @@ function createMockAPI(configOverrides: Partial<MockConfig> = {}) {
     advisorModelString: null,
     advisorThinkingLevel: undefined,
     advisorMaxUsesPerTurn: undefined,
+    advisorMaxOutputTokens: undefined,
     ...configOverrides,
   };
 
@@ -213,6 +216,7 @@ function createMockAPI(configOverrides: Partial<MockConfig> = {}) {
       advisorModelString: config.advisorModelString,
       advisorThinkingLevel: config.advisorThinkingLevel,
       advisorMaxUsesPerTurn: config.advisorMaxUsesPerTurn,
+      advisorMaxOutputTokens: config.advisorMaxOutputTokens,
     })
   );
 
@@ -223,6 +227,7 @@ function createMockAPI(configOverrides: Partial<MockConfig> = {}) {
       : null;
     config.advisorThinkingLevel = input.advisorThinkingLevel ?? null;
     config.advisorMaxUsesPerTurn = input.advisorMaxUsesPerTurn ?? null;
+    config.advisorMaxOutputTokens = input.advisorMaxOutputTokens ?? null;
     return Promise.resolve();
   });
 
@@ -297,8 +302,21 @@ describe("ExperimentsSection advisor config", () => {
 
   function chooseSelectOption(view: ReturnType<typeof render>, label: string, optionText: string) {
     const trigger = getSelectTrigger(view, label);
+    const row = trigger.parentElement?.parentElement;
+    if (!(row instanceof window.HTMLElement)) {
+      throw new Error(`Could not find row for ${label}`);
+    }
+
     fireEvent.pointerDown(trigger);
-    fireEvent.click(view.getByText(optionText));
+
+    const option = within(row)
+      .getAllByRole("button", { name: optionText })
+      .find((element) => element !== trigger);
+    if (!(option instanceof window.HTMLElement)) {
+      throw new Error(`Could not find ${optionText} option for ${label}`);
+    }
+
+    fireEvent.click(option);
   }
 
   test("keeps the advisor row toggle-only when the experiment is disabled", async () => {
@@ -340,6 +358,7 @@ describe("ExperimentsSection advisor config", () => {
         advisorModelString: null,
         advisorThinkingLevel: THINKING_LEVEL_OFF,
         advisorMaxUsesPerTurn: null,
+        advisorMaxOutputTokens: null,
       });
     });
 
@@ -357,6 +376,7 @@ describe("ExperimentsSection advisor config", () => {
         advisorModelString: null,
         advisorThinkingLevel: THINKING_LEVEL_OFF,
         advisorMaxUsesPerTurn: 3,
+        advisorMaxOutputTokens: null,
       });
     });
   });
@@ -380,6 +400,7 @@ describe("ExperimentsSection advisor config", () => {
         advisorModelString: null,
         advisorThinkingLevel: THINKING_LEVEL_OFF,
         advisorMaxUsesPerTurn: null,
+        advisorMaxOutputTokens: null,
       });
     });
 
 
@@ -65,6 +65,7 @@ export const AppConfigOnDiskSchema = z
     advisorModelString: z.string().optional(),
     advisorThinkingLevel: ThinkingLevelSchema.optional(),
     advisorMaxUsesPerTurn: z.number().int().positive().nullable().optional(),
+    advisorMaxOutputTokens: z.number().int().positive().nullable().optional(),
     hiddenModels: z.array(z.string()).optional(),
     preferredCompactionModel: z.string().optional(),
     agentAiDefaults: AgentAiDefaultsSchema.optional(),