farming-code 2.2.20 → 2.2.22

package/backend/acp-runtime.js

@@ -13,7 +13,7 @@ const { readCodexHistoryImageData } = require('./codex-transcript');
 const { AcpClientFileSystem, AcpClientTerminalManager } = require('./acp/client-services');
 const { PACKAGED_CODEX_ACP_ARG } = require('./acp/packaged-codex-acp');
 const { permissionSecurityWarnings } = require('./acp/permission-security');
-const { rejectPatch } = require('./acp/patch-decisions');
+const { patchBlock, rejectPatch } = require('./acp/patch-decisions');
 const { getProviderAdapter, listProviderAdapters } = require('./provider-adapters');
 const { isSafeProviderSessionId } = require('./provider-session-id');
 
@@ -35,7 +35,7 @@ const CODEX_SET_SESSION_MODEL_METHOD = 'session/set_model';
 const CODEX_STEER_METHOD = '_codex/session/steer';
 const CODEX_ACP_PACKAGE = '@agentclientprotocol/codex-acp';
 const CODEX_ACP_VERSION = '1.1.4';
-const CODEX_ACP_SHA256 = '39cbae01e336c2ca185d624358e03280d1f6fef6d73bbe42dd9eb77e2b1efb32';
+const CODEX_ACP_SHA256 = 'e36876cc2250737c719644e6c69ab054a3f8b58071fad45c44407013082942ff';
 const CODEX_ACP_VENDOR_ENTRY = path.join(
   __dirname,
   '..',
@@ -234,7 +234,8 @@ function validateElicitationContent(request, content) {
 function interactiveRuntimeState(binding, fallback = '') {
   if (binding.pendingPermissions.size > 0) return 'waiting-for-permission';
   if (binding.pendingElicitations.size > 0) return 'waiting-for-input';
-  if (binding.promptActive) return 'working';
+  if (binding.activeTurn?.phase === 'running') return 'working';
+  if (binding.activeTurn?.phase === 'cancelling') return 'interrupting';
   if (['connecting', 'idle', 'error'].includes(String(fallback || ''))) return fallback;
   return binding.sessionId ? 'idle' : 'connecting';
 }
@@ -336,6 +337,98 @@ function signalProcessTree(binding, signal) {
   binding.child.kill(signal);
 }
 
+async function stopBindingProcessAndWait(binding) {
+  if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_GRACEFUL_EXIT_MS)) return;
+  signalProcessTree(binding, 'SIGTERM');
+  if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_TERMINATE_MS)) return;
+  signalProcessTree(binding, 'SIGKILL');
+  if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_KILL_MS)) return;
+  throw new Error(`ACP identity adapter process tree ${binding.child?.pid || ''} did not exit`);
+}
+
+async function describeAcpProcessGroup(pid) {
+  const processId = Number(pid);
+  if (!Number.isSafeInteger(processId) || processId <= 0 || process.platform === 'win32') {
+    return null;
+  }
+  let stdout;
+  try {
+    ({ stdout } = await execFileAsync(
+      '/bin/ps',
+      ['-p', String(processId), '-o', 'pid=', '-o', 'pgid=', '-o', 'lstart='],
+      { encoding: 'utf8', timeout: 1_000, maxBuffer: 16_384 },
+    ));
+  } catch (error) {
+    if (error?.code === 1 || error?.code === 'ESRCH') return null;
+    throw error;
+  }
+  const match = String(stdout || '').trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+  if (!match || Number(match[1]) !== processId) {
+    throw new Error(`Could not read ACP process identity for pid ${processId}`);
+  }
+  if (Number(match[2]) !== processId) {
+    throw new Error(`ACP process ${processId} did not become its own process-group leader`);
+  }
+  return {
+    pid: processId,
+    processGroupId: Number(match[2]),
+    startedAt: match[3].trim(),
+  };
+}
+
+async function stopPersistedAcpProcessGroup(identity) {
+  const expected = identity && typeof identity === 'object' ? identity : null;
+  if (
+    !expected
+    || !Number.isSafeInteger(Number(expected.pid))
+    || !Number.isSafeInteger(Number(expected.processGroupId))
+    || !String(expected.startedAt || '').trim()
+  ) {
+    return { stopped: false, missingProof: true };
+  }
+  const processGroupId = Number(expected.processGroupId);
+  const groupHasExited = () => {
+    try {
+      process.kill(-processGroupId, 0);
+      return false;
+    } catch (error) {
+      return error?.code === 'ESRCH';
+    }
+  };
+  const current = await describeAcpProcessGroup(Number(expected.pid));
+  if (!current && groupHasExited()) return { stopped: true, alreadyExited: true };
+  if (
+    current
+    && (
+      current.processGroupId !== processGroupId
+      || current.startedAt !== String(expected.startedAt)
+    )
+  ) {
+    return { stopped: false, identityMismatch: true };
+  }
+  const waitForExit = async timeoutMs => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      if (groupHasExited()) return true;
+      await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    return groupHasExited();
+  };
+  const signal = value => {
+    try {
+      process.kill(-processGroupId, value);
+    } catch (error) {
+      if (error?.code !== 'ESRCH') throw error;
+    }
+  };
+
+  signal('SIGTERM');
+  if (await waitForExit(IDENTITY_ADAPTER_TERMINATE_MS)) return { stopped: true };
+  signal('SIGKILL');
+  if (await waitForExit(IDENTITY_ADAPTER_KILL_MS)) return { stopped: true };
+  return { stopped: false, timedOut: true };
+}
+
 async function deleteProviderSessionIdentity(options = {}) {
   const provider = String(options.provider || '').trim().toLowerCase();
   const sessionId = String(options.sessionId || '').trim();
@@ -386,22 +479,66 @@ class AcpRuntime extends EventEmitter {
     this.historyReplayQuietMs = options.historyReplayQuietMs ?? DEFAULT_HISTORY_REPLAY_QUIET_MS;
     this.historyReplayMaxWaitMs = options.historyReplayMaxWaitMs ?? DEFAULT_HISTORY_REPLAY_MAX_WAIT_MS;
     this.deleteProviderSessionIdentity = options.deleteProviderSessionIdentity || deleteProviderSessionIdentity;
+    this.describeProcessGroup = options.describeAcpProcessGroup || describeAcpProcessGroup;
     this.checkpointStore = options.checkpointStore
       || (options.configDir ? new AcpCheckpointStore(options.configDir, options.checkpointOptions) : null);
     this.bindings = new Map();
-    this.permissionSequence = 0;
-    this.elicitationSequence = 0;
+    this.disposing = false;
+    this.disposePromise = null;
+    this.disposed = false;
     this.clientFileSystem = options.clientFileSystem || new AcpClientFileSystem();
     this.clientTerminals = options.clientTerminals || new AcpClientTerminalManager({ spawn: options.terminalSpawn });
   }
 
   async prepareAgent(options = {}) {
+    if (this.disposing || this.disposed) {
+      throw new Error('ACP runtime is shutting down');
+    }
     const agentId = String(options.agentId || '');
     if (!agentId) throw new Error('ACP Agent id is required');
     if (this.bindings.has(agentId)) throw new Error('ACP Agent is already registered');
     const provider = String(options.provider || '').trim().toLowerCase();
     const launch = this.resolveLaunch(provider, options);
     const cwd = path.resolve(options.cwd || process.cwd());
+    const requestedSessionId = String(options.sessionId || '').trim();
+    const forkSourceSessionId = String(options.forkSourceSessionId || '').trim();
+    const forkSourceCheckpoint = options.forkSourceCheckpoint || null;
+    const forkSourceSessionCheckpoint = forkSourceCheckpoint?.version === 2
+      ? forkSourceCheckpoint.sessionState
+      : forkSourceCheckpoint;
+    const revisionBase = Number.isFinite(Number(options.revisionBase))
+      ? Math.max(0, Math.floor(Number(options.revisionBase)))
+      : 0;
+    let forkSourceCheckpointState = null;
+    if (forkSourceSessionId) {
+      if (requestedSessionId) {
+        throw new Error('ACP fork startup cannot also load a target session');
+      }
+      if (!isSafeProviderSessionId(forkSourceSessionId)) {
+        throw new Error('ACP fork startup requires a safe exact source session id');
+      }
+      if (!forkSourceCheckpoint) {
+        throw new Error('ACP fork startup requires an exact source checkpoint');
+      }
+      const checkpointCwd = String(forkSourceSessionCheckpoint?.cwd || '').trim();
+      if (
+        String(forkSourceSessionCheckpoint?.provider || '') !== provider
+        || String(forkSourceSessionCheckpoint?.sessionId || '') !== forkSourceSessionId
+        || !checkpointCwd
+        || path.resolve(checkpointCwd) !== cwd
+      ) {
+        throw new Error('ACP fork source checkpoint does not match the requested source');
+      }
+      forkSourceCheckpointState = AcpSessionState.fromCheckpoint(forkSourceSessionCheckpoint, {
+        provider,
+        sessionId: forkSourceSessionId,
+        cwd,
+        maxUpdates: this.maxUpdates,
+      });
+      if (!forkSourceCheckpointState) {
+        throw new Error('ACP fork source checkpoint is invalid');
+      }
+    }
     const sessionRequestOptions = acpSessionRequestOptions(options, cwd);
     const binding = {
       agentId,
@@ -413,7 +550,7 @@ class AcpRuntime extends EventEmitter {
       launch,
       restartOptions: { ...options, agentId, provider },
       approvalMode: options.approvalMode || 'approve',
-      ownsProcessGroup: options.identityOnly === true && process.platform !== 'win32',
+      ownsProcessGroup: process.platform !== 'win32',
       child: null,
       connection: null,
       initializeResponse: null,
@@ -430,23 +567,43 @@ class AcpRuntime extends EventEmitter {
       elicitationResolvers: new Map(),
       activeElicitations: new Map(),
       subagentStates: new Map(),
+      subagentControls: new Map(),
+      nextSubagentGeneration: 1,
       interactionOrigins: new Map(),
-      promptActive: false,
+      // One binding owns at most one Turn. All Turn controls and its terminal
+      // commit are fenced by this object before they may mutate shared state.
+      activeTurn: null,
+      nextTurnId: 1,
       supportsSteer: false,
-      steerTail: null,
       historyReplayActive: false,
       sessionState: null,
       authTerminal: null,
       patchDecisions: new Map(),
+      patchDecisionInFlight: new Map(),
       checkpointProof: null,
+      sessionMutation: null,
+      configMutationTail: null,
       stderr: '',
+      exited: false,
       updatedAt: new Date().toISOString(),
     };
     this.bindings.set(agentId, binding);
     this.emitRuntime(binding);
 
     try {
-      const child = this.spawn(launch.command, launch.args, {
+      const gatedLaunch = binding.ownsProcessGroup
+        ? {
+            command: '/bin/sh',
+            args: [
+              '-c',
+              'IFS= read -r farming_acp_start || exit 0; exec "$@"',
+              'farming-acp-start-gate',
+              launch.command,
+              ...launch.args,
+            ],
+          }
+        : launch;
+      const child = this.spawn(gatedLaunch.command, gatedLaunch.args, {
         cwd: binding.cwd,
         env: binding.env,
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -463,13 +620,30 @@ class AcpRuntime extends EventEmitter {
           this.handleExit(binding, code === 0 ? null : new Error(detail));
         }
       });
+      if (binding.ownsProcessGroup && typeof options.onProcessStarted === 'function') {
+        const processIdentity = await this.describeProcessGroup(child.pid);
+        if (!processIdentity) {
+          throw new Error(`ACP process ${child.pid || ''} exited before its identity was persisted`);
+        }
+        await options.onProcessStarted(processIdentity);
+      }
+      if (binding.ownsProcessGroup) {
+        await new Promise((resolve, reject) => {
+          child.stdin.write('start\n', error => {
+            if (error) reject(error);
+            else resolve();
+          });
+        });
+      }
 
       const connection = this.createConnection
         ? await this.createConnection(this.clientHandlers(binding), child, binding)
         : await this.officialConnection(this.clientHandlers(binding), child);
       binding.connection = connection;
+      this.requireOpenBinding(binding);
       connection.closed.catch(error => this.handleExit(binding, error));
       const sdk = await loadAcpSdk();
+      this.requireOpenBinding(binding);
       binding.initializeResponse = await withTimeout(connection.initialize({
         protocolVersion: sdk.PROTOCOL_VERSION,
         clientCapabilities: {
@@ -483,20 +657,99 @@ class AcpRuntime extends EventEmitter {
         },
         clientInfo: { name: 'farming', title: 'Farming', version: packageJson.version || '0.0.0' },
       }), this.initializeTimeoutMs, 'ACP initialize');
+      this.requireOpenBinding(binding);
       if (binding.initializeResponse.protocolVersion !== sdk.PROTOCOL_VERSION) {
         throw new Error(`ACP protocol version mismatch: Agent selected ${binding.initializeResponse.protocolVersion}, Farming supports ${sdk.PROTOCOL_VERSION}`);
       }
       binding.supportsSteer = binding.provider === 'codex'
         && supportsCodexSteer(binding.initializeResponse.agentCapabilities);
 
-      const requestedSessionId = String(options.sessionId || '').trim();
-      const revisionBase = Number.isFinite(Number(options.revisionBase))
-        ? Math.max(0, Math.floor(Number(options.revisionBase)))
-        : 0;
       const sessionRequest = { sessionId: requestedSessionId, ...binding.sessionRequestOptions };
       let sessionResponse;
       let historyMode = 'new';
-      if (requestedSessionId) {
+      if (forkSourceSessionId) {
+        const capabilities = binding.initializeResponse.agentCapabilities || {};
+        if (!capabilities.loadSession || !capabilities.sessionCapabilities?.fork) {
+          throw new Error(`${provider} ACP Agent cannot create an owned fork`);
+        }
+        if (!capabilities.sessionCapabilities?.close) {
+          throw new Error(`${provider} ACP Agent cannot release the loaded fork source`);
+        }
+        binding.sessionId = forkSourceSessionId;
+        binding.sessionState = new AcpSessionState({
+          provider,
+          sessionId: forkSourceSessionId,
+          cwd: binding.cwd,
+          maxUpdates: this.maxUpdates,
+          revisionBase,
+        });
+        binding.historyReplayActive = true;
+        let loadedSource;
+        try {
+          loadedSource = await withTimeout(
+            connection.loadSession({ sessionId: forkSourceSessionId, ...binding.sessionRequestOptions }),
+            this.sessionSetupTimeoutMs,
+            'ACP fork source session/load',
+          );
+          this.requireOpenBinding(binding);
+          if (provider === 'qoder') await this.waitForHistoryReplay(binding);
+          this.requireOpenBinding(binding);
+        } finally {
+          binding.historyReplayActive = false;
+        }
+        binding.sessionState.finishHistoryReplay();
+        const forked = await withTimeout(
+          connection.unstable_forkSession({
+            sessionId: forkSourceSessionId,
+            ...binding.sessionRequestOptions,
+          }),
+          this.sessionSetupTimeoutMs,
+          'ACP owned session/fork',
+        );
+        const forkedSessionId = String(forked?.sessionId || '').trim();
+        if (
+          !isSafeProviderSessionId(forkedSessionId)
+          || forkedSessionId === forkSourceSessionId
+        ) {
+          throw new Error('ACP owned session/fork returned an invalid new session id');
+        }
+        if (typeof options.onForkSessionCreated === 'function') {
+          await options.onForkSessionCreated(forkedSessionId);
+        }
+        this.requireOpenBinding(binding);
+        await withTimeout(
+          connection.closeSession({ sessionId: forkSourceSessionId }),
+          this.requestTimeoutMs,
+          'ACP fork source session/close',
+        );
+        this.requireOpenBinding(binding);
+        const forkUpdates = binding.subagentStates.get(forkedSessionId);
+        const restoredForkSource = this.restoreBindingCheckpoint(binding, forkSourceCheckpoint, {
+          sessionId: forkedSessionId,
+        });
+        if (!restoredForkSource) {
+          throw new Error('ACP fork source checkpoint could not be restored');
+        }
+        binding.sessionId = forkedSessionId;
+        binding.sessionState = restoredForkSource.sessionState;
+        binding.subagentStates = restoredForkSource.subagentStates;
+        this.resetSubagentControls(binding);
+        binding.patchDecisions = restoredForkSource.patchDecisions;
+        delete binding.restartOptions.forkSourceSessionId;
+        delete binding.restartOptions.forkSourceCheckpoint;
+        delete binding.restartOptions.onForkSessionCreated;
+        if (forkUpdates?.updates?.some(item => item?.update?.sessionUpdate === 'available_commands_update')) {
+          binding.sessionState.availableCommands = clone(forkUpdates.availableCommands);
+        }
+        sessionResponse = {
+          ...loadedSource,
+          ...forked,
+          sessionId: forkedSessionId,
+          modes: forked?.modes || loadedSource?.modes,
+          configOptions: forked?.configOptions || loadedSource?.configOptions,
+        };
+        historyMode = 'fork';
+      } else if (requestedSessionId) {
         const capabilities = binding.initializeResponse.agentCapabilities || {};
         let opened = false;
         let restoredCheckpointState = null;
@@ -507,6 +760,7 @@ class AcpRuntime extends EventEmitter {
             this.checkpointIdentity(binding, requestedSessionId),
             { allowDirty: true },
           );
+          this.requireOpenBinding(binding);
           restoredCheckpoint = this.restoreBindingCheckpoint(binding, saved?.state, {
             sessionId: requestedSessionId,
           });
@@ -516,10 +770,12 @@ class AcpRuntime extends EventEmitter {
           const providerStateMatches = restoredCheckpoint?.complete === true && saved?.exact === true
             ? await this.checkpointMatchesProviderSession(connection, capabilities, sessionRequest, saved)
             : false;
+          this.requireOpenBinding(binding);
           if (providerStateMatches) {
             binding.sessionId = requestedSessionId;
             binding.sessionState = restoredCheckpointState;
             binding.subagentStates = restoredCheckpoint.subagentStates;
+            this.resetSubagentControls(binding);
             binding.patchDecisions = restoredCheckpoint.patchDecisions;
             binding.checkpointProof = restoredCheckpoint.providerProof;
             try {
@@ -528,9 +784,11 @@ class AcpRuntime extends EventEmitter {
                 this.sessionSetupTimeoutMs,
                 'ACP session/resume'
               );
+              this.requireOpenBinding(binding);
               historyMode = 'checkpoint';
               opened = true;
             } catch (error) {
+              this.requireOpenBinding(binding);
               if (!capabilities.loadSession) throw error;
               console.warn(`ACP checkpoint resume failed for ${provider}; replaying history:`, error && (error.message || error));
             }
@@ -554,7 +812,9 @@ class AcpRuntime extends EventEmitter {
               this.sessionSetupTimeoutMs,
               'ACP session/load'
             );
+            this.requireOpenBinding(binding);
             if (provider === 'qoder') await this.waitForHistoryReplay(binding);
+            this.requireOpenBinding(binding);
           } finally {
             binding.historyReplayActive = false;
           }
@@ -568,8 +828,11 @@ class AcpRuntime extends EventEmitter {
             } catch {
               // Local history images can still be restored from their adapter paths.
             }
+            this.requireOpenBinding(binding);
             await binding.sessionState.hydrateCodexHistoryAttachments({ imageDataByPath });
+            this.requireOpenBinding(binding);
           }
+          this.restorePatchDecisions(binding, restoredCheckpoint?.patchDecisions);
           historyMode = 'load';
           opened = true;
         } else if (!opened && capabilities.sessionCapabilities?.resume) {
@@ -586,6 +849,7 @@ class AcpRuntime extends EventEmitter {
             this.sessionSetupTimeoutMs,
             'ACP session/resume'
           );
+          this.requireOpenBinding(binding);
           historyMode = 'resume';
           opened = true;
         } else {
@@ -597,6 +861,7 @@ class AcpRuntime extends EventEmitter {
           this.sessionSetupTimeoutMs,
           'ACP session/new'
         );
+        this.requireOpenBinding(binding);
         const returnedSessionId = String(sessionResponse.sessionId || '').trim();
         if (!isSafeProviderSessionId(returnedSessionId)) {
           binding.untrustedSessionId = returnedSessionId;
@@ -605,6 +870,7 @@ class AcpRuntime extends EventEmitter {
         binding.sessionId = returnedSessionId;
         binding.sessionState = new AcpSessionState({ provider, sessionId: binding.sessionId, cwd: binding.cwd, maxUpdates: this.maxUpdates });
       }
+      this.requireOpenBinding(binding);
       binding.modes = sessionResponse?.modes || null;
       binding.configOptions = sessionResponse?.configOptions || [];
       binding.sessionState.currentModeId = String(binding.modes?.currentModeId || '');
@@ -619,6 +885,7 @@ class AcpRuntime extends EventEmitter {
           await this.applySessionConfigOption(binding, fastOption.id, fastEnabled, { emit: false });
         }
       }
+      this.requireOpenBinding(binding);
       binding.state = 'idle';
       binding.updatedAt = new Date().toISOString();
       this.scheduleCheckpoint(binding, { exact: true });
@@ -670,7 +937,45 @@ class AcpRuntime extends EventEmitter {
           attachProviderSessionIdentity(runtimeError, identity);
         }
       } else {
-        this.unregisterAgent(agentId);
+        let runtimeCleanupVerified = false;
+        try {
+          if (this.isCurrentBinding(binding)) {
+            runtimeCleanupVerified = await this.unregisterAgentAndWait(agentId, binding);
+          } else {
+            try {
+              binding.connection?.close();
+            } catch {
+              // Process-tree cleanup below remains authoritative.
+            }
+            await stopBindingProcessAndWait(binding);
+            runtimeCleanupVerified = true;
+          }
+        } catch (cleanupError) {
+          Object.defineProperty(runtimeError, 'adapterCleanupError', {
+            value: cleanupError,
+            enumerable: false,
+            configurable: true,
+          });
+        }
+        Object.defineProperties(runtimeError, {
+          runtimeCleanupAttempted: {
+            value: true,
+            enumerable: false,
+            configurable: true,
+          },
+          runtimeCleanupVerified: {
+            value: runtimeCleanupVerified === true,
+            enumerable: false,
+            configurable: true,
+          },
+        });
+        if (!runtimeCleanupVerified && !this.isCurrentBinding(binding)) {
+          try {
+            binding.connection?.close();
+          } catch {
+            // The detached binding remains only as an error cleanup handle.
+          }
+        }
       }
       throw runtimeError;
     }
@@ -738,6 +1043,199 @@ class AcpRuntime extends EventEmitter {
     return result;
   }
 
+  isCurrentBinding(binding) {
+    return Boolean(binding) && this.bindings.get(binding.agentId) === binding;
+  }
+
+  requireCurrentBinding(binding) {
+    if (!this.isCurrentBinding(binding)) {
+      throw new Error('ACP Agent binding is no longer active');
+    }
+    return binding;
+  }
+
+  isOpenBinding(binding) {
+    return this.isCurrentBinding(binding) && binding.exited !== true;
+  }
+
+  requireOpenBinding(binding) {
+    if (this.disposing || this.disposed) throw new Error('ACP runtime is shutting down');
+    this.requireCurrentBinding(binding);
+    if (binding.exited) throw new Error('ACP Agent connection is closed');
+    return binding;
+  }
+
+  isCurrentTurn(binding, turn) {
+    return this.isOpenBinding(binding) && binding.activeTurn === turn;
+  }
+
+  requireCurrentTurn(binding, turn, phases = null) {
+    this.requireOpenBinding(binding);
+    if (
+      binding.activeTurn !== turn
+      || (Array.isArray(phases) && !phases.includes(turn?.phase))
+    ) {
+      throw new Error('No active Codex turn to steer');
+    }
+    return turn;
+  }
+
+  beginTurn(binding) {
+    this.requireOpenBinding(binding);
+    if (binding.activeTurn) throw new Error(`ACP Agent is not ready (${binding.state})`);
+    let resolveCompletion;
+    const completion = new Promise(resolve => {
+      resolveCompletion = resolve;
+    });
+    const turn = {
+      id: binding.nextTurnId++,
+      phase: 'admitting',
+      previousState: binding.state,
+      providerSettled: false,
+      controlTail: Promise.resolve(),
+      cancelPromise: null,
+      completion,
+      resolveCompletion,
+    };
+    binding.activeTurn = turn;
+    return turn;
+  }
+
+  finishTurn(binding, turn, result) {
+    if (binding.activeTurn !== turn) return false;
+    binding.activeTurn = null;
+    turn.phase = 'completed';
+    turn.resolveCompletion(result);
+    return true;
+  }
+
+  cancelAdmittingTurn(binding, turn) {
+    if (binding.activeTurn !== turn || turn.phase !== 'admitting') return false;
+    binding.activeTurn = null;
+    turn.phase = 'cancelled';
+    binding.state = turn.previousState || 'idle';
+    turn.resolveCompletion({ status: 'cancelled-before-submission' });
+    this.emitRuntime(binding);
+    return true;
+  }
+
+  async enqueueTurnControl(turn, operation) {
+    const previous = turn.controlTail || Promise.resolve();
+    const pending = previous.catch(() => {}).then(operation);
+    turn.controlTail = pending;
+    try {
+      return await pending;
+    } finally {
+      if (turn.controlTail === pending) turn.controlTail = Promise.resolve();
+    }
+  }
+
+  ensureSubagentControl(binding, sessionId) {
+    const id = String(sessionId || '');
+    if (!id) return null;
+    let control = binding.subagentControls.get(id);
+    if (!control) {
+      control = {
+        sessionId: id,
+        generation: binding.nextSubagentGeneration++,
+        phase: 'active',
+        error: '',
+        cancelPromise: null,
+      };
+      binding.subagentControls.set(id, control);
+    }
+    return control;
+  }
+
+  resetSubagentControls(binding) {
+    binding.subagentControls.clear();
+    for (const sessionId of binding.subagentStates.keys()) {
+      const control = this.ensureSubagentControl(binding, sessionId);
+      const parentTool = binding.sessionState?.entries.find(entry => (
+        entry?.type === 'tool'
+        && String(entry?._meta?.subagent_session_info?.session_id || '') === sessionId
+      ));
+      if (parentTool) {
+        this.updateSubagentControlFromParent(binding, parentTool);
+      } else {
+        // Restored evidence without a parent Tool cannot prove that a child
+        // from the previous adapter process is still active.
+        control.phase = 'completed';
+      }
+    }
+  }
+
+  activeSubagentSessionIds(binding) {
+    return [...binding.subagentStates.keys()].filter(sessionId => {
+      const control = this.ensureSubagentControl(binding, sessionId);
+      if (control?.cancelPromise || ['active', 'cancelling'].includes(control?.phase)) return true;
+      const hasInteraction = [...binding.pendingPermissions.values(), ...binding.pendingElicitations.values()]
+        .some(request => String(request?.sessionId || '') === sessionId);
+      if (hasInteraction) return true;
+      const parentTool = binding.sessionState?.entries.find(entry => (
+        entry?.type === 'tool'
+        && String(entry?._meta?.subagent_session_info?.session_id || '') === sessionId
+      ));
+      return ['pending', 'in_progress', 'in-progress', 'running']
+        .includes(String(parentTool?.status || '').toLowerCase());
+    });
+  }
+
+  updateSubagentControlFromParent(binding, update) {
+    const sessionId = String(update?._meta?.subagent_session_info?.session_id || '');
+    if (!sessionId || !binding.subagentStates.has(sessionId)) return;
+    const control = this.ensureSubagentControl(binding, sessionId);
+    const status = String(update?.status || '').toLowerCase();
+    if (['cancelled', 'canceled'].includes(status)) {
+      control.phase = 'cancelled';
+      control.error = '';
+    } else if (['completed', 'complete'].includes(status)) {
+      control.phase = 'completed';
+      control.error = '';
+    } else if (['failed', 'error'].includes(status)) {
+      control.phase = 'error';
+      control.error = String(update?.title || 'Subagent failed');
+    } else if (
+      ['pending', 'in_progress', 'in-progress', 'running'].includes(status)
+      && !['cancelling', 'cancelled', 'completed', 'error'].includes(control.phase)
+    ) {
+      control.phase = 'active';
+      control.error = '';
+    }
+  }
+
+  beginSessionMutation(binding, action) {
+    this.requireOpenBinding(binding);
+    if (
+      binding.sessionMutation
+      || binding.configMutationTail
+      || binding.patchDecisionInFlight.size > 0
+      || binding.activeTurn
+      || !['idle', 'error'].includes(binding.state)
+    ) {
+      throw new Error(`ACP Agent is not ready for ${action} (${binding.state})`);
+    }
+    const mutation = { action };
+    binding.sessionMutation = mutation;
+    return mutation;
+  }
+
+  endSessionMutation(binding, mutation) {
+    if (binding.sessionMutation === mutation) binding.sessionMutation = null;
+  }
+
+  requireConfigMutationReady(binding) {
+    this.requireOpenBinding(binding);
+    if (
+      binding.sessionMutation
+      || binding.patchDecisionInFlight.size > 0
+      || binding.activeTurn
+      || !['idle', 'error'].includes(binding.state)
+    ) {
+      throw new Error(`ACP Agent is not ready for configuration changes (${binding.state})`);
+    }
+  }
+
   checkpointIdentity(binding, sessionId = binding?.sessionId) {
     if (!binding || !sessionId) return null;
     return {
@@ -749,6 +1247,7 @@ class AcpRuntime extends EventEmitter {
   }
 
   scheduleCheckpoint(binding, _options = {}) {
+    if (!this.isOpenBinding(binding)) return;
     const identity = this.checkpointIdentity(binding);
     if (!this.checkpointStore || !identity || !binding.sessionState) return;
     // ACP currently has no conditional resume or provider-owned revision
@@ -759,15 +1258,19 @@ class AcpRuntime extends EventEmitter {
   }
 
   async markCheckpointDirty(binding) {
+    this.requireOpenBinding(binding);
     const identity = this.checkpointIdentity(binding);
     if (!this.checkpointStore || !identity) return;
     await this.checkpointStore.markDirty(identity);
+    this.requireOpenBinding(binding);
   }
 
   async writeCheckpoint(binding, _options = {}) {
+    this.requireOpenBinding(binding);
     const identity = this.checkpointIdentity(binding);
     if (!this.checkpointStore || !identity || !binding.sessionState) return;
     await this.checkpointStore.write(identity, this.bindingCheckpoint(binding), { exact: false });
+    this.requireOpenBinding(binding);
   }
 
   bindingCheckpoint(binding) {
@@ -830,6 +1333,29 @@ class AcpRuntime extends EventEmitter {
     };
   }
 
+  restorePatchDecisions(binding, decisions) {
+    if (!(decisions instanceof Map) || !binding.sessionState) return;
+    for (const [key, decision] of decisions) {
+      const separator = key.indexOf('\n');
+      if (separator <= 0) continue;
+      const toolCallId = key.slice(0, separator);
+      const requestedPath = key.slice(separator + 1);
+      const entry = binding.sessionState.toolEntries.get(toolCallId);
+      if (!entry || binding.sessionState.isInternalEntry(entry)) continue;
+      try {
+        patchBlock(entry, binding.cwd, requestedPath);
+      } catch {
+        continue;
+      }
+      binding.patchDecisions.set(key, decision);
+      entry._meta = { ...(entry._meta || {}) };
+      entry._meta.farming_patch_decisions = {
+        ...(entry._meta.farming_patch_decisions || {}),
+        [requestedPath]: decision,
+      };
+    }
+  }
+
   async checkpointMatchesProviderSession(connection, capabilities, request, saved) {
     const proof = saved?.state?.providerProof;
     if (
@@ -874,6 +1400,7 @@ class AcpRuntime extends EventEmitter {
     let lastChangedAt = startedAt;
     while (Date.now() - startedAt < this.historyReplayMaxWaitMs) {
       await new Promise(resolve => setTimeout(resolve, 50));
+      if (!this.isOpenBinding(binding)) return;
       const now = Date.now();
       const updateCount = binding.sessionState?.updates.length || 0;
       if (updateCount !== lastUpdateCount) {
@@ -888,8 +1415,17 @@ class AcpRuntime extends EventEmitter {
   }
 
   clientHandlers(binding) {
+    const openClientRequest = handler => async request => {
+      this.requireOpenBinding(binding);
+      if (binding.state === 'closed') throw new Error('ACP session is closed');
+      const response = await handler(request);
+      this.requireOpenBinding(binding);
+      if (binding.state === 'closed') throw new Error('ACP session is closed');
+      return response;
+    };
     return {
       sessionUpdate: notification => {
+        if (!this.isOpenBinding(binding) || binding.state === 'closed') return;
         const notificationSessionId = String(notification?.sessionId || '');
         const isPrimarySession = !binding.sessionId || !notificationSessionId || notificationSessionId === binding.sessionId;
         let targetState = isPrimarySession ? binding.sessionState : binding.subagentStates.get(notificationSessionId);
@@ -902,8 +1438,17 @@ class AcpRuntime extends EventEmitter {
           });
           binding.subagentStates.set(notificationSessionId, targetState);
         }
+        if (!isPrimarySession && targetState) {
+          this.ensureSubagentControl(binding, notificationSessionId);
+          const parentTool = binding.sessionState?.entries.find(entry => (
+            entry?.type === 'tool'
+            && String(entry?._meta?.subagent_session_info?.session_id || '') === notificationSessionId
+          ));
+          if (parentTool) this.updateSubagentControlFromParent(binding, parentTool);
+        }
         if (targetState?.apply(notification)) {
           const update = notification?.update;
+          if (isPrimarySession) this.updateSubagentControlFromParent(binding, update);
           if (isPrimarySession && update?.sessionUpdate === 'current_mode_update' && binding.modes) {
             binding.modes = { ...binding.modes, currentModeId: String(update.currentModeId || '') };
           }
@@ -918,7 +1463,7 @@ class AcpRuntime extends EventEmitter {
             if (parentTool) binding.sessionState.touchEntry(parentTool);
           }
           binding.updatedAt = new Date().toISOString();
-          if (isPrimarySession && !binding.historyReplayActive && !binding.promptActive) {
+          if (isPrimarySession && !binding.historyReplayActive && !binding.activeTurn) {
             this.scheduleCheckpoint(binding, { exact: true });
           }
           // A loaded history can contain hundreds of ordered updates. Applying
@@ -929,22 +1474,35 @@ class AcpRuntime extends EventEmitter {
         }
       },
       requestPermission: request => this.requestPermission(binding, request),
-      readTextFile: request => this.clientFileSystem.readTextFile(binding, request),
-      writeTextFile: request => this.clientFileSystem.writeTextFile(binding, request),
-      createTerminal: request => this.clientTerminals.create(binding, request),
-      terminalOutput: request => this.clientTerminals.output(binding, request),
-      waitForTerminalExit: request => this.clientTerminals.waitForExit(binding, request),
-      killTerminal: request => this.clientTerminals.kill(binding, request),
-      releaseTerminal: request => this.clientTerminals.release(binding, request),
+      readTextFile: openClientRequest(request => this.clientFileSystem.readTextFile(binding, request)),
+      writeTextFile: openClientRequest(request => this.clientFileSystem.writeTextFile(binding, request)),
+      createTerminal: openClientRequest(request => this.clientTerminals.create(binding, request)),
+      terminalOutput: openClientRequest(request => this.clientTerminals.output(binding, request)),
+      waitForTerminalExit: openClientRequest(request => this.clientTerminals.waitForExit(binding, request)),
+      killTerminal: openClientRequest(request => this.clientTerminals.kill(binding, request)),
+      releaseTerminal: openClientRequest(request => this.clientTerminals.release(binding, request)),
       unstable_createElicitation: request => this.requestElicitation(binding, request),
       unstable_completeElicitation: notification => this.completeElicitation(binding, notification),
     };
   }
 
   requestPermission(binding, request) {
+    if (!this.isOpenBinding(binding) || binding.state === 'closed') {
+      return { outcome: { outcome: 'cancelled' } };
+    }
+    const requestSessionId = String(request?.sessionId || '');
+    if (
+      !requestSessionId
+      || (
+        requestSessionId !== binding.sessionId
+        && !binding.subagentStates.has(requestSessionId)
+      )
+    ) {
+      return { outcome: { outcome: 'cancelled' } };
+    }
     const automatic = autoPermissionResponse(request, binding.approvalMode);
     if (automatic) return automatic;
-    const requestId = `acp-permission-${++this.permissionSequence}`;
+    const requestId = `acp-permission-${crypto.randomUUID()}`;
     binding.interactionOrigins.set(requestId, binding.state);
     binding.state = 'waiting-for-permission';
     const pending = { ...JSON.parse(JSON.stringify(request)), requestId };
@@ -979,6 +1537,7 @@ class AcpRuntime extends EventEmitter {
   }
 
   requestElicitation(binding, request) {
+    if (!this.isOpenBinding(binding) || binding.state === 'closed') return { action: 'cancel' };
     const hasSessionScope = typeof request?.sessionId === 'string' && request.sessionId.length > 0;
     const requestSessionId = hasSessionScope ? String(request.sessionId) : '';
     const isPrimarySession = hasSessionScope && requestSessionId === binding.sessionId;
@@ -989,7 +1548,7 @@ class AcpRuntime extends EventEmitter {
     if (!['form', 'url'].includes(String(request?.mode || ''))) {
       return { action: 'cancel' };
     }
-    const requestId = `acp-elicitation-${++this.elicitationSequence}`;
+    const requestId = `acp-elicitation-${crypto.randomUUID()}`;
     const cloned = JSON.parse(JSON.stringify(request));
     const protocolRequestId = Object.prototype.hasOwnProperty.call(cloned, 'requestId')
       ? cloned.requestId
@@ -1033,61 +1592,141 @@ class AcpRuntime extends EventEmitter {
   }
 
   completeElicitation(binding, notification) {
+    if (!this.isOpenBinding(binding) || binding.state === 'closed') return;
     const elicitationId = String(notification?.elicitationId || '');
     if (elicitationId) binding.activeElicitations.delete(elicitationId);
     this.emitRuntime(binding);
   }
 
-  async prompt(agentId, prompt) {
+  async submitMessage(agentId, prompt, options = {}) {
     const binding = this.requireBinding(agentId);
-    if (!['idle', 'error'].includes(binding.state)) throw new Error(`ACP Agent is not ready (${binding.state})`);
+    while (true) {
+      this.requireOpenBinding(binding);
+      const turn = binding.activeTurn;
+      if (turn?.phase === 'blocked') {
+        throw new Error(`ACP Agent is not ready (${binding.state})`);
+      }
+      if (
+        turn?.phase === 'running'
+        && turn.providerSettled !== true
+        && binding.provider === 'codex'
+        && binding.supportsSteer === true
+      ) {
+        try {
+          const result = await this.steer(agentId, prompt);
+          options.onSubmitted?.();
+          return { steered: true, ...result };
+        } catch (error) {
+          if (!isCodexSteerUnavailableError(error)) throw error;
+          this.requireOpenBinding(binding);
+        }
+      }
+      if (binding.activeTurn === turn && turn) {
+        await turn.completion;
+        continue;
+      }
+      if (binding.activeTurn) continue;
+      return this.prompt(agentId, prompt, options);
+    }
+  }
+
+  async prompt(agentId, prompt, options = {}) {
+    const binding = this.requireBinding(agentId);
+    if (
+      binding.exited
+      || binding.sessionMutation
+      || binding.activeTurn
+      || !['idle', 'error'].includes(binding.state)
+    ) {
+      throw new Error(`ACP Agent is not ready (${binding.state})`);
+    }
     const rawContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
     const content = promptContentForCapabilities(
       rawContent,
       binding.initializeResponse?.agentCapabilities || {},
     );
-    await this.markCheckpointDirty(binding);
+    const turn = this.beginTurn(binding);
+    try {
+      const configMutation = binding.configMutationTail;
+      const patchDecisions = [...binding.patchDecisionInFlight.values()].map(item => item.promise);
+      await Promise.allSettled([
+        ...(configMutation ? [configMutation] : []),
+        ...patchDecisions,
+      ]);
+      if (!this.isCurrentTurn(binding, turn) || turn.phase !== 'admitting') {
+        throw new Error('ACP prompt was cancelled before submission');
+      }
+      await this.markCheckpointDirty(binding);
+      if (!this.isCurrentTurn(binding, turn) || turn.phase !== 'admitting') {
+        throw new Error('ACP prompt was cancelled before submission');
+      }
+    } catch (error) {
+      if (this.isCurrentTurn(binding, turn)) {
+        binding.state = turn.previousState;
+        this.finishTurn(binding, turn, { status: 'admission-failed' });
+      }
+      throw error;
+    }
     binding.sessionState.beginPrompt(content);
-    binding.promptActive = true;
+    turn.phase = 'running';
     binding.state = 'working';
     binding.error = '';
     binding.stopReason = '';
     this.emitRuntime(binding);
     this.emitSession(binding);
+    let response;
     try {
-      const response = await binding.connection.prompt({ sessionId: binding.sessionId, prompt: content });
+      const responsePromise = binding.connection.prompt({ sessionId: binding.sessionId, prompt: content });
+      try {
+        options.onSubmitted?.();
+      } catch {
+        // Submission is already owned by the provider; admission callbacks cannot roll it back.
+      }
+      response = await responsePromise;
+      turn.providerSettled = true;
+    } catch (error) {
+      turn.providerSettled = true;
+      const runtimeError = new Error(acpErrorMessage(error), { cause: error });
+      if (!this.isCurrentTurn(binding, turn)) throw runtimeError;
+      await this.enqueueTurnControl(turn, async () => {
+        if (!this.isCurrentTurn(binding, turn)) return;
+        binding.stopReason = 'error';
+        // JSON-RPC implementations commonly move the actionable provider text
+        // into error.data.details. Classify the normalized message so the
+        // ordered transcript and runtime snapshot cannot disagree.
+        binding.sessionState.recordError(runtimeError.message, acpErrorKind(runtimeError));
+        binding.sessionState.completePrompt('error');
+        binding.state = 'error';
+        binding.error = runtimeError.message;
+        binding.updatedAt = new Date().toISOString();
+        this.finishTurn(binding, turn, { status: 'error', error: runtimeError });
+        this.scheduleCheckpoint(binding, { exact: true });
+        this.emitSession(binding);
+        this.emitRuntime(binding);
+      });
+      throw runtimeError;
+    }
+    return this.enqueueTurnControl(turn, async () => {
+      this.requireCurrentTurn(binding, turn);
       binding.stopReason = String(response?.stopReason || '');
       binding.sessionState.completePrompt(binding.stopReason);
-      binding.promptActive = false;
       binding.state = 'idle';
+      binding.error = '';
       binding.updatedAt = new Date().toISOString();
+      this.finishTurn(binding, turn, { status: 'completed', stopReason: binding.stopReason });
       this.scheduleCheckpoint(binding, { exact: true });
       this.emitSession(binding);
       this.emitRuntime(binding);
       return { sessionId: binding.sessionId, stopReason: binding.stopReason };
-    } catch (error) {
-      const runtimeError = new Error(acpErrorMessage(error), { cause: error });
-      binding.stopReason = 'error';
-      // JSON-RPC implementations commonly move the actionable provider text
-      // into error.data.details. Classify the normalized message so the
-      // ordered transcript and runtime snapshot cannot disagree.
-      binding.sessionState.recordError(runtimeError.message, acpErrorKind(runtimeError));
-      binding.sessionState.completePrompt('error');
-      binding.promptActive = false;
-      binding.state = 'error';
-      binding.error = runtimeError.message;
-      this.scheduleCheckpoint(binding, { exact: true });
-      this.emitSession(binding);
-      this.emitRuntime(binding);
-      throw runtimeError;
-    }
+    });
   }
 
   canSteer(agentId) {
     const binding = this.bindings.get(agentId);
     return binding?.provider === 'codex'
       && binding.supportsSteer === true
-      && binding.promptActive === true
+      && binding.activeTurn?.phase === 'running'
+      && binding.activeTurn?.providerSettled !== true
       && Boolean(binding.sessionId)
       && Boolean(binding.connection);
   }
@@ -1102,10 +1741,15 @@ class AcpRuntime extends EventEmitter {
       rawContent,
       binding.initializeResponse?.agentCapabilities || {},
     );
+    const turn = binding.activeTurn;
+    this.requireCurrentTurn(binding, turn, ['running']);
     const clientMessageId = `farming-steer-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
     const operation = async () => {
-      if (!binding.promptActive) throw new Error('No active Codex turn to steer');
+      this.requireCurrentTurn(binding, turn, ['running']);
+      if (turn.providerSettled) throw new Error('No active Codex turn to steer');
       await this.markCheckpointDirty(binding);
+      this.requireCurrentTurn(binding, turn, ['running']);
+      if (turn.providerSettled) throw new Error('No active Codex turn to steer');
       const response = await withTimeout(
         binding.connection.request(CODEX_STEER_METHOD, {
           sessionId: binding.sessionId,
@@ -1115,62 +1759,118 @@ class AcpRuntime extends EventEmitter {
         this.requestTimeoutMs,
         'Codex ACP steer',
       );
+      this.requireCurrentTurn(binding, turn, ['running']);
       return {
         sessionId: binding.sessionId,
         turnId: String(response?.turnId || ''),
         clientMessageId,
       };
     };
-    const previous = binding.steerTail || Promise.resolve();
-    const pending = previous.catch(() => {}).then(operation);
-    binding.steerTail = pending;
-    try {
-      return await pending;
-    } finally {
-      if (binding.steerTail === pending) binding.steerTail = null;
-    }
+    return this.enqueueTurnControl(turn, operation);
   }
 
   async cancel(agentId) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
+    if (binding.state === 'closed') throw new Error('ACP session is closed');
     if (!binding.sessionId) return false;
-    binding.state = 'interrupting';
-    for (const resolve of binding.permissionResolvers.values()) {
-      resolve({ outcome: { outcome: 'cancelled' } });
-    }
-    for (const resolve of binding.elicitationResolvers.values()) resolve({ action: 'cancel' });
-    binding.permissionResolvers.clear();
-    binding.pendingPermissions.clear();
-    binding.elicitationResolvers.clear();
-    binding.pendingElicitations.clear();
-    binding.activeElicitations.clear();
-    binding.interactionOrigins.clear();
-    this.emitRuntime(binding);
-    try {
-      await withTimeout(
-        binding.connection.cancel({ sessionId: binding.sessionId }),
-        this.cancelTimeoutMs,
-        'ACP session/cancel'
-      );
+    const turn = binding.activeTurn;
+    if (turn?.phase === 'admitting') {
+      this.cancelAdmittingTurn(binding, turn);
       return true;
-    } catch (error) {
-      const runtimeError = new Error(acpErrorMessage(error), { cause: error });
-      binding.state = 'error';
-      binding.error = runtimeError.message;
-      binding.stopReason = 'cancel_error';
-      binding.updatedAt = new Date().toISOString();
-      this.emitSession(binding);
+    }
+    if (!turn && (
+      binding.sessionMutation
+      || binding.configMutationTail
+      || binding.patchDecisionInFlight.size > 0
+    )) {
+      throw new Error(`ACP Agent is not ready for cancellation (${binding.state})`);
+    }
+    if (turn?.cancelPromise) return turn.cancelPromise;
+
+    const stateBeforeCancellation = binding.state;
+    let cancelAcknowledged = false;
+    const cancelOperation = async () => {
+      const activeSubagentSessionIds = this.activeSubagentSessionIds(binding);
+      if (turn) {
+        this.requireCurrentTurn(binding, turn, ['running']);
+        if (turn.providerSettled) throw new Error('No active turn to cancel');
+        turn.phase = 'cancelling';
+      }
+      binding.state = 'interrupting';
+      for (const resolve of binding.permissionResolvers.values()) {
+        resolve({ outcome: { outcome: 'cancelled' } });
+      }
+      for (const resolve of binding.elicitationResolvers.values()) resolve({ action: 'cancel' });
+      binding.permissionResolvers.clear();
+      binding.pendingPermissions.clear();
+      binding.elicitationResolvers.clear();
+      binding.pendingElicitations.clear();
+      binding.activeElicitations.clear();
+      binding.interactionOrigins.clear();
       this.emitRuntime(binding);
-      throw runtimeError;
+      await Promise.all([
+        withTimeout(
+          binding.connection.cancel({ sessionId: binding.sessionId }),
+          this.cancelTimeoutMs,
+          'ACP session/cancel'
+        ),
+        ...activeSubagentSessionIds.map(sessionId => this.cancelSubagentControl(binding, sessionId)),
+      ]);
+      this.requireOpenBinding(binding);
+      cancelAcknowledged = true;
+      return true;
+    };
+    const cancellation = (async () => {
+      try {
+        if (turn) await this.enqueueTurnControl(turn, cancelOperation);
+        else await cancelOperation();
+        if (!turn) {
+          if (binding.state === 'interrupting') {
+            binding.state = ['idle', 'error'].includes(stateBeforeCancellation)
+              ? stateBeforeCancellation
+              : 'idle';
+          }
+          binding.updatedAt = new Date().toISOString();
+          this.emitRuntime(binding);
+          return true;
+        }
+        await withTimeout(turn.completion, this.cancelTimeoutMs, 'ACP turn cancellation');
+        return true;
+      } catch (error) {
+        const runtimeError = new Error(acpErrorMessage(error), { cause: error });
+        if (!this.isOpenBinding(binding)) throw runtimeError;
+        const markBlocked = () => {
+          if (turn && binding.activeTurn !== turn) return;
+          if (turn) turn.phase = 'blocked';
+          binding.state = 'error';
+          binding.error = runtimeError.message;
+          binding.stopReason = turn && cancelAcknowledged ? 'cancel_timeout' : 'cancel_error';
+          binding.updatedAt = new Date().toISOString();
+          this.emitSession(binding);
+          this.emitRuntime(binding);
+        };
+        if (turn) await this.enqueueTurnControl(turn, markBlocked);
+        else markBlocked();
+        throw runtimeError;
+      }
+    })();
+    if (turn) turn.cancelPromise = cancellation;
+    try {
+      return await cancellation;
+    } finally {
+      if (turn?.cancelPromise === cancellation) turn.cancelPromise = null;
     }
   }
 
-  async cancelSubagent(agentId, sessionId) {
-    const binding = this.requireBinding(agentId);
-    const targetSessionId = String(sessionId || '');
-    if (!targetSessionId || targetSessionId === binding.sessionId || !binding.subagentStates.has(targetSessionId)) {
-      throw new Error('ACP subagent session not found');
+  cancelSubagentControl(binding, targetSessionId) {
+    const control = this.ensureSubagentControl(binding, targetSessionId);
+    if (control.cancelPromise) return control.cancelPromise;
+    if (['cancelled', 'completed'].includes(control.phase)) {
+      return Promise.resolve({ cancelled: true, sessionId: targetSessionId });
     }
+    control.phase = 'cancelling';
+    control.error = '';
     for (const [requestId, pending] of binding.pendingPermissions.entries()) {
       if (String(pending?.sessionId || '') !== targetSessionId) continue;
       binding.permissionResolvers.get(requestId)?.({ outcome: { outcome: 'cancelled' } });
@@ -1190,28 +1890,67 @@ class AcpRuntime extends EventEmitter {
     }
     binding.state = interactiveRuntimeState(binding, binding.state);
     this.emitRuntime(binding);
-    await withTimeout(
-      binding.connection.cancel({ sessionId: targetSessionId }),
-      this.cancelTimeoutMs,
-      'ACP subagent session/cancel'
-    );
-    binding.updatedAt = new Date().toISOString();
-    this.emitSession(binding);
-    this.emitRuntime(binding);
-    return { cancelled: true, sessionId: targetSessionId };
+    const cancellation = (async () => {
+      try {
+        await withTimeout(
+          binding.connection.cancel({ sessionId: targetSessionId }),
+          this.cancelTimeoutMs,
+          'ACP subagent session/cancel'
+        );
+        this.requireOpenBinding(binding);
+        if (binding.subagentControls.get(targetSessionId) !== control) {
+          throw new Error('ACP subagent control is no longer active');
+        }
+        control.phase = 'cancelled';
+        control.error = '';
+        binding.updatedAt = new Date().toISOString();
+        this.emitSession(binding);
+        this.emitRuntime(binding);
+        return { cancelled: true, sessionId: targetSessionId };
+      } catch (error) {
+        if (this.isOpenBinding(binding) && binding.subagentControls.get(targetSessionId) === control) {
+          control.phase = 'error';
+          control.error = acpErrorMessage(error);
+          binding.updatedAt = new Date().toISOString();
+          this.emitSession(binding);
+          this.emitRuntime(binding);
+        }
+        throw error;
+      }
+    })();
+    control.cancelPromise = cancellation;
+    void cancellation.finally(() => {
+      if (binding.subagentControls.get(targetSessionId) === control && control.cancelPromise === cancellation) {
+        control.cancelPromise = null;
+      }
+    }).catch(() => {});
+    return cancellation;
+  }
+
+  async cancelSubagent(agentId, sessionId) {
+    const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
+    const targetSessionId = String(sessionId || '');
+    if (!targetSessionId || targetSessionId === binding.sessionId || !binding.subagentStates.has(targetSessionId)) {
+      throw new Error('ACP subagent session not found');
+    }
+    return this.cancelSubagentControl(binding, targetSessionId);
   }
 
   async listSessions(agentId, options = {}) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
     const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
     if (!capabilities?.list) throw new Error(`${binding.provider} ACP Agent does not support session/list`);
-    return withTimeout(binding.connection.listSessions({
+    const response = await withTimeout(binding.connection.listSessions({
       ...(options.cwd ? { cwd: path.resolve(options.cwd) } : {}),
       ...(Array.isArray(options.additionalDirectories)
         ? { additionalDirectories: acpSessionRequestOptions(options, options.cwd || binding.cwd).additionalDirectories }
         : {}),
       ...(options.cursor ? { cursor: String(options.cursor) } : {}),
     }), this.requestTimeoutMs, 'ACP session/list');
+    this.requireOpenBinding(binding);
+    return response;
   }
 
   getSessionRequestOptions(agentId) {
@@ -1221,37 +1960,55 @@ class AcpRuntime extends EventEmitter {
 
   async authenticate(agentId, methodId) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
+    if (binding.state === 'closed') throw new Error('ACP session is closed');
+    const mutation = this.beginSessionMutation(binding, 'authentication');
     const method = binding.initializeResponse?.authMethods?.find(item => item.id === methodId);
-    if (!method) throw new Error('Unknown ACP authentication method');
-    if (method.type === 'terminal' || method?._meta?.['terminal-auth']) {
-      return this.startTerminalAuthentication(binding, method);
+    let terminalReservationTransferred = false;
+    try {
+      if (!method) throw new Error('Unknown ACP authentication method');
+      if (method.type === 'terminal' || method?._meta?.['terminal-auth']) {
+        const result = await this.startTerminalAuthentication(binding, method, mutation);
+        terminalReservationTransferred = true;
+        return result;
+      }
+      await withTimeout(
+        binding.connection.authenticate({ methodId }),
+        this.requestTimeoutMs,
+        'ACP authenticate'
+      );
+      this.requireOpenBinding(binding);
+      binding.error = '';
+      binding.stopReason = '';
+      binding.state = interactiveRuntimeState(binding, 'idle');
+      binding.updatedAt = new Date().toISOString();
+      this.emitRuntime(binding);
+      this.emitSession(binding);
+      return { authenticated: true, methodId };
+    } finally {
+      if (!terminalReservationTransferred) this.endSessionMutation(binding, mutation);
     }
-    await withTimeout(
-      binding.connection.authenticate({ methodId }),
-      this.requestTimeoutMs,
-      'ACP authenticate'
-    );
-    binding.error = '';
-    binding.stopReason = '';
-    binding.state = interactiveRuntimeState(binding, 'idle');
-    binding.updatedAt = new Date().toISOString();
-    this.emitRuntime(binding);
-    this.emitSession(binding);
-    return { authenticated: true, methodId };
   }
 
   async logout(agentId) {
     const binding = this.requireBinding(agentId);
-    if (binding.initializeResponse?.agentCapabilities?.auth?.logout == null) {
-      throw new Error(`${binding.provider} ACP Agent does not support logout`);
+    this.requireOpenBinding(binding);
+    const mutation = this.beginSessionMutation(binding, 'logout');
+    try {
+      if (binding.initializeResponse?.agentCapabilities?.auth?.logout == null) {
+        throw new Error(`${binding.provider} ACP Agent does not support logout`);
+      }
+      await withTimeout(binding.connection.logout({}), this.requestTimeoutMs, 'ACP logout');
+      this.requireOpenBinding(binding);
+      binding.error = '';
+      binding.stopReason = '';
+      binding.updatedAt = new Date().toISOString();
+      this.emitRuntime(binding);
+      this.emitSession(binding);
+      return { loggedOut: true };
+    } finally {
+      this.endSessionMutation(binding, mutation);
     }
-    await withTimeout(binding.connection.logout({}), this.requestTimeoutMs, 'ACP logout');
-    binding.error = '';
-    binding.stopReason = '';
-    binding.updatedAt = new Date().toISOString();
-    this.emitRuntime(binding);
-    this.emitSession(binding);
-    return { loggedOut: true };
   }
 
   terminalAuthenticationLaunch(binding, method) {
@@ -1271,7 +2028,9 @@ class AcpRuntime extends EventEmitter {
     };
   }
 
-  async startTerminalAuthentication(binding, method) {
+  async startTerminalAuthentication(binding, method, mutation) {
+    this.requireOpenBinding(binding);
+    if (binding.sessionMutation !== mutation) throw new Error('ACP authentication reservation is no longer active');
     if (binding.authTerminal?.state === 'running') throw new Error('ACP terminal authentication is already running');
     const launch = this.terminalAuthenticationLaunch(binding, method);
     const created = await this.clientTerminals.create(binding, {
@@ -1282,6 +2041,19 @@ class AcpRuntime extends EventEmitter {
       env: Object.entries(launch.env).map(([name, value]) => ({ name, value: String(value) })),
       outputByteLimit: 2 * 1024 * 1024,
     });
+    try {
+      this.requireOpenBinding(binding);
+    } catch (error) {
+      try {
+        this.clientTerminals.release(binding, {
+          sessionId: binding.sessionId,
+          terminalId: created.terminalId,
+        });
+      } catch {
+        // Binding teardown may already have removed the terminal.
+      }
+      throw error;
+    }
     binding.authTerminal = {
       terminalId: created.terminalId,
       methodId: String(method.id || ''),
@@ -1296,10 +2068,11 @@ class AcpRuntime extends EventEmitter {
       sessionId: binding.sessionId,
       terminalId: created.terminalId,
     })).then(async exit => {
-      if (this.bindings.get(binding.agentId) !== binding) return;
+      if (!this.isOpenBinding(binding) || binding.sessionMutation !== mutation) return;
       if (exit.exitCode !== 0) {
         binding.authTerminal.state = 'failed';
         binding.authTerminal.error = `Sign-in command exited ${exit.exitCode ?? exit.signal ?? ''}`.trim();
+        this.endSessionMutation(binding, mutation);
         binding.updatedAt = new Date().toISOString();
         this.emitRuntime(binding);
         this.emitSession(binding);
@@ -1308,18 +2081,20 @@ class AcpRuntime extends EventEmitter {
       binding.authTerminal.state = 'completed';
       binding.updatedAt = new Date().toISOString();
       this.emitSession(binding);
-      await this.restartAgentConnection(binding.agentId).catch(error => {
+      await this.restartAgentConnection(binding.agentId, mutation).catch(error => {
         const current = this.bindings.get(binding.agentId);
-        if (!current) return;
+        if (current !== binding || current.exited) return;
+        this.endSessionMutation(current, mutation);
         current.state = 'error';
         current.error = acpErrorMessage(error);
         current.updatedAt = new Date().toISOString();
         this.emitRuntime(current);
       });
     }).catch(error => {
-      if (this.bindings.get(binding.agentId) !== binding) return;
+      if (!this.isOpenBinding(binding) || binding.sessionMutation !== mutation) return;
       binding.authTerminal.state = 'failed';
       binding.authTerminal.error = acpErrorMessage(error);
+      this.endSessionMutation(binding, mutation);
       binding.updatedAt = new Date().toISOString();
       this.emitRuntime(binding);
       this.emitSession(binding);
@@ -1327,8 +2102,15 @@ class AcpRuntime extends EventEmitter {
     return { authenticated: false, methodId: method.id, terminalId: created.terminalId };
   }
 
-  async restartAgentConnection(agentId) {
+  async restartAgentConnection(agentId, mutation = null) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
+    if (binding.activeTurn || (binding.sessionMutation && binding.sessionMutation !== mutation)) {
+      throw new Error(`ACP Agent is not ready for restart (${binding.state})`);
+    }
+    if (mutation && binding.sessionMutation !== mutation) {
+      throw new Error('ACP restart reservation is no longer active');
+    }
     const revisionBase = Number(binding.sessionState?.revision || 0);
     const options = {
       ...binding.restartOptions,
@@ -1341,60 +2123,109 @@ class AcpRuntime extends EventEmitter {
       ...(revisionBase > 0 ? { revisionBase } : {}),
       ...(binding.sessionId ? { historyMode: 'checkpoint' } : {}),
     };
-    if (binding.sessionState && !binding.promptActive) {
+    if (binding.sessionState && !binding.activeTurn) {
       await this.writeCheckpoint(binding, { exact: true });
     }
-    this.unregisterAgent(agentId);
+    this.requireOpenBinding(binding);
+    await this.unregisterAgentAndWait(agentId, binding);
     return this.prepareAgent(options);
   }
 
   async forkSession(agentId, options = {}) {
+    return this.runWithForkReservation(agentId, options, async binding => {
+      const sessionOptions = acpSessionRequestOptions({
+        additionalDirectories: options.additionalDirectories ?? binding.sessionRequestOptions.additionalDirectories,
+        mcpServers: options.mcpServers ?? binding.sessionRequestOptions.mcpServers,
+      }, options.cwd || binding.cwd);
+      const response = await withTimeout(binding.connection.unstable_forkSession({
+        sessionId: options.sessionId || binding.sessionId,
+        ...sessionOptions,
+      }), this.sessionSetupTimeoutMs, 'ACP session/fork');
+      this.requireOpenBinding(binding);
+      const sessionId = String(response?.sessionId || '').trim();
+      if (!isSafeProviderSessionId(sessionId) || sessionId === binding.sessionId) {
+        throw new Error('ACP session/fork returned an invalid new session id');
+      }
+      return { ...response, sessionId };
+    });
+  }
+
+  async runWithForkReservation(agentId, options = {}, operation) {
     const binding = this.requireBinding(agentId);
-    const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
-    if (!capabilities?.fork) throw new Error(`${binding.provider} ACP Agent does not support session/fork`);
-    const sessionOptions = acpSessionRequestOptions({
-      additionalDirectories: options.additionalDirectories ?? binding.sessionRequestOptions.additionalDirectories,
-      mcpServers: options.mcpServers ?? binding.sessionRequestOptions.mcpServers,
-    }, options.cwd || binding.cwd);
-    return withTimeout(binding.connection.unstable_forkSession({
-      sessionId: options.sessionId || binding.sessionId,
-      ...sessionOptions,
-    }), this.sessionSetupTimeoutMs, 'ACP session/fork');
+    const mutation = this.beginSessionMutation(binding, 'fork');
+    try {
+      const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
+      if (!capabilities?.fork) throw new Error(`${binding.provider} ACP Agent does not support session/fork`);
+      if (options.requireLoad === true && !binding.initializeResponse?.agentCapabilities?.loadSession) {
+        throw new Error(`${binding.provider} ACP Agent cannot load a forked conversation`);
+      }
+      if (
+        Number.isFinite(options.expectedRevision)
+        && Number(binding.sessionState?.revision || 0) !== Math.floor(options.expectedRevision)
+      ) {
+        throw new Error('ACP conversation changed before it could be forked. Try again from the latest answer.');
+      }
+      if (typeof operation !== 'function') throw new Error('ACP fork operation is required');
+      return await operation(binding);
+    } finally {
+      this.endSessionMutation(binding, mutation);
+    }
   }
 
   async deleteSession(agentId, sessionId) {
     const binding = this.requireBinding(agentId);
-    const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
-    if (!capabilities?.delete) throw new Error(`${binding.provider} ACP Agent does not support session/delete`);
-    await withTimeout(
-      binding.connection.deleteSession({ sessionId: String(sessionId || '') }),
-      this.requestTimeoutMs,
-      'ACP session/delete'
-    );
-    return { deleted: true, sessionId: String(sessionId || '') };
+    const mutation = this.beginSessionMutation(binding, 'session deletion');
+    try {
+      const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
+      if (!capabilities?.delete) throw new Error(`${binding.provider} ACP Agent does not support session/delete`);
+      await withTimeout(
+        binding.connection.deleteSession({ sessionId: String(sessionId || '') }),
+        this.requestTimeoutMs,
+        'ACP session/delete'
+      );
+      this.requireOpenBinding(binding);
+      return { deleted: true, sessionId: String(sessionId || '') };
+    } finally {
+      this.endSessionMutation(binding, mutation);
+    }
   }
 
   async closeSession(agentId) {
     const binding = this.requireBinding(agentId);
-    const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
-    if (!capabilities?.close) throw new Error(`${binding.provider} ACP Agent does not support session/close`);
-    await withTimeout(
-      binding.connection.closeSession({ sessionId: binding.sessionId }),
-      this.requestTimeoutMs,
-      'ACP session/close'
-    );
-    binding.state = 'closed';
-    this.emitRuntime(binding);
-    return { closed: true, sessionId: binding.sessionId };
+    const mutation = this.beginSessionMutation(binding, 'session close');
+    try {
+      const capabilities = binding.initializeResponse?.agentCapabilities?.sessionCapabilities;
+      if (!capabilities?.close) throw new Error(`${binding.provider} ACP Agent does not support session/close`);
+      await withTimeout(
+        binding.connection.closeSession({ sessionId: binding.sessionId }),
+        this.requestTimeoutMs,
+        'ACP session/close'
+      );
+      this.requireOpenBinding(binding);
+      binding.state = 'closed';
+      this.emitRuntime(binding);
+      return { closed: true, sessionId: binding.sessionId };
+    } finally {
+      this.endSessionMutation(binding, mutation);
+    }
   }
 
   async setSessionMode(agentId, modeId) {
     const binding = this.requireBinding(agentId);
+    this.requireConfigMutationReady(binding);
+    return this.enqueueSessionConfigMutation(binding, () => (
+      this.setSessionModeNow(binding, modeId)
+    ));
+  }
+
+  async setSessionModeNow(binding, modeId) {
+    this.requireOpenBinding(binding);
     await withTimeout(
       binding.connection.setSessionMode({ sessionId: binding.sessionId, modeId: String(modeId || '') }),
       this.requestTimeoutMs,
       'ACP session/set_mode'
     );
+    this.requireOpenBinding(binding);
     binding.sessionState.currentModeId = String(modeId || '');
     if (binding.modes) binding.modes = { ...binding.modes, currentModeId: binding.sessionState.currentModeId };
     this.scheduleCheckpoint(binding, { exact: true });
@@ -1404,12 +2235,14 @@ class AcpRuntime extends EventEmitter {
 
   async setSessionConfigOption(agentId, configId, value) {
     const binding = this.requireBinding(agentId);
+    this.requireConfigMutationReady(binding);
     return this.enqueueSessionConfigMutation(binding, () => (
       this.setSessionConfigOptionNow(binding, configId, value)
     ));
   }
 
   async setSessionConfigOptionNow(binding, configId, value) {
+    this.requireOpenBinding(binding);
     const option = binding.configOptions?.find(candidate => candidate.id === String(configId || ''));
     if (
       binding.provider === 'codex'
@@ -1437,17 +2270,52 @@ class AcpRuntime extends EventEmitter {
 
   async setSessionConfigOptions(agentId, changes) {
     const binding = this.requireBinding(agentId);
+    this.requireConfigMutationReady(binding);
     return this.enqueueSessionConfigMutation(binding, () => (
       this.setSessionConfigOptionsNow(binding, changes)
     ));
   }
 
   async setSessionConfigOptionsNow(binding, changes) {
+    this.requireOpenBinding(binding);
     const normalized = Array.isArray(changes)
       ? changes.filter(change => change && typeof change.configId === 'string' && Object.prototype.hasOwnProperty.call(change, 'value'))
       : [];
     if (normalized.length === 0) throw new Error('ACP config options are required');
 
+    const originalValues = new Map();
+    for (const change of normalized) {
+      if (originalValues.has(change.configId)) continue;
+      const option = binding.configOptions?.find(candidate => candidate.id === change.configId);
+      if (option && Object.prototype.hasOwnProperty.call(option, 'currentValue')) {
+        originalValues.set(change.configId, option.currentValue);
+      }
+    }
+    try {
+      return await this.applySessionConfigOptionsNow(binding, normalized);
+    } catch (error) {
+      const rollbackErrors = [];
+      for (const [configId, value] of [...originalValues.entries()].reverse()) {
+        const current = binding.configOptions?.find(candidate => candidate.id === configId);
+        if (current?.currentValue === value) continue;
+        try {
+          await this.setSessionConfigOptionNow(binding, configId, value);
+        } catch (rollbackError) {
+          rollbackErrors.push(rollbackError);
+        }
+      }
+      if (rollbackErrors.length > 0 && error && typeof error === 'object') {
+        Object.defineProperty(error, 'configRollbackError', {
+          value: new AggregateError(rollbackErrors, 'ACP config rollback failed'),
+          enumerable: false,
+          configurable: true,
+        });
+      }
+      throw error;
+    }
+  }
+
+  async applySessionConfigOptionsNow(binding, normalized) {
     const configById = new Map((binding.configOptions || []).map(option => [option.id, option]));
     const modelChange = normalized.find(change => {
       const option = configById.get(change.configId);
@@ -1497,6 +2365,7 @@ class AcpRuntime extends EventEmitter {
   }
 
   async refreshCodexSessionModel(binding, model, effort) {
+    this.requireOpenBinding(binding);
     await withTimeout(
       binding.connection.request(CODEX_SET_SESSION_MODEL_METHOD, {
         sessionId: binding.sessionId,
@@ -1505,9 +2374,11 @@ class AcpRuntime extends EventEmitter {
       this.requestTimeoutMs,
       'Codex ACP session/set_model capability refresh'
     );
+    this.requireOpenBinding(binding);
   }
 
   async applySessionConfigOption(binding, configId, value, options = {}) {
+    this.requireOpenBinding(binding);
     const normalizedConfigId = String(configId || '');
     const currentOption = binding.configOptions?.find(candidate => candidate.id === normalizedConfigId);
     if (options.force !== true && currentOption?.currentValue === value) {
@@ -1524,6 +2395,7 @@ class AcpRuntime extends EventEmitter {
         this.requestTimeoutMs,
         'ACP session/set_config_option'
       );
+      this.requireOpenBinding(binding);
       binding.configOptions = response?.configOptions || binding.configOptions;
       const confirmed = binding.configOptions?.find(candidate => candidate.id === normalizedConfigId);
       if (confirmed?.currentValue === request.value) break;
@@ -1545,6 +2417,10 @@ class AcpRuntime extends EventEmitter {
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
       supportsSteer: binding.supportsSteer === true,
+      supportsFork: Boolean(
+        binding.initializeResponse?.agentCapabilities?.sessionCapabilities?.fork != null
+        && binding.initializeResponse?.agentCapabilities?.loadSession
+      ),
       protocolVersion: binding.initializeResponse?.protocolVersion || null,
       agentInfo: binding.initializeResponse?.agentInfo || null,
       capabilities: binding.initializeResponse?.agentCapabilities || {},
@@ -1625,33 +2501,82 @@ class AcpRuntime extends EventEmitter {
 
   async decidePatch(agentId, toolCallId, requestedPath, decision) {
     const binding = this.requireBinding(agentId);
-    if (binding.promptActive) throw new Error('Wait for the Agent to finish before deciding a patch');
+    this.requireOpenBinding(binding);
+    if (
+      binding.sessionMutation
+      || binding.configMutationTail
+      || binding.activeTurn
+      || !['idle', 'error'].includes(binding.state)
+    ) {
+      throw new Error('Wait for the Agent to finish before deciding a patch');
+    }
     const entry = binding.sessionState?.toolEntries.get(String(toolCallId || ''));
     if (entry && binding.sessionState.isInternalEntry(entry)) throw new Error('ACP tool call not found');
     if (!entry) throw new Error('ACP tool call not found');
     const normalizedDecision = String(decision || '').trim().toLowerCase();
     if (!['keep', 'revert'].includes(normalizedDecision)) throw new Error('ACP patch decision is invalid');
     const key = `${String(toolCallId || '')}\n${String(requestedPath || '')}`;
-    if (binding.patchDecisions.has(key)) throw new Error('ACP patch file already has a decision');
-    let result = { action: 'kept', path: String(requestedPath || '') };
-    if (normalizedDecision === 'revert') {
-      result = await rejectPatch({ entry, root: binding.cwd, requestedPath });
-    }
-    binding.patchDecisions.set(key, result.action);
-    entry._meta = { ...(entry._meta || {}) };
-    entry._meta.farming_patch_decisions = {
-      ...(entry._meta.farming_patch_decisions || {}),
-      [String(requestedPath || '')]: result.action,
-    };
-    binding.sessionState?.touchEntry(entry);
-    binding.updatedAt = new Date().toISOString();
-    this.scheduleCheckpoint(binding, { exact: true });
-    this.emitSession(binding);
-    return { ...result, toolCallId: String(toolCallId || '') };
+    const expectedAction = normalizedDecision === 'keep' ? 'kept' : 'reverted';
+    const existing = binding.patchDecisionInFlight.get(key);
+    if (existing) {
+      if (existing.decision !== normalizedDecision) {
+        throw new Error('ACP patch file already has a different decision in progress');
+      }
+      return existing.promise;
+    }
+    const committed = binding.patchDecisions.get(key);
+    if (committed) {
+      if (committed !== expectedAction) throw new Error('ACP patch file already has a different decision');
+      const operation = (async () => {
+        await this.writeCheckpoint(binding, { exact: true });
+        return {
+          action: committed,
+          path: String(requestedPath || ''),
+          toolCallId: String(toolCallId || ''),
+        };
+      })();
+      const pending = { decision: normalizedDecision, promise: operation };
+      binding.patchDecisionInFlight.set(key, pending);
+      try {
+        return await operation;
+      } finally {
+        if (binding.patchDecisionInFlight.get(key) === pending) {
+          binding.patchDecisionInFlight.delete(key);
+        }
+      }
+    }
+    const operation = (async () => {
+      let result = { action: 'kept', path: String(requestedPath || '') };
+      if (normalizedDecision === 'revert') {
+        result = await rejectPatch({ entry, root: binding.cwd, requestedPath });
+        this.requireOpenBinding(binding);
+      }
+      binding.patchDecisions.set(key, result.action);
+      entry._meta = { ...(entry._meta || {}) };
+      entry._meta.farming_patch_decisions = {
+        ...(entry._meta.farming_patch_decisions || {}),
+        [String(requestedPath || '')]: result.action,
+      };
+      binding.sessionState?.touchEntry(entry);
+      binding.updatedAt = new Date().toISOString();
+      await this.writeCheckpoint(binding, { exact: true });
+      this.emitSession(binding);
+      return { ...result, toolCallId: String(toolCallId || '') };
+    })();
+    const pending = { decision: normalizedDecision, promise: operation };
+    binding.patchDecisionInFlight.set(key, pending);
+    try {
+      return await operation;
+    } finally {
+      if (binding.patchDecisionInFlight.get(key) === pending) {
+        binding.patchDecisionInFlight.delete(key);
+      }
+    }
   }
 
   killTerminal(agentId, terminalId) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
     this.clientTerminals.kill(binding, {
       sessionId: binding.sessionId,
       terminalId: String(terminalId || ''),
@@ -1661,6 +2586,7 @@ class AcpRuntime extends EventEmitter {
 
   inputTerminal(agentId, terminalId, input) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
     return this.clientTerminals.input(binding, {
       sessionId: binding.sessionId,
       terminalId,
@@ -1670,6 +2596,7 @@ class AcpRuntime extends EventEmitter {
 
   resizeTerminal(agentId, terminalId, cols, rows) {
     const binding = this.requireBinding(agentId);
+    this.requireOpenBinding(binding);
     return this.clientTerminals.resize(binding, {
       sessionId: binding.sessionId,
       terminalId,
@@ -1692,17 +2619,26 @@ class AcpRuntime extends EventEmitter {
       .some(request => String(request?.sessionId || '') === id);
     const pendingElicitation = [...binding.pendingElicitations.values()]
       .some(request => String(request?.sessionId || '') === id);
+    const control = this.ensureSubagentControl(binding, id);
     const active = ['pending', 'in_progress', 'in-progress', 'running'].includes(status);
     const failed = ['failed', 'error'].includes(status);
     const stateName = pendingPermission
       ? 'waiting-for-permission'
       : pendingElicitation
         ? 'waiting-for-input'
-        : active
-          ? 'working'
-          : failed
+        : control.phase === 'cancelling'
+          ? 'interrupting'
+          : control.phase === 'error'
             ? 'error'
-            : 'idle';
+            : ['cancelled', 'completed'].includes(control.phase)
+              ? 'idle'
+              : active
+                ? 'working'
+                : failed
+                  ? 'error'
+                  : 'idle';
+    const controlFailed = control.phase === 'error';
+    const cancelled = control.phase === 'cancelled';
     return {
       version: 2,
       protocol: 'acp',
@@ -1713,13 +2649,17 @@ class AcpRuntime extends EventEmitter {
       updatedAt: binding.updatedAt,
       truncated: state.truncated === true,
       state: stateName,
-      error: failed ? String(parentTool?.title || 'Subagent failed') : '',
-      errorKind: failed ? 'agent' : '',
-      stopReason: failed ? 'error' : active ? '' : 'end_turn',
+      error: controlFailed ? control.error : failed ? String(parentTool?.title || 'Subagent failed') : '',
+      errorKind: controlFailed || failed ? 'agent' : '',
+      stopReason: controlFailed || failed ? 'error' : cancelled ? 'cancelled' : active ? '' : 'end_turn',
       ...state.transcriptSlice(options),
     };
   }
 
+  hasBinding(agentId) {
+    return this.bindings.has(agentId);
+  }
+
   requireBinding(agentId) {
     const binding = this.bindings.get(agentId);
     if (!binding) throw new Error('ACP Agent is not registered');
@@ -1727,6 +2667,7 @@ class AcpRuntime extends EventEmitter {
   }
 
   emitRuntime(binding) {
+    if (!this.isCurrentBinding(binding)) return false;
     this.emit('agent-runtime', {
       agentId: binding.agentId,
       provider: binding.provider,
@@ -1736,6 +2677,10 @@ class AcpRuntime extends EventEmitter {
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
       supportsSteer: binding.supportsSteer === true,
+      supportsFork: Boolean(
+        binding.initializeResponse?.agentCapabilities?.sessionCapabilities?.fork != null
+        && binding.initializeResponse?.agentCapabilities?.loadSession
+      ),
       pendingPermission: binding.pendingPermissions.values().next().value || null,
       pendingPermissions: [...binding.pendingPermissions.values()],
       pendingElicitation: binding.pendingElicitations.values().next().value || null,
@@ -1743,23 +2688,40 @@ class AcpRuntime extends EventEmitter {
       activeElicitations: [...binding.activeElicitations.values()],
       updatedAt: binding.updatedAt,
     });
+    return true;
   }
 
   emitSession(binding) {
+    if (!this.isCurrentBinding(binding)) return false;
     this.emit('session', {
       agentId: binding.agentId,
       updatedAt: binding.updatedAt,
       revision: binding.sessionState?.revision || 0,
     });
+    return true;
   }
 
   handleExit(binding, error) {
-    if (this.bindings.get(binding.agentId) !== binding) return;
+    if (!this.isCurrentBinding(binding) || binding.exited) return;
+    binding.exited = true;
+    const turn = binding.activeTurn;
+    const promptWasActive = Boolean(turn && turn.phase !== 'admitting');
+    binding.activeTurn = null;
     if (error) {
       binding.state = 'error';
       binding.error = acpErrorMessage(error);
+      binding.stopReason = 'error';
     } else if (binding.state !== 'error') {
       binding.state = 'stopped';
+      binding.stopReason = promptWasActive ? 'stopped' : binding.stopReason;
+    }
+    if (promptWasActive && binding.sessionState) {
+      if (error) binding.sessionState.recordError(binding.error, acpErrorKind(error));
+      binding.sessionState.completePrompt(binding.stopReason);
+    }
+    if (turn) {
+      turn.phase = 'completed';
+      turn.resolveCompletion({ status: 'connection-closed', error: error || null });
     }
     for (const resolve of binding.permissionResolvers.values()) {
       resolve({ outcome: { outcome: 'cancelled' } });
@@ -1772,14 +2734,23 @@ class AcpRuntime extends EventEmitter {
     binding.activeElicitations.clear();
     binding.interactionOrigins.clear();
     binding.subagentStates.clear();
+    binding.subagentControls.clear();
     this.clientTerminals.cleanupAgent(binding.agentId);
+    if (promptWasActive) this.emitSession(binding);
     this.emitRuntime(binding);
   }
 
-  detachAgentBinding(binding) {
+  detachAgentBinding(binding, options = {}) {
     if (!binding || this.bindings.get(binding.agentId) !== binding) return false;
-    if (binding.sessionState && !binding.promptActive) this.scheduleCheckpoint(binding, { exact: true });
-    this.bindings.delete(binding.agentId);
+    if (binding.sessionState && !binding.activeTurn) this.scheduleCheckpoint(binding, { exact: true });
+    if (options.retainForCleanup !== true) this.bindings.delete(binding.agentId);
+    binding.exited = true;
+    const turn = binding.activeTurn;
+    binding.activeTurn = null;
+    if (turn) {
+      turn.phase = 'completed';
+      turn.resolveCompletion({ status: 'binding-detached' });
+    }
     for (const resolve of binding.permissionResolvers.values()) resolve({ outcome: { outcome: 'cancelled' } });
     for (const resolve of binding.elicitationResolvers.values()) resolve({ action: 'cancel' });
     binding.permissionResolvers.clear();
@@ -1789,6 +2760,7 @@ class AcpRuntime extends EventEmitter {
     binding.activeElicitations.clear();
     binding.interactionOrigins.clear();
     binding.subagentStates.clear();
+    binding.subagentControls.clear();
     this.clientTerminals.cleanupAgent(binding.agentId);
     try {
       binding.connection?.close();
@@ -1805,30 +2777,59 @@ class AcpRuntime extends EventEmitter {
     return true;
   }
 
-  unregisterAgent(agentId) {
+  unregisterAgent(agentId, expectedBinding = null) {
     const binding = this.bindings.get(agentId);
+    if (expectedBinding && binding !== expectedBinding) return;
     if (!binding || !this.detachAgentBinding(binding)) return;
     signalProcessTree(binding, 'SIGTERM');
   }
 
-  async unregisterAgentAndWait(agentId) {
+  async unregisterAgentAndWait(agentId, expectedBinding = null) {
     const binding = this.bindings.get(agentId);
-    if (!binding || !this.detachAgentBinding(binding)) return;
-    if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_GRACEFUL_EXIT_MS)) return;
-    signalProcessTree(binding, 'SIGTERM');
-    if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_TERMINATE_MS)) return;
-    signalProcessTree(binding, 'SIGKILL');
-    if (await waitForProcessTreeExit(binding, IDENTITY_ADAPTER_KILL_MS)) return;
-    throw new Error(`ACP identity adapter process tree ${binding.child?.pid || ''} did not exit`);
+    if (expectedBinding && binding !== expectedBinding) return false;
+    if (!binding || !this.detachAgentBinding(binding, { retainForCleanup: true })) return false;
+    await stopBindingProcessAndWait(binding);
+    if (this.bindings.get(agentId) === binding) this.bindings.delete(agentId);
+    return true;
+  }
+
+  dispose() {
+    if (this.disposed) return Promise.resolve();
+    if (this.disposePromise) return this.disposePromise;
+
+    this.disposing = true;
+    const disposePromise = this.performDispose();
+    this.disposePromise = disposePromise;
+    void disposePromise.finally(() => {
+      if (this.disposePromise === disposePromise) this.disposePromise = null;
+      if (!this.disposed) this.disposing = false;
+    }).catch(() => {});
+    return disposePromise;
+  }
+
+  resumeAfterDisposeAbort() {
+    this.disposed = false;
+    this.disposing = false;
   }
 
-  async dispose() {
+  async performDispose() {
     for (const binding of this.bindings.values()) {
-      if (binding.sessionState && !binding.promptActive) this.scheduleCheckpoint(binding, { exact: true });
+      if (binding.sessionState && !binding.activeTurn) this.scheduleCheckpoint(binding, { exact: true });
     }
     if (this.checkpointStore) await this.checkpointStore.flush();
-    for (const agentId of [...this.bindings.keys()]) this.unregisterAgent(agentId);
+    const failures = [];
+    for (const agentId of [...this.bindings.keys()]) {
+      try {
+        await this.unregisterAgentAndWait(agentId);
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'One or more ACP Agent process trees did not exit');
+    }
     if (this.checkpointStore) await this.checkpointStore.dispose();
+    this.disposed = true;
   }
 }
 
@@ -1839,8 +2840,10 @@ module.exports = {
   acpErrorKind,
   autoPermissionResponse,
   codexAcpEnvironment,
+  describeAcpProcessGroup,
   promptContentForCapabilities,
   resolveAcpLaunch,
+  stopPersistedAcpProcessGroup,
   supportsCodexSteer,
   isCodexSteerUnavailableError,
   CODEX_STEER_METHOD,