farming-code 2.2.28 → 2.2.29

package/backend/farming-app-cli.js

@@ -8,6 +8,12 @@ const { URLSearchParams } = require('url');
 const { execFileSync, spawn } = require('child_process');
 const { run: runControlCli } = require('./farming-cli');
 const { PACKAGED_CODEX_ACP_ARG, runPackagedCodexAcp } = require('./acp/packaged-codex-acp');
+const { PACKAGED_CLAUDE_ACP_ARG, runPackagedClaudeAcp } = require('./acp/packaged-claude-acp');
+const {
+  SERVER_PROCESS_IDENTITY_FORMAT,
+  matchingProcessIdentity,
+  readServerProcessIdentity,
+} = require('./server-process-identity');
 const storageLayout = require('./storage-layout');
 
 const SERVER_MODE_ARG = '--farming-server';
@@ -20,7 +26,6 @@ const DEFAULT_SERVER_START_TIMEOUT_MS = 30_000;
 const DEFAULT_SERVER_START_STABILITY_MS = 1_500;
 const DEFAULT_SERVER_STOP_TIMEOUT_MS = 30_000;
 const SERVER_STOP_POLL_MS = 100;
-const SERVER_PROCESS_IDENTITY_FORMAT = 'ps-lstart-c-utc-v1';
 const SERVER_COMMANDS = new Set(['start', 'serve', 'daemon', 'stop', 'status', 'logs', 'url', 'help']);
 const CONTROL_COMMANDS = new Set(['skills', 'capabilities', 'memory', 'report', 'list', 'spawn', 'output', 'send', 'kill']);
 const SERVER_BACKED_CONTROL_COMMANDS = new Set(['capabilities', 'list', 'spawn', 'output', 'send', 'kill']);
@@ -437,7 +442,9 @@ function childInvocation(env = process.env) {
     // making daemon ownership impossible to prove on Linux.
     return {
       command: '/usr/bin/env',
-      args: buildCleanEnvExecArgs(env, process.execPath, ['--']),
+      // FARMING_RUN_SERVER selects the embedded server entry. Do not append a
+      // sentinel argument: pkg may interpret it as an external script path.
+      args: buildCleanEnvExecArgs(env, process.execPath),
     };
   }
   const nodePath = env.FARMING_NODE_BIN || process.execPath;
@@ -482,45 +489,20 @@ function canonicalConfigDir(configDir) {
   }
 }
 
-async function readServerProcessIdentity(pid) {
-  const processId = Number(pid);
-  if (!Number.isSafeInteger(processId) || processId <= 0 || process.platform === 'win32') return null;
-  let stdout;
-  try {
-    stdout = execFileSync(
-      '/bin/ps',
-      ['-p', String(processId), '-o', 'pid=', '-o', 'pgid=', '-o', 'lstart='],
-      {
-        encoding: 'utf8',
-        timeout: 1_000,
-        maxBuffer: 16_384,
-        env: { ...process.env, LANG: 'C', LC_ALL: 'C', TZ: 'UTC' },
-      },
-    );
-  } catch (error) {
-    if (error?.status === 1 || error?.code === 'ESRCH') return null;
-    throw error;
-  }
-  const match = String(stdout || '').trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
-  if (!match || Number(match[1]) !== processId) return null;
-  return {
-    pid: processId,
-    processGroupId: Number(match[2]),
-    startedAt: match[3].trim(),
-    format: SERVER_PROCESS_IDENTITY_FORMAT,
-  };
-}
-
-function writeServerState(configDir, env, pid, processIdentity) {
+function writeServerState(configDir, env, pid, processIdentity, phase = 'running') {
   const state = {
     pid,
     port: Number(env.PORT || DEFAULT_PORT),
     basePath: env.FARMING_BASE_PATH || DEFAULT_BASE_PATH,
     configDir: canonicalConfigDir(configDir),
     processIdentity,
+    phase,
     updatedAt: new Date().toISOString(),
   };
-  fs.writeFileSync(serverStateFile(configDir), `${JSON.stringify(state, null, 2)}\n`);
+  const target = serverStateFile(configDir);
+  const temporary = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporary, target);
 }
 
 function processLooksLikeFarmingServer(pid) {
@@ -664,15 +646,6 @@ function processOwnsListeningPort(pid, port) {
   }
 }
 
