farming-code 2.2.8 → 2.2.12

package/backend/agent-manager.js

@@ -6,19 +6,46 @@ const path = require('path');
 const { promisify } = require('util');
 const SystemMonitor = require('./system-monitor');
 const SessionEngineBridge = require('./session-engine-bridge');
-const { isSupportedHistoryAgent, resolveLaunchCommand } = require('./cli-agents');
-const { buildAgentSessionResumeCommand, findAgentSession } = require('./agent-session-history');
-const { listCodexSessions } = require('./codex-session-history');
+const { isSupportedHistoryAgent, parseCommand, resolveLaunchCommand } = require('./cli-agents');
+const {
+  buildAgentSessionResumeCommand,
+  findAgentSession,
+} = require('./agent-session-history');
+const { archiveCodexSession, unarchiveCodexSession } = require('./codex-session-archive');
 const { buildAgentProviderSessionPlan, sessionFromExactResumeSource } = require('./agent-provider-session');
 const { resolveAgentExecutable, resolveCompatibleCodexExecutable } = require('./executable-discovery');
 const { ensureMainAgentSkillFiles, renderMainAgentBootstrap } = require('./main-agent-skills');
 const { mainPageAgentSessionKey, resumedAgentSource } = require('./main-page-session');
 const { isSafeProviderSessionId, isTemporaryProviderSessionId } = require('./provider-session-id');
