fix(coordinator): address PR125 polish nits

Author: brooksc

electron/mcp/agent-args.test.ts

@@ -28,6 +28,22 @@ describe('MCP agent launch args', () => {
     ]);
   });
 
+  it('quotes Codex inline config env keys so non-bare TOML keys remain valid', () => {
+    const override = buildCodexMcpConfigOverride({
+      mcpServers: {
+        'parallel-code': {
+          command: 'node',
+          args: [],
+          env: {
+            'TOKEN.WITH.DOTS': 'token-1',
+          },
+        },
+      },
+    });
+
+    expect(override).toContain('"TOKEN.WITH.DOTS" = "token-1"');
+  });
+
   it('uses --mcp-config for Claude-compatible agents', () => {
     expect(buildMcpLaunchArgs('claude', '/tmp/config.json', config)).toEqual([
       '--mcp-config',

electron/mcp/agent-args.ts

@@ -24,7 +24,7 @@ function tomlStringArray(values: string[]): string {
 
 function tomlStringMap(values: Record<string, string>): string {
   return `{ ${Object.entries(values)
-    .map(([key, value]) => `${key} = ${tomlString(value)}`)
+    .map(([key, value]) => `${tomlString(key)} = ${tomlString(value)}`)
     .join(', ')} }`;
 }
 

src/components/NewTaskDialog.tsx

@@ -32,6 +32,12 @@ import { ProjectSelect } from './ProjectSelect';
 import { SymlinkDirPicker } from './SymlinkDirPicker';
 import type { AgentDef } from '../ipc/types';
 import { DEFAULT_DOCKER_IMAGE, PROJECT_DOCKERFILE_RELATIVE_PATH } from '../lib/docker';
+import {
+  clampCoordinatorConcurrentTasks,
+  DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+  MAX_COORDINATOR_CONCURRENT_TASKS,
+  MIN_COORDINATOR_CONCURRENT_TASKS,
+} from '../lib/coordinator-limits';
 
 interface NewTaskDialogProps {
   open: boolean;
@@ -65,7 +71,9 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
   } | null>(null);
   const [coordinatorMode, setCoordinatorMode] = createSignal(false);
   const [propagateSkipPermissions, setPropagateSkipPermissions] = createSignal(false);
-  const [maxConcurrentTasks, setMaxConcurrentTasks] = createSignal(3);
+  const [maxConcurrentTasks, setMaxConcurrentTasks] = createSignal(
+    DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+  );
   const hasActiveCoordinator = () =>
     Object.values(store.tasks).some(
       (t) => t.coordinatorMode && !t.closingStatus && t.projectId === selectedProjectId(),
@@ -553,7 +561,9 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
           : undefined,
         coordinatorMode: coordinatorMode() || undefined,
         propagateSkipPermissions: coordinatorMode() ? propagateSkipPermissions() : undefined,
-        maxConcurrentTasks: coordinatorMode() ? maxConcurrentTasks() : undefined,
+        maxConcurrentTasks: coordinatorMode()
+          ? clampCoordinatorConcurrentTasks(maxConcurrentTasks())
+          : undefined,
       });
       // Drop flow: prefill prompt without auto-sending
       if (isFromDrop && p) {
@@ -1137,12 +1147,12 @@ export function NewTaskDialog(props: NewTaskDialogProps) {
                   Max concurrent sub-tasks:
                   <input
                     type="number"
-                    min="1"
-                    max="20"
+                    min={MIN_COORDINATOR_CONCURRENT_TASKS}
+                    max={MAX_COORDINATOR_CONCURRENT_TASKS}
                     value={maxConcurrentTasks()}
                     onInput={(e) => {
                       const v = parseInt(e.currentTarget.value, 10);
-                      if (!isNaN(v) && v >= 1) setMaxConcurrentTasks(v);
+                      if (!isNaN(v)) setMaxConcurrentTasks(clampCoordinatorConcurrentTasks(v));
                     }}
                     style={{
                       width: '60px',

src/lib/coordinator-limits.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  clampCoordinatorConcurrentTasks,
+  DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+} from './coordinator-limits';
+
+describe('clampCoordinatorConcurrentTasks', () => {
+  it('keeps values within the coordinator concurrency range', () => {
+    expect(clampCoordinatorConcurrentTasks(0)).toBe(1);
+    expect(clampCoordinatorConcurrentTasks(3)).toBe(3);
+    expect(clampCoordinatorConcurrentTasks(21)).toBe(20);
+  });
+
+  it('falls back to the default for invalid values', () => {
+    expect(clampCoordinatorConcurrentTasks(Number.NaN)).toBe(DEFAULT_COORDINATOR_CONCURRENT_TASKS);
+    expect(clampCoordinatorConcurrentTasks(Number.POSITIVE_INFINITY)).toBe(
+      DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+    );
+  });
+});

src/lib/coordinator-limits.ts

@@ -0,0 +1,11 @@
+export const MIN_COORDINATOR_CONCURRENT_TASKS = 1;
+export const MAX_COORDINATOR_CONCURRENT_TASKS = 20;
+export const DEFAULT_COORDINATOR_CONCURRENT_TASKS = 3;
+
+export function clampCoordinatorConcurrentTasks(value: number): number {
+  if (!Number.isFinite(value)) return DEFAULT_COORDINATOR_CONCURRENT_TASKS;
+  return Math.min(
+    MAX_COORDINATOR_CONCURRENT_TASKS,
+    Math.max(MIN_COORDINATOR_CONCURRENT_TASKS, Math.trunc(value)),
+  );
+}

src/store/tasks.ts

@@ -29,6 +29,10 @@ import { parseGitHubUrl, taskNameFromGitHubUrl } from '../lib/github-url';
 import type { Agent, Task, GitIsolationMode } from './types';
 import type { DockerSource } from '../lib/docker';
 import { COORDINATOR_PREAMBLE } from './coordinator-preamble';
+import {
+  clampCoordinatorConcurrentTasks,
+  DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+} from '../lib/coordinator-limits';
 import { getCoordinatorChildren, isCoordinatedChild } from './sidebar-order';
 
 function initTaskInStore(
@@ -257,7 +261,11 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
       opts.coordinatorMode && effectivePrompt
         ? COORDINATOR_PREAMBLE.replace(
             /\{\{MAX_CONCURRENT\}\}/g,
-            String(opts.maxConcurrentTasks ?? 3),
+            String(
+              clampCoordinatorConcurrentTasks(
+                opts.maxConcurrentTasks ?? DEFAULT_COORDINATOR_CONCURRENT_TASKS,
+              ),
+            ),
           ) +
           `Use \`${opts.baseBranch}\` as the baseBranch for all sub-tasks.\n\n` +
           effectivePrompt