-function matchingProcessIdentity(expected, current) {
-  return Boolean(
-    current
-    && current.pid === Number(expected?.pid)
-    && current.processGroupId === Number(expected?.processGroupId)
-    && current.startedAt === String(expected?.startedAt || '')
-  );
-}
-
 async function assertServerProcessIdentity(configDir, pid, state) {
   const expected = state?.processIdentity;
   if (
@@ -694,7 +667,7 @@ async function assertServerProcessIdentity(configDir, pid, state) {
       `Refusing to stop Farming PID ${pid}: the live process identity does not match the server control metadata`,
     );
   }
-  if (!processOwnsListeningPort(pid, Number(state.port))) {
+  if (state.phase !== 'starting' && !processOwnsListeningPort(pid, Number(state.port))) {
     throw new Error(`Refusing to stop Farming PID ${pid}: the process does not own listening port ${state.port}`);
   }
   return current;
@@ -752,7 +725,8 @@ function isRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') return true;
     return false;
   }
 }
@@ -840,12 +814,31 @@ function waitForProcessStability(pid, durationMs = DEFAULT_SERVER_START_STABILIT
   });
 }
 
-function cleanupFailedDaemonStart(configDir, childPid) {
+async function cleanupFailedDaemonStart(configDir, childPid, expectedIdentity = null) {
   if (isRunning(childPid)) {
+    const expected = expectedIdentity || readServerState(configDir).processIdentity;
+    const current = readServerProcessIdentity(childPid);
+    if (!matchingProcessIdentity(expected, current)) {
+      throw new Error(`Failed Farming startup left live PID ${childPid} with an unproved identity; refusing to signal it`);
+    }
     try {
-      process.kill(childPid, 'SIGTERM');
-    } catch {
-      // The child may exit between the liveness check and the signal.
+      process.kill(childPid, 'SIGKILL');
+    } catch (error) {
+      if (error?.code === 'EPERM' || error?.code === 'EACCES') {
+        throw new Error(
+          `Failed Farming startup left Server PID ${childPid} running because cleanup lacks permission. `
+          + 'Stop it as the operating-system user that owns the process, then retry.',
+          { cause: error },
+        );
+      }
+      if (error?.code !== 'ESRCH') throw error;
+    }
+    const startedAt = Date.now();
+    while (matchingProcessIdentity(expected, readServerProcessIdentity(childPid))) {
+      if (Date.now() - startedAt >= 5_000) {
+        throw new Error(`Failed Farming startup left Server PID ${childPid} running after SIGKILL`);
+      }
+      await new Promise(resolve => setTimeout(resolve, SERVER_STOP_POLL_MS));
     }
   }
   if (readPid(configDir) !== childPid) return;
@@ -910,10 +903,31 @@ function waitForServer(env, timeoutMs = serverStartTimeoutMs(env), childPid = 0)
   });
 }
 
