farming-code 2.2.14 → 2.2.17

package/backend/agent-manager.js

@@ -37,16 +37,15 @@ const {
   providerSupportsRuntime,
 } = require('./provider-adapters');
 const { deriveTerminalStatus } = require('./terminal-status');
-const { CodexAppServerRuntime, normalizeCodexRuntimeMode } = require('./codex-app-server-runtime');
 const { JsonCliRuntime } = require('./json-cli-runtime');
-const { AcpRuntime } = require('./acp-runtime');
+const { AcpRuntime, isCodexSteerUnavailableError } = require('./acp-runtime');
+const { chatRuntimeForProvider, isChatMode } = require('./chat-runtime');
 const { acpToolChanges, acpToolDetail, acpToolReviewChanges, acpTranscriptToolEntry } = require('./acp-transcript');
 const {
   applyCodexTerminalProfile,
   codexTerminalProfileFromOutput,
   codexTerminalProfileFromPreview,
 } = require('./codex-terminal-profile');
-const { ensureCodexAppServerHome } = require('./codex-app-server-home');
 const {
   ensureAgentOrders,
   finiteOrder,
@@ -77,6 +76,9 @@ const MISSING_ENGINE_SESSION_STARTUP_GRACE_MS = 5000;
 const MIN_TERMINAL_RESIZE_COLS = 40;
 const MIN_TERMINAL_RESIZE_ROWS = 10;
 const AGENT_DISCOVERY_CACHE_MAX_AGE_MS = 3_000;
+const UNCERTAIN_TERMINAL_STOP_TIMEOUT_MS = 5_000;
+const TERMINAL_STOP_STATE_READ_TIMEOUT_MS = 1_000;
+const TERMINAL_STOP_POLL_MS = 50;
 const SHELL_PROMPT_ENV_KEYS = [
   'PS1',
   'PS2',
@@ -89,6 +91,31 @@ const SHELL_PROMPT_ENV_KEYS = [
 ];
 const execFileAsync = promisify(execFile);
 
+function withBoundedWait(promise, timeoutMs, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+async function deletePrecreatedProviderSession(options = {}) {
+  const provider = String(options.provider || '').trim().toLowerCase();
+  const sessionId = String(options.sessionId || '').trim();
+  if (!isSafeProviderSessionId(sessionId)) throw new Error('Invalid pre-created provider session id');
+  let args = [];
+  if (provider === 'codex') args = ['delete', '--force', sessionId];
+  else if (provider === 'opencode') args = ['session', 'delete', sessionId];
+  else throw new Error(`${provider || 'Provider'} does not support pre-created session rollback`);
+  await execFileAsync(options.executable, args, {
+    cwd: options.cwd,
+    env: options.env,
+    timeout: 15_000,
+    maxBuffer: 1024 * 1024,
+  });
+}
+
 function trimSessionOutput(output) {
   const text = typeof output === 'string' ? output : '';
   return text.length > SESSION_OUTPUT_LIMIT ? text.slice(-SESSION_OUTPUT_LIMIT) : text;
@@ -177,12 +204,6 @@ function applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision,
   return true;
 }
 
-function hasResumeArg(args) {
-  return Array.isArray(args)
-    ? args.some(arg => arg === '--resume' || (typeof arg === 'string' && arg.startsWith('--resume=')))
-    : false;
-}
-
 function codexCommandContinuesSession(command) {
   const parts = parseCommand(command);
   return path.basename(parts[0] || '') === 'codex'
@@ -216,18 +237,6 @@ function agentHomeProviderForProgram(command) {
   return providerForProgram(agentProgramName(command));
 }
 
-function hasUsableCodexAppServerHome(metadata) {
-  const homePath = String(runtimeBindingOf(metadata, 'app-server')?.homePath || '').trim();
-  return Boolean(homePath) && fs.existsSync(homePath);
-}
-
-function shouldRecoverAsCodexAppServer(metadata) {
-  const provider = metadata?.providerSessionProvider || metadata?.provider || '';
-  return provider === 'codex'
-    && runtimeKind(metadata) === 'app-server'
-    && hasUsableCodexAppServerHome(metadata);
-}
-
 function isJsonCliAgent(agent) {
   return runtimeKind(agent) === 'json';
 }
@@ -236,6 +245,19 @@ function isAcpAgent(agent) {
   return runtimeKind(agent) === 'acp';
 }
 
+function normalizedComposerPrompt(message) {
+  const prompt = Array.isArray(message) ? message : [{ type: 'text', text: String(message || '') }];
+  const text = prompt
+    .filter(content => content?.type === 'text')
+    .map(content => String(content.text || ''))
+    .join('')
+    .trim();
+  if (prompt.length === 0 || (!text && !prompt.some(content => content?.type !== 'text'))) {
+    throw new Error('Composer message is empty');
+  }
+  return prompt;
+}
+
 function isShellProgram(command) {
   return ['bash', 'zsh', 'sh', 'fish'].includes(agentProgramName(command).toLowerCase());
 }
@@ -264,7 +286,6 @@ function activeCodexTerminalProfile(agent, previewText) {
     || agentHomeProviderForProgram(agent.forkCommand || agent.command || '');
   if (
     provider !== 'codex'
-    || isCodexAppServerAgent(agent)
     || isJsonCliAgent(agent)
     || isAcpAgent(agent)
     || runtimeKind(agent) !== 'terminal'
@@ -379,13 +400,23 @@ function hasAgentOutputAfterAttentionBaseline(agent) {
   return false;
 }
 
-function shouldRecoverEngineSession(metadata) {
-  if (!metadata) return false;
-  // Main Agent shells are a product session, not an ephemeral scratch shell.
-  // Keep them attached to the persistent native PTY host across server restarts.
-  if (metadata.wantsMain === true) return true;
-  if (metadata.category === 'shell') return false;
-  return !isShellProgram(metadata.forkCommand || metadata.command || '');
+function shouldRestoreAgentFromMetadata(record, mainPageSessionKeys) {
+  if (!record || record.archived === true) return false;
+  if (record.wantsMain === true) return true;
+  if (
+    record.providerSessionTemporary === true
+    || isTemporaryProviderSessionId(record.providerSessionId)
+  ) {
+    return record.visibleOnMainPage === true;
+  }
+  const provider = String(record.providerSessionProvider || record.provider || '').trim();
+  const sessionKey = record.providerSessionKey || mainPageAgentSessionKey(
+    provider,
+    record.providerSessionId,
+    record.providerHomeId || 'default'
+  );
+  if (sessionKey) return mainPageSessionKeys.has(sessionKey);
+  return record.visibleOnMainPage === true;
 }
 
 function recoveredEngineSessionId(entry, metadata = {}) {
@@ -500,10 +531,6 @@ function isRunningAgentRuntimeStatus(status) {
   return String(status || '').toLowerCase() === 'running';
 }
 
-function isCodexAppServerAgent(agent) {
-  return runtimeKind(agent) === 'app-server';
-}
-
 function isLiveEngineSessionState(sessionState) {
   return Boolean(sessionState && sessionState.status && sessionState.status !== 'exited');
 }
@@ -554,6 +581,7 @@ class AgentManager extends EventEmitter {
     );
     this.agents = new RuntimeAgentMap();
     this.mainAgentId = null;
+    this.mainAgentStartReservation = null;
     this.lastActivity = new Map();
     this.lastActivityUpdate = new Map();
     this.outputEvents = new Map(); // Map<agentId, Array<{timestamp, bytes}>> for rate tracking
@@ -567,8 +595,11 @@ class AgentManager extends EventEmitter {
     this.permissionRestartInFlight = new Map();
     this.runtimeRestartInFlight = new Map();
     this.codexSessionUnarchiveInFlight = new Map();
+    // Standard ACP session inputs may contain MCP credentials. Keep the live
+    // copy outside browser-facing Agent records; crash recovery persists it
+    // only through the private Farming session store.
+    this.acpSessionOptionsByKey = new Map();
     this.permissionRestartSuppressedAgentIds = new Set();
-    this.codexAppServerRuntime = options.codexAppServerRuntime || new CodexAppServerRuntime();
     this.jsonCliRuntime = options.jsonCliRuntime || new JsonCliRuntime();
     this.acpRuntime = options.acpRuntime || new AcpRuntime({
       ...(this.configManager?.farmingDir ? { configDir: this.configManager.farmingDir } : {}),
@@ -582,6 +613,12 @@ class AgentManager extends EventEmitter {
           }
         : {}),
     });
+    this.createProviderSessionIdentity = typeof options.createProviderSessionIdentity === 'function'
+      ? options.createProviderSessionIdentity
+      : createOptions => this.acpRuntime.createSessionIdentity(createOptions);
+    this.deleteProviderSessionIdentity = typeof options.deleteProviderSessionIdentity === 'function'
+      ? options.deleteProviderSessionIdentity
+      : deletePrecreatedProviderSession;
     this.archiveCodexSession = options.archiveCodexSession || archiveCodexSession;
     this.unarchiveCodexSession = options.unarchiveCodexSession || unarchiveCodexSession;
     this.heartbeatInterval = null;
@@ -612,7 +649,6 @@ class AgentManager extends EventEmitter {
     this.lastZombieSweepAt = 0;
     this.startHeartbeat();
     this.bindEngineEvents();
-    this.bindCodexAppServerRuntimeEvents();
     this.bindJsonCliRuntimeEvents();
     this.bindAcpRuntimeEvents();
     if (this.configManager && this.configManager.farmingDir) {
@@ -649,13 +685,14 @@ class AgentManager extends EventEmitter {
 
   bindAcpRuntimeEvents() {
     if (!this.acpRuntime || typeof this.acpRuntime.on !== 'function') return;
-    this.acpRuntime.on('agent-runtime', ({ agentId, state, error, sessionId, stopReason, pendingPermission, pendingPermissions, pendingElicitation, pendingElicitations, activeElicitations, updatedAt }) => {
+    this.acpRuntime.on('agent-runtime', ({ agentId, state, error, sessionId, stopReason, supportsSteer, pendingPermission, pendingPermissions, pendingElicitation, pendingElicitations, activeElicitations, updatedAt }) => {
       const agent = this.agents.get(agentId);
       const runtime = runtimeBindingOf(agent, 'acp');
       if (!runtime) return;
       runtime.state = state || '';
       runtime.error = error || '';
       runtime.stopReason = stopReason || '';
+      runtime.supportsSteer = supportsSteer === true;
       runtime.pendingPermission = pendingPermission || null;
       runtime.pendingPermissions = Array.isArray(pendingPermissions) ? pendingPermissions : [];
       runtime.pendingElicitation = pendingElicitation || null;
@@ -679,46 +716,6 @@ class AgentManager extends EventEmitter {
     });
   }
 
-  bindCodexAppServerRuntimeEvents() {
-    if (!this.codexAppServerRuntime || typeof this.codexAppServerRuntime.on !== 'function') return;
-    this.codexAppServerRuntime.on('agent-runtime', ({ agentId, ...patch }) => {
-      const agent = this.agents.get(agentId);
-      const runtime = runtimeBindingOf(agent, 'app-server');
-      if (!runtime) return;
-
-      if (typeof patch.threadId === 'string' && patch.threadId) {
-        runtime.threadId = patch.threadId;
-        this.providerSessionService.bindConfirmed(
-          agentId,
-          agent.providerSessionProvider || 'codex',
-          patch.threadId
-        );
-      }
-      if (typeof patch.turnId === 'string') runtime.turnId = patch.turnId;
-      if (typeof patch.state === 'string' && patch.state) runtime.state = patch.state;
-      if (typeof patch.error === 'string') runtime.error = patch.error;
-      if (typeof patch.pendingRequestId === 'string') runtime.pendingRequestId = patch.pendingRequestId;
-      if (typeof patch.pendingRequestMethod === 'string') runtime.pendingRequestMethod = patch.pendingRequestMethod;
-      if (Object.prototype.hasOwnProperty.call(patch, 'pendingRequest')) {
-        runtime.pendingRequest = patch.pendingRequest || null;
-      }
-      if (Object.prototype.hasOwnProperty.call(patch, 'notice')) {
-        runtime.notice = patch.notice || null;
-      }
-      if (Object.prototype.hasOwnProperty.call(patch, 'goal')) {
-        runtime.goal = patch.goal || null;
-      }
-      if (typeof patch.transcriptUpdatedAt === 'string') {
-        runtime.transcriptUpdatedAt = patch.transcriptUpdatedAt;
-      }
-
-      if (patch.state === 'working' || patch.state === 'waiting-for-input') {
-        this.lastActivity.set(agentId, Date.now());
-      }
-      this.emit('update');
-    });
-  }
-
   bindEngineEvents() {
     this.engineBridge.on('session-started', ({
       sessionId,
@@ -760,6 +757,9 @@ class AgentManager extends EventEmitter {
 
         this.reviveAgentRuntime(agent);
         agent.output = trimSessionOutput(agent.output + data);
+        if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
+          void this.providerSessionService.resolveTemporaryCodex(sessionId);
+        }
         const outputAt = Date.now();
         agent.lastEngineOutputAt = outputAt;
         this.lastActivity.set(sessionId, outputAt);
@@ -1055,12 +1055,6 @@ class AgentManager extends EventEmitter {
         clearPendingTerminalStartSyncCut(agent);
         if (this.permissionRestartSuppressedAgentIds.has(sessionId)) return;
 
-        // A fresh App Server thread deliberately has no CLI/PTy observer until
-        // its first turn has completed and become resumable.  Native host
-        // cleanup can still report an old/missing session id while that gap is
-        // open; it is not an exit of the App Server Agent.
-        if (isCodexAppServerAgent(agent)) return;
-
         if (stateProofAvailable === false) {
           this.providerSessionService.stop(sessionId);
           agent.status = 'dead';
@@ -1134,6 +1128,7 @@ class AgentManager extends EventEmitter {
     const persistedRecords = this.configManager && typeof this.configManager.listAgentSessionRecords === 'function'
       ? this.configManager.listAgentSessionRecords()
       : [];
+    const mainPageSessionKeys = new Set(this.getMainPageSessionKeys());
     const persistedByRuntimeAgentId = new Map(persistedRecords
       .filter(record => record && record.runtimeAgentId)
       .map(record => [record.runtimeAgentId, record]));
@@ -1144,6 +1139,11 @@ class AgentManager extends EventEmitter {
       const state = entry.state || {};
       const agentId = recoveredEngineSessionId(entry, engineMetadata);
       const persisted = persistedByRuntimeAgentId.get(agentId);
+      const desiredMetadata = persisted || engineMetadata;
+      if (!shouldRestoreAgentFromMetadata(desiredMetadata, mainPageSessionKeys)) {
+        await this.killRecoveredEngineSession(entry, engineMetadata, agentId);
+        continue;
+      }
       // The persisted runtime mode is authoritative. A PTY can outlive the
       // server long enough to appear in native-host recovery after the Agent
       // has already switched to ACP. Recovering that stale PTY first would
@@ -1162,6 +1162,7 @@ class AgentManager extends EventEmitter {
         // even briefly makes Chat/Terminal switching disappear until a later
         // provider resolver update happens to repair it.
         source: persisted.source || engineMetadata.source,
+        persistentSessionId: persisted.id || persisted.persistentSessionId || engineMetadata.persistentSessionId,
         projectWorkspace: persisted.projectWorkspace || engineMetadata.projectWorkspace,
         provider: persistedProvider || engineMetadata.provider,
         providerSessionProvider: persistedProvider || engineMetadata.providerSessionProvider,
@@ -1179,21 +1180,23 @@ class AgentManager extends EventEmitter {
         terminalInputReceived: Object.prototype.hasOwnProperty.call(persisted, 'terminalInputReceived')
           ? persisted.terminalInputReceived === true
           : engineMetadata.terminalInputReceived,
+        customTitle: Object.prototype.hasOwnProperty.call(persisted, 'customTitle')
+          ? persisted.customTitle
+          : engineMetadata.customTitle,
         ...legacyRuntimeMetadata(persisted),
         pinned: persisted.pinned === true,
         projectOrder: finiteOrder(persisted.projectOrder) ?? finiteOrder(engineMetadata.projectOrder),
         pinnedOrder: finiteOrder(persisted.pinnedOrder) ?? finiteOrder(engineMetadata.pinnedOrder),
       } : engineMetadata;
       if (!agentId || this.agents.has(agentId)) continue;
-      if (!shouldRecoverEngineSession(metadata)) {
-        await this.killRecoveredEngineSession(entry, metadata, agentId);
-        continue;
-      }
 
       const agentRecord = this.recoveredAgentRecord(agentId, entry.engineName || metadata.engineName || 'native', metadata, state);
       ensureAgentOrders(agentRecord, Array.from(this.agents.values()));
       agentRecord.lastObservedTurnActive = this.isAgentAttentionTurnActive(agentRecord);
-      this.ensurePersistentAgentSession(agentRecord);
+      this.ensurePersistentAgentSession(agentRecord, {
+        visibleOnMainPage: true,
+        archived: false,
+      });
       this.agents.set(agentId, agentRecord);
       void this.refreshAgentWorktree(agentId);
       this.lastActivity.set(agentId, state.lastActivityAt || metadata.lastActivityAt || Date.now());
@@ -1215,12 +1218,12 @@ class AgentManager extends EventEmitter {
       await this.restoreTerminalSessionsAfterRuntimeRotation(persistedRecords, runtimeRotations);
     }
 
-    await this.recoverCodexAppServerSessions();
     await this.recoverAcpSessions();
   }
 
   async restoreTerminalSessionsAfterRuntimeRotation(records, rotations) {
     const mainPageOrder = new Map(this.getMainPageSessionKeys().map((key, index) => [key, index]));
+    const mainPageSessionKeys = new Set(mainPageOrder.keys());
     const liveProviderSessions = new Set(
       [...this.agents.values()]
         .filter(agent => agent?.providerSessionProvider && agent?.providerSessionId)
@@ -1314,8 +1317,9 @@ class AgentManager extends EventEmitter {
           return (Number(right.updatedAt) || 0) - (Number(left.updatedAt) || 0);
         })
       : fallbackCandidates;
+    const desiredCandidates = candidates.filter(record => shouldRestoreAgentFromMetadata(record, mainPageSessionKeys));
 
-    if (candidates.length > 0) {
+    if (desiredCandidates.length > 0) {
       const rotationSummary = (Array.isArray(rotations) ? rotations : []).map(rotation => {
         const { serializedTerminalState, ...rest } = rotation || {};
         return {
@@ -1326,13 +1330,13 @@ class AgentManager extends EventEmitter {
         };
       });
       console.warn(
-        `Restoring ${candidates.length} Terminal session(s) after native PTY runtime rotation`,
+        `Restoring ${desiredCandidates.length} Terminal session(s) after native PTY runtime rotation`,
         rotationSummary
       );
     }
 
     let changed = false;
-    for (const record of candidates) {
+    for (const record of desiredCandidates) {
       if (record.wantsMain === true && this.mainAgentId) continue;
       const provider = String(record.providerSessionProvider || record.provider || '').trim();
       const sessionId = record.providerSessionId;
@@ -1342,6 +1346,19 @@ class AgentManager extends EventEmitter {
         record.providerHomeId || 'default'
       );
       if (sessionKey && liveProviderSessions.has(sessionKey)) continue;
+      if (
+        provider === 'codex'
+        && record.terminalInputReceived === true
+        && (
+          record.providerSessionTemporary === true
+          || isTemporaryProviderSessionId(sessionId)
+        )
+      ) {
+        console.warn(
+          `Refusing to replace Codex Terminal ${record.runtimeAgentId || sessionId} after native PTY runtime rotation without an exact resume id`
+        );
+        continue;
+      }
       const canResumeProvider = Boolean(getProviderAdapter(provider))
         && isSafeProviderSessionId(sessionId);
       const command = canResumeProvider
@@ -1435,8 +1452,12 @@ class AgentManager extends EventEmitter {
   async recoverAcpSessions() {
     if (!this.acpRuntime || !this.configManager || typeof this.configManager.listAgentSessionRecords !== 'function') return;
     const mainPageOrder = new Map(this.getMainPageSessionKeys().map((key, index) => [key, index]));
+    const mainPageSessionKeys = new Set(mainPageOrder.keys());
     const records = this.configManager.listAgentSessionRecords()
-      .filter(record => record && record.archived !== true && runtimeKind(record) === 'acp')
+      .filter(record => (
+        shouldRestoreAgentFromMetadata(record, mainPageSessionKeys)
+        && runtimeKind(record) === 'acp'
+      ))
       .sort((left, right) => {
         const leftOrder = mainPageOrder.get(left.providerSessionKey);
         const rightOrder = mainPageOrder.get(right.providerSessionKey);
@@ -1450,7 +1471,7 @@ class AgentManager extends EventEmitter {
     for (const record of records) {
       const agentId = String(record.runtimeAgentId || '').trim();
       const provider = String(record.providerSessionProvider || record.provider || '').trim();
-      const sessionId = String(record.providerSessionId || '').trim();
+      const sessionId = String(record.providerSessionId || record.codexAppServerThreadId || '').trim();
       if (!agentId || !sessionId || !providerSupportsRuntime(provider, 'acp')) continue;
       const agent = this.agents.get(agentId);
       if (!agent) {
@@ -1469,7 +1490,7 @@ class AgentManager extends EventEmitter {
     for (const record of records) {
       const agentId = String(record.runtimeAgentId || '').trim();
       const provider = String(record.providerSessionProvider || record.provider || '').trim();
-      const sessionId = String(record.providerSessionId || '').trim();
+      const sessionId = String(record.providerSessionId || record.codexAppServerThreadId || '').trim();
       const agent = this.agents.get(agentId);
       if (!agent || !sessionId || !providerSupportsRuntime(provider, 'acp')) continue;
       try {
@@ -1495,8 +1516,23 @@ class AgentManager extends EventEmitter {
           model: 'config',
           reasoningEffort: 'config',
           serviceTier: 'config',
+          additionalDirectories: Array.isArray(record.acpAdditionalDirectories) ? record.acpAdditionalDirectories : [],
+          mcpServers: Array.isArray(record.acpMcpServers) ? record.acpMcpServers : [],
         });
         agent.providerSessionId = prepared.sessionId;
+        agent.providerSessionKey = mainPageAgentSessionKey(
+          provider,
+          prepared.sessionId,
+          agent.providerHomeId || record.providerHomeId || 'default'
+        );
+        this.acpSessionOptionsByKey.set(agent.providerSessionKey, {
+          additionalDirectories: Array.isArray(record.acpAdditionalDirectories)
+            ? [...record.acpAdditionalDirectories]
+            : [],
+          mcpServers: Array.isArray(record.acpMcpServers)
+            ? JSON.parse(JSON.stringify(record.acpMcpServers))
+            : [],
+        });
         agent.providerSessionTemporary = false;
         agent.providerSessionSource = `acp-${prepared.historyMode}`;
         const runtime = replaceRuntimeBinding(agent, 'acp', runtimeBindingOf(agent, 'acp'));
@@ -1520,82 +1556,6 @@ class AgentManager extends EventEmitter {
     this.emit('update');
   }
 
-  async recoverCodexAppServerSessions() {
-    if (!this.codexAppServerRuntime || !this.configManager || typeof this.configManager.listAgentSessionRecords !== 'function') return;
-    const records = this.configManager.listAgentSessionRecords();
-    for (const record of records) {
-      if (!record || record.archived === true || runtimeKind(record) !== 'app-server') continue;
-      const agentId = String(record.runtimeAgentId || '').trim();
-      const threadId = String(record.codexAppServerThreadId || record.providerSessionId || '').trim();
-      const home = String(record.codexAppServerHomePath || '').trim();
-      if (!agentId || !threadId || !home || !fs.existsSync(home)) {
-        if (record.provider === 'codex' || record.providerSessionProvider === 'codex') {
-          let agent = this.agents.get(agentId);
-          if (!agent && agentId) {
-            agent = this.recoveredAgentRecord(agentId, record.engine || 'native', record, { status: 'running' });
-            agent.persistentSessionId = record.id || '';
-          }
-          if (agent) {
-            ensureAgentOrders(agent, Array.from(this.agents.values()));
-            replaceRuntimeBinding(agent, 'terminal');
-            this.ensurePersistentAgentSession(agent);
-            this.updateEngineProviderSessionMetadata(agent);
-          }
-        }
-        continue;
-      }
-      let agent = this.agents.get(agentId);
-      if (!agent) {
-        agent = this.recoveredAgentRecord(agentId, record.engine || 'native', record, { status: 'running' });
-        ensureAgentOrders(agent, Array.from(this.agents.values()));
-        agent.persistentSessionId = record.id || '';
-        agent.engineStarted = false;
-        this.agents.set(agentId, agent);
-        void this.refreshAgentWorktree(agentId);
-        this.lastActivity.set(agentId, Date.now());
-      }
-      try {
-        // Remove a CLI observer recovered from pre-split metadata before the
-        // structured runtime reconnects to this App Server Agent.
-        await this.killRecoveredEngineSession({ engineName: agent.engineName }, record, agentId);
-        const executable = resolveCompatibleCodexExecutable('').path || resolveAgentExecutable('codex') || 'codex';
-        const binding = await this.codexAppServerRuntime.reattachAgent({
-          agentId,
-          threadId,
-          codexHome: home,
-          executable,
-          env: this.buildAgentEnv(agentId, agent),
-          cwd: agent.cwd,
-          workspaceRoot: effectiveAgentWorkspaceRoot(agent),
-          approvalMode: agent.launchPermissionMode || 'approve',
-        });
-        const runtime = runtimeBindingOf(agent, 'app-server');
-        runtime.threadId = binding.threadId;
-        runtime.state = 'idle';
-        runtime.error = '';
-        // App Server owns this runtime. It deliberately has no CLI/PTy
-        // observer, so recovery cannot create a second reader or writer.
-        agent.status = 'running';
-        agent.engineStatus = 'running';
-        agent.engineStarted = false;
-        runtime.observerDeferred = false;
-        agent.exitedAt = null;
-        this.providerSessionService.activate(agentId);
-        this.ensurePersistentAgentSession(agent);
-      } catch (error) {
-        const runtime = runtimeBindingOf(agent, 'app-server');
-        runtime.error = `Codex App Server recovery failed: ${error && (error.message || error)}`;
-        runtime.state = 'error';
-        agent.status = 'stopped';
-        agent.engineStatus = 'stopped';
-        agent.engineStarted = false;
-        agent.exitedAt = Date.now();
-        this.ensurePersistentAgentSession(agent);
-      }
-    }
-    this.emit('update');
-  }
-
   async killRecoveredEngineSession(entry, metadata, agentId) {
     if (!this.engineBridge || typeof this.engineBridge.killSession !== 'function') return;
     const engineName = entry.engineName || metadata.engineName || 'native';
@@ -1613,16 +1573,8 @@ class AgentManager extends EventEmitter {
   recoveredAgentRecord(agentId, engineName, metadata, state) {
     const wantsMain = metadata.wantsMain === true;
     const providerSessionProvider = metadata.providerSessionProvider || metadata.provider || '';
-    const recoverCodexAppServer = shouldRecoverAsCodexAppServer(metadata);
-    const persistedRuntimeKind = runtimeKind(metadata);
-    const recoveredRuntimeKind = recoverCodexAppServer
-      ? 'app-server'
-      : (persistedRuntimeKind === 'app-server' ? 'terminal' : persistedRuntimeKind);
-    const runtimeBinding = runtimeBindingFor(recoveredRuntimeKind, {
-      ...metadata,
-      codexAppServerThreadId: metadata.codexAppServerThreadId || metadata.providerSessionId || '',
-      codexCliObserverDeferred: false,
-    });
+    const providerSessionId = metadata.providerSessionId || metadata.codexAppServerThreadId || '';
+    const runtimeBinding = runtimeBindingFor(runtimeKind(metadata), metadata);
     return {
       id: agentId,
       command: metadata.forkCommand || metadata.command || '',
@@ -1648,23 +1600,21 @@ class AgentManager extends EventEmitter {
       providerSessionProvider,
       providerHomeId: metadata.providerHomeId || '',
       providerHomePath: metadata.providerHomePath || '',
-      providerSessionId: metadata.providerSessionId || '',
+      providerSessionId,
       providerSessionKey: metadata.providerSessionKey || (
-        providerSessionProvider && metadata.providerSessionId
-          ? mainPageAgentSessionKey(providerSessionProvider, metadata.providerSessionId, metadata.providerHomeId || '')
+        providerSessionProvider && providerSessionId
+          ? mainPageAgentSessionKey(providerSessionProvider, providerSessionId, metadata.providerHomeId || '')
           : ''
       ),
-      providerSessionTemporary: metadata.providerSessionTemporary === true || isTemporaryProviderSessionId(metadata.providerSessionId),
+      providerSessionTemporary: metadata.providerSessionTemporary === true || isTemporaryProviderSessionId(providerSessionId),
       providerSessionSource: metadata.providerSessionSource || '',
       providerSessionResolvedAt: metadata.providerSessionResolvedAt || null,
       providerSessionTitle: metadata.providerSessionTitle || '',
       providerSessionWorkspace: metadata.providerSessionWorkspace || '',
       terminalInputReceived: metadata.terminalInputReceived === true,
-      // Older persisted sessions predate App Server mode. Also, a Codex
-      // App Server record without its isolated runtime home is not actually
-      // attachable; recover it as terminal-owned CLI instead of leaving the
-      // UI in a split state where the pane is terminal but Composer sends to
-      // App Server.
+      // Legacy App Server records normalize to ACP at the runtime-binding
+      // boundary. Codex thread ids are valid ACP session ids, so the existing
+      // conversation remains recoverable without restarting App Server.
       runtimeBinding,
       forkedFromProviderSessionId: metadata.forkedFromProviderSessionId || '',
       restartedFromAgentId: metadata.restartedFromAgentId || '',
@@ -1735,7 +1685,6 @@ class AgentManager extends EventEmitter {
 
   shouldDeferMissingEngineSession(agent) {
     if (!agent || !isRunningAgentRuntimeStatus(agent.status)) return false;
-    if (isCodexAppServerAgent(agent)) return true;
     if (agent.engineStarted === false) return true;
     const startedAt = Number(agent.startedAt);
     return Number.isFinite(startedAt) && Date.now() - startedAt < MISSING_ENGINE_SESSION_STARTUP_GRACE_MS;
@@ -1767,7 +1716,16 @@ class AgentManager extends EventEmitter {
     if (!agent || !this.configManager || typeof this.configManager.ensureAgentSessionRecord !== 'function') {
       return '';
     }
-    const persistentSessionId = this.configManager.ensureAgentSessionRecord(agent, patch);
+    const sessionOptions = agent.providerSessionKey
+      ? this.acpSessionOptionsByKey.get(agent.providerSessionKey)
+      : null;
+    const persistentSessionId = this.configManager.ensureAgentSessionRecord(agent, {
+      ...(sessionOptions ? {
+        acpAdditionalDirectories: [...sessionOptions.additionalDirectories],
+        acpMcpServers: JSON.parse(JSON.stringify(sessionOptions.mcpServers)),
+      } : {}),
+      ...patch,
+    });
     if (persistentSessionId && !agent.persistentSessionId) {
       agent.persistentSessionId = persistentSessionId;
     }
@@ -1828,6 +1786,7 @@ class AgentManager extends EventEmitter {
       readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
       projectOrder: finiteOrder(agent.projectOrder),
       pinnedOrder: finiteOrder(agent.pinnedOrder),
+      customTitle: agent.customTitle || '',
     })).catch((error) => {
       console.warn('Failed to update provider session metadata:', error && (error.message || error));
     });
@@ -2180,11 +2139,10 @@ class AgentManager extends EventEmitter {
     }
     if (agent.providerHomePath) {
       const provider = agent.providerSessionProvider || agentHomeProviderForProgram(agent.forkCommand || agent.command);
-      const appServerHome = runtimeBindingOf(agent, 'app-server')?.homePath || '';
       applyProviderHomeEnvironment(
         env,
         provider,
-        provider === 'codex' ? (appServerHome || agent.providerHomePath) : agent.providerHomePath
+        agent.providerHomePath
       );
     }
 
@@ -2306,9 +2264,7 @@ class AgentManager extends EventEmitter {
     this.resizeDrains.clear();
     this.inputQueues.clear();
     this.codexTerminalProfileQueues.clear();
-    if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.dispose === 'function') {
-      this.codexAppServerRuntime.dispose();
-    }
+    this.acpSessionOptionsByKey.clear();
     if (this.jsonCliRuntime) {
       for (const agentId of this.agents.keys()) this.jsonCliRuntime.unregisterAgent(agentId);
     }
@@ -2395,11 +2351,103 @@ class AgentManager extends EventEmitter {
     });
   }
 
+  async stopUncertainTerminalSession(engine, agentId) {
+    if (typeof engine?.killSession !== 'function' || typeof engine?.getSessionState !== 'function') {
+      throw new Error('Session engine cannot prove an uncertain Terminal start has stopped');
+    }
+    await withBoundedWait(
+      Promise.resolve(engine.killSession(agentId)),
+      UNCERTAIN_TERMINAL_STOP_TIMEOUT_MS,
+      'Terminal kill request',
+    );
+    const deadline = Date.now() + UNCERTAIN_TERMINAL_STOP_TIMEOUT_MS;
+    while (Date.now() <= deadline) {
+      const state = await withBoundedWait(
+        Promise.resolve(engine.getSessionState(agentId)),
+        TERMINAL_STOP_STATE_READ_TIMEOUT_MS,
+        'Terminal stop-state read',
+      );
+      if (!state || ['dead', 'exited', 'stopped'].includes(String(state.status || ''))) return;
+      await new Promise(resolve => setTimeout(resolve, TERMINAL_STOP_POLL_MS));
+    }
+    throw new Error(`Terminal ${agentId} did not reach an exited state after kill`);
+  }
+
   async startAgent(command, customWorkspace, callback, options = {}) {
     if (options.wantsMain !== false && options.skipRecoveryWait !== true) {
       await this.whenRecovered();
     }
 
+    const wantsMain = options.wantsMain === true || (options.wantsMain !== false && !this.mainAgentId);
+    if (!wantsMain) {
+      return this.startAgentUnreserved(command, customWorkspace, callback, {
+        ...options,
+        wantsMain: false,
+        skipRecoveryWait: true,
+      });
+    }
+
+    if (this.mainAgentStartReservation) {
+      const outcome = await this.mainAgentStartReservation.promise;
+      if (callback) callback(outcome.agentId, outcome.error);
+      return outcome.agentId;
+    }
+
+    const existingMainStart = this.findActiveMainAgentStart();
+    if (existingMainStart) {
+      if (this.mainAgentId !== existingMainStart.id) {
+        this.mainAgentId = existingMainStart.id;
+        this.emit('update');
+      }
+      console.log('Main Agent already starting or running:', existingMainStart.id);
+      if (callback) callback(existingMainStart.id);
+      return existingMainStart.id;
+    }
+
+    let resolveReservation;
+    const reservation = {
+      promise: new Promise(resolve => {
+        resolveReservation = resolve;
+      }),
+    };
+    this.mainAgentStartReservation = reservation;
+    let outcome = null;
+    let callbackCalled = false;
+    const reservedCallback = (agentId, error) => {
+      callbackCalled = true;
+      outcome = { agentId: agentId || null, error: error || null };
+      if (callback) callback(agentId, error);
+    };
+    try {
+      const agentId = await this.startAgentUnreserved(command, customWorkspace, reservedCallback, {
+        ...options,
+        wantsMain: true,
+        skipRecoveryWait: true,
+      });
+      if (!callbackCalled) {
+        outcome = { agentId: agentId || null, error: null };
+        if (callback) callback(agentId);
+      }
+      return agentId;
+    } catch (error) {
+      if (!callbackCalled) {
+        outcome = { agentId: null, error: error && (error.message || String(error)) };
+        if (callback) callback(null, outcome.error);
+      }
+      throw error;
+    } finally {
+      resolveReservation(outcome || { agentId: null, error: 'Main Agent failed to start' });
+      if (this.mainAgentStartReservation === reservation) {
+        this.mainAgentStartReservation = null;
+      }
+    }
+  }
+
+  async startAgentUnreserved(command, customWorkspace, callback, options = {}) {
+    if (options.wantsMain !== false && options.skipRecoveryWait !== true) {
+      await this.whenRecovered();
+    }
+
     const wantsMain = options.wantsMain === true || (options.wantsMain !== false && !this.mainAgentId);
     if (wantsMain) {
       const existingMainStart = this.findActiveMainAgentStart();
@@ -2472,13 +2520,28 @@ class AgentManager extends EventEmitter {
     });
 
     const hasResumeSource = Boolean(resumedSessionFromSource(resolvedSource));
-    if (providerSessionPlan.source === 'resume-source' && hasResumeSource && !hasResumeArg(launch.args)) {
-      providerSessionPlan = buildAgentProviderSessionPlan({
-        command,
-        program,
-        args: launch.args,
-        source: 'ui',
-      });
+    const commandProviderSessionPlan = hasResumeSource
+      ? buildAgentProviderSessionPlan({
+          command,
+          program,
+          args: launch.args,
+          source: 'ui',
+        })
+      : null;
+    const commandContinuesProviderSession = commandProviderSessionPlan
+      && commandProviderSessionPlan.temporary !== true
+      && commandProviderSessionPlan.provider === providerSessionPlan.provider
+      && commandProviderSessionPlan.id === providerSessionPlan.id;
+    if (
+      providerSessionPlan.source === 'resume-source'
+      && hasResumeSource
+      && !commandContinuesProviderSession
+    ) {
+      providerSessionPlan = commandProviderSessionPlan;
+    }
+    if (providerSessionPlan.error) {
+      if (callback) callback(null, providerSessionPlan.error);
+      return null;
     }
 
     let args = providerSessionPlan.args;
@@ -2561,13 +2624,6 @@ class AgentManager extends EventEmitter {
       }
     }
     
-    const logArgs = args.map((arg, index) => (
-      index > 0 && args[index - 1] === '--append-system-prompt'
-        ? '<farming-main-agent-bootstrap>'
-        : arg
-    ));
-    console.log('Starting agent:', program, logArgs, 'workspace:', workspace, spawnProgram !== program ? `resolved: ${spawnProgram}` : '');
-    
     if (!fs.existsSync(workspace)) {
       console.log('Workspace does not exist:', workspace);
       if (callback) callback(null, `Workspace does not exist: ${workspace}`);
@@ -2629,56 +2685,34 @@ class AgentManager extends EventEmitter {
         resolvedProviderHomeId = defaultCodexHome.id || 'default';
       }
     }
-    const requestedAgentRuntimeMode = ['json', 'acp'].includes(options.agentRuntimeMode)
+    const requestedAgentRuntimeMode = ['json', 'acp', 'chat'].includes(options.agentRuntimeMode)
       ? options.agentRuntimeMode
       : 'terminal';
     // A fresh structured runtime does not need a provider CLI resume id yet:
     // ACP/JSON creates the provider session and writes the resulting id back
-    // after connecting. OpenCode is the important case here because its
-    // terminal CLI does not accept a pre-generated id for a fresh session.
-    const structuredRuntimeProvider = ['json', 'acp'].includes(requestedAgentRuntimeMode)
+    // after connecting. Fresh Terminal sessions are handled separately below.
+    const structuredRuntimeProvider = ['json', 'acp', 'chat'].includes(requestedAgentRuntimeMode)
       ? homeProvider
       : providerSessionPlan.provider;
-    const requestedCodexRuntimeMode = options.codexRuntimeMode === 'app-server' || options.codexRuntimeMode === 'cli'
-      ? options.codexRuntimeMode
-      : (this.configManager && typeof this.configManager.getCodexRuntimeMode === 'function'
-        ? this.configManager.getCodexRuntimeMode()
-        : 'cli');
-    const useCodexAppServer = providerSessionPlan.provider === 'codex'
-      && this.codexAppServerRuntime
-      && options.agentRuntimeMode !== 'acp'
-      // The deterministic browser/server fixtures are terminal-only shims,
-      // not an implementation of the Codex App Server protocol. App Server
-      // behavior has its own mock runtime test; keep these legacy PTY tests
-      // on the path they are designed to exercise.
-      && process.env.FARMING_E2E_FAKE_EXECUTABLES !== '1'
-      && normalizeCodexRuntimeMode(requestedCodexRuntimeMode) === 'app-server';
+    // `chat` is the only browser-facing structured-runtime request. Treat the
+    // retired Codex ACP launch request as that intent too, so an old client
+    // cannot create a second Codex Chat implementation.
+    const requestedChatRuntime = isChatMode(requestedAgentRuntimeMode)
+      || (requestedAgentRuntimeMode === 'acp' && homeProvider === 'codex');
+    const resolvedChatRuntime = requestedChatRuntime
+      ? chatRuntimeForProvider(homeProvider)
+      : (requestedAgentRuntimeMode === 'acp' ? 'acp' : '');
     const useJsonCli = requestedAgentRuntimeMode === 'json'
       && providerSupportsRuntime(structuredRuntimeProvider, 'json')
-      && !useCodexAppServer
       && process.env.FARMING_E2E_FAKE_EXECUTABLES !== '1';
-    const useAcp = requestedAgentRuntimeMode === 'acp'
+    const useAcp = resolvedChatRuntime === 'acp'
       && providerSupportsRuntime(structuredRuntimeProvider, 'acp')
-      && !useCodexAppServer
       && (
         process.env.FARMING_E2E_FAKE_EXECUTABLES !== '1'
         || process.env.FARMING_E2E_FAKE_ACP_AGENT === '1'
       );
     const acpGeneratedFreshSession = useAcp
       && isFreshAcpSessionSource(structuredRuntimeProvider, providerSessionPlan.source);
-    let codexAppServerHomePath = '';
-    if (useCodexAppServer) {
-      try {
-        codexAppServerHomePath = ensureCodexAppServerHome({
-          configDir: this.configManager && this.configManager.farmingDir,
-          agentId,
-          sourceHome: providerHomePath || path.join(os.homedir(), '.codex'),
-        });
-      } catch (error) {
-        if (callback) callback(null, error.message);
-        return null;
-      }
-    }
     const agentRecord = {
       id: agentId,
       command: launch.program,
@@ -2712,16 +2746,14 @@ class AgentManager extends EventEmitter {
       providerSessionTitle: typeof options.providerSessionTitle === 'string' ? options.providerSessionTitle.trim().slice(0, 160) : '',
       providerSessionWorkspace: '',
       terminalInputReceived: false,
-      runtimeBinding: useCodexAppServer
-        ? runtimeBindingFor('app-server', { state: 'connecting', homePath: codexAppServerHomePath })
-        : (useAcp
-          ? runtimeBindingFor('acp', { state: 'connecting' })
-          : (useJsonCli
-            ? runtimeBindingFor('json', {
-              state: 'idle',
-              events: Array.isArray(options.jsonCliEvents) ? options.jsonCliEvents : [],
-            })
-            : runtimeBindingFor('terminal'))),
+      runtimeBinding: useAcp
+        ? runtimeBindingFor('acp', { state: 'connecting' })
+        : (useJsonCli
+          ? runtimeBindingFor('json', {
+            state: 'idle',
+            events: Array.isArray(options.jsonCliEvents) ? options.jsonCliEvents : [],
+          })
+          : runtimeBindingFor('terminal')),
       forkedFromProviderSessionId: providerSessionPlan.forkedFromProviderSessionId || '',
       restartedFromAgentId: typeof options.restartedFromAgentId === 'string' ? options.restartedFromAgentId : '',
       restartedFromAgentIds: Array.isArray(options.restartedFromAgentIds)
@@ -2768,6 +2800,135 @@ class AgentManager extends EventEmitter {
       attentionSuppressUntil: 0
     };
 
+    let precreatedProviderSession = null;
+    if (
+      providerSessionPlan.precreate === true
+      && !useAcp
+      && !useJsonCli
+    ) {
+      const adapter = getProviderAdapter(providerSessionPlan.provider);
+      if (typeof adapter?.terminalResumeArgs !== 'function') {
+        const message = `${providerSessionPlan.provider} cannot resume a pre-created Terminal session`;
+        if (callback) callback(null, message);
+        return null;
+      }
+      try {
+        const requestedIdentityWorkspace = this.expandWorkspacePath(providerSessionPlan.identityWorkspace || '');
+        const identityWorkspace = requestedIdentityWorkspace
+          ? (path.isAbsolute(requestedIdentityWorkspace)
+            ? path.resolve(requestedIdentityWorkspace)
+            : path.resolve(workspace, requestedIdentityWorkspace))
+          : workspace;
+        let identityWorkspaceExists = false;
+        try {
+          identityWorkspaceExists = fs.statSync(identityWorkspace).isDirectory();
+        } catch {
+          identityWorkspaceExists = false;
+        }
+        if (!identityWorkspaceExists) {
+          throw new Error(`Workspace does not exist: ${identityWorkspace}`);
+        }
+        const identityEnv = this.buildAgentEnv(agentId, agentRecord);
+        const requestedAdditionalDirectories = Array.isArray(options.additionalDirectories)
+          ? options.additionalDirectories
+          : [];
+        const requestedMcpServers = Array.isArray(options.mcpServers) ? options.mcpServers : [];
+        const created = await this.createProviderSessionIdentity({
+          provider: providerSessionPlan.provider,
+          executable: spawnProgram,
+          env: identityEnv,
+          cwd: identityWorkspace,
+          providerHomeId: agentRecord.providerHomeId || 'default',
+          approvalMode: agentRecord.launchPermissionMode || 'approve',
+          model: codexModel,
+          reasoningEffort: codexReasoningEffort,
+          serviceTier: codexServiceTier,
+          additionalDirectories: requestedAdditionalDirectories,
+          mcpServers: requestedMcpServers,
+        });
+        const providerSessionId = String(created?.sessionId || '').trim();
+        if (!isSafeProviderSessionId(providerSessionId)) {
+          throw new Error(`${providerSessionPlan.provider} ACP session/new returned an invalid session id`);
+        }
+        const normalizedSessionOptions = created?.sessionRequestOptions || {
+          additionalDirectories: requestedAdditionalDirectories.map(directory => path.resolve(identityWorkspace, directory)),
+          mcpServers: JSON.parse(JSON.stringify(requestedMcpServers)),
+        };
+        args = adapter.terminalResumeArgs(args, providerSessionId, providerSessionPlan);
+        providerSessionPlan = {
+          ...providerSessionPlan,
+          id: providerSessionId,
+          precreate: false,
+          temporary: false,
+          source: 'acp-precreated',
+          args,
+        };
+        agentRecord.providerSessionId = providerSessionId;
+        agentRecord.providerSessionKey = mainPageAgentSessionKey(
+          providerSessionPlan.provider,
+          providerSessionId,
+          agentRecord.providerHomeId || 'default'
+        );
+        agentRecord.providerSessionTemporary = false;
+        agentRecord.providerSessionSource = providerSessionPlan.source;
+        agentRecord.providerSessionResolvedAt = Date.now();
+        this.acpSessionOptionsByKey.set(agentRecord.providerSessionKey, {
+          additionalDirectories: Array.isArray(normalizedSessionOptions.additionalDirectories)
+            ? [...normalizedSessionOptions.additionalDirectories]
+            : [],
+          mcpServers: Array.isArray(normalizedSessionOptions.mcpServers)
+            ? JSON.parse(JSON.stringify(normalizedSessionOptions.mcpServers))
+            : [],
+        });
+        precreatedProviderSession = {
+          provider: providerSessionPlan.provider,
+          executable: spawnProgram,
+          env: identityEnv,
+          cwd: identityWorkspace,
+          sessionId: providerSessionId,
+          sessionKey: agentRecord.providerSessionKey,
+        };
+      } catch (error) {
+        let identityRollbackError = null;
+        let identityRetainedReason = '';
+        const orphanedIdentity = error?.providerSessionIdentity;
+        if (
+          orphanedIdentity
+          && orphanedIdentity.producerStopped === true
+          && isSafeProviderSessionId(orphanedIdentity.sessionId)
+        ) {
+          try {
+            await this.deleteProviderSessionIdentity(orphanedIdentity);
+          } catch (cleanupError) {
+            identityRollbackError = cleanupError;
+          }
+        } else if (orphanedIdentity && !isSafeProviderSessionId(orphanedIdentity.sessionId)) {
+          identityRetainedReason = 'provider returned an unsafe session id; it was retained without invoking CLI rollback';
+        } else if (orphanedIdentity) {
+          identityRetainedReason = 'provider session retained because ACP producer shutdown could not be proven';
+        }
+        const baseMessage = error && error.message
+          ? error.message
+          : `Failed to create ${providerSessionPlan.provider} session identity`;
+        let message = baseMessage;
+        if (identityRollbackError) {
+          message = `${baseMessage}; provider session rollback failed: ${identityRollbackError.message || identityRollbackError}`;
+        } else if (identityRetainedReason) {
+          message = `${baseMessage}; ${identityRetainedReason}`;
+        }
+        console.error('Failed to create provider session identity:', error);
+        if (callback) callback(null, message);
+        return null;
+      }
+    }
+
+    const logArgs = args.map((arg, index) => (
+      index > 0 && args[index - 1] === '--append-system-prompt'
+        ? '<farming-main-agent-bootstrap>'
+        : arg
+    ));
+    console.log('Starting agent:', program, logArgs, 'workspace:', workspace, spawnProgram !== program ? `resolved: ${spawnProgram}` : '');
+
     ensureAgentOrders(agentRecord, Array.from(this.agents.values()));
     this.agents.set(agentId, agentRecord);
     void this.refreshAgentWorktree(agentId);
@@ -2777,50 +2938,6 @@ class AgentManager extends EventEmitter {
     this.emit('update');
 
     try {
-      if (useCodexAppServer) {
-        try {
-          const appServer = runtimeBindingOf(agentRecord, 'app-server');
-          const prepared = await this.codexAppServerRuntime.prepareAgent({
-            agentId,
-            codexHome: appServer.homePath,
-            executable: spawnProgram,
-            env: this.buildAgentEnv(agentId, agentRecord),
-            cwd: workspace,
-            workspaceRoot: projectWorkspace || workspace,
-            resumeThreadId: agentRecord.providerSessionTemporary ? '' : agentRecord.providerSessionId,
-            temporaryThreadId: agentRecord.providerSessionTemporary ? agentRecord.providerSessionId : '',
-            approvalMode: agentRecord.launchPermissionMode || (
-              this.configManager && this.configManager.getCodexApprovalMode
-                ? this.configManager.getCodexApprovalMode()
-                : 'approve'
-            ),
-            model: codexModel,
-            reasoningEffort: codexReasoningEffort,
-            serviceTier: codexServiceTier,
-            developerInstructions: wantsMain ? renderMainAgentBootstrap() : '',
-          });
-          agentRecord.providerSessionId = prepared.threadId;
-          agentRecord.providerSessionKey = mainPageAgentSessionKey(
-            'codex',
-            prepared.threadId,
-            agentRecord.providerHomeId || 'default'
-          );
-          agentRecord.providerSessionTemporary = false;
-          agentRecord.providerSessionSource = prepared.resumed ? 'app-server-resume' : 'app-server-start';
-          agentRecord.providerSessionResolvedAt = Date.now();
-          appServer.state = 'idle';
-          appServer.endpoint = prepared.endpoint;
-          appServer.threadId = prepared.threadId;
-          appServer.error = '';
-          // App Server mode has no embedded CLI observer. Its chat and
-          // lifecycle both come from the structured App Server connection.
-          appServer.observerDeferred = false;
-        } catch (error) {
-          const reason = error && error.message ? error.message : String(error);
-          throw new Error(`Codex App Server failed to start: ${reason}`, { cause: error });
-        }
-      }
-
       if (useJsonCli) {
         const jsonRuntime = runtimeBindingOf(agentRecord, 'json');
         this.jsonCliRuntime.registerAgent({
@@ -2838,6 +2955,22 @@ class AgentManager extends EventEmitter {
 
       if (useAcp) {
         const acpRuntime = runtimeBindingOf(agentRecord, 'acp');
+        const sessionOptionsKey = agentRecord.providerSessionId && !agentRecord.providerSessionTemporary
+          ? mainPageAgentSessionKey(
+              structuredRuntimeProvider,
+              agentRecord.providerSessionId,
+              agentRecord.providerHomeId || 'default'
+            )
+          : '';
+        const rememberedSessionOptions = sessionOptionsKey
+          ? this.acpSessionOptionsByKey.get(sessionOptionsKey) || {}
+          : {};
+        const additionalDirectories = Array.isArray(options.additionalDirectories)
+          ? options.additionalDirectories
+          : rememberedSessionOptions.additionalDirectories || [];
+        const mcpServers = Array.isArray(options.mcpServers)
+          ? options.mcpServers
+          : rememberedSessionOptions.mcpServers || [];
         const prepared = await this.acpRuntime.prepareAgent({
           agentId,
           provider: structuredRuntimeProvider,
@@ -2855,6 +2988,8 @@ class AgentManager extends EventEmitter {
           model: codexModel,
           reasoningEffort: codexReasoningEffort,
           serviceTier: codexServiceTier,
+          additionalDirectories,
+          mcpServers,
         });
         agentRecord.providerSessionId = prepared.sessionId;
         agentRecord.providerSessionKey = mainPageAgentSessionKey(
@@ -2865,12 +3000,22 @@ class AgentManager extends EventEmitter {
         agentRecord.providerSessionTemporary = false;
         agentRecord.providerSessionSource = `acp-${prepared.historyMode}`;
         agentRecord.providerSessionResolvedAt = Date.now();
+        let normalizedSessionOptions = { additionalDirectories, mcpServers };
+        try {
+          normalizedSessionOptions = this.acpRuntime.getSessionRequestOptions(agentId);
+        } catch {
+          // prepareAgent already validated the request; retain the caller copy
+          // only for custom runtimes that do not expose the normalized scope.
+        }
+        this.acpSessionOptionsByKey.set(agentRecord.providerSessionKey, {
+          additionalDirectories: [...normalizedSessionOptions.additionalDirectories],
+          mcpServers: JSON.parse(JSON.stringify(normalizedSessionOptions.mcpServers)),
+        });
         acpRuntime.state = 'idle';
         acpRuntime.error = '';
       }
 
-      agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord);
-      if (!useCodexAppServer && !useJsonCli && !useAcp) {
+      if (!useJsonCli && !useAcp) {
         const engineLaunch = {
           command: spawnProgram,
           args,
@@ -2880,6 +3025,10 @@ class AgentManager extends EventEmitter {
         };
         await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
       }
+      agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord, {
+        visibleOnMainPage: true,
+        archived: false,
+      });
 
       const agent = this.agents.get(agentId);
       if (agent && agent.status === 'pending') {
@@ -2898,6 +3047,33 @@ class AgentManager extends EventEmitter {
       return agentId;
     } catch (error) {
       console.error('Failed to start agent:', error);
+      let runtimeCleanupError = null;
+      if (!useJsonCli && !useAcp) {
+        try {
+          await this.stopUncertainTerminalSession(resolution.engine, agentId);
+        } catch (engineCleanupError) {
+          runtimeCleanupError = engineCleanupError;
+          console.error(
+            'Failed to stop partially started Agent runtime:',
+            engineCleanupError && (engineCleanupError.message || engineCleanupError)
+          );
+        }
+      }
+      let rollbackError = null;
+      if (precreatedProviderSession && !runtimeCleanupError) {
+        try {
+          await this.deleteProviderSessionIdentity(precreatedProviderSession);
+        } catch (cleanupError) {
+          rollbackError = cleanupError;
+          console.error(
+            'Failed to roll back pre-created provider session:',
+            cleanupError && (cleanupError.message || cleanupError)
+          );
+        }
+        this.acpSessionOptionsByKey.delete(precreatedProviderSession.sessionKey);
+      } else if (precreatedProviderSession) {
+        this.acpSessionOptionsByKey.delete(precreatedProviderSession.sessionKey);
+      }
       if (options.restoreRuntimeAgentIdOnFailure && agentRecord.persistentSessionId) {
         const failedAgentId = agentRecord.id;
         try {
@@ -2919,9 +3095,6 @@ class AgentManager extends EventEmitter {
       this.agentUsageRateCache.delete(agentId);
       this.lastResizeByAgent.delete(agentId);
       this.providerSessionService.stop(agentId);
-      if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.unregisterAgent === 'function') {
-        this.codexAppServerRuntime.unregisterAgent(agentId);
-      }
       if (this.acpRuntime) this.acpRuntime.unregisterAgent(agentId);
 
       if (this.mainAgentId === agentId) {
@@ -2929,7 +3102,14 @@ class AgentManager extends EventEmitter {
       }
 
       this.emit('update');
-      if (callback) callback(null, error.message);
+      const startupError = error && (error.message || String(error));
+      const cleanupSuffix = rollbackError
+        ? `; provider session rollback failed: ${rollbackError.message || rollbackError}`
+        : '';
+      const runtimeCleanupSuffix = runtimeCleanupError
+        ? `; Terminal rollback failed and the provider session was retained: ${runtimeCleanupError.message || runtimeCleanupError}`
+        : '';
+      if (callback) callback(null, `${startupError}${runtimeCleanupSuffix}${cleanupSuffix}`);
       return null;
     }
   }
@@ -2980,41 +3160,14 @@ class AgentManager extends EventEmitter {
     return this.enqueueInputOperation(agentId, () => this.sendInputNow(agentId, input, options));
   }
 
-  codexAppServerOptionsForAgent(agent, message = '') {
-    const codexResolution = resolveCompatibleCodexExecutable(agent.requiredCliVersion || '');
-    if (!codexResolution.compatible) {
-      throw new Error(codexResolution.error || 'Codex CLI is not compatible with App Server mode');
-    }
-
-    const runtime = runtimeBindingOf(agent, 'app-server');
-    if (!runtime) throw new Error('Agent is not using the Codex App Server runtime');
-    return {
-      agentId: agent.id,
-      codexHome: runtime.homePath,
-      executable: codexResolution.path || resolveAgentExecutable(agent.command) || agent.command,
-      env: this.buildAgentEnv(agent.id, agent),
-      cwd: agent.cwd,
-      workspaceRoot: effectiveAgentWorkspaceRoot(agent),
-      threadId: runtime.threadId || agent.providerSessionId || '',
-      approvalMode: agent.launchPermissionMode || (
-        this.configManager && this.configManager.getCodexApprovalMode
-          ? this.configManager.getCodexApprovalMode()
-          : 'approve'
-      ),
-      model: this.configManager && this.configManager.getCodexModel
-        ? this.configManager.getCodexModel()
-        : 'gpt-5.5',
-      reasoningEffort: this.configManager && this.configManager.getCodexReasoningEffort
-        ? this.configManager.getCodexReasoningEffort()
-        : 'xhigh',
-      serviceTier: this.configManager && this.configManager.getCodexServiceTier
-        ? this.configManager.getCodexServiceTier()
-        : 'default',
-      message,
-    };
-  }
-
   async sendComposerMessage(agentId, message) {
+    if (this.acpRuntime.canSteer?.(agentId)) {
+      try {
+        return await this.sendAcpSteerNow(agentId, message);
+      } catch (error) {
+        if (!isCodexSteerUnavailableError(error)) throw error;
+      }
+    }
     return this.enqueueInputOperation(agentId, () => this.sendComposerMessageNow(agentId, message));
   }
 
@@ -3045,7 +3198,6 @@ class AgentManager extends EventEmitter {
     if (!agent) throw new Error('Agent not found');
     if (
       agentProgramName(agent.command).toLowerCase() !== 'codex'
-      || isCodexAppServerAgent(agent)
       || isJsonCliAgent(agent)
       || isAcpAgent(agent)
       || runtimeKind(agent) !== 'terminal'
@@ -3113,34 +3265,12 @@ class AgentManager extends EventEmitter {
   async sendComposerMessageNow(agentId, message) {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
-    const prompt = Array.isArray(message) ? message : [{ type: 'text', text: String(message || '') }];
+    const prompt = normalizedComposerPrompt(message);
     const text = prompt
       .filter(content => content?.type === 'text')
       .map(content => String(content.text || ''))
       .join('')
       .trim();
-    if (prompt.length === 0 || (!text && !prompt.some(content => content?.type !== 'text'))) {
-      throw new Error('Composer message is empty');
-    }
-
-    const appServer = runtimeBindingOf(agent, 'app-server');
-    if (
-      agent.providerSessionProvider === 'codex'
-      && appServer
-      && this.codexAppServerRuntime
-      && typeof this.codexAppServerRuntime.submitComposerMessage === 'function'
-    ) {
-      const result = await this.codexAppServerRuntime.submitComposerMessage(
-        this.codexAppServerOptionsForAgent(agent, text)
-      );
-      appServer.threadId = result.threadId;
-      appServer.turnId = result.turnId;
-      appServer.state = 'working';
-      appServer.error = '';
-      this.lastActivity.set(agentId, Date.now());
-      this.emit('update');
-      return result;
-    }
 
     if (isJsonCliAgent(agent)) {
       const result = await this.jsonCliRuntime.submitComposerMessage(agentId, text, {
@@ -3165,62 +3295,14 @@ class AgentManager extends EventEmitter {
     return { kind: 'terminal' };
   }
 
-  respondToCodexAppServerRequest(agentId, requestId, result, options = {}) {
+  async sendAcpSteerNow(agentId, message) {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
-    const runtime = runtimeBindingOf(agent, 'app-server');
-    if (agent.providerSessionProvider !== 'codex' || !runtime) {
-      throw new Error('This Agent is not using the Codex App Server runtime');
-    }
-    const resolvedRequestId = String(requestId || '');
-    if (!resolvedRequestId || resolvedRequestId !== runtime.pendingRequestId) {
-      throw new Error('Codex App Server request is no longer pending');
-    }
-    if (!this.codexAppServerRuntime) throw new Error('Codex App Server runtime is unavailable');
-
-    const response = options.reject === true
-      ? this.codexAppServerRuntime.rejectAgentServerRequest(
-        agentId,
-        resolvedRequestId,
-        { code: -32000, message: String(options.reason || 'Rejected by Farming') }
-      )
-      : this.codexAppServerRuntime.resolveAgentServerRequest(agentId, resolvedRequestId, result);
-    runtime.pendingRequestId = '';
-    runtime.pendingRequestMethod = '';
-    runtime.pendingRequest = null;
-    runtime.state = runtime.turnId ? 'working' : 'idle';
-    this.emit('update');
-    return response;
-  }
-
-  assertCodexAppServerGoalAgent(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent) throw new Error('Agent not found');
-    const runtime = runtimeBindingOf(agent, 'app-server');
-    if (agent.providerSessionProvider !== 'codex' || !runtime) {
-      throw new Error('This Agent is not using the Codex App Server runtime');
-    }
-    if (!this.codexAppServerRuntime) throw new Error('Codex App Server runtime is unavailable');
-    if (!(runtime.threadId || agent.providerSessionId)) {
-      throw new Error('Codex App Server thread id is not available yet');
-    }
-    return agent;
-  }
-
-  async getCodexAppServerGoal(agentId) {
-    const agent = this.assertCodexAppServerGoalAgent(agentId);
-    const goal = await this.codexAppServerRuntime.getAgentGoal(this.codexAppServerOptionsForAgent(agent));
-    runtimeBindingOf(agent, 'app-server').goal = goal || null;
-    this.emit('update');
-    return goal || null;
-  }
-
-  getCodexAppServerTranscript(agentId, options = {}) {
-    const agent = this.assertCodexAppServerGoalAgent(agentId);
-    if (!this.codexAppServerRuntime || typeof this.codexAppServerRuntime.getAgentTranscript !== 'function') {
-      throw new Error('Codex App Server transcript is unavailable');
-    }
-    return this.codexAppServerRuntime.getAgentTranscript(agent.id, options);
+    if (!isAcpAgent(agent)) throw new Error('Agent is not using ACP Chat');
+    const prompt = normalizedComposerPrompt(message);
+    const result = await this.acpRuntime.steer(agentId, prompt);
+    this.ensurePersistentAgentSession(agent);
+    return { kind: 'acp', steered: true, ...result };
   }
 
   getJsonCliTranscript(agentId, options = {}) {
@@ -3337,6 +3419,11 @@ class AgentManager extends EventEmitter {
     return this.acpRuntime.authenticate(agentId, methodId);
   }
 
+  logoutAcpAgent(agentId) {
+    this.getAcpSession(agentId);
+    return this.acpRuntime.logout(agentId);
+  }
+
   forkAcpSession(agentId, options = {}) {
     this.getAcpSession(agentId);
     return this.acpRuntime.forkSession(agentId, options);
@@ -3367,44 +3454,10 @@ class AgentManager extends EventEmitter {
     return this.acpRuntime.setSessionConfigOptions(agentId, changes);
   }
 
-  async setCodexAppServerGoal(agentId, patch = {}) {
-    const agent = this.assertCodexAppServerGoalAgent(agentId);
-    const objective = typeof patch.objective === 'string' ? patch.objective.trim().slice(0, 4000) : undefined;
-    const status = typeof patch.status === 'string' ? patch.status : undefined;
-    let tokenBudget;
-    if (Object.prototype.hasOwnProperty.call(patch, 'tokenBudget')) {
-      tokenBudget = Number.isFinite(Number(patch.tokenBudget)) && Number(patch.tokenBudget) > 0
-        ? Math.floor(Number(patch.tokenBudget))
-        : null;
-    }
-    if (objective !== undefined && !objective) {
-      throw new Error('Codex goal objective is required');
-    }
-    const goal = await this.codexAppServerRuntime.setAgentGoal({
-      ...this.codexAppServerOptionsForAgent(agent),
-      ...(objective !== undefined ? { objective } : {}),
-      ...(status !== undefined ? { status } : {}),
-      ...(Object.prototype.hasOwnProperty.call(patch, 'tokenBudget') ? { tokenBudget } : {}),
-    });
-    runtimeBindingOf(agent, 'app-server').goal = goal || null;
-    this.emit('update');
-    return goal || null;
-  }
-
-  async clearCodexAppServerGoal(agentId) {
-    const agent = this.assertCodexAppServerGoalAgent(agentId);
-    await this.codexAppServerRuntime.clearAgentGoal(this.codexAppServerOptionsForAgent(agent));
-    runtimeBindingOf(agent, 'app-server').goal = null;
-    this.emit('update');
-    return null;
-  }
-
   async sendInputNow(agentId, input, { markUserInput = true, expectedRuntimeEpoch = '' } = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) return;
-    // The observer PTY is optional telemetry for App Server Agents. Its
-    // disappearance must never redefine the App Server Agent as dead.
-    if (isCodexAppServerAgent(agent) || isJsonCliAgent(agent) || isAcpAgent(agent)) return;
+    if (isJsonCliAgent(agent) || isAcpAgent(agent)) return;
     if (expectedRuntimeEpoch && agent.runtimeEpoch !== expectedRuntimeEpoch) {
       return { status: 'input-rejected', reason: 'runtime-epoch-mismatch' };
     }
@@ -3412,15 +3465,16 @@ class AgentManager extends EventEmitter {
     const engine = this.engineBridge.getEngine(agent.engineName);
     if (!engine) return;
 
+    const submittedUserInput = markUserInput && hasSubmittedTerminalInput(input);
+    if (submittedUserInput && agent.terminalInputReceived !== true) {
+      agent.terminalInputReceived = true;
+      this.ensurePersistentAgentSession(agent);
+      this.updateEngineProviderSessionMetadata(agent);
+      this.emit('agent-update', { agentId, patch: { terminalInputReceived: true } });
+    }
+
     try {
-      const submittedUserInput = markUserInput && hasSubmittedTerminalInput(input);
       const result = await engine.sendInput(agentId, input, { expectedRuntimeEpoch });
-      if (submittedUserInput && agent.terminalInputReceived !== true) {
-        agent.terminalInputReceived = true;
-        this.ensurePersistentAgentSession(agent);
-        this.updateEngineProviderSessionMetadata(agent);
-        this.emit('agent-update', { agentId, patch: { terminalInputReceived: true } });
-      }
       if (submittedUserInput) {
         this.providerSessionService.observe(agentId, { force: true });
       }
@@ -3437,8 +3491,6 @@ class AgentManager extends EventEmitter {
   markAgentSessionDead(agentId, error) {
     const agent = this.agents.get(agentId);
     if (!agent || agent.status === 'dead') return;
-    if (isCodexAppServerAgent(agent)) return;
-
     const message = error && error.message ? error.message : String(error || 'Session not available');
     agent.status = 'dead';
     agent.engineStatus = 'dead';
@@ -3452,31 +3504,7 @@ class AgentManager extends EventEmitter {
   async interruptAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) return;
-    const appServer = runtimeBindingOf(agent, 'app-server');
-
     try {
-      if (
-        agent.providerSessionProvider === 'codex'
-        && appServer
-        && this.codexAppServerRuntime
-        && typeof this.codexAppServerRuntime.interruptAgent === 'function'
-      ) {
-        try {
-          const interrupted = await this.codexAppServerRuntime.interruptAgent(agentId);
-          if (interrupted) {
-            appServer.state = 'interrupting';
-            this.emit('update');
-            return;
-          }
-          appServer.error = 'Codex App Server interrupt is not available';
-          this.emit('update');
-          return;
-        } catch (error) {
-          appServer.error = `Codex App Server interrupt failed: ${error && (error.message || error)}`;
-          this.emit('update');
-          return;
-        }
-      }
       if (isJsonCliAgent(agent)) {
         this.jsonCliRuntime.interruptAgent(agentId);
         return;
@@ -3505,12 +3533,12 @@ class AgentManager extends EventEmitter {
   agentSupportsTerminalInput(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) return false;
-    return !isCodexAppServerAgent(agent) && !isJsonCliAgent(agent) && !isAcpAgent(agent);
+    return !isJsonCliAgent(agent) && !isAcpAgent(agent);
   }
 
   async getAgentSessionAttachCheckpoint(agentId) {
     const agent = this.agents.get(agentId);
-    if (!agent || isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) {
+    if (!agent || isAcpAgent(agent) || isJsonCliAgent(agent)) {
       return null;
     }
     try {
@@ -3541,7 +3569,7 @@ class AgentManager extends EventEmitter {
   async resizeAgentSession(agentId, cols, rows) {
     const agent = this.agents.get(agentId);
     if (!agent) return { status: 'resize-rejected', reason: 'session-unavailable', resized: false };
-    if (isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) {
+    if (isAcpAgent(agent) || isJsonCliAgent(agent)) {
       return { status: 'resize-rejected', reason: 'unsupported-session', resized: false };
     }
 
@@ -3579,7 +3607,7 @@ class AgentManager extends EventEmitter {
   async clearAgentSessionBuffer(agentId, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) return { cleared: false };
-    if (isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) return { cleared: false };
+    if (isAcpAgent(agent) || isJsonCliAgent(agent)) return { cleared: false };
     if (options.expectedRuntimeEpoch && agent.runtimeEpoch !== options.expectedRuntimeEpoch) {
       return { cleared: false, reason: 'runtime-epoch-mismatch' };
     }
@@ -3615,6 +3643,8 @@ class AgentManager extends EventEmitter {
 
     const customTitle = String(title || '').trim().slice(0, 80);
     agent.customTitle = customTitle;
+    this.ensurePersistentAgentSession(agent);
+    this.updateEngineProviderSessionMetadata(agent);
     this.emit('update');
     return { agentId, customTitle };
   }
@@ -3780,52 +3810,9 @@ class AgentManager extends EventEmitter {
   async syncCodexTerminalPermissionMode(agentId, mode) {
     const agent = this.agents.get(agentId);
     if (!agent) return { error: 'Agent not found' };
-
-    if (
-      agent.providerSessionProvider === 'codex'
-      && runtimeKind(agent) === 'app-server'
-    ) {
-      return this.updateCodexAppServerPermissionMode(agentId, mode);
-    }
-
     return this.restartAgentWithPermissionMode(agentId, mode);
   }
 
-  async updateCodexAppServerPermissionMode(agentId, mode) {
-    const agent = this.agents.get(agentId);
-    if (!agent) return { error: 'Agent not found' };
-    const runtime = runtimeBindingOf(agent, 'app-server');
-    if (agent.providerSessionProvider !== 'codex' || !runtime) {
-      return { error: 'Agent is not using the Codex App Server runtime' };
-    }
-
-    const nextMode = ['ask', 'approve', 'full', 'custom'].includes(mode) ? mode : '';
-    if (!nextMode) return { error: 'Unsupported Codex permission mode' };
-    if (!this.codexAppServerRuntime || typeof this.codexAppServerRuntime.updateAgentPermissionMode !== 'function') {
-      return { error: 'Codex App Server permission updates are unavailable' };
-    }
-
-    try {
-      await this.codexAppServerRuntime.updateAgentPermissionMode({
-        ...this.codexAppServerOptionsForAgent(agent),
-        approvalMode: nextMode,
-      });
-    } catch (error) {
-      return { error: error && error.message ? error.message : 'Failed to update Codex App Server permissions' };
-    }
-
-    agent.launchPermissionMode = nextMode;
-    runtime.error = '';
-    this.updateEngineProviderSessionMetadata(agent);
-    this.ensurePersistentAgentSession(agent, { launchPermissionMode: nextMode });
-    this.emit('update');
-    return {
-      agentId,
-      updated: true,
-      launchPermissionMode: nextMode,
-    };
-  }
-
   async restartAgentWithPermissionMode(agentId, mode) {
     const inFlight = this.permissionRestartInFlight.get(agentId);
     if (inFlight) {
@@ -3868,15 +3855,16 @@ class AgentManager extends EventEmitter {
   async performAgentRuntimeModeRestart(agentId, mode) {
     const agent = this.agents.get(agentId);
     if (!agent) return { error: 'Agent not found' };
-    const nextMode = ['terminal', 'json', 'acp'].includes(mode) ? mode : '';
-    if (!nextMode) return { error: 'Unsupported Agent runtime mode' };
     const provider = agent.providerSessionProvider || '';
+    const requestedMode = ['terminal', 'json', 'acp', 'chat'].includes(mode) ? mode : '';
+    const nextMode = requestedMode === 'acp' && provider === 'codex' ? 'chat' : requestedMode;
+    if (!nextMode) return { error: 'Unsupported Agent runtime mode' };
     const currentKind = runtimeKind(agent);
-    const currentMode = ['acp', 'json'].includes(currentKind) ? currentKind : 'terminal';
-    const leavesCodexAppServer = provider === 'codex'
-      && currentKind === 'app-server'
-      && nextMode === 'terminal';
-    if (currentMode === nextMode && !leavesCodexAppServer) {
+    const currentMode = currentKind === 'acp'
+      ? 'chat'
+      : (currentKind === 'json' ? 'json' : 'terminal');
+    const nextRuntimeKind = nextMode === 'chat' ? chatRuntimeForProvider(provider) : nextMode;
+    if (currentMode === nextMode) {
       return { agentId, agentRuntimeMode: nextMode };
     }
     const turnActive = currentKind === 'acp'
@@ -3885,18 +3873,21 @@ class AgentManager extends EventEmitter {
     if (turnActive) {
       return { error: 'Interrupt the active Agent turn before switching Chat and Terminal.' };
     }
-    if (!providerSupportsRuntime(provider, nextMode)) {
+    const supportsNextMode = nextMode === 'chat'
+      ? providerCapabilities(provider).supportsChat === true
+      : providerSupportsRuntime(provider, nextMode);
+    if (!supportsNextMode) {
       return { error: `Agent does not support the ${nextMode.toUpperCase()} runtime` };
     }
     const sessionId = String(agent.providerSessionId || '').trim();
-    const canStartFreshAcpSession = nextMode === 'acp'
+    const canStartFreshChatSession = nextMode === 'chat'
       && currentMode === 'terminal'
       && agent.terminalInputReceived !== true
       && (
         agent.providerSessionTemporary === true
         || isFreshAcpSessionSource(provider, agent.providerSessionSource || '')
       );
-    if (!isSafeProviderSessionId(sessionId) && !canStartFreshAcpSession) {
+    if (!isSafeProviderSessionId(sessionId) && !canStartFreshChatSession) {
       return { error: 'Runtime switching requires a resumable provider session. Send the first message and try again.' };
     }
     // A live ACP binding is the authoritative owner of a newly-created
@@ -3915,15 +3906,15 @@ class AgentManager extends EventEmitter {
       }
     }
     const previouslyVerifiedSession = String(agent.runtimeSwitchVerifiedSessionId || '') === sessionId;
-    let startsFreshAcpSession = canStartFreshAcpSession && !isSafeProviderSessionId(sessionId);
-    if (!startsFreshAcpSession && !liveAcpSession && !previouslyVerifiedSession) {
+    let startsFreshChatSession = canStartFreshChatSession && !isSafeProviderSessionId(sessionId);
+    if (!startsFreshChatSession && !liveAcpSession && !previouslyVerifiedSession) {
       const providerSession = await this.findRuntimeSwitchSession(agent);
       if (!providerSession) {
-        if (canStartFreshAcpSession) startsFreshAcpSession = true;
+        if (canStartFreshChatSession) startsFreshChatSession = true;
         else return { error: 'The saved Agent session is no longer available in the selected Agent Home.' };
       }
     }
-    const command = startsFreshAcpSession
+    const command = startsFreshChatSession
       ? (agent.forkCommand || agent.command)
       : buildAgentSessionResumeCommand(provider, sessionId, {
           cwd: effectiveAgentWorkspaceRoot(agent),
@@ -3940,12 +3931,20 @@ class AgentManager extends EventEmitter {
         ? this.jsonCliRuntime.getEvents(agentId)
         : (Array.isArray(agent.runtimeResumeState?.jsonEvents) ? agent.runtimeResumeState.jsonEvents : []),
     };
+    let acpSessionOptions = {};
+    if (currentKind === 'acp' && this.acpRuntime?.getSessionRequestOptions) {
+      try {
+        acpSessionOptions = this.acpRuntime.getSessionRequestOptions(agentId);
+      } catch {
+        acpSessionOptions = {};
+      }
+    }
     const restartOptions = {
       wantsMain: agent.wantsMain === true,
       task: agent.task || agent.providerSessionTitle || '',
       workflowTemplate: agent.workflowTemplate || '',
       projectWorkspace: effectiveAgentWorkspaceRoot(agent),
-      source: startsFreshAcpSession
+      source: startsFreshChatSession
         ? 'ui-runtime-switch-fresh'
         : resumedAgentSource(provider, sessionId, agent.providerHomeId || ''),
       providerHomeId: agent.providerHomeId || '',
@@ -3960,12 +3959,12 @@ class AgentManager extends EventEmitter {
       projectOrder: preserved.projectOrder,
       pinnedOrder: preserved.pinnedOrder,
       agentRuntimeMode: nextMode,
-      acpStartFresh: startsFreshAcpSession,
-      codexRuntimeMode: 'cli',
+      acpStartFresh: startsFreshChatSession && nextRuntimeKind === 'acp',
       codexApprovalMode: agent.launchPermissionMode || undefined,
       jsonCliEvents: preserved.jsonCliEvents,
-      runtimeSwitchVerifiedSessionId: startsFreshAcpSession ? '' : sessionId,
-      ...(provider === 'codex' && !startsFreshAcpSession
+      runtimeSwitchVerifiedSessionId: startsFreshChatSession ? '' : sessionId,
+      ...acpSessionOptions,
+      ...(provider === 'codex' && !startsFreshChatSession
         ? preserveCodexSessionProfileOptions()
         : {}),
     };
@@ -3973,7 +3972,6 @@ class AgentManager extends EventEmitter {
     const originalOptions = {
       ...restartOptions,
       agentRuntimeMode: originalMode,
-      codexRuntimeMode: currentKind === 'app-server' ? 'app-server' : 'cli',
       acpStartFresh: false,
     };
     const startReplacement = options => new Promise(resolve => {
@@ -4090,6 +4088,9 @@ class AgentManager extends EventEmitter {
     const startsFreshCodexSession = provider === 'codex'
       && !hasResumableSession
       && (agent.providerSessionTemporary === true || !String(agent.providerSessionId || '').trim());
+    if (startsFreshCodexSession && agent.terminalInputReceived === true) {
+      return { error: 'Permission changes require a resumable provider session. Try again after the session id is available.' };
+    }
     if (!hasResumableSession && !startsFreshCodexSession) {
       return { error: 'Permission changes require a resumable provider session. Try again after the session id is available.' };
     }
@@ -4103,6 +4104,14 @@ class AgentManager extends EventEmitter {
       return { error: 'Failed to build provider resume command' };
     }
 
+    let acpSessionOptions = {};
+    if (isAcpAgent(agent) && this.acpRuntime?.getSessionRequestOptions) {
+      try {
+        acpSessionOptions = this.acpRuntime.getSessionRequestOptions(agentId);
+      } catch {
+        acpSessionOptions = {};
+      }
+    }
     const restartOptions = {
       wantsMain: agent.wantsMain === true,
       task: agent.task || agent.providerSessionTitle || '',
@@ -4125,6 +4134,7 @@ class AgentManager extends EventEmitter {
       ])),
       projectOrder: finiteOrder(agent.projectOrder),
       pinnedOrder: finiteOrder(agent.pinnedOrder),
+      ...acpSessionOptions,
       ...(provider === 'codex' ? { codexApprovalMode: nextMode } : { claudePermissionMode: nextMode }),
       ...(provider === 'codex' && hasResumableSession
         ? preserveCodexSessionProfileOptions()
@@ -4457,6 +4467,12 @@ class AgentManager extends EventEmitter {
     if (!['same-worktree', 'new-worktree'].includes(mode)) {
       return { error: 'Unsupported fork mode' };
     }
+    if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
+      await this.providerSessionService.resolveTemporaryCodex(agentId, { force: true });
+      if (agent.providerSessionTemporary === true) {
+        return { error: 'Fork requires a resumable Codex session. Try again after the session id is available.' };
+      }
+    }
 
     const sourceWorkspace = effectiveAgentWorkspaceRoot(agent);
     const resumedSession = agent.providerSessionProvider
@@ -4606,6 +4622,7 @@ class AgentManager extends EventEmitter {
     }
 
     const removedMainPageSessionKeys = this.removeMainPageProviderSessionsForAgents([agent]);
+    this.ensurePersistentAgentSession(agent, { visibleOnMainPage: false });
     await this.killAgent(agentId, {
       reason: 'manual-archive',
       recordHistory: !isEphemeralShellAgent(agent),
@@ -4670,9 +4687,6 @@ class AgentManager extends EventEmitter {
     this.agentUsageRateCache.delete(agentId);
     this.lastResizeByAgent.delete(agentId);
     this.providerSessionService.stop(agentId);
-    if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.unregisterAgent === 'function') {
-      this.codexAppServerRuntime.unregisterAgent(agentId);
-    }
     if (this.jsonCliRuntime) this.jsonCliRuntime.unregisterAgent(agentId);
     if (this.acpRuntime) this.acpRuntime.unregisterAgent(agentId);
 
@@ -4729,13 +4743,11 @@ class AgentManager extends EventEmitter {
   getAgentProviderSession(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) return null;
-    const appServer = runtimeBindingOf(agent, 'app-server');
     return {
       provider: agent.providerSessionProvider || '',
       sessionId: agent.providerSessionId || '',
       providerHomeId: agent.providerHomeId || '',
       providerHomePath: agent.providerHomePath || '',
-      codexAppServerHomePath: appServer?.homePath || '',
       runtimeBinding: publicRuntimeBinding(agent),
       temporary: agent.providerSessionTemporary === true,
       title: agent.providerSessionTitle || '',
@@ -5023,7 +5035,10 @@ class AgentManager extends EventEmitter {
         providerSessionResolvedAt: agent.providerSessionResolvedAt || null,
         providerSessionTitle: agent.providerSessionTitle || '',
         providerSessionWorkspace: agent.providerSessionWorkspace || '',
-        providerCapabilities: providerCapabilities(agent.providerSessionProvider),
+        providerCapabilities: {
+          ...providerCapabilities(agent.providerSessionProvider),
+          supportsSteer: runtimeBindingOf(agent, 'acp')?.supportsSteer === true,
+        },
         terminalInputReceived: agent.terminalInputReceived === true,
         runtimeBinding: publicRuntimeBinding(agent),
         runtimeObservation: deriveRuntimeObservation(agent),