Add configurable supervisor evaluation timeout

Author: root

packages/core/src/domain/supervisor.ts

@@ -48,6 +48,21 @@ export interface SupervisorConfig {
   guidanceDedupeWindow: number;
 }
 
+export const DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC = 600;
+export const MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC = 86_400;
+
+export function resolveSupervisorEvaluationTimeoutSec(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isSafeInteger(value)) {
+    return DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC;
+  }
+
+  if (value < 1 || value > MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC) {
+    return DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC;
+  }
+
+  return value;
+}
+
 export const DEFAULT_SUPERVISOR_CONFIG: SupervisorConfig = {
   maxCyclesPerSession: 100,
   terminalLinesForEvaluation: 500,

packages/core/src/domain/types.ts

@@ -138,6 +138,9 @@ export interface Settings {
     enabled: boolean;
     soundEnabled: boolean;
   };
+  supervisor: {
+    evaluationTimeoutSec: number;
+  };
   appearance: {
     theme: "dark";
     terminalRenderer: "standard" | "compatibility";

packages/server/src/__tests__/supervisor-manager.test.ts

@@ -137,6 +137,9 @@ function createManagerDeps() {
       providerId === "codex" ? { additionalArgs: [], envVars: {} } : undefined
     ),
   };
+  const settingsRepo = {
+    get: vi.fn(() => undefined),
+  };
 
   const supervisorRepo = {
     create: vi.fn((value: NewSupervisor) => {
@@ -222,6 +225,7 @@ function createManagerDeps() {
       }),
     ],
     providerConfigRepo,
+    settingsRepo,
     logger,
     supervisorRepo,
     cycleRepo,

packages/server/src/commands/settings.test.ts

@@ -45,6 +45,9 @@ describe("settings commands", () => {
               enabled: true,
               soundEnabled: false,
             },
+            supervisor: {
+              evaluationTimeoutSec: 600,
+            },
           },
         },
       },