+const { ProviderSessionService } = require('./provider-session-service');
+const {
+  legacyRuntimeMetadata,
+  publicRuntimeBinding,
+  replaceRuntimeBinding,
+  RuntimeAgentMap,
+  runtimeBindingFor,
+  runtimeBindingOf,
+  runtimeKind,
+} = require('./agent-runtime-binding');
+const { deriveRuntimeObservation } = require('./runtime-observation');
+const {
+  applyProviderHomeEnvironment,
+  getProviderAdapter,
+  isFreshAcpSessionSource,
+  providerCapabilities,
+  providerForProgram,
+  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 { acpToolChanges, acpToolDetail, acpToolReviewChanges } = require('./acp-transcript');
+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,
@@ -32,22 +59,23 @@ const {
   normalizeInteractiveTerminalEnv,
   resolveUserShellEnvSync,
 } = require('./agent-env');
+const { inspectGitWorktree } = require('./git-worktree-info');
+const { deserializeTerminalState } = require('./terminal-state-serialization');
+const { compareNativePtyRuntimeEpochs } = require('./native-pty-controller-generation');
+const { canonicalWorkspacePath } = require('./workspace-root-registry');
 
 const SESSION_OUTPUT_LIMIT = 10000;
 const AGENT_USAGE_RATE_WINDOW_MS = 5 * 60 * 1000;
+const AGENT_USAGE_RATE_REFRESH_MS = 5 * 1000;
 const ACTIVITY_UPDATE_INTERVAL_MS = 1000;
 const ACTIVITY_HOT_SEC = 30 * 60;
 const ACTIVITY_WARM_SEC = 3 * 60 * 60;
 const ACTIVITY_COOL_SEC = 12 * 60 * 60;
 const ZOMBIE_IDLE_MS = 72 * 60 * 60 * 1000;
 const ZOMBIE_SWEEP_INTERVAL_MS = 60 * 1000;
-const INPUT_SESSION_RETRY_DELAYS_MS = [25, 50, 100, 180, 300, 500];
 const MISSING_ENGINE_SESSION_STARTUP_GRACE_MS = 5000;
 const MIN_TERMINAL_RESIZE_COLS = 40;
 const MIN_TERMINAL_RESIZE_ROWS = 10;
-const CODEX_PROVIDER_SESSION_RESOLVE_COOLDOWN_MS = 1000;
-const CODEX_PROVIDER_SESSION_MATCH_GRACE_MS = 30 * 1000;
-const PROVIDER_SESSION_TITLE_RESOLVE_COOLDOWN_MS = 30 * 1000;
 const AGENT_DISCOVERY_CACHE_MAX_AGE_MS = 3_000;
 const SHELL_PROMPT_ENV_KEYS = [
   'PS1',
@@ -66,12 +94,107 @@ function trimSessionOutput(output) {
   return text.length > SESSION_OUTPUT_LIMIT ? text.slice(-SESSION_OUTPUT_LIMIT) : text;
 }
 
+function terminalStateUpdateDisposition(agent, runtimeEpoch, outputSeq, stateRevision) {
+  const currentEpoch = typeof agent.runtimeEpoch === 'string' ? agent.runtimeEpoch : '';
+  const nextEpoch = typeof runtimeEpoch === 'string' ? runtimeEpoch : '';
+  if (currentEpoch && nextEpoch && currentEpoch !== nextEpoch) {
+    const relation = compareNativePtyRuntimeEpochs(nextEpoch, currentEpoch);
+    return relation === 1 ? 'new-epoch' : 'stale';
+  }
+  if (currentEpoch && !nextEpoch) return 'unversioned';
+  if (!currentEpoch || !nextEpoch) return 'current';
+
+  const currentRevision = Number(agent.stateRevision);
+  const nextRevision = Number(stateRevision);
+  if (Number.isFinite(currentRevision) && Number.isFinite(nextRevision)) {
+    if (nextRevision < currentRevision) return 'stale';
+    if (nextRevision === currentRevision) {
+      const currentOutputSeq = Number(agent.lastOutputSeq);
+      const nextOutputSeq = Number(outputSeq);
+      return Number.isFinite(nextOutputSeq)
+        && Number.isFinite(currentOutputSeq)
+        && nextOutputSeq === currentOutputSeq
+        ? 'duplicate'
+        : 'stale';
+    }
+  }
+  const currentOutputSeq = Number(agent.lastOutputSeq);
+  const nextOutputSeq = Number(outputSeq);
+  if (Number.isFinite(currentOutputSeq) && Number.isFinite(nextOutputSeq) && nextOutputSeq < currentOutputSeq) {
+    return 'stale';
+  }
+  return 'current';
+}
+
+function terminalRuntimeEventMatches(agent, runtimeEpoch) {
+  const currentEpoch = typeof agent?.runtimeEpoch === 'string' ? agent.runtimeEpoch : '';
+  if (!currentEpoch) return true;
+  return typeof runtimeEpoch === 'string' && runtimeEpoch === currentEpoch;
+}
+
+function setPendingTerminalStartSyncCut(agent, runtimeEpoch, outputSeq, stateRevision) {
+  if (
+    typeof runtimeEpoch !== 'string' || !runtimeEpoch ||
+    !Number.isFinite(outputSeq) ||
+    !Number.isFinite(stateRevision)
+  ) {
+    delete agent.pendingTerminalStartSyncCut;
+    return;
+  }
+  agent.pendingTerminalStartSyncCut = {
+    runtimeEpoch,
+    outputSeq,
+    stateRevision,
+  };
+}
+
+function consumesPendingTerminalStartSyncCut(agent, runtimeEpoch, outputSeq, stateRevision) {
+  const pending = agent?.pendingTerminalStartSyncCut;
+  return Boolean(
+    pending &&
+    pending.runtimeEpoch === runtimeEpoch &&
+    pending.outputSeq === outputSeq &&
+    pending.stateRevision === stateRevision &&
+    agent.runtimeEpoch === runtimeEpoch &&
+    agent.lastOutputSeq === outputSeq &&
+    agent.stateRevision === stateRevision
+  );
+}
+
+function clearPendingTerminalStartSyncCut(agent) {
+  if (agent) delete agent.pendingTerminalStartSyncCut;
+}
+
+function applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision, disposition) {
+  if (disposition === 'stale' || disposition === 'duplicate' || disposition === 'unversioned') return false;
+  if (disposition === 'new-epoch') {
+    agent.lastOutputSeq = 0;
+    agent.stateRevision = 0;
+  }
+  if (typeof runtimeEpoch === 'string' && runtimeEpoch) agent.runtimeEpoch = runtimeEpoch;
+  if (Number.isFinite(outputSeq)) agent.lastOutputSeq = outputSeq;
+  if (Number.isFinite(stateRevision)) agent.stateRevision = 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'
+    && parts.slice(1).some(arg => arg === 'resume' || arg === 'fork');
+}
+
+function preserveCodexSessionProfileOptions() {
+  return {
+    preserveProviderSessionProfile: true,
+  };
+}
+
 function isSameOrDescendantPath(root, target) {
   const relative = path.relative(root, target);
   return relative === '' || Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
@@ -90,29 +213,27 @@ function agentProgramName(command) {
 }
 
 function agentHomeProviderForProgram(command) {
-  const program = agentProgramName(command).toLowerCase();
-  if (program === 'qodercli') return 'qoder';
-  return ['codex', 'claude', 'opencode', 'qoder'].includes(program) ? program : '';
+  return providerForProgram(agentProgramName(command));
 }
 
 function hasUsableCodexAppServerHome(metadata) {
-  const homePath = String(metadata?.codexAppServerHomePath || '').trim();
+  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'
-    && metadata?.codexRuntimeMode === 'app-server'
+    && runtimeKind(metadata) === 'app-server'
     && hasUsableCodexAppServerHome(metadata);
 }
 
 function isJsonCliAgent(agent) {
-  return agent && agent.agentRuntimeMode === 'json';
+  return runtimeKind(agent) === 'json';
 }
 
 function isAcpAgent(agent) {
-  return agent && agent.agentRuntimeMode === 'acp';
+  return runtimeKind(agent) === 'acp';
 }
 
 function isShellProgram(command) {
@@ -123,6 +244,68 @@ function isEphemeralShellAgent(agent) {
   return agent && isShellProgram(agent.forkCommand || agent.command || '');
 }
 
+function hasSubmittedTerminalInput(input) {
+  const parts = Array.isArray(input) ? input : [input];
+  return parts.some(part => {
+    // Composer paste parts carry draft text separately from the trailing Enter.
+    // Newlines inside that draft must not independently materialize a session.
+    if (part && typeof part === 'object' && part.type === 'paste') return false;
+    const text = String(part || '');
+    // xterm wraps native paste payloads so embedded newlines remain draft text.
+    // Remove complete bracketed-paste spans before looking for a submission.
+    const withoutBracketedPaste = text.replace(/\x1b\[200~[\s\S]*?\x1b\[201~/g, '');
+    return /[\r\n]/.test(withoutBracketedPaste);
+  });
+}
+
+function activeCodexTerminalProfile(agent, previewText) {
+  if (!agent) return null;
+  const provider = agent.providerSessionProvider
+    || agentHomeProviderForProgram(agent.forkCommand || agent.command || '');
+  if (
+    provider !== 'codex'
+    || isCodexAppServerAgent(agent)
+    || isJsonCliAgent(agent)
+    || isAcpAgent(agent)
+    || runtimeKind(agent) !== 'terminal'
+  ) {
+    return null;
+  }
+
+  const outputProfile = codexTerminalProfileFromOutput(agent.output || '');
+  const parsed = outputProfile || codexTerminalProfileFromPreview(previewText);
+  if (!parsed) return agent.codexTerminalProfile || null;
+  const previousServiceTier = agent.codexTerminalProfile?.serviceTier;
+  const profile = {
+    model: parsed.model,
+    reasoningEffort: parsed.effort,
+    serviceTier: typeof parsed.fast === 'boolean'
+      ? (parsed.fast ? 'priority' : 'default')
+      : (previousServiceTier || 'default'),
+    source: outputProfile ? 'terminal-output' : 'terminal-footer',
+  };
+  agent.codexTerminalProfile = profile;
+  return profile;
+}
+
+function terminalMetadataPatch(agent) {
+  const terminalStatus = deriveAgentTerminalStatus(agent);
+  return {
+    terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
+    shellCwd: agent.shellCwd || '',
+    shellLastExitCode: agent.shellLastExitCode ?? null,
+    shellLastEvent: agent.shellLastEvent || '',
+    shellCommand: agent.shellCommand || '',
+    shellLastCommand: agent.shellLastCommand || '',
+    shellCommandStartedAt: agent.shellCommandStartedAt ?? null,
+    shellLastCommandStartedAt: agent.shellLastCommandStartedAt ?? null,
+    shellLastCommandFinishedAt: agent.shellLastCommandFinishedAt ?? null,
+    shellLastCommandDurationMs: agent.shellLastCommandDurationMs ?? null,
+    terminalStatus,
+    runtimeObservation: deriveRuntimeObservation({ ...agent, terminalStatus }),
+  };
+}
+
 function terminalRuntimeStatus(agentStatus) {
   return agentStatus === 'stopped' || agentStatus === 'dead' ? 'exited' : agentStatus;
 }
@@ -198,6 +381,9 @@ function hasAgentOutputAfterAttentionBaseline(agent) {
 
 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 || '');
 }
@@ -208,9 +394,7 @@ function recoveredEngineSessionId(entry, metadata = {}) {
 
 function agentDisplayName(command) {
   const program = agentProgramName(command).toLowerCase();
-  if (program === 'codex') return 'codex';
-  if (program === 'claude') return 'claude code';
-  return program;
+  return getProviderAdapter(providerForProgram(program))?.displayName || program;
 }
 
 function titleComparisonKey(title) {
@@ -249,15 +433,8 @@ function isGenericSessionTitle(agent, title) {
 }
 
 function interruptInputForAgent(agent) {
-  const program = agentProgramName(agent && agent.command);
-  if (program === 'codex' || program === 'claude' || program === 'qodercli') {
-    return '\x1b';
-  }
-  return '\x03';
-}
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  const provider = agent?.providerSessionProvider || agentHomeProviderForProgram(agent?.command);
+  return getProviderAdapter(provider)?.interruptInput || '\x03';
 }
 
 function normalizePathValue(value) {
@@ -267,9 +444,44 @@ function normalizePathValue(value) {
   return trimmed.replace(/[\\/]+$/, '');
 }
 
-function timestampMs(value) {
-  const parsed = Date.parse(value || '');
-  return Number.isFinite(parsed) ? parsed : 0;
+function effectiveAgentWorkspaceRoot(agent) {
+  if (agent && agent.gitWorktree && agent.gitWorktree.workspace) {
+    return agent.gitWorktree.workspace;
+  }
+  return agent && (agent.projectWorkspace || agent.cwd) || '';
+}
+
+function publicAgentGitWorktree(agent) {
+  const worktree = agent && agent.gitWorktree;
+  if (!worktree || !worktree.workspace) return null;
+  return {
+    workspace: worktree.workspace,
+    commonDir: worktree.commonDir || '',
+    mainWorkspace: worktree.mainWorkspace || '',
+    linked: worktree.linked === true,
+    branch: worktree.branch || '',
+    head: worktree.head || '',
+    detached: worktree.detached === true,
+    locked: worktree.locked === true,
+    lockReason: worktree.lockReason || '',
+    prunable: worktree.prunable === true,
+    pruneReason: worktree.pruneReason || '',
+    worktrees: Array.isArray(worktree.worktrees)
+      ? worktree.worktrees.map(item => ({
+        workspace: item.workspace || '',
+        head: item.head || '',
+        branch: item.branch || '',
+        bare: item.bare === true,
+        detached: item.detached === true,
+        locked: item.locked === true,
+        lockReason: item.lockReason || '',
+        prunable: item.prunable === true,
+        pruneReason: item.pruneReason || '',
+        current: item.current === true,
+        main: item.main === true,
+      }))
+      : [],
+  };
 }
 
 function normalizePositiveInteger(value, fallback, min, max) {
@@ -289,7 +501,7 @@ function isRunningAgentRuntimeStatus(status) {
 }
 
 function isCodexAppServerAgent(agent) {
-  return agent && agent.codexRuntimeMode === 'app-server';
+  return runtimeKind(agent) === 'app-server';
 }
 
 function isLiveEngineSessionState(sessionState) {
@@ -340,24 +552,27 @@ class AgentManager extends EventEmitter {
       0,
       60 * 60 * 1000
     );
-    this.agents = new Map();
+    this.agents = new RuntimeAgentMap();
     this.mainAgentId = null;
     this.lastActivity = new Map();
     this.lastActivityUpdate = new Map();
     this.outputEvents = new Map(); // Map<agentId, Array<{timestamp, bytes}>> for rate tracking
+    this.agentUsageRateCache = new Map();
     this.lastResizeByAgent = new Map();
+    this.pendingResizeByAgent = new Map();
+    this.resizeDrains = new Map();
     this.inputQueues = new Map();
-    this.codexSessionResolveInFlight = new Map();
-    this.codexSessionResolveLastAttemptAt = new Map();
-    this.providerSessionTitleResolveInFlight = new Map();
-    this.providerSessionTitleResolveLastAttemptAt = new Map();
+    this.codexTerminalProfileQueues = new Map();
+    this.agentWorktreeResolveGeneration = new Map();
     this.permissionRestartInFlight = new Map();
     this.runtimeRestartInFlight = new Map();
+    this.codexSessionUnarchiveInFlight = new Map();
     this.permissionRestartSuppressedAgentIds = new Set();
     this.codexAppServerRuntime = options.codexAppServerRuntime || new CodexAppServerRuntime();
     this.jsonCliRuntime = options.jsonCliRuntime || new JsonCliRuntime();
-    this.acpRuntime = options.acpRuntime || new AcpRuntime(
-      process.env.FARMING_E2E_FAKE_ACP_AGENT === '1'
+    this.acpRuntime = options.acpRuntime || new AcpRuntime({
+      ...(this.configManager?.farmingDir ? { configDir: this.configManager.farmingDir } : {}),
+      ...(process.env.FARMING_E2E_FAKE_ACP_AGENT === '1'
         ? {
             resolveLaunch: () => ({
               command: process.execPath,
@@ -365,13 +580,31 @@ class AgentManager extends EventEmitter {
               version: 'e2e',
             }),
           }
-        : undefined
-    );
+        : {}),
+    });
+    this.archiveCodexSession = options.archiveCodexSession || archiveCodexSession;
+    this.unarchiveCodexSession = options.unarchiveCodexSession || unarchiveCodexSession;
     this.heartbeatInterval = null;
     this.disposed = false;
     this.systemMonitor = new SystemMonitor();
     this.startTime = Date.now();
     this.engineBridge = new SessionEngineBridge(configManager);
+    this.providerSessionService = new ProviderSessionService({
+      agents: this.agents,
+      getProviderHomes: () => this.configManager?.getSettings?.()?.agentHomes,
+      commit: (agent, change = {}) => {
+        if (change.kind === 'session-updated') this.ensurePersistentAgentSession(agent);
+        this.updateEngineProviderSessionMetadata(agent);
+        this.rememberMainPageProviderSession(agent);
+        if (change.event) {
+          this.emit('provider-session-updated', change.event);
+          this.emit('update');
+        }
+        if (change.refreshWorkspace) {
+          void this.refreshAgentWorktree(agent.id, change.refreshWorkspace);
+        }
+      },
+    });
     this.recoveryPromise = Promise.resolve();
     this.taskHistory = (this.configManager && this.configManager.getTaskHistory)
       ? [...this.configManager.getTaskHistory()]
@@ -393,17 +626,12 @@ class AgentManager extends EventEmitter {
     if (!this.jsonCliRuntime || typeof this.jsonCliRuntime.on !== 'function') return;
     this.jsonCliRuntime.on('agent-runtime', ({ agentId, state, error, sessionId }) => {
       const agent = this.agents.get(agentId);
-      if (!agent) return;
-      agent.jsonCliState = state || '';
-      agent.jsonCliError = error || '';
+      const runtime = runtimeBindingOf(agent, 'json');
+      if (!runtime) return;
+      runtime.state = state || '';
+      runtime.error = error || '';
       if (sessionId) {
-        agent.providerSessionId = sessionId;
-        agent.providerSessionTemporary = false;
-        agent.providerSessionKey = this.providerSessionKey(
-          agent.providerSessionProvider,
-          sessionId,
-          agent.providerHomeId || 'default'
-        );
+        this.providerSessionService.bindConfirmed(agentId, agent.providerSessionProvider, sessionId);
         this.ensurePersistentAgentSession(agent);
       }
       this.lastActivity.set(agentId, Date.now());
@@ -411,9 +639,10 @@ class AgentManager extends EventEmitter {
     });
     this.jsonCliRuntime.on('transcript', ({ agentId }) => {
       const agent = this.agents.get(agentId);
-      if (!agent) return;
-      agent.jsonCliEvents = this.jsonCliRuntime.getEvents(agentId);
-      agent.jsonCliTranscriptUpdatedAt = new Date().toISOString();
+      const runtime = runtimeBindingOf(agent, 'json');
+      if (!runtime) return;
+      runtime.events = this.jsonCliRuntime.getEvents(agentId);
+      runtime.transcriptUpdatedAt = new Date().toISOString();
       this.emit('update');
     });
   }
@@ -422,24 +651,19 @@ class AgentManager extends EventEmitter {
     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 }) => {
       const agent = this.agents.get(agentId);
-      if (!agent) return;
-      agent.acpState = state || '';
-      agent.acpError = error || '';
-      agent.acpStopReason = stopReason || '';
-      agent.acpPendingPermission = pendingPermission || null;
-      agent.acpPendingPermissions = Array.isArray(pendingPermissions) ? pendingPermissions : [];
-      agent.acpPendingElicitation = pendingElicitation || null;
-      agent.acpPendingElicitations = Array.isArray(pendingElicitations) ? pendingElicitations : [];
-      agent.acpActiveElicitations = Array.isArray(activeElicitations) ? activeElicitations : [];
-      agent.acpSessionUpdatedAt = updatedAt || '';
+      const runtime = runtimeBindingOf(agent, 'acp');
+      if (!runtime) return;
+      runtime.state = state || '';
+      runtime.error = error || '';
+      runtime.stopReason = stopReason || '';
+      runtime.pendingPermission = pendingPermission || null;
+      runtime.pendingPermissions = Array.isArray(pendingPermissions) ? pendingPermissions : [];
+      runtime.pendingElicitation = pendingElicitation || null;
+      runtime.pendingElicitations = Array.isArray(pendingElicitations) ? pendingElicitations : [];
+      runtime.activeElicitations = Array.isArray(activeElicitations) ? activeElicitations : [];
+      runtime.sessionUpdatedAt = updatedAt || '';
       if (sessionId) {
-        agent.providerSessionId = sessionId;
-        agent.providerSessionTemporary = false;
-        agent.providerSessionKey = this.providerSessionKey(
-          agent.providerSessionProvider,
-          sessionId,
-          agent.providerHomeId || 'default'
-        );
+        this.providerSessionService.bindConfirmed(agentId, agent.providerSessionProvider, sessionId);
         this.ensurePersistentAgentSession(agent);
       }
       if (state === 'working' || state === 'waiting-for-permission' || state === 'waiting-for-input') this.lastActivity.set(agentId, Date.now());
@@ -447,9 +671,10 @@ class AgentManager extends EventEmitter {
     });
     this.acpRuntime.on('session', ({ agentId, revision }) => {
       const agent = this.agents.get(agentId);
-      if (!agent) return;
-      agent.acpSessionUpdatedAt = new Date().toISOString();
-      agent.acpSessionRevision = Number.isFinite(Number(revision)) ? Number(revision) : (Number(agent.acpSessionRevision) || 0) + 1;
+      const runtime = runtimeBindingOf(agent, 'acp');
+      if (!runtime) return;
+      runtime.sessionUpdatedAt = new Date().toISOString();
+      runtime.sessionRevision = Number.isFinite(Number(revision)) ? Number(revision) : (Number(runtime.sessionRevision) || 0) + 1;
       this.emit('update');
     });
   }
@@ -458,34 +683,33 @@ class AgentManager extends EventEmitter {
     if (!this.codexAppServerRuntime || typeof this.codexAppServerRuntime.on !== 'function') return;
     this.codexAppServerRuntime.on('agent-runtime', ({ agentId, ...patch }) => {
       const agent = this.agents.get(agentId);
-      if (!agent) return;
+      const runtime = runtimeBindingOf(agent, 'app-server');
+      if (!runtime) return;
 
       if (typeof patch.threadId === 'string' && patch.threadId) {
-        agent.codexAppServerThreadId = patch.threadId;
-        agent.providerSessionId = patch.threadId;
-        agent.providerSessionTemporary = false;
-        agent.providerSessionKey = this.providerSessionKey(
+        runtime.threadId = patch.threadId;
+        this.providerSessionService.bindConfirmed(
+          agentId,
           agent.providerSessionProvider || 'codex',
-          patch.threadId,
-          agent.providerHomeId || 'default'
+          patch.threadId
         );
       }
-      if (typeof patch.turnId === 'string') agent.codexAppServerTurnId = patch.turnId;
-      if (typeof patch.state === 'string' && patch.state) agent.codexAppServerState = patch.state;
-      if (typeof patch.error === 'string') agent.codexAppServerError = patch.error;
-      if (typeof patch.pendingRequestId === 'string') agent.codexAppServerPendingRequestId = patch.pendingRequestId;
-      if (typeof patch.pendingRequestMethod === 'string') agent.codexAppServerPendingRequestMethod = patch.pendingRequestMethod;
+      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')) {
-        agent.codexAppServerPendingRequest = patch.pendingRequest || null;
+        runtime.pendingRequest = patch.pendingRequest || null;
       }
       if (Object.prototype.hasOwnProperty.call(patch, 'notice')) {
-        agent.codexAppServerNotice = patch.notice || null;
+        runtime.notice = patch.notice || null;
       }
       if (Object.prototype.hasOwnProperty.call(patch, 'goal')) {
-        agent.codexAppServerGoal = patch.goal || null;
+        runtime.goal = patch.goal || null;
       }
       if (typeof patch.transcriptUpdatedAt === 'string') {
-        agent.codexAppServerTranscriptUpdatedAt = patch.transcriptUpdatedAt;
+        runtime.transcriptUpdatedAt = patch.transcriptUpdatedAt;
       }
 
       if (patch.state === 'working' || patch.state === 'waiting-for-input') {
@@ -496,39 +720,57 @@ class AgentManager extends EventEmitter {
   }
 
   bindEngineEvents() {
-    this.engineBridge.on('session-started', ({ sessionId, status, startedAt }) => {
+    this.engineBridge.on('session-started', ({
+      sessionId,
+      status,
+      startedAt,
+      runtimeEpoch,
+      outputSeq,
+      stateRevision,
+    }) => {
         const agent = this.agents.get(sessionId);
         if (!agent) return;
 
+        const disposition = terminalStateUpdateDisposition(agent, runtimeEpoch, outputSeq, stateRevision);
+        if (!applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision, disposition)) return;
+        setPendingTerminalStartSyncCut(agent, runtimeEpoch, outputSeq, stateRevision);
+
         agent.engineStarted = true;
         agent.engineStatus = status || 'running';
         agent.startedAt = startedAt || Date.now();
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId, { force: true });
+        this.providerSessionService.observe(sessionId, { force: true });
         this.emit('update');
       });
 
-    this.engineBridge.on('session-output', ({ sessionId, data, engineName, outputSeq }) => {
+    this.engineBridge.on('session-output', ({
+      sessionId,
+      data,
+      engineName,
+      runtimeEpoch,
+      outputSeq,
+      stateRevision,
+    }) => {
         const agent = this.agents.get(sessionId);
         if (!agent) return;
 
+        const disposition = terminalStateUpdateDisposition(agent, runtimeEpoch, outputSeq, stateRevision);
+        if (!applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision, disposition)) return;
+        clearPendingTerminalStartSyncCut(agent);
+
         this.reviveAgentRuntime(agent);
         agent.output = trimSessionOutput(agent.output + data);
-        agent.lastEngineOutputAt = Date.now();
-        if (Number.isFinite(outputSeq)) {
-          agent.lastOutputSeq = outputSeq;
-        }
-
-        this.lastActivity.set(sessionId, Date.now());
+        const outputAt = Date.now();
+        agent.lastEngineOutputAt = outputAt;
+        this.lastActivity.set(sessionId, outputAt);
 
         // Track output events for rate calculation
         const events = this.outputEvents.get(sessionId) || [];
-        events.push({ timestamp: Date.now(), bytes: Buffer.byteLength(String(data), 'utf8') });
-        const cutoff = Date.now() - AGENT_USAGE_RATE_WINDOW_MS;
-        this.outputEvents.set(sessionId, events.filter(e => e.timestamp > cutoff));
+        events.push({ timestamp: outputAt, bytes: Buffer.byteLength(String(data), 'utf8') });
+        this.outputEvents.set(sessionId, events);
+        this.getAgentUsageRate(sessionId, { now: outputAt });
 
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId);
         const sessionSource = this.getEngineSessionSource(engineName);
         const stream = {
           agentId: sessionId,
@@ -538,44 +780,123 @@ class AgentManager extends EventEmitter {
         if (Number.isFinite(outputSeq)) {
           stream.outputSeq = outputSeq;
         }
+        if (Number.isFinite(stateRevision)) {
+          stream.stateRevision = stateRevision;
+        }
+        if (typeof runtimeEpoch === 'string' && runtimeEpoch) {
+          stream.runtimeEpoch = runtimeEpoch;
+        }
         this.emit('session-stream', stream);
       });
 
-    this.engineBridge.on('session-sync', ({ sessionId, output, engineName, replaceLive = true, outputSeq }) => {
+    this.engineBridge.on('session-transition', ({
+      sessionId,
+      engineName,
+      kind,
+      data = '',
+      runtimeEpoch,
+      outputSeq,
+      stateRevision,
+      cols,
+      rows,
+    }) => {
+      const agent = this.agents.get(sessionId);
+      if (!agent) return;
+      const disposition = terminalStateUpdateDisposition(agent, runtimeEpoch, outputSeq, stateRevision);
+      if (!applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision, disposition)) return;
+      clearPendingTerminalStartSyncCut(agent);
+      this.reviveAgentRuntime(agent);
+      if (kind === 'clear') {
+        agent.output = '';
+        agent.previewText = '';
+        agent.previewSnapshot = null;
+        this.outputEvents.delete(sessionId);
+        this.agentUsageRateCache.delete(sessionId);
+      }
+      if (Number.isFinite(cols) && cols > 0) agent.previewCols = cols;
+      if (Number.isFinite(rows) && rows > 0) agent.previewRows = rows;
+      this.lastActivity.set(sessionId, Date.now());
+      this.emit('session-stream', {
+        agentId: sessionId,
+        sessionSource: this.getEngineSessionSource(engineName),
+        kind,
+        data,
+        runtimeEpoch,
+        outputSeq,
+        stateRevision,
+        cols,
+        rows,
+      });
+      this.observeAgentAttentionState(sessionId);
+      this.emit('update');
+    });
+
+    this.engineBridge.on('session-sync', ({
+      sessionId,
+      output,
+      engineName,
+      replaceLive = true,
+      runtimeEpoch,
+      outputSeq,
+      stateRevision,
+      textOutput,
+      cols,
+      rows,
+    }) => {
         const agent = this.agents.get(sessionId);
         if (!agent) return;
 
+        const hydratesStartedCut = consumesPendingTerminalStartSyncCut(
+          agent,
+          runtimeEpoch,
+          outputSeq,
+          stateRevision,
+        );
+        const disposition = terminalStateUpdateDisposition(agent, runtimeEpoch, outputSeq, stateRevision);
+        if (
+          !hydratesStartedCut &&
+          !applyTerminalStateCursor(agent, runtimeEpoch, outputSeq, stateRevision, disposition)
+        ) return;
+        clearPendingTerminalStartSyncCut(agent);
+
         this.reviveAgentRuntime(agent);
-        agent.output = trimSessionOutput(output);
+        agent.output = trimSessionOutput(typeof textOutput === 'string' ? textOutput : output);
         agent.previewText = agent.output.slice(-2000);
-        if (Number.isFinite(outputSeq)) {
-          agent.lastOutputSeq = outputSeq;
-        }
         this.lastActivity.set(sessionId, Date.now());
 
         if (replaceLive) {
           const sessionSource = this.getEngineSessionSource(engineName);
           const stream = {
             agentId: sessionId,
-            data: agent.output,
+            data: output,
             sessionSource,
             replace: true,
           };
           if (Number.isFinite(outputSeq)) {
             stream.outputSeq = outputSeq;
           }
+          if (Number.isFinite(stateRevision)) {
+            stream.stateRevision = stateRevision;
+          }
+          if (typeof runtimeEpoch === 'string' && runtimeEpoch) {
+            stream.runtimeEpoch = runtimeEpoch;
+          }
+          if (Number.isFinite(cols) && cols > 0) {
+            stream.cols = cols;
+          }
+          if (Number.isFinite(rows) && rows > 0) {
+            stream.rows = rows;
+          }
           this.emit('session-stream', stream);
         }
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId);
         this.emit('update');
       });
 
-    this.engineBridge.on('session-preview', ({ sessionId, previewText, cols, rows, previewSnapshot, title }) => {
+    this.engineBridge.on('session-preview', ({ sessionId, previewText, cols, rows, previewSnapshot, title, runtimeEpoch }) => {
         const agent = this.agents.get(sessionId);
-        if (!agent) return;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
 
-        const revived = this.reviveAgentRuntime(agent);
         const titleChanged = typeof title === 'string'
           ? this.updateAgentSessionTitle(agent, title)
           : false;
@@ -587,44 +908,43 @@ class AgentManager extends EventEmitter {
         if (Number.isFinite(rows) && rows > 0) {
           agent.previewRows = rows;
         }
+        const terminalStatus = deriveAgentTerminalStatus(agent, {
+          previewText: agent.previewText,
+          title: agent.sessionTitle || '',
+          terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
+        });
         this.emit('session-preview-update', {
           agentId: sessionId,
           previewText: agent.previewText,
           cols: agent.previewCols || 80,
           rows: agent.previewRows || 30,
           previewSnapshot: agent.previewSnapshot,
-          terminalStatus: deriveAgentTerminalStatus(agent, {
-            previewText: agent.previewText,
-            title: agent.sessionTitle || '',
-            terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
-          }),
+          codexTerminalProfile: activeCodexTerminalProfile(agent, agent.previewText),
+          terminalStatus,
+          runtimeObservation: deriveRuntimeObservation({ ...agent, terminalStatus }),
         });
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId);
-        if (titleChanged || revived) {
+        if (titleChanged) {
           this.emit('update');
         }
       });
 
-    this.engineBridge.on('session-title', ({ sessionId, title }) => {
+    this.engineBridge.on('session-title', ({ sessionId, title, runtimeEpoch }) => {
         const agent = this.agents.get(sessionId);
-        if (!agent) return;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
 
         if (this.updateAgentSessionTitle(agent, title)) {
           this.observeAgentAttentionState(sessionId);
-          this.observeAgentStateChange(sessionId);
           this.emit('update');
         }
       });
 
-    this.engineBridge.on('session-activity', ({ sessionId, lastActivityAt }) => {
+    this.engineBridge.on('session-activity', ({ sessionId, lastActivityAt, runtimeEpoch }) => {
         const agent = this.agents.get(sessionId);
-        const revived = agent ? this.reviveAgentRuntime(agent) : false;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
         this.lastActivity.set(sessionId, lastActivityAt || Date.now());
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId);
         this.emitActivityUpdate(sessionId, lastActivityAt || Date.now());
-        if (revived) this.emit('update');
       });
 
     this.engineBridge.on('session-busy-state', (payload = {}) => {
@@ -642,9 +962,11 @@ class AgentManager extends EventEmitter {
           shellLastCommandDurationMs,
           statusMarkerSeen,
           busyMarkerSeen,
+          runtimeEpoch,
         } = payload;
         const agent = this.agents.get(sessionId);
-        if (!agent) return;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
+        const previousShellCwd = agent.shellCwd || '';
 
         const previousState = JSON.stringify({
           terminalBusy: agent.terminalBusy,
@@ -714,14 +1036,23 @@ class AgentManager extends EventEmitter {
           shellBusyMarkerSeen: agent.shellBusyMarkerSeen === true,
         });
         if (previousState === nextState) return;
+        if (agent.shellCwd && agent.shellCwd !== previousShellCwd) {
+          void this.refreshAgentWorktree(sessionId, agent.shellCwd);
+        }
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId);
-        this.emit('update');
+        this.emit('agent-update', { agentId: sessionId, patch: terminalMetadataPatch(agent) });
       });
 
-    this.engineBridge.on('session-exited', ({ sessionId, code, exitedAt }) => {
+    this.engineBridge.on('session-exited', ({
+      sessionId,
+      code,
+      exitedAt,
+      runtimeEpoch,
+      stateProofAvailable,
+    }) => {
         const agent = this.agents.get(sessionId);
-        if (!agent) return;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
+        clearPendingTerminalStartSyncCut(agent);
         if (this.permissionRestartSuppressedAgentIds.has(sessionId)) return;
 
         // A fresh App Server thread deliberately has no CLI/PTy observer until
@@ -730,13 +1061,29 @@ class AgentManager extends EventEmitter {
         // 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';
+          agent.engineStatus = 'dead';
+          agent.terminalBusy = false;
+          agent.exitedAt = exitedAt || Date.now();
+          const proofError = 'Terminal exited without an authoritative final checkpoint';
+          if (!String(agent.output || '').includes(proofError)) {
+            agent.output = trimSessionOutput(`${agent.output || ''}\n${proofError}`);
+          }
+          this.observeAgentAttentionState(sessionId);
+          this.providerSessionService.observe(sessionId, { force: true });
+          this.emit('update');
+          return;
+        }
+
         if (!agent.validated) {
-          this.stopCodexProviderSessionResolver(sessionId);
-          this.stopProviderSessionTitleResolver(sessionId);
+          this.providerSessionService.stop(sessionId);
           this.agents.delete(sessionId);
           this.lastActivity.delete(sessionId);
           this.lastActivityUpdate.delete(sessionId);
           this.outputEvents.delete(sessionId);
+          this.agentUsageRateCache.delete(sessionId);
           this.lastResizeByAgent.delete(sessionId);
 
           if (this.mainAgentId === sessionId) {
@@ -747,13 +1094,12 @@ class AgentManager extends EventEmitter {
           return;
         }
 
-        this.stopCodexProviderSessionResolver(sessionId);
-        this.stopProviderSessionTitleResolver(sessionId);
+        this.providerSessionService.stop(sessionId);
         agent.status = sessionId === this.mainAgentId ? 'dead' : 'stopped';
         agent.exitedAt = exitedAt || Date.now();
         agent.output = trimSessionOutput(`${agent.output}\nProcess exited with code ${code}`);
         this.observeAgentAttentionState(sessionId);
-        this.observeAgentStateChange(sessionId, { force: true });
+        this.providerSessionService.observe(sessionId, { force: true });
         if (sessionId !== this.mainAgentId) {
           this.recordTaskHistory(agent, {
             reason: 'process-exit',
@@ -763,9 +1109,9 @@ class AgentManager extends EventEmitter {
         this.emit('update');
       });
 
-    this.engineBridge.on('session-error', ({ sessionId, error, fatal = true }) => {
+    this.engineBridge.on('session-error', ({ sessionId, error, fatal = true, runtimeEpoch }) => {
         const agent = this.agents.get(sessionId);
-        if (!agent) return;
+        if (!agent || !terminalRuntimeEventMatches(agent, runtimeEpoch)) return;
         if (this.permissionRestartSuppressedAgentIds.has(sessionId)) return;
 
         if (fatal === false) {
@@ -803,12 +1149,37 @@ class AgentManager extends EventEmitter {
       // has already switched to ACP. Recovering that stale PTY first would
       // overwrite the persisted record back to `terminal` before
       // recoverAcpSessions() gets a chance to read it.
-      if (persisted?.agentRuntimeMode === 'acp') {
+      if (runtimeKind(persisted) === 'acp') {
         await this.killRecoveredEngineSession(entry, engineMetadata, agentId);
         continue;
       }
+      const persistedProvider = String(persisted?.providerSessionProvider || persisted?.provider || '').trim();
       const metadata = persisted ? {
         ...engineMetadata,
+        // The native host owns the live PTY/reducer state, but the Farming
+        // session record owns stable product identity. Legacy hosts can omit
+        // these fields during recovery; projecting that incomplete metadata
+        // even briefly makes Chat/Terminal switching disappear until a later
+        // provider resolver update happens to repair it.
+        source: persisted.source || engineMetadata.source,
+        projectWorkspace: persisted.projectWorkspace || engineMetadata.projectWorkspace,
+        provider: persistedProvider || engineMetadata.provider,
+        providerSessionProvider: persistedProvider || engineMetadata.providerSessionProvider,
+        providerHomeId: persisted.providerHomeId || engineMetadata.providerHomeId,
+        providerHomePath: persisted.providerHomePath || engineMetadata.providerHomePath,
+        providerSessionId: persisted.providerSessionId || engineMetadata.providerSessionId,
+        providerSessionKey: persisted.providerSessionKey || engineMetadata.providerSessionKey,
+        providerSessionTemporary: Object.prototype.hasOwnProperty.call(persisted, 'providerSessionTemporary')
+          ? persisted.providerSessionTemporary === true
+          : engineMetadata.providerSessionTemporary,
+        providerSessionSource: persisted.providerSessionSource || engineMetadata.providerSessionSource,
+        providerSessionResolvedAt: persisted.providerSessionResolvedAt || engineMetadata.providerSessionResolvedAt,
+        providerSessionTitle: persisted.providerSessionTitle || engineMetadata.providerSessionTitle,
+        providerSessionWorkspace: persisted.providerSessionWorkspace || engineMetadata.providerSessionWorkspace,
+        terminalInputReceived: Object.prototype.hasOwnProperty.call(persisted, 'terminalInputReceived')
+          ? persisted.terminalInputReceived === true
+          : engineMetadata.terminalInputReceived,
+        ...legacyRuntimeMetadata(persisted),
         pinned: persisted.pinned === true,
         projectOrder: finiteOrder(persisted.projectOrder) ?? finiteOrder(engineMetadata.projectOrder),
         pinnedOrder: finiteOrder(persisted.pinnedOrder) ?? finiteOrder(engineMetadata.pinnedOrder),
@@ -824,11 +1195,12 @@ class AgentManager extends EventEmitter {
       agentRecord.lastObservedTurnActive = this.isAgentAttentionTurnActive(agentRecord);
       this.ensurePersistentAgentSession(agentRecord);
       this.agents.set(agentId, agentRecord);
+      void this.refreshAgentWorktree(agentId);
       this.lastActivity.set(agentId, state.lastActivityAt || metadata.lastActivityAt || Date.now());
       if (agentRecord.wantsMain && !this.mainAgentId) {
         this.mainAgentId = agentId;
       }
-      this.activateProviderSessionTracking(agentId);
+      this.providerSessionService.activate(agentId);
       changed = true;
     }
 
@@ -836,29 +1208,272 @@ class AgentManager extends EventEmitter {
       this.emit('update');
     }
 
+    const runtimeRotations = this.engineBridge && typeof this.engineBridge.consumeRuntimeRotations === 'function'
+      ? this.engineBridge.consumeRuntimeRotations()
+      : [];
+    if (runtimeRotations.length > 0) {
+      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 liveProviderSessions = new Set(
+      [...this.agents.values()]
+        .filter(agent => agent?.providerSessionProvider && agent?.providerSessionId)
+        .map(agent => mainPageAgentSessionKey(
+          agent.providerSessionProvider,
+          agent.providerSessionId,
+          agent.providerHomeId || 'default'
+        ))
+        .filter(Boolean)
+    );
+    const recordList = Array.isArray(records) ? records : [];
+    const recordByRuntimeAgentId = new Map(recordList
+      .filter(record => record && typeof record.runtimeAgentId === 'string' && record.runtimeAgentId)
+      .map(record => [record.runtimeAgentId, record]));
+    const serializedStates = [];
+    for (const rotation of Array.isArray(rotations) ? rotations : []) {
+      if (!rotation || typeof rotation.serializedTerminalState !== 'string' || !rotation.serializedTerminalState) continue;
+      try {
+        serializedStates.push(...deserializeTerminalState(rotation.serializedTerminalState));
+      } catch (error) {
+        console.warn(
+          'Ignoring invalid serialized terminal state after native PTY runtime rotation:',
+          error && (error.message || error)
+        );
+      }
+    }
+    const serializedByRuntimeAgentId = new Map(serializedStates.map(state => [state.id, state]));
+    const candidateKeys = new Set();
+    const fallbackCandidates = recordList
+      .filter(record => {
+        if (!record || record.archived === true) return false;
+        if (runtimeKind(record) !== 'terminal') return false;
+        const provider = String(record.providerSessionProvider || record.provider || '').trim();
+        if (!getProviderAdapter(provider)) return false;
+        if (!isSafeProviderSessionId(record.providerSessionId)) return false;
+        const sessionKey = record.providerSessionKey || mainPageAgentSessionKey(
+          provider,
+          record.providerSessionId,
+          record.providerHomeId || 'default'
+        );
+        if (!sessionKey || liveProviderSessions.has(sessionKey)) return false;
+        if (record.wantsMain === true) return !this.mainAgentId;
+        return mainPageOrder.has(sessionKey);
+      })
+      .sort((left, right) => {
+        if (left.wantsMain === true && right.wantsMain !== true) return -1;
+        if (right.wantsMain === true && left.wantsMain !== true) return 1;
+        const leftProvider = String(left.providerSessionProvider || left.provider || '').trim();
+        const rightProvider = String(right.providerSessionProvider || right.provider || '').trim();
+        const leftKey = left.providerSessionKey || mainPageAgentSessionKey(
+          leftProvider,
+          left.providerSessionId,
+          left.providerHomeId || 'default'
+        );
+        const rightKey = right.providerSessionKey || mainPageAgentSessionKey(
+          rightProvider,
+          right.providerSessionId,
+          right.providerHomeId || 'default'
+        );
+        const orderDelta = (mainPageOrder.get(leftKey) ?? Number.MAX_SAFE_INTEGER) -
+          (mainPageOrder.get(rightKey) ?? Number.MAX_SAFE_INTEGER);
+        if (orderDelta !== 0) return orderDelta;
+        return (Number(right.updatedAt) || 0) - (Number(left.updatedAt) || 0);
+      })
+      .filter(record => {
+        const provider = String(record.providerSessionProvider || record.provider || '').trim();
+        const sessionKey = record.providerSessionKey || mainPageAgentSessionKey(
+          provider,
+          record.providerSessionId,
+          record.providerHomeId || 'default'
+        );
+        if (candidateKeys.has(sessionKey)) return false;
+        candidateKeys.add(sessionKey);
+        return true;
+      });
+    const candidates = serializedByRuntimeAgentId.size > 0
+      ? [...serializedByRuntimeAgentId.values()]
+        .map(serializedState => ({
+          ...(serializedState.metadata || {}),
+          ...(recordByRuntimeAgentId.get(serializedState.id) || {}),
+          runtimeAgentId: serializedState.id,
+          serializedState,
+        }))
+        .filter(record => {
+          if (!record || record.archived === true) return false;
+          return runtimeKind(record) === 'terminal';
+        })
+        .sort((left, right) => {
+          if (left.wantsMain === true && right.wantsMain !== true) return -1;
+          if (right.wantsMain === true && left.wantsMain !== true) return 1;
+          return (Number(right.updatedAt) || 0) - (Number(left.updatedAt) || 0);
+        })
+      : fallbackCandidates;
+
+    if (candidates.length > 0) {
+      const rotationSummary = (Array.isArray(rotations) ? rotations : []).map(rotation => {
+        const { serializedTerminalState, ...rest } = rotation || {};
+        return {
+          ...rest,
+          serializedTerminalStateBytes: typeof serializedTerminalState === 'string'
+            ? Buffer.byteLength(serializedTerminalState, 'utf8')
+            : 0,
+        };
+      });
+      console.warn(
+        `Restoring ${candidates.length} Terminal session(s) after native PTY runtime rotation`,
+        rotationSummary
+      );
+    }
+
+    let changed = false;
+    for (const record of candidates) {
+      if (record.wantsMain === true && this.mainAgentId) continue;
+      const provider = String(record.providerSessionProvider || record.provider || '').trim();
+      const sessionId = record.providerSessionId;
+      const sessionKey = record.providerSessionKey || mainPageAgentSessionKey(
+        provider,
+        sessionId,
+        record.providerHomeId || 'default'
+      );
+      if (sessionKey && liveProviderSessions.has(sessionKey)) continue;
+      const canResumeProvider = Boolean(getProviderAdapter(provider))
+        && isSafeProviderSessionId(sessionId);
+      const command = canResumeProvider
+        ? buildAgentSessionResumeCommand(provider, sessionId, {
+            cwd: record.cwd || record.projectWorkspace || '',
+            providerHomePath: record.providerHomePath || '',
+          })
+        : (
+            record.forkCommand ||
+            record.command ||
+            record.serializedState?.processLaunchConfig?.command ||
+            ''
+          );
+      if (!command) continue;
+
+      const options = {
+        wantsMain: record.wantsMain === true,
+        skipRecoveryWait: true,
+        task: record.task || record.providerSessionTitle || '',
+        workflowTemplate: record.workflowTemplate || '',
+        projectWorkspace: record.projectWorkspace || record.cwd || '',
+        source: canResumeProvider
+          ? resumedAgentSource(provider, sessionId, record.providerHomeId || 'default')
+          : (record.source || 'terminal-revive'),
+        providerHomeId: record.providerHomeId || '',
+        providerHomePath: record.providerHomePath || '',
+        providerSessionTitle: record.providerSessionTitle || '',
+        restartedFromAgentId: record.restartedFromAgentId || '',
+        restartedFromAgentIds: Array.isArray(record.restartedFromAgentIds)
+          ? record.restartedFromAgentIds
+          : [],
+        projectOrder: finiteOrder(record.projectOrder),
+        pinnedOrder: finiteOrder(record.pinnedOrder),
+        customTitle: record.customTitle || '',
+        persistentSessionId: record.id || '',
+        runtimeAgentId: record.runtimeAgentId || '',
+        reviveTerminalState: record.serializedState || null,
+        ...(provider === 'codex'
+          ? {
+              codexApprovalMode: record.launchPermissionMode || undefined,
+              ...preserveCodexSessionProfileOptions(),
+            }
+          : {}),
+        ...(provider === 'claude'
+          ? { claudePermissionMode: record.launchPermissionMode || undefined }
+          : {}),
+      };
+
+      let restartedAgentId = null;
+      try {
+        restartedAgentId = await this.startAgent(
+          command,
+          record.cwd || record.projectWorkspace || null,
+          null,
+          options
+        );
+      } catch (error) {
+        console.warn(
+          `Failed to restore Terminal session ${record.runtimeAgentId || sessionId} after native PTY runtime rotation:`,
+          error && (error.message || error)
+        );
+        continue;
+      }
+      const replacement = restartedAgentId ? this.agents.get(restartedAgentId) : null;
+      if (!replacement) {
+        console.warn(
+          `Failed to restore Terminal session ${record.runtimeAgentId || sessionId} after native PTY runtime rotation`
+        );
+        continue;
+      }
+
+      replacement.pinned = record.pinned === true;
+      replacement.projectOrder = finiteOrder(record.projectOrder);
+      replacement.pinnedOrder = finiteOrder(record.pinnedOrder);
+      replacement.customTitle = record.customTitle || replacement.customTitle || '';
+      replacement.terminalInputReceived = record.terminalInputReceived === true;
+      replacement.attentionSeq = finiteNonNegativeInteger(record.attentionSeq);
+      replacement.readAttentionSeq = finiteNonNegativeInteger(record.readAttentionSeq);
+      replacement.attentionUpdatedAt = finiteNumberOrNull(record.attentionUpdatedAt);
+      replacement.readAttentionAt = finiteNumberOrNull(record.readAttentionAt);
+      replacement.attentionReason = record.attentionReason || '';
+      replacement.attentionOutputSeq = finiteNumberOrNull(record.attentionOutputSeq);
+      replacement.unread = agentAttentionUnread(replacement);
+      this.ensurePersistentAgentSession(replacement);
+      if (sessionKey) liveProviderSessions.add(sessionKey);
+      changed = true;
+    }
+    if (changed) this.emit('update');
+  }
+
   async recoverAcpSessions() {
     if (!this.acpRuntime || !this.configManager || typeof this.configManager.listAgentSessionRecords !== 'function') return;
-    for (const record of this.configManager.listAgentSessionRecords()) {
-      if (!record || record.archived === true || record.agentRuntimeMode !== 'acp') continue;
+    const mainPageOrder = new Map(this.getMainPageSessionKeys().map((key, index) => [key, index]));
+    const records = this.configManager.listAgentSessionRecords()
+      .filter(record => record && record.archived !== true && runtimeKind(record) === 'acp')
+      .sort((left, right) => {
+        const leftOrder = mainPageOrder.get(left.providerSessionKey);
+        const rightOrder = mainPageOrder.get(right.providerSessionKey);
+        return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
+      });
+
+    // Materialize every recoverable row before loading any transcript. Large
+    // Codex histories can take tens of seconds each; creating rows one by one
+    // after every await temporarily leaves later main-page sessions invisible
+    // in both Projects and History.
+    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();
-      if (!agentId || !sessionId || !['codex', 'claude', 'opencode', 'qoder'].includes(provider)) continue;
-      let agent = this.agents.get(agentId);
+      if (!agentId || !sessionId || !providerSupportsRuntime(provider, 'acp')) continue;
+      const 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);
+        const recoveredAgent = this.recoveredAgentRecord(agentId, record.engine || 'native', record, { status: 'running' });
+        ensureAgentOrders(recoveredAgent, Array.from(this.agents.values()));
+        recoveredAgent.persistentSessionId = record.id || '';
+        recoveredAgent.engineStarted = false;
+        runtimeBindingOf(recoveredAgent, 'acp').state = 'connecting';
+        this.agents.set(agentId, recoveredAgent);
+        void this.refreshAgentWorktree(agentId);
         this.lastActivity.set(agentId, Date.now());
       }
+    }
+    this.emit('update');
+
+    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 agent = this.agents.get(agentId);
+      if (!agent || !sessionId || !providerSupportsRuntime(provider, 'acp')) continue;
       try {
-        const executableName = provider === 'qoder' ? 'qodercli' : provider;
+        const executableName = getProviderAdapter(provider).executable;
         const executable = resolveAgentExecutable(executableName) || executableName;
         const approvalMode = agent.launchPermissionMode || (
           provider === 'codex' && this.configManager.getCodexApprovalMode
@@ -872,31 +1487,29 @@ class AgentManager extends EventEmitter {
           env: this.buildAgentEnv(agentId, agent),
           cwd: agent.cwd,
           sessionId,
-          historyMode: 'load',
+          historyMode: 'checkpoint',
+          providerHomeId: agent.providerHomeId || record.providerHomeId || 'default',
           approvalMode,
-          model: this.configManager.getCodexModel
-            ? this.configManager.getCodexModel()
-            : '',
-          reasoningEffort: this.configManager.getCodexReasoningEffort
-            ? this.configManager.getCodexReasoningEffort()
-            : '',
-          serviceTier: this.configManager.getCodexServiceTier
-            ? this.configManager.getCodexServiceTier()
-            : '',
+          // Let Codex resolve its selected Home config and existing session
+          // state instead of applying today's Farming launch defaults.
+          model: 'config',
+          reasoningEffort: 'config',
+          serviceTier: 'config',
         });
         agent.providerSessionId = prepared.sessionId;
         agent.providerSessionTemporary = false;
         agent.providerSessionSource = `acp-${prepared.historyMode}`;
-        agent.agentRuntimeMode = 'acp';
-        agent.acpState = 'idle';
-        agent.acpError = '';
+        const runtime = replaceRuntimeBinding(agent, 'acp', runtimeBindingOf(agent, 'acp'));
+        runtime.state = 'idle';
+        runtime.error = '';
         agent.status = 'running';
         agent.engineStatus = 'running';
         agent.engineStarted = false;
         this.ensurePersistentAgentSession(agent);
       } catch (error) {
-        agent.acpState = 'error';
-        agent.acpError = `ACP recovery failed: ${error && (error.message || error)}`;
+        const runtime = runtimeBindingOf(agent, 'acp');
+        runtime.state = 'error';
+        runtime.error = `ACP recovery failed: ${error && (error.message || error)}`;
         agent.status = 'stopped';
         agent.engineStatus = 'stopped';
         agent.engineStarted = false;
@@ -911,7 +1524,7 @@ class AgentManager extends EventEmitter {
     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 || record.codexRuntimeMode !== 'app-server') continue;
+      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();
@@ -924,16 +1537,7 @@ class AgentManager extends EventEmitter {
           }
           if (agent) {
             ensureAgentOrders(agent, Array.from(this.agents.values()));
-            agent.codexRuntimeMode = 'cli';
-            agent.codexAppServerHomePath = '';
-            agent.codexAppServerState = '';
-            agent.codexAppServerEndpoint = '';
-            agent.codexAppServerTurnId = '';
-            agent.codexAppServerError = '';
-            agent.codexAppServerPendingRequestId = '';
-            agent.codexAppServerPendingRequestMethod = '';
-            agent.codexAppServerPendingRequest = null;
-            agent.codexCliObserverDeferred = false;
+            replaceRuntimeBinding(agent, 'terminal');
             this.ensurePersistentAgentSession(agent);
             this.updateEngineProviderSessionMetadata(agent);
           }
@@ -947,6 +1551,7 @@ class AgentManager extends EventEmitter {
         agent.persistentSessionId = record.id || '';
         agent.engineStarted = false;
         this.agents.set(agentId, agent);
+        void this.refreshAgentWorktree(agentId);
         this.lastActivity.set(agentId, Date.now());
       }
       try {
@@ -961,24 +1566,26 @@ class AgentManager extends EventEmitter {
           executable,
           env: this.buildAgentEnv(agentId, agent),
           cwd: agent.cwd,
-          workspaceRoot: agent.projectWorkspace || agent.cwd,
+          workspaceRoot: effectiveAgentWorkspaceRoot(agent),
           approvalMode: agent.launchPermissionMode || 'approve',
         });
-        agent.codexAppServerThreadId = binding.threadId;
-        agent.codexAppServerState = 'idle';
-        agent.codexAppServerError = '';
+        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;
-        agent.codexCliObserverDeferred = false;
+        runtime.observerDeferred = false;
         agent.exitedAt = null;
-        this.activateProviderSessionTracking(agentId);
+        this.providerSessionService.activate(agentId);
         this.ensurePersistentAgentSession(agent);
       } catch (error) {
-        agent.codexAppServerError = `Codex App Server recovery failed: ${error && (error.message || error)}`;
-        agent.codexAppServerState = '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;
@@ -1007,6 +1614,15 @@ class AgentManager extends EventEmitter {
     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,
+    });
     return {
       id: agentId,
       command: metadata.forkCommand || metadata.command || '',
@@ -1042,34 +1658,14 @@ class AgentManager extends EventEmitter {
       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.
-      codexRuntimeMode: recoverCodexAppServer ? 'app-server' : 'cli',
-      agentRuntimeMode: metadata.agentRuntimeMode === 'acp' ? 'acp' : (metadata.agentRuntimeMode === 'json' ? 'json' : 'terminal'),
-      acpState: metadata.agentRuntimeMode === 'acp' ? (metadata.acpState || '') : '',
-      acpError: metadata.agentRuntimeMode === 'acp' ? (metadata.acpError || '') : '',
-      acpStopReason: metadata.agentRuntimeMode === 'acp' ? (metadata.acpStopReason || '') : '',
-      acpPendingPermission: null,
-      acpPendingPermissions: [],
-      acpPendingElicitation: null,
-      acpPendingElicitations: [],
-      acpActiveElicitations: [],
-      acpSessionUpdatedAt: metadata.agentRuntimeMode === 'acp' ? (metadata.acpSessionUpdatedAt || '') : '',
-      acpSessionRevision: metadata.agentRuntimeMode === 'acp' ? (Number(metadata.acpSessionRevision) || 0) : 0,
-      codexAppServerHomePath: recoverCodexAppServer ? metadata.codexAppServerHomePath : '',
-      codexAppServerState: recoverCodexAppServer ? (metadata.codexAppServerState || '') : '',
-      codexAppServerEndpoint: recoverCodexAppServer ? (metadata.codexAppServerEndpoint || '') : '',
-      codexAppServerThreadId: metadata.codexAppServerThreadId || metadata.providerSessionId || '',
-      codexAppServerTurnId: recoverCodexAppServer ? (metadata.codexAppServerTurnId || '') : '',
-      codexAppServerError: recoverCodexAppServer ? (metadata.codexAppServerError || '') : '',
-      codexAppServerPendingRequestId: recoverCodexAppServer ? (metadata.codexAppServerPendingRequestId || '') : '',
-      codexAppServerPendingRequestMethod: recoverCodexAppServer ? (metadata.codexAppServerPendingRequestMethod || '') : '',
-      codexAppServerPendingRequest: recoverCodexAppServer ? (metadata.codexAppServerPendingRequest || null) : null,
-      codexCliObserverDeferred: false,
+      runtimeBinding,
       forkedFromProviderSessionId: metadata.forkedFromProviderSessionId || '',
       restartedFromAgentId: metadata.restartedFromAgentId || '',
       restartedFromAgentIds: Array.isArray(metadata.restartedFromAgentIds)
@@ -1095,7 +1691,10 @@ class AgentManager extends EventEmitter {
       attentionUpdatedAt: finiteNumberOrNull(metadata.attentionUpdatedAt),
       readAttentionAt: finiteNumberOrNull(metadata.readAttentionAt),
       attentionReason: metadata.attentionReason || '',
+      attentionOutputEpoch: metadata.attentionOutputEpoch || '',
       attentionOutputSeq: finiteNumberOrNull(metadata.attentionOutputSeq),
+      readOutputEpoch: metadata.readOutputEpoch || '',
+      readOutputSeq: finiteNumberOrNull(metadata.readOutputSeq),
       unread: finiteNonNegativeInteger(metadata.attentionSeq) > finiteNonNegativeInteger(metadata.readAttentionSeq),
       archived: false,
       archivedAt: null,
@@ -1104,6 +1703,8 @@ class AgentManager extends EventEmitter {
       engineStarted: true,
       engineStatus: state.status || 'running',
       startedAt: state.startedAt || metadata.startedAt || Date.now(),
+      runtimeEpoch: typeof state.runtimeEpoch === 'string' ? state.runtimeEpoch : '',
+      stateRevision: finiteNumberOrNull(state.stateRevision),
       lastEngineOutputAt: Date.now(),
       lastOutputSeq: finiteNumberOrNull(state.outputSeq),
       attentionRequiresNewOutput: true,
@@ -1140,10 +1741,6 @@ class AgentManager extends EventEmitter {
     return Number.isFinite(startedAt) && Date.now() - startedAt < MISSING_ENGINE_SESSION_STARTUP_GRACE_MS;
   }
 
-  providerSessionKey(provider, sessionId, providerHomeId = '') {
-    return provider && sessionId ? mainPageAgentSessionKey(provider, sessionId, providerHomeId) : '';
-  }
-
   getMainPageSessionKeys() {
     if (this.configManager && typeof this.configManager.getMainPageSessionKeys === 'function') {
       return this.configManager.getMainPageSessionKeys();
@@ -1177,19 +1774,6 @@ class AgentManager extends EventEmitter {
     return persistentSessionId;
   }
 
-  currentProviderSessionIds(provider, excludedAgentId = '', providerHomeId = 'default') {
-    const ids = new Set();
-    const normalizedHomeId = String(providerHomeId || 'default').trim() || 'default';
-    for (const agent of this.agents.values()) {
-      if (!agent || agent.id === excludedAgentId) continue;
-      if (agent.providerSessionProvider !== provider) continue;
-      if ((String(agent.providerHomeId || 'default').trim() || 'default') !== normalizedHomeId) continue;
-      if (!agent.providerSessionId || agent.providerSessionTemporary === true) continue;
-      ids.add(agent.providerSessionId);
-    }
-    return ids;
-  }
-
   rememberMainPageProviderSession(agent) {
     if (!agent || agent.wantsMain) return;
     if (!agent.providerSessionProvider || !agent.providerSessionId || agent.providerSessionTemporary === true) return;
@@ -1197,7 +1781,7 @@ class AgentManager extends EventEmitter {
       return;
     }
 
-    const sessionKey = this.providerSessionKey(agent.providerSessionProvider, agent.providerSessionId, agent.providerHomeId || '');
+    const sessionKey = mainPageAgentSessionKey(agent.providerSessionProvider, agent.providerSessionId, agent.providerHomeId || '');
     if (!sessionKey) return;
     const currentKeys = this.getMainPageSessionKeys();
     if (currentKeys[0] === sessionKey) {
@@ -1230,23 +1814,7 @@ class AgentManager extends EventEmitter {
       providerSessionResolvedAt: agent.providerSessionResolvedAt || null,
       providerSessionTitle: agent.providerSessionTitle || '',
       terminalInputReceived: agent.terminalInputReceived === true,
-      codexRuntimeMode: agent.codexRuntimeMode || '',
-      agentRuntimeMode: agent.agentRuntimeMode || 'terminal',
-      acpState: agent.acpState || '',
-      acpError: agent.acpError || '',
-      acpStopReason: agent.acpStopReason || '',
-      acpSessionUpdatedAt: agent.acpSessionUpdatedAt || '',
-      acpSessionRevision: Number(agent.acpSessionRevision) || 0,
-      codexAppServerHomePath: agent.codexAppServerHomePath || '',
-      codexAppServerState: agent.codexAppServerState || '',
-      codexAppServerEndpoint: agent.codexAppServerEndpoint || '',
-      codexAppServerThreadId: agent.codexAppServerThreadId || '',
-      codexAppServerTurnId: agent.codexAppServerTurnId || '',
-      codexAppServerError: agent.codexAppServerError || '',
-      codexAppServerPendingRequestId: agent.codexAppServerPendingRequestId || '',
-      codexAppServerPendingRequestMethod: agent.codexAppServerPendingRequestMethod || '',
-      codexAppServerPendingRequest: agent.codexAppServerPendingRequest || null,
-      codexCliObserverDeferred: agent.codexCliObserverDeferred === true,
+      ...legacyRuntimeMetadata(agent),
       forkedFromProviderSessionId: agent.forkedFromProviderSessionId || '',
       launchPermissionMode: agent.launchPermissionMode || '',
       attentionSeq: finiteNonNegativeInteger(agent.attentionSeq),
@@ -1254,7 +1822,10 @@ class AgentManager extends EventEmitter {
       attentionUpdatedAt: finiteNumberOrNull(agent.attentionUpdatedAt),
       readAttentionAt: finiteNumberOrNull(agent.readAttentionAt),
       attentionReason: agent.attentionReason || '',
+      attentionOutputEpoch: agent.attentionOutputEpoch || '',
       attentionOutputSeq: finiteNumberOrNull(agent.attentionOutputSeq),
+      readOutputEpoch: agent.readOutputEpoch || '',
+      readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
       projectOrder: finiteOrder(agent.projectOrder),
       pinnedOrder: finiteOrder(agent.pinnedOrder),
     })).catch((error) => {
@@ -1262,33 +1833,6 @@ class AgentManager extends EventEmitter {
     });
   }
 
-  activateProviderSessionTracking(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent || !agent.providerSessionProvider || !agent.providerSessionId) return;
-
-    if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
-      this.observeAgentStateChange(agentId, { force: true });
-      return;
-    }
-
-    this.stopCodexProviderSessionResolver(agentId);
-    this.updateEngineProviderSessionMetadata(agent);
-    this.rememberMainPageProviderSession(agent);
-    this.attemptProviderSessionTitleResolution(agentId, { force: true }).catch((error) => {
-      console.warn('Failed to resolve provider session title:', error && (error.message || error));
-    });
-  }
-
-  stopCodexProviderSessionResolver(agentId) {
-    this.codexSessionResolveInFlight.delete(agentId);
-    this.codexSessionResolveLastAttemptAt.delete(agentId);
-  }
-
-  stopProviderSessionTitleResolver(agentId) {
-    this.providerSessionTitleResolveInFlight.delete(agentId);
-    this.providerSessionTitleResolveLastAttemptAt.delete(agentId);
-  }
-
   isAgentAttentionTurnActive(agent) {
     if (!agent) return false;
     if (agent.status === 'pending') return true;
@@ -1333,8 +1877,16 @@ class AgentManager extends EventEmitter {
     agent.attentionSeq = nextSeq;
     agent.attentionUpdatedAt = now;
     agent.attentionReason = reason;
+    agent.attentionOutputEpoch = typeof agent.runtimeEpoch === 'string' ? agent.runtimeEpoch : '';
     agent.attentionOutputSeq = Number.isFinite(agent.lastOutputSeq) ? agent.lastOutputSeq : null;
-    if (agent.attentionAutoReadNext === true) {
+    const attentionOutputAlreadyRead = Boolean(
+      agent.attentionOutputEpoch
+      && agent.attentionOutputEpoch === agent.readOutputEpoch
+      && agent.attentionOutputSeq !== null
+      && Number.isFinite(agent.readOutputSeq)
+      && agent.attentionOutputSeq <= agent.readOutputSeq
+    );
+    if (agent.attentionAutoReadNext === true || attentionOutputAlreadyRead) {
       agent.attentionAutoReadNext = false;
       agent.readAttentionSeq = nextSeq;
       agent.readAttentionAt = now;
@@ -1351,7 +1903,7 @@ class AgentManager extends EventEmitter {
     };
   }
 
-  markAgentReadCursor(agentId, readAttentionSeq) {
+  markAgentReadCursor(agentId, readAttentionSeq, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) {
       return { error: 'Agent not found' };
@@ -1370,7 +1922,7 @@ class AgentManager extends EventEmitter {
     if (changed) {
       this.ensurePersistentAgentSession(agent);
       this.updateEngineProviderSessionMetadata(agent);
-      this.emit('update');
+      if (options.emitUpdate !== false) this.emit('update');
     }
     return {
       agentId,
@@ -1381,6 +1933,48 @@ class AgentManager extends EventEmitter {
     };
   }
 
+  markAgentReadOutputCut(agentId, runtimeEpoch, outputSeq) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      return { error: 'Agent not found' };
+    }
+
+    const currentRuntimeEpoch = typeof agent.runtimeEpoch === 'string' ? agent.runtimeEpoch : '';
+    const requestedRuntimeEpoch = typeof runtimeEpoch === 'string' ? runtimeEpoch : '';
+    const currentOutputSeq = finiteNumberOrNull(agent.lastOutputSeq);
+    if (
+      !currentRuntimeEpoch
+      || requestedRuntimeEpoch !== currentRuntimeEpoch
+      || currentOutputSeq === null
+      || !Number.isFinite(outputSeq)
+    ) {
+      return {
+        agentId,
+        readOutputEpoch: typeof agent.readOutputEpoch === 'string' ? agent.readOutputEpoch : '',
+        readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
+        changed: false,
+      };
+    }
+
+    const requestedOutputSeq = Math.max(0, Math.floor(outputSeq));
+    const nextOutputSeq = Math.min(currentOutputSeq, requestedOutputSeq);
+    const previousOutputSeq = agent.readOutputEpoch === currentRuntimeEpoch
+      ? finiteNumberOrNull(agent.readOutputSeq)
+      : null;
+    const readOutputSeq = previousOutputSeq === null
+      ? nextOutputSeq
+      : Math.max(previousOutputSeq, nextOutputSeq);
+    const changed = agent.readOutputEpoch !== currentRuntimeEpoch || previousOutputSeq !== readOutputSeq;
+    agent.readOutputEpoch = currentRuntimeEpoch;
+    agent.readOutputSeq = readOutputSeq;
+    return {
+      agentId,
+      readOutputEpoch: agent.readOutputEpoch,
+      readOutputSeq: agent.readOutputSeq,
+      changed,
+    };
+  }
+
   markAgentUnreadCursor(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -1405,182 +1999,47 @@ class AgentManager extends EventEmitter {
       this.updateEngineProviderSessionMetadata(agent);
       this.emit('update');
     }
-    return {
-      agentId,
-      attentionSeq: agent.attentionSeq,
-      readAttentionSeq: agent.readAttentionSeq,
-      unread: agent.unread,
-      changed,
-    };
-  }
-
-  observeAgentStateChange(agentId, options = {}) {
-    this.attemptCodexProviderSessionResolution(agentId, options).catch((error) => {
-      console.warn('Failed to resolve Codex provider session:', error && (error.message || error));
-    });
-    this.attemptProviderSessionTitleResolution(agentId, options).catch((error) => {
-      console.warn('Failed to resolve provider session title:', error && (error.message || error));
-    });
-  }
-
-  attemptCodexProviderSessionResolution(agentId, options = {}) {
-    const agent = this.agents.get(agentId);
-    if (!agent || agent.providerSessionProvider !== 'codex' || agent.providerSessionTemporary !== true) {
-      this.stopCodexProviderSessionResolver(agentId);
-      return Promise.resolve(false);
-    }
-
-    const inFlight = this.codexSessionResolveInFlight.get(agentId);
-    if (inFlight) return inFlight;
-
-    const now = Date.now();
-    const lastAttemptAt = this.codexSessionResolveLastAttemptAt.get(agentId) || 0;
-    if (options.force !== true && now - lastAttemptAt < CODEX_PROVIDER_SESSION_RESOLVE_COOLDOWN_MS) {
-      return Promise.resolve(false);
-    }
-    this.codexSessionResolveLastAttemptAt.set(agentId, now);
-
-    const attempt = this.findCodexSessionForTemporaryAgent(agent)
-      .then((session) => {
-        if (!session || !session.id) return false;
-        return this.resolveProviderSession(agentId, {
-          provider: 'codex',
-          sessionId: session.id,
-          source: 'codex-rollout',
-          title: session.title || '',
-        });
-      })
-      .catch(() => false)
-      .finally(() => {
-        if (this.codexSessionResolveInFlight.get(agentId) === attempt) {
-          this.codexSessionResolveInFlight.delete(agentId);
-        }
-      });
-    this.codexSessionResolveInFlight.set(agentId, attempt);
-    return attempt;
-  }
-
-  attemptProviderSessionTitleResolution(agentId, options = {}) {
-    const agent = this.agents.get(agentId);
-    if (
-      !agent
-      || !agent.providerSessionProvider
-      || !agent.providerSessionId
-      || agent.providerSessionTemporary === true
-      || isTemporaryProviderSessionId(agent.providerSessionId)
-      || String(agent.providerSessionTitle || '').trim()
-    ) {
-      this.stopProviderSessionTitleResolver(agentId);
-      return Promise.resolve(false);
-    }
-
-    const inFlight = this.providerSessionTitleResolveInFlight.get(agentId);
-    if (inFlight) return inFlight;
-
-    const now = Date.now();
-    const lastAttemptAt = this.providerSessionTitleResolveLastAttemptAt.get(agentId) || 0;
-    if (options.force !== true && now - lastAttemptAt < PROVIDER_SESSION_TITLE_RESOLVE_COOLDOWN_MS) {
-      return Promise.resolve(false);
-    }
-    this.providerSessionTitleResolveLastAttemptAt.set(agentId, now);
-
-    const provider = agent.providerSessionProvider;
-    const sessionId = agent.providerSessionId;
-    const attempt = findAgentSession(provider, sessionId, { limit: 200, providerLimit: 200, providerHomeId: agent.providerHomeId || 'default', providerHomes: this.configManager && this.configManager.getSettings ? this.configManager.getSettings().agentHomes : undefined })
-      .then((session) => {
-        const title = String(session && session.title || '').trim().slice(0, 160);
-        if (!title) return false;
-
-        const current = this.agents.get(agentId);
-        if (
-          !current
-          || current.providerSessionProvider !== provider
-          || current.providerSessionId !== sessionId
-          || current.providerSessionTemporary === true
-          || String(current.providerSessionTitle || '').trim()
-        ) {
-          return false;
-        }
-
-        current.providerSessionTitle = title;
-        this.ensurePersistentAgentSession(current);
-        this.updateEngineProviderSessionMetadata(current);
-        this.rememberMainPageProviderSession(current);
-        this.emit('provider-session-updated', {
-          agentId,
-          provider,
-          sessionId,
-          title,
-          temporary: false,
-        });
-        this.emit('update');
-        return true;
-      })
-      .catch(() => false)
-      .finally(() => {
-        if (this.providerSessionTitleResolveInFlight.get(agentId) === attempt) {
-          this.providerSessionTitleResolveInFlight.delete(agentId);
-        }
-      });
-    this.providerSessionTitleResolveInFlight.set(agentId, attempt);
-    return attempt;
-  }
-
-  async findCodexSessionForTemporaryAgent(agent) {
-    const sessions = await listCodexSessions({ codexHome: agent.providerHomePath || undefined, limit: 100, scanLimit: 1000 });
-    const workspace = normalizePathValue(agent.projectWorkspace || agent.cwd);
-    const startedAt = Number(agent.startedAt) || 0;
-    const claimedSessionIds = this.currentProviderSessionIds('codex', agent.id, agent.providerHomeId || 'default');
-    const candidates = sessions
-      .filter(session => {
-        if (!session || !session.id || claimedSessionIds.has(session.id)) return false;
-        const sessionWorkspace = normalizePathValue(session.workspace || session.cwd);
-        if (workspace && !sessionWorkspace) return false;
-        if (workspace && workspace !== sessionWorkspace) return false;
-        const sessionTime = timestampMs(session.createdAt || session.updatedAt);
-        if (!sessionTime || !startedAt) return true;
-        return sessionTime >= startedAt - CODEX_PROVIDER_SESSION_MATCH_GRACE_MS;
-      })
-      .sort((a, b) => {
-        const aTime = timestampMs(a.createdAt || a.updatedAt);
-        const bTime = timestampMs(b.createdAt || b.updatedAt);
-        const aDistance = startedAt && aTime ? Math.abs(aTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        const bDistance = startedAt && bTime ? Math.abs(bTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        if (aDistance !== bDistance) return aDistance - bDistance;
-        return bTime - aTime;
-      });
-
-    return candidates[0] || null;
+    return {
+      agentId,
+      attentionSeq: agent.attentionSeq,
+      readAttentionSeq: agent.readAttentionSeq,
+      unread: agent.unread,
+      changed,
+    };
   }
 
-  resolveProviderSession(agentId, { provider, sessionId, source, title }) {
+  async refreshAgentWorktree(agentId, workspaceCandidate = '') {
     const agent = this.agents.get(agentId);
-    if (!agent || !provider || !sessionId || isTemporaryProviderSessionId(sessionId)) return false;
-
-    const previousSessionId = agent.providerSessionId || '';
-    const providerSessionTitle = String(title || '').trim().slice(0, 160);
-    agent.providerSessionProvider = provider;
-    agent.providerSessionId = sessionId;
-    agent.providerSessionKey = this.providerSessionKey(provider, sessionId, agent.providerHomeId || '');
-    agent.providerSessionTemporary = false;
-    agent.providerSessionSource = source || agent.providerSessionSource || '';
-    agent.providerSessionResolvedAt = Date.now();
-    if (providerSessionTitle) {
-      agent.providerSessionTitle = providerSessionTitle;
-    }
-
-    this.stopCodexProviderSessionResolver(agentId);
-    this.stopProviderSessionTitleResolver(agentId);
-    this.ensurePersistentAgentSession(agent);
-    this.updateEngineProviderSessionMetadata(agent);
-    this.rememberMainPageProviderSession(agent);
-    this.emit('provider-session-updated', {
-      agentId,
-      provider,
-      sessionId,
-      previousSessionId,
-      temporary: false,
-    });
+    if (!agent || agent.isMain || agent.wantsMain) return false;
+    const candidate = normalizePathValue(
+      workspaceCandidate
+      || agent.providerSessionWorkspace
+      || agent.shellCwd
+      || agent.projectWorkspace
+      || agent.cwd
+    );
+    if (!candidate) return false;
+
+    const generation = (this.agentWorktreeResolveGeneration.get(agentId) || 0) + 1;
+    this.agentWorktreeResolveGeneration.set(agentId, generation);
+    const baseWorkspace = normalizePathValue(agent.projectWorkspace || agent.cwd);
+    const [info, baseInfo] = await Promise.all([
+      inspectGitWorktree(candidate),
+      inspectGitWorktree(baseWorkspace),
+    ]);
+    if (this.agentWorktreeResolveGeneration.get(agentId) !== generation) return false;
+
+    const current = this.agents.get(agentId);
+    if (!current) return false;
+    const nextWorktree = info
+      && baseInfo
+      && info.commonDir === baseInfo.commonDir
+      ? info
+      : null;
+    const previousProjection = JSON.stringify(publicAgentGitWorktree(current));
+    current.gitWorktree = nextWorktree;
+    const nextProjection = JSON.stringify(publicAgentGitWorktree(current));
+    if (previousProjection === nextProjection) return false;
     this.emit('update');
     return true;
   }
@@ -1593,7 +2052,18 @@ class AgentManager extends EventEmitter {
     }
 
     this.lastActivityUpdate.set(sessionId, now);
-    this.emit('update');
+    const agent = this.agents.get(sessionId);
+    if (!agent) return;
+    const isMain = this.isMainAgentRecord(sessionId, agent);
+    const lastActivity = this.lastActivity.get(sessionId) || now;
+    this.emit('agent-activity', {
+      agentId: sessionId,
+      lastActivity,
+      activityLevel: isMain ? 'warm' : this.calculateActivityLevel(lastActivity, now),
+      attentionScore: isMain ? 0 : this.calculateAttentionScore(sessionId, now),
+      isZombie: isMain ? false : this.isZombie(sessionId, now),
+      usageRate: this.getAgentUsageRate(sessionId, { now }),
+    });
   }
 
   updateAgentSessionTitle(agent, title) {
@@ -1688,7 +2158,7 @@ class AgentManager extends EventEmitter {
     env.FARMING_IS_MAIN_AGENT = agent.wantsMain ? '1' : '0';
     env.FARMING_SKILLS_COMMAND = 'farming skills';
     env.FARMING_MAIN_WORKSPACE = agent.mainWorkspace || '';
-    env.FARMING_PROJECT_WORKSPACE = agent.projectWorkspace || '';
+    env.FARMING_PROJECT_WORKSPACE = effectiveAgentWorkspaceRoot(agent);
 
     if (agent.parentAgentId) {
       env.FARMING_PARENT_AGENT_ID = agent.parentAgentId;
@@ -1710,10 +2180,12 @@ class AgentManager extends EventEmitter {
     }
     if (agent.providerHomePath) {
       const provider = agent.providerSessionProvider || agentHomeProviderForProgram(agent.forkCommand || agent.command);
-      if (provider === 'codex') env.CODEX_HOME = agent.codexAppServerHomePath || agent.providerHomePath;
-      if (provider === 'claude') env.CLAUDE_CONFIG_DIR = agent.providerHomePath;
-      if (provider === 'opencode') env.OPENCODE_CONFIG_DIR = agent.providerHomePath;
-      if (provider === 'qoder') env.QODER_CONFIG_DIR = agent.providerHomePath;
+      const appServerHome = runtimeBindingOf(agent, 'app-server')?.homePath || '';
+      applyProviderHomeEnvironment(
+        env,
+        provider,
+        provider === 'codex' ? (appServerHome || agent.providerHomePath) : agent.providerHomePath
+      );
     }
 
     return env;
@@ -1825,21 +2297,22 @@ class AgentManager extends EventEmitter {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = null;
     }
-    this.codexSessionResolveInFlight.clear();
-    this.codexSessionResolveLastAttemptAt.clear();
-    this.providerSessionTitleResolveInFlight.clear();
-    this.providerSessionTitleResolveLastAttemptAt.clear();
+    this.providerSessionService.dispose();
+    this.agentWorktreeResolveGeneration.clear();
     this.permissionRestartInFlight.clear();
     this.runtimeRestartInFlight.clear();
     this.permissionRestartSuppressedAgentIds.clear();
+    this.pendingResizeByAgent.clear();
+    this.resizeDrains.clear();
     this.inputQueues.clear();
+    this.codexTerminalProfileQueues.clear();
     if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.dispose === 'function') {
       this.codexAppServerRuntime.dispose();
     }
     if (this.jsonCliRuntime) {
       for (const agentId of this.agents.keys()) this.jsonCliRuntime.unregisterAgent(agentId);
     }
-    if (this.acpRuntime && typeof this.acpRuntime.dispose === 'function') this.acpRuntime.dispose();
+    if (this.acpRuntime && typeof this.acpRuntime.dispose === 'function') await this.acpRuntime.dispose();
     if (this.engineBridge && typeof this.engineBridge.dispose === 'function') {
       await this.engineBridge.dispose({
         preserveHost: options.preserveTerminalHost === true,
@@ -1867,6 +2340,7 @@ class AgentManager extends EventEmitter {
       forkCommand: agent.forkCommand,
       cwd: agent.cwd,
       projectWorkspace: agent.projectWorkspace || '',
+      gitWorktree: publicAgentGitWorktree(agent),
       mainWorkspace: agent.mainWorkspace || '',
       wantsMain: agent.wantsMain === true,
       category: agent.category,
@@ -1884,31 +2358,9 @@ class AgentManager extends EventEmitter {
       providerSessionSource: agent.providerSessionSource,
       providerSessionResolvedAt: agent.providerSessionResolvedAt,
       providerSessionTitle: agent.providerSessionTitle,
+      providerSessionWorkspace: agent.providerSessionWorkspace || '',
       terminalInputReceived: agent.terminalInputReceived === true,
-      codexRuntimeMode: agent.codexRuntimeMode,
-      agentRuntimeMode: agent.agentRuntimeMode || 'terminal',
-      jsonCliState: agent.jsonCliState || '',
-      jsonCliError: agent.jsonCliError || '',
-      acpState: agent.acpState || '',
-      acpError: agent.acpError || '',
-      acpStopReason: agent.acpStopReason || '',
-      acpPendingPermission: agent.acpPendingPermission || null,
-      acpPendingPermissions: Array.isArray(agent.acpPendingPermissions) ? agent.acpPendingPermissions : [],
-      acpPendingElicitation: agent.acpPendingElicitation || null,
-      acpPendingElicitations: Array.isArray(agent.acpPendingElicitations) ? agent.acpPendingElicitations : [],
-      acpActiveElicitations: Array.isArray(agent.acpActiveElicitations) ? agent.acpActiveElicitations : [],
-      acpSessionUpdatedAt: agent.acpSessionUpdatedAt || '',
-      acpSessionRevision: Number(agent.acpSessionRevision) || 0,
-      codexAppServerHomePath: agent.codexAppServerHomePath || '',
-      codexAppServerState: agent.codexAppServerState,
-      codexAppServerEndpoint: agent.codexAppServerEndpoint,
-      codexAppServerThreadId: agent.codexAppServerThreadId,
-      codexAppServerTurnId: agent.codexAppServerTurnId,
-      codexAppServerError: agent.codexAppServerError,
-      codexAppServerPendingRequestId: agent.codexAppServerPendingRequestId,
-      codexAppServerPendingRequestMethod: agent.codexAppServerPendingRequestMethod,
-      codexAppServerPendingRequest: agent.codexAppServerPendingRequest || null,
-      codexCliObserverDeferred: agent.codexCliObserverDeferred === true,
+      ...legacyRuntimeMetadata(agent),
       forkedFromProviderSessionId: agent.forkedFromProviderSessionId,
       restartedFromAgentId: agent.restartedFromAgentId,
       restartedFromAgentIds: agent.restartedFromAgentIds,
@@ -1923,7 +2375,10 @@ class AgentManager extends EventEmitter {
       attentionUpdatedAt: agent.attentionUpdatedAt,
       readAttentionAt: agent.readAttentionAt,
       attentionReason: agent.attentionReason,
+      attentionOutputEpoch: agent.attentionOutputEpoch,
       attentionOutputSeq: agent.attentionOutputSeq,
+      readOutputEpoch: agent.readOutputEpoch,
+      readOutputSeq: agent.readOutputSeq,
     };
   }
 
@@ -1936,11 +2391,12 @@ class AgentManager extends EventEmitter {
       env: this.buildAgentEnv(agent.id, agent),
       category: launch.category,
       metadata: this.engineSessionMetadata(agent),
+      reviveState: launch.reviveState || null,
     });
   }
 
   async startAgent(command, customWorkspace, callback, options = {}) {
-    if (options.wantsMain !== false) {
+    if (options.wantsMain !== false && options.skipRecoveryWait !== true) {
       await this.whenRecovered();
     }
 
@@ -1960,6 +2416,29 @@ class AgentManager extends EventEmitter {
         && this.configManager
         && this.configManager.getDangerouslySkipAgentPermissionsByDefault()
       );
+    const preserveProviderSessionProfile = options.preserveProviderSessionProfile === true
+      || codexCommandContinuesSession(command);
+    const codexModel = preserveProviderSessionProfile
+      ? 'config'
+      : (typeof options.codexModel === 'string'
+        ? options.codexModel
+        : (this.configManager && this.configManager.getCodexModel
+          ? this.configManager.getCodexModel()
+          : 'gpt-5.5'));
+    const codexReasoningEffort = preserveProviderSessionProfile
+      ? 'config'
+      : (typeof options.codexReasoningEffort === 'string'
+        ? options.codexReasoningEffort
+        : (this.configManager && this.configManager.getCodexReasoningEffort
+          ? this.configManager.getCodexReasoningEffort()
+          : 'xhigh'));
+    const codexServiceTier = preserveProviderSessionProfile
+      ? 'config'
+      : (typeof options.codexServiceTier === 'string'
+        ? options.codexServiceTier
+        : (this.configManager && this.configManager.getCodexServiceTier
+          ? this.configManager.getCodexServiceTier()
+          : 'default'));
     const launch = resolveLaunchCommand(command, {
       dangerouslySkipPermissions,
       agentLaunchProfiles: this.configManager && this.configManager.getAgentLaunchProfiles
@@ -1974,15 +2453,9 @@ class AgentManager extends EventEmitter {
       codexModelPreset: this.configManager && this.configManager.getCodexModelPreset
         ? this.configManager.getCodexModelPreset()
         : 'gpt-5.5:xhigh',
-      codexModel: this.configManager && this.configManager.getCodexModel
-        ? this.configManager.getCodexModel()
-        : 'gpt-5.5',
-      codexReasoningEffort: this.configManager && this.configManager.getCodexReasoningEffort
-        ? this.configManager.getCodexReasoningEffort()
-        : 'xhigh',
-      codexServiceTier: this.configManager && this.configManager.getCodexServiceTier
-        ? this.configManager.getCodexServiceTier()
-        : 'default',
+      codexModel,
+      codexReasoningEffort,
+      codexServiceTier,
       mainAgentSystemPrompt: wantsMain ? renderMainAgentBootstrap() : '',
     });
     const program = launch.program;
@@ -2105,7 +2578,19 @@ class AgentManager extends EventEmitter {
       return null;
     }
     
-    const agentId = `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const requestedRuntimeAgentId = typeof options.runtimeAgentId === 'string'
+      ? options.runtimeAgentId.trim()
+      : '';
+    if (requestedRuntimeAgentId && !/^agent-[A-Za-z0-9_-]+$/.test(requestedRuntimeAgentId)) {
+      if (callback) callback(null, 'Invalid runtime Agent id');
+      return null;
+    }
+    if (requestedRuntimeAgentId && this.agents.has(requestedRuntimeAgentId)) {
+      if (callback) callback(null, `Runtime Agent id is already active: ${requestedRuntimeAgentId}`);
+      return null;
+    }
+    const agentId = requestedRuntimeAgentId ||
+      `agent-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     const homeProvider = providerSessionPlan.provider || agentHomeProviderForProgram(program);
     const providerHomeId = typeof options.providerHomeId === 'string' && options.providerHomeId.trim()
       ? options.providerHomeId.trim()
@@ -2165,16 +2650,18 @@ class AgentManager extends EventEmitter {
       && process.env.FARMING_E2E_FAKE_EXECUTABLES !== '1'
       && normalizeCodexRuntimeMode(requestedCodexRuntimeMode) === 'app-server';
     const useJsonCli = requestedAgentRuntimeMode === 'json'
-      && ['codex', 'opencode'].includes(structuredRuntimeProvider)
+      && providerSupportsRuntime(structuredRuntimeProvider, 'json')
       && !useCodexAppServer
       && process.env.FARMING_E2E_FAKE_EXECUTABLES !== '1';
     const useAcp = requestedAgentRuntimeMode === 'acp'
-      && ['codex', 'claude', 'opencode', 'qoder'].includes(structuredRuntimeProvider)
+      && 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 {
@@ -2214,40 +2701,23 @@ class AgentManager extends EventEmitter {
       providerHomeId: resolvedProviderHomeId,
       providerHomePath,
       providerSessionId: providerSessionPlan.id || '',
-      providerSessionKey: this.providerSessionKey(providerSessionPlan.provider, providerSessionPlan.id, providerHome ? providerHome.id : providerHomeId),
+      providerSessionKey: mainPageAgentSessionKey(providerSessionPlan.provider, providerSessionPlan.id, providerHome ? providerHome.id : providerHomeId),
       providerSessionTemporary: providerSessionPlan.temporary === true,
       providerSessionSource: providerSessionPlan.source || '',
       providerSessionResolvedAt: providerSessionPlan.temporary === true ? null : Date.now(),
       providerSessionTitle: typeof options.providerSessionTitle === 'string' ? options.providerSessionTitle.trim().slice(0, 160) : '',
+      providerSessionWorkspace: '',
       terminalInputReceived: false,
-      codexRuntimeMode: structuredRuntimeProvider === 'codex'
-        ? (useCodexAppServer ? 'app-server' : 'cli')
-        : '',
-      agentRuntimeMode: useAcp ? 'acp' : (useJsonCli ? 'json' : 'terminal'),
-      jsonCliState: useJsonCli ? 'idle' : '',
-      jsonCliError: '',
-      jsonCliTranscriptUpdatedAt: '',
-      jsonCliEvents: Array.isArray(options.jsonCliEvents) ? options.jsonCliEvents : [],
-      acpState: useAcp ? 'connecting' : '',
-      acpError: '',
-      acpStopReason: '',
-      acpPendingPermission: null,
-      acpPendingPermissions: [],
-      acpPendingElicitation: null,
-      acpPendingElicitations: [],
-      acpActiveElicitations: [],
-      acpSessionUpdatedAt: '',
-      acpSessionRevision: 0,
-      codexAppServerHomePath,
-      codexAppServerState: useCodexAppServer ? 'connecting' : '',
-      codexAppServerEndpoint: '',
-      codexAppServerThreadId: '',
-      codexAppServerTurnId: '',
-      codexAppServerError: '',
-      codexAppServerPendingRequestId: '',
-      codexAppServerPendingRequestMethod: '',
-      codexAppServerPendingRequest: null,
-      codexCliObserverDeferred: 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'))),
       forkedFromProviderSessionId: providerSessionPlan.forkedFromProviderSessionId || '',
       restartedFromAgentId: typeof options.restartedFromAgentId === 'string' ? options.restartedFromAgentId : '',
       restartedFromAgentIds: Array.isArray(options.restartedFromAgentIds)
@@ -2256,7 +2726,7 @@ class AgentManager extends EventEmitter {
       runtimeSwitchVerifiedSessionId: typeof options.runtimeSwitchVerifiedSessionId === 'string'
         ? options.runtimeSwitchVerifiedSessionId
         : '',
-      persistentSessionId: '',
+      persistentSessionId: typeof options.persistentSessionId === 'string' ? options.persistentSessionId : '',
       customTitle: typeof options.customTitle === 'string' ? options.customTitle.trim().slice(0, 80) : '',
       terminalBusy: null,
       shellCwd: '',
@@ -2276,7 +2746,10 @@ class AgentManager extends EventEmitter {
       attentionUpdatedAt: null,
       readAttentionAt: null,
       attentionReason: '',
+      attentionOutputEpoch: '',
       attentionOutputSeq: null,
+      readOutputEpoch: '',
+      readOutputSeq: null,
       unread: false,
       archived: false,
       archivedAt: null,
@@ -2293,6 +2766,7 @@ class AgentManager extends EventEmitter {
 
     ensureAgentOrders(agentRecord, Array.from(this.agents.values()));
     this.agents.set(agentId, agentRecord);
+    void this.refreshAgentWorktree(agentId);
 
     this.lastActivity.set(agentId, Date.now());
 
@@ -2301,9 +2775,10 @@ class AgentManager extends EventEmitter {
     try {
       if (useCodexAppServer) {
         try {
+          const appServer = runtimeBindingOf(agentRecord, 'app-server');
           const prepared = await this.codexAppServerRuntime.prepareAgent({
             agentId,
-            codexHome: agentRecord.codexAppServerHomePath,
+            codexHome: appServer.homePath,
             executable: spawnProgram,
             env: this.buildAgentEnv(agentId, agentRecord),
             cwd: workspace,
@@ -2315,19 +2790,13 @@ class AgentManager extends EventEmitter {
                 ? 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',
+            model: codexModel,
+            reasoningEffort: codexReasoningEffort,
+            serviceTier: codexServiceTier,
             developerInstructions: wantsMain ? renderMainAgentBootstrap() : '',
           });
           agentRecord.providerSessionId = prepared.threadId;
-          agentRecord.providerSessionKey = this.providerSessionKey(
+          agentRecord.providerSessionKey = mainPageAgentSessionKey(
             'codex',
             prepared.threadId,
             agentRecord.providerHomeId || 'default'
@@ -2335,13 +2804,13 @@ class AgentManager extends EventEmitter {
           agentRecord.providerSessionTemporary = false;
           agentRecord.providerSessionSource = prepared.resumed ? 'app-server-resume' : 'app-server-start';
           agentRecord.providerSessionResolvedAt = Date.now();
-          agentRecord.codexAppServerState = 'idle';
-          agentRecord.codexAppServerEndpoint = prepared.endpoint;
-          agentRecord.codexAppServerThreadId = prepared.threadId;
-          agentRecord.codexAppServerError = '';
+          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.
-          agentRecord.codexCliObserverDeferred = false;
+          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 });
@@ -2349,6 +2818,7 @@ class AgentManager extends EventEmitter {
       }
 
       if (useJsonCli) {
+        const jsonRuntime = runtimeBindingOf(agentRecord, 'json');
         this.jsonCliRuntime.registerAgent({
           agentId,
           provider: structuredRuntimeProvider,
@@ -2358,34 +2828,32 @@ class AgentManager extends EventEmitter {
           sessionId: agentRecord.providerSessionTemporary ? '' : agentRecord.providerSessionId,
           approvalMode: agentRecord.launchPermissionMode || 'approve',
           autoApprove: options.dangerouslySkipPermissions === true,
-          initialEvents: agentRecord.jsonCliEvents,
+          initialEvents: jsonRuntime.events,
         });
       }
 
       if (useAcp) {
+        const acpRuntime = runtimeBindingOf(agentRecord, 'acp');
         const prepared = await this.acpRuntime.prepareAgent({
           agentId,
           provider: structuredRuntimeProvider,
           executable: spawnProgram,
           env: this.buildAgentEnv(agentId, agentRecord),
           cwd: workspace,
-          sessionId: options.acpStartFresh === true || agentRecord.providerSessionTemporary
+          sessionId: options.acpStartFresh === true || agentRecord.providerSessionTemporary || acpGeneratedFreshSession
             ? ''
             : agentRecord.providerSessionId,
-          historyMode: options.acpHistoryMode === 'resume' ? 'resume' : 'load',
+          historyMode: options.acpHistoryMode === 'resume'
+            ? 'resume'
+            : (options.acpHistoryMode === 'load' ? 'load' : 'checkpoint'),
+          providerHomeId: agentRecord.providerHomeId || 'default',
           approvalMode: agentRecord.launchPermissionMode || 'approve',
-          model: this.configManager && this.configManager.getCodexModel
-            ? this.configManager.getCodexModel()
-            : '',
-          reasoningEffort: this.configManager && this.configManager.getCodexReasoningEffort
-            ? this.configManager.getCodexReasoningEffort()
-            : '',
-          serviceTier: this.configManager && this.configManager.getCodexServiceTier
-            ? this.configManager.getCodexServiceTier()
-            : '',
+          model: codexModel,
+          reasoningEffort: codexReasoningEffort,
+          serviceTier: codexServiceTier,
         });
         agentRecord.providerSessionId = prepared.sessionId;
-        agentRecord.providerSessionKey = this.providerSessionKey(
+        agentRecord.providerSessionKey = mainPageAgentSessionKey(
           structuredRuntimeProvider,
           prepared.sessionId,
           agentRecord.providerHomeId || 'default'
@@ -2393,8 +2861,8 @@ class AgentManager extends EventEmitter {
         agentRecord.providerSessionTemporary = false;
         agentRecord.providerSessionSource = `acp-${prepared.historyMode}`;
         agentRecord.providerSessionResolvedAt = Date.now();
-        agentRecord.acpState = 'idle';
-        agentRecord.acpError = '';
+        acpRuntime.state = 'idle';
+        acpRuntime.error = '';
       }
 
       agentRecord.persistentSessionId = this.ensurePersistentAgentSession(agentRecord);
@@ -2404,6 +2872,7 @@ class AgentManager extends EventEmitter {
           args,
           cwd: workspace,
           category: resolution.spec ? resolution.spec.category : 'shell',
+          reviveState: options.reviveTerminalState || null,
         };
         await this.createAgentEngineSession(agentRecord, resolution.engine, engineLaunch);
       }
@@ -2419,18 +2888,33 @@ class AgentManager extends EventEmitter {
         }
       }
 
-      this.activateProviderSessionTracking(agentId);
+      this.providerSessionService.activate(agentId);
       if (callback) callback(agentId);
       this.emit('update');
       return agentId;
     } catch (error) {
       console.error('Failed to start agent:', error);
+      if (options.restoreRuntimeAgentIdOnFailure && agentRecord.persistentSessionId) {
+        const failedAgentId = agentRecord.id;
+        try {
+          agentRecord.id = options.restoreRuntimeAgentIdOnFailure;
+          this.ensurePersistentAgentSession(agentRecord);
+        } catch (rollbackError) {
+          console.error(
+            'Failed to roll back persisted Agent runtime id after restart failure:',
+            rollbackError && (rollbackError.message || rollbackError)
+          );
+        } finally {
+          agentRecord.id = failedAgentId;
+        }
+      }
       this.agents.delete(agentId);
       this.lastActivity.delete(agentId);
       this.lastActivityUpdate.delete(agentId);
       this.outputEvents.delete(agentId);
+      this.agentUsageRateCache.delete(agentId);
       this.lastResizeByAgent.delete(agentId);
-      this.stopCodexProviderSessionResolver(agentId);
+      this.providerSessionService.stop(agentId);
       if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.unregisterAgent === 'function') {
         this.codexAppServerRuntime.unregisterAgent(agentId);
       }
@@ -2446,15 +2930,15 @@ class AgentManager extends EventEmitter {
     }
   }
   
-  async sendInput(agentId, input) {
+  async enqueueInputOperation(agentId, operation) {
     const previous = this.inputQueues.get(agentId) || Promise.resolve();
     const next = previous
       .catch(() => {})
-      .then(() => this.sendInputNow(agentId, input));
+      .then(operation);
 
     this.inputQueues.set(agentId, next);
     try {
-      await next;
+      return await next;
     } finally {
       if (this.inputQueues.get(agentId) === next) {
         this.inputQueues.delete(agentId);
@@ -2462,20 +2946,52 @@ class AgentManager extends EventEmitter {
     }
   }
 
+  async enqueueInputOperationUntilReleased(agentId, operation) {
+    const previous = this.inputQueues.get(agentId) || Promise.resolve();
+    let released = false;
+    let resolveReleased;
+    const releasedPromise = new Promise(resolve => {
+      resolveReleased = resolve;
+    });
+    const release = () => {
+      if (released) return;
+      released = true;
+      resolveReleased();
+    };
+
+    const ready = previous.catch(() => {});
+    const completion = ready.then(() => operation(release));
+    completion.catch(() => release());
+    const boundary = ready.then(() => releasedPromise);
+    this.inputQueues.set(agentId, boundary);
+    boundary.then(() => {
+      if (this.inputQueues.get(agentId) === boundary) {
+        this.inputQueues.delete(agentId);
+      }
+    });
+    return completion;
+  }
+
+  async sendInput(agentId, input, options = {}) {
+    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: agent.codexAppServerHomePath || '',
+      codexHome: runtime.homePath,
       executable: codexResolution.path || resolveAgentExecutable(agent.command) || agent.command,
       env: this.buildAgentEnv(agent.id, agent),
       cwd: agent.cwd,
-      workspaceRoot: agent.projectWorkspace || agent.cwd,
-      threadId: agent.codexAppServerThreadId || agent.providerSessionId || '',
+      workspaceRoot: effectiveAgentWorkspaceRoot(agent),
+      threadId: runtime.threadId || agent.providerSessionId || '',
       approvalMode: agent.launchPermissionMode || (
         this.configManager && this.configManager.getCodexApprovalMode
           ? this.configManager.getCodexApprovalMode()
@@ -2495,21 +3011,101 @@ class AgentManager extends EventEmitter {
   }
 
   async sendComposerMessage(agentId, message) {
-    const previous = this.inputQueues.get(agentId) || Promise.resolve();
-    const next = previous
-      .catch(() => {})
-      .then(() => this.sendComposerMessageNow(agentId, message));
+    return this.enqueueInputOperation(agentId, () => this.sendComposerMessageNow(agentId, message));
+  }
 
-    this.inputQueues.set(agentId, next);
+  async setCodexTerminalProfile(agentId, profile, options = {}) {
+    const previous = this.codexTerminalProfileQueues.get(agentId) || Promise.resolve();
+    const start = () => this.enqueueInputOperationUntilReleased(
+      agentId,
+      releaseInput => this.setCodexTerminalProfileNow(agentId, profile, {
+        ...options,
+        onInputSafe: releaseInput,
+      }),
+    );
+    const next = this.codexTerminalProfileQueues.has(agentId)
+      ? previous.catch(() => {}).then(start)
+      : start();
+    this.codexTerminalProfileQueues.set(agentId, next);
     try {
       return await next;
     } finally {
-      if (this.inputQueues.get(agentId) === next) {
-        this.inputQueues.delete(agentId);
+      if (this.codexTerminalProfileQueues.get(agentId) === next) {
+        this.codexTerminalProfileQueues.delete(agentId);
       }
     }
   }
 
+  async setCodexTerminalProfileNow(agentId, profile, options = {}) {
+    const agent = this.agents.get(agentId);
+    if (!agent) throw new Error('Agent not found');
+    if (
+      agentProgramName(agent.command).toLowerCase() !== 'codex'
+      || isCodexAppServerAgent(agent)
+      || isJsonCliAgent(agent)
+      || isAcpAgent(agent)
+      || runtimeKind(agent) !== 'terminal'
+    ) {
+      throw new Error('This Agent is not using Codex Terminal');
+    }
+    if (!isRunningAgentRuntimeStatus(agent.status)) {
+      throw new Error('Codex Terminal is not running');
+    }
+    if (this.isAgentAttentionTurnActive(agent)) {
+      throw new Error('Wait for the active Codex Terminal turn to finish before changing its model');
+    }
+
+    const applied = await applyCodexTerminalProfile({
+      profile,
+      timeoutMs: options.timeoutMs,
+      signal: options.signal,
+      onInputSafe: options.onInputSafe,
+      readPreview: async () => {
+        const view = await this.getAgentSessionView(agentId);
+        if (!view) throw new Error('Agent not found');
+        return view.previewText;
+      },
+      readOutput: async () => String(await this.getAgentSessionText(agentId) || ''),
+      // `/model` and `/fast on|off` are Farming-owned control traffic. They must not
+      // make a fresh Terminal look user-authored, because that would remove
+      // the safe fresh-session path into ACP Chat before the provider has
+      // materialized a resumable history record.
+      sendInput: async input => this.sendInputNow(agentId, input, { markUserInput: false }),
+    });
+    agent.codexTerminalProfile = {
+      model: applied.model,
+      reasoningEffort: applied.effort,
+      serviceTier: applied.serviceTier,
+      source: 'terminal-command',
+    };
+
+    // The HTTP response confirms the terminal has already reached this profile.
+    // Publish that confirmation immediately instead of waiting for a later PTY
+    // preview tick; otherwise the browser's bounded optimistic state can expire
+    // and briefly fall back to the pre-command footer.
+    const view = options.signal?.aborted
+      ? null
+      : await this.getAgentSessionView(agentId);
+    if (view) {
+      agent.previewText = view.previewText || agent.previewText || '';
+      agent.previewSnapshot = view.previewSnapshot || agent.previewSnapshot || null;
+      agent.previewCols = view.previewCols || agent.previewCols || 80;
+      agent.previewRows = view.previewRows || agent.previewRows || 30;
+      this.emit('session-preview-update', {
+        agentId,
+        previewText: agent.previewText,
+        cols: agent.previewCols,
+        rows: agent.previewRows,
+        previewSnapshot: agent.previewSnapshot,
+        codexTerminalProfile: agent.codexTerminalProfile,
+        terminalStatus: view.terminalStatus,
+        runtimeObservation: deriveRuntimeObservation({ ...agent, terminalStatus: view.terminalStatus }),
+      });
+    }
+    this.emit('update');
+    return applied;
+  }
+
   async sendComposerMessageNow(agentId, message) {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
@@ -2523,19 +3119,20 @@ class AgentManager extends EventEmitter {
       throw new Error('Composer message is empty');
     }
 
+    const appServer = runtimeBindingOf(agent, 'app-server');
     if (
       agent.providerSessionProvider === 'codex'
-      && agent.codexRuntimeMode === 'app-server'
+      && appServer
       && this.codexAppServerRuntime
       && typeof this.codexAppServerRuntime.submitComposerMessage === 'function'
     ) {
       const result = await this.codexAppServerRuntime.submitComposerMessage(
         this.codexAppServerOptionsForAgent(agent, text)
       );
-      agent.codexAppServerThreadId = result.threadId;
-      agent.codexAppServerTurnId = result.turnId;
-      agent.codexAppServerState = 'working';
-      agent.codexAppServerError = '';
+      appServer.threadId = result.threadId;
+      appServer.turnId = result.turnId;
+      appServer.state = 'working';
+      appServer.error = '';
       this.lastActivity.set(agentId, Date.now());
       this.emit('update');
       return result;
@@ -2553,8 +3150,9 @@ class AgentManager extends EventEmitter {
 
     if (isAcpAgent(agent)) {
       const result = await this.acpRuntime.prompt(agentId, prompt);
-      agent.acpState = 'idle';
-      agent.acpStopReason = result.stopReason || '';
+      const runtime = runtimeBindingOf(agent, 'acp');
+      runtime.state = 'idle';
+      runtime.stopReason = result.stopReason || '';
       this.ensurePersistentAgentSession(agent);
       return { kind: 'acp', ...result };
     }
@@ -2566,11 +3164,12 @@ class AgentManager extends EventEmitter {
   respondToCodexAppServerRequest(agentId, requestId, result, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
-    if (agent.providerSessionProvider !== 'codex' || agent.codexRuntimeMode !== 'app-server') {
+    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 !== agent.codexAppServerPendingRequestId) {
+    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');
@@ -2582,10 +3181,10 @@ class AgentManager extends EventEmitter {
         { code: -32000, message: String(options.reason || 'Rejected by Farming') }
       )
       : this.codexAppServerRuntime.resolveAgentServerRequest(agentId, resolvedRequestId, result);
-    agent.codexAppServerPendingRequestId = '';
-    agent.codexAppServerPendingRequestMethod = '';
-    agent.codexAppServerPendingRequest = null;
-    agent.codexAppServerState = agent.codexAppServerTurnId ? 'working' : 'idle';
+    runtime.pendingRequestId = '';
+    runtime.pendingRequestMethod = '';
+    runtime.pendingRequest = null;
+    runtime.state = runtime.turnId ? 'working' : 'idle';
     this.emit('update');
     return response;
   }
@@ -2593,11 +3192,12 @@ class AgentManager extends EventEmitter {
   assertCodexAppServerGoalAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
-    if (agent.providerSessionProvider !== 'codex' || agent.codexRuntimeMode !== 'app-server') {
+    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 (!(agent.codexAppServerThreadId || agent.providerSessionId)) {
+    if (!(runtime.threadId || agent.providerSessionId)) {
       throw new Error('Codex App Server thread id is not available yet');
     }
     return agent;
@@ -2606,7 +3206,7 @@ class AgentManager extends EventEmitter {
   async getCodexAppServerGoal(agentId) {
     const agent = this.assertCodexAppServerGoalAgent(agentId);
     const goal = await this.codexAppServerRuntime.getAgentGoal(this.codexAppServerOptionsForAgent(agent));
-    agent.codexAppServerGoal = goal || null;
+    runtimeBindingOf(agent, 'app-server').goal = goal || null;
     this.emit('update');
     return goal || null;
   }
@@ -2637,7 +3237,11 @@ class AgentManager extends EventEmitter {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error('Agent not found');
     if (!isAcpAgent(agent)) throw new Error('Agent is not using the ACP runtime');
-    return this.acpRuntime.getTranscriptSession(agentId, options);
+    const transcript = this.acpRuntime.getTranscriptSession(agentId, options);
+    return {
+      ...transcript,
+      entries: transcript.entries.map(entry => entry?.type === 'tool' ? acpTranscriptToolEntry(entry) : entry),
+    };
   }
 
   getAcpToolDetail(agentId, toolCallId) {
@@ -2778,7 +3382,7 @@ class AgentManager extends EventEmitter {
       ...(status !== undefined ? { status } : {}),
       ...(Object.prototype.hasOwnProperty.call(patch, 'tokenBudget') ? { tokenBudget } : {}),
     });
-    agent.codexAppServerGoal = goal || null;
+    runtimeBindingOf(agent, 'app-server').goal = goal || null;
     this.emit('update');
     return goal || null;
   }
@@ -2786,43 +3390,43 @@ class AgentManager extends EventEmitter {
   async clearCodexAppServerGoal(agentId) {
     const agent = this.assertCodexAppServerGoalAgent(agentId);
     await this.codexAppServerRuntime.clearAgentGoal(this.codexAppServerOptionsForAgent(agent));
-    agent.codexAppServerGoal = null;
+    runtimeBindingOf(agent, 'app-server').goal = null;
     this.emit('update');
     return null;
   }
 
-  async sendInputNow(agentId, input) {
+  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 (expectedRuntimeEpoch && agent.runtimeEpoch !== expectedRuntimeEpoch) {
+      return { status: 'input-rejected', reason: 'runtime-epoch-mismatch' };
+    }
 
     const engine = this.engineBridge.getEngine(agent.engineName);
     if (!engine) return;
 
-    if (agent.terminalInputReceived !== true) {
-      agent.terminalInputReceived = true;
-      this.ensurePersistentAgentSession(agent);
-      this.updateEngineProviderSessionMetadata(agent);
-    }
-
-    for (let attempt = 0; ; attempt += 1) {
-      try {
-        await engine.sendInput(agentId, input);
-        this.observeAgentStateChange(agentId, { force: true });
-        return;
-      } catch (error) {
-        const delay = INPUT_SESSION_RETRY_DELAYS_MS[attempt];
-        if (!isSessionNotAvailableError(error) || delay === undefined) {
-          console.error('Failed to send input:', error);
-          if (isSessionNotAvailableError(error)) {
-            this.markAgentSessionDead(agentId, error);
-          }
-          return;
-        }
-        await sleep(delay);
+    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 });
       }
+      return result;
+    } catch (error) {
+      console.error('Failed to send input:', error);
+      if (isSessionNotAvailableError(error)) {
+        this.markAgentSessionDead(agentId, error);
+      }
+      return;
     }
   }
 
@@ -2837,33 +3441,34 @@ class AgentManager extends EventEmitter {
     agent.terminalBusy = false;
     agent.exitedAt = Date.now();
     agent.output = trimSessionOutput(`${agent.output || ''}\n${message}`);
-    this.observeAgentStateChange(agentId, { force: true });
+    this.providerSessionService.observe(agentId, { force: true });
     this.emit('update');
   }
 
-  async interruptAgent(agentId) {
+  async interruptAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
     if (!agent) return;
+    const appServer = runtimeBindingOf(agent, 'app-server');
 
     try {
       if (
         agent.providerSessionProvider === 'codex'
-        && agent.codexRuntimeMode === 'app-server'
+        && appServer
         && this.codexAppServerRuntime
         && typeof this.codexAppServerRuntime.interruptAgent === 'function'
       ) {
         try {
           const interrupted = await this.codexAppServerRuntime.interruptAgent(agentId);
           if (interrupted) {
-            agent.codexAppServerState = 'interrupting';
+            appServer.state = 'interrupting';
             this.emit('update');
             return;
           }
-          agent.codexAppServerError = 'Codex App Server interrupt is not available';
+          appServer.error = 'Codex App Server interrupt is not available';
           this.emit('update');
           return;
         } catch (error) {
-          agent.codexAppServerError = `Codex App Server interrupt failed: ${error && (error.message || error)}`;
+          appServer.error = `Codex App Server interrupt failed: ${error && (error.message || error)}`;
           this.emit('update');
           return;
         }
@@ -2881,9 +3486,9 @@ class AgentManager extends EventEmitter {
 
       const input = interruptInputForAgent(agent);
       if (engine.interruptSession) {
-        await engine.interruptSession(agentId, input);
+        return await engine.interruptSession(agentId, input, options);
       } else {
-        await engine.sendInput(agentId, input);
+        return await engine.sendInput(agentId, input, options);
       }
     } catch (error) {
       console.error('Failed to interrupt agent:', error);
@@ -2893,10 +3498,48 @@ class AgentManager extends EventEmitter {
     }
   }
 
+  agentSupportsTerminalInput(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return false;
+    return !isCodexAppServerAgent(agent) && !isJsonCliAgent(agent) && !isAcpAgent(agent);
+  }
+
+  async getAgentSessionAttachCheckpoint(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent || isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) {
+      return null;
+    }
+    try {
+      return await this.engineBridge.getSessionAttachCheckpoint(agent.engineName, agentId);
+    } catch (error) {
+      console.error('Failed to read agent terminal attach checkpoint:', error);
+      return null;
+    }
+  }
+
+  requestAgentSessionResize(agentId, cols, rows) {
+    this.pendingResizeByAgent.set(agentId, { cols, rows });
+    if (this.resizeDrains.has(agentId)) return true;
+
+    const drain = (async () => {
+      while (this.pendingResizeByAgent.has(agentId)) {
+        const next = this.pendingResizeByAgent.get(agentId);
+        this.pendingResizeByAgent.delete(agentId);
+        await this.resizeAgentSession(agentId, next.cols, next.rows);
+      }
+    })().finally(() => {
+      this.resizeDrains.delete(agentId);
+    });
+    this.resizeDrains.set(agentId, drain);
+    return true;
+  }
+
   async resizeAgentSession(agentId, cols, rows) {
     const agent = this.agents.get(agentId);
-    if (!agent) return;
-    if (isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) return;
+    if (!agent) return { status: 'resize-rejected', reason: 'session-unavailable', resized: false };
+    if (isCodexAppServerAgent(agent) || isAcpAgent(agent) || isJsonCliAgent(agent)) {
+      return { status: 'resize-rejected', reason: 'unsupported-session', resized: false };
+    }
 
     const nextCols = Math.floor(Number(cols));
     const nextRows = Math.floor(Number(rows));
@@ -2906,49 +3549,50 @@ class AgentManager extends EventEmitter {
       nextCols < MIN_TERMINAL_RESIZE_COLS ||
       nextRows < MIN_TERMINAL_RESIZE_ROWS
     ) {
-      return;
+      return { status: 'resize-rejected', reason: 'invalid-dimensions', resized: false };
     }
 
     try {
-      const previousSize = this.lastResizeByAgent.get(agentId);
-      if (previousSize && previousSize.cols === nextCols && previousSize.rows === nextRows) {
-        return;
-      }
-
       const engine = this.engineBridge.getEngine(agent.engineName);
-      if (!engine || !engine.resizeSession) return;
+      if (!engine || !engine.resizeSession) {
+        return { status: 'resize-rejected', reason: 'unsupported-engine', resized: false };
+      }
 
       const result = await engine.resizeSession(agentId, nextCols, nextRows);
-      if (result && result.resized === false) {
+      if (result && result.resized === false && result.reason === 'session-unavailable') {
         this.markAgentSessionDead(agentId, 'Session not available');
-        return;
       }
-      this.lastResizeByAgent.set(agentId, { cols: nextCols, rows: nextRows });
+      if (result && result.status === 'resize-committed') {
+        this.lastResizeByAgent.set(agentId, { cols: nextCols, rows: nextRows });
+      }
+      return result;
     } catch (error) {
       console.error('Failed to resize agent session:', error);
+      return { status: 'resize-rejected', reason: 'resize-failed', resized: false };
     }
   }
 
-  async clearAgentSessionBuffer(agentId) {
+  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 (options.expectedRuntimeEpoch && agent.runtimeEpoch !== options.expectedRuntimeEpoch) {
+      return { cleared: false, reason: 'runtime-epoch-mismatch' };
+    }
 
     try {
       const engine = this.engineBridge.getEngine(agent.engineName);
       if (!engine || !engine.clearBuffer) return { cleared: false };
-      const result = await engine.clearBuffer(agentId);
+      const result = await engine.clearBuffer(agentId, options);
       if (result && result.cleared === false) {
-        this.markAgentSessionDead(agentId, 'Session not available');
+        if (result.reason === 'session-unavailable') {
+          this.markAgentSessionDead(agentId, 'Session not available');
+        }
         return result;
       }
-      agent.output = '';
-      agent.previewText = '';
-      agent.previewSnapshot = null;
-      this.outputEvents.delete(agentId);
-      this.lastActivity.set(agentId, Date.now());
-      this.observeAgentStateChange(agentId, { force: true });
-      this.emit('update');
+      // The ordered clear transition is the single metadata writer. Output
+      // committed immediately after clear must not be erased by this RPC
+      // response path racing the transition stream.
       return result || { cleared: true };
     } catch (error) {
       console.error('Failed to clear agent session buffer:', error);
@@ -2990,9 +3634,12 @@ class AgentManager extends EventEmitter {
     }
 
     const updates = {};
+    let structuralUpdateChanged = false;
+    let readUpdateChanged = false;
     if (typeof flags.pinned === 'boolean') {
       const wasPinned = agent.pinned === true;
       agent.pinned = flags.pinned;
+      structuralUpdateChanged = structuralUpdateChanged || wasPinned !== agent.pinned;
       updates.pinned = agent.pinned;
       if (!wasPinned && agent.pinned) {
         agent.pinnedOrder = nextPinnedOrder(Array.from(this.agents.values()));
@@ -3000,22 +3647,36 @@ class AgentManager extends EventEmitter {
       updates.pinnedOrder = finiteOrder(agent.pinnedOrder);
     }
 
+    if (
+      typeof flags.readOutputEpoch === 'string'
+      && typeof flags.readOutputSeq === 'number'
+      && Number.isFinite(flags.readOutputSeq)
+    ) {
+      const result = this.markAgentReadOutputCut(agentId, flags.readOutputEpoch, flags.readOutputSeq);
+      if (result.error) return result;
+      updates.readOutputEpoch = result.readOutputEpoch;
+      updates.readOutputSeq = result.readOutputSeq;
+      readUpdateChanged = readUpdateChanged || result.changed;
+    }
+
     if (typeof flags.unread === 'boolean') {
       const result = flags.unread
         ? this.markAgentUnreadCursor(agentId)
-        : this.markAgentReadCursor(agentId);
+        : this.markAgentReadCursor(agentId, undefined, { emitUpdate: false });
       if (result.error) return result;
       updates.unread = result.unread;
       updates.attentionSeq = result.attentionSeq;
       updates.readAttentionSeq = result.readAttentionSeq;
+      readUpdateChanged = readUpdateChanged || result.changed === true;
     }
 
     if (typeof flags.readAttentionSeq === 'number' && Number.isFinite(flags.readAttentionSeq)) {
-      const result = this.markAgentReadCursor(agentId, flags.readAttentionSeq);
+      const result = this.markAgentReadCursor(agentId, flags.readAttentionSeq, { emitUpdate: false });
       if (result.error) return result;
       updates.unread = result.unread;
       updates.attentionSeq = result.attentionSeq;
       updates.readAttentionSeq = result.readAttentionSeq;
+      readUpdateChanged = readUpdateChanged || result.changed === true;
     }
 
     if (flags.archived === true) {
@@ -3026,18 +3687,38 @@ class AgentManager extends EventEmitter {
     }
 
     if (flags.archived === false) {
+      structuralUpdateChanged = structuralUpdateChanged || agent.archived === true || agent.archivedAt !== null;
       agent.archived = false;
       agent.archivedAt = null;
       updates.archived = agent.archived;
       updates.archivedAt = agent.archivedAt;
     }
 
-    if (typeof flags.pinned === 'boolean') {
+    if (
+      typeof flags.pinned === 'boolean'
+      || (typeof flags.readOutputEpoch === 'string' && typeof flags.readOutputSeq === 'number')
+    ) {
       this.ensurePersistentAgentSession(agent);
       this.updateEngineProviderSessionMetadata(agent);
     }
-    this.emit('update');
-    return { agentId, ...updates };
+    if (structuralUpdateChanged) {
+      this.emit('update');
+    } else if (readUpdateChanged) {
+      this.emit('agent-read', {
+        agentId,
+        unread: agent.unread === true,
+        attentionSeq: finiteNonNegativeInteger(agent.attentionSeq),
+        readAttentionSeq: finiteNonNegativeInteger(agent.readAttentionSeq),
+        readOutputEpoch: typeof agent.readOutputEpoch === 'string' ? agent.readOutputEpoch : '',
+        readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
+      });
+    }
+    return {
+      agentId,
+      ...updates,
+      changed: structuralUpdateChanged || readUpdateChanged,
+      requiresState: structuralUpdateChanged,
+    };
   }
 
   reorderProjectAgent(agentId, { beforeAgentId = '', afterAgentId = '' } = {}) {
@@ -3098,7 +3779,7 @@ class AgentManager extends EventEmitter {
 
     if (
       agent.providerSessionProvider === 'codex'
-      && agent.codexRuntimeMode === 'app-server'
+      && runtimeKind(agent) === 'app-server'
     ) {
       return this.updateCodexAppServerPermissionMode(agentId, mode);
     }
@@ -3109,7 +3790,8 @@ class AgentManager extends EventEmitter {
   async updateCodexAppServerPermissionMode(agentId, mode) {
     const agent = this.agents.get(agentId);
     if (!agent) return { error: 'Agent not found' };
-    if (agent.providerSessionProvider !== 'codex' || agent.codexRuntimeMode !== 'app-server') {
+    const runtime = runtimeBindingOf(agent, 'app-server');
+    if (agent.providerSessionProvider !== 'codex' || !runtime) {
       return { error: 'Agent is not using the Codex App Server runtime' };
     }
 
@@ -3129,7 +3811,7 @@ class AgentManager extends EventEmitter {
     }
 
     agent.launchPermissionMode = nextMode;
-    agent.codexAppServerError = '';
+    runtime.error = '';
     this.updateEngineProviderSessionMetadata(agent);
     this.ensurePersistentAgentSession(agent, { launchPermissionMode: nextMode });
     this.emit('update');
@@ -3185,29 +3867,30 @@ class AgentManager extends EventEmitter {
     const nextMode = ['terminal', 'json', 'acp'].includes(mode) ? mode : '';
     if (!nextMode) return { error: 'Unsupported Agent runtime mode' };
     const provider = agent.providerSessionProvider || '';
+    const currentKind = runtimeKind(agent);
+    const currentMode = ['acp', 'json'].includes(currentKind) ? currentKind : 'terminal';
     const leavesCodexAppServer = provider === 'codex'
-      && agent.codexRuntimeMode === 'app-server'
+      && currentKind === 'app-server'
       && nextMode === 'terminal';
-    if (agent.agentRuntimeMode === nextMode && !leavesCodexAppServer) {
+    if (currentMode === nextMode && !leavesCodexAppServer) {
       return { agentId, agentRuntimeMode: nextMode };
     }
-    const turnActive = agent.agentRuntimeMode === 'acp'
-      ? ['working', 'waiting-for-permission', 'interrupting'].includes(agent.acpState || '')
+    const turnActive = currentKind === 'acp'
+      ? ['working', 'waiting-for-permission', 'interrupting'].includes(runtimeBindingOf(agent, 'acp').state)
       : this.isAgentAttentionTurnActive(agent);
     if (turnActive) {
       return { error: 'Interrupt the active Agent turn before switching Chat and Terminal.' };
     }
-    const supportedProviders = nextMode === 'json' ? ['codex', 'opencode'] : ['codex', 'claude', 'opencode', 'qoder'];
-    if (!supportedProviders.includes(provider)) {
+    if (!providerSupportsRuntime(provider, nextMode)) {
       return { error: `Agent does not support the ${nextMode.toUpperCase()} runtime` };
     }
     const sessionId = String(agent.providerSessionId || '').trim();
     const canStartFreshAcpSession = nextMode === 'acp'
-      && agent.agentRuntimeMode === 'terminal'
+      && currentMode === 'terminal'
       && agent.terminalInputReceived !== true
       && (
         agent.providerSessionTemporary === true
-        || ['codex-temporary', 'claude-session-id', 'qoder-session-id'].includes(agent.providerSessionSource || '')
+        || isFreshAcpSessionSource(provider, agent.providerSessionSource || '')
       );
     if (!isSafeProviderSessionId(sessionId) && !canStartFreshAcpSession) {
       return { error: 'Runtime switching requires a resumable provider session. Send the first message and try again.' };
@@ -3219,7 +3902,7 @@ class AgentManager extends EventEmitter {
     // fail. Historical/terminal sessions still use the provider lookup as a
     // stale-session guard.
     let liveAcpSession = false;
-    if (agent.agentRuntimeMode === 'acp' && this.acpRuntime && typeof this.acpRuntime.getSession === 'function') {
+    if (currentKind === 'acp' && this.acpRuntime && typeof this.acpRuntime.getSession === 'function') {
       try {
         const snapshot = this.acpRuntime.getSession(agentId, { maxEntries: 0 });
         liveAcpSession = String(snapshot?.sessionId || '') === sessionId;
@@ -3239,7 +3922,8 @@ class AgentManager extends EventEmitter {
     const command = startsFreshAcpSession
       ? (agent.forkCommand || agent.command)
       : buildAgentSessionResumeCommand(provider, sessionId, {
-          cwd: agent.cwd || agent.projectWorkspace || '',
+          cwd: effectiveAgentWorkspaceRoot(agent),
+          providerHomePath: agent.providerHomePath || '',
         });
     if (!command) return { error: 'Failed to build provider resume command' };
     const preserved = {
@@ -3250,13 +3934,13 @@ class AgentManager extends EventEmitter {
       unread: agent.unread === true,
       jsonCliEvents: isJsonCliAgent(agent)
         ? this.jsonCliRuntime.getEvents(agentId)
-        : (Array.isArray(agent.jsonCliEvents) ? agent.jsonCliEvents : []),
+        : (Array.isArray(agent.runtimeResumeState?.jsonEvents) ? agent.runtimeResumeState.jsonEvents : []),
     };
     const restartOptions = {
       wantsMain: agent.wantsMain === true,
       task: agent.task || agent.providerSessionTitle || '',
       workflowTemplate: agent.workflowTemplate || '',
-      projectWorkspace: agent.projectWorkspace || agent.cwd || '',
+      projectWorkspace: effectiveAgentWorkspaceRoot(agent),
       source: startsFreshAcpSession
         ? 'ui-runtime-switch-fresh'
         : resumedAgentSource(provider, sessionId, agent.providerHomeId || ''),
@@ -3277,12 +3961,15 @@ class AgentManager extends EventEmitter {
       codexApprovalMode: agent.launchPermissionMode || undefined,
       jsonCliEvents: preserved.jsonCliEvents,
       runtimeSwitchVerifiedSessionId: startsFreshAcpSession ? '' : sessionId,
+      ...(provider === 'codex' && !startsFreshAcpSession
+        ? preserveCodexSessionProfileOptions()
+        : {}),
     };
-    const originalMode = agent.agentRuntimeMode || 'terminal';
+    const originalMode = currentMode;
     const originalOptions = {
       ...restartOptions,
       agentRuntimeMode: originalMode,
-      codexRuntimeMode: agent.codexRuntimeMode || 'cli',
+      codexRuntimeMode: currentKind === 'app-server' ? 'app-server' : 'cli',
       acpStartFresh: false,
     };
     const startReplacement = options => new Promise(resolve => {
@@ -3295,7 +3982,7 @@ class AgentManager extends EventEmitter {
       try {
         const started = this.startAgent(
           command,
-          agent.cwd || agent.projectWorkspace || null,
+          effectiveAgentWorkspaceRoot(agent) || null,
           (restartedAgentId, error) => finish(restartedAgentId, error),
           options
         );
@@ -3402,11 +4089,11 @@ class AgentManager extends EventEmitter {
     if (!hasResumableSession && !startsFreshCodexSession) {
       return { error: 'Permission changes require a resumable provider session. Try again after the session id is available.' };
     }
-
     const command = startsFreshCodexSession
       ? 'codex'
       : buildAgentSessionResumeCommand(provider, sessionId, {
-        cwd: agent.cwd || agent.projectWorkspace || '',
+        cwd: effectiveAgentWorkspaceRoot(agent),
+        providerHomePath: agent.providerHomePath || '',
       });
     if (!command) {
       return { error: 'Failed to build provider resume command' };
@@ -3417,7 +4104,7 @@ class AgentManager extends EventEmitter {
       task: agent.task || agent.providerSessionTitle || '',
       workflowTemplate: agent.workflowTemplate || '',
       requiredCliVersion: provider === 'codex' ? (agent.requiredCliVersion || '') : '',
-      projectWorkspace: agent.projectWorkspace || agent.cwd || '',
+      projectWorkspace: effectiveAgentWorkspaceRoot(agent),
       source: startsFreshCodexSession
         ? 'ui'
         : (resumedSessionFromSource(agent.source)
@@ -3435,6 +4122,9 @@ class AgentManager extends EventEmitter {
       projectOrder: finiteOrder(agent.projectOrder),
       pinnedOrder: finiteOrder(agent.pinnedOrder),
       ...(provider === 'codex' ? { codexApprovalMode: nextMode } : { claudePermissionMode: nextMode }),
+      ...(provider === 'codex' && hasResumableSession
+        ? preserveCodexSessionProfileOptions()
+        : {}),
     };
     const preserved = {
       pinned: agent.pinned === true,
@@ -3458,7 +4148,7 @@ class AgentManager extends EventEmitter {
     }
 
     return new Promise((resolve) => {
-      const startResult = this.startAgent(command, agent.cwd || agent.projectWorkspace || null, (restartedAgentId, error) => {
+      const startResult = this.startAgent(command, effectiveAgentWorkspaceRoot(agent) || null, (restartedAgentId, error) => {
         if (error) {
           this.emit('update');
           resolve({ error });
@@ -3513,23 +4203,26 @@ class AgentManager extends EventEmitter {
       : this.markAgentReadCursor(agentId);
   }
 
-  async createForkWorktree(workspace) {
+  async resolveGitWorktreeSourceRoot(workspace) {
     const sourceWorkspace = this.expandWorkspacePath(workspace);
     if (!sourceWorkspace) {
       throw new Error('Source workspace is empty');
     }
 
-    let root;
     try {
       const { stdout } = await execFileAsync('git', ['-C', sourceWorkspace, 'rev-parse', '--show-toplevel'], {
         timeout: 15000,
         maxBuffer: 1024 * 1024,
       });
-      root = stdout.trim();
+      return stdout.trim();
     } catch (error) {
       const message = error && error.stderr ? String(error.stderr).trim() : '';
       throw new Error(message || 'Source workspace is not inside a git repository', { cause: error });
     }
+  }
+
+  async createForkWorktree(workspace) {
+    const root = await this.resolveGitWorktreeSourceRoot(workspace);
 
     const parentDir = path.dirname(root);
     const baseName = path.basename(root);
@@ -3554,6 +4247,70 @@ class AgentManager extends EventEmitter {
     return target;
   }
 
+  async createPermanentWorktree(workspace) {
+    const root = await this.resolveGitWorktreeSourceRoot(workspace);
+    const parentDir = path.dirname(root);
+    const baseName = path.basename(root);
+    const slug = timestampSlug();
+    let suffix = 1;
+
+    while (suffix < 1000) {
+      const suffixText = suffix === 1 ? '' : `-${suffix}`;
+      const target = path.join(parentDir, `${baseName}-farming-worktree-${slug}${suffixText}`);
+      const branch = `farming/worktree-${slug}${suffixText}`;
+      let branchExists = false;
+      try {
+        await execFileAsync('git', ['-C', root, 'show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+          timeout: 15000,
+          maxBuffer: 1024 * 1024,
+        });
+        branchExists = true;
+      } catch (error) {
+        if (error?.code !== 1) {
+          const message = error && error.stderr ? String(error.stderr).trim() : '';
+          throw new Error(message || 'Failed to inspect git branches', { cause: error });
+        }
+      }
+
+      if (!fs.existsSync(target) && !branchExists) {
+        try {
+          await execFileAsync('git', ['-C', root, 'worktree', 'add', '-b', branch, target, 'HEAD'], {
+            timeout: 60000,
+            maxBuffer: 1024 * 1024 * 4,
+          });
+        } catch (error) {
+          const message = error && error.stderr ? String(error.stderr).trim() : '';
+          throw new Error(message || 'Failed to create permanent git worktree', { cause: error });
+        }
+        return { workspace: target, branch, sourceWorkspace: root };
+      }
+      suffix += 1;
+    }
+
+    throw new Error('Unable to allocate a permanent worktree name');
+  }
+
+  async rollbackPermanentWorktree(created) {
+    if (!created?.workspace || !created?.sourceWorkspace) return;
+    try {
+      await execFileAsync('git', ['-C', created.sourceWorkspace, 'worktree', 'remove', '--force', created.workspace], {
+        timeout: 60000,
+        maxBuffer: 1024 * 1024 * 4,
+      });
+    } catch {
+      // Rollback is best-effort so the original create/persist failure remains visible.
+    }
+    if (!created.branch) return;
+    try {
+      await execFileAsync('git', ['-C', created.sourceWorkspace, 'branch', '-D', created.branch], {
+        timeout: 30000,
+        maxBuffer: 1024 * 1024 * 4,
+      });
+    } catch {
+      // The worktree removal may already have pruned the newly created branch.
+    }
+  }
+
   async inspectForkWorktreeProject(workspace) {
     const expanded = this.expandWorkspacePath(workspace);
     const resolvedWorkspace = expanded ? path.resolve(expanded) : '';
@@ -3608,7 +4365,7 @@ class AgentManager extends EventEmitter {
     const resolvedWorkspace = path.resolve(workspace);
     return Array.from(this.agents.values()).filter(agent => {
       if (!agent || agent.isMain) return false;
-      const agentWorkspace = this.expandWorkspacePath(agent.projectWorkspace || agent.cwd || '');
+      const agentWorkspace = this.expandWorkspacePath(effectiveAgentWorkspaceRoot(agent));
       if (!agentWorkspace) return false;
       return path.resolve(agentWorkspace) === resolvedWorkspace;
     });
@@ -3621,7 +4378,7 @@ class AgentManager extends EventEmitter {
 
     const keysToRemove = new Set();
     agents.forEach(agent => {
-      const providerSessionKey = agent.providerSessionKey || this.providerSessionKey(
+      const providerSessionKey = agent.providerSessionKey || mainPageAgentSessionKey(
         agent.providerSessionProvider,
         agent.providerSessionId,
         agent.providerHomeId || ''
@@ -3693,8 +4450,21 @@ class AgentManager extends EventEmitter {
     if (!agent) {
       return { error: 'Agent not found' };
     }
+    if (!['same-worktree', 'new-worktree'].includes(mode)) {
+      return { error: 'Unsupported fork mode' };
+    }
+
+    const sourceWorkspace = effectiveAgentWorkspaceRoot(agent);
+    const resumedSession = agent.providerSessionProvider
+      && agent.providerSessionId
+      && agent.providerSessionTemporary !== true
+      ? { provider: agent.providerSessionProvider, providerHomeId: agent.providerHomeId || 'default', sessionId: agent.providerSessionId }
+      : resumedSessionFromSource(agent.source);
+    if (resumedSession?.provider === 'codex') {
+      const availability = await this.ensureCodexSessionAvailableForFork(agent, resumedSession, sourceWorkspace);
+      if (availability?.error) return availability;
+    }
 
-    const sourceWorkspace = agent.projectWorkspace || agent.cwd;
     let targetWorkspace = sourceWorkspace;
     if (mode === 'new-worktree') {
       try {
@@ -3702,19 +4472,13 @@ class AgentManager extends EventEmitter {
       } catch (error) {
         return { error: error.message || 'Failed to create git worktree' };
       }
-    } else if (mode !== 'same-worktree') {
-      return { error: 'Unsupported fork mode' };
     }
 
-    const resumedSession = agent.providerSessionProvider
-      && agent.providerSessionId
-      && agent.providerSessionTemporary !== true
-      ? { provider: agent.providerSessionProvider, providerHomeId: agent.providerHomeId || 'default', sessionId: agent.providerSessionId }
-      : resumedSessionFromSource(agent.source);
     const forkCommand = resumedSession
       ? buildAgentSessionResumeCommand(resumedSession.provider, resumedSession.sessionId, {
         fork: true,
         cwd: targetWorkspace,
+        providerHomePath: agent.providerHomePath || '',
       })
       : (agent.forkCommand || agent.command);
 
@@ -3741,10 +4505,62 @@ class AgentManager extends EventEmitter {
         source: mode === 'new-worktree' ? 'ui-fork-new-worktree' : 'ui-fork-same-worktree',
         providerHomeId: agent.providerHomeId || (resumedSession && resumedSession.providerHomeId) || '',
         providerHomePath: agent.providerHomePath || '',
+        ...(resumedSession?.provider === 'codex'
+          ? preserveCodexSessionProfileOptions()
+          : {}),
       });
     });
   }
 
+  async ensureCodexSessionAvailableForFork(agent, resumedSession, sourceWorkspace) {
+    const providerHomeId = agent.providerHomeId || resumedSession.providerHomeId || 'default';
+    const providerHomePath = agent.providerHomePath || '';
+    const sessionId = resumedSession.sessionId;
+    const unarchiveKey = `${providerHomePath || providerHomeId}:${sessionId}`;
+    const inFlight = this.codexSessionUnarchiveInFlight.get(unarchiveKey);
+    if (inFlight) return inFlight;
+
+    const unarchivePromise = (async () => {
+      let session;
+      try {
+        session = await findAgentSession('codex', sessionId, {
+          limit: 1000,
+          providerLimit: 1000,
+          scanLimit: 5000,
+          providerHomeId,
+          providerHomes: providerHomePath
+            ? { codex: [{ id: providerHomeId, path: providerHomePath }] }
+            : undefined,
+        });
+      } catch (error) {
+        return {
+          error: `Failed to inspect Codex session before forking: ${error && (error.message || error)}`,
+        };
+      }
+      if (!session || session.archived !== true) return null;
+
+      const result = await this.unarchiveCodexSession(sessionId, {
+        ...session,
+        // Fork is an action on the live Farming Agent. Its current workspace is
+        // authoritative even when the older provider history cwd no longer exists.
+        cwd: sourceWorkspace || session.cwd || session.workspace,
+        providerHomePath: session.providerHomePath || providerHomePath,
+      });
+      if (!result?.error) return null;
+      return {
+        error: `Codex session ${sessionId} is archived and could not be unarchived before forking: ${result.error}`,
+      };
+    })();
+    this.codexSessionUnarchiveInFlight.set(unarchiveKey, unarchivePromise);
+    try {
+      return await unarchivePromise;
+    } finally {
+      if (this.codexSessionUnarchiveInFlight.get(unarchiveKey) === unarchivePromise) {
+        this.codexSessionUnarchiveInFlight.delete(unarchiveKey);
+      }
+    }
+  }
+
   recordTaskHistory(agent, options = {}) {
     if (!agent || agent.id === this.mainAgentId) return;
     if (!isSupportedHistoryAgent(agent.forkCommand || agent.command || '')) return;
@@ -3758,7 +4574,7 @@ class AgentManager extends EventEmitter {
       agentId: agent.id,
       command: agent.command || '',
       cwd: agent.cwd || '',
-      projectWorkspace: agent.projectWorkspace || agent.cwd || '',
+      projectWorkspace: effectiveAgentWorkspaceRoot(agent),
       title: agent.customTitle || agent.sessionTitle || agent.task || '',
       customTitle: agent.customTitle || '',
       task: agent.task || '',
@@ -3790,8 +4606,38 @@ class AgentManager extends EventEmitter {
       reason: 'manual-archive',
       recordHistory: !isEphemeralShellAgent(agent),
     });
+    this.scheduleCodexSessionArchive(agent);
     return { agentId, archived: true, removed: true, removedMainPageSessionKeys };
   }
+
+  scheduleCodexSessionArchive(agent) {
+    if (
+      !agent
+      || agent.providerSessionProvider !== 'codex'
+      || !agent.providerSessionId
+      || agent.providerSessionTemporary === true
+    ) {
+      return;
+    }
+
+    const sessionId = agent.providerSessionId;
+    const session = {
+      cliVersion: agent.cliVersion || '',
+      cwd: agent.cwd || '',
+      workspace: agent.projectWorkspace || '',
+      providerHomePath: agent.providerHomePath || '',
+    };
+    void Promise.resolve()
+      .then(() => this.archiveCodexSession(sessionId, session))
+      .then(result => {
+        if (result?.error) {
+          console.error(`Failed to archive Codex session ${sessionId}: ${result.error}`);
+        }
+      })
+      .catch(error => {
+        console.error(`Failed to archive Codex session ${sessionId}:`, error);
+      });
+  }
   
   async killAgent(agentId, options = {}) {
     const agent = this.agents.get(agentId);
@@ -3817,9 +4663,9 @@ class AgentManager extends EventEmitter {
     this.lastActivity.delete(agentId);
     this.lastActivityUpdate.delete(agentId);
     this.outputEvents.delete(agentId);
+    this.agentUsageRateCache.delete(agentId);
     this.lastResizeByAgent.delete(agentId);
-    this.stopCodexProviderSessionResolver(agentId);
-    this.stopProviderSessionTitleResolver(agentId);
+    this.providerSessionService.stop(agentId);
     if (this.codexAppServerRuntime && typeof this.codexAppServerRuntime.unregisterAgent === 'function') {
       this.codexAppServerRuntime.unregisterAgent(agentId);
     }
@@ -3873,19 +4719,20 @@ class AgentManager extends EventEmitter {
       return null;
     }
 
-    return agent.projectWorkspace || agent.cwd;
+    return effectiveAgentWorkspaceRoot(agent);
   }
 
   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: agent.codexAppServerHomePath || '',
-      codexRuntimeMode: agent.codexRuntimeMode || '',
+      codexAppServerHomePath: appServer?.homePath || '',
+      runtimeBinding: publicRuntimeBinding(agent),
       temporary: agent.providerSessionTemporary === true,
       title: agent.providerSessionTitle || '',
     };
@@ -3965,6 +4812,7 @@ class AgentManager extends EventEmitter {
       engineName: agent.engineName || '',
       cwd: agent.cwd,
       projectWorkspace: agent.projectWorkspace || '',
+      gitWorktree: publicAgentGitWorktree(agent),
       status: sessionState && sessionState.status === 'exited'
         ? agent.status
         : (isLiveEngineSessionState(sessionState) ? 'running' : agent.status),
@@ -3989,27 +4837,9 @@ class AgentManager extends EventEmitter {
       providerSessionSource: agent.providerSessionSource || '',
       providerSessionResolvedAt: agent.providerSessionResolvedAt || null,
       providerSessionTitle: agent.providerSessionTitle || '',
+      providerSessionWorkspace: agent.providerSessionWorkspace || '',
       terminalInputReceived: agent.terminalInputReceived === true,
-      codexRuntimeMode: agent.codexRuntimeMode || '',
-      agentRuntimeMode: agent.agentRuntimeMode || 'terminal',
-      acpState: agent.acpState || '',
-      acpError: agent.acpError || '',
-      acpStopReason: agent.acpStopReason || '',
-      acpPendingPermission: agent.acpPendingPermission || null,
-      acpPendingPermissions: Array.isArray(agent.acpPendingPermissions) ? agent.acpPendingPermissions : [],
-      acpPendingElicitation: agent.acpPendingElicitation || null,
-      acpPendingElicitations: Array.isArray(agent.acpPendingElicitations) ? agent.acpPendingElicitations : [],
-      acpActiveElicitations: Array.isArray(agent.acpActiveElicitations) ? agent.acpActiveElicitations : [],
-      acpSessionUpdatedAt: agent.acpSessionUpdatedAt || '',
-      acpSessionRevision: Number(agent.acpSessionRevision) || 0,
-      codexAppServerState: agent.codexAppServerState || '',
-      codexAppServerEndpoint: agent.codexAppServerEndpoint || '',
-      codexAppServerThreadId: agent.codexAppServerThreadId || '',
-      codexAppServerTurnId: agent.codexAppServerTurnId || '',
-      codexAppServerError: agent.codexAppServerError || '',
-      codexAppServerPendingRequestId: agent.codexAppServerPendingRequestId || '',
-      codexAppServerPendingRequestMethod: agent.codexAppServerPendingRequestMethod || '',
-      codexAppServerPendingRequest: agent.codexAppServerPendingRequest || null,
+      runtimeBinding: publicRuntimeBinding(agent),
       forkedFromProviderSessionId: agent.forkedFromProviderSessionId || '',
       customTitle: agent.customTitle || '',
       pinned: agent.pinned === true,
@@ -4020,12 +4850,21 @@ class AgentManager extends EventEmitter {
       attentionUpdatedAt: finiteNumberOrNull(agent.attentionUpdatedAt),
       readAttentionAt: finiteNumberOrNull(agent.readAttentionAt),
       attentionReason: agent.attentionReason || '',
+      attentionOutputEpoch: agent.attentionOutputEpoch || '',
       attentionOutputSeq: finiteNumberOrNull(agent.attentionOutputSeq),
+      readOutputEpoch: agent.readOutputEpoch || '',
+      readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
       unread: agentAttentionUnread(agent),
       archived: agent.archived === true,
       archivedAt: agent.archivedAt || null,
       sessionSource: this.getEngineSessionSource(agent.engineName),
+      runtimeEpoch: sessionState && typeof sessionState.runtimeEpoch === 'string'
+        ? sessionState.runtimeEpoch
+        : (agent.runtimeEpoch || ''),
       outputSeq: sessionState && Number.isFinite(sessionState.outputSeq) ? sessionState.outputSeq : null,
+      stateRevision: sessionState && Number.isFinite(sessionState.stateRevision)
+        ? sessionState.stateRevision
+        : null,
       isMain,
       activityLevel: isMain ? 'warm' : this.calculateActivityLevel(lastActivity, now),
       lastActivity,
@@ -4037,6 +4876,7 @@ class AgentManager extends EventEmitter {
       output: (sessionState && typeof sessionState.output === 'string') ? sessionState.output : fallbackOutput,
       renderOutput: (sessionState && typeof sessionState.renderOutput === 'string') ? sessionState.renderOutput : fallbackOutput,
       previewText,
+      codexTerminalProfile: activeCodexTerminalProfile(agent, previewText),
       previewSnapshot: (sessionState && sessionState.previewSnapshot) || agent.previewSnapshot || null,
       previewCols: (sessionState && Number.isFinite(sessionState.previewCols) && sessionState.previewCols > 0)
         ? sessionState.previewCols
@@ -4044,10 +4884,28 @@ class AgentManager extends EventEmitter {
       previewRows: (sessionState && Number.isFinite(sessionState.previewRows) && sessionState.previewRows > 0)
         ? sessionState.previewRows
         : (agent.previewRows || 30),
-      usageRate: this.calculateAgentUsageRate(agent.id),
+      usageRate: this.getAgentUsageRate(agent.id),
     };
   }
 
+  getAgentUsageRate(agentId, options = {}) {
+    const now = options.now || Date.now();
+    const windowMs = options.windowMs || AGENT_USAGE_RATE_WINDOW_MS;
+    const cached = this.agentUsageRateCache.get(agentId);
+    if (
+      cached
+      && cached.windowMs === windowMs
+      && now >= cached.sampledAt
+      && now - cached.sampledAt < AGENT_USAGE_RATE_REFRESH_MS
+    ) {
+      return cached.value;
+    }
+
+    const value = this.calculateAgentUsageRate(agentId, { now, windowMs });
+    this.agentUsageRateCache.set(agentId, { windowMs, sampledAt: now, value });
+    return value;
+  }
+
   calculateAgentUsageRate(agentId, options = {}) {
     const now = options.now || Date.now();
     const windowMs = options.windowMs || AGENT_USAGE_RATE_WINDOW_MS;
@@ -4084,7 +4942,7 @@ class AgentManager extends EventEmitter {
       cwd: agent.cwd,
       isMain: this.isMainAgentRecord(agent.id, agent),
       status: agent.status,
-      usageRate: this.calculateAgentUsageRate(agent.id, { now, windowMs }),
+      usageRate: this.getAgentUsageRate(agent.id, { now, windowMs }),
     }));
     const totalOutputBytes = agents.reduce((sum, agent) => sum + agent.usageRate.outputBytes, 0);
     const estimatedOutputTokens = agents.reduce((sum, agent) => sum + agent.usageRate.estimatedOutputTokens, 0);
@@ -4125,13 +4983,18 @@ class AgentManager extends EventEmitter {
         command: agent.command,
         engineName: agent.engineName || '',
         cwd: agent.cwd,
-        projectWorkspace: agent.projectWorkspace || '',
+        projectWorkspace: canonicalWorkspacePath(agent.projectWorkspace || ''),
+        gitWorktree: publicAgentGitWorktree(agent),
         output: agent.output.slice(-2000),
         previewText: agent.previewText || '',
+        codexTerminalProfile: activeCodexTerminalProfile(agent, agent.previewText || ''),
         previewCols: agent.previewCols || 80,
         previewRows: agent.previewRows || 30,
         sessionTitle: agent.sessionTitle || '',
         sessionSource: this.getEngineSessionSource(agent.engineName),
+        runtimeEpoch: agent.runtimeEpoch || '',
+        outputSeq: finiteNumberOrNull(agent.lastOutputSeq),
+        stateRevision: finiteNumberOrNull(agent.stateRevision),
         status: agent.status,
         terminalBusy,
         terminalStatus,
@@ -4155,33 +5018,11 @@ class AgentManager extends EventEmitter {
         providerSessionSource: agent.providerSessionSource || '',
         providerSessionResolvedAt: agent.providerSessionResolvedAt || null,
         providerSessionTitle: agent.providerSessionTitle || '',
+        providerSessionWorkspace: agent.providerSessionWorkspace || '',
+        providerCapabilities: providerCapabilities(agent.providerSessionProvider),
         terminalInputReceived: agent.terminalInputReceived === true,
-        codexRuntimeMode: agent.codexRuntimeMode || '',
-        agentRuntimeMode: agent.agentRuntimeMode || 'terminal',
-        jsonCliState: agent.jsonCliState || '',
-        jsonCliError: agent.jsonCliError || '',
-        jsonCliTranscriptUpdatedAt: agent.jsonCliTranscriptUpdatedAt || '',
-        acpState: agent.acpState || '',
-        acpError: agent.acpError || '',
-        acpStopReason: agent.acpStopReason || '',
-        acpPendingPermission: agent.acpPendingPermission || null,
-        acpPendingPermissions: Array.isArray(agent.acpPendingPermissions) ? agent.acpPendingPermissions : [],
-        acpPendingElicitation: agent.acpPendingElicitation || null,
-        acpPendingElicitations: Array.isArray(agent.acpPendingElicitations) ? agent.acpPendingElicitations : [],
-        acpActiveElicitations: Array.isArray(agent.acpActiveElicitations) ? agent.acpActiveElicitations : [],
-        acpSessionUpdatedAt: agent.acpSessionUpdatedAt || '',
-        acpSessionRevision: Number(agent.acpSessionRevision) || 0,
-        codexAppServerState: agent.codexAppServerState || '',
-        codexAppServerEndpoint: agent.codexAppServerEndpoint || '',
-        codexAppServerThreadId: agent.codexAppServerThreadId || '',
-        codexAppServerTurnId: agent.codexAppServerTurnId || '',
-        codexAppServerError: agent.codexAppServerError || '',
-        codexAppServerPendingRequestId: agent.codexAppServerPendingRequestId || '',
-        codexAppServerPendingRequestMethod: agent.codexAppServerPendingRequestMethod || '',
-        codexAppServerPendingRequest: agent.codexAppServerPendingRequest || null,
-        codexAppServerNotice: agent.codexAppServerNotice || null,
-        codexAppServerGoal: agent.codexAppServerGoal || null,
-        codexCliObserverDeferred: agent.codexCliObserverDeferred === true,
+        runtimeBinding: publicRuntimeBinding(agent),
+        runtimeObservation: deriveRuntimeObservation(agent),
         forkedFromProviderSessionId: agent.forkedFromProviderSessionId || '',
         restartedFromAgentId: agent.restartedFromAgentId || '',
         restartedFromAgentIds: Array.isArray(agent.restartedFromAgentIds) ? agent.restartedFromAgentIds : [],
@@ -4195,11 +5036,14 @@ class AgentManager extends EventEmitter {
         attentionUpdatedAt: finiteNumberOrNull(agent.attentionUpdatedAt),
         readAttentionAt: finiteNumberOrNull(agent.readAttentionAt),
         attentionReason: agent.attentionReason || '',
+        attentionOutputEpoch: agent.attentionOutputEpoch || '',
         attentionOutputSeq: finiteNumberOrNull(agent.attentionOutputSeq),
+        readOutputEpoch: agent.readOutputEpoch || '',
+        readOutputSeq: finiteNumberOrNull(agent.readOutputSeq),
         unread: agentAttentionUnread(agent),
         archived: agent.archived === true,
         archivedAt: agent.archivedAt || null,
-        canForkNewWorktree: this.canCreateForkWorktree(agent.projectWorkspace || agent.cwd || ''),
+        canForkNewWorktree: this.canCreateForkWorktree(effectiveAgentWorkspaceRoot(agent)),
         startedAt: agent.startedAt || null,
         exitedAt: agent.exitedAt || null,
         // Main agent is exempt from activity/attention/zombie scoring
@@ -4207,7 +5051,7 @@ class AgentManager extends EventEmitter {
         lastActivity,
         attentionScore: isMain ? 0 : this.calculateAttentionScore(id, now),
         isZombie: isMain ? false : this.isZombie(id, now),
-        usageRate: this.calculateAgentUsageRate(id, { now })
+        usageRate: this.getAgentUsageRate(id, { now })
       });
     }
     
@@ -4280,6 +5124,10 @@ class AgentManager extends EventEmitter {
     this.on('update', callback);
   }
 
+  onAgentActivity(callback) {
+    this.on('agent-activity', callback);
+  }
+
   onSessionStream(callback) {
     this.on('session-stream', callback);
   }
@@ -4295,17 +5143,20 @@ class AgentManager extends EventEmitter {
         continue;
       }
 
+      const terminalStatus = deriveAgentTerminalStatus(agent, {
+        previewText: agent.previewText || '',
+        title: agent.sessionTitle || '',
+        terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
+      });
       previews.push({
         agentId: agent.id,
         previewText: agent.previewText || '',
         cols: agent.previewCols || 80,
         rows: agent.previewRows || 30,
         previewSnapshot: agent.previewSnapshot || null,
-        terminalStatus: deriveAgentTerminalStatus(agent, {
-          previewText: agent.previewText || '',
-          title: agent.sessionTitle || '',
-          terminalBusy: typeof agent.terminalBusy === 'boolean' ? agent.terminalBusy : null,
-        }),
+        codexTerminalProfile: activeCodexTerminalProfile(agent, agent.previewText || ''),
+        terminalStatus,
+        runtimeObservation: deriveRuntimeObservation({ ...agent, terminalStatus }),
       });
     }