@spencer-kit/coder-studio 0.3.4 → 0.3.6

package/dist/esm/bin.mjs

@@ -615,6 +615,7 @@ var init_config_schema2 = __esm({
   "packages/providers/src/codex/config-schema.ts"() {
     "use strict";
     codexConfigSchema = z2.object({
+      model: z2.string().min(1).optional(),
       additionalArgs: z2.array(z2.string()).default([]),
       envVars: z2.record(z2.string(), z2.string()).default({})
     });
@@ -661,6 +662,7 @@ function buildCodexSupervisorEvalCommand(config, req) {
       "-s",
       "read-only",
       "--skip-git-repo-check",
+      ...req.model ? ["-m", req.model] : [],
       ...cfg.additionalArgs,
       req.prompt
     ],
@@ -2727,12 +2729,46 @@ function resolveSupervisorEvaluationTimeoutSec(value) {
   }
   return value;
 }
-var DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC, MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC, DEFAULT_SUPERVISOR_CONFIG;
+function resolveSupervisorRetryEnabled(value) {
+  return typeof value === "boolean" ? value : DEFAULT_SUPERVISOR_RETRY_ENABLED;
+}
+function resolveSupervisorRetryMaxCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isSafeInteger(value)) {
+    return DEFAULT_SUPERVISOR_RETRY_MAX_COUNT;
+  }
+  if (value < 0 || value > MAX_SUPERVISOR_RETRY_MAX_COUNT) {
+    return DEFAULT_SUPERVISOR_RETRY_MAX_COUNT;
+  }
+  return value;
+}
+function resolveSupervisorRetryDelaySec(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isSafeInteger(value)) {
+    return DEFAULT_SUPERVISOR_RETRY_DELAY_SEC;
+  }
+  if (value < 1 || value > MAX_SUPERVISOR_RETRY_DELAY_SEC) {
+    return DEFAULT_SUPERVISOR_RETRY_DELAY_SEC;
+  }
+  return value;
+}
+function resolveSupervisorRetryOnTimeout(value) {
+  return typeof value === "boolean" ? value : DEFAULT_SUPERVISOR_RETRY_ON_TIMEOUT;
+}
+function resolveSupervisorRetryOnEvaluatorError(value) {
+  return typeof value === "boolean" ? value : DEFAULT_SUPERVISOR_RETRY_ON_EVALUATOR_ERROR;
+}
+var DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC, MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC, DEFAULT_SUPERVISOR_RETRY_ENABLED, DEFAULT_SUPERVISOR_RETRY_MAX_COUNT, MAX_SUPERVISOR_RETRY_MAX_COUNT, DEFAULT_SUPERVISOR_RETRY_DELAY_SEC, MAX_SUPERVISOR_RETRY_DELAY_SEC, DEFAULT_SUPERVISOR_RETRY_ON_TIMEOUT, DEFAULT_SUPERVISOR_RETRY_ON_EVALUATOR_ERROR, DEFAULT_SUPERVISOR_CONFIG;
 var init_supervisor = __esm({
   "packages/core/src/domain/supervisor.ts"() {
     "use strict";
     DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC = 600;
     MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC = 86400;
+    DEFAULT_SUPERVISOR_RETRY_ENABLED = false;
+    DEFAULT_SUPERVISOR_RETRY_MAX_COUNT = 0;
+    MAX_SUPERVISOR_RETRY_MAX_COUNT = 20;
+    DEFAULT_SUPERVISOR_RETRY_DELAY_SEC = 10;
+    MAX_SUPERVISOR_RETRY_DELAY_SEC = 3600;
+    DEFAULT_SUPERVISOR_RETRY_ON_TIMEOUT = true;
+    DEFAULT_SUPERVISOR_RETRY_ON_EVALUATOR_ERROR = false;
     DEFAULT_SUPERVISOR_CONFIG = {
       maxCyclesPerSession: 100,
       terminalLinesForEvaluation: 500,
@@ -3760,7 +3796,7 @@ var init_database = __esm({
   }
 });
 
-// packages/server/src/storage/db.ts
+// packages/server/src/storage/schema-version.ts
 import { DatabaseSync } from "node:sqlite";
 import { readFileSync as readFileSync4 } from "fs";
 import { join as join3 } from "path";
@@ -3784,15 +3820,229 @@ function listSchemaEntries(db) {
     sql: normalizeSql(row.sql)
   }));
 }
-function buildExpectedSchemaEntries() {
+function schemaEntrySignature(entry) {
+  return `${entry.type}:${entry.name}:${entry.tableName}:${entry.sql}`;
+}
+function buildSchemaEntries(schemaSql) {
   const db = new DatabaseSync(":memory:");
   try {
-    db.exec(SCHEMA_SQL);
+    db.exec(schemaSql);
     return listSchemaEntries(db);
   } finally {
     db.close();
   }
 }
+function hasExactFingerprint(actualEntries, expectedEntries) {
+  if (actualEntries.length !== expectedEntries.length) {
+    return false;
+  }
+  return actualEntries.every(
+    (entry, index) => schemaEntrySignature(entry) === schemaEntrySignature(expectedEntries[index])
+  );
+}
+function describeSchemaMismatch(expected, actual) {
+  const expectedByName = new Map(expected.map((entry) => [`${entry.type}:${entry.name}`, entry]));
+  const actualByName = new Map(actual.map((entry) => [`${entry.type}:${entry.name}`, entry]));
+  const keys = /* @__PURE__ */ new Set([...expectedByName.keys(), ...actualByName.keys()]);
+  for (const key of keys) {
+    const expectedEntry = expectedByName.get(key);
+    const actualEntry = actualByName.get(key);
+    if (!expectedEntry) {
+      return `unexpected ${actualEntry?.type ?? "schema object"} ${actualEntry?.name ?? key}`;
+    }
+    if (!actualEntry) {
+      return `missing ${expectedEntry.type} ${expectedEntry.name}`;
+    }
+    if (schemaEntrySignature(expectedEntry) !== schemaEntrySignature(actualEntry)) {
+      return `definition mismatch for ${expectedEntry.type} ${expectedEntry.name}`;
+    }
+  }
+  return "unknown schema drift";
+}
+function detectSchema(db) {
+  const actualEntries = listSchemaEntries(db);
+  const userVersionRow = db.prepare("PRAGMA user_version").get();
+  const userVersion = userVersionRow?.user_version ?? 0;
+  if (actualEntries.length === 0) {
+    return {
+      state: "empty",
+      userVersion,
+      mismatch: null
+    };
+  }
+  if (hasExactFingerprint(actualEntries, CURRENT_SCHEMA_ENTRIES)) {
+    return {
+      state: "current",
+      userVersion,
+      mismatch: null
+    };
+  }
+  if (hasExactFingerprint(actualEntries, V1_SCHEMA_ENTRIES)) {
+    return {
+      state: "v1",
+      userVersion,
+      mismatch: null
+    };
+  }
+  return {
+    state: "incompatible",
+    userVersion,
+    mismatch: describeSchemaMismatch(CURRENT_SCHEMA_ENTRIES, actualEntries)
+  };
+}
+function stampCurrentSchemaVersion(db) {
+  db.exec(`PRAGMA user_version = ${CURRENT_SCHEMA_VERSION}`);
+}
+var CURRENT_SCHEMA_VERSION, CURRENT_SCHEMA_PATH, CURRENT_SCHEMA_SQL, V1_SCHEMA_SQL, CURRENT_SCHEMA_ENTRIES, V1_SCHEMA_ENTRIES, IncompatibleSchemaError;
+var init_schema_version = __esm({
+  "packages/server/src/storage/schema-version.ts"() {
+    "use strict";
+    CURRENT_SCHEMA_VERSION = 2;
+    CURRENT_SCHEMA_PATH = join3(import.meta.dirname, "migrations", "001_init.sql");
+    CURRENT_SCHEMA_SQL = readFileSync4(CURRENT_SCHEMA_PATH, "utf-8");
+    V1_SCHEMA_SQL = `
+CREATE TABLE workspaces (
+  id TEXT PRIMARY KEY,
+  path TEXT NOT NULL UNIQUE,
+  target_runtime TEXT NOT NULL,
+  wsl_distro TEXT,
+  opened_at INTEGER NOT NULL,
+  last_active_at INTEGER NOT NULL,
+  ui_state TEXT
+);
+
+CREATE TABLE terminals (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL,
+  cwd TEXT NOT NULL,
+  argv TEXT NOT NULL,
+  env TEXT,
+  title TEXT,
+  cols INTEGER NOT NULL,
+  rows INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  exit_code INTEGER
+);
+
+CREATE INDEX idx_terminals_workspace ON terminals(workspace_id);
+CREATE INDEX idx_terminals_kind ON terminals(workspace_id, kind);
+
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+  terminal_id TEXT NOT NULL REFERENCES terminals(id) ON DELETE CASCADE,
+  provider_id TEXT NOT NULL,
+  capability TEXT NOT NULL,
+  state TEXT NOT NULL,
+  started_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  last_active_at INTEGER NOT NULL,
+  completion_percent INTEGER,
+  error_reason TEXT,
+  archived BOOLEAN DEFAULT 0,
+  title TEXT
+);
+
+CREATE INDEX idx_sessions_workspace ON sessions(workspace_id);
+CREATE UNIQUE INDEX idx_sessions_terminal ON sessions(terminal_id);
+CREATE UNIQUE INDEX idx_sessions_id_workspace ON sessions(id, workspace_id);
+
+CREATE TABLE provider_configs (
+  provider_id TEXT PRIMARY KEY,
+  config TEXT NOT NULL
+);
+
+CREATE TABLE user_settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE auth_sessions (
+  token TEXT PRIMARY KEY,
+  created_at INTEGER NOT NULL,
+  last_seen_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_auth_sessions_last_seen_at ON auth_sessions(last_seen_at);
+
+CREATE TABLE supervisors (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL UNIQUE,
+  workspace_id TEXT NOT NULL,
+  state TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  evaluator_provider_id TEXT NOT NULL,
+  last_cycle_at INTEGER,
+  last_evaluated_turn_id TEXT,
+  error_reason TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (session_id, workspace_id) REFERENCES sessions(id, workspace_id) ON DELETE CASCADE,
+  FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_supervisors_workspace ON supervisors(workspace_id);
+CREATE INDEX idx_supervisors_session ON supervisors(session_id);
+CREATE UNIQUE INDEX idx_supervisors_id_session ON supervisors(id, session_id);
+
+CREATE TABLE supervisor_cycles (
+  id TEXT PRIMARY KEY,
+  supervisor_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  trigger TEXT NOT NULL,
+  evidence_source TEXT NOT NULL,
+  objective TEXT NOT NULL,
+  evaluator_provider_id TEXT NOT NULL,
+  turn_id TEXT,
+  progress INTEGER,
+  result TEXT,
+  injected_guidance TEXT,
+  error_reason TEXT,
+  created_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  FOREIGN KEY (supervisor_id, session_id) REFERENCES supervisors(id, session_id) ON DELETE CASCADE,
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_supervisor_cycles_supervisor ON supervisor_cycles(supervisor_id, created_at DESC);
+CREATE INDEX idx_supervisor_cycles_session ON supervisor_cycles(session_id, created_at DESC);
+
+CREATE TABLE auth_login_blocks (
+  ip TEXT PRIMARY KEY,
+  failed_count INTEGER NOT NULL,
+  first_failed_at INTEGER NOT NULL,
+  last_failed_at INTEGER NOT NULL,
+  blocked_until INTEGER
+);
+
+CREATE INDEX idx_auth_login_blocks_blocked_until ON auth_login_blocks(blocked_until);
+
+CREATE TABLE auth_login_failures (
+  ip TEXT NOT NULL,
+  failed_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_auth_login_failures_ip_failed_at ON auth_login_failures(ip, failed_at);
+`;
+    CURRENT_SCHEMA_ENTRIES = buildSchemaEntries(CURRENT_SCHEMA_SQL);
+    V1_SCHEMA_ENTRIES = buildSchemaEntries(V1_SCHEMA_SQL);
+    IncompatibleSchemaError = class extends Error {
+      code = "db_incompatible_schema";
+      constructor(dbPath, mismatch) {
+        super(
+          `db_incompatible_schema: Database schema mismatch detected at ${dbPath}: ${mismatch}. This build requires the current baseline schema. Delete the local database file and restart.`
+        );
+        this.name = "IncompatibleSchemaError";
+      }
+    };
+  }
+});
+
+// packages/server/src/storage/db.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function hasTable(db, tableName) {
   const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(tableName);
   return row?.name === tableName;
@@ -3819,68 +4069,75 @@ function detectLegacySchema(db) {
   }
   return reasons;
 }
