@spencer-kit/coder-studio 0.3.4 → 0.3.6

package/dist/esm/server-runner.mjs

@@ -385,34 +385,34 @@ var init_config = __esm({
 });
 
 // packages/core/src/runtime.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 function getRuntimeDir() {
   const override = process.env.CODER_STUDIO_RUNTIME_DIR;
   if (override && override.trim()) {
     return override;
   }
-  return join2(homedir2(), ".coder-studio");
+  return join(homedir(), ".coder-studio");
 }
 function getRuntimePath() {
   const pathOverride = process.env.CODER_STUDIO_RUNTIME_JSON_PATH;
   if (pathOverride && pathOverride.trim()) {
     return pathOverride;
   }
-  return join2(getRuntimeDir(), "runtime.json");
+  return join(getRuntimeDir(), "runtime.json");
 }
 function writeRuntimeConfig(config) {
   const runtimePath = getRuntimePath();
-  const runtimeDir = dirname2(runtimePath);
-  if (!existsSync4(runtimeDir)) {
-    mkdirSync2(runtimeDir, { recursive: true });
+  const runtimeDir = dirname(runtimePath);
+  if (!existsSync(runtimeDir)) {
+    mkdirSync(runtimeDir, { recursive: true });
   }
-  writeFileSync2(runtimePath, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync(runtimePath, JSON.stringify(config, null, 2), "utf-8");
 }
 function deleteRuntimeConfig() {
   const runtimePath = getRuntimePath();
-  if (existsSync4(runtimePath)) {
+  if (existsSync(runtimePath)) {
     unlinkSync(runtimePath);
   }
 }
@@ -593,6 +593,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({})
     });
@@ -639,6 +640,7 @@ function buildCodexSupervisorEvalCommand(config, req) {
       "-s",
       "read-only",
       "--skip-git-repo-check",
+      ...req.model ? ["-m", req.model] : [],
       ...cfg.additionalArgs,
       req.prompt
     ],
@@ -786,7 +788,7 @@ var init_src = __esm({
 });
 
 // packages/utils/src/direct-execution.ts
-import { posix, resolve as resolve2 } from "node:path";
+import { posix, resolve } from "node:path";
 function isWindowsDrivePath(path10) {
   return /^[A-Za-z]:\//.test(path10);
 }
@@ -820,7 +822,7 @@ function normalizeModuleUrlPath(moduleUrl) {
 }
 function normalizeArgvPath(argv1) {
   const isAbsoluteWindowsPath = /^[A-Za-z]:[\\/]/.test(argv1) || /^\\\\/.test(argv1);
-  return normalizeComparablePath(isAbsoluteWindowsPath ? argv1 : resolve2(argv1));
+  return normalizeComparablePath(isAbsoluteWindowsPath ? argv1 : resolve(argv1));
 }
 function isDirectExecution(moduleUrl, argv1 = process.argv[1]) {
   if (argv1 === void 0) {
@@ -995,7 +997,7 @@ var init_image = __esm({
 // packages/server/src/fs/file-io.ts
 import { createHash } from "crypto";
 import { readFile as fsReadFile, writeFile as fsWriteFile, mkdir, rm, stat } from "fs/promises";
-import { dirname as dirname3, isAbsolute, relative, resolve as resolve3 } from "path";
+import { dirname as dirname2, isAbsolute, relative, resolve as resolve2 } from "path";
 async function statSafe(path10) {
   try {
     return await stat(path10);
@@ -1009,7 +1011,7 @@ async function createFile(rootPath, relPath) {
   if (existing) {
     throw { code: "already_exists", message: "File already exists" };
   }
-  await mkdir(dirname3(abs), { recursive: true });
+  await mkdir(dirname2(abs), { recursive: true });
   await fsWriteFile(abs, "", "utf-8");
 }
 async function createDirectory(rootPath, relPath) {
@@ -1029,8 +1031,8 @@ async function deleteEntry(rootPath, relPath) {
   await rm(abs, { recursive: true });
 }
 function resolveSafe(root, relPath) {
-  const absRoot = resolve3(root);
-  const abs = resolve3(absRoot, relPath);
+  const absRoot = resolve2(root);
+  const abs = resolve2(absRoot, relPath);
   const rel = relative(absRoot, abs);
   if (rel === ".." || rel.startsWith(`..${"/"}`) || isAbsolute(rel)) {
     throw { code: "path_escape", message: "Path escapes workspace root" };
@@ -1079,7 +1081,7 @@ async function writeFile(rootPath, relPath, content, baseHash) {
       };
     }
   }
-  await mkdir(dirname3(abs), { recursive: true });
+  await mkdir(dirname2(abs), { recursive: true });
   await fsWriteFile(abs, content, "utf-8");
   const newHash = createHash("sha256").update(content).digest("hex");
   return { newHash };
@@ -2108,8 +2110,8 @@ var init_command_check = __esm({
 });
 
 // packages/server/src/provider-runtime/e2e-provider-mock.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join3 } from "node:path";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 function createE2EProviderMockOverrides(env = process.env) {
   const statePath = env.CODER_STUDIO_E2E_PROVIDER_STATE_PATH;
   if (!statePath) {
@@ -2191,10 +2193,10 @@ function getInstallProviderId(file, args) {
   return null;
 }
 function readMockState(statePath) {
-  if (!existsSync6(statePath)) {
+  if (!existsSync3(statePath)) {
     return {};
   }
-  const raw = readFileSync5(statePath, "utf8");
+  const raw = readFileSync3(statePath, "utf8");
   if (!raw.trim()) {
     return {};
   }
@@ -2209,22 +2211,22 @@ function readMockState(statePath) {
 function writeMockState(statePath, updater) {
   const nextState = readMockState(statePath);
   updater(nextState);
-  mkdirSync3(dirname4(statePath), { recursive: true });
-  writeFileSync3(statePath, JSON.stringify(nextState, null, 2));
+  mkdirSync2(dirname3(statePath), { recursive: true });
+  writeFileSync2(statePath, JSON.stringify(nextState, null, 2));
   return nextState;
 }
 function ensureProviderCommand(binDir, providerId) {
-  mkdirSync3(binDir, { recursive: true });
-  const scriptPath = join3(binDir, providerId);
-  writeFileSync3(scriptPath, PROVIDER_COMMAND_SCRIPTS[providerId], "utf8");
+  mkdirSync2(binDir, { recursive: true });
+  const scriptPath = join2(binDir, providerId);
+  writeFileSync2(scriptPath, PROVIDER_COMMAND_SCRIPTS[providerId], "utf8");
   chmodSync(scriptPath, 493);
 }
 function appendDebugLog(path10, line) {
   if (!path10) {
     return;
   }
-  mkdirSync3(dirname4(path10), { recursive: true });
-  writeFileSync3(path10, `${line}
+  mkdirSync2(dirname3(path10), { recursive: true });
+  writeFileSync2(path10, `${line}
 `, { flag: "a" });
 }
 var PROVIDER_INSTALL_PACKAGES, PROVIDER_COMMAND_SCRIPTS;
@@ -2705,12 +2707,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,
@@ -3738,10 +3774,10 @@ 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 readFileSync6 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
 function normalizeSql(sql) {
   return (sql ?? "").replace(/\s+/g, " ").trim();
 }
@@ -3762,15 +3798,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;
@@ -3797,68 +4047,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");
@@ -3866,7 +4123,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 {
@@ -3883,16 +4140,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 = join4(import.meta.dirname, "migrations", "001_init.sql");
-    SCHEMA_SQL = readFileSync6(SCHEMA_PATH, "utf-8");
+    init_schema_version();
     LEGACY_TABLES = ["hook_registrations", "_migrations"];
     LEGACY_SESSION_COLUMNS = ["resume_id", "transcript_path"];
-    EXPECTED_SCHEMA_ENTRIES = buildExpectedSchemaEntries();
   }
 });
 
@@ -4142,6 +4397,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(input) {
+        this.db.prepare(
+          `INSERT INTO supervisor_cycle_attempts (id, cycle_id, attempt_index, status, started_at, completed_at, error_reason, provider_model)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          input.id,
+          input.cycleId,
+          input.attemptIndex,
+          input.status,
+          input.startedAt,
+          input.completedAt ?? null,
+          input.errorReason ?? null,
+          input.providerModel ?? null
+        );
+        return this.findById(input.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({
@@ -4271,8 +4613,8 @@ var init_supervisor_repo = __esm({
       db;
       create(input) {
         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(
           input.id,
           input.sessionId,
@@ -4280,6 +4622,11 @@ var init_supervisor_repo = __esm({
           input.state,
           input.objective,
           input.evaluatorProviderId,
+          input.evaluatorModel ?? null,
+          input.maxSupervisionCount ?? 0,
+          input.completedSupervisionCount ?? 0,
+          input.scheduledAt ?? null,
+          input.stopReason ?? null,
           input.lastCycleAt ?? null,
           input.lastEvaluatedTurnId ?? null,
           input.errorReason ?? null,
@@ -4318,6 +4665,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;
@@ -4347,6 +4714,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,
@@ -5364,7 +5736,7 @@ var init_context_builder = __esm({
 });
 
 // packages/server/src/terminal/pty-host.ts
-import { chmodSync as chmodSync2, existsSync as existsSync7, statSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync4, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import path6 from "node:path";
 function ensureNodePtySpawnHelperExecutable(deps = {}) {
@@ -5374,7 +5746,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
   }
   const arch = deps.arch ?? process.arch;
   const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
-  const fileExists = deps.existsSync ?? existsSync7;
+  const fileExists = deps.existsSync ?? existsSync4;
   const stat7 = deps.statSync ?? statSync;
   const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
@@ -5534,12 +5906,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";
   }
 });
 
@@ -5761,6 +6184,12 @@ function extractSupervisorMessage(output, 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}`);
@@ -5862,7 +6291,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 {
@@ -5891,7 +6320,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]"
+        };
       }
     };
   }
@@ -5927,7 +6360,13 @@ var init_injector = __esm({
       }
       deps;
       config;
-      async inject(supervisor, input, recentCycles) {
+      async inject(supervisor, input, 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 {
@@ -5948,6 +6387,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";
@@ -5970,6 +6415,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(
@@ -5982,9 +6430,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);
+          }
+        }
       }
     };
   }
@@ -6005,6 +6508,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;
@@ -6032,6 +6538,7 @@ var init_manager2 = __esm({
     init_evaluator();
     init_injector();
     init_scheduler();
+    init_settings();
     NOOP_LOGGER3 = {
       child: () => NOOP_LOGGER3,
       debug: () => {
@@ -6060,7 +6567,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,
@@ -6079,10 +6587,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"
+              );
+            });
           }
         });
       }
@@ -6091,6 +6608,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;
@@ -6143,6 +6661,7 @@ var init_manager2 = __esm({
           }
         );
         this.scheduler.start();
+        this.scheduler.refresh();
       }
       stop() {
         this.scheduler.stop();
@@ -6214,12 +6733,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) {
@@ -6231,6 +6755,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()
@@ -6238,9 +6765,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",
@@ -6249,6 +6781,7 @@ var init_manager2 = __esm({
         );
         this.storeSnapshot(updated);
         this.broadcastState(updated, "state_changed");
+        this.scheduler.refresh();
         return updated;
       }
       async resume(id) {
@@ -6261,6 +6794,7 @@ var init_manager2 = __esm({
         );
         this.storeSnapshot(updated);
         this.broadcastState(updated, "state_changed");
+        this.scheduler.refresh();
         return updated;
       }
       async delete(id) {
@@ -6269,6 +6803,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);
@@ -6302,8 +6837,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;
         }
@@ -6347,9 +6882,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",
@@ -6360,20 +6927,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,
@@ -6387,7 +6959,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);
@@ -6404,75 +6987,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);
@@ -6483,10 +7011,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()
               })
@@ -6495,6 +7024,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(
@@ -6512,6 +7043,7 @@ var init_manager2 = __esm({
           const failedSupervisor = this.attachCycles(
             this.deps.supervisorRepo.update(supervisorId, {
               state: "error",
+              stopReason: null,
               errorReason: reason,
               updatedAt: Date.now()
             })
@@ -6525,9 +7057,122 @@ var init_manager2 = __esm({
           }
           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
@@ -6593,6 +7238,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);
@@ -6602,7 +7255,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" }
@@ -6636,6 +7291,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 });
+        });
+      }
     };
   }
 });
@@ -7446,9 +8138,9 @@ var init_validator = __esm({
 });
 
 // packages/server/src/fs/gitignore.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import ignore from "ignore";
-import { join as join5, relative as relative3 } from "path";
+import { join as join4, relative as relative3 } from "path";
 function normalizePath(path10) {
   return path10.replace(/\\/g, "/");
 }
@@ -7468,26 +8160,26 @@ function isIgnoredByGitignore(ig, path10) {
   return ig.ignores(path10) || ig.ignores(`${path10}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
-  const gitignorePath = join5(rootPath, ".gitignore");
-  if (!existsSync8(gitignorePath)) {
+  const gitignorePath = join4(rootPath, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
     return (name) => !isDefaultTreeIgnored(name);
   }
-  const gitignoreContent = readFileSync7(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (name) => {
     if (isAlwaysTreeIgnored(name)) {
       return false;
     }
-    const relativePath = relativeToRoot(rootPath, join5(dirPath, name));
+    const relativePath = relativeToRoot(rootPath, join4(dirPath, name));
     return !isIgnoredByGitignore(ig, relativePath);
   };
 }
 function createWatcherIgnoreFilter(rootPath) {
-  const gitignorePath = join5(rootPath, ".gitignore");
-  if (!existsSync8(gitignorePath)) {
+  const gitignorePath = join4(rootPath, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
     return (path10) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path10)));
   }
-  const gitignoreContent = readFileSync7(gitignorePath, "utf-8");
+  const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
   return (path10) => {
     const normalizedPath = normalizePath(path10);
@@ -7537,6 +8229,7 @@ var init_watcher = __esm({
       dirtyTimer = null;
       firstDirtyTime = null;
       pendingReason = null;
+      pendingWorktreeChanged = false;
       DEBOUNCE_MS = 200;
       MAX_WAIT_MS = 1e3;
       /**
@@ -7549,6 +8242,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") {
@@ -7567,13 +8263,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.
        */
@@ -7809,12 +8515,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 {
@@ -7871,21 +8668,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,
@@ -7904,7 +8706,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.
@@ -8053,7 +8855,7 @@ var init_fencing = __esm({
 });
 
 // packages/server/src/commands/terminal.ts
-import { basename as basename2 } from "node:path";
+import { basename } from "node:path";
 import { z as z5 } from "zod";
 function decodeTerminalInput(args) {
   if ("bytes" in args) {
@@ -8108,11 +8910,11 @@ function resolveShellCommand() {
     const shellPath2 = process.env.ComSpec || process.env.COMSPEC || "cmd.exe";
     return {
       argv: [shellPath2],
-      title: basename2(shellPath2) || shellPath2
+      title: basename(shellPath2) || shellPath2
     };
   }
   const shellPath = process.env.SHELL || "/bin/bash";
-  const shellName = basename2(shellPath);
+  const shellName = basename(shellPath);
   const argv = shellName === "cmd.exe" ? [shellPath] : [shellPath, "-i"];
   return {
     argv,
@@ -8423,8 +9225,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;
@@ -8443,7 +9249,7 @@ var init_client = __esm({
           this.closeHandler?.();
         });
         this.socket.on("pong", () => {
-          this.isAlive = true;
+          this.markAlive();
         });
       }
       /**
@@ -8474,6 +9280,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;
@@ -8638,6 +9458,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)
        */
@@ -8747,6 +9577,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
@@ -8763,9 +9594,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,
@@ -8899,8 +9731,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
@@ -8941,6 +9775,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
@@ -8953,6 +9805,10 @@ var init_hub = __esm({
        */
       pingAll() {
         for (const client of this.clients.values()) {
+          if (!client.alive) {
+            client.close(1011, "keepalive_timeout");
+            continue;
+          }
           client.ping();
         }
       }
@@ -8964,6 +9820,7 @@ var init_hub = __esm({
           client.close();
         }
         this.clients.clear();
+        this.clientRequests.clear();
       }
       /**
        * Subscribe to domain events and broadcast them
@@ -9093,8 +9950,8 @@ var init_hub = __esm({
 
 // packages/server/src/commands/workspace.ts
 import { readdir as readdir2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join5 } from "node:path";
 import { z as z6 } from "zod";
 var init_workspace = __esm({
   "packages/server/src/commands/workspace.ts"() {
@@ -9109,15 +9966,15 @@ var init_workspace = __esm({
         path: z6.string().optional()
       }),
       async (args) => {
-        const basePath = args.path || homedir3();
+        const basePath = args.path || homedir2();
         const entries = await readdir2(basePath, { withFileTypes: true });
         const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
           name: entry.name,
-          path: join6(basePath, entry.name)
+          path: join5(basePath, entry.name)
         })).sort((a, b) => a.name.localeCompare(b.name));
         return {
           currentPath: basePath,
-          parentPath: basePath !== "/" ? join6(basePath, "..") : null,
+          parentPath: basePath !== "/" ? join5(basePath, "..") : null,
           directories
         };
       }
@@ -9211,6 +10068,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] ?? [];
@@ -9305,7 +10219,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);
 }
@@ -9316,8 +10230,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);
@@ -9325,10 +10239,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);
@@ -9362,8 +10276,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);
@@ -9371,8 +10285,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);
@@ -9390,9 +10304,9 @@ var init_session = __esm({
 
 // packages/server/src/fs/tree.ts
 import { readdir as readdir3, stat as stat6 } from "fs/promises";
-import { join as join7, relative as relative4 } from "path";
+import { join as join6, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
-  const targetPath = subdir ? join7(rootPath, subdir) : rootPath;
+  const targetPath = subdir ? join6(rootPath, subdir) : rootPath;
   const filter = createGitignoreFilter(rootPath, targetPath);
   const entries = await readdir3(targetPath, { withFileTypes: true });
   const nodes = [];
@@ -9400,7 +10314,7 @@ async function readTree(rootPath, subdir) {
     if (!filter(entry.name)) {
       continue;
     }
-    const fullPath = join7(targetPath, entry.name);
+    const fullPath = join6(targetPath, entry.name);
     const relPath = relative4(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
@@ -9444,7 +10358,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     const filteredEntries = entries.filter((entry) => filter(entry.name));
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
-      const fullPath = join7(dirPath, entry.name);
+      const fullPath = join6(dirPath, entry.name);
       const relPath = relative4(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
@@ -9537,7 +10451,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";
@@ -9546,9 +10460,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);
@@ -9560,10 +10474,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);
@@ -9575,9 +10489,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);
@@ -9589,9 +10503,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);
@@ -9609,9 +10523,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);
@@ -9629,9 +10543,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);
@@ -9649,11 +10563,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) => {
@@ -9744,7 +10658,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();
@@ -9759,16 +10673,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);
@@ -9780,9 +10694,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);
@@ -9796,10 +10710,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);
@@ -9813,9 +10727,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);
@@ -9829,8 +10743,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.show",
-      z10.object({
-        workspaceId: z10.string(),
+      z12.object({
+        workspaceId: z12.string(),
         sha: gitCommitRevisionSchema
       }),
       async (args, ctx) => {
@@ -9845,9 +10759,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);
@@ -9861,9 +10775,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);
@@ -9879,9 +10793,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);
@@ -9898,11 +10812,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) => {
@@ -9929,10 +10843,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) => {
@@ -9960,12 +10874,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);
@@ -9994,10 +10908,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);
@@ -10019,10 +10933,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);
@@ -10041,8 +10955,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);
@@ -10056,37 +10970,37 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename3, dirname as dirname5, join as join8 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename2, dirname as dirname4, join as join7 } from "node:path";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
     const testHome = process.env.CODER_STUDIO_CODEX_HOME;
     if (testHome && testHome.trim()) {
-      return join8(testHome, "config.toml");
+      return join7(testHome, "config.toml");
     }
     const codexHome = process.env.CODEX_HOME;
     if (codexHome && codexHome.trim()) {
-      return join8(codexHome, "config.toml");
+      return join7(codexHome, "config.toml");
     }
-    return join8(homedir4(), ".codex", "config.toml");
+    return join7(homedir3(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
-      return join8(testHome, "settings.json");
+      return join7(testHome, "settings.json");
     }
-    return join8(homedir4(), ".claude", "settings.json");
+    return join7(homedir3(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
 function readConfigFile(configType) {
   const configPath = resolveConfigPath(configType);
-  if (!existsSync9(configPath)) {
+  if (!existsSync6(configPath)) {
     return { configPath, content: "", exists: false };
   }
   try {
-    const content = readFileSync8(configPath, "utf-8");
+    const content = readFileSync6(configPath, "utf-8");
     return { configPath, content, exists: true };
   } catch {
     return { configPath, content: "", exists: false };
@@ -10095,16 +11009,16 @@ function readConfigFile(configType) {
 function writeConfigFile(configType, content) {
   try {
     const configPath = resolveConfigPath(configType);
-    const parentDir = dirname5(configPath);
-    if (!existsSync9(parentDir)) {
-      mkdirSync4(parentDir, { recursive: true });
+    const parentDir = dirname4(configPath);
+    if (!existsSync6(parentDir)) {
+      mkdirSync3(parentDir, { recursive: true });
     }
     let backupPath = null;
-    if (existsSync9(configPath)) {
+    if (existsSync6(configPath)) {
       backupPath = createBackup(configPath);
     }
     const tempPath = `${configPath}.tmp`;
-    writeFileSync4(tempPath, content, "utf-8");
+    writeFileSync3(tempPath, content, "utf-8");
     renameSync(tempPath, configPath);
     return { success: true, backupPath };
   } catch (error) {
@@ -10116,13 +11030,13 @@ function writeConfigFile(configType, content) {
   }
 }
 function createBackup(filePath) {
-  const original = readFileSync8(filePath, "utf-8");
+  const original = readFileSync6(filePath, "utf-8");
   const ext = filePath.split(".").pop() ?? "";
-  const base = basename3(filePath, `.${ext}`);
-  const dir = dirname5(filePath);
+  const base = basename2(filePath, `.${ext}`);
+  const dir = dirname4(filePath);
   const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join8(dir, `${base}.bak.${ts}.${ext}`);
-  writeFileSync4(backupPath, original, "utf-8");
+  const backupPath = join7(dir, `${base}.bak.${ts}.${ext}`);
+  writeFileSync3(backupPath, original, "utf-8");
   return backupPath;
 }
 function formatTimestamp(d) {
@@ -10136,7 +11050,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)) {
@@ -10159,27 +11073,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) {
@@ -10208,11 +11129,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) => {
@@ -10244,10 +11190,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);
@@ -10268,8 +11214,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);
@@ -10278,9 +11224,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);
@@ -10291,19 +11237,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) {
@@ -10317,8 +11263,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) {
@@ -10341,36 +11287,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(
-      (input) => input.objective !== void 0 || input.evaluatorProviderId !== void 0,
-      "objective or evaluatorProviderId is required"
+      (input) => input.objective !== void 0 || input.evaluatorProviderId !== void 0 || input.evaluatorModel !== void 0 || input.maxSupervisionCount !== void 0 || input.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
         })
       };
     });
@@ -10381,7 +11336,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
         })
       };
     });
@@ -10541,7 +11499,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(
@@ -10574,7 +11532,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}` };
@@ -10583,7 +11541,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) {
@@ -10595,10 +11553,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);
@@ -10611,7 +11569,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) {
@@ -10623,10 +11581,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);
@@ -10641,10 +11599,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);
@@ -10668,7 +11626,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",
@@ -10681,9 +11639,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(
@@ -10696,7 +11654,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 };
@@ -10704,13 +11662,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 {
@@ -10721,9 +11679,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(
@@ -10743,6 +11701,8 @@ var init_commands = __esm({
     "use strict";
     init_workspace();
     init_workspace_activity();
+    init_activation2();
+    init_connection();
     init_session();
     init_terminal();
     init_file();
@@ -10761,6 +11721,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;
@@ -10851,6 +11812,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,
@@ -10862,6 +11824,7 @@ async function createServer(configOverrides) {
     settingsRepo,
     supervisorRepo,
     cycleRepo,
+    cycleAttemptRepo,
     logger: app.log
   });
   await sessionMgr.hydrate();
@@ -10886,7 +11849,8 @@ async function createServer(configOverrides) {
     supervisorMgr,
     autoFetch,
     providerRuntimeDeps,
-    providerInstallMgr
+    providerInstallMgr,
+    activationMgr
   };
   wsHub.setCommandContext(commandContext);
   await app.listen({
@@ -10911,11 +11875,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();
@@ -11031,6 +12000,7 @@ function createSessionDatabase(db) {
     }
   };
 }
+var WS_KEEPALIVE_INTERVAL_MS;
 var init_server = __esm({
   async "packages/server/src/server.ts"() {
     "use strict";
@@ -11051,6 +12021,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();
@@ -11059,10 +12030,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 () => {
@@ -11285,6 +12258,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();
@@ -11315,6 +12289,7 @@ __export(src_exports, {
   RingBuffer: () => RingBuffer,
   SessionRepo: () => SessionRepo,
   SettingsRepo: () => SettingsRepo,
+  SupervisorCycleAttemptRepo: () => SupervisorCycleAttemptRepo,
   SupervisorCycleRepo: () => SupervisorCycleRepo,
   SupervisorRepo: () => SupervisorRepo,
   TerminalManager: () => TerminalManager,
@@ -11349,22 +12324,25 @@ var init_src4 = __esm({
 });
 
 // packages/cli/src/server-runner.ts
+await init_src4();
+import { mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/cli/src/config-store.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { basename, join } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, join as join8 } from "path";
 function getCliConfigPath() {
-  return join(homedir(), ".coder-studio", "config.json");
+  return join8(homedir4(), ".coder-studio", "config.json");
 }
 function readCliConfig() {
   const path10 = getCliConfigPath();
-  if (!existsSync(path10)) {
+  if (!existsSync7(path10)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync(path10, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path10, "utf-8"));
     if (parsed.host !== void 0 && typeof parsed.host !== "string" || parsed.port !== void 0 && typeof parsed.port !== "number" || parsed.dataDir !== void 0 && typeof parsed.dataDir !== "string" || parsed.password !== void 0 && typeof parsed.password !== "string") {
       return null;
     }
@@ -11375,17 +12353,17 @@ function readCliConfig() {
 }
 
 // packages/cli/src/embed.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname, resolve } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname5, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var WEB_ASSETS_DIR = resolve(__dirname, "../web");
+var __dirname = dirname5(__filename);
+var WEB_ASSETS_DIR = resolve3(__dirname, "../web");
 function getStaticAssetsDir() {
   return WEB_ASSETS_DIR;
 }
 function hasWebAssets() {
-  return existsSync2(WEB_ASSETS_DIR);
+  return existsSync8(WEB_ASSETS_DIR);
 }
 
 // packages/cli/src/node-version.ts
@@ -11419,12 +12397,12 @@ function assertSupportedNodeVersion(version = process.versions.node) {
 }
 
 // packages/cli/src/package-manifest.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
 function resolveCliPackageManifestUrl(importMetaUrl) {
   const manifestUrl = [
     new URL("../package.json", importMetaUrl),
     new URL("../../package.json", importMetaUrl)
-  ].find((candidate) => existsSync3(candidate));
+  ].find((candidate) => existsSync9(candidate));
   if (!manifestUrl) {
     throw new Error("Unable to locate CLI package.json");
   }
@@ -11432,7 +12410,7 @@ function resolveCliPackageManifestUrl(importMetaUrl) {
 }
 function getCliPackageManifest(importMetaUrl) {
   return JSON.parse(
-    readFileSync2(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
+    readFileSync8(resolveCliPackageManifestUrl(importMetaUrl), "utf-8")
   );
 }
 function getCliVersion(importMetaUrl) {
@@ -11464,6 +12442,14 @@ var buildServerConfig = () => {
   console.warn(MISSING_WEB_ASSETS_WARNING);
   return config;
 };
+var verifyLocalDatabaseCompatibility = () => {
+  const config = parseServerConfig(buildServerConfig());
+  if (config.dataDir !== ":memory:") {
+    mkdirSync5(dirname6(config.dataDir), { recursive: true });
+  }
+  const db = openDatabase(config.dataDir);
+  closeDatabase(db);
+};
 var createShutdownHandler = (server) => async () => {
   await server.stop();
   process.exit(0);
@@ -11498,6 +12484,7 @@ void runServerEntrypoint(import.meta.url, process.argv[1]);
 export {
   buildServerConfig,
   runServerEntrypoint,
-  startServer
+  startServer,
+  verifyLocalDatabaseCompatibility
 };
 //# sourceMappingURL=server-runner.mjs.map