🤖 fix: validate task settings + reschedule queue

ThomasK33 · ThomasK33 · commit 2f9f47735067 · 2025-12-18T17:59:29.000+01:00
- Clamp/validate Tasks settings inputs and surface save errors\n- Re-run TaskService scheduler after task limit updates\n\n---\n_Generated with `mux` • Model: `openai:gpt-5.2` • Thinking: `xhigh`_\n

Change-Id: I5932a79b9d4df8a476e74d1b8a6e65a32a2ad0f9
Signed-off-by: Thomas Kosiewski &lt;tk@coder.com&gt;
diff --git a/src/browser/components/Settings/sections/TasksSection.tsx b/src/browser/components/Settings/sections/TasksSection.tsx
@@ -1,13 +1,30 @@
 import React from "react";
 import { useAPI } from "@/browser/contexts/API";
-import { Button } from "@/browser/components/ui/button";
 import { Input } from "@/browser/components/ui/input";
+import { Button } from "@/browser/components/ui/button";
+
+const MAX_PARALLEL_AGENT_TASKS_MIN = 1;
+const MAX_PARALLEL_AGENT_TASKS_MAX = 10;
+const MAX_TASK_NESTING_DEPTH_MIN = 1;
+const MAX_TASK_NESTING_DEPTH_MAX = 5;
+
+function clampNumber(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function parseIntOrNull(value: string): number | null {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
 
 export function TasksSection() {
   const { api } = useAPI();
 
   const [maxParallelAgentTasks, setMaxParallelAgentTasks] = React.useState<number>(3);
+  const [maxParallelAgentTasksInput, setMaxParallelAgentTasksInput] = React.useState<string>("3");
   const [maxTaskNestingDepth, setMaxTaskNestingDepth] = React.useState<number>(3);
+  const [maxTaskNestingDepthInput, setMaxTaskNestingDepthInput] = React.useState<string>("3");
+  const [error, setError] = React.useState<string | null>(null);
   const [isSaving, setIsSaving] = React.useState(false);
   const [isLoading, setIsLoading] = React.useState(true);
 
@@ -29,7 +46,10 @@ export function TasksSection() {
         }
 
         setMaxParallelAgentTasks(settings.maxParallelAgentTasks);
+        setMaxParallelAgentTasksInput(String(settings.maxParallelAgentTasks));
         setMaxTaskNestingDepth(settings.maxTaskNestingDepth);
+        setMaxTaskNestingDepthInput(String(settings.maxTaskNestingDepth));
+        setError(null);
       } finally {
         if (!cancelled) {
           setIsLoading(false);
@@ -47,16 +67,57 @@ export function TasksSection() {
       return;
     }
 
+    const parsedMaxParallelAgentTasks = parseIntOrNull(maxParallelAgentTasksInput);
+    const parsedMaxTaskNestingDepth = parseIntOrNull(maxTaskNestingDepthInput);
+
+    if (parsedMaxParallelAgentTasks === null || parsedMaxTaskNestingDepth === null) {
+      setError("Please enter valid numbers for task limits.");
+      setMaxParallelAgentTasksInput(String(maxParallelAgentTasks));
+      setMaxTaskNestingDepthInput(String(maxTaskNestingDepth));
+      return;
+    }
+
+    const nextMaxParallelAgentTasks = clampNumber(
+      parsedMaxParallelAgentTasks,
+      MAX_PARALLEL_AGENT_TASKS_MIN,
+      MAX_PARALLEL_AGENT_TASKS_MAX
+    );
+    const nextMaxTaskNestingDepth = clampNumber(
+      parsedMaxTaskNestingDepth,
+      MAX_TASK_NESTING_DEPTH_MIN,
+      MAX_TASK_NESTING_DEPTH_MAX
+    );
+
+    setMaxParallelAgentTasks(nextMaxParallelAgentTasks);
+    setMaxParallelAgentTasksInput(String(nextMaxParallelAgentTasks));
+    setMaxTaskNestingDepth(nextMaxTaskNestingDepth);
+    setMaxTaskNestingDepthInput(String(nextMaxTaskNestingDepth));
+
     setIsSaving(true);
+    setError(null);
     try {
       await api.tasks.setTaskSettings({
-        maxParallelAgentTasks,
-        maxTaskNestingDepth,
+        maxParallelAgentTasks: nextMaxParallelAgentTasks,
+        maxTaskNestingDepth: nextMaxTaskNestingDepth,
       });
+
+      const saved = await api.tasks.getTaskSettings();
+      setMaxParallelAgentTasks(saved.maxParallelAgentTasks);
+      setMaxParallelAgentTasksInput(String(saved.maxParallelAgentTasks));
+      setMaxTaskNestingDepth(saved.maxTaskNestingDepth);
+      setMaxTaskNestingDepthInput(String(saved.maxTaskNestingDepth));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to save task settings");
     } finally {
       setIsSaving(false);
     }
-  }, [api, maxParallelAgentTasks, maxTaskNestingDepth]);
+  }, [
+    api,
+    maxParallelAgentTasks,
+    maxParallelAgentTasksInput,
+    maxTaskNestingDepth,
+    maxTaskNestingDepthInput,
+  ]);
 
   return (
     <div className="space-y-4">
@@ -73,11 +134,30 @@ export function TasksSection() {
             <label className="text-sm">Max parallel subagents</label>
             <Input
               type="number"
-              min={1}
-              max={10}
-              value={maxParallelAgentTasks}
+              min={MAX_PARALLEL_AGENT_TASKS_MIN}
+              max={MAX_PARALLEL_AGENT_TASKS_MAX}
+              step={1}
+              value={maxParallelAgentTasksInput}
               disabled={isLoading}
-              onChange={(e) => setMaxParallelAgentTasks(Number(e.target.value))}
+              onChange={(e) => {
+                setMaxParallelAgentTasksInput(e.target.value);
+                setError(null);
+              }}
+              onBlur={(e) => {
+                const parsed = parseIntOrNull(e.target.value);
+                if (parsed === null) {
+                  setMaxParallelAgentTasksInput(String(maxParallelAgentTasks));
+                  return;
+                }
+
+                const clamped = clampNumber(
+                  parsed,
+                  MAX_PARALLEL_AGENT_TASKS_MIN,
+                  MAX_PARALLEL_AGENT_TASKS_MAX
+                );
+                setMaxParallelAgentTasks(clamped);
+                setMaxParallelAgentTasksInput(String(clamped));
+              }}
             />
           </div>
         </div>
@@ -87,18 +167,39 @@ export function TasksSection() {
             <label className="text-sm">Max nesting depth</label>
             <Input
               type="number"
-              min={1}
-              max={5}
-              value={maxTaskNestingDepth}
+              min={MAX_TASK_NESTING_DEPTH_MIN}
+              max={MAX_TASK_NESTING_DEPTH_MAX}
+              step={1}
+              value={maxTaskNestingDepthInput}
               disabled={isLoading}
-              onChange={(e) => setMaxTaskNestingDepth(Number(e.target.value))}
+              onChange={(e) => {
+                setMaxTaskNestingDepthInput(e.target.value);
+                setError(null);
+              }}
+              onBlur={(e) => {
+                const parsed = parseIntOrNull(e.target.value);
+                if (parsed === null) {
+                  setMaxTaskNestingDepthInput(String(maxTaskNestingDepth));
+                  return;
+                }
+
+                const clamped = clampNumber(
+                  parsed,
+                  MAX_TASK_NESTING_DEPTH_MIN,
+                  MAX_TASK_NESTING_DEPTH_MAX
+                );
+                setMaxTaskNestingDepth(clamped);
+                setMaxTaskNestingDepthInput(String(clamped));
+              }}
             />
           </div>
         </div>
 
         <Button onClick={() => void onSave()} disabled={isLoading || isSaving}>
           {isSaving ? "Saving..." : "Save"}
         </Button>
+
+        {error && <div className="text-error text-sm">{error}</div>}
       </div>
     </div>
   );
diff --git a/src/cli/cli.test.ts b/src/cli/cli.test.ts
@@ -57,6 +57,7 @@ async function createTestServer(authToken?: string): Promise<TestServerHandle> {
 
   // Build context
   const context: ORPCContext = {
+    taskService: services.taskService,
     config: services.config,
     aiService: services.aiService,
     projectService: services.projectService,
diff --git a/src/cli/server.test.ts b/src/cli/server.test.ts
@@ -60,6 +60,7 @@ async function createTestServer(): Promise<TestServerHandle> {
 
   // Build context
   const context: ORPCContext = {
+    taskService: services.taskService,
     config: services.config,
     aiService: services.aiService,
     projectService: services.projectService,
diff --git a/src/cli/server.ts b/src/cli/server.ts
@@ -76,6 +76,7 @@ const mockWindow: BrowserWindow = {
 
   // Build oRPC context from services
   const context: ORPCContext = {
+    taskService: serviceContainer.taskService,
     config: serviceContainer.config,
     aiService: serviceContainer.aiService,
     projectService: serviceContainer.projectService,
diff --git a/src/desktop/main.ts b/src/desktop/main.ts
@@ -323,6 +323,7 @@ async function loadServices(): Promise<void> {
   // Build the oRPC context with all services
   const orpcContext = {
     config: services.config,
+    taskService: services.taskService,
     aiService: services.aiService,
     projectService: services.projectService,
     workspaceService: services.workspaceService,
diff --git a/src/node/orpc/context.ts b/src/node/orpc/context.ts
@@ -1,6 +1,7 @@
 import type { IncomingHttpHeaders } from "http";
 import type { Config } from "@/node/config";
 import type { AIService } from "@/node/services/aiService";
+import type { TaskService } from "@/node/services/taskService";
 import type { ProjectService } from "@/node/services/projectService";
 import type { WorkspaceService } from "@/node/services/workspaceService";
 import type { ProviderService } from "@/node/services/providerService";
@@ -20,6 +21,7 @@ import type { SessionUsageService } from "@/node/services/sessionUsageService";
 
 export interface ORPCContext {
   config: Config;
+  taskService: TaskService;
   aiService: AIService;
   projectService: ProjectService;
   workspaceService: WorkspaceService;
diff --git a/src/node/orpc/router.ts b/src/node/orpc/router.ts
@@ -80,6 +80,7 @@ export const router = (authToken?: string) => {
         .output(schemas.tasks.setTaskSettings.output)
         .handler(async ({ context, input }) => {
           await context.config.setTaskSettings(input);
+          await context.taskService.rescheduleQueuedTasks();
         }),
     },
     server: {
diff --git a/src/node/services/taskService.ts b/src/node/services/taskService.ts
@@ -120,6 +120,16 @@ export class TaskService {
     await this.queueScheduling();
   }
 
+  /**
+   * Trigger a scheduler pass (e.g. after task settings change).
+   *
+   * Note: This does not block on any agent model calls; it only advances queued tasks into
+   * "running" and kicks off their resume streams.
+   */
+  async rescheduleQueuedTasks(): Promise<void> {
+    await this.queueScheduling();
+  }
+
   private formatErrorForReport(error: unknown): string {
     if (error instanceof Error) {
       return error.message;
diff --git a/tests/ipc/setup.ts b/tests/ipc/setup.ts
@@ -69,6 +69,7 @@ export async function createTestEnvironment(): Promise<TestEnvironment> {
   services.windowService.setMainWindow(mockWindow);
 
   const orpcContext: ORPCContext = {
+    taskService: services.taskService,
     config: services.config,
     aiService: services.aiService,
     projectService: services.projectService,