@@ -61,6 +64,63 @@ describe("settings commands", () => {
     expect(
       db.prepare("SELECT value FROM user_settings WHERE key = ?").get("notifications.soundEnabled")
     ).toEqual({ value: "false" });
+    expect(
+      db
+        .prepare("SELECT value FROM user_settings WHERE key = ?")
+        .get("supervisor.evaluationTimeoutSec")
+    ).toEqual({ value: "600" });
+  });
+
+  it("settings.update rejects fractional supervisor timeout values", async () => {
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-update-supervisor-timeout-fractional",
+        op: "settings.update",
+        args: {
+          settings: {
+            supervisor: {
+              evaluationTimeoutSec: 1.9,
+            },
+          },
+        },
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.error?.code).toBe("validation_error");
+    expect(
+      db
+        .prepare("SELECT value FROM user_settings WHERE key = ?")
+        .get("supervisor.evaluationTimeoutSec")
+    ).toBeUndefined();
+  });
+
+  it("settings.update rejects supervisor timeout values above the supported maximum", async () => {
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-update-supervisor-timeout-too-large",
+        op: "settings.update",
+        args: {
+          settings: {
+            supervisor: {
+              evaluationTimeoutSec: 86_401,
+            },
+          },
+        },
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(false);
+    expect(result.error?.code).toBe("validation_error");
+    expect(
+      db
+        .prepare("SELECT value FROM user_settings WHERE key = ?")
+        .get("supervisor.evaluationTimeoutSec")
+    ).toBeUndefined();
   });
 
   it("settings.update persists provider startup command arguments per provider config", async () => {
@@ -191,6 +251,10 @@ describe("settings commands", () => {
       "notifications.enabled",
       "true"
     );
+    db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+      "supervisor.evaluationTimeoutSec",
+      "900"
+    );
 
     const result = await dispatch(
       {
@@ -206,6 +270,7 @@ describe("settings commands", () => {
     expect(result.data).toMatchObject({
       defaultProviderId: "codex",
       "notifications.enabled": true,
+      "supervisor.evaluationTimeoutSec": 900,
       externalConfigAudit: {
         codex: {
           configPath: "/tmp/config.toml",
@@ -215,4 +280,44 @@ describe("settings commands", () => {
       },
     });
   });
+
+  it("settings.get normalizes invalid persisted supervisor timeout values", async () => {
+    db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+      "supervisor.evaluationTimeoutSec",
+      "999999"
+    );
+
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-get-supervisor-timeout-invalid",
+        op: "settings.get",
+        args: {},
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data?.["supervisor.evaluationTimeoutSec"]).toBe(600);
+  });
+
+  it("settings.get falls back when the persisted supervisor timeout is fractional", async () => {
+    db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+      "supervisor.evaluationTimeoutSec",
+      "1.9"
+    );
+
+    const result = await dispatch(
+      {
+        kind: "command",
+        id: "settings-get-supervisor-timeout-fractional",
+        op: "settings.get",
+        args: {},
+      },
+      ctx
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.data?.["supervisor.evaluationTimeoutSec"]).toBe(600);
+  });
 });

packages/server/src/commands/settings.ts

@@ -2,6 +2,11 @@
  * Settings Commands
  */
 
+import {
+  DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC,
+  MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC,
+  resolveSupervisorEvaluationTimeoutSec,
+} from "@coder-studio/core";
 import { z } from "zod";
 import { type ConfigType, readConfigFile, writeConfigFile } from "../config/config-io.js";
 import {
@@ -12,6 +17,7 @@ import {
   sanitizeProviderLaunchConfig,
 } from "../provider-config.js";
 import { ProviderConfigRepo } from "../storage/repositories/provider-config-repo.js";
+import { SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY } from "../supervisor/settings.js";
 import { registerCommand } from "../ws/dispatch.js";
 
 const EMPTY_CODEX_AUDIT = {
@@ -35,6 +41,17 @@ const SettingsSchema = z.object({
       onlyWhenBackgrounded: z.boolean().optional(),
     })
     .optional(),
+  supervisor: z
+    .object({
+      evaluationTimeoutSec: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC)
+        .default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC)
+        .optional(),
+    })
+    .optional(),
   appearance: z
     .object({
       theme: z.enum(["dark"]).optional(),
@@ -88,6 +105,12 @@ registerCommand("settings.get", z.object({}), async (_args, ctx) => {
     settings.externalConfigAudit = null;
   }
 
+  if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY)) {
+    settings[SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY] = resolveSupervisorEvaluationTimeoutSec(
+      settings[SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY]
+    );
+  }
+
   return settings;
 });
 

packages/server/src/server.ts

@@ -33,6 +33,7 @@ import { AuthLoginBlockRepo } from "./storage/repositories/auth-login-block-repo
 import { AuthSessionRepo } from "./storage/repositories/auth-session-repo.js";
 import { ProviderConfigRepo } from "./storage/repositories/provider-config-repo.js";
 import { rowToSession, type SessionRow } from "./storage/repositories/session-repo.js";
+import { SettingsRepo } from "./storage/repositories/settings-repo.js";
 import { SupervisorCycleRepo } from "./storage/repositories/supervisor-cycle-repo.js";
 import { SupervisorRepo } from "./storage/repositories/supervisor-repo.js";
 import { SupervisorManager } from "./supervisor/manager.js";
@@ -119,6 +120,7 @@ export async function createServer(
 
   const sessionDb = createSessionDatabase(db);
   const providerConfigRepo = new ProviderConfigRepo(db);
+  const settingsRepo = new SettingsRepo(db);
   const sessionMgr = new SessionManager({
     terminalMgr,
     eventBus,
@@ -183,6 +185,7 @@ export async function createServer(
     sessionMgr,
     providerRegistry,
     providerConfigRepo,
+    settingsRepo,
     supervisorRepo,
     cycleRepo,
     logger: app.log,

packages/server/src/supervisor/evaluator.test.ts

@@ -1,12 +1,19 @@
 import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import type { ProviderDefinition, Supervisor } from "@coder-studio/core";
+import {
+  DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC,
+  type ProviderDefinition,
+  type Supervisor,
+} from "@coder-studio/core";
 import type { FastifyBaseLogger } from "fastify";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { closeDatabase, openDatabase } from "../storage/db.js";
 import type { ProviderConfigRepo } from "../storage/repositories/provider-config-repo.js";
+import { SettingsRepo } from "../storage/repositories/settings-repo.js";
 import type { SupervisorEvaluationContext } from "./context-builder.js";
 import { SupervisorEvaluator } from "./evaluator.js";
+import { getSupervisorEvaluationTimeoutMs } from "./settings.js";
 
 function nodeEchoCommand(stdout: string) {
   return {
@@ -190,6 +197,90 @@ describe("SupervisorEvaluator", () => {
     expect(result.message).toBe("proceed with review");
   });
 
+  it("uses the shared 600-second default timeout when the setting is missing", () => {
+    expect(getSupervisorEvaluationTimeoutMs()).toBe(
+      DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC * 1000
+    );
+    expect(
+      getSupervisorEvaluationTimeoutMs({
+        get: vi.fn(() => undefined),
+      } as never)
+    ).toBe(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC * 1000);
+  });
+
+  it("uses the stored supervisor timeout setting when available", () => {
+    expect(
+      getSupervisorEvaluationTimeoutMs({
+        get: vi.fn(() => 900),
+      } as never)
+    ).toBe(900_000);
+  });
+
+  it("falls back to the default timeout when the stored setting exceeds the supported maximum", () => {
+    expect(
+      getSupervisorEvaluationTimeoutMs({
+        get: vi.fn(() => 999_999_999),
+      } as never)
+    ).toBe(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC * 1000);
+  });
+
+  it("falls back to the default timeout when the stored setting is fractional", () => {
+    expect(
+      getSupervisorEvaluationTimeoutMs({
+        get: vi.fn(() => 1.9),
+      } as never)
+    ).toBe(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC * 1000);
+  });
+
+  it("falls back to the default timeout when reading the stored setting throws", () => {
+    expect(
+      getSupervisorEvaluationTimeoutMs({
+        get: vi.fn(() => {
+          throw new SyntaxError("Unexpected token");
+        }),
+      } as never)
+    ).toBe(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC * 1000);
+  });
+
+  it("reads the evaluator timeout from settingsRepo when timeoutMs is not provided", async () => {
+    const settingsRepo = {
+      get: vi.fn(() => 900),
+    };
+    const evaluator = new SupervisorEvaluator({
+      providerRegistry: [createProvider("codex", "next step: run tests")],
+      providerConfigRepo: createProviderConfigRepo(),
+      settingsRepo: settingsRepo as never,
+    });
+
+    const result = await evaluator.evaluate(makeSupervisor("codex"), makeContext());
+
+    expect(result.message).toBe("next step: run tests");
+    expect(settingsRepo.get).toHaveBeenCalledWith("supervisor.evaluationTimeoutSec");
+  });
+
+  it("falls back to the default timeout when the stored row is malformed JSON", async () => {
+    const db = openDatabase(":memory:");
+
+    try {
+      db.prepare("INSERT INTO user_settings (key, value) VALUES (?, ?)").run(
+        "supervisor.evaluationTimeoutSec",
+        "not-json"
+      );
+
+      const evaluator = new SupervisorEvaluator({
+        providerRegistry: [createProvider("codex", "next step: run tests")],
+        providerConfigRepo: createProviderConfigRepo(),
+        settingsRepo: new SettingsRepo(db),
+      });
+
+      const result = await evaluator.evaluate(makeSupervisor("codex"), makeContext());
+
+      expect(result.message).toBe("next step: run tests");
+    } finally {
+      closeDatabase(db);
+    }
+  });
+
   it("builds a natural language prompt matching the develop supervisor pattern", async () => {
     const logger = createLogger();
     const evaluator = new SupervisorEvaluator({