-function schemaEntrySignature(entry) {
-  return `${entry.type}:${entry.name}:${entry.tableName}:${entry.sql}`;
-}
-function isSchemaEmpty(db) {
-  return listSchemaEntries(db).length === 0;
-}
-function assertNoLegacySchema(db, dbPath) {
+function throwIfLegacySchema(db, dbPath) {
   const reasons = detectLegacySchema(db);
   if (reasons.length === 0) {
     return;
   }
-  throw new Error(
-    `Legacy database schema detected at ${dbPath}: ${reasons.join(", ")}. This build no longer supports automatic database upgrades. Delete the local database file and restart.`
-  );
-}
-function describeSchemaMismatch(expected, actual) {
-  const expectedByName = new Map(expected.map((entry) => [`${entry.type}:${entry.name}`, entry]));
-  const actualByName = new Map(actual.map((entry) => [`${entry.type}:${entry.name}`, entry]));
-  const keys = /* @__PURE__ */ new Set([...expectedByName.keys(), ...actualByName.keys()]);
-  for (const key of keys) {
-    const expectedEntry = expectedByName.get(key);
-    const actualEntry = actualByName.get(key);
-    if (!expectedEntry) {
-      return `unexpected ${actualEntry?.type ?? "schema object"} ${actualEntry?.name ?? key}`;
-    }
-    if (!actualEntry) {
-      return `missing ${expectedEntry.type} ${expectedEntry.name}`;
-    }
-    if (schemaEntrySignature(expectedEntry) !== schemaEntrySignature(actualEntry)) {
-      return `definition mismatch for ${expectedEntry.type} ${expectedEntry.name}`;
-    }
-  }
-  return "unknown schema drift";
-}
-function assertSchemaMatchesBaseline(db, dbPath) {
-  const actualEntries = listSchemaEntries(db);
-  const expectedSignatures = EXPECTED_SCHEMA_ENTRIES.map(schemaEntrySignature);
-  const actualSignatures = actualEntries.map(schemaEntrySignature);
-  if (actualSignatures.length === expectedSignatures.length && actualSignatures.every((signature, index) => signature === expectedSignatures[index])) {
-    return;
-  }
-  const mismatch = describeSchemaMismatch(EXPECTED_SCHEMA_ENTRIES, actualEntries);
-  throw new Error(
-    `Database schema mismatch detected at ${dbPath}: ${mismatch}. This build requires the current baseline schema. Delete the local database file and restart.`
-  );
+  throw new IncompatibleSchemaError(dbPath, `legacy schema detected (${reasons.join(", ")})`);
 }
 function initializeSchema(db) {
   withTransaction(db, () => {
-    db.exec(SCHEMA_SQL);
+    db.exec(CURRENT_SCHEMA_SQL);
   });
 }
-function initializeOrValidateSchema(db, dbPath) {
-  assertNoLegacySchema(db, dbPath);
-  if (isSchemaEmpty(db)) {
-    initializeSchema(db);
-    assertSchemaMatchesBaseline(db, dbPath);
-    return;
+function upgradeSchemaV1ToV2(db) {
+  withTransaction(db, () => {
+    db.exec("ALTER TABLE supervisors ADD COLUMN evaluator_model TEXT");
+    db.exec("ALTER TABLE supervisors ADD COLUMN max_supervision_count INTEGER NOT NULL DEFAULT 0");
+    db.exec(
+      "ALTER TABLE supervisors ADD COLUMN completed_supervision_count INTEGER NOT NULL DEFAULT 0"
+    );
+    db.exec("ALTER TABLE supervisors ADD COLUMN scheduled_at INTEGER");
+    db.exec("ALTER TABLE supervisors ADD COLUMN stop_reason TEXT");
+    db.exec(`
+      CREATE TABLE supervisor_cycle_attempts (
+        id TEXT PRIMARY KEY,
+        cycle_id TEXT NOT NULL REFERENCES supervisor_cycles(id) ON DELETE CASCADE,
+        attempt_index INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        error_reason TEXT,
+        provider_model TEXT
+      )
+    `);
+    db.exec(
+      "CREATE INDEX idx_supervisor_cycle_attempts_cycle ON supervisor_cycle_attempts(cycle_id, attempt_index)"
+    );
+    stampCurrentSchemaVersion(db);
+  });
+}
+function assertCurrentSchema(db, dbPath) {
+  const detection = detectSchema(db);
+  if (detection.state !== "current") {
+    throw new IncompatibleSchemaError(dbPath, detection.mismatch ?? "unknown schema drift");
+  }
+}
+function initializeOrUpgradeSchema(db, dbPath) {
+  throwIfLegacySchema(db, dbPath);
+  const detection = detectSchema(db);
+  switch (detection.state) {
+    case "empty":
+      initializeSchema(db);
+      assertCurrentSchema(db, dbPath);
+      return;
+    case "current":
+      if (detection.userVersion !== CURRENT_SCHEMA_VERSION) {
+        stampCurrentSchemaVersion(db);
+      }
+      assertCurrentSchema(db, dbPath);
+      return;
+    case "v1":
+      upgradeSchemaV1ToV2(db);
+      assertCurrentSchema(db, dbPath);
+      return;
+    case "incompatible":
+      throw new IncompatibleSchemaError(dbPath, detection.mismatch ?? "unknown schema drift");
   }
-  assertSchemaMatchesBaseline(db, dbPath);
 }
 function openDatabase(dbPath) {
-  const db = new DatabaseSync(dbPath);
+  const db = new DatabaseSync2(dbPath);
   try {
     db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA foreign_keys = ON");
@@ -3888,7 +4145,7 @@ function openDatabase(dbPath) {
     if (integrityResult[0]?.integrity_check !== "ok") {
       throw new Error(`Database integrity check failed: ${JSON.stringify(integrityResult)}`);
     }
-    initializeOrValidateSchema(db, dbPath);
+    initializeOrUpgradeSchema(db, dbPath);
     return db;
   } catch (error) {
     try {
@@ -3905,16 +4162,14 @@ function closeDatabase(db) {
     db.close();
   }
 }
-var SCHEMA_PATH, SCHEMA_SQL, LEGACY_TABLES, LEGACY_SESSION_COLUMNS, EXPECTED_SCHEMA_ENTRIES;
+var LEGACY_TABLES, LEGACY_SESSION_COLUMNS;
 var init_db = __esm({
   "packages/server/src/storage/db.ts"() {
     "use strict";
     init_database();
-    SCHEMA_PATH = join3(import.meta.dirname, "migrations", "001_init.sql");
-    SCHEMA_SQL = readFileSync4(SCHEMA_PATH, "utf-8");
+    init_schema_version();
     LEGACY_TABLES = ["hook_registrations", "_migrations"];
     LEGACY_SESSION_COLUMNS = ["resume_id", "transcript_path"];
-    EXPECTED_SCHEMA_ENTRIES = buildExpectedSchemaEntries();
   }
 });
 
@@ -4164,6 +4419,93 @@ var init_settings_repo = __esm({
   }
 });
 
+// packages/server/src/storage/repositories/supervisor-cycle-attempt-repo.ts
+var SupervisorCycleAttemptRepo;
+var init_supervisor_cycle_attempt_repo = __esm({
+  "packages/server/src/storage/repositories/supervisor-cycle-attempt-repo.ts"() {
+    "use strict";
+    SupervisorCycleAttemptRepo = class {
+      constructor(db) {
+        this.db = db;
+      }
+      db;
+      create(input2) {
+        this.db.prepare(
+          `INSERT INTO supervisor_cycle_attempts (id, cycle_id, attempt_index, status, started_at, completed_at, error_reason, provider_model)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          input2.id,
+          input2.cycleId,
+          input2.attemptIndex,
+          input2.status,
+          input2.startedAt,
+          input2.completedAt ?? null,
+          input2.errorReason ?? null,
+          input2.providerModel ?? null
+        );
+        return this.findById(input2.id);
+      }
+      findById(id) {
+        const row = this.db.prepare("SELECT * FROM supervisor_cycle_attempts WHERE id = ?").get(id);
+        return row ? this.rowToAttempt(row) : void 0;
+      }
+      listForCycle(cycleId) {
+        const rows = this.db.prepare(
+          "SELECT * FROM supervisor_cycle_attempts WHERE cycle_id = ? ORDER BY attempt_index ASC"
+        ).all(cycleId);
+        return rows.map((row) => this.rowToAttempt(row));
+      }
+      update(id, patch) {
+        const assignments = [];
+        const params = { id };
+        if (patch.status !== void 0) {
+          assignments.push("status = @status");
+          params.status = patch.status;
+        }
+        if (patch.completedAt !== void 0) {
+          assignments.push("completed_at = @completedAt");
+          params.completedAt = patch.completedAt;
+        }
+        if (patch.errorReason !== void 0) {
+          assignments.push("error_reason = @errorReason");
+          params.errorReason = patch.errorReason;
+        }
+        if (patch.providerModel !== void 0) {
+          assignments.push("provider_model = @providerModel");
+          params.providerModel = patch.providerModel;
+        }
+        if (assignments.length === 0) {
+          const existing = this.findById(id);
+          if (!existing) {
+            throw new Error(`Supervisor cycle attempt not found: ${id}`);
+          }
+          return existing;
+        }
+        const result = this.db.prepare(`UPDATE supervisor_cycle_attempts SET ${assignments.join(", ")} WHERE id = @id`).run(params);
+        if (result.changes === 0) {
+          throw new Error(`Supervisor cycle attempt not found: ${id}`);
+        }
+        return this.findById(id);
+      }
+      deleteForCycle(cycleId) {
+        this.db.prepare("DELETE FROM supervisor_cycle_attempts WHERE cycle_id = ?").run(cycleId);
+      }
+      rowToAttempt(row) {
+        return {
+          id: row.id,
+          cycleId: row.cycle_id,
+          attemptIndex: row.attempt_index,
+          status: row.status,
+          startedAt: row.started_at,
+          completedAt: row.completed_at ?? void 0,
+          errorReason: row.error_reason ?? void 0,
+          providerModel: row.provider_model ?? void 0
+        };
+      }
+    };
+  }
+});
+
 // packages/server/src/storage/repositories/supervisor-cycle-repo.ts
 var SupervisorCycleRepo;
 var init_supervisor_cycle_repo = __esm({
@@ -4293,8 +4635,8 @@ var init_supervisor_repo = __esm({
       db;
       create(input2) {
         this.db.prepare(
-          `INSERT INTO supervisors (id, session_id, workspace_id, state, objective, evaluator_provider_id, last_cycle_at, last_evaluated_turn_id, error_reason, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          `INSERT INTO supervisors (id, session_id, workspace_id, state, objective, evaluator_provider_id, evaluator_model, max_supervision_count, completed_supervision_count, scheduled_at, stop_reason, last_cycle_at, last_evaluated_turn_id, error_reason, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         ).run(
           input2.id,
           input2.sessionId,
@@ -4302,6 +4644,11 @@ var init_supervisor_repo = __esm({
           input2.state,
           input2.objective,
           input2.evaluatorProviderId,
+          input2.evaluatorModel ?? null,
+          input2.maxSupervisionCount ?? 0,
+          input2.completedSupervisionCount ?? 0,
+          input2.scheduledAt ?? null,
+          input2.stopReason ?? null,
           input2.lastCycleAt ?? null,
           input2.lastEvaluatedTurnId ?? null,
           input2.errorReason ?? null,
@@ -4340,6 +4687,26 @@ var init_supervisor_repo = __esm({
           assignments.push("evaluator_provider_id = @evaluatorProviderId");
           params.evaluatorProviderId = patch.evaluatorProviderId;
         }
+        if (patch.evaluatorModel !== void 0) {
+          assignments.push("evaluator_model = @evaluatorModel");
+          params.evaluatorModel = patch.evaluatorModel;
+        }
+        if (patch.maxSupervisionCount !== void 0) {
+          assignments.push("max_supervision_count = @maxSupervisionCount");
+          params.maxSupervisionCount = patch.maxSupervisionCount;
+        }
+        if (patch.completedSupervisionCount !== void 0) {
+          assignments.push("completed_supervision_count = @completedSupervisionCount");
+          params.completedSupervisionCount = patch.completedSupervisionCount;
+        }
+        if (patch.scheduledAt !== void 0) {
+          assignments.push("scheduled_at = @scheduledAt");
+          params.scheduledAt = patch.scheduledAt;
+        }
+        if (patch.stopReason !== void 0) {
+          assignments.push("stop_reason = @stopReason");
+          params.stopReason = patch.stopReason;
+        }
         if (patch.lastCycleAt !== void 0) {
           assignments.push("last_cycle_at = @lastCycleAt");
           params.lastCycleAt = patch.lastCycleAt;
@@ -4369,6 +4736,11 @@ var init_supervisor_repo = __esm({
           state: row.state,
           objective: row.objective,
           evaluatorProviderId: row.evaluator_provider_id,
+          evaluatorModel: row.evaluator_model ?? void 0,
+          maxSupervisionCount: row.max_supervision_count,
+          completedSupervisionCount: row.completed_supervision_count,
+          scheduledAt: row.scheduled_at ?? void 0,
+          stopReason: row.stop_reason ?? void 0,
           cycles: [],
           lastCycleAt: row.last_cycle_at ?? void 0,
           lastEvaluatedTurnId: row.last_evaluated_turn_id ?? void 0,
@@ -5556,12 +5928,63 @@ function getSupervisorEvaluationTimeoutMs(settingsRepo) {
   const timeoutSec = resolveSupervisorEvaluationTimeoutSec(storedValue);
   return timeoutSec * 1e3;
 }
-var SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY;
+function getSettingOrDefault(settingsRepo, key, fallback) {
+  try {
+    return settingsRepo?.get(key) ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+function getSupervisorRetrySettings(settingsRepo) {
+  return {
+    retryEnabled: resolveSupervisorRetryEnabled(
+      getSettingOrDefault(
+        settingsRepo,
+        SUPERVISOR_RETRY_ENABLED_SETTING_KEY,
+        DEFAULT_SUPERVISOR_RETRY_ENABLED
+      )
+    ),
+    retryMaxCount: resolveSupervisorRetryMaxCount(
+      getSettingOrDefault(
+        settingsRepo,
+        SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY,
+        DEFAULT_SUPERVISOR_RETRY_MAX_COUNT
+      )
+    ),
+    retryDelaySec: resolveSupervisorRetryDelaySec(
+      getSettingOrDefault(
+        settingsRepo,
+        SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY,
+        DEFAULT_SUPERVISOR_RETRY_DELAY_SEC
+      )
+    ),
+    retryOnTimeout: resolveSupervisorRetryOnTimeout(
+      getSettingOrDefault(
+        settingsRepo,
+        SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY,
+        DEFAULT_SUPERVISOR_RETRY_ON_TIMEOUT
+      )
+    ),
+    retryOnEvaluatorError: resolveSupervisorRetryOnEvaluatorError(
+      getSettingOrDefault(
+        settingsRepo,
+        SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY,
+        DEFAULT_SUPERVISOR_RETRY_ON_EVALUATOR_ERROR
+      )
+    )
+  };
+}
+var SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY, SUPERVISOR_RETRY_ENABLED_SETTING_KEY, SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY, SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY, SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY, SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY;
 var init_settings = __esm({
   "packages/server/src/supervisor/settings.ts"() {
     "use strict";
     init_src3();
     SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY = "supervisor.evaluationTimeoutSec";
+    SUPERVISOR_RETRY_ENABLED_SETTING_KEY = "supervisor.retryEnabled";
+    SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY = "supervisor.retryMaxCount";
+    SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY = "supervisor.retryDelaySec";
+    SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY = "supervisor.retryOnTimeout";
+    SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY = "supervisor.retryOnEvaluatorError";
   }
 });
 
@@ -5783,6 +6206,12 @@ function extractSupervisorMessage(output2, providerId) {
   }
   const lines = trimmed.split(/\r?\n/).filter(Boolean);
   if (providerId === "codex") {
+    if (trimmed === "[objective complete]") {
+      return trimmed;
+    }
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return stripCodeFence(trimmed);
+    }
     const scan = scanCodexStream(lines);
     if (scan.turnFailure) {
       throw new Error(`Supervisor (codex) failed: ${scan.turnFailure}`);
@@ -5884,7 +6313,7 @@ var init_evaluator = __esm({
           prompt,
           sessionId: supervisor.sessionId,
           workspacePath: context.workspacePath,
-          model: typeof config.model === "string" ? config.model : void 0
+          model: typeof supervisor.evaluatorModel === "string" && supervisor.evaluatorModel.trim() ? supervisor.evaluatorModel.trim() : typeof config.model === "string" ? config.model : void 0
         });
         if (!command) {
           throw {
@@ -5913,7 +6342,11 @@ var init_evaluator = __esm({
           );
           throw error;
         }
-        return { message: message.slice(0, this.config.guidanceMaxChars) };
+        const normalizedMessage = message.slice(0, this.config.guidanceMaxChars);
+        return {
+          message: normalizedMessage,
+          objectiveComplete: normalizedMessage.trim() === "[objective complete]"
+        };
       }
     };
   }
@@ -5949,7 +6382,13 @@ var init_injector = __esm({
       }
       deps;
       config;
-      async inject(supervisor, input2, recentCycles) {
+      async inject(supervisor, input2, recentCycles, options = {}) {
+        if (options.signal?.aborted) {
+          throw {
+            code: "supervisor_eval_aborted",
+            message: "Supervisor evaluator aborted"
+          };
+        }
         const session = this.deps.sessionMgr.get(supervisor.sessionId);
         if (!session) {
           throw {
@@ -5970,6 +6409,12 @@ var init_injector = __esm({
         if (duplicate) {
           return { injected: false, text };
         }
+        if (options.signal?.aborted) {
+          throw {
+            code: "supervisor_eval_aborted",
+            message: "Supervisor evaluator aborted"
+          };
+        }
         const BRACKETED_PASTE_START = "\x1B[200~";
         const BRACKETED_PASTE_END = "\x1B[201~";
         const SUBMIT = "\r";
@@ -5992,6 +6437,9 @@ var init_scheduler = __esm({
       }
       deps;
       unsubscribe = null;
+      scheduledTimer = null;
+      scheduledRetryDelayMs = 1e3;
+      retryAtBySupervisorId = /* @__PURE__ */ new Map();
       start() {
         this.unsubscribe?.();
         this.unsubscribe = this.deps.eventBus.on(
@@ -6004,9 +6452,64 @@ var init_scheduler = __esm({
           }
         );
       }
+      refresh() {
+        this.clearScheduledTimer();
+        const scheduled = this.deps.listScheduledSupervisors?.() ?? [];
+        this.pruneRetryState(scheduled);
+        if (scheduled.length === 0) {
+          return;
+        }
+        const now = Date.now();
+        const nextAt = scheduled.reduce((earliest, item) => {
+          const candidate = this.getNextAttemptAt(item, now);
+          return candidate < earliest ? candidate : earliest;
+        }, Number.POSITIVE_INFINITY);
+        if (!Number.isFinite(nextAt)) {
+          return;
+        }
+        const delayMs = Math.max(nextAt - now, 0);
+        this.scheduledTimer = setTimeout(() => {
+          this.scheduledTimer = null;
+          const current = this.deps.listScheduledSupervisors?.() ?? [];
+          this.pruneRetryState(current);
+          const dueAt = Date.now();
+          const due = current.filter(
+            (item) => item.scheduledAt <= dueAt && (this.retryAtBySupervisorId.get(item.supervisorId) ?? Number.NEGATIVE_INFINITY) <= dueAt
+          );
+          for (const item of due) {
+            this.retryAtBySupervisorId.set(item.supervisorId, dueAt + this.scheduledRetryDelayMs);
+            this.deps.onScheduledDue?.(item.supervisorId);
+          }
+          this.refresh();
+        }, delayMs);
+        this.scheduledTimer.unref?.();
+      }
       stop() {
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.clearScheduledTimer();
+        this.retryAtBySupervisorId.clear();
+      }
+      clearScheduledTimer() {
+        if (this.scheduledTimer) {
+          clearTimeout(this.scheduledTimer);
+          this.scheduledTimer = null;
+        }
+      }
+      getNextAttemptAt(item, now) {
+        if (item.scheduledAt > now) {
+          return item.scheduledAt;
+        }
+        const retryAt = this.retryAtBySupervisorId.get(item.supervisorId);
+        return retryAt && retryAt > now ? retryAt : item.scheduledAt;
+      }
+      pruneRetryState(scheduled) {
+        const scheduledIds = new Set(scheduled.map((item) => item.supervisorId));
+        for (const supervisorId of this.retryAtBySupervisorId.keys()) {
+          if (!scheduledIds.has(supervisorId)) {
+            this.retryAtBySupervisorId.delete(supervisorId);
+          }
+        }
       }
     };
   }
@@ -6027,6 +6530,9 @@ function generateSupervisorId() {
 function generateCycleId() {
   return `cycle_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
 }
+function generateAttemptId() {
+  return `attempt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
 function messageOf(error, fallback) {
   if (error instanceof Error) {
     return error.message;
@@ -6054,6 +6560,7 @@ var init_manager2 = __esm({
     init_evaluator();
     init_injector();
     init_scheduler();
+    init_settings();
     NOOP_LOGGER3 = {
       child: () => NOOP_LOGGER3,
       debug: () => {
@@ -6082,7 +6589,8 @@ var init_manager2 = __esm({
           sessionMgr: deps.sessionMgr,
           terminalMgr: deps.terminalMgr,
           providerRegistry: deps.providerRegistry,
-          logger: this.logger
+          logger: this.logger,
+          git: deps.git
         });
         this.evaluator = new SupervisorEvaluator({
           providerRegistry: deps.providerRegistry,
@@ -6101,10 +6609,19 @@ var init_manager2 = __esm({
           onTurnCompleted: (sessionId) => {
             const supervisorId = this.supervisorsBySession.get(sessionId);
             if (supervisorId) {
-              void this.runEvaluation(supervisorId).catch((error) => {
+              void this.runEvaluation(supervisorId, "turn_completed").catch((error) => {
                 this.logger.warn({ err: error, supervisorId }, "Supervisor auto-evaluation failed");
               });
             }
+          },
+          listScheduledSupervisors: () => this.listScheduledSupervisors(),
+          onScheduledDue: (supervisorId) => {
+            void this.runEvaluation(supervisorId, "scheduled").catch((error) => {
+              this.logger.warn(
+                { err: error, supervisorId },
+                "Supervisor scheduled auto-evaluation failed"
+              );
+            });
           }
         });
       }
@@ -6113,6 +6630,7 @@ var init_manager2 = __esm({
       supervisorsBySession = /* @__PURE__ */ new Map();
       inFlight = /* @__PURE__ */ new Set();
       pendingDeletes = /* @__PURE__ */ new Set();
+      pendingPauses = /* @__PURE__ */ new Set();
       evaluationAbortControllers = /* @__PURE__ */ new Map();
       inFlightCompletions = /* @__PURE__ */ new Map();
       scheduler;
@@ -6165,6 +6683,7 @@ var init_manager2 = __esm({
           }
         );
         this.scheduler.start();
+        this.scheduler.refresh();
       }
       stop() {
         this.scheduler.stop();
@@ -6236,12 +6755,17 @@ var init_manager2 = __esm({
             state: "idle",
             objective: req.objective.trim(),
             evaluatorProviderId: req.evaluatorProviderId,
+            evaluatorModel: req.evaluatorModel?.trim() || void 0,
+            maxSupervisionCount: req.maxSupervisionCount ?? 0,
+            completedSupervisionCount: 0,
+            scheduledAt: req.scheduledAt,
             createdAt: now,
             updatedAt: now
           })
         );
         this.storeSnapshot(supervisor);
         this.broadcastState(supervisor, "created");
+        this.scheduler.refresh();
         return supervisor;
       }
       async update(id, patch) {
@@ -6253,6 +6777,9 @@ var init_manager2 = __esm({
           this.deps.supervisorRepo.update(id, {
             objective: patch.objective !== void 0 ? patch.objective.trim() : current.objective,
             evaluatorProviderId: patch.evaluatorProviderId ?? current.evaluatorProviderId,
+            evaluatorModel: patch.evaluatorModel === void 0 ? current.evaluatorModel : patch.evaluatorModel?.trim() || null,
+            maxSupervisionCount: patch.maxSupervisionCount ?? current.maxSupervisionCount,
+            scheduledAt: patch.scheduledAt === void 0 ? current.scheduledAt : patch.scheduledAt,
             state: current.state === "error" ? "idle" : current.state,
             errorReason: null,
             updatedAt: Date.now()
@@ -6260,9 +6787,14 @@ var init_manager2 = __esm({
         );
         this.storeSnapshot(updated);
         this.broadcastState(updated, "updated");
+        this.scheduler.refresh();
         return updated;
       }
       async pause(id) {
+        if (this.inFlight.has(id)) {
+          this.pendingPauses.add(id);
+          this.evaluationAbortControllers.get(id)?.abort();
+        }
         const updated = this.attachCycles(
           this.deps.supervisorRepo.update(id, {
             state: "paused",
@@ -6271,6 +6803,7 @@ var init_manager2 = __esm({
         );
         this.storeSnapshot(updated);
         this.broadcastState(updated, "state_changed");
+        this.scheduler.refresh();
         return updated;
       }
       async resume(id) {
@@ -6283,6 +6816,7 @@ var init_manager2 = __esm({
         );
         this.storeSnapshot(updated);
         this.broadcastState(updated, "state_changed");
+        this.scheduler.refresh();
         return updated;
       }
       async delete(id) {
@@ -6291,6 +6825,7 @@ var init_manager2 = __esm({
           this.pendingDeletes.add(id);
           this.evaluationAbortControllers.get(id)?.abort();
           await this.inFlightCompletions.get(id)?.promise;
+          this.scheduler.refresh();
           return;
         }
         this.deleteNow(supervisor);
@@ -6324,8 +6859,8 @@ var init_manager2 = __esm({
        * auto trigger path (scheduler) and for tests that want to observe the
        * final cycle outcome.
        */
-      async runEvaluation(supervisorId) {
-        const started = await this.beginCycle(supervisorId, "turn_completed");
+      async runEvaluation(supervisorId, trigger = "turn_completed") {
+        const started = await this.beginCycle(supervisorId, trigger);
         if (!started) {
           return null;
         }
@@ -6369,9 +6904,41 @@ var init_manager2 = __esm({
           }
           return null;
         }
-        if (trigger === "turn_completed" && (supervisor.state !== "idle" || session.state !== "running" && session.state !== "idle")) {
+        if (supervisor.state === "stopped") {
+          if (trigger === "manual") {
+            throw {
+              code: "supervisor_stopped",
+              message: `Supervisor ${id} is stopped`
+            };
+          }
+          return null;
+        }
+        if ((trigger === "turn_completed" || trigger === "scheduled") && (supervisor.state !== "idle" || session.state !== "running" && session.state !== "idle")) {
+          return null;
+        }
+        if (supervisor.maxSupervisionCount > 0 && supervisor.completedSupervisionCount >= supervisor.maxSupervisionCount) {
+          const stopped = this.attachCycles(
+            this.deps.supervisorRepo.update(id, {
+              state: "stopped",
+              stopReason: "max_supervision_count_reached",
+              updatedAt: Date.now()
+            })
+          );
+          this.storeSnapshot(stopped);
+          this.broadcastState(stopped, "state_changed");
+          this.scheduler.refresh();
           return null;
         }
+        if (trigger === "turn_completed") {
+          if (supervisor.scheduledAt !== void 0 && supervisor.scheduledAt !== null && supervisor.scheduledAt > Date.now()) {
+            return null;
+          }
+        }
+        if (trigger === "scheduled") {
+          if (supervisor.scheduledAt === void 0 || supervisor.scheduledAt > Date.now()) {
+            return null;
+          }
+        }
         if (trigger === "manual" && !INJECTABLE_SESSION_STATES.has(session.state)) {
           throw {
             code: "supervisor_session_not_ready",
@@ -6382,20 +6949,25 @@ var init_manager2 = __esm({
         this.evaluationAbortControllers.set(id, new AbortController());
         this.inFlightCompletions.set(id, createDeferredCompletion());
         try {
+          const retrySettings = getSupervisorRetrySettings(this.deps.settingsRepo);
           const context = await this.contextBuilder.build(supervisor);
           if (trigger === "turn_completed" && context.lastTurnId && context.lastTurnId === supervisor.lastEvaluatedTurnId) {
             this.releaseInFlight(id);
             return null;
           }
+          const shouldConsumeScheduledAt = trigger === "scheduled" || trigger === "turn_completed" && supervisor.scheduledAt !== void 0 && supervisor.scheduledAt !== null && supervisor.scheduledAt <= Date.now();
           const evaluatingSupervisor = this.attachCycles(
             this.deps.supervisorRepo.update(supervisor.id, {
               state: "evaluating",
+              scheduledAt: shouldConsumeScheduledAt ? null : supervisor.scheduledAt ?? void 0,
+              stopReason: null,
               errorReason: null,
               updatedAt: Date.now()
             })
           );
           this.storeSnapshot(evaluatingSupervisor);
           this.broadcastState(evaluatingSupervisor, "state_changed");
+          this.scheduler.refresh();
           const activeCycle = this.deps.cycleRepo.create({
             id: generateCycleId(),
             supervisorId: supervisor.id,
@@ -6409,7 +6981,18 @@ var init_manager2 = __esm({
             createdAt: Date.now()
           });
           this.broadcastCycle(evaluatingSupervisor, activeCycle, "created");
-          return { cycle: activeCycle, context };
+          return {
+            cycle: activeCycle,
+            context,
+            trigger,
+            retry: {
+              retryEnabled: retrySettings.retryEnabled,
+              retryMaxCount: retrySettings.retryMaxCount,
+              retryDelayMs: retrySettings.retryDelaySec * 1e3,
+              retryOnTimeout: retrySettings.retryOnTimeout,
+              retryOnEvaluatorError: retrySettings.retryOnEvaluatorError
+            }
+          };
         } catch (error) {
           this.releaseInFlight(id);
           this.markSupervisorError(id, error);
@@ -6426,75 +7009,20 @@ var init_manager2 = __esm({
         const supervisorId = activeCycle.supervisorId;
         try {
           const supervisorForEval = this.supervisors.get(supervisorId) ?? this.requireSupervisor(supervisorId);
-          const evaluation = await this.evaluator.evaluate(supervisorForEval, context, {
-            signal: this.evaluationAbortControllers.get(supervisorId)?.signal
-          });
-          let injected = false;
-          let injectedText;
-          let cycleResult;
-          let injectionError;
-          if (evaluation.message.trim()) {
-            const injectingSupervisor = this.attachCycles(
-              this.deps.supervisorRepo.update(supervisorId, {
-                state: "injecting",
-                updatedAt: Date.now()
-              })
-            );
-            this.storeSnapshot(injectingSupervisor);
-            this.broadcastState(injectingSupervisor, "state_changed");
-            const recentCycles = this.deps.cycleRepo.listRecentForSupervisor(supervisorId, this.config.guidanceDedupeWindow + 1).filter((cycle) => cycle.id !== activeCycle.id);
-            try {
-              const injection = await this.injector.inject(
-                injectingSupervisor,
-                {
-                  message: evaluation.message
-                },
-                recentCycles
-              );
-              injected = injection.injected;
-              injectedText = injection.injected ? injection.text : void 0;
-              cycleResult = injection.injected ? injection.text : `Skipped duplicate: ${injection.text}`;
-            } catch (error) {
-              injectionError = messageOf(error, "Injection failed");
-              this.logger.warn(
-                { err: error, supervisorId, cycleId: activeCycle.id },
-                "Supervisor injection failed"
-              );
-            }
-          }
-          const finalStatus = injectionError ? "failed" : injected ? "injected" : "completed";
-          const finishedCycle = this.deps.cycleRepo.update(activeCycle.id, {
-            status: finalStatus,
-            result: cycleResult ?? null,
-            injectedGuidance: injectedText,
-            errorReason: injectionError ?? null,
-            completedAt: Date.now()
-          });
-          const latestState = this.supervisors.get(supervisorId)?.state;
-          const nextState = latestState === "paused" ? "paused" : injectionError ? "error" : "idle";
-          const finishedSupervisor = this.attachCycles(
-            this.deps.supervisorRepo.update(supervisorId, {
-              state: nextState,
-              lastCycleAt: finishedCycle.completedAt,
-              lastEvaluatedTurnId: context.lastTurnId ?? void 0,
-              errorReason: injectionError ?? null,
-              updatedAt: Date.now()
-            })
-          );
-          this.storeSnapshot(finishedSupervisor);
-          this.broadcastCycle(finishedSupervisor, finishedCycle, "updated");
-          this.broadcastState(finishedSupervisor, "state_changed");
-          this.deps.cycleRepo.pruneOldest(supervisorId, this.config.maxCyclesPerSession);
+          const signal = this.evaluationAbortControllers.get(supervisorId)?.signal;
+          const evaluation = await this.executeCycleWithRetry(started, supervisorForEval, signal);
+          const finalized = this.finalizeSuccessfulCycle(activeCycle, context, evaluation);
           if (this.pendingDeletes.has(supervisorId)) {
             this.pendingDeletes.delete(supervisorId);
-            this.deleteNow(finishedSupervisor);
+            this.deleteNow(finalized.supervisor);
           }
-          return finishedCycle;
+          return finalized.cycle;
         } catch (error) {
           if (isSupervisorEvalAborted(error)) {
+            const cancelled = this.pendingPauses.has(supervisorId);
             const abortedCycle = this.deps.cycleRepo.update(activeCycle.id, {
-              status: "failed",
-              errorReason: messageOf(error, "Supervisor evaluator aborted"),
+              status: cancelled ? "cancelled" : "failed",
+              errorReason: cancelled ? null : messageOf(error, "Supervisor evaluator aborted"),
               completedAt: Date.now()
             });
             const currentSupervisor = this.supervisors.get(supervisorId) ?? this.requireSupervisor(supervisorId);
@@ -6505,10 +7033,11 @@ var init_manager2 = __esm({
               return abortedCycle;
             }
             const latestState = this.supervisors.get(supervisorId)?.state;
-            const nextState = latestState === "paused" ? "paused" : "idle";
+            const nextState = cancelled || latestState === "paused" ? "paused" : "idle";
             const recoveredSupervisor = this.attachCycles(
               this.deps.supervisorRepo.update(supervisorId, {
                 state: nextState,
+                stopReason: null,
                 errorReason: null,
                 updatedAt: Date.now()
               })
@@ -6517,6 +7046,8 @@ var init_manager2 = __esm({
             this.broadcastCycle(recoveredSupervisor, abortedCycle, "updated");
             this.broadcastState(recoveredSupervisor, "state_changed");
             this.deps.cycleRepo.pruneOldest(supervisorId, this.config.maxCyclesPerSession);
+            this.scheduler.refresh();
+            this.pendingPauses.delete(supervisorId);
             return abortedCycle;
           }
           logFailure(
@@ -6534,6 +7065,7 @@ var init_manager2 = __esm({
           const failedSupervisor = this.attachCycles(
             this.deps.supervisorRepo.update(supervisorId, {
               state: "error",
+              stopReason: null,
               errorReason: reason,
               updatedAt: Date.now()
             })
@@ -6545,11 +7077,124 @@ var init_manager2 = __esm({
             this.pendingDeletes.delete(supervisorId);
             this.deleteNow(failedSupervisor);
           }
-          throw error;
-        } finally {
-          this.releaseInFlight(supervisorId);
+          throw error;
+        } finally {
+          this.pendingPauses.delete(supervisorId);
+          this.releaseInFlight(supervisorId);
+        }
+      }
+      async executeCycleWithRetry(started, supervisor, signal) {
+        for (let attemptIndex = 0; ; attemptIndex += 1) {
+          const attempt = this.deps.cycleAttemptRepo.create({
+            id: generateAttemptId(),
+            cycleId: started.cycle.id,
+            attemptIndex,
+            status: "evaluating",
+            startedAt: Date.now()
+          });
+          try {
+            const evaluation = await this.evaluator.evaluate(supervisor, started.context, { signal });
+            this.deps.cycleAttemptRepo.update(attempt.id, {
+              status: "completed",
+              completedAt: Date.now(),
+              providerModel: supervisor.evaluatorModel ?? null
+            });
+            if (evaluation.objectiveComplete) {
+              return {
+                objectiveComplete: true,
+                injected: false,
+                cycleResult: evaluation.message
+              };
+            }
+            if (!evaluation.message.trim()) {
+              return {
+                objectiveComplete: false,
+                injected: false
+              };
+            }
+            if (signal?.aborted || this.pendingPauses.has(supervisor.id)) {
+              throw { code: "supervisor_eval_aborted", message: "Supervisor evaluator aborted" };
+            }
+            const injectingSupervisor = this.attachCycles(
+              this.deps.supervisorRepo.update(supervisor.id, {
+                state: "injecting",
+                updatedAt: Date.now()
+              })
+            );
+            this.storeSnapshot(injectingSupervisor);
+            this.broadcastState(injectingSupervisor, "state_changed");
+            const recentCycles = this.deps.cycleRepo.listRecentForSupervisor(supervisor.id, this.config.guidanceDedupeWindow + 1).filter((cycle) => cycle.id !== started.cycle.id);
+            const injection = await this.injector.inject(
+              injectingSupervisor,
+              {
+                message: evaluation.message
+              },
+              recentCycles,
+              { signal }
+            );
+            return {
+              objectiveComplete: false,
+              injected: injection.injected,
+              injectedText: injection.injected ? injection.text : void 0,
+              cycleResult: injection.injected ? injection.text : `Skipped duplicate: ${injection.text}`
+            };
+          } catch (error) {
+            if (isSupervisorEvalAborted(error)) {
+              this.deps.cycleAttemptRepo.update(attempt.id, {
+                status: this.pendingPauses.has(supervisor.id) ? "cancelled" : "failed",
+                completedAt: Date.now(),
+                errorReason: this.pendingPauses.has(supervisor.id) ? null : messageOf(error, "Supervisor evaluator aborted")
+              });
+              throw error;
+            }
+            const reason = messageOf(error, "Supervisor evaluation failed");
+            this.deps.cycleAttemptRepo.update(attempt.id, {
+              status: "failed",
+              completedAt: Date.now(),
+              errorReason: reason
+            });
+            if (!this.shouldRetryAttempt(error, attemptIndex, started.retry)) {
+              throw error;
+            }
+            await this.sleep(started.retry.retryDelayMs, signal);
+            const evaluatingSupervisor = this.attachCycles(
+              this.deps.supervisorRepo.update(supervisor.id, {
+                state: "evaluating",
+                updatedAt: Date.now()
+              })
+            );
+            this.storeSnapshot(evaluatingSupervisor);
+            this.broadcastState(evaluatingSupervisor, "state_changed");
+          }
         }
       }
+      finalizeSuccessfulCycle(activeCycle, context, result) {
+        const finalStatus = result.injected ? "injected" : result.objectiveComplete ? "completed" : "completed";
+        const finishedCycle = this.deps.cycleRepo.update(activeCycle.id, {
+          status: finalStatus,
+          result: result.cycleResult ?? null,
+          injectedGuidance: result.injectedText ?? null,
+          errorReason: null,
+          completedAt: Date.now()
+        });
+        const finishedSupervisor = this.attachCycles(
+          this.deps.supervisorRepo.update(activeCycle.supervisorId, {
+            state: result.objectiveComplete ? "stopped" : "idle",
+            completedSupervisionCount: (this.supervisors.get(activeCycle.supervisorId)?.completedSupervisionCount ?? 0) + 1,
+            stopReason: result.objectiveComplete ? "objective_complete" : null,
+            lastCycleAt: finishedCycle.completedAt,
+            lastEvaluatedTurnId: context.lastTurnId ?? void 0,
+            errorReason: null,
+            updatedAt: Date.now()
+          })
+        );
+        this.storeSnapshot(finishedSupervisor);
+        this.broadcastCycle(finishedSupervisor, finishedCycle, "updated");
+        this.broadcastState(finishedSupervisor, "state_changed");
+        this.deps.cycleRepo.pruneOldest(activeCycle.supervisorId, this.config.maxCyclesPerSession);
+        this.scheduler.refresh();
+        return { cycle: finishedCycle, supervisor: finishedSupervisor };
+      }
       /**
        * Flip a supervisor to 'error' state when something blows up before we
        * had a chance to create a cycle. Without this the supervisor can get
@@ -6615,6 +7260,14 @@ var init_manager2 = __esm({
           cycles: this.deps.cycleRepo.listRecentForSupervisor(supervisor.id, 20)
         };
       }
+      listScheduledSupervisors() {
+        return Array.from(this.supervisors.values()).filter(
+          (supervisor) => supervisor.state === "idle" && typeof supervisor.scheduledAt === "number" && Number.isFinite(supervisor.scheduledAt)
+        ).map((supervisor) => ({
+          supervisorId: supervisor.id,
+          scheduledAt: supervisor.scheduledAt
+        }));
+      }
       storeSnapshot(supervisor) {
         this.supervisors.set(supervisor.id, supervisor);
         this.supervisorsBySession.set(supervisor.sessionId, supervisor.id);
@@ -6624,7 +7277,9 @@ var init_manager2 = __esm({
         this.supervisors.delete(supervisor.id);
         this.supervisorsBySession.delete(supervisor.sessionId);
         this.pendingDeletes.delete(supervisor.id);
+        this.pendingPauses.delete(supervisor.id);
         this.releaseInFlight(supervisor.id);
+        this.scheduler.refresh();
         this.deps.broadcaster.broadcast(
           Topics.supervisorState(supervisor.workspaceId, supervisor.sessionId),
           { supervisorId: supervisor.id, event: "deleted" }
@@ -6658,6 +7313,43 @@ var init_manager2 = __esm({
           { cycle, event }
         );
       }
+      shouldRetryAttempt(error, attemptIndex, retry) {
+        if (!retry.retryEnabled) {
+          return false;
+        }
+        if (attemptIndex >= retry.retryMaxCount) {
+          return false;
+        }
+        const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+        if (code === "supervisor_eval_timeout") {
+          return retry.retryOnTimeout;
+        }
+        if (code === "supervisor_eval_failed") {
+          return retry.retryOnEvaluatorError;
+        }
+        return false;
+      }
+      async sleep(delayMs, signal) {
+        if (delayMs <= 0) {
+          return;
+        }
+        if (signal?.aborted) {
+          throw { code: "supervisor_eval_aborted", message: "Supervisor evaluator aborted" };
+        }
+        await new Promise((resolve4, reject) => {
+          const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve4();
+          }, delayMs);
+          timer.unref?.();
+          const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject({ code: "supervisor_eval_aborted", message: "Supervisor evaluator aborted" });
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+        });
+      }
     };
   }
 });
@@ -7559,6 +8251,7 @@ var init_watcher = __esm({
       dirtyTimer = null;
       firstDirtyTime = null;
       pendingReason = null;
+      pendingWorktreeChanged = false;
       DEBOUNCE_MS = 200;
       MAX_WAIT_MS = 1e3;
       /**
@@ -7571,6 +8264,9 @@ var init_watcher = __esm({
         if (this.firstDirtyTime === null) {
           this.firstDirtyTime = now;
         }
+        if (changedPath && this.isWorktreeMetadataPath(changedPath)) {
+          this.pendingWorktreeChanged = true;
+        }
         if (changedPath && !this.isGitMetadataPath(changedPath)) {
           this.pendingReason = "fs_change";
         } else if (changedPath && this.pendingReason !== "fs_change") {
@@ -7589,13 +8285,23 @@ var init_watcher = __esm({
         this.broadcaster?.broadcast(Topics.workspaceFsDirty(this.workspaceId), {
           reason: this.pendingReason ?? "fs_change"
         });
+        if (this.pendingWorktreeChanged) {
+          this.broadcaster?.broadcast(Topics.workspaceGitState(this.workspaceId), {
+            worktreeChanged: true
+          });
+        }
         this.dirtyTimer = null;
         this.firstDirtyTime = null;
         this.pendingReason = null;
+        this.pendingWorktreeChanged = false;
       }
       isGitMetadataPath(changedPath) {
         return changedPath.replace(/\\/g, "/").includes("/.git/");
       }
+      isWorktreeMetadataPath(changedPath) {
+        const normalized = changedPath.replace(/\\/g, "/");
+        return normalized.includes("/.git/worktrees");
+      }
       /**
        * Stops watching and cleans up resources.
        */
@@ -7831,12 +8537,103 @@ var init_manager4 = __esm({
   }
 });
 
+// packages/server/src/ws/activation.ts
+var DEFAULT_OPTIONS, ActivationManager;
+var init_activation = __esm({
+  "packages/server/src/ws/activation.ts"() {
+    "use strict";
+    DEFAULT_OPTIONS = {
+      graceMs: 3e3
+    };
+    ActivationManager = class {
+      options;
+      lease = null;
+      generation = 0;
+      constructor(options) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+      }
+      claim(clientInstanceId, wsClientId, request) {
+        const now = Date.now();
+        const activeLease = this.getLease();
+        if (activeLease && activeLease.clientInstanceId === clientInstanceId) {
+          const isGraceRecovery = activeLease.graceUntil !== null && now <= activeLease.graceUntil;
+          const displacedWsClientId2 = isGraceRecovery || activeLease.wsClientId === wsClientId ? null : activeLease.wsClientId;
+          activeLease.wsClientId = wsClientId;
+          activeLease.graceUntil = null;
+          return {
+            active: true,
+            generation: activeLease.generation,
+            recoveryMode: "grace_recover",
+            displacedWsClientId: displacedWsClientId2
+          };
+        }
+        const displacedWsClientId = activeLease && activeLease.clientInstanceId !== clientInstanceId ? activeLease.wsClientId : null;
+        const recoveryMode = displacedWsClientId === null ? "fresh" : "takeover";
+        this.generation += 1;
+        this.lease = {
+          clientInstanceId,
+          wsClientId,
+          generation: this.generation,
+          issuedAt: now,
+          graceUntil: null,
+          ip: request.ip,
+          userAgent: request.headers["user-agent"] ?? ""
+        };
+        return {
+          active: true,
+          generation: this.lease.generation,
+          recoveryMode,
+          displacedWsClientId
+        };
+      }
+      release(clientInstanceId, generation) {
+        const lease = this.getLease();
+        if (!lease) {
+          return;
+        }
+        if (lease.clientInstanceId !== clientInstanceId || lease.generation !== generation) {
+          return;
+        }
+        this.lease = null;
+      }
+      onSocketClosed(wsClientId) {
+        const lease = this.getLease();
+        if (!lease || lease.wsClientId !== wsClientId) {
+          return;
+        }
+        lease.graceUntil = Date.now() + this.options.graceMs;
+      }
+      getLease() {
+        if (!this.lease) {
+          return null;
+        }
+        return this.lease;
+      }
+    };
+  }
+});
+
 // packages/server/src/ws/dispatch.ts
 function registerCommand(op, schema, handler) {
   handlers.set(op, handler);
   schemas.set(op, schema);
 }
 async function dispatch(msg, ctx, clientId) {
+  const isWsDispatch = clientId !== void 0 && typeof ctx.broadcaster.getRequestMetadata === "function";
+  if (isWsDispatch && !ACTIVATION_ALLOWLIST.has(msg.op)) {
+    const active = ctx.activationMgr.getLease();
+    if (!active || active.wsClientId !== clientId) {
+      return {
+        kind: "result",
+        id: msg.id,
+        ok: false,
+        error: {
+          code: "activation_required",
+          message: "This tab is no longer the active session"
+        }
+      };
+    }
+  }
   const handler = handlers.get(msg.op);
   if (!handler) {
     return {
@@ -7893,21 +8690,26 @@ function normalizeError(error) {
     message: candidate.message || "An internal error occurred"
   };
 }
-var handlers, schemas;
+var handlers, schemas, ACTIVATION_ALLOWLIST;
 var init_dispatch = __esm({
   "packages/server/src/ws/dispatch.ts"() {
     "use strict";
     handlers = /* @__PURE__ */ new Map();
     schemas = /* @__PURE__ */ new Map();
+    ACTIVATION_ALLOWLIST = /* @__PURE__ */ new Set([
+      "activation.claim",
+      "activation.release",
+      "connection.probe"
+    ]);
   }
 });
 
 // packages/server/src/ws/fencing.ts
-var DEFAULT_OPTIONS, FencingManager;
+var DEFAULT_OPTIONS2, FencingManager;
 var init_fencing = __esm({
   "packages/server/src/ws/fencing.ts"() {
     "use strict";
-    DEFAULT_OPTIONS = {
+    DEFAULT_OPTIONS2 = {
       visibleHeartbeatMs: 1e4,
       // 10 seconds
       hiddenHeartbeatMs: 2e4,
@@ -7926,7 +8728,7 @@ var init_fencing = __esm({
       // workspaceId -> { clientId, closedAt, ip, ua } (for grace period)
       lastWriter = /* @__PURE__ */ new Map();
       constructor(options) {
-        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.options = { ...DEFAULT_OPTIONS2, ...options };
       }
       /**
        * Request controller status for a workspace.
@@ -8445,8 +9247,12 @@ var init_client = __esm({
       evictedBytesSinceLastWarn = 0;
       lastStreamBufferWarnAt = 0;
       logger;
+      markAlive() {
+        this.isAlive = true;
+      }
       setupSocketHandlers() {
         this.socket.on("message", (data, isBinary) => {
+          this.markAlive();
           if (isBinary) {
             this.messageHandler?.(data);
             return;
@@ -8465,7 +9271,7 @@ var init_client = __esm({
           this.closeHandler?.();
         });
         this.socket.on("pong", () => {
-          this.isAlive = true;
+          this.markAlive();
         });
       }
       /**
@@ -8496,6 +9302,20 @@ var init_client = __esm({
           return false;
         }
       }
+      sendControlAndClose(msg, code, reason) {
+        if (this.socket.readyState !== WebSocket.OPEN) {
+          return false;
+        }
+        try {
+          this.socket.send(JSON.stringify(msg), () => {
+            this.socket.close(code, reason);
+          });
+          return true;
+        } catch (error) {
+          console.error(`Failed to send message to client ${this.id}:`, error);
+          return false;
+        }
+      }
       sendBinary(data) {
         if (this.socket.readyState !== WebSocket.OPEN) {
           return false;
@@ -8660,6 +9480,16 @@ var init_client = __esm({
         };
         return this.send(event);
       }
+      sendEventAndClose(topic, data, code, reason, seq = 0) {
+        const event = {
+          kind: "event",
+          topic,
+          seq,
+          timestamp: Date.now(),
+          data
+        };
+        return this.sendControlAndClose(event, code, reason);
+      }
       /**
        * Check if client subscribes to a topic (supports glob patterns)
        */
@@ -8769,6 +9599,7 @@ var init_hub = __esm({
       }
       deps;
       clients = /* @__PURE__ */ new Map();
+      clientRequests = /* @__PURE__ */ new Map();
       eventUnsubscribers = [];
       nextStreamId = 1;
       // Per-client queue of waiters for the next inbound binary frame. The
@@ -8785,9 +9616,10 @@ var init_hub = __esm({
       /**
        * Handle a new WebSocket connection
        */
-      handleConnection(socket, _req) {
+      handleConnection(socket, req) {
         const client = new WsClient(socket, uuidv4(), this.deps.logger);
         this.clients.set(client.id, client);
+        this.clientRequests.set(client.id, req);
         client.sendEvent("connection.status", {
           status: "connected",
           clientId: client.id,
@@ -8921,8 +9753,10 @@ var init_hub = __esm({
        */
       handleClose(client) {
         this.clients.delete(client.id);
+        this.clientRequests.delete(client.id);
         this.discardPendingBinaryWaiters(client.id);
         this.deps.commandContext?.autoFetch.unregisterViewer(client.id);
+        this.deps.commandContext?.activationMgr.onSocketClosed(client.id);
       }
       /**
        * Takeover: Force close existing writer and accept new one
@@ -8963,6 +9797,24 @@ var init_hub = __esm({
         if (!client) return false;
         return client.sendBinary(data);
       }
+      revokeAndCloseClient(clientId, generation) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+          return;
+        }
+        client.sendEventAndClose(
+          "activation.revoked",
+          {
+            reason: "displaced",
+            generation
+          },
+          4001,
+          "single_active_displaced"
+        );
+      }
+      getRequestMetadata(clientId) {
+        return this.clientRequests.get(clientId);
+      }
       /**
        * Get the current writer client
        * DEPRECATED: Writer tracking now handled by FencingManager
@@ -8975,6 +9827,10 @@ var init_hub = __esm({
        */
       pingAll() {
         for (const client of this.clients.values()) {
+          if (!client.alive) {
+            client.close(1011, "keepalive_timeout");
+            continue;
+          }
           client.ping();
         }
       }
@@ -8986,6 +9842,7 @@ var init_hub = __esm({
           client.close();
         }
         this.clients.clear();
+        this.clientRequests.clear();
       }
       /**
        * Subscribe to domain events and broadcast them
@@ -9233,6 +10090,63 @@ var init_workspace_activity = __esm({
   }
 });
 
+// packages/server/src/commands/activation.ts
+import { z as z8 } from "zod";
+var init_activation2 = __esm({
+  "packages/server/src/commands/activation.ts"() {
+    "use strict";
+    init_dispatch();
+    registerCommand(
+      "activation.claim",
+      z8.object({ clientInstanceId: z8.string().min(1) }),
+      async (args, ctx, clientId) => {
+        if (!clientId) {
+          throw {
+            code: "activation_request_unavailable",
+            message: "Activation claim requires websocket request metadata"
+          };
+        }
+        const request = ctx.broadcaster.getRequestMetadata?.(clientId);
+        if (!request) {
+          throw {
+            code: "activation_request_unavailable",
+            message: "Activation claim requires websocket request metadata"
+          };
+        }
+        const claim = ctx.activationMgr.claim(args.clientInstanceId, clientId, request);
+        if (claim.displacedWsClientId) {
+          ctx.broadcaster.revokeAndCloseClient?.(claim.displacedWsClientId, claim.generation);
+        }
+        return claim;
+      }
+    );
+    registerCommand(
+      "activation.release",
+      z8.object({ clientInstanceId: z8.string(), generation: z8.number().int().positive() }),
+      async (args, ctx, clientId) => {
+        const lease = ctx.activationMgr.getLease();
+        if (!clientId || !lease || lease.wsClientId !== clientId) {
+          return { ok: false };
+        }
+        ctx.activationMgr.release(args.clientInstanceId, args.generation);
+        return { ok: true };
+      }
+    );
+  }
+});
+
+// packages/server/src/commands/connection.ts
+import { z as z9 } from "zod";
+var init_connection = __esm({
+  "packages/server/src/commands/connection.ts"() {
+    "use strict";
+    init_dispatch();
+    registerCommand("connection.probe", z9.object({}).default({}), async () => {
+      return { ok: true };
+    });
+  }
+});
+
 // packages/server/src/provider-runtime/runtime-status.ts
 function canAutoInstall(provider, platform, missingCommands, missingPrerequisites, availableCommands) {
   const strategies = provider.install.strategies[platform] ?? [];
@@ -9327,7 +10241,7 @@ var init_runtime_status = __esm({
 });
 
 // packages/server/src/commands/session.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 function getProviderFromRegistry(providerId, registry) {
   return registry.find((provider) => provider.id === providerId);
 }
@@ -9338,8 +10252,8 @@ var init_session = __esm({
     init_dispatch();
     registerCommand(
       "session.list",
-      z8.object({
-        workspaceId: z8.string()
+      z10.object({
+        workspaceId: z10.string()
       }),
       async (args, ctx) => {
         return ctx.sessionMgr.getForWorkspace(args.workspaceId);
@@ -9347,10 +10261,10 @@ var init_session = __esm({
     );
     registerCommand(
       "session.create",
-      z8.object({
-        workspaceId: z8.string(),
-        providerId: z8.string(),
-        draft: z8.string().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        providerId: z10.string(),
+        draft: z10.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9384,8 +10298,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.stop",
-      z8.object({
-        sessionId: z8.string()
+      z10.object({
+        sessionId: z10.string()
       }),
       async (args, ctx) => {
         await ctx.sessionMgr.stop(args.sessionId);
@@ -9393,8 +10307,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.remove",
-      z8.object({
-        sessionId: z8.string()
+      z10.object({
+        sessionId: z10.string()
       }),
       async (args, ctx) => {
         const session = ctx.sessionMgr.get(args.sessionId);
@@ -9559,7 +10473,7 @@ var init_tree = __esm({
 });
 
 // packages/server/src/commands/file.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var init_file = __esm({
   "packages/server/src/commands/file.ts"() {
     "use strict";
@@ -9568,9 +10482,9 @@ var init_file = __esm({
     init_dispatch();
     registerCommand(
       "file.readTree",
-      z9.object({
-        workspaceId: z9.string(),
-        subPath: z9.string().optional()
+      z11.object({
+        workspaceId: z11.string(),
+        subPath: z11.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9582,10 +10496,10 @@ var init_file = __esm({
     );
     registerCommand(
       "file.search",
-      z9.object({
-        workspaceId: z9.string(),
-        query: z9.string(),
-        limit: z9.number().int().positive().max(50).optional()
+      z11.object({
+        workspaceId: z11.string(),
+        query: z11.string(),
+        limit: z11.number().int().positive().max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9597,9 +10511,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.read",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9611,9 +10525,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.create",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9631,9 +10545,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.mkdir",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9651,9 +10565,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.delete",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9671,11 +10585,11 @@ var init_file = __esm({
     );
     registerCommand(
       "file.write",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string(),
-        content: z9.string(),
-        baseHash: z9.string().optional()
+      z11.object({
+        workspaceId: z11.string(),
+        path: z11.string(),
+        content: z11.string(),
+        baseHash: z11.string().optional()
         // For conflict detection
       }),
       async (args, ctx) => {
@@ -9766,7 +10680,7 @@ var init_git_events = __esm({
 });
 
 // packages/server/src/commands/git.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 async function runGitNetworkOperation(ctx, workspaceId, op) {
   if (!ctx.autoFetch?.runExclusive) {
     return op();
@@ -9781,16 +10695,16 @@ var init_git2 = __esm({
     init_diff();
     init_dispatch();
     init_git_events();
-    gitHttpAuthSchema = z10.object({
-      username: z10.string(),
-      password: z10.string()
+    gitHttpAuthSchema = z12.object({
+      username: z12.string(),
+      password: z12.string()
     });
-    gitCommitRevisionSchema = z10.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
+    gitCommitRevisionSchema = z12.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
     GIT_BACKGROUND_FETCH_TIMEOUT_MS = 30 * 1e3;
     registerCommand(
       "git.status",
-      z10.object({
-        workspaceId: z10.string()
+      z12.object({
+        workspaceId: z12.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9802,9 +10716,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.stage",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z12.object({
+        workspaceId: z12.string(),
+        paths: z12.array(z12.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9818,10 +10732,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.diff",
-      z10.object({
-        workspaceId: z10.string(),
-        path: z10.string(),
-        staged: z10.boolean().optional()
+      z12.object({
+        workspaceId: z12.string(),
+        path: z12.string(),
+        staged: z12.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9835,9 +10749,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.log",
-      z10.object({
-        workspaceId: z10.string(),
-        limit: z10.number().int().min(1).max(50).optional()
+      z12.object({
+        workspaceId: z12.string(),
+        limit: z12.number().int().min(1).max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9851,8 +10765,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.show",
-      z10.object({
-        workspaceId: z10.string(),
+      z12.object({
+        workspaceId: z12.string(),
         sha: gitCommitRevisionSchema
       }),
       async (args, ctx) => {
@@ -9867,9 +10781,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.unstage",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z12.object({
+        workspaceId: z12.string(),
+        paths: z12.array(z12.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9883,9 +10797,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.discard",
-      z10.object({
-        workspaceId: z10.string(),
-        paths: z10.array(z10.string())
+      z12.object({
+        workspaceId: z12.string(),
+        paths: z12.array(z12.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9901,9 +10815,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.commit",
-      z10.object({
-        workspaceId: z10.string(),
-        message: z10.string()
+      z12.object({
+        workspaceId: z12.string(),
+        message: z12.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9920,11 +10834,11 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.push",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        branch: z10.string().optional(),
-        force: z10.boolean().optional(),
+      z12.object({
+        workspaceId: z12.string(),
+        remote: z12.string().optional(),
+        branch: z12.string().optional(),
+        force: z12.boolean().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9951,10 +10865,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.pull",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        branch: z10.string().optional(),
+      z12.object({
+        workspaceId: z12.string(),
+        remote: z12.string().optional(),
+        branch: z12.string().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9982,12 +10896,12 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.fetch",
-      z10.object({
-        workspaceId: z10.string(),
-        remote: z10.string().optional(),
-        prune: z10.boolean().optional(),
+      z12.object({
+        workspaceId: z12.string(),
+        remote: z12.string().optional(),
+        prune: z12.boolean().optional(),
         auth: gitHttpAuthSchema.optional(),
-        background: z10.boolean().optional()
+        background: z12.boolean().optional()
       }),
       async (args, ctx, clientId) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10016,10 +10930,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.checkout",
-      z10.object({
-        workspaceId: z10.string(),
-        ref: z10.string(),
-        createBranch: z10.boolean().optional()
+      z12.object({
+        workspaceId: z12.string(),
+        ref: z12.string(),
+        createBranch: z12.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10041,10 +10955,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branch",
-      z10.object({
-        workspaceId: z10.string(),
-        name: z10.string(),
-        startPoint: z10.string().optional()
+      z12.object({
+        workspaceId: z12.string(),
+        name: z12.string(),
+        startPoint: z12.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10063,8 +10977,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branches",
-      z10.object({
-        workspaceId: z10.string()
+      z12.object({
+        workspaceId: z12.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10158,7 +11072,7 @@ var init_config_io = __esm({
 });
 
 // packages/server/src/commands/settings.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 function flattenSettings(obj, prefix = "") {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -10181,27 +11095,34 @@ var init_settings2 = __esm({
     init_provider_config_repo();
     init_settings();
     init_dispatch();
-    SettingsSchema = z11.object({
-      defaultProviderId: z11.string().optional(),
-      notifications: z11.object({
-        enabled: z11.boolean().optional(),
-        soundEnabled: z11.boolean().optional(),
+    SettingsSchema = z13.object({
+      defaultProviderId: z13.string().optional(),
+      notifications: z13.object({
+        enabled: z13.boolean().optional(),
+        soundEnabled: z13.boolean().optional(),
         // Legacy field — accepted for backward compat with older clients but
         // no longer surfaced in the UI. The web client now picks the channel
         // automatically based on workspace focus + page visibility.
-        onlyWhenBackgrounded: z11.boolean().optional()
+        onlyWhenBackgrounded: z13.boolean().optional()
       }).optional(),
-      supervisor: z11.object({
-        evaluationTimeoutSec: z11.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional()
+      supervisor: z13.object({
+        evaluationTimeoutSec: z13.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional(),
+        retryEnabled: z13.boolean().optional(),
+        retryMaxCount: z13.number().int().min(0).max(MAX_SUPERVISOR_RETRY_MAX_COUNT).optional(),
+        retryDelaySec: z13.number().int().min(1).max(MAX_SUPERVISOR_RETRY_DELAY_SEC).optional(),
+        retryOnTimeout: z13.boolean().optional(),
+        retryOnEvaluatorError: z13.boolean().optional()
       }).optional(),
-      appearance: z11.object({
-        theme: z11.enum(["dark"]).optional(),
-        terminalRenderer: z11.enum(["standard", "compatibility"]).optional(),
-        locale: z11.enum(["zh", "en"]).optional()
+      appearance: z13.object({
+        theme: z13.enum(["dark", "light"]).optional(),
+        themeId: z13.string().optional(),
+        terminalRenderer: z13.enum(["standard", "compatibility"]).optional(),
+        terminalCopyOnSelect: z13.boolean().optional(),
+        locale: z13.enum(["zh", "en"]).optional()
       }).optional(),
       providers: ProviderSettingsSchema.optional()
     });
-    registerCommand("settings.get", z11.object({}), async (_args, ctx) => {
+    registerCommand("settings.get", z13.object({}), async (_args, ctx) => {
       const row = ctx.db.prepare("SELECT key, value FROM user_settings").all();
       const settings = {};
       for (const { key, value } of row) {
@@ -10230,11 +11151,36 @@ var init_settings2 = __esm({
           settings[SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY]
         );
       }
+      if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_RETRY_ENABLED_SETTING_KEY)) {
+        settings[SUPERVISOR_RETRY_ENABLED_SETTING_KEY] = resolveSupervisorRetryEnabled(
+          settings[SUPERVISOR_RETRY_ENABLED_SETTING_KEY]
+        );
+      }
+      if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY)) {
+        settings[SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY] = resolveSupervisorRetryMaxCount(
+          settings[SUPERVISOR_RETRY_MAX_COUNT_SETTING_KEY]
+        );
+      }
+      if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY)) {
+        settings[SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY] = resolveSupervisorRetryDelaySec(
+          settings[SUPERVISOR_RETRY_DELAY_SEC_SETTING_KEY]
+        );
+      }
+      if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY)) {
+        settings[SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY] = resolveSupervisorRetryOnTimeout(
+          settings[SUPERVISOR_RETRY_ON_TIMEOUT_SETTING_KEY]
+        );
+      }
+      if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY)) {
+        settings[SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY] = resolveSupervisorRetryOnEvaluatorError(
+          settings[SUPERVISOR_RETRY_ON_EVALUATOR_ERROR_SETTING_KEY]
+        );
+      }
       return settings;
     });
     registerCommand(
       "settings.update",
-      z11.object({
+      z13.object({
         settings: SettingsSchema
       }),
       async (args, ctx) => {
@@ -10266,10 +11212,10 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.previewCommand",
-      z11.object({
-        providerId: z11.string(),
+      z13.object({
+        providerId: z13.string(),
         config: ProviderLaunchConfigInputSchema,
-        workspacePath: z11.string().optional()
+        workspacePath: z13.string().optional()
       }),
       async (args, ctx) => {
         const provider = ctx.providerRegistry.find((item) => item.id === args.providerId);
@@ -10290,8 +11236,8 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.readConfigFile",
-      z11.object({
-        configType: z11.enum(["codex", "claude"])
+      z13.object({
+        configType: z13.enum(["codex", "claude"])
       }),
       async (args) => {
         const result = readConfigFile(args.configType);
@@ -10300,9 +11246,9 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.writeConfigFile",
-      z11.object({
-        configType: z11.enum(["codex", "claude"]),
-        content: z11.string()
+      z13.object({
+        configType: z13.enum(["codex", "claude"]),
+        content: z13.string()
       }),
       async (args) => {
         const result = writeConfigFile(args.configType, args.content);
@@ -10313,19 +11259,19 @@ var init_settings2 = __esm({
 });
 
 // packages/server/src/commands/provider.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 var init_provider = __esm({
   "packages/server/src/commands/provider.ts"() {
     "use strict";
     init_runtime_status();
     init_dispatch();
-    registerCommand("provider.runtimeStatus", z12.object({}), async (_args, ctx) => {
+    registerCommand("provider.runtimeStatus", z14.object({}), async (_args, ctx) => {
       return buildProviderRuntimeStatus(ctx.providerRegistry, ctx.providerRuntimeDeps);
     });
     registerCommand(
       "provider.install.start",
-      z12.object({
-        providerId: z12.string()
+      z14.object({
+        providerId: z14.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -10339,8 +11285,8 @@ var init_provider = __esm({
     );
     registerCommand(
       "provider.install.get",
-      z12.object({
-        jobId: z12.string()
+      z14.object({
+        jobId: z14.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -10363,36 +11309,45 @@ var init_provider = __esm({
 });
 
 // packages/server/src/commands/supervisor.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 var supervisorObjectiveSchema, createSupervisorSchema, updateSupervisorSchema, sessionIdSchema, supervisorIdSchema;
 var init_supervisor2 = __esm({
   "packages/server/src/commands/supervisor.ts"() {
     "use strict";
     init_dispatch();
-    supervisorObjectiveSchema = z13.string().trim().min(1).max(4e3);
-    createSupervisorSchema = z13.object({
-      sessionId: z13.string(),
-      workspaceId: z13.string(),
+    supervisorObjectiveSchema = z15.string().trim().min(1).max(4e3);
+    createSupervisorSchema = z15.object({
+      sessionId: z15.string(),
+      workspaceId: z15.string(),
       objective: supervisorObjectiveSchema,
-      evaluatorProviderId: z13.string()
+      evaluatorProviderId: z15.string(),
+      evaluatorModel: z15.string().trim().min(1).max(200).optional(),
+      maxSupervisionCount: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional()
     }).strict();
-    updateSupervisorSchema = z13.object({
-      id: z13.string(),
+    updateSupervisorSchema = z15.object({
+      id: z15.string(),
       objective: supervisorObjectiveSchema.optional(),
-      evaluatorProviderId: z13.string().optional()
+      evaluatorProviderId: z15.string().optional(),
+      evaluatorModel: z15.string().trim().min(1).max(200).nullable().optional(),
+      maxSupervisionCount: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+      scheduledAt: z15.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable().optional()
     }).strict().refine(
-      (input2) => input2.objective !== void 0 || input2.evaluatorProviderId !== void 0,
-      "objective or evaluatorProviderId is required"
+      (input2) => input2.objective !== void 0 || input2.evaluatorProviderId !== void 0 || input2.evaluatorModel !== void 0 || input2.maxSupervisionCount !== void 0 || input2.scheduledAt !== void 0,
+      "at least one supervisor field is required"
     );
-    sessionIdSchema = z13.object({ sessionId: z13.string() });
-    supervisorIdSchema = z13.object({ id: z13.string() });
+    sessionIdSchema = z15.object({ sessionId: z15.string() });
+    supervisorIdSchema = z15.object({ id: z15.string() });
     registerCommand("supervisor.create", createSupervisorSchema, async (args, ctx) => {
       return {
         supervisor: await ctx.supervisorMgr.create({
           sessionId: args.sessionId,
           workspaceId: args.workspaceId,
           objective: args.objective,
-          evaluatorProviderId: args.evaluatorProviderId
+          evaluatorProviderId: args.evaluatorProviderId,
+          evaluatorModel: args.evaluatorModel,
+          maxSupervisionCount: args.maxSupervisionCount,
+          scheduledAt: args.scheduledAt
         })
       };
     });
@@ -10403,7 +11358,10 @@ var init_supervisor2 = __esm({
       return {
         supervisor: await ctx.supervisorMgr.update(args.id, {
           objective: args.objective,
-          evaluatorProviderId: args.evaluatorProviderId
+          evaluatorProviderId: args.evaluatorProviderId,
+          evaluatorModel: args.evaluatorModel,
+          maxSupervisionCount: args.maxSupervisionCount,
+          scheduledAt: args.scheduledAt
         })
       };
     });
@@ -10563,7 +11521,7 @@ var init_worktree = __esm({
 
 // packages/server/src/commands/worktree.ts
 import path9 from "node:path";
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 async function findRelatedWorkspaceIds(ctx, workspacePath) {
   const targetCommonDir = await getGitCommonDirPath(workspacePath);
   const relatedWorkspaceIds = await Promise.all(
@@ -10596,7 +11554,7 @@ var init_worktree2 = __esm({
     init_worktree();
     init_dispatch();
     init_git_events();
-    registerCommand("worktree.list", z14.object({ workspaceId: z14.string() }), async (args, ctx) => {
+    registerCommand("worktree.list", z16.object({ workspaceId: z16.string() }), async (args, ctx) => {
       const workspace = ctx.workspaceMgr.get(args.workspaceId);
       if (!workspace) {
         throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
@@ -10605,7 +11563,7 @@ var init_worktree2 = __esm({
     });
     registerCommand(
       "worktree.status",
-      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
+      z16.object({ workspaceId: z16.string(), worktreePath: z16.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10617,10 +11575,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.diff",
-      z14.object({
-        workspaceId: z14.string(),
-        worktreePath: z14.string(),
-        staged: z14.boolean().optional().default(false)
+      z16.object({
+        workspaceId: z16.string(),
+        worktreePath: z16.string(),
+        staged: z16.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10633,7 +11591,7 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.tree",
-      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
+      z16.object({ workspaceId: z16.string(), worktreePath: z16.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10645,10 +11603,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.create",
-      z14.object({
-        workspaceId: z14.string(),
-        branch: z14.string(),
-        path: z14.string()
+      z16.object({
+        workspaceId: z16.string(),
+        branch: z16.string(),
+        path: z16.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10663,10 +11621,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.remove",
-      z14.object({
-        workspaceId: z14.string(),
-        worktreePath: z14.string(),
-        force: z14.boolean().optional().default(false)
+      z16.object({
+        workspaceId: z16.string(),
+        worktreePath: z16.string(),
+        force: z16.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10690,7 +11648,7 @@ var init_worktree2 = __esm({
 });
 
 // packages/server/src/commands/fencing.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 function createMockFencingRequest() {
   return {
     ip: "127.0.0.1",
@@ -10703,9 +11661,9 @@ var init_fencing2 = __esm({
     init_dispatch();
     registerCommand(
       "fencing.request",
-      z15.object({
-        workspaceId: z15.string(),
-        tabId: z15.string()
+      z17.object({
+        workspaceId: z17.string(),
+        tabId: z17.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.requestControl(
@@ -10718,7 +11676,7 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.heartbeat",
-      z15.object({ workspaceId: z15.string() }),
+      z17.object({ workspaceId: z17.string() }),
       async (args, ctx, clientId) => {
         const success = ctx.fencingMgr.heartbeat(args.workspaceId, clientId);
         return { success };
@@ -10726,13 +11684,13 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.release",
-      z15.object({ workspaceId: z15.string() }),
+      z17.object({ workspaceId: z17.string() }),
       async (args, ctx, clientId) => {
         ctx.fencingMgr.release(args.workspaceId, clientId);
         return {};
       }
     );
-    registerCommand("fencing.status", z15.object({ workspaceId: z15.string() }), async (args, ctx) => {
+    registerCommand("fencing.status", z17.object({ workspaceId: z17.string() }), async (args, ctx) => {
       const controller = ctx.fencingMgr.getController(args.workspaceId);
       const isUnresponsive = ctx.fencingMgr.isControllerUnresponsive(args.workspaceId);
       return {
@@ -10743,9 +11701,9 @@ var init_fencing2 = __esm({
     });
     registerCommand(
       "fencing.takeover",
-      z15.object({
-        workspaceId: z15.string(),
-        tabId: z15.string()
+      z17.object({
+        workspaceId: z17.string(),
+        tabId: z17.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.forceTakeover(
@@ -10765,6 +11723,8 @@ var init_commands = __esm({
     "use strict";
     init_workspace();
     init_workspace_activity();
+    init_activation2();
+    init_connection();
     init_session();
     init_terminal();
     init_file();
@@ -10783,6 +11743,7 @@ async function createServer(configOverrides) {
   ensureDataDir(config);
   const db = openDatabase(config.dataDir);
   const eventBus = new EventBus();
+  const activationMgr = new ActivationManager();
   const fencingMgr = new FencingManager();
   const wsHub = new WsHub({ eventBus, commandContext: null, config, fencingMgr });
   let workspaceMgr;
@@ -10873,6 +11834,7 @@ async function createServer(configOverrides) {
   wsHub.setLogger(app.log);
   const supervisorRepo = new SupervisorRepo(db);
   const cycleRepo = new SupervisorCycleRepo(db);
+  const cycleAttemptRepo = new SupervisorCycleAttemptRepo(db);
   supervisorMgr = new SupervisorManager({
     eventBus,
     broadcaster: wsHub,
@@ -10884,6 +11846,7 @@ async function createServer(configOverrides) {
     settingsRepo,
     supervisorRepo,
     cycleRepo,
+    cycleAttemptRepo,
     logger: app.log
   });
   await sessionMgr.hydrate();
@@ -10908,7 +11871,8 @@ async function createServer(configOverrides) {
     supervisorMgr,
     autoFetch,
     providerRuntimeDeps,
-    providerInstallMgr
+    providerInstallMgr,
+    activationMgr
   };
   wsHub.setCommandContext(commandContext);
   await app.listen({
@@ -10933,11 +11897,16 @@ async function createServer(configOverrides) {
     );
   }, STARTUP_GC_DELAY_MS);
   gcTimer.unref();
+  const wsKeepaliveTimer = setInterval(() => {
+    wsHub.pingAll();
+  }, WS_KEEPALIVE_INTERVAL_MS);
+  wsKeepaliveTimer.unref();
   let stopped = false;
   const stopServer = async () => {
     if (stopped) return;
     stopped = true;
     clearTimeout(gcTimer);
+    clearInterval(wsKeepaliveTimer);
     await app.close();
     autoFetch.stop();
     supervisorMgr.stop();
@@ -11053,6 +12022,7 @@ function createSessionDatabase(db) {
     }
   };
 }
+var WS_KEEPALIVE_INTERVAL_MS;
 var init_server = __esm({
   async "packages/server/src/server.ts"() {
     "use strict";
@@ -11073,6 +12043,7 @@ var init_server = __esm({
     init_provider_config_repo();
     init_session_repo();
     init_settings_repo();
+    init_supervisor_cycle_attempt_repo();
     init_supervisor_cycle_repo();
     init_supervisor_repo();
     init_manager2();
@@ -11081,10 +12052,12 @@ var init_server = __esm({
     init_cleanup();
     init_constants();
     init_manager4();
+    init_activation();
     init_dispatch();
     init_fencing();
     init_hub();
     init_commands();
+    WS_KEEPALIVE_INTERVAL_MS = 15e3;
     if (isDirectExecution(import.meta.url)) {
       const server = await createServer();
       process.on("SIGINT", async () => {
@@ -11307,6 +12280,7 @@ var init_storage = __esm({
     init_provider_config_repo();
     init_session_repo();
     init_settings_repo();
+    init_supervisor_cycle_attempt_repo();
     init_supervisor_cycle_repo();
     init_supervisor_repo();
     init_terminal_repo();
@@ -11337,6 +12311,7 @@ __export(src_exports, {
   RingBuffer: () => RingBuffer,
   SessionRepo: () => SessionRepo,
   SettingsRepo: () => SettingsRepo,
+  SupervisorCycleAttemptRepo: () => SupervisorCycleAttemptRepo,
   SupervisorCycleRepo: () => SupervisorCycleRepo,
   SupervisorRepo: () => SupervisorRepo,
   TerminalManager: () => TerminalManager,
@@ -11371,8 +12346,8 @@ var init_src4 = __esm({
 });
 
 // packages/cli/src/cli.ts
-import { existsSync as existsSync11 } from "fs";
-import { dirname as dirname6, join as join10 } from "path";
+import { existsSync as existsSync11, rmSync } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // packages/cli/src/auth-control.ts
@@ -12187,6 +13162,9 @@ async function getServerStatus() {
 }
 
 // packages/cli/src/server-runner.ts
+await init_src4();
+import { mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/cli/src/embed.ts
@@ -12228,6 +13206,14 @@ var buildServerConfig = () => {
   console.warn(MISSING_WEB_ASSETS_WARNING);
   return config;
 };
+var verifyLocalDatabaseCompatibility = () => {
+  const config = parseServerConfig(buildServerConfig());
+  if (config.dataDir !== ":memory:") {
+    mkdirSync6(dirname6(config.dataDir), { recursive: true });
+  }
+  const db = openDatabase(config.dataDir);
+  closeDatabase(db);
+};
 var createShutdownHandler = (server) => async () => {
   await server.stop();
   process.exit(0);
@@ -12402,7 +13388,7 @@ function formatAuthBlocks(blocks) {
 }
 function resolveManagedScriptPath() {
   const currentFile = fileURLToPath3(import.meta.url);
-  const currentDir = dirname6(currentFile);
+  const currentDir = dirname7(currentFile);
   const candidates = [
     join10(currentDir, "server-runner.js"),
     join10(currentDir, "server-runner.mjs"),
@@ -12460,6 +13446,44 @@ async function startManagedServerFlow() {
     waitMs: MANAGED_SERVER_WAIT_MS
   });
 }
+function parseIncompatibleSchemaError(error) {
+  if (!error || typeof error !== "object") {
+    return null;
+  }
+  const candidate = error;
+  if (candidate.code !== "db_incompatible_schema" || typeof candidate.dbPath !== "string") {
+    return null;
+  }
+  return {
+    code: "db_incompatible_schema",
+    dbPath: candidate.dbPath
+  };
+}
+async function handleIncompatibleSchema(error) {
+  const payload = parseIncompatibleSchemaError(error);
+  if (!payload) {
+    return false;
+  }
+  const approved = isInteractiveSession() ? await confirmYesNo(
+    `Local database is incompatible at ${payload.dbPath}. Delete and rebuild the local database? [y/N] `
+  ) : false;
+  if (!approved) {
+    throw error;
+  }
+  rmSync(payload.dbPath, { force: true });
+  return true;
+}
+async function verifyManagedDatabaseCompatibility() {
+  try {
+    verifyLocalDatabaseCompatibility();
+  } catch (error) {
+    const rebuilt = await handleIncompatibleSchema(error);
+    if (!rebuilt) {
+      throw error;
+    }
+    verifyLocalDatabaseCompatibility();
+  }
+}
 async function openManagedServerInBrowser(existingStatus) {
   const status = existingStatus ?? await getServerStatus();
   const browserUrl = getBrowserUrl(status);
@@ -12531,6 +13555,7 @@ async function main(argv = process.argv.slice(2)) {
   if (args.command === "open") {
     const startup2 = await prepareManagedStartup(args.restart);
     if (startup2.existingStatus === null) {
+      await verifyManagedDatabaseCompatibility();
       await startManagedServerFlow();
     }
     await openManagedServerInBrowser(startup2.existingStatus);
@@ -12545,13 +13570,22 @@ async function main(argv = process.argv.slice(2)) {
       await stopRunningServer();
     }
     console.log("Starting Coder Studio Server in foreground...");
-    await startServer();
+    try {
+      await startServer();
+    } catch (error) {
+      const rebuilt = await handleIncompatibleSchema(error);
+      if (!rebuilt) {
+        throw error;
+      }
+      await startServer();
+    }
     return;
   }
   const startup = await prepareManagedStartup(args.restart);
   if (startup.existingStatus !== null) {
     return;
   }
+  await verifyManagedDatabaseCompatibility();
   await startManagedServerFlow();
   console.log("Coder Studio server started in background.");
   console.log("Run `coder-studio status` to inspect the server.");