@spencer-kit/coder-studio 0.3.2 → 0.3.4

package/dist/esm/server-runner.mjs

@@ -115,8 +115,8 @@ var init_plugin = __esm({
     init_web_ui_routing();
     init_login_protection();
     AUTH_COOKIE_NAME = "coder_studio_auth";
-    isPublicPath = (path9) => {
-      const pathname = getRequestPathname(path9);
+    isPublicPath = (path10) => {
+      const pathname = getRequestPathname(path10);
       return pathname === "/" || pathname === "/login" || pathname === "/healthz" || pathname === "/auth/status" || pathname === "/auth/login" || pathname === "/auth/logout" || pathname.startsWith("/@") || isPublicStaticPath(pathname);
     };
     parseCookies = (cookieHeader) => {
@@ -787,11 +787,11 @@ var init_src = __esm({
 
 // packages/utils/src/direct-execution.ts
 import { posix, resolve as resolve2 } from "node:path";
-function isWindowsDrivePath(path9) {
-  return /^[A-Za-z]:\//.test(path9);
+function isWindowsDrivePath(path10) {
+  return /^[A-Za-z]:\//.test(path10);
 }
-function normalizeComparablePath(path9) {
-  let normalized = path9.replace(/\\/g, "/");
+function normalizeComparablePath(path10) {
+  let normalized = path10.replace(/\\/g, "/");
   if (/^\/[A-Za-z]:\//.test(normalized)) {
     normalized = normalized.slice(1);
   }
@@ -815,8 +815,8 @@ function normalizeModuleUrlPath(moduleUrl) {
   if (url.protocol !== "file:") {
     return null;
   }
-  const path9 = `${url.host ? `//${url.host}` : ""}${decodeURIComponent(url.pathname)}`;
-  return normalizeComparablePath(path9);
+  const path10 = `${url.host ? `//${url.host}` : ""}${decodeURIComponent(url.pathname)}`;
+  return normalizeComparablePath(path10);
 }
 function normalizeArgvPath(argv1) {
   const isAbsoluteWindowsPath = /^[A-Za-z]:[\\/]/.test(argv1) || /^\\\\/.test(argv1);
@@ -995,10 +995,10 @@ 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, resolve as resolve3 } from "path";
-async function statSafe(path9) {
+import { dirname as dirname3, isAbsolute, relative, resolve as resolve3 } from "path";
+async function statSafe(path10) {
   try {
-    return await stat(path9);
+    return await stat(path10);
   } catch {
     return null;
   }
@@ -1031,7 +1031,8 @@ async function deleteEntry(rootPath, relPath) {
 function resolveSafe(root, relPath) {
   const absRoot = resolve3(root);
   const abs = resolve3(absRoot, relPath);
-  if (!abs.startsWith(absRoot + "/") && abs !== absRoot) {
+  const rel = relative(absRoot, abs);
+  if (rel === ".." || rel.startsWith(`..${"/"}`) || isAbsolute(rel)) {
     throw { code: "path_escape", message: "Path escapes workspace root" };
   }
   return abs;
@@ -1093,8 +1094,10 @@ var init_file_io = __esm({
 // packages/server/src/routes/file-asset.ts
 import { createReadStream } from "fs";
 import { realpath, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative2 } from "path";
 function isPathInsideRoot(rootPath, targetPath) {
-  return targetPath === rootPath || targetPath.startsWith(`${rootPath}/`);
+  const rel = relative2(rootPath, targetPath);
+  return rel !== ".." && !rel.startsWith(`..${"/"}`) && !isAbsolute2(rel);
 }
 function registerFileAssetRoutes(app, deps) {
   app.get(
@@ -1219,12 +1222,12 @@ async function ensureSafeUploadDir(rootDir, targetDir) {
     await mkdir2(resolvedRoot, { recursive: true });
     await assertDirectorySegmentSafe(resolvedRoot);
   }
-  const relative3 = path3.relative(resolvedRoot, resolvedTarget);
-  if (!relative3) {
+  const relative5 = path3.relative(resolvedRoot, resolvedTarget);
+  if (!relative5) {
     return;
   }
   let current = resolvedRoot;
-  for (const segment of relative3.split(path3.sep)) {
+  for (const segment of relative5.split(path3.sep)) {
     current = path3.join(current, segment);
     try {
       await assertDirectorySegmentSafe(current);
@@ -1773,189 +1776,265 @@ var init_app = __esm({
   }
 });
 
-// packages/server/src/config/codex-config-audit.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join3 } from "node:path";
-function resolveCodexConfigPath() {
-  const codexHome = process.env.CODEX_HOME;
-  if (codexHome && codexHome.trim()) {
-    return join3(codexHome, "config.toml");
-  }
-  return join3(homedir3(), ".codex", "config.toml");
-}
-function auditCodexConfigToml(configPath) {
-  const path9 = configPath ?? resolveCodexConfigPath();
-  if (!existsSync6(path9)) {
-    return { configPath: path9, exists: false, findings: [] };
-  }
-  let content;
-  try {
-    content = readFileSync5(path9, "utf-8");
-  } catch {
-    return { configPath: path9, exists: false, findings: [] };
-  }
-  const lines = content.split(/\r?\n/);
-  const findings = [];
-  const notifyFinding = detectTopLevelNotify(lines);
-  if (notifyFinding) findings.push(notifyFinding);
-  const codexHooksFinding = detectCodexHooksFlag(lines);
-  if (codexHooksFinding) findings.push(codexHooksFinding);
-  return { configPath: path9, exists: true, findings };
-}
-function cleanupCodexConfigToml(configPath, opts) {
-  if (opts.removeIds.length === 0) {
-    return { removed: [], backupPath: null, noop: true };
-  }
-  if (!existsSync6(configPath)) {
-    return { removed: [], backupPath: null, noop: true };
-  }
-  const audit = auditCodexConfigToml(configPath);
-  const selected = audit.findings.filter((f) => opts.removeIds.includes(f.id));
-  if (selected.length === 0) {
-    return { removed: [], backupPath: null, noop: true };
-  }
-  const original = readFileSync5(configPath, "utf-8");
-  const backupPath = writeBackup(configPath, original, opts.backupDir);
-  const linesToDrop = /* @__PURE__ */ new Set();
-  for (const finding of selected) {
-    for (let ln = finding.startLine; ln <= finding.endLine; ln++) {
-      linesToDrop.add(ln);
-    }
-  }
-  const originalLines = original.split(/\r?\n/);
-  const kept = [];
-  for (let i = 0; i < originalLines.length; i++) {
-    const ln = i + 1;
-    if (linesToDrop.has(ln)) continue;
-    kept.push(originalLines[i]);
-  }
-  const cleaned = collapseBlankRunsNearDeletions(kept);
-  const output = cleaned.join("\n");
-  atomicWrite(configPath, output);
-  return {
-    removed: selected.map((f) => f.id),
-    backupPath,
-    noop: false
-  };
-}
-function detectTopLevelNotify(lines) {
-  const headerRegex = /^\s*\[/;
-  const notifyRegex = /^\s*notify\s*=\s*(.*)$/;
-  let inTopLevel = true;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (headerRegex.test(trimmed)) {
-      inTopLevel = false;
-      continue;
-    }
-    if (!inTopLevel) continue;
-    const m = trimmed.match(notifyRegex);
-    if (!m) continue;
-    const rhs = (m[1] ?? "").trim();
-    if (rhs.startsWith("[") && rhs.endsWith("]") && countBrackets(rhs) === 0) {
-      return makeNotifyFinding(lines, i, i);
-    }
-    if (rhs.startsWith("[")) {
-      let depth = countBrackets(rhs);
-      for (let j = i + 1; j < lines.length; j++) {
-        depth += countBrackets(lines[j]);
-        if (depth === 0) {
-          return makeNotifyFinding(lines, i, j);
+// packages/server/src/git/auto-fetch.ts
+var PERIOD_SETTING_KEY, DEFAULT_PERIOD_SEC, TICK_INTERVAL_MS, OPEN_TIME_COOLDOWN_MS, MAX_CONSECUTIVE_FAILURES, JITTER_RATIO, AutoFetchScheduler;
+var init_auto_fetch = __esm({
+  "packages/server/src/git/auto-fetch.ts"() {
+    "use strict";
+    PERIOD_SETTING_KEY = "git.autofetchPeriodSec";
+    DEFAULT_PERIOD_SEC = 180;
+    TICK_INTERVAL_MS = 1e3;
+    OPEN_TIME_COOLDOWN_MS = 5 * 60 * 1e3;
+    MAX_CONSECUTIVE_FAILURES = 3;
+    JITTER_RATIO = 0.1;
+    AutoFetchScheduler = class {
+      constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+        this.random = deps.random ?? (() => 0.5);
+        this.setTimeoutFn = deps.setTimeout ?? globalThis.setTimeout;
+        this.setIntervalFn = deps.setInterval ?? globalThis.setInterval;
+        this.clearIntervalFn = deps.clearInterval ?? globalThis.clearInterval;
+        this.clearTimeoutFn = deps.clearTimeout ?? globalThis.clearTimeout;
+        this.start();
+      }
+      deps;
+      clientWorkspaceMap = /* @__PURE__ */ new Map();
+      workspaceStateMap = /* @__PURE__ */ new Map();
+      now;
+      random;
+      setTimeoutFn;
+      setIntervalFn;
+      clearIntervalFn;
+      clearTimeoutFn;
+      pendingTimeouts = /* @__PURE__ */ new Set();
+      tickTimer = null;
+      stopped = false;
+      registerViewer(clientId, workspaceId) {
+        const previousWorkspaceId = this.clientWorkspaceMap.get(clientId);
+        if (previousWorkspaceId === workspaceId) {
+          return;
         }
+        if (previousWorkspaceId) {
+          this.unregisterViewer(clientId);
+        }
+        this.clientWorkspaceMap.set(clientId, workspaceId);
+        const state = this.getOrCreateState(workspaceId);
+        state.viewerCount += 1;
+        if (state.viewerCount === 1) {
+          state.blocked = false;
+          state.consecutiveFailures = 0;
+        }
+        this.ensureNextPeriodicFetch(state, false);
+      }
+      unregisterViewer(clientId) {
+        const workspaceId = this.clientWorkspaceMap.get(clientId);
+        if (!workspaceId) {
+          return;
+        }
+        this.clientWorkspaceMap.delete(clientId);
+        const state = this.workspaceStateMap.get(workspaceId);
+        if (!state) {
+          return;
+        }
+        state.viewerCount = Math.max(0, state.viewerCount - 1);
+        if (state.viewerCount === 0) {
+          state.blocked = false;
+          state.consecutiveFailures = 0;
+          state.nextFetchAt = void 0;
+        }
+      }
+      triggerOpenTimeFetch(workspaceId) {
+        const state = this.getOrCreateState(workspaceId);
+        const lastFetchAt = state.lastFetchAt;
+        if (this.stopped || state.inFlight) {
+          return;
+        }
+        if (lastFetchAt !== void 0 && this.now() - lastFetchAt < OPEN_TIME_COOLDOWN_MS) {
+          return;
+        }
+        const timer = this.setTimeoutFn(() => {
+          this.pendingTimeouts.delete(timer);
+          if (this.stopped) {
+            return;
+          }
+          void this.fetchWorkspace(workspaceId, "open");
+        }, 0);
+        this.pendingTimeouts.add(timer);
+      }
+      recordSuccess(workspaceId) {
+        const state = this.getOrCreateState(workspaceId);
+        state.lastFetchAt = this.now();
+        state.consecutiveFailures = 0;
+        state.blocked = false;
+        state.nextFetchAt = void 0;
+        this.ensureNextPeriodicFetch(state, true);
+      }
+      recordFailure(workspaceId) {
+        const state = this.getOrCreateState(workspaceId);
+        state.consecutiveFailures += 1;
+        state.nextFetchAt = void 0;
+        if (state.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          state.blocked = true;
+          return;
+        }
+        this.ensureNextPeriodicFetch(state, true);
+      }
+      getLastFetchAt(workspaceId) {
+        return this.workspaceStateMap.get(workspaceId)?.lastFetchAt;
+      }
+      async runExclusive(workspaceId, op) {
+        const release = await this.acquireWorkspaceOperation(workspaceId);
+        try {
+          return await op();
+        } finally {
+          release();
+        }
+      }
+      start() {
+        if (this.tickTimer) {
+          return;
+        }
+        this.stopped = false;
+        this.tickTimer = this.setIntervalFn(() => {
+          this.evaluateDueFetches();
+        }, TICK_INTERVAL_MS);
+      }
+      stop() {
+        if (this.tickTimer) {
+          this.clearIntervalFn(this.tickTimer);
+          this.tickTimer = null;
+        }
+        this.stopped = true;
+        for (const timer of this.pendingTimeouts) {
+          this.clearTimeoutFn(timer);
+        }
+        this.pendingTimeouts.clear();
+      }
+      evaluateDueFetches() {
+        const now = this.now();
+        for (const [workspaceId, state] of this.workspaceStateMap) {
+          if (!this.shouldCheckWorkspace(state)) {
+            continue;
+          }
+          if (state.nextFetchAt === void 0) {
+            this.ensureNextPeriodicFetch(state, false);
+          }
+          if (state.nextFetchAt === void 0 || state.nextFetchAt > now) {
+            continue;
+          }
+          void this.fetchWorkspace(workspaceId, "periodic", state.nextFetchAt);
+        }
+      }
+      shouldCheckWorkspace(state) {
+        return this.getPeriodMs() > 0 && state.viewerCount > 0 && !state.inFlight && !state.blocked;
+      }
+      ensureNextPeriodicFetch(state, resetSchedule) {
+        const periodMs = this.getPeriodMs();
+        if (periodMs <= 0 || state.viewerCount <= 0 || state.blocked || state.inFlight) {
+          return;
+        }
+        if (!resetSchedule && state.nextFetchAt !== void 0) {
+          return;
+        }
+        if (state.lastFetchAt === void 0) {
+          state.nextFetchAt = this.now();
+          return;
+        }
+        const nextFetchAt = state.lastFetchAt + this.getJitteredPeriodMs(periodMs);
+        state.nextFetchAt = Math.max(this.now(), nextFetchAt);
+      }
+      getPeriodMs() {
+        const configuredPeriodSec = this.deps.settingsRepo.get(PERIOD_SETTING_KEY);
+        const periodSec = configuredPeriodSec ?? DEFAULT_PERIOD_SEC;
+        return Math.max(0, periodSec) * 1e3;
+      }
+      getJitteredPeriodMs(periodMs) {
+        const jitterScale = 1 + (this.random() - 0.5) * 2 * JITTER_RATIO;
+        return Math.round(periodMs * jitterScale);
+      }
+      getOrCreateState(workspaceId) {
+        const existingState = this.workspaceStateMap.get(workspaceId);
+        if (existingState) {
+          return existingState;
+        }
+        const state = {
+          viewerCount: 0,
+          consecutiveFailures: 0,
+          inFlight: false,
+          blocked: false,
+          waiters: []
+        };
+        this.workspaceStateMap.set(workspaceId, state);
+        return state;
+      }
+      async fetchWorkspace(workspaceId, mode, scheduledAt) {
+        if (this.stopped) {
+          return;
+        }
+        const state = this.getOrCreateState(workspaceId);
+        if (state.inFlight || state.blocked) {
+          return;
+        }
+        if (!this.deps.workspaceMgr.get(workspaceId)) {
+          state.nextFetchAt = void 0;
+          return;
+        }
+        await this.runExclusive(workspaceId, async () => {
+          const currentState = this.getOrCreateState(workspaceId);
+          if (this.stopped || currentState.blocked) {
+            return;
+          }
+          if (!this.deps.workspaceMgr.get(workspaceId)) {
+            currentState.nextFetchAt = void 0;
+            return;
+          }
+          if (mode === "open") {
+            const lastFetchAt = currentState.lastFetchAt;
+            if (lastFetchAt !== void 0 && this.now() - lastFetchAt < OPEN_TIME_COOLDOWN_MS) {
+              return;
+            }
+          } else if (scheduledAt !== void 0 && currentState.lastFetchAt !== void 0 && currentState.lastFetchAt >= scheduledAt) {
+            return;
+          }
+          try {
+            await this.deps.runFetch(workspaceId);
+            this.recordSuccess(workspaceId);
+          } catch {
+            this.recordFailure(workspaceId);
+          }
+        });
+      }
+      acquireWorkspaceOperation(workspaceId) {
+        const state = this.getOrCreateState(workspaceId);
+        return new Promise((resolve4) => {
+          const grant = () => {
+            state.inFlight = true;
+            state.nextFetchAt = void 0;
+            let released = false;
+            resolve4(() => {
+              if (released) {
+                return;
+              }
+              released = true;
+              const next = state.waiters.shift();
+              if (next) {
+                next();
+                return;
+              }
+              state.inFlight = false;
+              this.ensureNextPeriodicFetch(state, true);
+            });
+          };
+          if (state.inFlight) {
+            state.waiters.push(grant);
+            return;
+          }
+          grant();
+        });
       }
-      return null;
-    }
-    return makeNotifyFinding(lines, i, i);
-  }
-  return null;
-}
-function makeNotifyFinding(lines, startIdx, endIdx) {
-  return {
-    id: "toml_notify",
-    type: "toml_notify",
-    severity: "warn",
-    startLine: startIdx + 1,
-    endLine: endIdx + 1,
-    snippet: lines.slice(startIdx, endIdx + 1).join("\n"),
-    message: "config.toml \u9876\u5C42\u8BBE\u7F6E\u4E86 notify\uFF0C\u4F1A\u4E0E Coder Studio \u7684\u542F\u52A8\u53C2\u6570\u6CE8\u5165\u51B2\u7A81\uFF0C\u53EF\u80FD\u5BFC\u81F4 session \u72B6\u6001\u4E0D\u540C\u6B65\u3002"
-  };
-}
-function detectCodexHooksFlag(lines) {
-  const headerRegex = /^\s*\[([^\]]+)\]\s*$/;
-  const codexHooksRegex = /^\s*codex_hooks\s*=\s*true\b/;
-  let currentSection = null;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const headerMatch = line.match(headerRegex);
-    if (headerMatch) {
-      currentSection = headerMatch[1].trim();
-      continue;
-    }
-    if (currentSection !== "features") continue;
-    if (!codexHooksRegex.test(line)) continue;
-    return {
-      id: "toml_codex_hooks",
-      type: "toml_codex_hooks",
-      severity: "info",
-      startLine: i + 1,
-      endLine: i + 1,
-      snippet: line,
-      message: "[features] codex_hooks = true \u542F\u7528\u4E86 Codex CLI \u7684\u5B9E\u9A8C\u6027 hook \u5F15\u64CE\uFF0C\u53EF\u80FD\u5F71\u54CD notify \u7684\u884C\u4E3A\u3002\u82E5\u4E0D\u4E3B\u52A8\u4F7F\u7528\u8BE5\u7279\u6027\uFF0C\u5EFA\u8BAE\u5173\u95ED\u3002"
     };
   }
-  return null;
-}
-function countBrackets(s) {
-  let n = 0;
-  for (const ch of s) {
-    if (ch === "[") n++;
-    else if (ch === "]") n--;
-  }
-  return n;
-}
-function writeBackup(configPath, original, backupDir) {
-  const dir = backupDir ?? dirname4(configPath);
-  if (!existsSync6(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const ts = formatTimestamp(/* @__PURE__ */ new Date());
-  const backupPath = join3(dir, `${basenameNoTomlExt(configPath)}.bak.${ts}.toml`);
-  writeFileSync3(backupPath, original, "utf-8");
-  return backupPath;
-}
-function atomicWrite(configPath, contents) {
-  const tempPath = `${configPath}.tmp`;
-  writeFileSync3(tempPath, contents, "utf-8");
-  renameSync(tempPath, configPath);
-}
-function basenameNoTomlExt(p) {
-  const base = p.split(/[\\/]/).pop() ?? "config.toml";
-  return base.replace(/\.toml$/i, "");
-}
-function formatTimestamp(d) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
-}
-function collapseBlankRunsNearDeletions(lines) {
-  const out = [];
-  let blankRun = 0;
-  for (const line of lines) {
-    if (line.trim() === "") {
-      blankRun++;
-      if (blankRun <= 2) out.push(line);
-    } else {
-      blankRun = 0;
-      out.push(line);
-    }
-  }
-  return out;
-}
-var init_codex_config_audit = __esm({
-  "packages/server/src/config/codex-config-audit.ts"() {
-    "use strict";
-  }
 });
 
 // packages/server/src/provider-runtime/command-runner.ts
@@ -2028,6 +2107,157 @@ 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";
+function createE2EProviderMockOverrides(env = process.env) {
+  const statePath = env.CODER_STUDIO_E2E_PROVIDER_STATE_PATH;
+  if (!statePath) {
+    return null;
+  }
+  const binDir = env.CODER_STUDIO_E2E_PROVIDER_BIN_DIR;
+  const debugLogPath = env.CODER_STUDIO_E2E_PROVIDER_DEBUG_LOG_PATH;
+  appendDebugLog(debugLogPath, `init statePath=${statePath} binDir=${binDir ?? ""}`);
+  const commandExists = async (command) => {
+    const state = readMockState(statePath);
+    const override = state.commands?.[command];
+    appendDebugLog(
+      debugLogPath,
+      `commandExists ${command} override=${String(override)} state=${JSON.stringify(state.commands ?? {})}`
+    );
+    if (typeof override === "boolean") {
+      return override;
+    }
+    return checkCommandAvailable(command);
+  };
+  const runCommand2 = async (file, args, options) => {
+    const providerId = getInstallProviderId(file, args);
+    appendDebugLog(
+      debugLogPath,
+      `runCommand ${file} ${args.join(" ")} provider=${providerId ?? "none"}`
+    );
+    if (!providerId) {
+      return runCommandAsString(file, args, options);
+    }
+    const state = readMockState(statePath);
+    const behavior = state.installBehavior?.[providerId];
+    appendDebugLog(
+      debugLogPath,
+      `behavior ${providerId} ${JSON.stringify(behavior)} state=${JSON.stringify(state)}`
+    );
+    if (!behavior) {
+      return runCommandAsString(file, args, options);
+    }
+    if (behavior.result === "success") {
+      writeMockState(statePath, (draft) => {
+        draft.commands ??= {};
+        draft.commands[providerId] = true;
+      });
+      if (binDir) {
+        ensureProviderCommand(binDir, providerId);
+      }
+      appendDebugLog(debugLogPath, `install success ${providerId}`);
+      return {
+        stdout: `installed ${providerId}`,
+        stderr: ""
+      };
+    }
+    const message = behavior.message ?? (behavior.result === "permission_denied" ? "permission denied" : "command not found");
+    throw Object.assign(new Error(message), {
+      exitCode: 1,
+      stdout: "",
+      stderr: message
+    });
+  };
+  return {
+    commandExists,
+    runCommand: runCommand2
+  };
+}
+function getInstallProviderId(file, args) {
+  if (file !== "npm" || args.length !== 3) {
+    return null;
+  }
+  if (args[0] !== "install" || args[1] !== "-g") {
+    return null;
+  }
+  const packageName = args[2];
+  if (packageName === PROVIDER_INSTALL_PACKAGES.claude) {
+    return "claude";
+  }
+  if (packageName === PROVIDER_INSTALL_PACKAGES.codex) {
+    return "codex";
+  }
+  return null;
+}
+function readMockState(statePath) {
+  if (!existsSync6(statePath)) {
+    return {};
+  }
+  const raw = readFileSync5(statePath, "utf8");
+  if (!raw.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Invalid provider mock state at ${statePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeMockState(statePath, updater) {
+  const nextState = readMockState(statePath);
+  updater(nextState);
+  mkdirSync3(dirname4(statePath), { recursive: true });
+  writeFileSync3(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");
+  chmodSync(scriptPath, 493);
+}
+function appendDebugLog(path10, line) {
+  if (!path10) {
+    return;
+  }
+  mkdirSync3(dirname4(path10), { recursive: true });
+  writeFileSync3(path10, `${line}
+`, { flag: "a" });
+}
+var PROVIDER_INSTALL_PACKAGES, PROVIDER_COMMAND_SCRIPTS;
+var init_e2e_provider_mock = __esm({
+  "packages/server/src/provider-runtime/e2e-provider-mock.ts"() {
+    "use strict";
+    init_command_check();
+    init_command_runner();
+    PROVIDER_INSTALL_PACKAGES = {
+      claude: "@anthropic-ai/claude-code",
+      codex: "@openai/codex"
+    };
+    PROVIDER_COMMAND_SCRIPTS = {
+      claude: `#!/usr/bin/env bash
+set -euo pipefail
+trap 'exit 0' TERM INT
+printf 'Mock Claude ready\\n'
+while true; do
+  sleep 1
+done
+`,
+      codex: `#!/usr/bin/env bash
+set -euo pipefail
+trap 'exit 0' TERM INT
+printf 'Session ID: abcdef-123456\\n> '
+while true; do
+  sleep 1
+done
+`
+    };
+  }
+});
+
 // packages/server/src/provider-runtime/install-manager.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 function getErrorDetails(error) {
@@ -4188,7 +4418,7 @@ function parseStatus(porcelainV2) {
       continue;
     }
     if (record.startsWith("? ")) {
-      untracked.push({ path: record.substring(2) });
+      untracked.push({ path: record.substring(2), status: "untracked" });
     }
   }
   return {
@@ -4209,11 +4439,11 @@ function parseOrdinaryChangedEntry(record, staged, modified, deleted) {
   if (!xy) {
     return;
   }
-  const path9 = parts.slice(8).join(" ");
-  if (!path9) {
+  const path10 = parts.slice(8).join(" ");
+  if (!path10) {
     return;
   }
-  pushChange({ path: path9 }, xy, staged, modified, deleted);
+  pushChange({ path: path10 }, xy, staged, modified, deleted);
 }
 function parseRenamedEntry(record, oldPathRecord, staged, modified, deleted) {
   const parts = record.split(" ");
@@ -4225,27 +4455,52 @@ function parseRenamedEntry(record, oldPathRecord, staged, modified, deleted) {
   const pathAndMaybeOldPath = pathTokens.join(" ");
   const inlinePathParts = pathAndMaybeOldPath.split("	");
   const fallbackPath = !oldPathRecord && inlinePathParts.length === 1 && pathTokens.length > 1 ? pathTokens.slice(0, -1).join(" ") : void 0;
-  const path9 = fallbackPath ?? inlinePathParts[0];
-  if (!path9) {
+  const path10 = fallbackPath ?? inlinePathParts[0];
+  if (!path10) {
     return;
   }
   const oldPath = (oldPathRecord && !oldPathRecord.startsWith("#") ? oldPathRecord : void 0) ?? inlinePathParts[1] ?? (pathTokens.length > 1 ? pathTokens[pathTokens.length - 1] : void 0);
-  pushChange({ path: path9, oldPath }, xy, staged, modified, deleted);
+  pushChange({ path: path10, oldPath }, xy, staged, modified, deleted);
 }
 function pushChange(change, xy, staged, modified, deleted) {
   const indexStatus = xy[0];
   const worktreeStatus = xy[1];
   if (indexStatus && indexStatus !== "." && indexStatus !== " ") {
-    staged.push(change);
+    staged.push({
+      ...change,
+      status: resolveGitChangeStatus(indexStatus, change.oldPath)
+    });
   }
   if (!worktreeStatus || worktreeStatus === "." || worktreeStatus === " ") {
     return;
   }
   if (worktreeStatus === "D") {
-    deleted.push({ path: change.path });
+    deleted.push({ path: change.path, status: "deleted" });
     return;
   }
-  modified.push({ path: change.path });
+  modified.push({
+    path: change.path,
+    oldPath: change.oldPath,
+    status: resolveGitChangeStatus(worktreeStatus, change.oldPath)
+  });
+}
+function resolveGitChangeStatus(code, oldPath) {
+  switch (code) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return oldPath ? "renamed" : "added";
+    case "U":
+      return "modified";
+    case "M":
+    case "T":
+    default:
+      return oldPath ? "renamed" : "modified";
+  }
 }
 var init_status_parser = __esm({
   "packages/server/src/git/status-parser.ts"() {
@@ -4315,6 +4570,40 @@ async function getGitStatus(cwd) {
     headSubject: headSubjectOutput.trim()
   };
 }
+async function getGitHistory(cwd, limit = 5) {
+  try {
+    const { stdout } = await runGit(cwd, [
+      "log",
+      `--max-count=${Math.max(1, limit)}`,
+      "--format=%H%x1f%h%x1f%s%x1f%an%x1f%at%x1e"
+    ]);
+    return stdout.split("").map((record) => record.trim()).filter((record) => record.length > 0).map((record) => {
+      const [sha = "", shortSha = "", subject = "", authorName = "", authoredAt = "0"] = record.split("");
+      return {
+        sha,
+        shortSha,
+        subject,
+        authorName,
+        authoredAt: Number.parseInt(authoredAt, 10) * 1e3
+      };
+    }).filter((entry) => entry.sha && entry.subject);
+  } catch (error) {
+    if (error instanceof GitError && /does not have any commits yet/i.test(error.stderr)) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function getGitCommitDiff(cwd, sha) {
+  const { stdout } = await runGit(cwd, [
+    "show",
+    "--format=medium",
+    "--no-color",
+    "--end-of-options",
+    sha
+  ]);
+  return stdout;
+}
 async function getGitStatusSummary(cwd) {
   const { stdout } = await runGit(cwd, ["status", "--short"]);
   return stdout.trim();
@@ -4335,12 +4624,12 @@ async function discardChanges(cwd, paths) {
   if (paths.length === 0) return;
   const trackedPaths = [];
   const untrackedPaths = [];
-  for (const path9 of paths) {
+  for (const path10 of paths) {
     try {
-      await runGit(cwd, ["ls-files", "--error-unmatch", "--", path9]);
-      trackedPaths.push(path9);
+      await runGit(cwd, ["ls-files", "--error-unmatch", "--", path10]);
+      trackedPaths.push(path10);
     } catch {
-      untrackedPaths.push(path9);
+      untrackedPaths.push(path10);
     }
   }
   if (trackedPaths.length > 0) {
@@ -4379,6 +4668,7 @@ async function runGitPush(cwd, options) {
   if (!remote) {
     remote = await getPreferredRemote(cwd) ?? void 0;
   }
+  const summaryBranch = branch ?? await getCurrentBranchName(cwd);
   if (remote && branch) {
     args.push(remote, `HEAD:${branch}`);
   } else if (remote) {
@@ -4396,8 +4686,13 @@ async function runGitPush(cwd, options) {
     if (options?.auth) {
       await persistGitHttpCredentials(cwd, options.auth, remoteMetadata);
     }
-    const message = stdout || stderr || "Push completed successfully";
-    return { success: true, message };
+    return {
+      success: true,
+      message: "Push completed successfully",
+      remote,
+      branch: summaryBranch,
+      updated: !isPushUpToDate(stdout, stderr)
+    };
   } catch (error) {
     throw normalizeGitAuthFailure(error, {
       operation: "push",
@@ -4421,6 +4716,7 @@ async function runGitPull(cwd, options) {
   if (!remote && branch) {
     remote = await getPreferredRemote(cwd) ?? "origin";
   }
+  const summaryBranch = branch ?? await getCurrentBranchName(cwd);
   if (remote && branch) {
     args.push(remote, branch);
   }
@@ -4450,8 +4746,14 @@ async function runGitPull(cwd, options) {
         }
       }
     }
-    const message = stdout || stderr || "Pull completed successfully";
-    return { success: true, message, updatedFiles };
+    return {
+      success: true,
+      message: "Pull completed successfully",
+      remote,
+      branch: summaryBranch,
+      updated: !isPullUpToDate(stdout, stderr),
+      updatedFiles
+    };
   } catch (error) {
     throw normalizeGitAuthFailure(error, {
       operation: "pull",
@@ -4463,8 +4765,63 @@ async function runGitPull(cwd, options) {
     await authExecution.cleanup();
   }
 }
+async function runGitFetch(cwd, options) {
+  const args = ["fetch"];
+  const remote = options?.remote;
+  const metadataRemote = remote ?? await getPreferredRemote(cwd) ?? void 0;
+  const prune = options?.prune ?? true;
+  if (remote) {
+    args.push(remote);
+  } else {
+    args.push("--all");
+  }
+  if (prune) {
+    args.push("--prune");
+  }
+  const remoteUrl = metadataRemote ? await getRemoteUrl(cwd, metadataRemote) : null;
+  const remoteMetadata = parseRemoteUrlMetadata(remoteUrl ?? void 0);
+  const authExecution = await prepareGitAuthExecution(options?.auth, remoteMetadata);
+  try {
+    const { stdout, stderr } = await runGit(cwd, args, {
+      timeoutMs: options?.timeoutMs ?? GIT_NETWORK_TIMEOUT_MS,
+      env: authExecution.env,
+      config: authExecution.config
+    });
+    if (options?.auth) {
+      await persistGitHttpCredentials(cwd, options.auth, remoteMetadata);
+    }
+    const message = stdout || stderr || "Fetch completed successfully";
+    return {
+      success: true,
+      message,
+      updatedRefs: parseFetchUpdatedRefs(stderr)
+    };
+  } catch (error) {
+    throw normalizeGitAuthFailure(error, {
+      operation: "fetch",
+      remote: metadataRemote,
+      remoteUrl: remoteMetadata.sanitizedUrl ?? remoteUrl ?? void 0,
+      attemptedCredentialAuth: Boolean(options?.auth)
+    });
+  } finally {
+    await authExecution.cleanup();
+  }
+}
+function parseFetchUpdatedRefs(stderr) {
+  const refs = [];
+  for (const rawLine of stderr.split("\n")) {
+    const line = rawLine.trimEnd();
+    const arrowIndex = line.indexOf(" -> ");
+    if (arrowIndex < 0) continue;
+    const target = line.slice(arrowIndex + 4).trim();
+    if (!target) continue;
+    refs.push(target);
+  }
+  return refs;
+}
 async function runGitCheckout(cwd, ref, options) {
   const args = ["checkout"];
+  const formatCheckoutError = (error, fallbackMessage) => error instanceof GitError ? error.stderr.trim() || error.message || fallbackMessage : fallbackMessage;
   let isRemoteRef = false;
   try {
     const { stdout: remoteList } = await runGit(cwd, ["remote"]);
@@ -4476,15 +4833,22 @@ async function runGitCheckout(cwd, ref, options) {
   if (isRemoteRef && !options?.createBranch) {
     const remoteSeparatorIndex = ref.indexOf("/");
     const branchName = remoteSeparatorIndex >= 0 ? ref.slice(remoteSeparatorIndex + 1) : ref;
-    args.push("-b", branchName, ref);
+    try {
+      await runGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+      const { stdout, stderr } = await runGit(cwd, ["checkout", branchName]);
+      const message = stdout || stderr || `Checkout to ${branchName} completed`;
+      return { success: true, message, branch: branchName };
+    } catch {
+      args.push("-b", branchName, ref);
+    }
     try {
       const { stdout, stderr } = await runGit(cwd, args);
       const message = stdout || stderr || `Checkout to ${ref} completed`;
       return { success: true, message, branch: branchName };
-    } catch {
+    } catch (error) {
       return {
         success: false,
-        message: `Failed to checkout remote branch '${ref}'`
+        message: formatCheckoutError(error, `Failed to checkout remote branch '${ref}'`)
       };
     }
   } else {
@@ -4498,10 +4862,10 @@ async function runGitCheckout(cwd, ref, options) {
       const branch = branchMatch?.[1] ?? ref;
       const message = stdout || stderr || `Checkout to ${ref} completed`;
       return { success: true, message, branch };
-    } catch {
+    } catch (error) {
       return {
         success: false,
-        message: `Failed to checkout '${ref}'`
+        message: formatCheckoutError(error, `Failed to checkout '${ref}'`)
       };
     }
   }
@@ -4516,23 +4880,42 @@ async function runGitCreateBranch(cwd, branchName, options) {
 }
 async function runGitListBranches(cwd) {
   const { stdout: localOutput } = await runGit(cwd, ["branch", "--list"]);
+  const { stdout: localVerboseOutput } = await runGit(cwd, ["branch", "--list", "-vv"]);
   const { stdout: remoteOutput } = await runGit(cwd, ["branch", "-r"]);
   const branches = [];
   let current = "";
+  const linkedWorktreePathsByBranch = /* @__PURE__ */ new Map();
+  const localVerboseLines = localVerboseOutput.split("\n").filter((line) => line.trim());
+  for (const line of localVerboseLines) {
+    const normalizedLine = line.replace(/^[*+ ]\s+/, "");
+    const branchMatch = normalizedLine.match(/^([^\s]+)\s+/);
+    const worktreeMatch = line.match(/\((.+?)\)\s/);
+    if (!branchMatch?.[1] || !worktreeMatch?.[1]) {
+      continue;
+    }
+    const worktreePath = worktreeMatch[1];
+    if (worktreePath.startsWith("/") || worktreePath.startsWith("~")) {
+      linkedWorktreePathsByBranch.set(branchMatch[1], worktreePath);
+    }
+  }
   const localLines = localOutput.split("\n").filter((line) => line.trim());
   for (const line of localLines) {
     const isCurrent = line.startsWith("*");
-    const name = line.replace(/^\*?\s+/, "").trim();
+    const name = line.replace(/^[*+ ]\s+/, "").trim();
     if (name.startsWith("(HEAD detached")) {
       if (isCurrent) {
         current = "";
       }
       continue;
     }
+    if (linkedWorktreePathsByBranch.has(name) && !isCurrent) {
+      continue;
+    }
     branches.push({
       name,
       isRemote: false,
-      isCurrent
+      isCurrent,
+      linkedWorktreePath: linkedWorktreePathsByBranch.get(name)
     });
     if (isCurrent) {
       current = name;
@@ -4580,6 +4963,23 @@ async function resolveRemoteBranchTarget(cwd, mode) {
     return null;
   }
 }
+async function getCurrentBranchName(cwd) {
+  try {
+    const { stdout } = await runGit(cwd, ["branch", "--show-current"]);
+    const branch = stdout.trim();
+    return branch || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isPushUpToDate(stdout, stderr) {
+  return /Everything up-to-date/i.test(`${stdout}
+${stderr}`);
+}
+function isPullUpToDate(stdout, stderr) {
+  return /Already up[ -]to[ -]date\.?/i.test(`${stdout}
+${stderr}`);
+}
 async function getPreferredRemote(cwd) {
   try {
     const { stdout } = await runGit(cwd, ["remote"]);
@@ -4964,7 +5364,7 @@ var init_context_builder = __esm({
 });
 
 // packages/server/src/terminal/pty-host.ts
-import { chmodSync, existsSync as existsSync7, statSync } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync7, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import path6 from "node:path";
 function ensureNodePtySpawnHelperExecutable(deps = {}) {
@@ -4976,7 +5376,7 @@ function ensureNodePtySpawnHelperExecutable(deps = {}) {
   const resolve4 = deps.resolve ?? ((id) => require2.resolve(id));
   const fileExists = deps.existsSync ?? existsSync7;
   const stat7 = deps.statSync ?? statSync;
-  const chmod = deps.chmodSync ?? chmodSync;
+  const chmod = deps.chmodSync ?? chmodSync2;
   let packageJsonPath;
   try {
     packageJsonPath = resolve4(NODE_PTY_PKG);
@@ -7011,14 +7411,14 @@ var init_manager3 = __esm({
 // packages/server/src/workspace/validator.ts
 import { constants } from "fs";
 import { access, stat as stat5 } from "fs/promises";
-async function validatePath(path9) {
+async function validatePath(path10) {
   try {
-    const stats = await stat5(path9);
+    const stats = await stat5(path10);
     if (!stats.isDirectory()) {
       return { valid: false, error: "Path is not a directory" };
     }
-    await access(path9, constants.R_OK);
-    await access(path9, constants.W_OK);
+    await access(path10, constants.R_OK);
+    await access(path10, constants.W_OK);
     return { valid: true };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -7035,8 +7435,8 @@ var init_validator = __esm({
   "packages/server/src/workspace/validator.ts"() {
     "use strict";
     WorkspaceValidator = class {
-      async validate(path9) {
-        const result = await validatePath(path9);
+      async validate(path10) {
+        const result = await validatePath(path10);
         if (!result.valid) {
           throw new Error(`Invalid workspace path: ${result.error}`);
         }
@@ -7048,12 +7448,12 @@ var init_validator = __esm({
 // packages/server/src/fs/gitignore.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import ignore from "ignore";
-import { join as join5, relative } from "path";
-function normalizePath(path9) {
-  return path9.replace(/\\/g, "/");
+import { join as join5, relative as relative3 } from "path";
+function normalizePath(path10) {
+  return path10.replace(/\\/g, "/");
 }
-function relativeToRoot(rootPath, path9) {
-  return normalizePath(relative(rootPath, path9));
+function relativeToRoot(rootPath, path10) {
+  return normalizePath(relative3(rootPath, path10));
 }
 function isDefaultTreeIgnored(name) {
   return name.startsWith(".") || name === "node_modules" || name === ".git";
@@ -7061,11 +7461,11 @@ function isDefaultTreeIgnored(name) {
 function isAlwaysTreeIgnored(name) {
   return name === "node_modules" || name === ".git";
 }
-function isIgnoredByGitignore(ig, path9) {
-  if (!path9 || path9.startsWith("..")) {
+function isIgnoredByGitignore(ig, path10) {
+  if (!path10 || path10.startsWith("..")) {
     return false;
   }
-  return ig.ignores(path9) || ig.ignores(`${path9}/`);
+  return ig.ignores(path10) || ig.ignores(`${path10}/`);
 }
 function createGitignoreFilter(rootPath, dirPath) {
   const gitignorePath = join5(rootPath, ".gitignore");
@@ -7085,16 +7485,16 @@ function createGitignoreFilter(rootPath, dirPath) {
 function createWatcherIgnoreFilter(rootPath) {
   const gitignorePath = join5(rootPath, ".gitignore");
   if (!existsSync8(gitignorePath)) {
-    return (path9) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path9)));
+    return (path10) => DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizePath(path10)));
   }
   const gitignoreContent = readFileSync7(gitignorePath, "utf-8");
   const ig = ignore().add(gitignoreContent);
-  return (path9) => {
-    const normalizedPath = normalizePath(path9);
+  return (path10) => {
+    const normalizedPath = normalizePath(path10);
     if (DEFAULT_WATCHER_IGNORED_PATTERNS.some((p) => p.test(normalizedPath))) {
       return true;
     }
-    const relativePath = relativeToRoot(rootPath, path9);
+    const relativePath = relativeToRoot(rootPath, path10);
     return isIgnoredByGitignore(ig, relativePath);
   };
 }
@@ -7214,6 +7614,11 @@ var init_manager4 = __esm({
           new WorkspaceWatcher(workspaceId, rootPath, this.deps.broadcaster)
         );
       }
+      hydrateWatchers() {
+        for (const workspace of this.list()) {
+          this.startWatcher(workspace.id, workspace.path);
+        }
+      }
       updateUiState(workspaceId, uiState) {
         const workspace = this.get(workspaceId);
         if (!workspace) {
@@ -7248,6 +7653,7 @@ var init_manager4 = __esm({
             workspaceId: existing.id,
             patch: { lastActiveAt: Date.now() }
           });
+          this.deps.autoFetch?.triggerOpenTimeFetch(existing.id);
           return existing;
         }
         const workspace = {
@@ -7285,6 +7691,7 @@ var init_manager4 = __esm({
           patch: workspace
         });
         this.startWatcher(workspace.id, workspace.path);
+        this.deps.autoFetch?.triggerOpenTimeFetch(workspace.id);
         return workspace;
       }
       /**
@@ -7369,12 +7776,12 @@ var init_manager4 = __esm({
        * @param path - Workspace path
        * @returns Workspace or undefined
        */
-      getByPath(path9) {
+      getByPath(path10) {
         const row = this.deps.db.prepare(
           `SELECT id, path, target_runtime, wsl_distro, opened_at, last_active_at, ui_state
          FROM workspaces
          WHERE path = ?`
-        ).get(path9);
+        ).get(path10);
         if (!row) return void 0;
         return {
           id: row.id,
@@ -7395,13 +7802,87 @@ var init_manager4 = __esm({
         const now = Date.now();
         this.deps.db.prepare("UPDATE workspaces SET last_active_at = ? WHERE id = ?").run(now, workspaceId);
       }
+      recordFetch(workspaceId) {
+        this.deps.autoFetch?.recordSuccess(workspaceId);
+      }
     };
   }
 });
 
-// packages/server/src/ws/fencing.ts
-var DEFAULT_OPTIONS, FencingManager;
-var init_fencing = __esm({
+// 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 handler = handlers.get(msg.op);
+  if (!handler) {
+    return {
+      kind: "result",
+      id: msg.id,
+      ok: false,
+      error: {
+        code: "unknown_op",
+        message: `Unknown operation: ${msg.op}`
+      }
+    };
+  }
+  try {
+    const schema = schemas.get(msg.op);
+    let args = msg.args;
+    if (schema) {
+      args = schema.parse(msg.args);
+    }
+    const data = await handler(args, ctx, clientId);
+    return {
+      kind: "result",
+      id: msg.id,
+      ok: true,
+      data
+    };
+  } catch (error) {
+    const normalizedError = normalizeError(error);
+    return {
+      kind: "result",
+      id: msg.id,
+      ok: false,
+      error: normalizedError
+    };
+  }
+}
+function normalizeError(error) {
+  const candidate = error;
+  if (candidate.name === "ZodError") {
+    return {
+      code: "validation_error",
+      message: "Invalid arguments",
+      details: candidate.errors
+    };
+  }
+  if (candidate.code) {
+    return {
+      code: candidate.code,
+      message: candidate.message ?? String(candidate.code),
+      details: candidate.details
+    };
+  }
+  return {
+    code: "internal_error",
+    message: candidate.message || "An internal error occurred"
+  };
+}
+var handlers, schemas;
+var init_dispatch = __esm({
+  "packages/server/src/ws/dispatch.ts"() {
+    "use strict";
+    handlers = /* @__PURE__ */ new Map();
+    schemas = /* @__PURE__ */ new Map();
+  }
+});
+
+// packages/server/src/ws/fencing.ts
+var DEFAULT_OPTIONS, FencingManager;
+var init_fencing = __esm({
   "packages/server/src/ws/fencing.ts"() {
     "use strict";
     DEFAULT_OPTIONS = {
@@ -7571,127 +8052,6 @@ var init_fencing = __esm({
   }
 });
 
-// packages/server/src/ws/dispatch.ts
-async function debounce(key, op, windowMs) {
-  let entry = debounceMap.get(key);
-  if (entry) {
-    clearTimeout(entry.timer);
-    entry.op = op;
-  } else {
-    let resolve4;
-    let reject;
-    const promise = new Promise((res, rej) => {
-      resolve4 = res;
-      reject = rej;
-    });
-    entry = {
-      timer: void 0,
-      promise,
-      resolve: resolve4,
-      reject,
-      op
-    };
-    debounceMap.set(key, entry);
-  }
-  entry.timer = setTimeout(async () => {
-    debounceMap.delete(key);
-    try {
-      const result = await entry.op();
-      entry.resolve(result);
-    } catch (err) {
-      entry.reject(err);
-    }
-  }, windowMs);
-  return entry.promise;
-}
-function registerCommand(op, schema, handler) {
-  handlers.set(op, handler);
-  schemas.set(op, schema);
-}
-async function dispatch(msg, ctx, clientId) {
-  const handler = handlers.get(msg.op);
-  if (!handler) {
-    return {
-      kind: "result",
-      id: msg.id,
-      ok: false,
-      error: {
-        code: "unknown_op",
-        message: `Unknown operation: ${msg.op}`
-      }
-    };
-  }
-  try {
-    const schema = schemas.get(msg.op);
-    let args = msg.args;
-    if (schema) {
-      args = schema.parse(msg.args);
-    }
-    const data = await executeWithDebounce(msg.op, args, ctx, clientId);
-    return {
-      kind: "result",
-      id: msg.id,
-      ok: true,
-      data
-    };
-  } catch (error) {
-    const normalizedError = normalizeError(error);
-    return {
-      kind: "result",
-      id: msg.id,
-      ok: false,
-      error: normalizedError
-    };
-  }
-}
-async function executeWithDebounce(op, args, ctx, clientId) {
-  const handler = handlers.get(op);
-  if (op === "git.status") {
-    const workspaceId = getWorkspaceId(args);
-    const key = workspaceId ? `git.status:${workspaceId}` : op;
-    return debounce(key, () => handler(args, ctx, clientId), DEBOUNCE_GIT_STATUS_MS);
-  }
-  return handler(args, ctx, clientId);
-}
-function getWorkspaceId(args) {
-  if (typeof args !== "object" || args === null || !("workspaceId" in args)) {
-    return void 0;
-  }
-  const workspaceId = args.workspaceId;
-  return typeof workspaceId === "string" ? workspaceId : void 0;
-}
-function normalizeError(error) {
-  const candidate = error;
-  if (candidate.name === "ZodError") {
-    return {
-      code: "validation_error",
-      message: "Invalid arguments",
-      details: candidate.errors
-    };
-  }
-  if (candidate.code) {
-    return {
-      code: candidate.code,
-      message: candidate.message ?? String(candidate.code),
-      details: candidate.details
-    };
-  }
-  return {
-    code: "internal_error",
-    message: candidate.message || "An internal error occurred"
-  };
-}
-var handlers, schemas, debounceMap, DEBOUNCE_GIT_STATUS_MS;
-var init_dispatch = __esm({
-  "packages/server/src/ws/dispatch.ts"() {
-    "use strict";
-    handlers = /* @__PURE__ */ new Map();
-    schemas = /* @__PURE__ */ new Map();
-    debounceMap = /* @__PURE__ */ new Map();
-    DEBOUNCE_GIT_STATUS_MS = 500;
-  }
-});
-
 // packages/server/src/commands/terminal.ts
 import { basename as basename2 } from "node:path";
 import { z as z5 } from "zod";
@@ -8540,6 +8900,7 @@ var init_hub = __esm({
       handleClose(client) {
         this.clients.delete(client.id);
         this.discardPendingBinaryWaiters(client.id);
+        this.deps.commandContext?.autoFetch.unregisterViewer(client.id);
       }
       /**
        * Takeover: Force close existing writer and accept new one
@@ -8732,7 +9093,7 @@ var init_hub = __esm({
 
 // packages/server/src/commands/workspace.ts
 import { readdir as readdir2 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { join as join6 } from "node:path";
 import { z as z6 } from "zod";
 var init_workspace = __esm({
@@ -8748,7 +9109,7 @@ var init_workspace = __esm({
         path: z6.string().optional()
       }),
       async (args) => {
-        const basePath = args.path || homedir4();
+        const basePath = args.path || homedir3();
         const entries = await readdir2(basePath, { withFileTypes: true });
         const directories = entries.filter((entry) => entry.isDirectory()).map((entry) => ({
           name: entry.name,
@@ -8821,6 +9182,35 @@ var init_workspace = __esm({
   }
 });
 
+// packages/server/src/commands/workspace-activity.ts
+import { z as z7 } from "zod";
+var init_workspace_activity = __esm({
+  "packages/server/src/commands/workspace-activity.ts"() {
+    "use strict";
+    init_dispatch();
+    registerCommand(
+      "workspace.activate",
+      z7.object({
+        workspaceId: z7.string()
+      }),
+      async (args, ctx, clientId) => {
+        if (!clientId) {
+          return {};
+        }
+        ctx.autoFetch.registerViewer(clientId, args.workspaceId);
+        return {};
+      }
+    );
+    registerCommand("workspace.deactivate", z7.object({}), async (_args, ctx, clientId) => {
+      if (!clientId) {
+        return {};
+      }
+      ctx.autoFetch.unregisterViewer(clientId);
+      return {};
+    });
+  }
+});
+
 // packages/server/src/provider-runtime/runtime-status.ts
 function canAutoInstall(provider, platform, missingCommands, missingPrerequisites, availableCommands) {
   const strategies = provider.install.strategies[platform] ?? [];
@@ -8915,7 +9305,7 @@ var init_runtime_status = __esm({
 });
 
 // packages/server/src/commands/session.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function getProviderFromRegistry(providerId, registry) {
   return registry.find((provider) => provider.id === providerId);
 }
@@ -8926,8 +9316,8 @@ var init_session = __esm({
     init_dispatch();
     registerCommand(
       "session.list",
-      z7.object({
-        workspaceId: z7.string()
+      z8.object({
+        workspaceId: z8.string()
       }),
       async (args, ctx) => {
         return ctx.sessionMgr.getForWorkspace(args.workspaceId);
@@ -8935,10 +9325,10 @@ var init_session = __esm({
     );
     registerCommand(
       "session.create",
-      z7.object({
-        workspaceId: z7.string(),
-        providerId: z7.string(),
-        draft: z7.string().optional()
+      z8.object({
+        workspaceId: z8.string(),
+        providerId: z8.string(),
+        draft: z8.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -8972,8 +9362,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.stop",
-      z7.object({
-        sessionId: z7.string()
+      z8.object({
+        sessionId: z8.string()
       }),
       async (args, ctx) => {
         await ctx.sessionMgr.stop(args.sessionId);
@@ -8981,8 +9371,8 @@ var init_session = __esm({
     );
     registerCommand(
       "session.remove",
-      z7.object({
-        sessionId: z7.string()
+      z8.object({
+        sessionId: z8.string()
       }),
       async (args, ctx) => {
         const session = ctx.sessionMgr.get(args.sessionId);
@@ -9000,7 +9390,7 @@ 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 relative2 } from "path";
+import { join as join7, relative as relative4 } from "path";
 async function readTree(rootPath, subdir) {
   const targetPath = subdir ? join7(rootPath, subdir) : rootPath;
   const filter = createGitignoreFilter(rootPath, targetPath);
@@ -9011,7 +9401,7 @@ async function readTree(rootPath, subdir) {
       continue;
     }
     const fullPath = join7(targetPath, entry.name);
-    const relPath = relative2(rootPath, fullPath);
+    const relPath = relative4(rootPath, fullPath);
     if (entry.isDirectory()) {
       nodes.push({
         name: entry.name,
@@ -9055,7 +9445,7 @@ async function searchFiles(rootPath, query, limit = 10) {
     filteredEntries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of filteredEntries) {
       const fullPath = join7(dirPath, entry.name);
-      const relPath = relative2(rootPath, fullPath);
+      const relPath = relative4(rootPath, fullPath);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -9147,7 +9537,7 @@ var init_tree = __esm({
 });
 
 // packages/server/src/commands/file.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var init_file = __esm({
   "packages/server/src/commands/file.ts"() {
     "use strict";
@@ -9156,9 +9546,9 @@ var init_file = __esm({
     init_dispatch();
     registerCommand(
       "file.readTree",
-      z8.object({
-        workspaceId: z8.string(),
-        subPath: z8.string().optional()
+      z9.object({
+        workspaceId: z9.string(),
+        subPath: z9.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9170,10 +9560,10 @@ var init_file = __esm({
     );
     registerCommand(
       "file.search",
-      z8.object({
-        workspaceId: z8.string(),
-        query: z8.string(),
-        limit: z8.number().int().positive().max(50).optional()
+      z9.object({
+        workspaceId: z9.string(),
+        query: z9.string(),
+        limit: z9.number().int().positive().max(50).optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9185,9 +9575,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.read",
-      z8.object({
-        workspaceId: z8.string(),
-        path: z8.string()
+      z9.object({
+        workspaceId: z9.string(),
+        path: z9.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9199,9 +9589,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.create",
-      z8.object({
-        workspaceId: z8.string(),
-        path: z8.string()
+      z9.object({
+        workspaceId: z9.string(),
+        path: z9.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9219,9 +9609,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.mkdir",
-      z8.object({
-        workspaceId: z8.string(),
-        path: z8.string()
+      z9.object({
+        workspaceId: z9.string(),
+        path: z9.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9239,9 +9629,9 @@ var init_file = __esm({
     );
     registerCommand(
       "file.delete",
-      z8.object({
-        workspaceId: z8.string(),
-        path: z8.string()
+      z9.object({
+        workspaceId: z9.string(),
+        path: z9.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9259,11 +9649,11 @@ var init_file = __esm({
     );
     registerCommand(
       "file.write",
-      z8.object({
-        workspaceId: z8.string(),
-        path: z8.string(),
-        content: z8.string(),
-        baseHash: z8.string().optional()
+      z9.object({
+        workspaceId: z9.string(),
+        path: z9.string(),
+        content: z9.string(),
+        baseHash: z9.string().optional()
         // For conflict detection
       }),
       async (args, ctx) => {
@@ -9322,11 +9712,11 @@ async function getUntrackedFileDiff(cwd, filePath) {
     await rm5(tempDir, { recursive: true, force: true });
   }
 }
-async function getFileDiff(cwd, path9, staged = false) {
-  if (!staged && !await isTrackedPath(cwd, path9)) {
-    return getUntrackedFileDiff(cwd, path9);
+async function getFileDiff(cwd, path10, staged = false) {
+  if (!staged && !await isTrackedPath(cwd, path10)) {
+    return getUntrackedFileDiff(cwd, path10);
   }
-  const args = staged ? ["diff", "--staged", "--", path9] : ["diff", "--", path9];
+  const args = staged ? ["diff", "--staged", "--", path10] : ["diff", "--", path10];
   const result = await runGit(cwd, args);
   return result.stdout;
 }
@@ -9337,8 +9727,7 @@ var init_diff = __esm({
   }
 });
 
-// packages/server/src/commands/git.ts
-import { z as z9 } from "zod";
+// packages/server/src/commands/git-events.ts
 function emitGitStateChanged(ctx, workspaceId, options) {
   ctx.eventBus.emit({
     type: "git.state.changed",
@@ -9348,21 +9737,38 @@ function emitGitStateChanged(ctx, workspaceId, options) {
     worktreeChanged: options?.worktreeChanged
   });
 }
-var gitHttpAuthSchema;
+var init_git_events = __esm({
+  "packages/server/src/commands/git-events.ts"() {
+    "use strict";
+  }
+});
+
+// packages/server/src/commands/git.ts
+import { z as z10 } from "zod";
+async function runGitNetworkOperation(ctx, workspaceId, op) {
+  if (!ctx.autoFetch?.runExclusive) {
+    return op();
+  }
+  return ctx.autoFetch.runExclusive(workspaceId, op);
+}
+var gitHttpAuthSchema, gitCommitRevisionSchema, GIT_BACKGROUND_FETCH_TIMEOUT_MS;
 var init_git2 = __esm({
   "packages/server/src/commands/git.ts"() {
     "use strict";
     init_cli();
     init_diff();
     init_dispatch();
-    gitHttpAuthSchema = z9.object({
-      username: z9.string(),
-      password: z9.string()
+    init_git_events();
+    gitHttpAuthSchema = z10.object({
+      username: z10.string(),
+      password: z10.string()
     });
+    gitCommitRevisionSchema = z10.string().regex(/^[0-9a-fA-F]{7,64}$/, "Invalid git commit revision");
+    GIT_BACKGROUND_FETCH_TIMEOUT_MS = 30 * 1e3;
     registerCommand(
       "git.status",
-      z9.object({
-        workspaceId: z9.string()
+      z10.object({
+        workspaceId: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9374,9 +9780,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.stage",
-      z9.object({
-        workspaceId: z9.string(),
-        paths: z9.array(z9.string())
+      z10.object({
+        workspaceId: z10.string(),
+        paths: z10.array(z10.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9390,10 +9796,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.diff",
-      z9.object({
-        workspaceId: z9.string(),
-        path: z9.string(),
-        staged: z9.boolean().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        path: z10.string(),
+        staged: z10.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9405,11 +9811,43 @@ var init_git2 = __esm({
         };
       }
     );
+    registerCommand(
+      "git.log",
+      z10.object({
+        workspaceId: z10.string(),
+        limit: z10.number().int().min(1).max(50).optional()
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return {
+          entries: await getGitHistory(workspace.path, args.limit ?? 5)
+        };
+      }
+    );
+    registerCommand(
+      "git.show",
+      z10.object({
+        workspaceId: z10.string(),
+        sha: gitCommitRevisionSchema
+      }),
+      async (args, ctx) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        return {
+          diff: await getGitCommitDiff(workspace.path, args.sha)
+        };
+      }
+    );
     registerCommand(
       "git.unstage",
-      z9.object({
-        workspaceId: z9.string(),
-        paths: z9.array(z9.string())
+      z10.object({
+        workspaceId: z10.string(),
+        paths: z10.array(z10.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9423,9 +9861,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.discard",
-      z9.object({
-        workspaceId: z9.string(),
-        paths: z9.array(z9.string())
+      z10.object({
+        workspaceId: z10.string(),
+        paths: z10.array(z10.string())
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9441,9 +9879,9 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.commit",
-      z9.object({
-        workspaceId: z9.string(),
-        message: z9.string()
+      z10.object({
+        workspaceId: z10.string(),
+        message: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9460,11 +9898,11 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.push",
-      z9.object({
-        workspaceId: z9.string(),
-        remote: z9.string().optional(),
-        branch: z9.string().optional(),
-        force: z9.boolean().optional(),
+      z10.object({
+        workspaceId: z10.string(),
+        remote: z10.string().optional(),
+        branch: z10.string().optional(),
+        force: z10.boolean().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9472,12 +9910,16 @@ var init_git2 = __esm({
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
-        const result = await runGitPush(workspace.path, {
-          remote: args.remote,
-          branch: args.branch,
-          force: args.force,
-          auth: args.auth
-        });
+        const result = await runGitNetworkOperation(
+          ctx,
+          args.workspaceId,
+          () => runGitPush(workspace.path, {
+            remote: args.remote,
+            branch: args.branch,
+            force: args.force,
+            auth: args.auth
+          })
+        );
         emitGitStateChanged(ctx, args.workspaceId, {
           branchChanged: true,
           worktreeChanged: true
@@ -9487,10 +9929,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.pull",
-      z9.object({
-        workspaceId: z9.string(),
-        remote: z9.string().optional(),
-        branch: z9.string().optional(),
+      z10.object({
+        workspaceId: z10.string(),
+        remote: z10.string().optional(),
+        branch: z10.string().optional(),
         auth: gitHttpAuthSchema.optional()
       }),
       async (args, ctx) => {
@@ -9498,11 +9940,16 @@ var init_git2 = __esm({
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
-        const result = await runGitPull(workspace.path, {
-          remote: args.remote,
-          branch: args.branch,
-          auth: args.auth
-        });
+        const result = await runGitNetworkOperation(
+          ctx,
+          args.workspaceId,
+          () => runGitPull(workspace.path, {
+            remote: args.remote,
+            branch: args.branch,
+            auth: args.auth
+          })
+        );
+        ctx.workspaceMgr.recordFetch(args.workspaceId);
         emitGitStateChanged(ctx, args.workspaceId, {
           treeChanged: true,
           branchChanged: true,
@@ -9511,12 +9958,46 @@ var init_git2 = __esm({
         return result;
       }
     );
+    registerCommand(
+      "git.fetch",
+      z10.object({
+        workspaceId: z10.string(),
+        remote: z10.string().optional(),
+        prune: z10.boolean().optional(),
+        auth: gitHttpAuthSchema.optional(),
+        background: z10.boolean().optional()
+      }),
+      async (args, ctx, clientId) => {
+        const workspace = ctx.workspaceMgr.get(args.workspaceId);
+        if (!workspace) {
+          throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
+        }
+        try {
+          const isInternalBackgroundFetch = args.background === true && !clientId;
+          const runFetch = () => runGitFetch(workspace.path, {
+            remote: args.remote,
+            prune: args.prune,
+            auth: args.auth,
+            timeoutMs: args.background ? GIT_BACKGROUND_FETCH_TIMEOUT_MS : void 0
+          });
+          const result = isInternalBackgroundFetch ? await runFetch() : await runGitNetworkOperation(ctx, args.workspaceId, runFetch);
+          ctx.workspaceMgr.recordFetch(args.workspaceId);
+          emitGitStateChanged(ctx, args.workspaceId, { branchChanged: true });
+          return result;
+        } catch (err) {
+          if (args.background && err instanceof GitAuthError) {
+            return { success: false, message: err.message, updatedRefs: [] };
+          }
+          throw err;
+        }
+      }
+    );
     registerCommand(
       "git.checkout",
-      z9.object({
-        workspaceId: z9.string(),
-        ref: z9.string(),
-        createBranch: z9.boolean().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        ref: z10.string(),
+        createBranch: z10.boolean().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9538,10 +10019,10 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branch",
-      z9.object({
-        workspaceId: z9.string(),
-        name: z9.string(),
-        startPoint: z9.string().optional()
+      z10.object({
+        workspaceId: z10.string(),
+        name: z10.string(),
+        startPoint: z10.string().optional()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9560,8 +10041,8 @@ var init_git2 = __esm({
     );
     registerCommand(
       "git.branches",
-      z9.object({
-        workspaceId: z9.string()
+      z10.object({
+        workspaceId: z10.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -9575,8 +10056,8 @@ var init_git2 = __esm({
 });
 
 // packages/server/src/config/config-io.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+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";
 function resolveConfigPath(configType) {
   if (configType === "codex") {
@@ -9584,14 +10065,18 @@ function resolveConfigPath(configType) {
     if (testHome && testHome.trim()) {
       return join8(testHome, "config.toml");
     }
-    return resolveCodexConfigPath();
+    const codexHome = process.env.CODEX_HOME;
+    if (codexHome && codexHome.trim()) {
+      return join8(codexHome, "config.toml");
+    }
+    return join8(homedir4(), ".codex", "config.toml");
   }
   if (configType === "claude") {
     const testHome = process.env.CODER_STUDIO_CLAUDE_HOME;
     if (testHome && testHome.trim()) {
       return join8(testHome, "settings.json");
     }
-    return join8(homedir5(), ".claude", "settings.json");
+    return join8(homedir4(), ".claude", "settings.json");
   }
   throw new Error(`Unknown config type: ${configType}`);
 }
@@ -9620,7 +10105,7 @@ function writeConfigFile(configType, content) {
     }
     const tempPath = `${configPath}.tmp`;
     writeFileSync4(tempPath, content, "utf-8");
-    renameSync2(tempPath, configPath);
+    renameSync(tempPath, configPath);
     return { success: true, backupPath };
   } catch (error) {
     return {
@@ -9635,24 +10120,23 @@ function createBackup(filePath) {
   const ext = filePath.split(".").pop() ?? "";
   const base = basename3(filePath, `.${ext}`);
   const dir = dirname5(filePath);
-  const ts = formatTimestamp2(/* @__PURE__ */ new Date());
+  const ts = formatTimestamp(/* @__PURE__ */ new Date());
   const backupPath = join8(dir, `${base}.bak.${ts}.${ext}`);
   writeFileSync4(backupPath, original, "utf-8");
   return backupPath;
 }
-function formatTimestamp2(d) {
+function formatTimestamp(d) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
 }
 var init_config_io = __esm({
   "packages/server/src/config/config-io.ts"() {
     "use strict";
-    init_codex_config_audit();
   }
 });
 
 // packages/server/src/commands/settings.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function flattenSettings(obj, prefix = "") {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
@@ -9665,7 +10149,7 @@ function flattenSettings(obj, prefix = "") {
   }
   return result;
 }
-var EMPTY_CODEX_AUDIT, SettingsSchema;
+var SettingsSchema;
 var init_settings2 = __esm({
   "packages/server/src/commands/settings.ts"() {
     "use strict";
@@ -9675,34 +10159,27 @@ var init_settings2 = __esm({
     init_provider_config_repo();
     init_settings();
     init_dispatch();
-    EMPTY_CODEX_AUDIT = {
-      codex: {
-        configPath: "",
-        exists: false,
-        findings: []
-      }
-    };
-    SettingsSchema = z10.object({
-      defaultProviderId: z10.string().optional(),
-      notifications: z10.object({
-        enabled: z10.boolean().optional(),
-        soundEnabled: z10.boolean().optional(),
+    SettingsSchema = z11.object({
+      defaultProviderId: z11.string().optional(),
+      notifications: z11.object({
+        enabled: z11.boolean().optional(),
+        soundEnabled: z11.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: z10.boolean().optional()
+        onlyWhenBackgrounded: z11.boolean().optional()
       }).optional(),
-      supervisor: z10.object({
-        evaluationTimeoutSec: z10.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional()
+      supervisor: z11.object({
+        evaluationTimeoutSec: z11.number().int().min(1).max(MAX_SUPERVISOR_EVALUATION_TIMEOUT_SEC).default(DEFAULT_SUPERVISOR_EVALUATION_TIMEOUT_SEC).optional()
       }).optional(),
-      appearance: z10.object({
-        theme: z10.enum(["dark"]).optional(),
-        terminalRenderer: z10.enum(["standard", "compatibility"]).optional(),
-        locale: z10.enum(["zh", "en"]).optional()
+      appearance: z11.object({
+        theme: z11.enum(["dark"]).optional(),
+        terminalRenderer: z11.enum(["standard", "compatibility"]).optional(),
+        locale: z11.enum(["zh", "en"]).optional()
       }).optional(),
       providers: ProviderSettingsSchema.optional()
     });
-    registerCommand("settings.get", z10.object({}), async (_args, ctx) => {
+    registerCommand("settings.get", z11.object({}), async (_args, ctx) => {
       const row = ctx.db.prepare("SELECT key, value FROM user_settings").all();
       const settings = {};
       for (const { key, value } of row) {
@@ -9726,11 +10203,6 @@ var init_settings2 = __esm({
           flattenSettings(sanitizeProviderLaunchConfig(config), `providers.${providerId}`)
         );
       }
-      try {
-        settings.externalConfigAudit = ctx.codexConfigAudit?.audit() ?? EMPTY_CODEX_AUDIT;
-      } catch {
-        settings.externalConfigAudit = null;
-      }
       if (Object.prototype.hasOwnProperty.call(settings, SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY)) {
         settings[SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY] = resolveSupervisorEvaluationTimeoutSec(
           settings[SUPERVISOR_EVALUATION_TIMEOUT_SETTING_KEY]
@@ -9740,7 +10212,7 @@ var init_settings2 = __esm({
     });
     registerCommand(
       "settings.update",
-      z10.object({
+      z11.object({
         settings: SettingsSchema
       }),
       async (args, ctx) => {
@@ -9770,31 +10242,12 @@ var init_settings2 = __esm({
         };
       }
     );
-    registerCommand(
-      "settings.cleanupCodexConfig",
-      z10.object({
-        removeIds: z10.array(z10.enum(["toml_notify", "toml_codex_hooks"])).min(1)
-      }),
-      async (args, ctx) => {
-        const result = ctx.codexConfigAudit?.cleanup(args.removeIds) ?? {
-          removed: [],
-          backupPath: null,
-          noop: true
-        };
-        return {
-          removed: result.removed,
-          backupPath: result.backupPath,
-          noop: result.noop,
-          audit: ctx.codexConfigAudit?.audit() ?? EMPTY_CODEX_AUDIT
-        };
-      }
-    );
     registerCommand(
       "settings.previewCommand",
-      z10.object({
-        providerId: z10.string(),
+      z11.object({
+        providerId: z11.string(),
         config: ProviderLaunchConfigInputSchema,
-        workspacePath: z10.string().optional()
+        workspacePath: z11.string().optional()
       }),
       async (args, ctx) => {
         const provider = ctx.providerRegistry.find((item) => item.id === args.providerId);
@@ -9815,8 +10268,8 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.readConfigFile",
-      z10.object({
-        configType: z10.enum(["codex", "claude"])
+      z11.object({
+        configType: z11.enum(["codex", "claude"])
       }),
       async (args) => {
         const result = readConfigFile(args.configType);
@@ -9825,9 +10278,9 @@ var init_settings2 = __esm({
     );
     registerCommand(
       "settings.writeConfigFile",
-      z10.object({
-        configType: z10.enum(["codex", "claude"]),
-        content: z10.string()
+      z11.object({
+        configType: z11.enum(["codex", "claude"]),
+        content: z11.string()
       }),
       async (args) => {
         const result = writeConfigFile(args.configType, args.content);
@@ -9838,19 +10291,19 @@ var init_settings2 = __esm({
 });
 
 // packages/server/src/commands/provider.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var init_provider = __esm({
   "packages/server/src/commands/provider.ts"() {
     "use strict";
     init_runtime_status();
     init_dispatch();
-    registerCommand("provider.runtimeStatus", z11.object({}), async (_args, ctx) => {
+    registerCommand("provider.runtimeStatus", z12.object({}), async (_args, ctx) => {
       return buildProviderRuntimeStatus(ctx.providerRegistry, ctx.providerRuntimeDeps);
     });
     registerCommand(
       "provider.install.start",
-      z11.object({
-        providerId: z11.string()
+      z12.object({
+        providerId: z12.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -9864,8 +10317,8 @@ var init_provider = __esm({
     );
     registerCommand(
       "provider.install.get",
-      z11.object({
-        jobId: z11.string()
+      z12.object({
+        jobId: z12.string()
       }),
       async (args, ctx) => {
         if (!ctx.providerInstallMgr) {
@@ -9888,29 +10341,29 @@ var init_provider = __esm({
 });
 
 // packages/server/src/commands/supervisor.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var supervisorObjectiveSchema, createSupervisorSchema, updateSupervisorSchema, sessionIdSchema, supervisorIdSchema;
 var init_supervisor2 = __esm({
   "packages/server/src/commands/supervisor.ts"() {
     "use strict";
     init_dispatch();
-    supervisorObjectiveSchema = z12.string().trim().min(1).max(4e3);
-    createSupervisorSchema = z12.object({
-      sessionId: z12.string(),
-      workspaceId: z12.string(),
+    supervisorObjectiveSchema = z13.string().trim().min(1).max(4e3);
+    createSupervisorSchema = z13.object({
+      sessionId: z13.string(),
+      workspaceId: z13.string(),
       objective: supervisorObjectiveSchema,
-      evaluatorProviderId: z12.string()
+      evaluatorProviderId: z13.string()
     }).strict();
-    updateSupervisorSchema = z12.object({
-      id: z12.string(),
+    updateSupervisorSchema = z13.object({
+      id: z13.string(),
       objective: supervisorObjectiveSchema.optional(),
-      evaluatorProviderId: z12.string().optional()
+      evaluatorProviderId: z13.string().optional()
     }).strict().refine(
       (input) => input.objective !== void 0 || input.evaluatorProviderId !== void 0,
       "objective or evaluatorProviderId is required"
     );
-    sessionIdSchema = z12.object({ sessionId: z12.string() });
-    supervisorIdSchema = z12.object({ id: z12.string() });
+    sessionIdSchema = z13.object({ sessionId: z13.string() });
+    supervisorIdSchema = z13.object({ id: z13.string() });
     registerCommand("supervisor.create", createSupervisorSchema, async (args, ctx) => {
       return {
         supervisor: await ctx.supervisorMgr.create({
@@ -9953,6 +10406,10 @@ import path8 from "node:path";
 function normalizeWorktreePath(worktreePath) {
   return path8.resolve(worktreePath);
 }
+async function getGitCommonDirPath(repoPath) {
+  const { stdout } = await runGit(repoPath, ["rev-parse", "--git-common-dir"]);
+  return normalizeWorktreePath(path8.resolve(repoPath, stdout.trim()));
+}
 async function resolveWorktreePath(repoPath, worktreePath) {
   const normalizedRequested = normalizeWorktreePath(worktreePath);
   const worktrees = await listWorktrees(repoPath);
@@ -10038,19 +10495,30 @@ async function getWorktreeTree(worktreePath) {
   for (const line of lines) {
     const isDir = line.endsWith("/");
     const name = isDir ? line.slice(0, -1) : line;
-    const path9 = `${worktreePath}/${name}`;
+    const path10 = `${worktreePath}/${name}`;
     nodes.push({
       name,
-      path: path9,
+      path: path10,
       kind: isDir ? "dir" : "file"
     });
   }
   return nodes;
 }
-async function createWorktree(repoPath, branch, path9) {
-  await runGit(repoPath, ["worktree", "add", path9, branch]);
+async function createWorktree(repoPath, branch, worktreePath) {
+  let createArgs = ["worktree", "add", worktreePath, branch];
+  try {
+    await runGit(repoPath, ["rev-parse", "--verify", "--quiet", `${branch}^{commit}`]);
+  } catch (error) {
+    if (error instanceof GitError) {
+      createArgs = ["worktree", "add", "-b", branch, worktreePath];
+    } else {
+      throw error;
+    }
+  }
+  await runGit(repoPath, createArgs);
   const worktrees = await listWorktrees(repoPath);
-  const created = worktrees.find((wt) => wt.path === path9);
+  const normalizedRequested = normalizeWorktreePath(worktreePath);
+  const created = worktrees.find((wt) => normalizeWorktreePath(wt.path) === normalizedRequested);
   if (!created) {
     throw new Error("Failed to find created worktree");
   }
@@ -10072,13 +10540,41 @@ var init_worktree = __esm({
 });
 
 // packages/server/src/commands/worktree.ts
-import { z as z13 } from "zod";
+import path9 from "node:path";
+import { z as z14 } from "zod";
+async function findRelatedWorkspaceIds(ctx, workspacePath) {
+  const targetCommonDir = await getGitCommonDirPath(workspacePath);
+  const relatedWorkspaceIds = await Promise.all(
+    ctx.workspaceMgr.list().map(async (workspace) => {
+      try {
+        const commonDir = await getGitCommonDirPath(workspace.path);
+        return commonDir === targetCommonDir ? workspace.id : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return relatedWorkspaceIds.filter((workspaceId) => Boolean(workspaceId));
+}
+function emitWorktreeChangedForWorkspaceIds(ctx, workspaceIds) {
+  for (const workspaceId of workspaceIds) {
+    if (!ctx.workspaceMgr.get(workspaceId)) {
+      continue;
+    }
+    emitGitStateChanged(ctx, workspaceId, { worktreeChanged: true });
+  }
+}
+function isWorkspaceOpenForPath(ctx, workspacePath) {
+  const targetPath = path9.resolve(workspacePath);
+  return ctx.workspaceMgr.list().some((openWorkspace) => path9.resolve(openWorkspace.path) === targetPath);
+}
 var init_worktree2 = __esm({
   "packages/server/src/commands/worktree.ts"() {
     "use strict";
     init_worktree();
     init_dispatch();
-    registerCommand("worktree.list", z13.object({ workspaceId: z13.string() }), async (args, ctx) => {
+    init_git_events();
+    registerCommand("worktree.list", z14.object({ workspaceId: z14.string() }), async (args, ctx) => {
       const workspace = ctx.workspaceMgr.get(args.workspaceId);
       if (!workspace) {
         throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
@@ -10087,7 +10583,7 @@ var init_worktree2 = __esm({
     });
     registerCommand(
       "worktree.status",
-      z13.object({ workspaceId: z13.string(), worktreePath: z13.string() }),
+      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10099,10 +10595,10 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.diff",
-      z13.object({
-        workspaceId: z13.string(),
-        worktreePath: z13.string(),
-        staged: z13.boolean().optional().default(false)
+      z14.object({
+        workspaceId: z14.string(),
+        worktreePath: z14.string(),
+        staged: z14.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
@@ -10115,7 +10611,7 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.tree",
-      z13.object({ workspaceId: z13.string(), worktreePath: z13.string() }),
+      z14.object({ workspaceId: z14.string(), worktreePath: z14.string() }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
@@ -10127,33 +10623,44 @@ var init_worktree2 = __esm({
     );
     registerCommand(
       "worktree.create",
-      z13.object({
-        workspaceId: z13.string(),
-        branch: z13.string(),
-        path: z13.string()
+      z14.object({
+        workspaceId: z14.string(),
+        branch: z14.string(),
+        path: z14.string()
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
-        return { worktree: await createWorktree(workspace.path, args.branch, args.path) };
+        const relatedWorkspaceIds = await findRelatedWorkspaceIds(ctx, workspace.path);
+        const worktree = await createWorktree(workspace.path, args.branch, args.path);
+        emitWorktreeChangedForWorkspaceIds(ctx, relatedWorkspaceIds);
+        return { worktree };
       }
     );
     registerCommand(
       "worktree.remove",
-      z13.object({
-        workspaceId: z13.string(),
-        worktreePath: z13.string(),
-        force: z13.boolean().optional().default(false)
+      z14.object({
+        workspaceId: z14.string(),
+        worktreePath: z14.string(),
+        force: z14.boolean().optional().default(false)
       }),
       async (args, ctx) => {
         const workspace = ctx.workspaceMgr.get(args.workspaceId);
         if (!workspace) {
           throw { code: "workspace_not_found", message: `Workspace not found: ${args.workspaceId}` };
         }
+        const relatedWorkspaceIds = await findRelatedWorkspaceIds(ctx, workspace.path);
         const worktreePath = await resolveWorktreePath(workspace.path, args.worktreePath);
+        if (isWorkspaceOpenForPath(ctx, worktreePath)) {
+          throw {
+            code: "worktree_in_use",
+            message: `Cannot remove an open worktree workspace: ${worktreePath}`
+          };
+        }
         await removeWorktree(workspace.path, worktreePath, args.force);
+        emitWorktreeChangedForWorkspaceIds(ctx, relatedWorkspaceIds);
         return {};
       }
     );
@@ -10161,7 +10668,7 @@ var init_worktree2 = __esm({
 });
 
 // packages/server/src/commands/fencing.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function createMockFencingRequest() {
   return {
     ip: "127.0.0.1",
@@ -10174,9 +10681,9 @@ var init_fencing2 = __esm({
     init_dispatch();
     registerCommand(
       "fencing.request",
-      z14.object({
-        workspaceId: z14.string(),
-        tabId: z14.string()
+      z15.object({
+        workspaceId: z15.string(),
+        tabId: z15.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.requestControl(
@@ -10189,7 +10696,7 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.heartbeat",
-      z14.object({ workspaceId: z14.string() }),
+      z15.object({ workspaceId: z15.string() }),
       async (args, ctx, clientId) => {
         const success = ctx.fencingMgr.heartbeat(args.workspaceId, clientId);
         return { success };
@@ -10197,13 +10704,13 @@ var init_fencing2 = __esm({
     );
     registerCommand(
       "fencing.release",
-      z14.object({ workspaceId: z14.string() }),
+      z15.object({ workspaceId: z15.string() }),
       async (args, ctx, clientId) => {
         ctx.fencingMgr.release(args.workspaceId, clientId);
         return {};
       }
     );
-    registerCommand("fencing.status", z14.object({ workspaceId: z14.string() }), async (args, ctx) => {
+    registerCommand("fencing.status", z15.object({ workspaceId: z15.string() }), async (args, ctx) => {
       const controller = ctx.fencingMgr.getController(args.workspaceId);
       const isUnresponsive = ctx.fencingMgr.isControllerUnresponsive(args.workspaceId);
       return {
@@ -10214,9 +10721,9 @@ var init_fencing2 = __esm({
     });
     registerCommand(
       "fencing.takeover",
-      z14.object({
-        workspaceId: z14.string(),
-        tabId: z14.string()
+      z15.object({
+        workspaceId: z15.string(),
+        tabId: z15.string()
       }),
       async (args, ctx, clientId) => {
         return ctx.fencingMgr.forceTakeover(
@@ -10235,6 +10742,7 @@ var init_commands = __esm({
   "packages/server/src/commands/index.ts"() {
     "use strict";
     init_workspace();
+    init_workspace_activity();
     init_session();
     init_terminal();
     init_file();
@@ -10248,32 +10756,6 @@ var init_commands = __esm({
 });
 
 // packages/server/src/server.ts
-function createCodexConfigAuditApi() {
-  return {
-    audit: () => ({ codex: auditCodexConfigToml() }),
-    cleanup: (removeIds) => {
-      const audit = auditCodexConfigToml();
-      return cleanupCodexConfigToml(audit.configPath, { removeIds });
-    }
-  };
-}
-async function logCodexConfigFindings(auditApi, logger) {
-  try {
-    const audit = auditApi.audit();
-    for (const finding of audit.codex.findings) {
-      logger.warn(
-        {
-          configPath: audit.codex.configPath,
-          startLine: finding.startLine,
-          findingMessage: finding.message
-        },
-        "Codex config finding"
-      );
-    }
-  } catch (err) {
-    logger.warn({ err }, "Codex config audit failed (non-fatal)");
-  }
-}
 async function createServer(configOverrides) {
   const config = parseServerConfig(configOverrides);
   ensureDataDir(config);
@@ -10281,14 +10763,45 @@ async function createServer(configOverrides) {
   const eventBus = new EventBus();
   const fencingMgr = new FencingManager();
   const wsHub = new WsHub({ eventBus, commandContext: null, config, fencingMgr });
+  let workspaceMgr;
+  let commandContext;
   const terminalMgr = new TerminalManager({
     ptyHost: createPtyHost(),
     eventBus,
     db: createTerminalDatabase(db)
   });
+  const settingsRepo = new SettingsRepo(db);
+  const autoFetch = new AutoFetchScheduler({
+    workspaceMgr: { get: (workspaceId) => workspaceMgr.get(workspaceId) },
+    eventBus,
+    settingsRepo,
+    runFetch: async (workspaceId) => {
+      if (!workspaceMgr.get(workspaceId)) {
+        return;
+      }
+      const result = await dispatch(
+        {
+          kind: "command",
+          id: `auto-fetch:${workspaceId}:${Date.now()}`,
+          op: "git.fetch",
+          args: {
+            workspaceId,
+            background: true
+          }
+        },
+        commandContext
+      );
+      if (!result.ok) {
+        throw new Error(result.error?.message ?? "Background fetch failed");
+      }
+      const data = result.data;
+      if (data.success === false) {
+        throw new Error(data.message ?? "Background fetch failed");
+      }
+    }
+  });
   const sessionDb = createSessionDatabase(db);
   const providerConfigRepo = new ProviderConfigRepo(db);
-  const settingsRepo = new SettingsRepo(db);
   const sessionMgr = new SessionManager({
     terminalMgr,
     eventBus,
@@ -10298,10 +10811,11 @@ async function createServer(configOverrides) {
     providerConfigRepo
   });
   let supervisorMgr;
-  const workspaceMgr = new WorkspaceManager({
+  workspaceMgr = new WorkspaceManager({
     db,
     eventBus,
     broadcaster: wsHub,
+    autoFetch,
     teardown: async (workspaceId) => {
       await supervisorMgr?.deleteForWorkspace(workspaceId);
       await sessionMgr.stopForWorkspace(workspaceId);
@@ -10312,9 +10826,9 @@ async function createServer(configOverrides) {
       (err) => console.warn("[uploads] cascade cleanup failed", { wsId: workspaceId, err })
     )
   });
+  workspaceMgr.hydrateWatchers();
   const authSessionRepo = new AuthSessionRepo(db);
   const authLoginBlockRepo = new AuthLoginBlockRepo(db);
-  const codexConfigAudit = createCodexConfigAuditApi();
   const app = await buildFastifyApp({
     wsHub,
     db,
@@ -10335,7 +10849,6 @@ async function createServer(configOverrides) {
     }
   });
   wsHub.setLogger(app.log);
-  await logCodexConfigFindings(codexConfigAudit, app.log);
   const supervisorRepo = new SupervisorRepo(db);
   const cycleRepo = new SupervisorCycleRepo(db);
   supervisorMgr = new SupervisorManager({
@@ -10353,12 +10866,15 @@ async function createServer(configOverrides) {
   });
   await sessionMgr.hydrate();
   await supervisorMgr.hydrate();
-  const providerRuntimeDeps = {};
+  const providerMockOverrides = createE2EProviderMockOverrides();
+  const providerRuntimeDeps = providerMockOverrides ? {
+    commandExists: providerMockOverrides.commandExists
+  } : {};
   const providerInstallMgr = new ProviderInstallManager(providerRegistry, {
     ...providerRuntimeDeps,
-    runCommand: runCommandAsString
+    runCommand: providerMockOverrides?.runCommand ?? runCommandAsString
   });
-  const commandContext = {
+  commandContext = {
     workspaceMgr,
     sessionMgr,
     terminalMgr,
@@ -10368,9 +10884,9 @@ async function createServer(configOverrides) {
     providerRegistry,
     fencingMgr,
     supervisorMgr,
+    autoFetch,
     providerRuntimeDeps,
-    providerInstallMgr,
-    codexConfigAudit
+    providerInstallMgr
   };
   wsHub.setCommandContext(commandContext);
   await app.listen({
@@ -10401,6 +10917,7 @@ async function createServer(configOverrides) {
     stopped = true;
     clearTimeout(gcTimer);
     await app.close();
+    autoFetch.stop();
     supervisorMgr.stop();
     terminalMgr.shutdown();
     wsHub.destroy();
@@ -10522,9 +11039,10 @@ var init_server = __esm({
     init_src2();
     init_app();
     init_event_bus();
-    init_codex_config_audit();
     init_config();
+    init_auto_fetch();
     init_command_runner();
+    init_e2e_provider_mock();
     init_install_manager();
     init_manager();
     init_db();
@@ -10541,6 +11059,7 @@ var init_server = __esm({
     init_cleanup();
     init_constants();
     init_manager4();
+    init_dispatch();
     init_fencing();
     init_hub();
     init_commands();
@@ -10694,8 +11213,8 @@ var init_workspace_repo = __esm({
       /**
        * Finds a workspace by path
        */
-      findByPath(path9) {
-        const row = this.db.prepare("SELECT * FROM workspaces WHERE path = ?").get(path9);
+      findByPath(path10) {
+        const row = this.db.prepare("SELECT * FROM workspaces WHERE path = ?").get(path10);
         return row ? this.rowToWorkspace(row) : void 0;
       }
       /**
@@ -10840,12 +11359,12 @@ function getCliConfigPath() {
   return join(homedir(), ".coder-studio", "config.json");
 }
 function readCliConfig() {
-  const path9 = getCliConfigPath();
-  if (!existsSync(path9)) {
+  const path10 = getCliConfigPath();
+  if (!existsSync(path10)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync(path9, "utf-8"));
+    const parsed = JSON.parse(readFileSync(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;
     }