farming-code 2.2.16 → 2.2.18

package/backend/agent-manager.js

@@ -76,6 +76,12 @@ 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 CODEX_TERMINAL_START_READY_TIMEOUT_MS = 30_000;
+const CODEX_TERMINAL_START_READY_POLL_MS = 50;
+const CODEX_TERMINAL_START_OUTPUT_LIMIT = 64 * 1024;
 const SHELL_PROMPT_ENV_KEYS = [
   'PS1',
   'PS2',
@@ -88,6 +94,40 @@ 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));
+}
+
+function canonicalProviderHomePath(value) {
+  const resolved = path.resolve(String(value || '').trim() || '.');
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+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;
@@ -176,12 +216,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'
@@ -378,13 +412,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 = {}) {
@@ -549,6 +593,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
@@ -558,6 +603,8 @@ class AgentManager extends EventEmitter {
     this.resizeDrains = new Map();
     this.inputQueues = new Map();
     this.codexTerminalProfileQueues = new Map();
+    this.codexTerminalStartQueues = new Map();
+    this.codexTerminalStartOutput = new Map();
     this.agentWorktreeResolveGeneration = new Map();
     this.permissionRestartInFlight = new Map();
     this.runtimeRestartInFlight = new Map();
@@ -580,6 +627,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;
@@ -718,6 +771,16 @@ class AgentManager extends EventEmitter {
 
         this.reviveAgentRuntime(agent);
         agent.output = trimSessionOutput(agent.output + data);
+        if (this.codexTerminalStartOutput.has(sessionId)) {
+          const startupOutput = `${this.codexTerminalStartOutput.get(sessionId) || ''}${data}`;
+          this.codexTerminalStartOutput.set(
+            sessionId,
+            startupOutput.slice(-CODEX_TERMINAL_START_OUTPUT_LIMIT),
+          );
+        }
+        if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
+          void this.providerSessionService.resolveTemporaryCodex(sessionId);
+        }
         const outputAt = Date.now();
         agent.lastEngineOutputAt = outputAt;
         this.lastActivity.set(sessionId, outputAt);
@@ -1086,6 +1149,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]));
@@ -1096,6 +1160,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
@@ -1114,6 +1183,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,
@@ -1131,21 +1201,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());
@@ -1172,6 +1244,7 @@ class AgentManager extends EventEmitter {
 
   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)
@@ -1265,8 +1338,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 {
@@ -1277,13 +1351,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;
@@ -1293,6 +1367,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
@@ -1386,8 +1473,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);
@@ -1716,6 +1807,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));
     });
@@ -2193,6 +2285,8 @@ class AgentManager extends EventEmitter {
     this.resizeDrains.clear();
     this.inputQueues.clear();
     this.codexTerminalProfileQueues.clear();
+    this.codexTerminalStartQueues.clear();
+    this.codexTerminalStartOutput.clear();
     this.acpSessionOptionsByKey.clear();
     if (this.jsonCliRuntime) {
       for (const agentId of this.agents.keys()) this.jsonCliRuntime.unregisterAgent(agentId);
@@ -2280,11 +2374,134 @@ 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 waitForCodexTerminalStart(agentId) {
+    const deadline = Date.now() + CODEX_TERMINAL_START_READY_TIMEOUT_MS;
+    while (Date.now() <= deadline) {
+      const agent = this.agents.get(agentId);
+      if (!agent) throw new Error(`Codex Terminal ${agentId} disappeared during startup`);
+      if (['dead', 'stopped'].includes(agent.status) || agent.engineStatus === 'exited') {
+        const detail = trimSessionOutput(agent.previewText || agent.output || '').trim();
+        throw new Error(detail || `Codex Terminal ${agentId} exited during startup`);
+      }
+      if ((this.codexTerminalStartOutput.get(agentId) || '').includes('\u001b')) {
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, CODEX_TERMINAL_START_READY_POLL_MS));
+    }
+    throw new Error(`Codex Terminal ${agentId} did not become ready within ${CODEX_TERMINAL_START_READY_TIMEOUT_MS}ms`);
+  }
+
+  async enqueueCodexTerminalStart(providerHomeKey, operation) {
+    const key = canonicalProviderHomePath(providerHomeKey || '.');
+    const previous = this.codexTerminalStartQueues.get(key) || Promise.resolve();
+    const next = previous.catch(() => {}).then(operation);
+    this.codexTerminalStartQueues.set(key, next);
+    try {
+      return await next;
+    } finally {
+      if (this.codexTerminalStartQueues.get(key) === next) {
+        this.codexTerminalStartQueues.delete(key);
+      }
+    }
+  }
+
   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();
@@ -2357,13 +2574,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;
@@ -2446,13 +2678,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}`);
@@ -2519,8 +2744,7 @@ class AgentManager extends EventEmitter {
       : '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.
+    // after connecting. Fresh Terminal sessions are handled separately below.
     const structuredRuntimeProvider = ['json', 'acp', 'chat'].includes(requestedAgentRuntimeMode)
       ? homeProvider
       : providerSessionPlan.provider;
@@ -2630,6 +2854,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);
@@ -2716,17 +3069,40 @@ class AgentManager extends EventEmitter {
         acpRuntime.error = '';
       }
 
-      agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord);
       if (!useJsonCli && !useAcp) {
-        const engineLaunch = {
-          command: spawnProgram,
-          args,
-          cwd: workspace,
-          category: resolution.spec ? resolution.spec.category : 'shell',
-          reviveState: options.reviveTerminalState || null,
+        const serializeCodexStartup = agentRecord.providerSessionProvider === 'codex'
+          && resolution.engineName === 'native';
+        const startTerminal = async () => {
+          const engineLaunch = {
+            command: spawnProgram,
+            args,
+            cwd: workspace,
+            category: resolution.spec ? resolution.spec.category : 'shell',
+            reviveState: options.reviveTerminalState || null,
+          };
+          if (serializeCodexStartup) this.codexTerminalStartOutput.set(agentId, '');
+          try {
+            await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
+            if (serializeCodexStartup) {
+              await this.waitForCodexTerminalStart(agentId);
+            }
+          } finally {
+            if (serializeCodexStartup) this.codexTerminalStartOutput.delete(agentId);
+          }
         };
-        await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
+        if (serializeCodexStartup) {
+          await this.enqueueCodexTerminalStart(
+            providerHomePath || resolvedProviderHomeId || 'default',
+            startTerminal
+          );
+        } else {
+          await startTerminal();
+        }
       }
+      agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord, {
+        visibleOnMainPage: true,
+        archived: false,
+      });
 
       const agent = this.agents.get(agentId);
       if (agent && agent.status === 'pending') {
@@ -2745,6 +3121,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 {
@@ -2773,7 +3176,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;
     }
   }
@@ -3129,15 +3539,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 });
       }
@@ -3306,6 +3717,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 };
   }
@@ -3749,6 +4162,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.' };
     }
@@ -4125,6 +4541,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
@@ -4274,6 +4696,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),