farming-code 2.2.30 → 2.2.32

package/backend/server.js

@@ -1,3225 +0,0 @@
-const express = require('express');
-const WebSocket = require('ws');
-const http = require('http');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const crypto = require('crypto');
-const { execFile } = require('child_process');
-const { promisify } = require('util');
-const { URLSearchParams, pathToFileURL } = require('url');
-const AgentManager = require('./agent-manager');
-const { runtimeKind } = require('./agent-runtime-binding');
-const ConfigManager = require('./config-manager');
-const ThemeManager = require('./theme-manager');
-const TokenAuth = require('./auth');
-const { getLocalIPs, getPrimaryLocalIP } = require('./network');
-const { listAvailableAgents, resolveCompatibleCodexExecutable } = require('./executable-discovery');
-const { readClaudeSettingsSummary } = require('./claude-settings');
-const { listCodexModelOptions } = require('./codex-models');
-const { listCodexSessions } = require('./codex-session-history');
-const {
-  buildAgentSessionResumeCommand,
-  findAgentSession,
-  isSafeSessionId,
-  listAgentSessions,
-  normalizeProvider,
-  paginateAgentSessions,
-  resolveCodexResumeModelProvider,
-  searchAgentSessions,
-} = require('./agent-session-history');
-const {
-  findActiveAgentClaimingSession,
-  mainPageAgentSessionKey,
-  mainPageAgentSessionFromKey,
-  mainPageAgentSessionsToAutoResume,
-  resumedAgentSource,
-} = require('./main-page-session');
-const { discoverAgentWorkspaces } = require('./workspace-discovery');
-const { inspectGitWorktree } = require('./git-worktree-info');
-const { createWorkspaceDirectoryRouter } = require('./workspace-directory');
-const { createControlRouter } = require('./control-api');
-const { WorkspaceFileService, WorkspaceFileError } = require('./workspace-file-service');
-const { createWorkspaceFileRouter, resolveWorkspaceRoot } = require('./workspace-file-router');
-const { WorkspaceRootRegistry, rootIdForPath } = require('./workspace-root-registry');
-const {
-  BrowserResourceManager,
-  createBrowserRouter,
-} = require('../extensions/browser/backend');
-const { UsageMonitor } = require('./usage-monitor');
-const { CodexContextWindowReader } = require('./codex-context-window');
-const { AsyncCache } = require('./async-cache');
-const { getMainAgentSkillsCatalog } = require('./main-agent-skills');
-const { discoverAgentExtensions, discoverSlashCommands } = require('./slash-command-discovery');
-const { FarmingUpdateService } = require('./update-service');
-const { inputPartsFromMessage } = require('./input-parts');
-const { cleanupTerminalRuntime } = require('./terminal-runtime-cleanup');
-const { QrShareTicketStore, SHARE_TICKET_TTL_MS } = require('./qr-share-tickets');
-const { ReviewStateStore } = require('./review-state-store');
-const { createReviewStateRouter } = require('./review-state-router');
-const { ReviewDiffService } = require('./review-diff-service');
-const { createReviewDiffRouter } = require('./review-diff-router');
-const { ReviewSessionStore } = require('./review-session-store');
-const { ReviewSessionService } = require('./review-session-service');
-const { createReviewSessionRouter } = require('./review-session-router');
-const {
-  applyIndexHtmlAppearance,
-  normalizeBasePath,
-  routePath,
-  rewriteIndexHtmlForBasePath,
-  appendIndexHtmlAssetToken,
-} = require('./index-html');
-const { decodeAcpTranscriptMedia } = require('./acp-transcript');
-const {
-  coalesceSessionStream,
-  deliverSessionStreamToClients,
-  shouldBroadcastSessionStreamImmediately,
-} = require('./session-stream-protocol');
-const {
-  MIN_PROTOCOL_VERSION,
-  PROTOCOL_VERSION,
-  protocolCompatible,
-  sanitizeAgentUpdatePatch,
-  validateClientMessage,
-} = require('../shared/browser-protocol');
-
-const BASE_PATH = normalizeBasePath(process.env.FARMING_BASE_PATH || '/');
-const PORT = process.env.PORT || 3000;
-const tokenAuth = new TokenAuth({ basePath: BASE_PATH || '/' });
-const authEnabled = tokenAuth.isEnabled();
-const WS_PATH = routePath(BASE_PATH, '/ws');
-const encodeCookieToken = TokenAuth.encodeCookieToken;
-const DEFAULT_TRANSCRIPT_MAX_TURNS = 240;
-const MAX_TRANSCRIPT_TURNS = 1000;
-const INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS = 3_000;
-const execFileAsync = promisify(execFile);
-
-const app = express();
-const server = http.createServer(app);
-const wss = new WebSocket.Server({ server });
-
-const configManager = new ConfigManager();
-configManager.init();
-
-function resolveCliBinDir() {
-  if (process.env.FARMING_CLI_BIN_DIR) {
-    return process.env.FARMING_CLI_BIN_DIR;
-  }
-  if (process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1') {
-    return path.dirname(process.execPath);
-  }
-  return path.join(__dirname, '..', 'bin');
-}
-
-const agentManager = new AgentManager(configManager, {
-  controlUrl: `http://127.0.0.1:${PORT}${BASE_PATH}`,
-  tokenFile: tokenAuth.getTokenFile(),
-  authDisabled: !authEnabled,
-  cliBinDir: resolveCliBinDir(),
-});
-
-async function requireAgentRecoveryForHttp(res) {
-  try {
-    await agentManager.whenRecovered();
-    return true;
-  } catch (error) {
-    res.status(503).json({
-      error: error?.message || 'Agent lifecycle recovery is unavailable',
-      retryable: true,
-    });
-    return false;
-  }
-}
-
-const themeManager = new ThemeManager({ configDir: configManager.farmingDir });
-const workspaceFileService = new WorkspaceFileService();
-const workspaceRootRegistry = new WorkspaceRootRegistry(agentManager);
-const browserResourceManager = new BrowserResourceManager({
-  configDir: configManager.farmingDir,
-  isEnabled: () => configManager.getSettings().browserExtensionEnabled === true,
-  getBrowserSettings: () => configManager.getSettings(),
-});
-const browserRuntimeRecoveryPromise = browserResourceManager.init().catch(error => {
-  console.warn('Failed to recover Browser runtimes:', error?.message || error);
-  return null;
-});
-const updateService = new FarmingUpdateService({
-  rootDir: path.join(__dirname, '..'),
-  configDir: configManager.farmingDir,
-  platform: process.platform,
-  arch: process.arch,
-  packagedRuntime: Boolean(process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1'),
-});
-const usageMonitor = new UsageMonitor({
-  agentManager,
-  configDir: configManager.farmingDir,
-  getProviderHomes: configuredProviderHomes,
-});
-const codexContextWindowReader = new CodexContextWindowReader();
-const usageSummaryCache = new AsyncCache(() => usageMonitor.getUsageSummary(), {
-  ttlMs: 15_000,
-  staleMs: 2 * 60_000,
-});
-const codexModelOptionsCache = new AsyncCache(() => listCodexModelOptions(), {
-  ttlMs: 5 * 60_000,
-  staleMs: 5 * 60_000,
-});
-function configuredProviderHomes() {
-  const settings = configManager.getSettings();
-  const agentHomes = settings.agentHomes && typeof settings.agentHomes === 'object' ? settings.agentHomes : {};
-  const result = {};
-  for (const [provider, homes] of Object.entries(agentHomes)) {
-    if (!Array.isArray(homes)) continue;
-    result[provider] = homes.map(home => ({
-      id: String(home.id || 'default'),
-      path: configManager.expandWorkspacePath(String(home.path || '')),
-    })).filter(home => home.id && home.path);
-  }
-  return result;
-}
-
-const agentSessionsCache = new AsyncCache(() => {
-  return listAgentSessions({
-    limit: 5000,
-    providerLimit: 5000,
-    scanLimit: 5000,
-    providerHomes: configuredProviderHomes(),
-  });
-}, {
-  ttlMs: 30_000,
-  staleMs: 5 * 60_000,
-});
-
-function withSearchTimeout(promise, timeoutMs) {
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => {
-      const error = new Error('Agent search timed out');
-      error.code = 'ETIMEDOUT';
-      reject(error);
-    }, timeoutMs);
-  });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-
-const qrShareTickets = new QrShareTicketStore({ ttlMs: SHARE_TICKET_TTL_MS });
-const reviewStateStore = new ReviewStateStore(configManager.farmingDir, {
-  seedReviews: {
-    'review-fixture-553987': {
-      patchsets: {
-        'Patchset 20': { reviewedPaths: ['clis/dataflow.py', 'clis/fetch_instance_log.py'], revision: 0 },
-        'Patchset 19': { reviewedPaths: ['clis/fetch_instance_log.py'], revision: 0 },
-      },
-    },
-  },
-});
-const reviewDiffService = new ReviewDiffService(agentManager, workspaceFileService);
-const reviewSessionStore = new ReviewSessionStore(configManager.farmingDir);
-const reviewSessionService = new ReviewSessionService(workspaceFileService, reviewSessionStore, reviewStateStore, {
-  resolveAgentRoot: agentId => agentManager.getAgentWorkspaceRoot(agentId),
-  resolveAcpReviewChanges: (agentId, itemIds) => agentManager.getAcpReviewChanges(agentId, itemIds),
-});
-const workspaceDiscoveryCache = new AsyncCache((key) => {
-  const request = JSON.parse(key);
-  return discoverAgentWorkspaces({
-    limit: request.limit,
-    agent: request.agent,
-  });
-}, {
-  ttlMs: 30_000,
-  staleMs: 2 * 60_000,
-});
-
-const frontendDir = path.join(__dirname, '../frontend');
-const crtFrontendDir = path.join(frontendDir, 'skins', 'crt');
-const distDir = path.join(__dirname, '../dist');
-const staticAppDir = fs.existsSync(distDir) ? distDir : frontendDir;
-const xtermBrowserEntryPath = path.join(__dirname, '..', 'node_modules', '@xterm', 'xterm', 'lib', 'xterm.js');
-const xtermFitEntryPath = path.join(__dirname, '..', 'node_modules', '@xterm', 'addon-fit', 'lib', 'addon-fit.js');
-const xtermWebglEntryPath = path.join(__dirname, '..', 'node_modules', '@xterm', 'addon-webgl', 'lib', 'addon-webgl.js');
-const xtermCssPath = path.join(__dirname, '..', 'node_modules', '@xterm', 'xterm', 'css', 'xterm.css');
-const materialIconDir = path.join(__dirname, '..', 'node_modules', 'material-icon-theme', 'icons');
-
-function getAvailableAgentsForRequest() {
-  if (process.env.FARMING_E2E_FAKE_EXECUTABLES === '1') {
-    return [
-      {
-        name: 'codex',
-        command: 'codex',
-        description: 'Codex CLI - OpenAI coding assistant',
-        category: 'coding',
-        supported: true,
-        interactive: true,
-      },
-      {
-        name: 'claude',
-        command: 'claude',
-        description: 'Claude CLI - Anthropic assistant',
-        category: 'coding',
-        supported: true,
-        interactive: true,
-      },
-      {
-        name: 'opencode',
-        command: 'opencode',
-        description: 'OpenCode - AI coding assistant',
-        category: 'coding',
-        supported: true,
-        interactive: true,
-      },
-      {
-        name: 'qoder',
-        command: 'qodercli',
-        description: 'Qoder - AI coding assistant',
-        category: 'coding',
-        supported: true,
-        interactive: true,
-      },
-      {
-        name: 'bash',
-        command: 'bash',
-        description: 'Shell session',
-        category: 'shell',
-        supported: true,
-        interactive: true,
-      },
-      {
-        name: 'zsh',
-        command: 'zsh',
-        description: 'Z shell',
-        category: 'shell',
-        supported: true,
-        interactive: true,
-      },
-    ];
-  }
-
-  const shellEnv = agentManager.resolveAgentShellEnv('', { maxAgeMs: INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS });
-  const pathEnv = typeof shellEnv?.PATH === 'string' && shellEnv.PATH.trim()
-    ? shellEnv.PATH
-    : (process.env.PATH || '');
-  return listAvailableAgents(pathEnv);
-}
-
-function normalizeWorkspaceCompletionInput(value) {
-  const raw = typeof value === 'string' ? value.trim() : '';
-  if (!raw) {
-    return { raw: '', parent: os.homedir(), prefix: '', displayParent: '~', explicitDirectory: false };
-  }
-
-  const home = os.homedir();
-  const expanded = raw === '~' ? home : raw.startsWith('~/') ? path.join(home, raw.slice(2)) : raw;
-  const explicitDirectory = raw.endsWith(path.sep) || raw === '~';
-  const parent = explicitDirectory ? expanded : path.dirname(expanded);
-  const prefix = explicitDirectory ? '' : path.basename(expanded);
-  const trimTrailingSeparator = (input) => {
-    let next = input;
-    while (next.length > 1 && next.endsWith(path.sep)) next = next.slice(0, -1);
-    return next;
-  };
-  const displayParent = explicitDirectory
-    ? trimTrailingSeparator(raw)
-    : trimTrailingSeparator(raw.slice(0, raw.length - prefix.length));
-
-  return {
-    raw,
-    parent: parent || path.sep,
-    prefix,
-    displayParent: displayParent || (path.isAbsolute(raw) ? path.sep : ''),
-    explicitDirectory,
-  };
-}
-
-async function listWorkspacePathCompletions(partialPath, limit = 12) {
-  const query = normalizeWorkspaceCompletionInput(partialPath);
-  const entries = await fs.promises.readdir(query.parent, { withFileTypes: true });
-  const normalizedPrefix = query.prefix.toLowerCase();
-  const maxResults = Math.max(1, Math.min(Number(limit) || 12, 100));
-
-  return entries
-    .filter(entry => entry.isDirectory())
-    .filter(entry => normalizedPrefix.startsWith('.') || !entry.name.startsWith('.'))
-    .filter(entry => !normalizedPrefix || entry.name.toLowerCase().startsWith(normalizedPrefix))
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .slice(0, maxResults)
-    .map(entry => {
-      const fullPath = path.join(query.parent, entry.name);
-      const displayPath = query.raw.startsWith('~')
-        ? path.join(query.displayParent || '~', entry.name)
-        : fullPath;
-      return {
-        name: entry.name,
-        path: `${displayPath}${path.sep}`,
-      };
-    });
-}
-
-// iOS can fetch installed-web-app metadata outside the authenticated page
-// request, without preserving its cookie or token query. These files contain
-// only public product artwork and must remain available to that fetcher.
-const publicProductAssetsDir = path.join(staticAppDir, 'farming-2');
-app.use(routePath(BASE_PATH, '/farming-2'), express.static(publicProductAssetsDir, { index: false }));
-
-const sendPublicProductAsset = (filename) => (_req, res) => {
-  res.sendFile(path.join(publicProductAssetsDir, filename));
-};
-
-app.get(['/favicon.ico', routePath(BASE_PATH, '/favicon.ico')], sendPublicProductAsset('favicon-v2.ico'));
-app.get([
-  '/apple-touch-icon.png',
-  '/apple-touch-icon-precomposed.png',
-  '/apple-touch-icon-180x180.png',
-  routePath(BASE_PATH, '/apple-touch-icon.png'),
-  routePath(BASE_PATH, '/apple-touch-icon-precomposed.png'),
-  routePath(BASE_PATH, '/apple-touch-icon-180x180.png'),
-], sendPublicProductAsset('app-icon-v2-180.png'));
-
-app.get(routePath(BASE_PATH, '/j/:code'), (req, res) => {
-  if (req.method === 'HEAD') {
-    res.status(204).end();
-    return;
-  }
-
-  const ticket = qrShareTickets.consume(req.params.code);
-  if (!ticket || (authEnabled && !tokenAuth.verify(ticket.token))) {
-    res.status(410).send('Farming share link expired.');
-    return;
-  }
-
-  if (authEnabled) {
-    res.setHeader(
-      'Set-Cookie',
-      `farming_token=${encodeCookieToken(ticket.token)}; Path=/; HttpOnly; SameSite=Lax`,
-    );
-  }
-  res.redirect(302, entryPathWithQuery(ticket.targetQuery));
-});
-
-// Token authentication middleware (before static files)
-app.use(tokenAuth.middleware());
-
-// Auth status endpoint (allowed without authentication via middleware)
-app.get(routePath(BASE_PATH, '/api/auth/status'), (req, res) => {
-  res.json({ authRequired: authEnabled });
-});
-
-function absoluteClientUrl(req, urlPath) {
-  const forwardedProto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim();
-  const protocol = forwardedProto || req.protocol || 'http';
-  const forwardedHost = String(req.headers['x-forwarded-host'] || '').split(',')[0].trim();
-  const host = forwardedHost || req.headers.host || `127.0.0.1:${PORT}`;
-  return `${protocol}://${host}${urlPath}`;
-}
-
-function shareTargetPositiveInteger(value) {
-  const number = Number(value);
-  return Number.isInteger(number) && number > 0 ? String(number) : '';
-}
-
-function shareTargetString(value, maxLength) {
-  const string = String(value || '').trim();
-  if (!string || string.length > maxLength || string.includes('\0')) return '';
-  return string;
-}
-
-function shareTargetQueryFromBody(body) {
-  const target = body && typeof body === 'object' ? body.target : null;
-  if (!target || typeof target !== 'object') return '';
-
-  const kind = target.kind === 'file' ? 'file' : target.kind === 'folder' ? 'folder' : target.kind === 'agent' ? 'agent' : '';
-  const agentId = shareTargetString(target.agentId, 160);
-  const absolutePath = shareTargetString(target.absolutePath, 2048);
-  const projectLabel = shareTargetString(target.projectLabel, 160);
-  const readingAnchor = shareTargetString(target.readingAnchor, 1800);
-  if (!kind || kind === 'agent' && !agentId || kind !== 'agent' && !absolutePath && !agentId && !projectLabel) return '';
-
-  const params = new URLSearchParams();
-  params.set('ftarget', kind);
-  if (agentId) params.set('agent', agentId);
-  if (kind === 'agent' && readingAnchor && /^[A-Za-z0-9_-]+$/.test(readingAnchor)) params.set('fra', readingAnchor);
-  if (absolutePath) params.set('path', absolutePath);
-  if (projectLabel) params.set('project', projectLabel);
-
-  if (kind === 'folder') {
-    const folderPath = shareTargetString(target.folderPath, 2048);
-    if (!absolutePath && !folderPath) return '';
-    if (folderPath) params.set('folder', folderPath);
-  } else if (kind === 'file') {
-    const filePath = shareTargetString(target.filePath, 2048);
-    if (!absolutePath && !filePath) return '';
-    if (filePath) params.set('file', filePath);
-    if (target.view === 'diff') params.set('view', 'diff');
-    const line = shareTargetPositiveInteger(target.lineNumber);
-    const column = shareTargetPositiveInteger(target.column);
-    const endColumn = shareTargetPositiveInteger(target.endColumn);
-    if (line) params.set('line', line);
-    if (column) params.set('column', column);
-    if (endColumn) params.set('endColumn', endColumn);
-  }
-
-  if (absolutePath) {
-    const absoluteParams = new URLSearchParams(params);
-    absoluteParams.delete('agent');
-    absoluteParams.delete(kind === 'folder' ? 'folder' : 'file');
-    if (absoluteParams.toString().length <= 1800) return absoluteParams.toString();
-    params.delete('path');
-  }
-
-  return params.toString();
-}
-
-function entryPathWithQuery(query = '', options = {}) {
-  const entryPath = BASE_PATH || '/';
-  const params = new URLSearchParams(query || '');
-  if (options.includeToken && authEnabled) {
-    params.set('token', tokenAuth.getToken());
-  }
-  const queryString = params.toString();
-  return queryString ? `${entryPath}?${queryString}` : entryPath;
-}
-
-function entryPathWithToken(targetQuery = '') {
-  return entryPathWithQuery(targetQuery, { includeToken: true });
-}
-
-app.post(routePath(BASE_PATH, '/api/share/qr-ticket'), express.json({ limit: '8kb' }), (req, res) => {
-  try {
-    const targetQuery = shareTargetQueryFromBody(req.body);
-    const ticket = qrShareTickets.create(authEnabled ? tokenAuth.getToken() : '', { targetQuery });
-    const shortPath = routePath(BASE_PATH, `/j/${ticket.code}`);
-    const longPath = entryPathWithToken(ticket.targetQuery);
-    res.json({
-      code: ticket.code,
-      expiresAt: ticket.expiresAt,
-      ttlMs: SHARE_TICKET_TTL_MS,
-      shortPath,
-      shortUrl: absoluteClientUrl(req, shortPath),
-      longUrl: absoluteClientUrl(req, longPath),
-      tokenLabel: authEnabled ? tokenAuth.getToken() : '',
-    });
-  } catch (error) {
-    res.status(500).json({ error: error.message || 'Failed to create share ticket' });
-  }
-});
-
-app.delete(routePath(BASE_PATH, '/api/share/qr-ticket/:code'), (req, res) => {
-  res.json({ revoked: qrShareTickets.revoke(req.params.code) });
-});
-
-// Terminal assets remain available to the standalone CRT skin when React is served from dist.
-app.use(routePath(BASE_PATH, '/vendor'), express.static(path.join(frontendDir, 'vendor')));
-app.get(routePath(BASE_PATH, '/vendor/xterm/xterm.js'), (_req, res) => {
-  res.sendFile(xtermBrowserEntryPath);
-});
-app.get(routePath(BASE_PATH, '/vendor/xterm/addon-fit.js'), (_req, res) => {
-  res.sendFile(xtermFitEntryPath);
-});
-app.get(routePath(BASE_PATH, '/vendor/xterm/addon-webgl.js'), (_req, res) => {
-  res.sendFile(xtermWebglEntryPath);
-});
-app.get(routePath(BASE_PATH, '/vendor/xterm/xterm.css'), (_req, res) => {
-  res.sendFile(xtermCssPath);
-});
-app.use(routePath(BASE_PATH, '/vendor/material-icons'), express.static(materialIconDir));
-app.get(routePath(BASE_PATH, '/vendor/material-icons/:iconId.svg'), (req, res) => {
-  const fallbackIcon = String(req.params.iconId || '').startsWith('folder-') ? 'folder.svg' : 'file.svg';
-  res.sendFile(path.join(materialIconDir, fallbackIcon));
-});
-if (BASE_PATH) {
-  app.use('/assets', express.static(path.join(staticAppDir, 'assets'), { index: false }));
-  app.use('/farming-2', express.static(path.join(staticAppDir, 'farming-2'), { index: false }));
-}
-const crtEntryPath = routePath(BASE_PATH, '/crt');
-app.get(crtEntryPath, (req, res) => {
-  if (req.path.endsWith('/')) {
-    res.setHeader('Cache-Control', 'no-cache');
-    res.sendFile(path.join(crtFrontendDir, 'index.html'));
-    return;
-  }
-  const requestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-  res.redirect(308, `${crtEntryPath}/${requestUrl.search}`);
-});
-app.use(`${crtEntryPath}/shared`, express.static(frontendDir, { index: false }));
-app.get(`${crtEntryPath}/crt-markdown-renderer.js`, (_req, res) => {
-  res.sendFile(path.join(distDir, 'crt-markdown-renderer.js'));
-});
-app.get(`${crtEntryPath}/crt-markdown-renderer.css`, (_req, res) => {
-  res.sendFile(path.join(distDir, 'crt-markdown-renderer.css'));
-});
-app.use(`${crtEntryPath}/crt-markdown-assets`, express.static(path.join(distDir, 'crt-markdown-assets'), { index: false }));
-app.get(`${crtEntryPath}/crt-mermaid-renderer.js`, (_req, res) => {
-  res.sendFile(path.join(distDir, 'crt-mermaid-renderer.js'));
-});
-app.use(`${crtEntryPath}/`, express.static(crtFrontendDir, { index: false }));
-app.use(BASE_PATH || '/', express.static(staticAppDir, { index: false }));
-
-app.use(routePath(BASE_PATH, '/api/files'), createWorkspaceFileRouter(agentManager, workspaceFileService, {
-  rootRegistry: workspaceRootRegistry,
-}));
-app.use(routePath(BASE_PATH, '/api/browsers'), createBrowserRouter(browserResourceManager, workspaceRootRegistry));
-
-app.use(routePath(BASE_PATH, '/api/review-sessions'), createReviewSessionRouter(reviewSessionService));
-app.use(routePath(BASE_PATH, '/api/reviews'), createReviewDiffRouter(reviewDiffService, reviewSessionService));
-app.use(routePath(BASE_PATH, '/api/reviews'), createReviewStateRouter(reviewStateStore));
-
-if (process.env.NODE_ENV === 'test' && process.env.FARMING_E2E_FAKE_EXECUTABLES === '1') {
-  app.post(routePath(BASE_PATH, '/api/control/e2e/close-websockets'), express.json(), (_req, res) => {
-    const clients = [...wss.clients].filter(client => client.readyState === WebSocket.OPEN);
-    res.json({ closing: clients.length, code: 1013 });
-    setImmediate(() => {
-      clients.forEach(client => client.close(1013, 'terminal stream backpressure test'));
-    });
-  });
-}
-
-app.use(routePath(BASE_PATH, '/api/control'), createControlRouter(agentManager, {
-  notifyUpdate: broadcastState,
-  allowConcurrentTestControl: process.env.NODE_ENV === 'test'
-    && process.env.FARMING_E2E_FAKE_EXECUTABLES === '1',
-}));
-
-app.get([
-  BASE_PATH || '/',
-  `${BASE_PATH || ''}/`,
-  routePath(BASE_PATH, '/code'),
-  routePath(BASE_PATH, '/code/'),
-  routePath(BASE_PATH, '/error-preview'),
-  routePath(BASE_PATH, '/review'),
-].filter(Boolean), (req, res) => {
-  const indexPath = path.join(staticAppDir, 'index.html');
-  fs.readFile(indexPath, 'utf8', (error, html) => {
-    if (error) {
-      res.status(500).send('Farming frontend is not built');
-      return;
-    }
-    res.setHeader('Content-Type', 'text/html; charset=utf-8');
-    res.setHeader('Cache-Control', 'no-cache');
-    const rewrittenHtml = applyIndexHtmlAppearance(
-      rewriteIndexHtmlForBasePath(html, BASE_PATH),
-      configManager.getSettings().appearance
-    );
-    const requestUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-    const requestToken = requestUrl.searchParams.has('token') ? tokenAuth.extractToken(req) : '';
-    const htmlWithAssetToken = authEnabled && requestToken && tokenAuth.verify(requestToken)
-      ? appendIndexHtmlAssetToken(rewrittenHtml, requestToken)
-      : rewrittenHtml;
-    res.send(htmlWithAssetToken);
-  });
-});
-
-app.get(routePath(BASE_PATH, '/api/executables'), (req, res) => {
-  const availableAgents = getAvailableAgentsForRequest();
-  res.setHeader('Cache-Control', 'no-store');
-  res.json({
-    agents: availableAgents,
-    total: availableAgents.length
-  });
-});
-
-app.get(routePath(BASE_PATH, '/api/workspaces/complete'), async (req, res) => {
-  try {
-    const partialPath = typeof req.query.path === 'string' ? req.query.path : '';
-    const requestedLimit = Number(req.query.limit);
-    const suggestions = await listWorkspacePathCompletions(partialPath, requestedLimit);
-    res.json({ suggestions });
-  } catch (error) {
-    res.status(200).json({
-      suggestions: [],
-      error: error.message || 'Failed to read directory',
-    });
-  }
-});
-
-app.use(routePath(BASE_PATH, '/api/workspaces'), createWorkspaceDirectoryRouter());
-
-app.get(routePath(BASE_PATH, '/api/skills'), (_req, res) => {
-  res.json({ skills: getMainAgentSkillsCatalog() });
-});
-
-app.get(routePath(BASE_PATH, '/api/agent-extensions'), (_req, res) => {
-  const agents = getAvailableAgentsForRequest()
-    .filter(agent => agent.category === 'coding')
-    .map(agent => {
-      const provider = String(agent.name || agent.command || '').trim().toLowerCase();
-      const configuredHomes = configManager.getAgentHomes(provider);
-      const homes = configuredHomes.length > 0
-        ? configuredHomes
-        : [{ id: 'default', path: '' }];
-      return {
-        id: provider,
-        name: agent.name,
-        description: agent.description || '',
-        discoverySupported: provider === 'codex' || provider === 'claude',
-        homes: homes.map(home => ({
-          id: home.id,
-          extensions: discoverAgentExtensions({
-            provider,
-            providerHomePath: home.path,
-          }).map(extension => ({
-            id: extension.command,
-            command: extension.command,
-            name: extension.label,
-            description: extension.description,
-            kind: extension.source === 'custom' ? 'command' : extension.source || 'command',
-            scope: extension.scope || '',
-          })),
-        })),
-      };
-    });
-  res.setHeader('Cache-Control', 'no-store');
-  res.json({ agents });
-});
-
-app.get(routePath(BASE_PATH, '/api/slash-commands'), (req, res) => {
-  const provider = typeof req.query.provider === 'string' ? req.query.provider : '';
-  const workspace = typeof req.query.workspace === 'string' ? req.query.workspace : '';
-  res.json({ commands: discoverSlashCommands({ provider, workspace }) });
-});
-
-const IMAGE_ATTACHMENT_EXTENSIONS = {
-  'image/png': 'png',
-  'image/jpeg': 'jpg',
-  'image/gif': 'gif',
-  'image/webp': 'webp',
-};
-const AUDIO_ATTACHMENT_EXTENSIONS = {
-  'audio/aac': 'aac',
-  'audio/flac': 'flac',
-  'audio/mp4': 'm4a',
-  'audio/mpeg': 'mp3',
-  'audio/ogg': 'ogg',
-  'audio/wav': 'wav',
-  'audio/wave': 'wav',
-  'audio/webm': 'webm',
-  'audio/x-wav': 'wav',
-};
-const IMAGE_ATTACHMENT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-const IMAGE_ATTACHMENT_GC_INTERVAL_MS = 60 * 60 * 1000;
-const IMAGE_ATTACHMENT_FILENAME_RE = /^pasted-image-\d+-[a-f0-9]{8}\.(?:png|jpg|gif|webp)$/;
-const AUDIO_ATTACHMENT_FILENAME_RE = /^pasted-audio-\d+-[a-f0-9]{8}\.(?:aac|flac|m4a|mp3|ogg|wav|webm)$/;
-let lastImageAttachmentGcAt = 0;
-
-function imageAttachmentExtension(contentType) {
-  const normalized = String(contentType || '').split(';')[0].trim().toLowerCase();
-  return IMAGE_ATTACHMENT_EXTENSIONS[normalized] || '';
-}
-
-function audioAttachmentExtension(contentType) {
-  const normalized = String(contentType || '').split(';')[0].trim().toLowerCase();
-  return AUDIO_ATTACHMENT_EXTENSIONS[normalized] || '';
-}
-
-function imageAttachmentsDir() {
-  return path.join(configManager.farmingDir, 'attachments');
-}
-
-async function cleanupExpiredImageAttachments(options = {}) {
-  const now = Date.now();
-  if (!options.force && now - lastImageAttachmentGcAt < IMAGE_ATTACHMENT_GC_INTERVAL_MS) return;
-  lastImageAttachmentGcAt = now;
-
-  const attachmentsDir = imageAttachmentsDir();
-  let entries = [];
-  try {
-    entries = await fs.promises.readdir(attachmentsDir, { withFileTypes: true });
-  } catch (error) {
-    if (error && error.code !== 'ENOENT') {
-      console.warn('Failed to scan image attachments:', error.message || error);
-    }
-    return;
-  }
-
-  const cutoff = now - IMAGE_ATTACHMENT_RETENTION_MS;
-  await Promise.all(entries.map(async (entry) => {
-    if (!entry.isFile() || (!IMAGE_ATTACHMENT_FILENAME_RE.test(entry.name) && !AUDIO_ATTACHMENT_FILENAME_RE.test(entry.name))) return;
-
-    const filePath = path.join(attachmentsDir, entry.name);
-    try {
-      const stat = await fs.promises.stat(filePath);
-      if (stat.mtimeMs < cutoff) {
-        await fs.promises.unlink(filePath);
-      }
-    } catch (error) {
-      if (!error || error.code !== 'ENOENT') {
-        console.warn('Failed to remove expired image attachment:', error && (error.message || error));
-      }
-    }
-  }));
-}
-
-void cleanupExpiredImageAttachments({ force: true });
-
-app.post(
-  routePath(BASE_PATH, '/api/attachments/image'),
-  express.raw({ type: 'image/*', limit: '12mb' }),
-  (req, res) => {
-    const contentType = String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
-    const extension = imageAttachmentExtension(contentType);
-    if (!extension) {
-      res.status(415).json({ error: 'unsupported image type' });
-      return;
-    }
-
-    if (!Buffer.isBuffer(req.body) || req.body.length === 0) {
-      res.status(400).json({ error: 'empty image attachment' });
-      return;
-    }
-
-    const attachmentsDir = imageAttachmentsDir();
-    fs.mkdirSync(attachmentsDir, { recursive: true });
-    const filename = `pasted-image-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    fs.writeFileSync(filePath, req.body);
-    void cleanupExpiredImageAttachments();
-
-    res.status(201).json({
-      path: filePath,
-      name: filename,
-      type: contentType,
-      size: req.body.length,
-    });
-  }
-);
-
-app.post(
-  routePath(BASE_PATH, '/api/attachments/audio'),
-  express.raw({ type: 'audio/*', limit: '25mb' }),
-  (req, res) => {
-    const contentType = String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
-    const extension = audioAttachmentExtension(contentType);
-    if (!extension) {
-      res.status(415).json({ error: 'unsupported audio type' });
-      return;
-    }
-    if (!Buffer.isBuffer(req.body) || req.body.length === 0) {
-      res.status(400).json({ error: 'empty audio attachment' });
-      return;
-    }
-    const attachmentsDir = imageAttachmentsDir();
-    fs.mkdirSync(attachmentsDir, { recursive: true });
-    const filename = `pasted-audio-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.${extension}`;
-    const filePath = path.join(attachmentsDir, filename);
-    fs.writeFileSync(filePath, req.body);
-    void cleanupExpiredImageAttachments();
-    res.status(201).json({ path: filePath, name: filename, type: contentType, size: req.body.length });
-  }
-);
-
-app.get(routePath(BASE_PATH, '/api/codex/models'), async (req, res) => {
-  try {
-    const catalog = await codexModelOptionsCache.get('catalog');
-    res.json(catalog);
-  } catch (error) {
-    const timedOut = error && error.code === 'CODEX_MODELS_TIMEOUT';
-    res.status(timedOut ? 504 : 502).json({
-      error: error && error.message ? error.message : 'Failed to load Codex model catalog',
-      code: error && error.code ? error.code : 'CODEX_MODELS_FAILED',
-    });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/claude/settings'), (req, res) => {
-  res.json({ settings: readClaudeSettingsSummary() });
-});
-
-app.get(routePath(BASE_PATH, '/api/usage'), async (req, res) => {
-  try {
-    const fresh = req.query.fresh === '1';
-    const live = req.query.live === '1';
-    if (fresh) usageMonitor.invalidateDailyCache();
-    const usage = await usageSummaryCache.get(
-      'summary',
-      fresh ? { force: true } : live ? { maxAgeMs: 15_000 } : {},
-    );
-    res.json({ usage });
-  } catch (error) {
-    res.status(500).json({ error: error.message || 'Failed to read usage information' });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/usage/day'), async (req, res) => {
-  try {
-    const date = String(req.query.date || '').trim();
-    const detail = await usageMonitor.getUsageDay(date, {
-      fresh: req.query.fresh === '1',
-      live: req.query.live === '1',
-    });
-    res.json({ detail });
-  } catch (error) {
-    const invalidDate = error instanceof RangeError;
-    res.status(invalidDate ? 400 : 500).json({
-      error: invalidDate
-        ? error.message
-        : error.message || 'Failed to read usage day information',
-    });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/codex/context-windows'), express.json(), async (req, res) => {
-  try {
-    const requestedIds = Array.isArray(req.body?.agentIds)
-      ? req.body.agentIds
-        .map(value => String(value || '').trim())
-        .filter(Boolean)
-        .slice(0, 20)
-      : [];
-    const requestedIdSet = new Set(requestedIds);
-    const agents = agentManager.getState().agents.filter(agent => requestedIdSet.has(agent.id));
-    const contextWindows = await codexContextWindowReader.readForAgents(agents);
-    res.json({ contextWindows });
-  } catch (error) {
-    res.status(500).json({ error: error.message || 'Failed to read Codex context windows' });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/update'), async (req, res) => {
-  try {
-    const update = await updateService.check({ force: req.query.force === '1' });
-    res.json({ update });
-  } catch (error) {
-    res.status(502).json({ error: error.message || 'Failed to check for updates' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/update/install'), express.json(), async (req, res) => {
-  try {
-    const state = await updateService.startInstall({
-      assetName: req.body && typeof req.body.assetName === 'string' ? req.body.assetName : '',
-    });
-    res.status(202).json({ update: { state } });
-  } catch (error) {
-    res.status(500).json({ error: error.message || 'Failed to start update' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/update/restart'), express.json(), async (req, res) => {
-  try {
-    const state = await updateService.applyPreparedUpdate();
-    res.status(202).json({ update: { state } });
-  } catch (error) {
-    res.status(500).json({ error: error.message || 'Failed to restart for update' });
-  }
-});
-
-function warmCodexExecutableVersionCache() {
-  const startedAt = Date.now();
-  try {
-    const result = resolveCompatibleCodexExecutable('');
-    if (result.path) {
-      console.log(`Codex executable ready: ${result.version || 'unknown version'} (${Date.now() - startedAt}ms)`);
-    }
-  } catch (error) {
-    console.warn('Failed to warm Codex executable version cache:', error.message || error);
-  }
-}
-
-app.get(routePath(BASE_PATH, '/api/codex/sessions'), async (req, res) => {
-  const requestedLimit = Number(req.query.limit);
-  const limit = Number.isFinite(requestedLimit) ? Math.max(0, Math.min(1000, requestedLimit)) : 40;
-  const requestedScanLimit = Number(req.query.scanLimit);
-  const scanLimit = Number.isFinite(requestedScanLimit) ? Math.max(limit, Math.min(5000, requestedScanLimit)) : undefined;
-  const sessions = await listCodexSessions({ limit, scanLimit });
-  res.json({ sessions });
-});
-
-app.get(routePath(BASE_PATH, '/api/agent-sessions'), async (req, res) => {
-  try {
-    const requestedLimit = Number(req.query.limit);
-    const limit = Number.isFinite(requestedLimit) ? Math.max(0, Math.min(1000, requestedLimit)) : 60;
-    const cursor = typeof req.query.cursor === 'string' ? req.query.cursor : '';
-    const cacheOptions = req.query.force === '1'
-      ? { force: true }
-      : (req.query.fresh === '1' ? { maxAgeMs: INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS } : {});
-    const sessions = await agentSessionsCache.get(
-      JSON.stringify(configManager.getSettings().agentHomes || {}),
-      cacheOptions
-    );
-    const page = paginateAgentSessions(sessions, { limit: Math.max(1, limit), cursor });
-    if (page.invalidCursor) {
-      res.status(400).json({ error: 'Invalid Agent session cursor' });
-      return;
-    }
-    const displayStateByKey = new Map(configManager.listAgentSessionRecords()
-      .filter(record => record && record.providerSessionKey)
-      .map(record => [record.providerSessionKey, record]));
-    res.json({
-      sessions: page.sessions.map(session => {
-        const key = mainPageAgentSessionKey(session.provider, session.id, session.providerHomeId);
-        const displayState = displayStateByKey.get(key);
-        return typeof displayState?.displayPinned === 'boolean'
-          ? { ...session, pinned: displayState.displayPinned }
-          : session;
-      }),
-      nextCursor: page.nextCursor,
-      hasMore: page.hasMore,
-      total: sessions.length,
-    });
-  } catch (error) {
-    console.error('Failed to read agent sessions:', error);
-    res.status(500).json({ error: error.message || 'Failed to read agent sessions' });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agent-sessions/search'), async (req, res) => {
-  try {
-    const query = typeof req.query.q === 'string' ? req.query.q : '';
-    const requestedLimit = Number(req.query.limit);
-    const limit = Number.isFinite(requestedLimit) ? Math.max(1, Math.min(1000, requestedLimit)) : 100;
-    const settings = configManager.getSettings();
-    const cacheOptions = req.query.force === '1'
-      ? { force: true }
-      : (req.query.fresh === '1' ? { maxAgeMs: INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS } : {});
-    const sessions = await withSearchTimeout(
-      agentSessionsCache.get(
-        JSON.stringify(settings.agentHomes || {}),
-        cacheOptions
-      ),
-      settings.searchTimeoutMs
-    );
-    const result = searchAgentSessions(sessions, query, {
-      limit,
-      projectNames: settings.projectNames,
-    });
-    const displayStateByKey = new Map(configManager.listAgentSessionRecords()
-      .filter(record => record && record.providerSessionKey)
-      .map(record => [record.providerSessionKey, record]));
-    res.json({
-      ...result,
-      sessions: result.sessions.map(session => {
-        const key = mainPageAgentSessionKey(session.provider, session.id, session.providerHomeId);
-        const displayState = displayStateByKey.get(key);
-        return typeof displayState?.displayPinned === 'boolean'
-          ? { ...session, pinned: displayState.displayPinned }
-          : session;
-      }),
-    });
-  } catch (error) {
-    if (error?.code === 'ETIMEDOUT') {
-      res.status(504).json({ error: error.message });
-      return;
-    }
-    console.error('Failed to search agent sessions:', error);
-    res.status(500).json({ error: error.message || 'Failed to search Agent sessions' });
-  }
-});
-
-app.patch(routePath(BASE_PATH, '/api/agent-sessions/:provider/:sessionId'), express.json(), (req, res) => {
-  const provider = normalizeProvider(req.params.provider);
-  const sessionId = String(req.params.sessionId || '').trim();
-  const providerHomeId = String(req.body?.providerHomeId || 'default').trim() || 'default';
-  if (!provider || !isSafeSessionId(sessionId) || !/^[A-Za-z0-9._-]+$/.test(providerHomeId)) {
-    res.status(400).json({ error: 'Invalid Agent session' });
-    return;
-  }
-  if (typeof req.body?.pinned !== 'boolean') {
-    res.status(400).json({ error: 'Pinned state is required' });
-    return;
-  }
-  const sessionKey = mainPageAgentSessionKey(provider, sessionId, providerHomeId);
-  configManager.setProviderSessionDisplayState(sessionKey, { pinned: req.body.pinned });
-  res.json({ sessionKey, pinned: req.body.pinned });
-});
-
-app.post(routePath(BASE_PATH, '/api/main-page-agent-sessions'), express.json(), (req, res) => {
-  const operation = req.body?.operation;
-  const requestedKeys = Array.isArray(req.body?.sessionKeys) ? req.body.sessionKeys : [];
-  const sessionKeys = [...new Set(requestedKeys.map(key => String(key || '').trim()).filter(Boolean))];
-  if (
-    !['add', 'remove'].includes(operation)
-    || sessionKeys.length === 0
-    || sessionKeys.length > 50
-    || sessionKeys.some(key => !mainPageAgentSessionFromKey(key))
-  ) {
-    res.status(400).json({ error: 'A valid main-page Agent session mutation is required' });
-    return;
-  }
-
-  if (operation === 'add') {
-    [...sessionKeys].reverse().forEach(sessionKey => {
-      const session = mainPageAgentSessionFromKey(sessionKey);
-      configManager.rememberMainPageSessionKey(sessionKey, {
-        provider: session.provider,
-        providerSessionId: session.sessionId,
-        providerSessionKey: sessionKey,
-        providerHomeId: session.providerHomeId || 'default',
-      });
-    });
-  } else {
-    configManager.removeMainPageSessionKeys(sessionKeys);
-  }
-
-  const mainPageSessionKeys = configManager.getMainPageSessionKeys();
-  agentSessionsCache.invalidate();
-  res.json({ success: true, mainPageSessionKeys });
-  scheduleBroadcastState();
-});
-
-app.get(routePath(BASE_PATH, '/api/themes'), (req, res) => {
-  const currentTheme = configManager.getSettings().theme || 'terminal';
-  res.json({
-    themes: themeManager.getAllThemes(),
-    current: currentTheme
-  });
-});
-
-app.get(routePath(BASE_PATH, '/api/settings'), (req, res) => {
-  res.json({
-    settings: configManager.getSettings()
-  });
-});
-
-app.get(routePath(BASE_PATH, '/api/workspaces/discovered'), (req, res) => {
-  const requestedLimit = Number(req.query.limit);
-  const limit = Number.isFinite(requestedLimit) ? Math.max(0, Math.min(20, requestedLimit)) : 12;
-  const agent = typeof req.query.agent === 'string' ? req.query.agent : '';
-  const cacheToken = JSON.stringify({ limit, agent });
-  workspaceDiscoveryCache.get(cacheToken)
-    .then(workspaces => {
-      res.json({ workspaces });
-    })
-    .catch(error => {
-      console.error('Failed to discover workspaces:', error);
-      res.status(500).json({ error: error.message || 'Failed to discover workspaces' });
-    });
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/session-text'), async (req, res) => {
-  const text = await agentManager.getAgentSessionText(req.params.agentId);
-  if (text === null) {
-    res.status(404).json({ error: 'Agent not found' });
-    return;
-  }
-
-  res.type('text/plain');
-  res.send(text);
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/session-view'), async (req, res) => {
-  const sessionView = await agentManager.getAgentSessionView(req.params.agentId);
-  if (!sessionView) {
-    res.status(404).json({ error: 'Agent not found' });
-    return;
-  }
-
-  res.json({ session: sessionView });
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/json-cli-transcript'), async (req, res) => {
-  try {
-    const transcript = agentManager.getJsonCliTranscript(req.params.agentId, {
-      maxTurns: DEFAULT_TRANSCRIPT_MAX_TURNS,
-    });
-    res.json({ transcript });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read JSON CLI transcript';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-session'), async (req, res) => {
-  try {
-    res.json({
-      session: agentManager.getAcpSession(req.params.agentId, {
-        includeUpdates: req.query.includeUpdates === '1',
-        includeEntries: req.query.includeEntries !== '0',
-      }),
-    });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read ACP session';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-transcript'), async (req, res) => {
-  try {
-    const requestedMaxTurns = Number.parseInt(String(req.query.maxTurns || ''), 10);
-    const maxTurns = Number.isFinite(requestedMaxTurns)
-      ? Math.min(MAX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
-      : DEFAULT_TRANSCRIPT_MAX_TURNS;
-    const requestedRevision = Number.parseInt(String(req.query.sinceRevision || ''), 10);
-    const externalMedia = req.query.media === 'external-v1';
-    res.json({ transcript: agentManager.getAcpTranscript(req.params.agentId, {
-      maxTurns,
-      ...(externalMedia
-        ? {
-            mediaPathPrefix: routePath(
-              BASE_PATH,
-              `/api/agents/${encodeURIComponent(req.params.agentId)}/acp-media`
-            ),
-          }
-        : {}),
-      ...(Number.isFinite(requestedRevision) && requestedRevision >= 0
-        ? { sinceRevision: requestedRevision }
-        : {}),
-    }) });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read ACP transcript';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-media/:entryId/:mediaId'), (req, res) => {
-  try {
-    const media = agentManager.getAcpTranscriptMedia(
-      req.params.agentId,
-      req.params.entryId,
-      req.params.mediaId
-    );
-    const decoded = decodeAcpTranscriptMedia(media);
-    if (!decoded) {
-      res.status(415).json({ error: 'unsupported ACP transcript media' });
-      return;
-    }
-    res.setHeader('Cache-Control', 'private, max-age=31536000, immutable');
-    res.setHeader('X-Content-Type-Options', 'nosniff');
-    res.type(decoded.mimeType).send(decoded.content);
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read ACP transcript media';
-    const status = message === 'Agent not found'
-      || message === 'ACP transcript entry not found'
-      || message === 'ACP transcript media not found'
-      ? 404
-      : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-tool-details/:toolCallId'), async (req, res) => {
-  try {
-    res.json(agentManager.getAcpToolDetail(req.params.agentId, req.params.toolCallId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read ACP tool details';
-    const status = message === 'Agent not found' || message === 'ACP tool call not found' ? 404 : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-terminals/:terminalId/kill'), (req, res) => {
-  try {
-    res.json(agentManager.killAcpTerminal(req.params.agentId, req.params.terminalId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to stop ACP terminal';
-    const status = message === 'Agent not found' || message === 'Unknown ACP terminal' ? 404 : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-terminals/:terminalId/input'), express.json({ limit: '96kb' }), (req, res) => {
-  try {
-    res.json(agentManager.inputAcpTerminal(req.params.agentId, req.params.terminalId, req.body?.input));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to write ACP terminal input';
-    const status = message === 'Agent not found' || message === 'Unknown ACP terminal' ? 404 : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-terminals/:terminalId/resize'), express.json(), (req, res) => {
-  try {
-    res.json(agentManager.resizeAcpTerminal(
-      req.params.agentId,
-      req.params.terminalId,
-      req.body?.cols,
-      req.body?.rows,
-    ));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to resize ACP terminal';
-    const status = message === 'Agent not found' || message === 'Unknown ACP terminal' ? 404 : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-subagents/:sessionId/cancel'), async (req, res) => {
-  try {
-    res.json(await agentManager.cancelAcpSubagent(req.params.agentId, req.params.sessionId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to stop ACP subagent';
-    const status = message === 'Agent not found' || message === 'ACP subagent session not found' ? 404 : 409;
-    res.status(status).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-patches/:toolCallId/decision'), express.json({ limit: '16kb' }), async (req, res) => {
-  try {
-    res.json(await agentManager.decideAcpPatch(
-      req.params.agentId,
-      req.params.toolCallId,
-      req.body?.path,
-      req.body?.decision,
-    ));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to decide ACP patch';
-    const status = Number(error?.statusCode) || (message === 'Agent not found' || message === 'ACP tool call not found' ? 404 : 409);
-    res.status(status).json({ error: message });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/acp-sessions'), async (req, res) => {
-  try {
-    const result = await agentManager.listAcpSessions(req.params.agentId, {
-      cwd: typeof req.query.cwd === 'string' ? req.query.cwd : '',
-      cursor: typeof req.query.cursor === 'string' ? req.query.cursor : '',
-    });
-    res.json(result);
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to list ACP sessions';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-permission'), express.json(), (req, res) => {
-  try {
-    const result = agentManager.respondToAcpPermission(
-      req.params.agentId,
-      req.body?.requestId,
-      req.body?.optionId,
-      req.body?.cancelled === true
-    );
-    res.json(result);
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to respond to ACP permission';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-elicitation'), express.json(), (req, res) => {
-  try {
-    const result = agentManager.respondToAcpElicitation(
-      req.params.agentId,
-      req.body?.requestId,
-      req.body?.action,
-      req.body?.content
-    );
-    res.json(result);
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to respond to ACP input request';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/authenticate'), express.json(), async (req, res) => {
-  try {
-    res.json(await agentManager.authenticateAcpAgent(req.params.agentId, req.body?.methodId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to authenticate ACP Agent';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/logout'), async (req, res) => {
-  try {
-    res.json(await agentManager.logoutAcpAgent(req.params.agentId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to log out ACP Agent';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/fork'), express.json(), async (req, res) => {
-  try {
-    res.json(await agentManager.forkAcpSession(req.params.agentId, req.body || {}));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to fork ACP session';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.delete(routePath(BASE_PATH, '/api/agents/:agentId/acp-sessions/:sessionId'), async (req, res) => {
-  try {
-    res.json(await agentManager.deleteAcpSession(req.params.agentId, req.params.sessionId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to delete ACP session';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/close'), async (req, res) => {
-  try {
-    res.json(await agentManager.closeAcpSession(req.params.agentId));
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to close ACP session';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.patch(routePath(BASE_PATH, '/api/agents/:agentId/acp-session'), express.json(), async (req, res) => {
-  try {
-    if (typeof req.body?.modeId === 'string') {
-      res.json(await agentManager.setAcpSessionMode(req.params.agentId, req.body.modeId));
-      return;
-    }
-    if (Array.isArray(req.body?.configOptions)) {
-      res.json(await agentManager.setAcpSessionConfigOptions(req.params.agentId, req.body.configOptions));
-      return;
-    }
-    if (typeof req.body?.configId === 'string' && Object.prototype.hasOwnProperty.call(req.body, 'value')) {
-      res.json(await agentManager.setAcpSessionConfigOption(
-        req.params.agentId,
-        req.body.configId,
-        req.body.value
-      ));
-      return;
-    }
-    res.status(400).json({ error: 'ACP modeId, configOptions, or configId/value is required' });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to update ACP session';
-    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/codex-terminal-profile'), express.json(), async (req, res) => {
-  const requestAbort = new globalThis.AbortController();
-  const abortRequest = () => requestAbort.abort(new Error('Terminal profile request was canceled'));
-  const abortClosedResponse = () => {
-    if (!res.writableEnded) abortRequest();
-  };
-  req.once('aborted', abortRequest);
-  res.once('close', abortClosedResponse);
-  try {
-    const profile = await agentManager.setCodexTerminalProfile(req.params.agentId, {
-      model: req.body?.model,
-      effort: req.body?.effort,
-      serviceTier: req.body?.serviceTier,
-    }, {
-      signal: requestAbort.signal,
-      timeoutMs: 44_000,
-    });
-    res.json({ profile });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to update Codex Terminal profile';
-    const status = message === 'Agent not found'
-      ? 404
-      : /^A valid Codex /.test(message)
-        ? 400
-        : 409;
-    if (!res.headersSent && !res.destroyed) res.status(status).json({ error: message });
-  } finally {
-    req.off('aborted', abortRequest);
-    res.off('close', abortClosedResponse);
-  }
-});
-
-app.patch(routePath(BASE_PATH, '/api/agents/:agentId'), express.json(), async (req, res) => {
-  if (!await requireAgentRecoveryForHttp(res)) return;
-  const body = req.body || {};
-  const updates = {};
-  const providedPatchFields = [
-    'customTitle',
-    'task',
-    'pinned',
-    'unread',
-    'archived',
-    'readAttentionSeq',
-    'readOutputEpoch',
-    'readOutputSeq',
-    'launchPermissionMode',
-    'agentRuntimeMode',
-  ].filter(field => Object.prototype.hasOwnProperty.call(body, field));
-  const lifecyclePatchFields = providedPatchFields.filter(field => (
-    field === 'launchPermissionMode'
-    || field === 'agentRuntimeMode'
-    || (field === 'archived' && body.archived === true)
-  ));
-  if (lifecyclePatchFields.length > 0 && providedPatchFields.length > 1) {
-    res.status(400).json({
-      error: 'Archive, permission restart, and runtime switch must be requested separately from other Agent updates',
-    });
-    return;
-  }
-  const ordinaryPatchGroups = [
-    providedPatchFields.includes('customTitle') ? 'customTitle' : '',
-    providedPatchFields.includes('task') ? 'task' : '',
-    providedPatchFields.some(field => [
-      'pinned',
-      'unread',
-      'archived',
-      'readAttentionSeq',
-      'readOutputEpoch',
-      'readOutputSeq',
-    ].includes(field)) ? 'flags' : '',
-  ].filter(Boolean);
-  if (ordinaryPatchGroups.length > 1) {
-    res.status(400).json({
-      error: 'Agent title, task, and flags must be updated in separate requests',
-    });
-    return;
-  }
-
-  await agentManager.whenAgentLifecycleIdle(req.params.agentId);
-
-  if (typeof body.customTitle === 'string') {
-    const result = agentManager.renameAgent(req.params.agentId, body.customTitle);
-    if (result.error) {
-      const status = result.error === 'Agent not found'
-        ? 404
-        : (result.error.startsWith('Failed to ') ? 500 : 409);
-      res.status(status).json({ error: result.error });
-      return;
-    }
-    updates.customTitle = result.customTitle;
-  }
-
-  if (typeof body.task === 'string') {
-    const result = agentManager.setAgentTask(req.params.agentId, body.task);
-    if (result.error) {
-      const status = result.error === 'Agent not found'
-        ? 404
-        : (result.error.startsWith('Failed to ') ? 500 : 409);
-      res.status(status).json({ error: result.error });
-      return;
-    }
-    updates.task = result.task;
-  }
-
-  const flagPatch = {};
-  ['pinned', 'unread', 'archived'].forEach((flagName) => {
-    if (typeof body[flagName] === 'boolean') {
-      flagPatch[flagName] = body[flagName];
-    }
-  });
-  if (typeof body.readAttentionSeq === 'number' && Number.isFinite(body.readAttentionSeq)) {
-    flagPatch.readAttentionSeq = body.readAttentionSeq;
-  }
-  if (
-    typeof body.readOutputEpoch === 'string'
-    && body.readOutputEpoch
-    && typeof body.readOutputSeq === 'number'
-    && Number.isFinite(body.readOutputSeq)
-  ) {
-    flagPatch.readOutputEpoch = body.readOutputEpoch;
-    flagPatch.readOutputSeq = body.readOutputSeq;
-  }
-
-  if (flagPatch.archived === true) {
-    const result = await agentManager.archiveAgent(req.params.agentId);
-    if (result.error) {
-      const status = result.stopped === true
-        ? 409
-        : (result.error === 'Agent not found' ? 404 : 400);
-      res.status(status).json(result);
-      return;
-    }
-    Object.assign(updates, result);
-    delete updates.agentId;
-    delete flagPatch.archived;
-  }
-
-  let flagUpdateRequiresState = false;
-  if (Object.keys(flagPatch).length > 0) {
-    const result = agentManager.updateAgentFlags(req.params.agentId, flagPatch);
-    if (result.error) {
-      const status = result.error === 'Agent not found'
-        ? 404
-        : (result.error.startsWith('Failed to ') ? 500 : 409);
-      res.status(status).json({ error: result.error });
-      return;
-    }
-    Object.assign(updates, result);
-    delete updates.agentId;
-    flagUpdateRequiresState = result.requiresState === true;
-  }
-
-  if (typeof body.launchPermissionMode === 'string') {
-    const result = await agentManager.syncCodexTerminalPermissionMode(req.params.agentId, body.launchPermissionMode);
-    if (result.error) {
-      const status = result.error === 'Agent not found' ? 404 : 400;
-      res.status(status).json({ error: result.error });
-      return;
-    }
-    updates.launchPermissionMode = result.launchPermissionMode;
-    if (result.restarted === true) updates.restarted = true;
-    if (result.restartedAgentId) updates.restartedAgentId = result.restartedAgentId;
-  }
-
-  if (typeof body.agentRuntimeMode === 'string') {
-    const result = await agentManager.restartAgentRuntimeMode(req.params.agentId, body.agentRuntimeMode);
-    if (result.error) {
-      const status = result.error === 'Agent not found' ? 404 : 400;
-      res.status(status).json({ error: result.error });
-      return;
-    }
-    updates.agentRuntimeMode = result.agentRuntimeMode;
-    if (result.restarted === true) updates.restarted = true;
-    if (result.restartedAgentId) updates.restartedAgentId = result.restartedAgentId;
-    if (result.switchFailed === true) updates.switchFailed = true;
-    if (result.warning) updates.warning = result.warning;
-  }
-
-  if (Object.keys(updates).length === 0) {
-    res.status(400).json({ error: 'customTitle, task, pinned, unread, archived, readAttentionSeq, readOutputEpoch/readOutputSeq, launchPermissionMode, or agentRuntimeMode is required' });
-    return;
-  }
-
-  if (flagUpdateRequiresState || typeof body.task === 'string' || typeof body.customTitle === 'string' || typeof body.launchPermissionMode === 'string' || typeof body.agentRuntimeMode === 'string') {
-    scheduleBroadcastState();
-  }
-  res.json({ agentId: req.params.agentId, ...updates });
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/reorder'), express.json(), async (req, res) => {
-  if (!await requireAgentRecoveryForHttp(res)) return;
-  await agentManager.whenAgentLifecycleIdle(req.params.agentId);
-  const result = agentManager.reorderAgent(req.params.agentId, {
-    beforeAgentId: req.body?.beforeAgentId,
-    afterAgentId: req.body?.afterAgentId,
-  });
-  if (result.error) {
-    const status = result.error === 'Agent not found'
-      ? 404
-      : (result.error.startsWith('Failed to ') ? 500 : 409);
-    res.status(status).json({ error: result.error });
-    return;
-  }
-  scheduleBroadcastState();
-  res.json(result);
-});
-
-app.post(routePath(BASE_PATH, '/api/agents/:agentId/fork'), express.json(), async (req, res) => {
-  if (!await requireAgentRecoveryForHttp(res)) return;
-  const mode = req.body && typeof req.body.mode === 'string' ? req.body.mode : 'same-worktree';
-  const targetRuntime = req.body && typeof req.body.targetRuntime === 'string'
-    ? req.body.targetRuntime
-    : '';
-  if (targetRuntime && targetRuntime !== 'chat') {
-    res.status(400).json({ error: 'Unsupported Fork target runtime' });
-    return;
-  }
-  const requestId = typeof req.body?.requestId === 'string' ? req.body.requestId.trim() : '';
-  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
-    res.status(400).json({ error: 'Fork requires a valid requestId' });
-    return;
-  }
-  const result = await agentManager.forkAgent(req.params.agentId, mode, {
-    requestId,
-    ...(targetRuntime ? { targetRuntime } : {}),
-    ...(Number.isSafeInteger(req.body?.expectedRevision)
-      ? { expectedRevision: req.body.expectedRevision }
-      : {}),
-  });
-  if (result.error) {
-    const status = result.error === 'Agent not found' ? 404 : 400;
-    res.status(status).json(result);
-    return;
-  }
-
-  try {
-    const membership = configManager.mountProjectWorkspace(result.workspace);
-    result.projectWorkspaces = membership.projectWorkspaces;
-    result.pinnedProjectWorkspaces = membership.pinnedProjectWorkspaces;
-  } catch (error) {
-    broadcastState();
-    const mountError = error.message || 'Failed to create Project';
-    res.status(500).json({
-      ...result,
-      error: `${mountError}. Retry the same Fork request to reconcile Project membership.`,
-      retryable: true,
-    });
-    return;
-  }
-  broadcastState();
-  res.status(201).json(result);
-});
-
-function resolveProjectActionRoot(rootId) {
-  const root = workspaceRootRegistry.resolve(rootId);
-  if (!root || root.kind === 'global') {
-    throw new WorkspaceFileError('project workspace is required', 400);
-  }
-  return root;
-}
-
-app.post(routePath(BASE_PATH, '/api/projects/reveal'), express.json(), async (req, res) => {
-  try {
-    const root = resolveProjectActionRoot(req.body?.rootId);
-    const command = process.platform === 'darwin'
-      ? 'open'
-      : process.platform === 'win32'
-        ? 'explorer'
-        : 'xdg-open';
-    await execFileAsync(command, [root.canonicalPath], {
-      timeout: 15000,
-      maxBuffer: 1024 * 1024,
-    });
-    res.json({ revealed: true, workspace: root.canonicalPath });
-  } catch (error) {
-    const status = error instanceof WorkspaceFileError ? error.statusCode : 500;
-    res.status(status).json({ error: error.message || 'Failed to reveal project workspace' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/projects/mount'), express.json(), async (req, res) => {
-  try {
-    const workspace = await canonicalProjectWorkspace(req.body?.workspace);
-    const membership = configManager.mountProjectWorkspace(workspace);
-    broadcastState();
-    res.json(membership);
-  } catch (error) {
-    res.status(400).json({ error: error.message || 'Failed to create Project' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/projects/remove'), express.json(), (req, res) => {
-  try {
-    const membership = configManager.removeProjectWorkspace(req.body?.workspace);
-    broadcastState();
-    res.json(membership);
-  } catch (error) {
-    res.status(400).json({ error: error.message || 'Failed to remove Project' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/projects/pin'), express.json(), (req, res) => {
-  try {
-    const membership = configManager.setProjectWorkspacePinned(
-      req.body?.workspace,
-      req.body?.pinned === true
-    );
-    broadcastState();
-    res.json(membership);
-  } catch (error) {
-    res.status(400).json({ error: error.message || 'Failed to update Project pin' });
-  }
-});
-
-app.patch(routePath(BASE_PATH, '/api/projects/name'), express.json(), (req, res) => {
-  try {
-    const result = configManager.setProjectName(req.body?.workspace, req.body?.name);
-    scheduleBroadcastState();
-    res.json(result);
-  } catch (error) {
-    res.status(400).json({ error: error.message || 'Failed to rename Project' });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/projects/create-worktree'), express.json(), async (req, res) => {
-  const requestId = typeof req.body?.requestId === 'string' ? req.body.requestId.trim() : '';
-  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
-    res.status(400).json({ error: 'Project worktree creation requires a valid requestId' });
-    return;
-  }
-  try {
-    const root = resolveProjectActionRoot(req.body?.rootId);
-    const created = await agentManager.createPermanentWorktree(root.canonicalPath, { requestId });
-    broadcastState();
-    res.status(201).json({
-      ...created,
-    });
-  } catch (error) {
-    const status = error instanceof WorkspaceFileError ? error.statusCode : 400;
-    const operation = configManager.getProjectOperation?.(requestId);
-    res.status(status).json({
-      error: error.message || 'Failed to create permanent worktree',
-      requestId,
-      ...(operation?.state === 'pending' ? { retryable: true } : {}),
-      ...(['unknown', 'blocked'].includes(operation?.state) ? { uncertain: true } : {}),
-    });
-  }
-});
-
-app.post(routePath(BASE_PATH, '/api/projects/delete-worktree'), express.json(), async (req, res) => {
-  if (!await requireAgentRecoveryForHttp(res)) return;
-  const body = req.body || {};
-  const workspace = typeof body.workspace === 'string' ? body.workspace : '';
-  const requestId = typeof body.requestId === 'string' ? body.requestId.trim() : '';
-  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
-    res.status(400).json({ error: 'Project worktree deletion requires a valid requestId' });
-    return;
-  }
-
-  const result = await agentManager.deleteForkWorktreeProject(workspace, {
-    force: body.force === true,
-    requestId,
-  });
-  if (result.error) {
-    broadcastState();
-    const status = result.requiresForce
-      ? 409
-      : (result.error === 'Workspace not found' || result.error === 'Workspace is required' ? 404 : 400);
-    res.status(status).json(result);
-    return;
-  }
-  broadcastState();
-  res.json(result);
-});
-
-app.post(routePath(BASE_PATH, '/api/codex/sessions/:sessionId/resume'), express.json(), async (req, res) => {
-  await startResumedAgentSession(req, res, 'codex', req.params.sessionId);
-});
-
-app.post(routePath(BASE_PATH, '/api/agent-sessions/:provider/:sessionId/resume'), express.json(), async (req, res) => {
-  await startResumedAgentSession(req, res, req.params.provider, req.params.sessionId);
-});
-
-const pendingResumeStarts = new Map();
-const pendingProjectWorkspaceResolutions = new Map();
-
-function resumedAgentStartKey(provider, sessionId, options = {}) {
-  return [
-    provider,
-    options.providerHomeId || 'default',
-    sessionId,
-    options.fork === true ? 'fork' : 'resume',
-    options.asMain === true ? 'main' : 'agent',
-  ].join(':');
-}
-
-function findResumedAgent(provider, sessionId, providerHomeId = '') {
-  return findActiveAgentClaimingSession(agentManager.getState().agents, provider, { id: sessionId, providerHomeId });
-}
-
-function isMainAgentSessionWorkspace(session) {
-  const values = [session && session.cwd, session && session.workspace];
-  return values.some(value => {
-    const normalized = String(value || '').trim().replace(/[\\/]+$/, '');
-    return normalized === '~/.farming' || /(^|[/\\])\.farming$/.test(normalized);
-  });
-}
-
-function rememberMainPageAgentSession(provider, sessionId, providerHomeId = '') {
-  const sessionKey = mainPageAgentSessionKey(provider, sessionId, providerHomeId);
-  if (typeof configManager.rememberMainPageSessionKey === 'function') {
-    configManager.rememberMainPageSessionKey(sessionKey, {
-      provider,
-      providerSessionId: sessionId,
-      providerSessionKey: sessionKey,
-      providerHomeId: providerHomeId || 'default',
-      source: 'resume',
-    });
-    return;
-  }
-  const currentKeys = typeof configManager.getMainPageSessionKeys === 'function'
-    ? configManager.getMainPageSessionKeys()
-    : (Array.isArray(configManager.getSettings().mainPageSessionKeys) ? configManager.getSettings().mainPageSessionKeys : []);
-  configManager.updateSettings({
-    mainPageSessionKeys: [
-      sessionKey,
-      ...currentKeys.filter(key => key !== sessionKey),
-    ],
-  });
-}
-
-function forgetMainPageAgentSession(provider, sessionId, providerHomeId = '') {
-  const sessionKey = mainPageAgentSessionKey(provider, sessionId, providerHomeId);
-  if (typeof configManager.removeMainPageSessionKey === 'function') {
-    configManager.removeMainPageSessionKey(sessionKey);
-    return;
-  }
-  const currentKeys = typeof configManager.getMainPageSessionKeys === 'function'
-    ? configManager.getMainPageSessionKeys()
-    : (Array.isArray(configManager.getSettings().mainPageSessionKeys) ? configManager.getSettings().mainPageSessionKeys : []);
-  if (!currentKeys.includes(sessionKey)) return;
-  configManager.updateSettings({
-    mainPageSessionKeys: currentKeys.filter(key => key !== sessionKey),
-  });
-}
-
-function savedFarmingAgentSession(provider, sessionId, providerHomeId = '') {
-  if (typeof configManager.getAgentSessionRecordForProviderSessionKey !== 'function') return null;
-  const sessionKey = mainPageAgentSessionKey(provider, sessionId, providerHomeId);
-  return sessionKey
-    ? configManager.getAgentSessionRecordForProviderSessionKey(sessionKey)
-    : null;
-}
-
-async function resumeAgentSessionById(provider, rawSessionId, options = {}) {
-  const normalizedProvider = normalizeProvider(provider);
-  const sessionId = String(rawSessionId || '').trim();
-  const providerHomeId = typeof options.providerHomeId === 'string' && options.providerHomeId.trim() ? options.providerHomeId.trim() : 'default';
-  if (!normalizedProvider || !isSafeSessionId(sessionId)) {
-    return { error: 'invalid session id', status: 400 };
-  }
-
-  const shouldFork = options.fork === true;
-  const requestedAsMain = options.asMain === true && !shouldFork;
-  const shouldRememberMainPageSession = options.rememberMainPageSession !== false && !shouldFork && !requestedAsMain;
-  const pendingResumeId = resumedAgentStartKey(normalizedProvider, sessionId, {
-    fork: shouldFork,
-    asMain: requestedAsMain,
-    providerHomeId,
-  });
-  if (!shouldFork) {
-    const existingAgent = findResumedAgent(normalizedProvider, sessionId, providerHomeId);
-    if (existingAgent) {
-      if (shouldRememberMainPageSession) rememberMainPageAgentSession(normalizedProvider, sessionId, providerHomeId);
-      const projectWorkspace = requestedAsMain
-        ? ''
-        : await canonicalProjectWorkspace(
-          existingAgent.gitWorktree?.workspace || existingAgent.projectWorkspace || existingAgent.cwd
-        );
-      return { agentId: existingAgent.id, projectWorkspace, reused: true };
-    }
-  }
-  const pendingStart = pendingResumeStarts.get(pendingResumeId);
-  if (pendingStart) {
-    const result = await pendingStart;
-    if (result.error) {
-      return result;
-    }
-    if (shouldRememberMainPageSession) rememberMainPageAgentSession(normalizedProvider, sessionId, providerHomeId);
-    return {
-      agentId: result.agentId,
-      projectWorkspace: result.projectWorkspace || '',
-      reused: true,
-      pending: true,
-      ...(result.claimed ? { claimed: true } : {}),
-    };
-  }
-
-  const startPromise = (async () => {
-    let session = await findAgentSession(normalizedProvider, sessionId, {
-      limit: 1000,
-      providerLimit: 1000,
-      scanLimit: 5000,
-      providerHomeId,
-      providerHomes: configuredProviderHomes(),
-    });
-    if (
-      options.allowUnarchiveArchived === true
-      && normalizedProvider === 'codex'
-      && !requestedAsMain
-    ) {
-      const providerHomes = configuredProviderHomes();
-      const configuredHomePath = (providerHomes.codex || [])
-        .find(home => home.id === providerHomeId)?.path || '';
-      const unarchiveResult = await agentManager.ensureCodexSessionAvailable(sessionId, {
-        providerHomeId,
-        providerHomePath: session?.providerHomePath || configuredHomePath,
-        providerHomes,
-        cwd: session?.cwd || session?.workspace || '',
-      });
-      if (unarchiveResult?.error) return unarchiveResult;
-      session = await findAgentSession(normalizedProvider, sessionId, {
-        limit: 1000,
-        providerLimit: 1000,
-        scanLimit: 5000,
-        providerHomeId,
-        providerHomes,
-      }) || (session ? { ...session, archived: false } : session);
-    }
-    if (session && session.archived && !shouldFork) {
-      forgetMainPageAgentSession(normalizedProvider, sessionId, providerHomeId);
-      return {
-        error: `${session.providerName || normalizedProvider} session is archived. Unarchive it before resuming.`,
-        status: 409,
-        archived: true,
-      };
-    }
-    if (!shouldFork && !requestedAsMain) {
-      const claimingAgent = findActiveAgentClaimingSession(agentManager.getState().agents, normalizedProvider, {
-        id: sessionId,
-        providerHomeId,
-        ...(session || {}),
-      });
-      if (claimingAgent) {
-        if (shouldRememberMainPageSession) rememberMainPageAgentSession(normalizedProvider, sessionId, providerHomeId);
-        const projectWorkspace = await canonicalProjectWorkspace(
-          claimingAgent.gitWorktree?.workspace || claimingAgent.projectWorkspace || claimingAgent.cwd
-        );
-        return { agentId: claimingAgent.id, projectWorkspace, reused: true, claimed: true };
-      }
-    }
-
-    const resumeAsMain = requestedAsMain && isMainAgentSessionWorkspace(session);
-    if (requestedAsMain && !resumeAsMain) {
-      return { error: 'session is not a Main Agent session', status: 400 };
-    }
-
-    const savedSession = shouldFork
-      ? null
-      : savedFarmingAgentSession(normalizedProvider, sessionId, session
-        ? (session.providerHomeId || providerHomeId)
-        : providerHomeId);
-    const hasRequestedCustomTitle = Object.prototype.hasOwnProperty.call(options, 'customTitle');
-    const savedAttentionSeq = Number(savedSession?.attentionSeq) || 0;
-    const savedReadAttentionSeq = Number(savedSession?.readAttentionSeq) || 0;
-    const workingDirectory = session && (session.cwd || session.workspace) ? (session.cwd || session.workspace) : null;
-    const projectWorkspace = resumeAsMain
-      ? ''
-      : await canonicalProjectWorkspace(
-        savedSession?.projectWorkspace || (session ? (session.workspace || session.cwd || '') : workingDirectory)
-      );
-    const command = buildAgentSessionResumeCommand(normalizedProvider, sessionId, {
-      fork: shouldFork,
-      cwd: workingDirectory,
-      modelProvider: normalizedProvider === 'codex'
-        ? resolveCodexResumeModelProvider(session ? session.providerHomePath : '')
-        : '',
-    });
-
-    if (!command) {
-      return { error: 'invalid session id', status: 400 };
-    }
-
-    return new Promise((resolve) => {
-      const resolvedProviderHomeId = session ? (session.providerHomeId || providerHomeId) : providerHomeId;
-      const resumeSource = resumedAgentSource(normalizedProvider, sessionId, resolvedProviderHomeId);
-      const startResult = agentManager.startAgent(command, workingDirectory, (agentId, error) => {
-        if (error) {
-          resolve({ error, status: 400 });
-          return;
-        }
-
-        if (!agentId) {
-          resolve({ error: 'failed to resume agent session', status: 500 });
-          return;
-        }
-
-        resolve({ agentId, projectWorkspace });
-      }, {
-        wantsMain: resumeAsMain,
-        task: savedSession?.task || (session ? session.title : ''),
-        workflowTemplate: savedSession?.workflowTemplate || '',
-        customTitle: hasRequestedCustomTitle
-          ? (typeof options.customTitle === 'string' ? options.customTitle : '')
-          : (savedSession?.customTitle || ''),
-        customTitleExplicit: hasRequestedCustomTitle,
-        requiredCliVersion: normalizedProvider === 'codex' && session ? session.cliVersion : '',
-        projectWorkspace,
-        source: shouldFork ? resumeSource.replace('-history:', '-history-fork:') : resumeSource,
-        agentRuntimeMode: ['chat', 'acp'].includes(options.agentRuntimeMode) ? 'chat' : 'terminal',
-        acpHistoryMode: options.acpHistoryMode === 'resume' ? 'resume' : 'load',
-        providerHomeId: resolvedProviderHomeId,
-        providerHomePath: session ? (session.providerHomePath || '') : '',
-        providerSessionTitle: session?.title || savedSession?.providerSessionTitle || '',
-        persistentSessionId: savedSession?.id || '',
-        pinned: savedSession?.pinned === true,
-        projectOrder: savedSession?.projectOrder,
-        pinnedOrder: savedSession?.pinnedOrder,
-        attentionSeq: savedAttentionSeq,
-        readAttentionSeq: savedReadAttentionSeq,
-        attentionUpdatedAt: savedSession?.attentionUpdatedAt,
-        readAttentionAt: savedSession?.readAttentionAt,
-        attentionReason: savedSession?.attentionReason,
-        attentionOutputEpoch: savedSession?.attentionOutputEpoch,
-        attentionOutputSeq: savedSession?.attentionOutputSeq,
-        readOutputEpoch: savedSession?.readOutputEpoch,
-        readOutputSeq: savedSession?.readOutputSeq,
-        autoReadInitialAttention: options.autoReadInitialAttention === true
-          && savedAttentionSeq <= savedReadAttentionSeq,
-        preserveProviderSessionProfile: normalizedProvider === 'codex',
-      });
-      Promise.resolve(startResult).catch((error) => {
-        resolve({ error: error.message || 'failed to resume agent session', status: 500 });
-      });
-    });
-  })();
-  pendingResumeStarts.set(pendingResumeId, startPromise);
-
-  const result = await startPromise;
-  if (pendingResumeStarts.get(pendingResumeId) === startPromise) {
-    pendingResumeStarts.delete(pendingResumeId);
-  }
-
-  if (result.error) {
-    return result;
-  }
-
-  if (shouldRememberMainPageSession) rememberMainPageAgentSession(normalizedProvider, sessionId, providerHomeId);
-  if (result.reused) {
-    return {
-      agentId: result.agentId,
-      projectWorkspace: result.projectWorkspace || '',
-      reused: true,
-      ...(result.claimed ? { claimed: true } : {}),
-    };
-  }
-  return {
-    agentId: result.agentId,
-    projectWorkspace: result.projectWorkspace || '',
-  };
-}
-
-async function canonicalProjectWorkspace(workspace) {
-  const candidate = configManager.expandWorkspacePath(String(workspace || '').trim());
-  if (!candidate) return '';
-  const pending = pendingProjectWorkspaceResolutions.get(candidate);
-  if (pending) return pending;
-
-  const resolution = (async () => {
-    try {
-      const worktree = await inspectGitWorktree(candidate);
-      if (worktree?.workspace) return worktree.workspace;
-    } catch (error) {
-      console.warn('Failed to resolve project worktree:', candidate, error?.message || error);
-    }
-    try {
-      return fs.realpathSync(path.resolve(candidate));
-    } catch {
-      return candidate;
-    }
-  })();
-  pendingProjectWorkspaceResolutions.set(candidate, resolution);
-  try {
-    return await resolution;
-  } finally {
-    if (pendingProjectWorkspaceResolutions.get(candidate) === resolution) {
-      pendingProjectWorkspaceResolutions.delete(candidate);
-    }
-  }
-}
-
-async function startResumedAgentSession(req, res, provider, rawSessionId) {
-  const shouldFork = req.body && req.body.fork === true;
-  const requestedAsMain = req.body && req.body.asMain === true && !shouldFork;
-  const allowUnarchiveArchived = req.body && req.body.unarchiveArchived === true && !shouldFork && !requestedAsMain;
-  const providerHomeId = req.body && typeof req.body.providerHomeId === 'string'
-    ? req.body.providerHomeId
-    : '';
-  const sessionKey = mainPageAgentSessionKey(provider, rawSessionId, providerHomeId);
-  const mainPageSessionWasRemembered = !shouldFork
-    && !requestedAsMain
-    && configManager.getMainPageSessionKeys().includes(sessionKey);
-  if (
-    req.body
-    && Object.prototype.hasOwnProperty.call(req.body, 'customTitle')
-    && typeof req.body.customTitle !== 'string'
-  ) {
-    res.status(400).json({ error: 'customTitle must be a string' });
-    return;
-  }
-  const result = await resumeAgentSessionById(provider, rawSessionId, {
-    fork: shouldFork,
-    asMain: requestedAsMain,
-    allowUnarchiveArchived,
-    providerHomeId,
-    ...(req.body && Object.prototype.hasOwnProperty.call(req.body, 'customTitle')
-      ? { customTitle: req.body.customTitle }
-      : {}),
-    agentRuntimeMode: req.body && ['chat', 'acp'].includes(req.body.agentRuntimeMode) ? 'chat' : 'terminal',
-    acpHistoryMode: req.body && req.body.acpHistoryMode === 'resume' ? 'resume' : 'load',
-  });
-
-  if (result.error) {
-    res.status(result.status || 400).json({ error: result.error });
-    return;
-  }
-
-  let projectMembership = {
-    projectWorkspaces: configManager.getSettings().projectWorkspaces || [],
-    pinnedProjectWorkspaces: configManager.getSettings().pinnedProjectWorkspaces || [],
-  };
-  try {
-    if (!requestedAsMain && result.projectWorkspace) {
-      projectMembership = configManager.mountProjectWorkspace(result.projectWorkspace);
-    }
-  } catch (error) {
-    let rollbackError = '';
-    if (!result.reused) {
-      try {
-        const rollback = await agentManager.archiveAgent(result.agentId, {
-          reason: 'project-mount-failed',
-          recordHistory: false,
-          requireEngineExit: true,
-          scheduleProviderArchive: false,
-        });
-        if (rollback?.error) rollbackError = rollback.error;
-      } catch (cleanupError) {
-        rollbackError = cleanupError?.message || String(cleanupError);
-      }
-    }
-    if (!mainPageSessionWasRemembered && !rollbackError) {
-      forgetMainPageAgentSession(provider, rawSessionId, providerHomeId || 'default');
-    }
-    broadcastState();
-    const mountError = error.message || 'Failed to create Project';
-    res.status(500).json({
-      error: rollbackError
-        ? `${mountError}. Rollback failed: ${rollbackError}`
-        : mountError,
-      ...(rollbackError ? { rollbackError } : {}),
-    });
-    return;
-  }
-  broadcastState();
-  if (result.reused) {
-    res.status(200).json({
-      agentId: result.agentId,
-      ...(result.projectWorkspace ? { projectWorkspace: result.projectWorkspace } : {}),
-      projectWorkspaces: projectMembership.projectWorkspaces,
-      pinnedProjectWorkspaces: projectMembership.pinnedProjectWorkspaces,
-      reused: true,
-      ...(result.claimed ? { claimed: true } : {}),
-      ...(result.pending ? { pending: true } : {}),
-    });
-    return;
-  }
-
-  res.status(201).json({
-    agentId: result.agentId,
-    ...(result.projectWorkspace ? { projectWorkspace: result.projectWorkspace } : {}),
-    projectWorkspaces: projectMembership.projectWorkspaces,
-    pinnedProjectWorkspaces: projectMembership.pinnedProjectWorkspaces,
-  });
-}
-
-async function autoResumeMainPageAgentSessions() {
-  if (typeof agentManager.whenRecovered === 'function') {
-    await agentManager.whenRecovered();
-  }
-
-  const sessions = mainPageAgentSessionsToAutoResume(configManager.getSettings());
-  if (sessions.length === 0) return;
-
-  let knownSessions;
-  try {
-    knownSessions = await agentSessionsCache.get(
-      JSON.stringify(configManager.getSettings().agentHomes || {}),
-      { maxAgeMs: INTERACTIVE_REFRESH_CACHE_MAX_AGE_MS }
-    );
-  } catch (error) {
-    console.warn('Failed to load Agent session catalog for auto-resume:', error && (error.message || error));
-    return;
-  }
-  const knownSessionByKey = new Map(knownSessions.map(session => [
-    mainPageAgentSessionKey(session.provider, session.id, session.providerHomeId || 'default'),
-    session,
-  ]));
-
-  let resumedCount = 0;
-  for (const session of sessions) {
-    try {
-      const sessionDetails = knownSessionByKey.get(mainPageAgentSessionKey(
-        session.provider,
-        session.sessionId,
-        session.providerHomeId || 'default'
-      ));
-      if (!sessionDetails) {
-        console.warn('Dropping stale main-page session from auto-resume:', session.provider, session.sessionId);
-        forgetMainPageAgentSession(session.provider, session.sessionId, session.providerHomeId || 'default');
-        continue;
-      }
-
-      const claimingAgent = findActiveAgentClaimingSession(agentManager.getState().agents, session.provider, {
-        id: session.sessionId,
-        ...(sessionDetails || {}),
-      });
-      if (claimingAgent) {
-        continue;
-      }
-
-      const result = await resumeAgentSessionById(session.provider, session.sessionId, {
-        rememberMainPageSession: false,
-        providerHomeId: session.providerHomeId || 'default',
-        autoReadInitialAttention: true,
-      });
-      if (result.error) {
-        const message = String(result.error || '').toLowerCase();
-        if (session.provider === 'qoder' && message.includes('invalid session identifier')) {
-          console.warn('Dropping stale qoder session from auto-resume:', session.provider, session.sessionId, result.error);
-          forgetMainPageAgentSession(session.provider, session.sessionId, session.providerHomeId || 'default');
-          continue;
-        }
-        console.warn('Failed to auto-resume main page agent session:', session.provider, session.sessionId, result.error);
-      } else {
-        resumedCount += 1;
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn('Failed to auto-resume main page agent session:', session.provider, session.sessionId, message);
-    }
-  }
-
-  if (resumedCount > 0) {
-    broadcastState();
-  }
-}
-
-app.post(routePath(BASE_PATH, '/api/settings'), express.json(), async (req, res) => {
-  const settingsPatch = { ...(req.body || {}) };
-  delete settingsPatch.mainPageSessionKeys;
-  delete settingsPatch.projectWorkspaces;
-  delete settingsPatch.pinnedProjectWorkspaces;
-  const browserConfigurationKeys = [
-    'browserSource',
-    'browserExecutablePath',
-    'browserExternalCdpUrl',
-  ];
-  const changesBrowserExtension = Object.prototype.hasOwnProperty.call(settingsPatch, 'browserExtensionEnabled');
-  const changesBrowserConfiguration = browserConfigurationKeys.some(key =>
-    Object.prototype.hasOwnProperty.call(settingsPatch, key)
-  );
-  const currentSettings = configManager.getSettings();
-  const browserExtensionEnabled = settingsPatch.browserExtensionEnabled === true;
-  const desiredBrowserEnabled = changesBrowserExtension
-    ? browserExtensionEnabled
-    : currentSettings.browserExtensionEnabled === true;
-  if ((changesBrowserExtension && browserExtensionEnabled) || changesBrowserConfiguration) {
-    const desiredSelection = browserResourceManager.browserSelection({
-      ...currentSettings,
-      ...settingsPatch,
-    });
-    const probe = await browserResourceManager.probeCapability(desiredSelection);
-    if (
-      (changesBrowserConfiguration || desiredBrowserEnabled)
-      && (!probe.runtimeCapability || probe.runtimeCapability.error)
-    ) {
-      res.status(400).json({
-        error: probe.runtimeCapability?.error
-          || 'Install Farming-managed Chromium, choose a system Chromium browser, or configure a loopback external CDP endpoint',
-        code: 'BROWSER_EXECUTABLE_NOT_FOUND',
-      });
-      return;
-    }
-  }
-  if (
-    currentSettings.browserExtensionEnabled === true
-    && (
-      (changesBrowserExtension && !browserExtensionEnabled)
-      || changesBrowserConfiguration
-    )
-  ) {
-    try {
-      await browserResourceManager.stopAll();
-    } catch (error) {
-      res.status(Number(error?.status) || 500).json({
-        error: error?.message || 'Browser extension could not be disabled',
-        code: error?.code || 'BROWSER_DISABLE_FAILED',
-      });
-      return;
-    }
-  }
-  configManager.updateSettings(settingsPatch);
-  if (changesBrowserExtension || changesBrowserConfiguration) {
-    await browserResourceManager.refreshCapability();
-  }
-  agentSessionsCache.invalidate();
-  res.json({
-    success: true,
-    settings: configManager.getSettings()
-  });
-  scheduleBroadcastState();
-});
-
-app.post(routePath(BASE_PATH, '/api/themes/:themeId/set'), express.json(), (req, res) => {
-  const theme = themeManager.getTheme(req.params.themeId);
-  if (!theme) {
-    res.status(404).json({ error: 'Theme not found' });
-    return;
-  }
-  
-  configManager.updateSettings({ theme: req.params.themeId });
-  res.json({ success: true, theme: req.params.themeId });
-});
-
-app.get(routePath(BASE_PATH, '/api/themes/:themeId/settings'), (req, res) => {
-  const theme = themeManager.getTheme(req.params.themeId);
-  if (!theme) {
-    res.status(404).json({ error: 'Theme not found' });
-    return;
-  }
-  
-  const settings = themeManager.getThemeSettings(req.params.themeId);
-  res.json({ settings });
-});
-
-app.post(routePath(BASE_PATH, '/api/themes/:themeId/settings'), express.json(), (req, res) => {
-  const theme = themeManager.getTheme(req.params.themeId);
-  if (!theme) {
-    res.status(404).json({ error: 'Theme not found' });
-    return;
-  }
-  
-  const success = themeManager.updateThemeSettings(req.params.themeId, req.body);
-  if (success) {
-    res.json({ success: true, settings: themeManager.getThemeSettings(req.params.themeId) });
-  } else {
-    res.status(500).json({ error: 'Failed to update theme settings' });
-  }
-});
-
-app.get(routePath(BASE_PATH, '/api/themes/:themeId'), (req, res) => {
-  const theme = themeManager.getTheme(req.params.themeId);
-  if (!theme) {
-    res.status(404).json({ error: 'Theme not found' });
-    return;
-  }
-  
-  const css = themeManager.getThemeCSS(req.params.themeId);
-  res.json({
-    theme,
-    css
-  });
-});
-
-wss.on('connection', (ws, req) => {
-  const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-  const viewerPrefix = routePath(BASE_PATH, '/api/browsers/');
-  if (url.pathname.startsWith(viewerPrefix) && url.pathname.endsWith('/viewer')) {
-    if (authEnabled && !tokenAuth.verifyWebSocket(req)) {
-      ws.close(4001, 'Authentication required');
-      return;
-    }
-    const encodedId = url.pathname.slice(viewerPrefix.length, -'/viewer'.length);
-    try {
-      browserResourceManager.attachViewer(decodeURIComponent(encodedId), ws);
-    } catch (error) {
-      ws.close(4004, error?.message || 'Browser resource not found');
-    }
-    return;
-  }
-  if (url.pathname !== WS_PATH) {
-    ws.close(1008, 'Invalid path');
-    return;
-  }
-
-  // Verify token for WebSocket connections when auth is enabled.
-  if (authEnabled && !tokenAuth.verifyWebSocket(req)) {
-    ws.close(4001, 'Authentication required');
-    return;
-  }
-
-  console.log('Client connected');
-  ws.connectionId = crypto.randomUUID();
-
-  ws.on('message', (message) => {
-    try {
-      const data = JSON.parse(message);
-      const validation = validateClientMessage(data);
-      if (!validation.ok) {
-        ws.send(JSON.stringify({
-          type: 'protocol-error',
-          protocolVersion: PROTOCOL_VERSION,
-          requestId: typeof data?.requestId === 'string' ? data.requestId : '',
-          message: validation.error,
-        }));
-        return;
-      }
-      handleMessage(ws, data);
-    } catch (e) {
-      console.error('Failed to parse message:', e);
-      ws.send(JSON.stringify({
-        type: 'protocol-error',
-        protocolVersion: PROTOCOL_VERSION,
-        requestId: '',
-        message: 'message must be valid JSON',
-      }));
-    }
-  });
-  
-  ws.on('close', () => {
-    clearWorkspaceFileWatch(ws);
-    console.log('Client disconnected');
-  });
-  
-  ws.send(JSON.stringify({
-    type: 'protocol-hello',
-    protocolVersion: PROTOCOL_VERSION,
-    minProtocolVersion: MIN_PROTOCOL_VERSION,
-  }));
-  sendState(ws);
-});
-
-const MAIN_AGENT_RESTART_COMMANDS = new Set(['codex', 'claude', 'opencode', 'qoder', 'bash', 'zsh']);
-
-function normalizeMainAgentRestartCommand(command) {
-  const normalized = String(command || '').trim();
-  return MAIN_AGENT_RESTART_COMMANDS.has(normalized) ? normalized : '';
-}
-
-function restartMainAgent(ws, command) {
-  const normalizedCommand = normalizeMainAgentRestartCommand(command);
-  if (!normalizedCommand) {
-    ws.send(JSON.stringify({ type: 'error', message: 'Unsupported Main Agent restart command' }));
-    return;
-  }
-
-  void (async () => {
-    try {
-      const state = agentManager.getState();
-      const currentMain = state.agents.find(agent => (
-        agent.id === state.mainAgentId || agent.isMain === true
-      ));
-      if (currentMain) {
-        const killed = await agentManager.killAgent(currentMain.id);
-        if (killed?.error) {
-          ws.send(JSON.stringify({ type: 'error', message: killed.error }));
-          return;
-        }
-      }
-
-      await agentManager.startAgent(normalizedCommand, null, (agentId, error) => {
-        if (error) {
-          ws.send(JSON.stringify({ type: 'error', message: error }));
-        } else if (agentId) {
-          ws.agentId = agentId;
-          broadcastState();
-          ws.send(JSON.stringify({ type: 'agent-started', agentId }));
-        }
-      }, {
-        wantsMain: true
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Failed to restart Main Agent';
-      ws.send(JSON.stringify({ type: 'error', message }));
-      broadcastState();
-    }
-  })();
-}
-
-async function killAgentFromMessage(ws, agentId, options = {}) {
-  try {
-    const requested = await agentManager.requestKillAgent(agentId, {
-      acknowledgeUnprovenAcpExit: options.acknowledgeUnprovenAcpExit === true,
-    });
-    const result = requested.result;
-    if (result?.error) {
-      ws.send(JSON.stringify({ type: 'error', message: result.error }));
-    } else if (result?.accepted) {
-      ws.send(JSON.stringify({ type: 'agent-delete-accepted', ...result }));
-      void requested.completion.then(completed => {
-        if (completed?.error && ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: 'error', message: completed.error }));
-        }
-      }).catch(error => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({
-            type: 'error',
-            message: error instanceof Error ? error.message : 'Failed to stop Agent',
-          }));
-        }
-      }).finally(() => broadcastState());
-    }
-  } catch (error) {
-    ws.send(JSON.stringify({
-      type: 'error',
-      message: error instanceof Error ? error.message : 'Failed to stop Agent',
-    }));
-  } finally {
-    broadcastState();
-  }
-}
-
-async function sendInputMessage(ws, data) {
-  const targetAgentId = resolveInputTargetAgentId(ws, data);
-  if (!targetAgentId) return;
-
-  const inputParts = inputPartsFromMessage(data);
-  if (inputParts.length === 0) return;
-  await agentManager.sendInput(targetAgentId, inputParts);
-}
-
-async function sendComposerInputMessage(ws, data) {
-  const targetAgentId = resolveInputTargetAgentId(ws, data);
-  const requestId = typeof data.requestId === 'string' ? data.requestId.trim() : '';
-  const responseAgentId = targetAgentId || (typeof data.agentId === 'string' ? data.agentId : '');
-  const respond = (accepted, message = '', uncertain = false) => {
-    if (!requestId || !responseAgentId) return;
-    ws.send(JSON.stringify({
-      type: 'composer-input-result',
-      requestId,
-      agentId: responseAgentId,
-      accepted,
-      ...(message ? { message } : {}),
-      ...(uncertain ? { uncertain: true } : {}),
-    }));
-  };
-  const message = typeof data.message === 'string' ? data.message : '';
-  if (!/^[A-Za-z0-9._:-]{1,160}$/.test(requestId)) {
-    if (responseAgentId) {
-      ws.send(JSON.stringify({
-        type: 'composer-input-result',
-        requestId: requestId || 'invalid-request',
-        agentId: responseAgentId,
-        accepted: false,
-        message: 'Structured Composer input requires a valid requestId',
-      }));
-    }
-    return;
-  }
-  const content = [];
-  if (message.trim()) content.push({ type: 'text', text: message });
-  const attachmentsRoot = path.resolve(imageAttachmentsDir());
-  const attachments = Array.isArray(data.attachments) ? data.attachments.slice(0, 8) : [];
-  for (const attachment of attachments) {
-    if (!['image', 'audio'].includes(attachment?.kind) || typeof attachment.path !== 'string') continue;
-    const filePath = path.resolve(attachment.path);
-    if (!filePath.startsWith(`${attachmentsRoot}${path.sep}`)) continue;
-    const mimeType = typeof attachment.type === 'string' && attachment.kind === 'image' && /^image\/(?:png|jpe?g|gif|webp)$/i.test(attachment.type)
-      ? attachment.type.toLowerCase()
-      : (typeof attachment.type === 'string' && attachment.kind === 'audio' && Object.hasOwn(AUDIO_ATTACHMENT_EXTENSIONS, attachment.type.toLowerCase())
-        ? attachment.type.toLowerCase()
-        : '');
-    if (!mimeType) continue;
-    try {
-      const data = await fs.promises.readFile(filePath);
-      if (data.length === 0 || data.length > 12 * 1024 * 1024) continue;
-      content.push({
-        type: attachment.kind,
-        data: data.toString('base64'),
-        mimeType,
-        path: filePath,
-        uri: pathToFileURL(filePath).href,
-      });
-    } catch {
-      // The text fallback already explains failed or unavailable uploads.
-    }
-  }
-  if (!targetAgentId || content.length === 0) {
-    respond(false, 'Composer message is empty');
-    return;
-  }
-  const targetAgent = agentManager.getState().agents.find(agent => agent.id === targetAgentId);
-  const structuredRuntime = targetAgent && runtimeKind(targetAgent) !== 'terminal';
-  if (!structuredRuntime) {
-    const error = 'Terminal Composer input requires the active terminal owner';
-    if (requestId) respond(false, error);
-    else ws.send(JSON.stringify({ type: 'error', message: error }));
-    return;
-  }
-  try {
-    await agentManager.sendComposerMessage(targetAgentId, content, { requestId });
-    respond(true);
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to send Composer message';
-    if (requestId) respond(false, message, error?.uncertain === true);
-    else ws.send(JSON.stringify({ type: 'error', message }));
-  }
-}
-
-function handleMessage(ws, data) {
-  switch (data.type) {
-    case 'protocol-hello':
-      if (!protocolCompatible(data.protocolVersion)) {
-        ws.close(4002, `Unsupported Farming protocol version ${data.protocolVersion}`);
-        return;
-      }
-      ws.protocolVersion = data.protocolVersion;
-      break;
-    case 'start-agent': {
-      const workspace = data.workspace || null;
-      void (async () => {
-        const projectWorkspace = data.asMain === true
-          ? ''
-          : await canonicalProjectWorkspace(
-            typeof data.projectWorkspace === 'string' && data.projectWorkspace.trim()
-              ? data.projectWorkspace
-              : workspace
-          );
-        agentManager.startAgent(data.command, workspace, (agentId, error) => {
-          if (error) {
-            ws.send(JSON.stringify({ type: 'error', message: error }));
-          } else if (agentId) {
-            void (async () => {
-              try {
-                if (projectWorkspace) configManager.mountProjectWorkspace(projectWorkspace);
-              } catch (mountError) {
-                let rollbackError = '';
-                try {
-                  const rollback = await agentManager.archiveAgent(agentId, {
-                    reason: 'project-mount-failed',
-                    recordHistory: false,
-                    requireEngineExit: true,
-                    scheduleProviderArchive: false,
-                  });
-                  if (rollback?.error) rollbackError = rollback.error;
-                } catch (cleanupError) {
-                  rollbackError = cleanupError?.message || String(cleanupError);
-                }
-                broadcastState();
-                const errorMessage = mountError.message || 'Failed to create Project';
-                ws.send(JSON.stringify({
-                  type: 'error',
-                  message: rollbackError
-                    ? `${errorMessage}. Rollback failed: ${rollbackError}`
-                    : errorMessage,
-                }));
-                return;
-              }
-              ws.agentId = agentId;
-              broadcastState();
-              ws.send(JSON.stringify({ type: 'agent-started', agentId }));
-            })().catch(callbackError => {
-              console.warn('Failed to finish started Agent transition:', agentId, callbackError?.message || callbackError);
-            });
-          }
-        }, {
-          wantsMain: data.asMain === true,
-          projectWorkspace,
-          task: typeof data.task === 'string' ? data.task : '',
-          workflowTemplate: typeof data.workflowTemplate === 'string' ? data.workflowTemplate : '',
-          customTitle: typeof data.customTitle === 'string' ? data.customTitle : '',
-          createRequestId: typeof data.requestId === 'string' ? data.requestId : '',
-          codexApprovalMode: typeof data.codexApprovalMode === 'string' ? data.codexApprovalMode : undefined,
-          agentRuntimeMode: ['json', 'acp', 'chat'].includes(data.agentRuntimeMode) ? data.agentRuntimeMode : 'terminal',
-          acpHistoryMode: data.acpHistoryMode === 'resume' ? 'resume' : 'load',
-          providerHomeId: typeof data.providerHomeId === 'string' ? data.providerHomeId : '',
-          ...(Array.isArray(data.additionalDirectories) ? { additionalDirectories: data.additionalDirectories } : {}),
-          ...(Array.isArray(data.mcpServers) ? { mcpServers: data.mcpServers } : {}),
-          ...(data.dangerouslySkipPermissions === true ? { dangerouslySkipPermissions: true } : {}),
-        });
-      })().catch(error => {
-        ws.send(JSON.stringify({
-          type: 'error',
-          message: error.message || 'Failed to resolve Project workspace',
-        }));
-      });
-      break;
-    }
-    case 'input':
-      {
-        void sendInputMessage(ws, data);
-      }
-      break;
-
-    case 'composer-input':
-      {
-        void sendComposerInputMessage(ws, data);
-      }
-      break;
-
-    case 'acp-permission-response':
-      try {
-        agentManager.respondToAcpPermission(
-          data.agentId,
-          data.requestId,
-          data.optionId,
-          data.cancelled === true
-        );
-      } catch (error) {
-        ws.send(JSON.stringify({
-          type: 'error',
-          message: error && error.message ? error.message : 'Failed to respond to ACP permission',
-        }));
-      }
-      break;
-
-    case 'interrupt-agent':
-      if (data.agentId) {
-        void agentManager.interruptAgent(data.agentId);
-      }
-      break;
-      
-    case 'focus-agent':
-      ws.focusedAgentId = data.agentId;
-      if (data.streamScope === 'focused' || data.streamScope === 'all') {
-        ws.streamScope = data.streamScope;
-      }
-      if (data.previewScope === 'none' || data.previewScope === 'focused' || data.previewScope === 'all') {
-        ws.previewScope = data.previewScope;
-      }
-      if (data.refreshState === true) {
-        sendState(ws);
-      }
-      break;
-
-    case 'resize-agent':
-      if (data.agentId && Number.isFinite(data.cols) && Number.isFinite(data.rows)) {
-        agentManager.requestAgentSessionResize(data.agentId, data.cols, data.rows);
-      }
-      break;
-
-    case 'clear-terminal':
-      if (data.agentId) void agentManager.clearAgentSessionBuffer(data.agentId);
-      break;
-
-    case 'watch-workspace-files':
-      watchWorkspaceFiles(ws, data);
-      break;
-
-    case 'unwatch-workspace-files':
-      clearWorkspaceFileWatch(ws, data.agentId);
-      break;
-      
-    case 'kill-agent':
-      void killAgentFromMessage(ws, data.agentId, {
-        acknowledgeUnprovenAcpExit: data.acknowledgeUnprovenAcpExit === true,
-      });
-      break;
-
-    case 'restart-main-agent':
-      restartMainAgent(ws, data.command);
-      break;
-      
-    default:
-      console.log('Unknown message type:', data.type);
-  }
-}
-
-const { resolveInputTargetAgentId } = require('./input-routing');
-
-function sendWorkspaceFileWatchError(ws, error) {
-  if (ws.readyState !== WebSocket.OPEN) return;
-  const message = error instanceof WorkspaceFileError ? error.message : 'failed to watch workspace files';
-  ws.send(JSON.stringify({ type: 'error', message }));
-}
-
-function isCurrentWorkspaceFileWatch(ws, agentId, record) {
-  return Boolean(
-    !record.cancelled
-    && ws.workspaceFileUnsubscribes?.get(agentId) === record
-  );
-}
-
-function closeWorkspaceFileWatchRecord(record) {
-  record.cancelled = true;
-  if (!record.unsubscribe) return;
-  Promise.resolve(record.unsubscribe()).catch((error) => {
-    console.error('Failed to clear workspace file watch:', error);
-  });
-}
-
-function clearWorkspaceFileWatch(ws, agentId = null) {
-  const watches = ws.workspaceFileUnsubscribes;
-  if (!watches) return;
-
-  const entries = agentId
-    ? [[agentId, watches.get(agentId)]]
-    : Array.from(watches.entries());
-
-  entries.forEach(([watchedAgentId, record]) => {
-    if (!record) return;
-    if (watches.get(watchedAgentId) === record) watches.delete(watchedAgentId);
-    closeWorkspaceFileWatchRecord(record);
-  });
-
-  if (watches.size === 0) {
-    ws.workspaceFileUnsubscribes = null;
-  }
-}
-
-async function watchWorkspaceFiles(ws, data) {
-  try {
-    if (!data.agentId) {
-      throw new WorkspaceFileError('agentId is required', 400);
-    }
-    if (!ws.workspaceFileUnsubscribes) {
-      ws.workspaceFileUnsubscribes = new Map();
-    }
-    const watches = ws.workspaceFileUnsubscribes;
-    const existing = watches.get(data.agentId);
-    if (existing) {
-      const watching = await existing.ready;
-      if (watching && isCurrentWorkspaceFileWatch(ws, data.agentId, existing) && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({
-          type: 'workspace-file-watch',
-          agentId: data.agentId,
-          watching: true,
-        }));
-      }
-      return;
-    }
-
-    const root = resolveWorkspaceRoot(agentManager, data.agentId);
-    const record = {
-      cancelled: false,
-      unsubscribe: null,
-      ready: null,
-    };
-    record.ready = (async () => {
-      const unsubscribe = await workspaceFileService.subscribe(root, (event) => {
-        if (!isCurrentWorkspaceFileWatch(ws, data.agentId, record) || ws.readyState !== WebSocket.OPEN) return;
-        ws.send(JSON.stringify({
-          type: 'workspace-file-event',
-          event: {
-            agentId: data.agentId,
-            ...event,
-          },
-        }));
-      });
-      record.unsubscribe = unsubscribe;
-      if (!isCurrentWorkspaceFileWatch(ws, data.agentId, record) || ws.readyState !== WebSocket.OPEN) {
-        closeWorkspaceFileWatchRecord(record);
-        return false;
-      }
-      return true;
-    })();
-    watches.set(data.agentId, record);
-    try {
-      const watching = await record.ready;
-      if (watching && isCurrentWorkspaceFileWatch(ws, data.agentId, record) && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({
-          type: 'workspace-file-watch',
-          agentId: data.agentId,
-          watching: true,
-        }));
-      }
-    } catch (error) {
-      if (watches.get(data.agentId) === record) watches.delete(data.agentId);
-      closeWorkspaceFileWatchRecord(record);
-      if (watches.size === 0 && ws.workspaceFileUnsubscribes === watches) {
-        ws.workspaceFileUnsubscribes = null;
-      }
-      throw error;
-    }
-  } catch (error) {
-    sendWorkspaceFileWatchError(ws, error);
-  }
-}
-
-function buildStatePayload() {
-  const state = agentManager.getState();
-  const settings = configManager.getSettings();
-  return {
-    ...state,
-    agents: state.agents.map(agent => ({
-      ...agent,
-      workspaceRootId: rootIdForPath(agent.projectWorkspace || agent.gitWorktree?.workspace || agent.cwd),
-    })),
-    workspaceRoots: workspaceRootRegistry.list(),
-    mainPageSessionKeys: typeof configManager.getMainPageSessionKeys === 'function'
-      ? configManager.getMainPageSessionKeys()
-      : (Array.isArray(settings.mainPageSessionKeys) ? settings.mainPageSessionKeys : []),
-    projectWorkspaces: settings.projectWorkspaces || [],
-    pinnedProjectWorkspaces: settings.pinnedProjectWorkspaces || [],
-  };
-}
-
-function sendState(ws) {
-  const state = buildStatePayload();
-  ws.send(JSON.stringify({ type: 'state', state }));
-  agentManager.getPreviewPayloads().forEach((preview) => {
-    sendPreview(ws, preview);
-  });
-}
-
-function previewForClient(preview, client) {
-  if (!preview || !client || client.focusedAgentId !== preview.agentId || !preview.previewSnapshot) {
-    return preview;
-  }
-  // The active terminal is hydrated from its authoritative session-view and
-  // receives live session-output. Sending its sidebar snapshot again adds a
-  // large, unrelated React update to every keystroke in a full-screen TUI.
-  return {
-    ...preview,
-    previewSnapshot: null,
-  };
-}
-
-function sendPreview(ws, preview) {
-  ws.send(JSON.stringify({
-    type: 'session-preview',
-    preview: previewForClient(preview, ws),
-  }));
-}
-
-const STATE_BROADCAST_INTERVAL_MS = 120;
-const PREVIEW_BROADCAST_INTERVAL_MS = 500;
-const SESSION_STREAM_BROADCAST_INTERVAL_MS = 33;
-const AGENT_ACTIVITY_BROADCAST_DELAY_MS = SESSION_STREAM_BROADCAST_INTERVAL_MS;
-const MAX_SESSION_STREAM_CLIENT_BUFFERED_AMOUNT = 4 * 1024 * 1024;
-let stateBroadcastTimer = null;
-let lastStateBroadcastAt = 0;
-const pendingPreviewBroadcasts = new Map();
-const pendingAgentActivityBroadcasts = new Map();
-const pendingAgentUpdates = new Map();
-const pendingSessionStreams = new Map();
-let sessionStreamBroadcastTimer = null;
-let lastSessionStreamBroadcastAt = 0;
-
-function broadcastState() {
-  lastStateBroadcastAt = Date.now();
-  stateBroadcastTimer = null;
-  const state = buildStatePayload();
-  const message = JSON.stringify({ type: 'state', state });
-  wss.clients.forEach(client => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(message);
-    }
-  });
-}
-
-function scheduleBroadcastState() {
-  const now = Date.now();
-  const elapsed = now - lastStateBroadcastAt;
-
-  if (elapsed >= STATE_BROADCAST_INTERVAL_MS) {
-    broadcastState();
-    return;
-  }
-
-  if (stateBroadcastTimer) {
-    return;
-  }
-
-  stateBroadcastTimer = setTimeout(() => {
-    broadcastState();
-  }, STATE_BROADCAST_INTERVAL_MS - elapsed);
-}
-
-function broadcastSessionPreview(preview) {
-  wss.clients.forEach((client) => {
-    const previewAllowed = client.previewScope !== 'none'
-      && (client.previewScope !== 'focused' || client.focusedAgentId === preview.agentId);
-    if (client.readyState === WebSocket.OPEN && previewAllowed) {
-      sendPreview(client, preview);
-    }
-  });
-}
-
-function schedulePreviewBroadcast(preview) {
-  const agentId = preview && preview.agentId;
-  if (!agentId) {
-    broadcastSessionPreview(preview);
-    return;
-  }
-
-  const now = Date.now();
-  const entry = pendingPreviewBroadcasts.get(agentId) || {
-    lastAt: 0,
-    timer: null,
-    preview: null,
-  };
-  entry.preview = preview;
-
-  const elapsed = now - entry.lastAt;
-  if (elapsed >= PREVIEW_BROADCAST_INTERVAL_MS) {
-    if (entry.timer) {
-      clearTimeout(entry.timer);
-      entry.timer = null;
-    }
-    entry.lastAt = now;
-    const latest = entry.preview;
-    entry.preview = null;
-    pendingPreviewBroadcasts.set(agentId, entry);
-    broadcastSessionPreview(latest);
-    return;
-  }
-
-  if (!entry.timer) {
-    entry.timer = setTimeout(() => {
-      entry.timer = null;
-      entry.lastAt = Date.now();
-      const latest = entry.preview;
-      entry.preview = null;
-      pendingPreviewBroadcasts.set(agentId, entry);
-      if (latest) {
-        broadcastSessionPreview(latest);
-      }
-    }, PREVIEW_BROADCAST_INTERVAL_MS - elapsed);
-  }
-
-  pendingPreviewBroadcasts.set(agentId, entry);
-}
-
-agentManager.onUpdate(() => {
-  scheduleBroadcastState();
-});
-
-agentManager.on('provider-session-updated', () => {
-  agentSessionsCache.invalidate();
-  scheduleBroadcastState();
-});
-
-function broadcastAgentActivity(activity) {
-  const message = JSON.stringify({
-    type: 'agent-activity',
-    activity,
-  });
-  wss.clients.forEach((client) => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(message);
-    }
-  });
-}
-
-function scheduleAgentActivityBroadcast(activity) {
-  if (!activity || !activity.agentId) return;
-  const agentId = activity.agentId;
-  const existing = pendingAgentActivityBroadcasts.get(agentId);
-  if (existing) {
-    existing.activity = activity;
-    return;
-  }
-  const entry = {
-    activity,
-    timer: setTimeout(() => {
-      pendingAgentActivityBroadcasts.delete(agentId);
-      broadcastAgentActivity(entry.activity);
-    }, AGENT_ACTIVITY_BROADCAST_DELAY_MS),
-  };
-  entry.timer.unref?.();
-  pendingAgentActivityBroadcasts.set(agentId, entry);
-}
-
-agentManager.onAgentActivity(scheduleAgentActivityBroadcast);
-
-function scheduleAgentUpdate(update) {
-  const patch = sanitizeAgentUpdatePatch(update?.patch);
-  if (!update?.agentId || !patch) return;
-  const existing = pendingAgentUpdates.get(update.agentId);
-  if (existing) {
-    Object.assign(existing.patch, patch);
-    return;
-  }
-  const entry = {
-    patch,
-    timer: setTimeout(() => {
-      pendingAgentUpdates.delete(update.agentId);
-      const message = JSON.stringify({
-        type: 'agent-update',
-        update: { agentId: update.agentId, patch: entry.patch },
-      });
-      wss.clients.forEach((client) => {
-        if (client.readyState === WebSocket.OPEN) client.send(message);
-      });
-    }, AGENT_ACTIVITY_BROADCAST_DELAY_MS),
-  };
-  entry.timer.unref?.();
-  pendingAgentUpdates.set(update.agentId, entry);
-}
-
-agentManager.on('agent-update', scheduleAgentUpdate);
-
-function broadcastAgentRead(read) {
-  if (!read || !read.agentId) return;
-  const message = JSON.stringify({ type: 'agent-read', read });
-  wss.clients.forEach((client) => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(message);
-    }
-  });
-}
-
-agentManager.on('agent-read', broadcastAgentRead);
-
-function sessionStreamKey(stream) {
-  return `${stream.agentId || ''}\0${stream.sessionSource || ''}`;
-}
-
-function broadcastSessionStream(stream) {
-  const message = JSON.stringify({
-    type: 'session-output',
-    stream
-  });
-  deliverSessionStreamToClients(wss.clients, stream, {
-    openState: WebSocket.OPEN,
-    maxBufferedAmount: MAX_SESSION_STREAM_CLIENT_BUFFERED_AMOUNT,
-    message,
-  });
-}
-
-function flushSessionStreams() {
-  sessionStreamBroadcastTimer = null;
-  const streams = Array.from(pendingSessionStreams.values());
-  pendingSessionStreams.clear();
-  if (streams.length > 0) lastSessionStreamBroadcastAt = Date.now();
-  streams.forEach(broadcastSessionStream);
-}
-
-function scheduleSessionStreamBroadcast(stream) {
-  if (!stream || !stream.agentId) return;
-  const now = Date.now();
-  if (shouldBroadcastSessionStreamImmediately({
-    pendingCount: pendingSessionStreams.size,
-    lastBroadcastAt: lastSessionStreamBroadcastAt,
-    now,
-    intervalMs: SESSION_STREAM_BROADCAST_INTERVAL_MS,
-  })) {
-    lastSessionStreamBroadcastAt = now;
-    broadcastSessionStream(coalesceSessionStream(null, stream));
-    return;
-  }
-  const key = sessionStreamKey(stream);
-  const existing = pendingSessionStreams.get(key);
-  pendingSessionStreams.set(key, coalesceSessionStream(existing, stream));
-
-  if (!sessionStreamBroadcastTimer) {
-    sessionStreamBroadcastTimer = setTimeout(flushSessionStreams, SESSION_STREAM_BROADCAST_INTERVAL_MS);
-    if (typeof sessionStreamBroadcastTimer.unref === 'function') sessionStreamBroadcastTimer.unref();
-  }
-}
-
-agentManager.onSessionStream((stream) => {
-  scheduleSessionStreamBroadcast(stream);
-});
-
-agentManager.onSessionPreview((preview) => {
-  schedulePreviewBroadcast(preview);
-});
-
-agentManager.onSystemStats((systemStats) => {
-  const usageSnapshot = agentManager.getAgentUsageSnapshots();
-  const message = JSON.stringify({ 
-    type: 'system-stats', 
-    stats: {
-      ...systemStats,
-      ip: getPrimaryLocalIP(),
-      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
-    },
-    uptime: agentManager.getUptime(),
-    usageRate: {
-      windowMs: usageSnapshot.windowMs,
-      estimatedTokensPerMinute: usageSnapshot.estimatedTokensPerMinute,
-      source: usageSnapshot.source,
-    }
-  });
-  wss.clients.forEach(client => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(message);
-    }
-  });
-});
-
-let serverStarted = false;
-let terminalRuntimeCleanupPromise = null;
-
-function runTerminalRuntimeStartupCleanup() {
-  if (!terminalRuntimeCleanupPromise) {
-    terminalRuntimeCleanupPromise = cleanupTerminalRuntime({ configDir: configManager.farmingDir })
-      .catch(error => {
-        console.warn('Failed to clean terminal runtime leftovers:', error && (error.message || error));
-        return null;
-      });
-  }
-  return terminalRuntimeCleanupPromise;
-}
-
-function startServer() {
-  if (serverStarted) return server;
-  serverStarted = true;
-
-  void Promise.all([
-    runTerminalRuntimeStartupCleanup(),
-    browserRuntimeRecoveryPromise,
-  ]).finally(() => {
-    server.listen(PORT, () => {
-      const token = tokenAuth.getToken();
-      const localIPs = getLocalIPs();
-      const entryPath = BASE_PATH || '/';
-      const entrySuffix = authEnabled ? `${entryPath}?token=${token}` : entryPath;
-
-      console.log('');
-      console.log('  Farming server running on:');
-      console.log('');
-      console.log(`  Local:   http://localhost:${PORT}${entrySuffix}`);
-      localIPs.forEach(ip => {
-        console.log(`  Network: http://${ip}:${PORT}${entrySuffix}`);
-      });
-      console.log('');
-      if (authEnabled) {
-        console.log(`  Token: ${token}`);
-        const tokenInfo = tokenAuth.getTokenInfo();
-        if (tokenInfo) {
-          console.log(`  Token style: ${tokenInfo.style} (${tokenInfo.source}, ~${tokenInfo.entropyBits} bits)`);
-        }
-      } else {
-        console.log('  Token auth: disabled');
-      }
-      console.log('');
-      setTimeout(warmCodexExecutableVersionCache, 100);
-      void autoResumeMainPageAgentSessions();
-    });
-  });
-
-  return server;
-}
-
-if (require.main === module) {
-  startServer();
-}
-
-module.exports = {
-  app,
-  server,
-  wss,
-  agentManager,
-  browserResourceManager,
-  workspaceFileService,
-  handleMessage,
-  resolveCliBinDir,
-  resolveInputTargetAgentId,
-  rewriteIndexHtmlForBasePath,
-  appendIndexHtmlAssetToken,
-  startServer,
-  runTerminalRuntimeStartupCleanup,
-};