farming-code 2.2.14 → 2.2.17

package/backend/acp-runtime.js

@@ -1,17 +1,21 @@
 const EventEmitter = require('events');
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
-const { spawn } = require('child_process');
+const { execFile, spawn } = require('child_process');
 const { Readable, Writable } = require('stream');
 const { createRequire } = require('module');
+const { promisify } = require('util');
 const packageJson = require('../package.json');
 const { AcpCheckpointStore } = require('./acp-checkpoint-store');
 const { AcpSessionState } = require('./acp-session-state');
 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 { getProviderAdapter, listProviderAdapters } = require('./provider-adapters');
+const { isSafeProviderSessionId } = require('./provider-session-id');
 
 const ADAPTER_VERSIONS = Object.freeze(Object.fromEntries(
   listProviderAdapters().filter(adapter => adapter.acp).map(adapter => [adapter.id, adapter.acp.version]),
@@ -24,7 +28,22 @@ const DEFAULT_CANCEL_TIMEOUT_MS = 15_000;
 const DEFAULT_HISTORY_REPLAY_MIN_WAIT_MS = 350;
 const DEFAULT_HISTORY_REPLAY_QUIET_MS = 150;
 const DEFAULT_HISTORY_REPLAY_MAX_WAIT_MS = 5_000;
+const IDENTITY_ADAPTER_GRACEFUL_EXIT_MS = 3_000;
+const IDENTITY_ADAPTER_TERMINATE_MS = 1_000;
+const IDENTITY_ADAPTER_KILL_MS = 1_000;
 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_VENDOR_ENTRY = path.join(
+  __dirname,
+  '..',
+  'dist',
+  'acp',
+  `codex-acp-${CODEX_ACP_VERSION}.js`,
+);
+const execFileAsync = promisify(execFile);
 
 let sdkPromise;
 const runtimeRequire = createRequire(__filename);
@@ -33,7 +52,24 @@ function loadAcpSdk() {
   return sdkPromise;
 }
 
+function fileSha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function verifiedCodexAcpEntry(entry) {
+  const actualSha256 = fileSha256(entry);
+  if (actualSha256 !== CODEX_ACP_SHA256) {
+    throw new Error(
+      `Codex ACP runtime failed integrity verification: expected ${CODEX_ACP_SHA256}, found ${actualSha256}`,
+    );
+  }
+  return entry;
+}
+
 function adapterEntry(packageName) {
+  if (packageName === CODEX_ACP_PACKAGE && fs.existsSync(CODEX_ACP_VENDOR_ENTRY)) {
+    return verifiedCodexAcpEntry(CODEX_ACP_VENDOR_ENTRY);
+  }
   let sdkDirectory;
   try {
     sdkDirectory = path.dirname(runtimeRequire.resolve('@agentclientprotocol/sdk'));
@@ -42,11 +78,15 @@ function adapterEntry(packageName) {
   }
   const entry = path.resolve(sdkDirectory, '..', '..', packageName.split('/').pop(), 'dist', 'index.js');
   if (!fs.existsSync(entry)) throw new Error(`ACP adapter is not installed: ${packageName}`);
+  if (packageName === CODEX_ACP_PACKAGE) return verifiedCodexAcpEntry(entry);
   return entry;
 }
 
-function nodeAdapterLaunch(entry, env = process.env) {
+function nodeAdapterLaunch(entry, env = process.env, packagedArg = '') {
   const runtimeEnv = env && typeof env === 'object' ? env : process.env;
+  if (process.pkg && packagedArg) {
+    return { command: process.execPath, args: [packagedArg] };
+  }
   const nodeBin = runtimeEnv.FARMING_NODE_BIN || process.execPath;
   const ldPath = runtimeEnv.FARMING_NODE_LD || '';
   const libraryPath = runtimeEnv.FARMING_NODE_LIBRARY_PATH || '';
@@ -69,6 +109,7 @@ function resolveAcpLaunch(provider, options = {}) {
     const launch = nodeAdapterLaunch(
       adapterEntry(adapter.acp.packageName),
       options.runtimeEnv || process.env,
+      adapter.acp.packageName === CODEX_ACP_PACKAGE ? PACKAGED_CODEX_ACP_ARG : '',
     );
     return { ...launch, version: adapter.acp.version };
   }
@@ -202,6 +243,134 @@ function clone(value) {
   return value == null ? value : JSON.parse(JSON.stringify(value));
 }
 
+function acpSessionRequestOptions(options = {}, cwd = process.cwd()) {
+  const root = path.resolve(cwd || process.cwd());
+  const additionalDirectories = Array.isArray(options.additionalDirectories)
+    ? [...new Set(options.additionalDirectories
+      .filter(directory => typeof directory === 'string' && directory.trim())
+      .map(directory => path.resolve(root, directory)))]
+    : [];
+  const mcpServers = Array.isArray(options.mcpServers)
+    ? clone(options.mcpServers.filter(server => server && typeof server === 'object' && !Array.isArray(server)))
+    : [];
+  return { cwd: root, additionalDirectories, mcpServers };
+}
+
+function promptContentForCapabilities(content, capabilities = {}) {
+  const promptCapabilities = capabilities?.promptCapabilities || {};
+  return (Array.isArray(content) ? content : []).flatMap(block => {
+    if (!block || typeof block !== 'object') return [];
+    if (!['image', 'audio'].includes(block.type)) return [clone(block)];
+    if (promptCapabilities[block.type] === true) return [clone(block)];
+
+    const label = block.type === 'audio' ? 'audio' : 'image';
+    const attachmentPath = typeof block.path === 'string' && block.path.trim()
+      ? path.resolve(block.path)
+      : '';
+    const name = attachmentPath ? path.basename(attachmentPath) : `attached ${label}`;
+    const detail = attachmentPath
+      ? `${label[0].toUpperCase()}${label.slice(1)} path: ${attachmentPath}`
+      : `[The ACP Agent does not accept native ${label} content]`;
+    return [{ type: 'text', text: `Attached ${label}: ${name}\n\n${detail}` }];
+  });
+}
+
+function supportsCodexSteer(capabilities = {}) {
+  const capability = capabilities?._meta?.codex?.steer;
+  return capability?.method === CODEX_STEER_METHOD
+    && Number.isFinite(Number(capability.version))
+    && Number(capability.version) >= 1;
+}
+
+function isCodexSteerUnavailableError(error) {
+  const text = [
+    error?.message,
+    error?.data?.details,
+    error?.cause?.message,
+    error?.cause?.data?.details,
+  ].filter(Boolean).join(' ').toLowerCase();
+  return text.includes('no active codex turn to steer')
+    || text.includes('no active turn to steer')
+    || /expected active turn id .* but found/.test(text)
+    || text.includes('cannot steer a review turn')
+    || text.includes('cannot steer a compact turn');
+}
+
+function childHasExited(child) {
+  return !child
+    || (child.exitCode !== null && child.exitCode !== undefined)
+    || (child.signalCode !== null && child.signalCode !== undefined);
+}
+
+function processGroupHasExited(binding) {
+  if (!binding?.ownsProcessGroup || !binding.child?.pid || process.platform === 'win32') {
+    return childHasExited(binding?.child);
+  }
+  try {
+    process.kill(-binding.child.pid, 0);
+    return false;
+  } catch (error) {
+    return error?.code === 'ESRCH';
+  }
+}
+
+async function waitForProcessTreeExit(binding, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    if (processGroupHasExited(binding)) return true;
+    await new Promise(resolve => setTimeout(resolve, 25));
+  }
+  return processGroupHasExited(binding);
+}
+
+function signalProcessTree(binding, signal) {
+  if (!binding?.child || processGroupHasExited(binding)) return;
+  if (binding.ownsProcessGroup && binding.child.pid && process.platform !== 'win32') {
+    try {
+      process.kill(-binding.child.pid, signal);
+      return;
+    } catch (error) {
+      if (error?.code === 'ESRCH') return;
+    }
+  }
+  binding.child.kill(signal);
+}
+
+async function deleteProviderSessionIdentity(options = {}) {
+  const provider = String(options.provider || '').trim().toLowerCase();
+  const sessionId = String(options.sessionId || '').trim();
+  if (!isSafeProviderSessionId(sessionId)) {
+    throw new Error('Provider session rollback requires a safe exact session id');
+  }
+  let args;
+  if (provider === 'codex') args = ['delete', '--force', sessionId];
+  else if (provider === 'opencode') args = ['session', 'delete', sessionId];
+  else throw new Error(`${provider || 'Provider'} does not support identity rollback`);
+  await execFileAsync(options.executable || getProviderAdapter(provider)?.executable, args, {
+    cwd: options.cwd,
+    env: options.env,
+    timeout: 15_000,
+    maxBuffer: 1024 * 1024,
+  });
+}
+
+function attachProviderSessionIdentity(error, identity, rollbackError) {
+  const target = error instanceof Error ? error : new Error(String(error || 'Provider session identity failed'));
+  Object.defineProperty(target, 'providerSessionIdentity', {
+    value: identity,
+    enumerable: false,
+    configurable: true,
+  });
+  if (rollbackError) {
+    Object.defineProperty(target, 'providerSessionRollbackError', {
+      value: rollbackError,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+  return target;
+}
+
 class AcpRuntime extends EventEmitter {
   constructor(options = {}) {
     super();
@@ -216,6 +385,7 @@ class AcpRuntime extends EventEmitter {
     this.historyReplayMinWaitMs = options.historyReplayMinWaitMs ?? DEFAULT_HISTORY_REPLAY_MIN_WAIT_MS;
     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.checkpointStore = options.checkpointStore
       || (options.configDir ? new AcpCheckpointStore(options.configDir, options.checkpointOptions) : null);
     this.bindings = new Map();
@@ -231,19 +401,24 @@ class AcpRuntime extends EventEmitter {
     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 sessionRequestOptions = acpSessionRequestOptions(options, cwd);
     const binding = {
       agentId,
       provider,
       providerHomeId: String(options.providerHomeId || 'default'),
-      cwd: path.resolve(options.cwd || process.cwd()),
+      cwd,
+      sessionRequestOptions,
       env: (getProviderAdapter(provider)?.prepareAcpEnvironment || (value => value.env || process.env))(options),
       launch,
       restartOptions: { ...options, agentId, provider },
       approvalMode: options.approvalMode || 'approve',
+      ownsProcessGroup: options.identityOnly === true && process.platform !== 'win32',
       child: null,
       connection: null,
       initializeResponse: null,
       sessionId: '',
+      untrustedSessionId: '',
       state: 'connecting',
       error: '',
       stopReason: '',
@@ -257,6 +432,8 @@ class AcpRuntime extends EventEmitter {
       subagentStates: new Map(),
       interactionOrigins: new Map(),
       promptActive: false,
+      supportsSteer: false,
+      steerTail: null,
       historyReplayActive: false,
       sessionState: null,
       authTerminal: null,
@@ -273,6 +450,7 @@ class AcpRuntime extends EventEmitter {
         cwd: binding.cwd,
         env: binding.env,
         stdio: ['pipe', 'pipe', 'pipe'],
+        detached: binding.ownsProcessGroup,
       });
       binding.child = child;
       child.stderr.on('data', chunk => {
@@ -308,12 +486,14 @@ class AcpRuntime extends EventEmitter {
       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, cwd: binding.cwd, mcpServers: [] };
+      const sessionRequest = { sessionId: requestedSessionId, ...binding.sessionRequestOptions };
       let sessionResponse;
       let historyMode = 'new';
       if (requestedSessionId) {
@@ -413,12 +593,16 @@ class AcpRuntime extends EventEmitter {
         }
       } else {
         sessionResponse = await withTimeout(
-          connection.newSession({ cwd: binding.cwd, mcpServers: [] }),
+          connection.newSession(binding.sessionRequestOptions),
           this.sessionSetupTimeoutMs,
           'ACP session/new'
         );
-        binding.sessionId = String(sessionResponse.sessionId || '');
-        if (!binding.sessionId) throw new Error('ACP session/new did not return a session id');
+        const returnedSessionId = String(sessionResponse.sessionId || '').trim();
+        if (!isSafeProviderSessionId(returnedSessionId)) {
+          binding.untrustedSessionId = returnedSessionId;
+          throw new Error('ACP session/new returned an invalid resumable session id');
+        }
+        binding.sessionId = returnedSessionId;
         binding.sessionState = new AcpSessionState({ provider, sessionId: binding.sessionId, cwd: binding.cwd, maxUpdates: this.maxUpdates });
       }
       binding.modes = sessionResponse?.modes || null;
@@ -451,11 +635,109 @@ class AcpRuntime extends EventEmitter {
     } catch (error) {
       const runtimeError = new Error(acpErrorMessage(error), { cause: error });
       this.handleExit(binding, runtimeError);
-      this.unregisterAgent(agentId);
+      if (options.identityOnly === true) {
+        const returnedIdentity = binding.sessionId || binding.untrustedSessionId;
+        const identity = returnedIdentity
+          ? {
+              provider,
+              executable: options.executable || getProviderAdapter(provider)?.executable,
+              env: binding.env,
+              cwd: binding.cwd,
+              sessionId: returnedIdentity,
+              producerStopped: false,
+            }
+          : null;
+        let producerStopped = false;
+        try {
+          await this.unregisterAgentAndWait(agentId);
+          producerStopped = true;
+          if (identity) identity.producerStopped = true;
+        } catch (cleanupError) {
+          Object.defineProperty(runtimeError, 'adapterCleanupError', {
+            value: cleanupError,
+            enumerable: false,
+            configurable: true,
+          });
+          if (identity) attachProviderSessionIdentity(runtimeError, identity);
+        }
+        if (identity && producerStopped && isSafeProviderSessionId(identity.sessionId)) {
+          try {
+            await this.deleteProviderSessionIdentity(identity);
+          } catch (rollbackError) {
+            attachProviderSessionIdentity(runtimeError, identity, rollbackError);
+          }
+        } else if (identity && producerStopped) {
+          attachProviderSessionIdentity(runtimeError, identity);
+        }
+      } else {
+        this.unregisterAgent(agentId);
+      }
       throw runtimeError;
     }
   }
 
+  async createSessionIdentity(options = {}) {
+    const agentId = `provider-session-${crypto.randomUUID()}`;
+    let prepared = null;
+    let result = null;
+    let failure = null;
+    let identity = null;
+    try {
+      prepared = await this.prepareAgent({
+        ...options,
+        agentId,
+        identityOnly: true,
+        sessionId: '',
+      });
+      const binding = this.requireBinding(agentId);
+      identity = {
+        provider: String(options.provider || '').trim().toLowerCase(),
+        executable: options.executable || getProviderAdapter(options.provider)?.executable,
+        env: binding.env,
+        cwd: binding.cwd,
+        sessionId: prepared.sessionId,
+        producerStopped: false,
+      };
+      result = {
+        ...prepared,
+        sessionRequestOptions: this.getSessionRequestOptions(agentId),
+      };
+    } catch (error) {
+      failure = error instanceof Error ? error : new Error(String(error || 'Provider session identity failed'));
+    }
+
+    if (prepared) {
+      let producerStopped = false;
+      try {
+        await this.unregisterAgentAndWait(agentId);
+        producerStopped = true;
+        if (identity) identity.producerStopped = true;
+      } catch (cleanupError) {
+        if (!failure) {
+          failure = cleanupError instanceof Error
+            ? cleanupError
+            : new Error(String(cleanupError || 'ACP identity adapter cleanup failed'));
+        } else {
+          Object.defineProperty(failure, 'adapterCleanupError', {
+            value: cleanupError,
+            enumerable: false,
+            configurable: true,
+          });
+        }
+        if (identity) failure = attachProviderSessionIdentity(failure, identity);
+      }
+      if (failure && identity?.sessionId && producerStopped) {
+        try {
+          await this.deleteProviderSessionIdentity(identity);
+        } catch (rollbackError) {
+          failure = attachProviderSessionIdentity(failure, identity, rollbackError);
+        }
+      }
+    }
+    if (failure) throw failure;
+    return result;
+  }
+
   checkpointIdentity(binding, sessionId = binding?.sessionId) {
     if (!binding || !sessionId) return null;
     return {
@@ -697,9 +979,11 @@ class AcpRuntime extends EventEmitter {
   }
 
   requestElicitation(binding, request) {
-    const requestSessionId = String(request?.sessionId || binding.sessionId);
-    const isPrimarySession = requestSessionId === binding.sessionId;
-    if (!isPrimarySession && !binding.subagentStates.has(requestSessionId)) {
+    const hasSessionScope = typeof request?.sessionId === 'string' && request.sessionId.length > 0;
+    const requestSessionId = hasSessionScope ? String(request.sessionId) : '';
+    const isPrimarySession = hasSessionScope && requestSessionId === binding.sessionId;
+    const isRequestScoped = !hasSessionScope;
+    if (!isRequestScoped && !isPrimarySession && !binding.subagentStates.has(requestSessionId)) {
       throw new Error('ACP elicitation does not match an active session');
     }
     if (!['form', 'url'].includes(String(request?.mode || ''))) {
@@ -715,7 +999,7 @@ class AcpRuntime extends EventEmitter {
       ...cloned,
       ...(protocolRequestId !== undefined ? { protocolRequestId } : {}),
       requestId,
-      origin: isPrimarySession ? 'agent' : 'subagent',
+      origin: isRequestScoped ? 'request' : isPrimarySession ? 'agent' : 'subagent',
     };
     binding.interactionOrigins.set(requestId, binding.state);
     binding.pendingElicitations.set(requestId, pending);
@@ -757,7 +1041,11 @@ class AcpRuntime extends EventEmitter {
   async prompt(agentId, prompt) {
     const binding = this.requireBinding(agentId);
     if (!['idle', 'error'].includes(binding.state)) throw new Error(`ACP Agent is not ready (${binding.state})`);
-    const content = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const rawContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const content = promptContentForCapabilities(
+      rawContent,
+      binding.initializeResponse?.agentCapabilities || {},
+    );
     await this.markCheckpointDirty(binding);
     binding.sessionState.beginPrompt(content);
     binding.promptActive = true;
@@ -795,6 +1083,54 @@ class AcpRuntime extends EventEmitter {
     }
   }
 
+  canSteer(agentId) {
+    const binding = this.bindings.get(agentId);
+    return binding?.provider === 'codex'
+      && binding.supportsSteer === true
+      && binding.promptActive === true
+      && Boolean(binding.sessionId)
+      && Boolean(binding.connection);
+  }
+
+  async steer(agentId, prompt) {
+    const binding = this.requireBinding(agentId);
+    if (binding.provider !== 'codex' || binding.supportsSteer !== true) {
+      throw new Error(`${binding.provider} ACP Agent does not support steer`);
+    }
+    const rawContent = Array.isArray(prompt) ? prompt : [{ type: 'text', text: String(prompt || '') }];
+    const content = promptContentForCapabilities(
+      rawContent,
+      binding.initializeResponse?.agentCapabilities || {},
+    );
+    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');
+      await this.markCheckpointDirty(binding);
+      const response = await withTimeout(
+        binding.connection.request(CODEX_STEER_METHOD, {
+          sessionId: binding.sessionId,
+          prompt: content,
+          clientMessageId,
+        }),
+        this.requestTimeoutMs,
+        'Codex ACP steer',
+      );
+      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;
+    }
+  }
+
   async cancel(agentId) {
     const binding = this.requireBinding(agentId);
     if (!binding.sessionId) return false;
@@ -871,10 +1207,18 @@ class AcpRuntime extends EventEmitter {
     if (!capabilities?.list) throw new Error(`${binding.provider} ACP Agent does not support session/list`);
     return 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');
   }
 
+  getSessionRequestOptions(agentId) {
+    const binding = this.requireBinding(agentId);
+    return clone(binding.sessionRequestOptions);
+  }
+
   async authenticate(agentId, methodId) {
     const binding = this.requireBinding(agentId);
     const method = binding.initializeResponse?.authMethods?.find(item => item.id === methodId);
@@ -896,6 +1240,20 @@ class AcpRuntime extends EventEmitter {
     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`);
+    }
+    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) {
     const legacy = method?._meta?.['terminal-auth'];
     if (legacy && typeof legacy === 'object' && legacy.command) {
@@ -994,13 +1352,13 @@ class AcpRuntime extends EventEmitter {
     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,
-      cwd: path.resolve(options.cwd || binding.cwd),
-      additionalDirectories: Array.isArray(options.additionalDirectories)
-        ? options.additionalDirectories.map(directory => path.resolve(directory))
-        : [],
-      mcpServers: [],
+      ...sessionOptions,
     }), this.sessionSetupTimeoutMs, 'ACP session/fork');
   }
 
@@ -1186,6 +1544,7 @@ class AcpRuntime extends EventEmitter {
       error: binding.error,
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
+      supportsSteer: binding.supportsSteer === true,
       protocolVersion: binding.initializeResponse?.protocolVersion || null,
       agentInfo: binding.initializeResponse?.agentInfo || null,
       capabilities: binding.initializeResponse?.agentCapabilities || {},
@@ -1376,6 +1735,7 @@ class AcpRuntime extends EventEmitter {
       error: binding.error,
       errorKind: binding.error ? acpErrorKind(binding.error) : '',
       stopReason: binding.stopReason,
+      supportsSteer: binding.supportsSteer === true,
       pendingPermission: binding.pendingPermissions.values().next().value || null,
       pendingPermissions: [...binding.pendingPermissions.values()],
       pendingElicitation: binding.pendingElicitations.values().next().value || null,
@@ -1416,11 +1776,10 @@ class AcpRuntime extends EventEmitter {
     this.emitRuntime(binding);
   }
 
-  unregisterAgent(agentId) {
-    const binding = this.bindings.get(agentId);
-    if (!binding) return;
+  detachAgentBinding(binding) {
+    if (!binding || this.bindings.get(binding.agentId) !== binding) return false;
     if (binding.sessionState && !binding.promptActive) this.scheduleCheckpoint(binding, { exact: true });
-    this.bindings.delete(agentId);
+    this.bindings.delete(binding.agentId);
     for (const resolve of binding.permissionResolvers.values()) resolve({ outcome: { outcome: 'cancelled' } });
     for (const resolve of binding.elicitationResolvers.values()) resolve({ action: 'cancel' });
     binding.permissionResolvers.clear();
@@ -1434,9 +1793,33 @@ class AcpRuntime extends EventEmitter {
     try {
       binding.connection?.close();
     } catch {
-      // The adapter process is terminated below even if transport cleanup raced its exit.
+      // Process cleanup below remains authoritative if transport cleanup races.
+    }
+    if (binding.child?.stdin?.writable && !binding.child.stdin.destroyed) {
+      try {
+        binding.child.stdin.end();
+      } catch {
+        // Process cleanup below remains authoritative if stdin already closed.
+      }
     }
-    if (binding.child && !binding.child.killed) binding.child.kill('SIGTERM');
+    return true;
+  }
+
+  unregisterAgent(agentId) {
+    const binding = this.bindings.get(agentId);
+    if (!binding || !this.detachAgentBinding(binding)) return;
+    signalProcessTree(binding, 'SIGTERM');
+  }
+
+  async unregisterAgentAndWait(agentId) {
+    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`);
   }
 
   async dispose() {
@@ -1452,8 +1835,14 @@ class AcpRuntime extends EventEmitter {
 module.exports = {
   AcpRuntime,
   ADAPTER_VERSIONS,
+  acpSessionRequestOptions,
   acpErrorKind,
   autoPermissionResponse,
   codexAcpEnvironment,
+  promptContentForCapabilities,
   resolveAcpLaunch,
+  supportsCodexSteer,
+  isCodexSteerUnavailableError,
+  CODEX_STEER_METHOD,
+  deleteProviderSessionIdentity,
 };