-function runServerInCurrentProcess() {
+async function runServerInCurrentProcess() {
   process.env = buildServerEnv();
+  ensureConfigDir(process.env.FARMING_CONFIG_DIR);
+  fs.writeFileSync(pidFile(process.env.FARMING_CONFIG_DIR), String(process.pid), { mode: 0o600 });
+  const processIdentity = await readServerProcessIdentity(process.pid);
+  if (!processIdentity) throw new Error('server process identity could not be committed before startup');
+  writeServerState(process.env.FARMING_CONFIG_DIR, process.env, process.pid, processIdentity, 'starting');
   const { startServer } = require('./server');
-  startServer();
+  const server = startServer();
+  server.once('listening', () => {
+    writeServerState(
+      process.env.FARMING_CONFIG_DIR,
+      process.env,
+      process.pid,
+      processIdentity,
+      'running',
+    );
+    const { pruneRuntimeDependencies } = require('./runtime-dependency-manager');
+    void pruneRuntimeDependencies({
+      configDir: process.env.FARMING_CONFIG_DIR,
+      env: process.env,
+    }).catch(error => {
+      console.warn(`Startup dependency cache cleanup failed: ${error?.message || error}`);
+    });
+  });
 }
 
 function runNativePtyHostInCurrentProcess() {
@@ -921,8 +935,24 @@ function runNativePtyHostInCurrentProcess() {
   startNativePtyHostProcess();
 }
 
+async function prepareStartupDependencies(env, options = {}) {
+  if (
+    options.force !== true
+    && (env.FARMING_SKIP_RUNTIME_PREPARE === '1' || env.NODE_ENV === 'test')
+  ) {
+    return { skipped: true };
+  }
+  const { prepareRuntimeDependencies } = require('./runtime-dependency-manager');
+  return prepareRuntimeDependencies({
+    configDir: env.FARMING_CONFIG_DIR,
+    env,
+  });
+}
+
 async function startForeground(parsed) {
-  const env = await adaptServerPort(buildServerEnv(parsed.env), parsed);
+  const env = buildServerEnv(parsed.env);
+  await prepareStartupDependencies(env);
+  await adaptServerPort(env, parsed);
   env[SERVER_MODE_ENV] = '1';
   ensureConfigDir(env.FARMING_CONFIG_DIR);
   const invocation = childInvocation(env);
@@ -952,13 +982,33 @@ async function startDaemon(parsed) {
   const existingPid = readPid(configDir);
   if (isRunning(existingPid)) {
     const state = readServerState(configDir);
-    if (state.port) env.PORT = String(state.port);
-    if (state.basePath) env.FARMING_BASE_PATH = state.basePath;
-    console.log(`Farming is already running (PID ${existingPid})`);
-    console.log(entryUrl(env));
-    return 0;
+    try {
+      if (state.processIdentity?.format === SERVER_PROCESS_IDENTITY_FORMAT) {
+        await assertServerProcessIdentity(configDir, existingPid, state);
+      } else {
+        await migrateLegacyServerIdentity(configDir, existingPid, state);
+      }
+    } catch (error) {
+      console.error(
+        `Farming PID ${existingPid} is live, but this config directory does not prove that it owns the Server: `
+        + `${error.message || error}`,
+      );
+      return 1;
+    }
+    if (state.phase === 'starting') {
+      console.warn(`Previous Farming startup (PID ${existingPid}) did not complete; replacing it.`);
+      const stopCode = await stopDaemon({ env });
+      if (stopCode !== 0) return stopCode;
+    } else {
+      if (state.port) env.PORT = String(state.port);
+      if (state.basePath) env.FARMING_BASE_PATH = state.basePath;
+      console.log(`Farming is already running (PID ${existingPid})`);
+      console.log(entryUrl(env));
+      return 0;
+    }
   }
 
+  await prepareStartupDependencies(env);
   const out = fs.openSync(logFile(configDir), 'a');
   const invocation = childInvocation(env);
   if (env.FARMING_DEBUG_CLI === '1') {
@@ -979,9 +1029,11 @@ async function startDaemon(parsed) {
   child.unref();
   fs.writeFileSync(pidFile(configDir), String(child.pid));
 
+  let processIdentity = null;
   try {
-    const processIdentity = await readServerProcessIdentity(child.pid);
+    processIdentity = await readServerProcessIdentity(child.pid);
     if (!processIdentity) throw new Error('server process identity could not be verified after launch');
+    writeServerState(configDir, env, child.pid, processIdentity, 'starting');
     await waitForServer(env, serverStartTimeoutMs(env), child.pid);
     await waitForProcessStability(child.pid, serverStartStabilityMs(env));
     await waitForServer(env, Math.min(serverStartTimeoutMs(env), 5_000), child.pid);
@@ -993,9 +1045,14 @@ async function startDaemon(parsed) {
     ) {
       throw new Error('server process identity changed during startup');
     }
-    writeServerState(configDir, env, child.pid, stableIdentity);
+    writeServerState(configDir, env, child.pid, stableIdentity, 'running');
   } catch (error) {
-    cleanupFailedDaemonStart(configDir, child.pid);
+    try {
+      await cleanupFailedDaemonStart(configDir, child.pid, processIdentity);
+    } catch (cleanupError) {
+      console.error(`${error.message}; cleanup failed: ${cleanupError.message || cleanupError}`);
+      return 1;
+    }
     console.error(error.message);
     const logs = tailFile(logFile(configDir), 80);
     if (logs) console.error(logs);
@@ -1031,8 +1088,15 @@ async function stopDaemon(parsed) {
     await migrateLegacyServerIdentity(configDir, pid, state);
   }
   try {
-    process.kill(pid, 'SIGTERM');
+    process.kill(pid, 'SIGKILL');
   } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') {
+      throw new Error(
+        `Farming cannot stop server ${pid} because this command lacks permission. `
+        + 'Run it as the operating-system user that owns the process (or as an administrator), then start Farming again.',
+        { cause: error },
+      );
+    }
     if (error?.code !== 'ESRCH') throw error;
   }
   await waitForDaemonStop(pid, port, { timeoutMs: serverStopTimeoutMs(env) });
@@ -1042,7 +1106,7 @@ async function stopDaemon(parsed) {
   return 0;
 }
 
-function statusDaemon(parsed) {
+async function statusDaemon(parsed) {
   const env = buildServerEnv(parsed.env);
   const configDir = env.FARMING_CONFIG_DIR;
   const pid = readPid(configDir);
@@ -1050,6 +1114,24 @@ function statusDaemon(parsed) {
     console.log('Farming is not running.');
     return 0;
   }
+  const state = readServerState(configDir);
+  try {
+    if (state.processIdentity?.format === SERVER_PROCESS_IDENTITY_FORMAT) {
+      await assertServerProcessIdentity(configDir, pid, state);
+    } else {
+      await migrateLegacyServerIdentity(configDir, pid, state);
+    }
+  } catch (error) {
+    console.error(
+      `Farming PID ${pid} is live, but this config directory does not prove that it owns the Server: `
+      + `${error.message || error}`,
+    );
+    return 1;
+  }
+  if (state.phase === 'starting') {
+    console.log(`Farming is starting (PID ${pid}). Run 'farming start' to replace an interrupted startup.`);
+    return 1;
+  }
   console.log(`Farming is running (PID ${pid})`);
   const logs = tailFile(logFile(configDir), 30);
   if (logs) console.log(logs);
@@ -1082,12 +1164,13 @@ function usage() {
   farming stop
   farming logs
   farming url
+  farming runtime prepare [--config-dir ~/.farming]
   farming review <git-dir> <old-revision> <new-revision|now> [--branch <branch>] [--no-open]
 
 Agent control commands are also available:
   farming skills
   farming capabilities [--json]
-  farming browser <capability|create|list|start|stop|snapshot|navigate|click|fill|type|press|scroll|screenshot> ...
+  farming browser ...
   farming list [--json] [--parent <agentId>]
   farming spawn --workspace <repo> -- <command...>
   farming output <agentId> [--tail <chars>]
@@ -1106,7 +1189,12 @@ async function run(argv = process.argv.slice(2)) {
   }
 
   if (argv[0] === PACKAGED_CODEX_ACP_ARG) {
-    runPackagedCodexAcp();
+    await runPackagedCodexAcp();
+    return 0;
+  }
+
+  if (argv[0] === PACKAGED_CLAUDE_ACP_ARG) {
+    await runPackagedClaudeAcp();
     return 0;
   }
 
@@ -1123,7 +1211,7 @@ async function run(argv = process.argv.slice(2)) {
   }
 
   if (process.env[SERVER_MODE_ENV] === '1' || argv[0] === SERVER_MODE_ARG) {
-    runServerInCurrentProcess();
+    await runServerInCurrentProcess();
     return 0;
   }
 
@@ -1132,6 +1220,14 @@ async function run(argv = process.argv.slice(2)) {
     return runBrowserCli(argv.slice(1));
   }
 
+  if (argv[0] === 'runtime' && argv[1] === 'prepare') {
+    const parsed = parseServerArgs(['start', ...argv.slice(2)]);
+    const env = buildServerEnv(parsed.env);
+    const result = await prepareStartupDependencies(env, { force: true });
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
   if (SERVER_BACKED_CONTROL_COMMANDS.has(argv[0])) {
     return runServerBackedControlCli(argv);
   }

package/backend/farming-cli.js

@@ -314,13 +314,15 @@ function farmingCapabilities(browser) {
       id: 'browser',
       state,
       summary: state === 'available'
-        ? 'An installed system Chromium Browser can be created or attached in Farming on demand.'
-        : (browser?.message || 'System Browser integration is unavailable in Farming.'),
+        ? (browser?.browser?.kind === 'external-cdp'
+            ? 'Default browser path for web tasks. An externally managed CDP Browser can be created or attached as a shared, user-visible Farming Resource.'
+            : 'Default browser path for web tasks. An installed system Chromium Browser can be created or attached as a shared, user-visible Farming Resource.')
+        : (browser?.message || 'Browser integration is unavailable in Farming.'),
       commands: state === 'available'
         ? {
             list: 'farming browser list',
             create: 'farming browser create',
-            help: 'farming browser --help',
+            workflow: 'farming browser help workflow',
           }
         : {},
     }],

package/backend/index-html.js

@@ -41,7 +41,20 @@ function appendIndexHtmlAssetToken(html, token) {
   });
 }
 
+function applyIndexHtmlAppearance(html, appearance) {
+  const normalizedAppearance = ['light', 'dark'].includes(appearance) ? appearance : 'system';
+  const source = String(html || '');
+  if (/\bdata-appearance-preference="[^"]*"/i.test(source)) {
+    return source.replace(
+      /\bdata-appearance-preference="[^"]*"/i,
+      `data-appearance-preference="${normalizedAppearance}"`
+    );
+  }
+  return source.replace(/<html\b/i, `<html data-appearance-preference="${normalizedAppearance}"`);
+}
+
 module.exports = {
+  applyIndexHtmlAppearance,
   normalizeBasePath,
   routePath,
   rewriteIndexHtmlForBasePath,

package/backend/main-agent-skills.js

@@ -61,16 +61,12 @@ const MAIN_AGENT_SKILLS = [
     id: 'browser-resource',
     name: '系统浏览器操作',
     trigger: '用户要求打开、查看或操作 Farming Project 下的 Browser Resource，或者需要绕过静态 HTML Viewer 限制验证真实网页时',
-    summary: '通过 Farming Browser ID 操作用户当前看到的同一个 Headless 系统浏览器；先 Snapshot 获取当前 Ref，再进行点击或输入，页面变化后重新 Snapshot。',
+    summary: '通过 Farming Browser ID 操作用户当前看到的同一个系统浏览器；先走 Browser 的渐进式帮助和标准 Workflow，只在需要时展开具体问题域与原子命令。',
     commands: [
-      'farming browser list --workspace <repo>',
-      'farming browser start <browser-id>',
-      'farming browser snapshot <browser-id>',
-      'farming browser navigate <browser-id> <url>',
-      'farming browser click <browser-id> <ref-or-css=selector>',
-      'farming browser fill <browser-id> <ref-or-css=selector> <text>',
-      'farming browser screenshot <browser-id> <output.png>',
-      'farming browser stop <browser-id>',
+      'farming capabilities',
+      'farming browser list',
+      'farming browser help workflow',
+      'farming browser help <lifecycle|navigation|interaction|inspection|debugging|state|files>',
     ],
   },
   {
@@ -153,7 +149,7 @@ function renderMainAgentSkills() {
   });
 
   lines.push('Rules:');
-  lines.push('- Use `farming browser` only for Browser Resources already in the user-selected Project scope; take a new snapshot after navigation or DOM-changing actions.');
+  lines.push('- Use `farming browser` only for Browser Resources already in the user-selected Project scope; follow `farming browser help workflow`, and reveal only the help topic or command needed for the current step.');
   lines.push('- Use `farming memory report` when you need recent context from local agent memories.');
   lines.push('- Use “牧场除虫计划” when the user asks for systematic bug hunting across a directory or module tree.');
   lines.push('- Before spawning child agents for pest control, map modules and module protocols first; do not send overlapping or vague tasks.');

package/backend/npm-update-helper.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
+const {
+  matchingProcessIdentity,
+  readServerProcessIdentity,
+} = require('./server-process-identity');
 
 function writeJsonAtomic(filePath, value) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -42,18 +46,37 @@ function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') return true;
     return false;
   }
 }
 
-async function stopProcess(pid, timeoutMs = 15_000) {
+async function stopProcess(pid, expectedIdentity, timeoutMs = 15_000) {
   if (!isProcessRunning(pid)) return;
-  process.kill(pid, 'SIGTERM');
+  const currentIdentity = await readServerProcessIdentity(pid);
+  if (!matchingProcessIdentity(expectedIdentity, currentIdentity)) {
+    throw new Error(`Refusing to stop Farming server ${pid}: process identity changed`);
+  }
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch (error) {
+    if (error?.code === 'EPERM' || error?.code === 'EACCES') {
+      throw new Error(
+        `Farming cannot stop server ${pid} because the update helper lacks permission. `
+        + 'Use the operating-system user that owns this process (or an administrator) to stop and restart Farming, then retry the update.',
+        { cause: error },
+      );
+    }
+    if (error?.code !== 'ESRCH') throw error;
+  }
   const startedAt = Date.now();
-  while (isProcessRunning(pid)) {
+  while (matchingProcessIdentity(expectedIdentity, await readServerProcessIdentity(pid))) {
     if (Date.now() - startedAt >= timeoutMs) {
-      throw new Error(`Farming server ${pid} did not stop before timeout`);
+      throw new Error(
+        `Farming server ${pid} did not exit after SIGKILL. `
+        + 'Stop and restart Farming manually, then retry the update.',
+      );
     }
     await new Promise(resolve => setTimeout(resolve, 100));
   }
@@ -200,9 +223,23 @@ async function prepareNpmUpdate(payload) {
     fs.mkdirSync(payload.stagingPrefix, { recursive: true });
     await installPackage(payload, payload.targetVersion, payload.stagingPrefix);
     verifyInstalledVersion(payload, payload.targetVersion, payload.stagingPackageRoot);
+    writeJsonAtomic(payload.stateFile, stateFor(payload, 'preparing-runtimes'));
+    appendLog(payload.logPath, `Preparing Farming ${payload.targetVersion} startup dependencies`);
+    await runCommand(payload.nodePath, [
+      path.join(payload.stagingPackageRoot, 'bin', 'farming'),
+      'runtime',
+      'prepare',
+      '--config-dir',
+      payload.configDir,
+    ], {
+      cwd: payload.configDir,
+      env: commandEnvironment(),
+      logPath: payload.logPath,
+    });
     const preparedAt = new Date().toISOString();
     writeJsonAtomic(payload.stateFile, stateFor(payload, 'ready-to-restart', {
       preparedAt,
+      runtimePreparedAt: preparedAt,
     }));
     appendLog(payload.logPath, `Farming ${payload.targetVersion} is ready to restart`);
   } catch (error) {
@@ -237,7 +274,7 @@ async function applyNpmUpdate(payload) {
       preparedAt: payload.preparedAt,
     }));
     await new Promise(resolve => setTimeout(resolve, 1_000));
-    await stopProcess(Number(payload.serverPid));
+    await stopProcess(Number(payload.serverPid), payload.serverProcessIdentity);
     stoppedOldServer = true;
     fs.renameSync(payload.packageRoot, backupRoot);
     movedOldPackage = true;

package/backend/provider-adapters.js

@@ -213,6 +213,14 @@ function codexAcpEnvironment(options = {}) {
   return env;
 }
 
+function claudeAcpEnvironment(options = {}) {
+  const env = { ...(options.env || process.env) };
+  if (options.executable && !env.CLAUDE_CODE_EXECUTABLE) {
+    env.CLAUDE_CODE_EXECUTABLE = options.executable;
+  }
+  return env;
+}
+
 const PROVIDER_ADAPTERS = Object.freeze([
   {
     id: 'codex',
@@ -250,6 +258,7 @@ const PROVIDER_ADAPTERS = Object.freeze([
       version: '0.59.0',
       forkMode: 'target-process',
     },
+    prepareAcpEnvironment: claudeAcpEnvironment,
     capabilities: {
       runtimeSwitch: true,
       terminalProfile: false,
@@ -378,6 +387,7 @@ function isFreshAcpSessionSource(provider, source) {
 }
 
 module.exports = {
+  claudeAcpEnvironment,
   getProviderAdapter,
   applyProviderHomeEnvironment,
   isFreshAcpSessionSource,