farming-code 2.2.23 → 2.2.28

package/backend/atomic-json-store.js

@@ -0,0 +1,37 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+function atomicWriteJson(file, value, options = {}) {
+  const fileSystem = options.fileSystem || fs;
+  const temporaryFile = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  const suffix = options.trailingNewline ? '\n' : '';
+  let descriptor = null;
+
+  fileSystem.mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    descriptor = fileSystem.openSync(temporaryFile, 'wx', options.mode);
+    fileSystem.writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}${suffix}`, 'utf8');
+    fileSystem.fdatasyncSync(descriptor);
+    fileSystem.closeSync(descriptor);
+    descriptor = null;
+    fileSystem.renameSync(temporaryFile, file);
+  } finally {
+    if (descriptor !== null) {
+      try {
+        fileSystem.closeSync(descriptor);
+      } catch {
+        // Preserve the original write failure.
+      }
+    }
+    try {
+      fileSystem.unlinkSync(temporaryFile);
+    } catch {
+      // A successful rename already removed the temporary path.
+    }
+  }
+}
+
+module.exports = {
+  atomicWriteJson,
+};

package/backend/cli-agents.js

@@ -49,7 +49,8 @@ const CLI_AGENTS = [
     permissions: {
       supportsDangerousSkip: true,
       dangerousSkipArgs: ['--dangerously-skip-permissions']
-    }
+    },
+    systemPromptArg: '--append-system-prompt'
   },
   {
     name: 'bash',
@@ -459,12 +460,13 @@ function resolveLaunchCommand(command, options = {}) {
     launchArgs.unshift('--permission-mode', claudePermissionMode);
   }
 
-  if (
-    options.mainAgentSystemPrompt &&
-    spec &&
-    typeof spec.systemPromptArg === 'string'
-  ) {
-    launchArgs.push(spec.systemPromptArg, options.mainAgentSystemPrompt);
+  const systemPrompt = [options.farmingSystemPrompt, options.mainAgentSystemPrompt]
+    .filter(value => typeof value === 'string' && value.trim())
+    .join('\n\n');
+  if (systemPrompt && spec && typeof spec.systemPromptArg === 'string') {
+    launchArgs.push(spec.systemPromptArg, systemPrompt);
+  } else if (systemPrompt && spec?.name === 'codex') {
+    launchArgs.unshift('-c', `developer_instructions=${JSON.stringify(systemPrompt)}`);
   }
 
   return {

package/backend/config-manager.js

@@ -1,7 +1,9 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { atomicWriteJson } = require('./atomic-json-store');
 const { ensureMainAgentSkillFiles } = require('./main-agent-skills');
+const { ensureFarmingAgentBootstrapFile } = require('./farming-agent-bootstrap');
 const { normalizeClaudeModelValue } = require('./claude-settings');
 const { isTemporaryProviderSessionId } = require('./provider-session-id');
 const { FarmingSessionStore, MAX_MAIN_PAGE_SESSION_KEYS } = require('./farming-session-store');
@@ -68,6 +70,8 @@ const DEFAULT_CRT_TERMINAL_FONT_SIZE = 15;
 const MIN_CRT_TERMINAL_FONT_SIZE = 10;
 const MAX_CRT_TERMINAL_FONT_SIZE = 20;
 const MAX_INSTANCE_NAME_LENGTH = 80;
+const MAX_PROJECT_OPERATIONS = 32;
+const PROJECT_OPERATION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,160}$/;
 
 const PERSISTED_SETTING_KEYS = new Set([
   'workspace',
@@ -76,12 +80,14 @@ const PERSISTED_SETTING_KEYS = new Set([
   'projectWorkspaces',
   'pinnedProjectWorkspaces',
   'projectNames',
+  'projectOperations',
   'instanceName',
   'theme',
   'appearance',
   'language',
   'heartbeatInterval',
   'dangerouslySkipAgentPermissionsByDefault',
+  'browserExtensionEnabled',
   'crtSkinEffectsEnabled',
   'crtDynamicHeatEnabled',
   'crtTerminalFontSize',
@@ -113,8 +119,8 @@ function cloneAgentHomes(agentHomes) {
 }
 
 class ConfigManager {
-  constructor() {
-    this.farmingDir = storageLayout.farmingConfigDir();
+  constructor(options = {}) {
+    this.farmingDir = options.configDir || storageLayout.farmingConfigDir();
     this.settingsFile = storageLayout.settingsFile(this.farmingDir);
     this.sessionStore = new FarmingSessionStore(this.farmingDir, {
       normalizeMainPageSessionKeys: keys => this.normalizeMainPageSessionKeys(keys),
@@ -122,6 +128,7 @@ class ConfigManager {
     this.runHistoryStore = new RunHistoryStore(this.farmingDir, {
       normalizeTaskHistory: entries => this.normalizeTaskHistory(entries),
     });
+    this.writeJson = typeof options.writeJson === 'function' ? options.writeJson : atomicWriteJson;
     this.settings = null;
   }
 
@@ -221,7 +228,7 @@ class ConfigManager {
       const expanded = this.expandWorkspacePath(entry);
       if (!expanded) continue;
       const resolved = path.resolve(expanded);
-      if (resolved === path.parse(resolved).root || this.isInternalWorkspace(resolved)) continue;
+      if (this.isInternalWorkspace(resolved)) continue;
       let canonical = resolved;
       try {
         canonical = fs.realpathSync(resolved);
@@ -305,12 +312,14 @@ class ConfigManager {
         projectWorkspaces: [],
         pinnedProjectWorkspaces: [],
         projectNames: {},
+        projectOperations: {},
         instanceName: '',
         theme: 'terminal',
         appearance: 'system',
         language: 'en',
         heartbeatInterval: 1000,
         dangerouslySkipAgentPermissionsByDefault: false,
+        browserExtensionEnabled: false,
         crtSkinEffectsEnabled: true,
         crtDynamicHeatEnabled: false,
         crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
@@ -329,7 +338,7 @@ class ConfigManager {
         codexModelPreset: 'gpt-5.5:xhigh',
         version: '2'
       };
-      fs.writeFileSync(this.settingsFile, JSON.stringify(defaultSettings, null, 2));
+      this.writeSettingsFile(defaultSettings);
       console.log('Created default settings:', this.settingsFile);
     }
     
@@ -341,12 +350,14 @@ class ConfigManager {
       projectWorkspaces: [],
       pinnedProjectWorkspaces: [],
       projectNames: {},
+      projectOperations: {},
       instanceName: '',
       theme: 'terminal',
       appearance: 'system',
       language: 'en',
       heartbeatInterval: 1000,
       dangerouslySkipAgentPermissionsByDefault: false,
+      browserExtensionEnabled: false,
       crtSkinEffectsEnabled: true,
       crtDynamicHeatEnabled: false,
       crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
@@ -391,6 +402,7 @@ class ConfigManager {
     this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
     this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
     this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
+    this.settings.projectOperations = this.normalizeProjectOperations(this.settings.projectOperations);
     this.settings.instanceName = this.normalizeInstanceName(this.settings.instanceName);
     this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
     if (this.settings.updateUrl === LEGACY_DEFAULT_UPDATE_URL || this.settings.updateUrl === API_DEFAULT_UPDATE_URL) {
@@ -407,20 +419,22 @@ class ConfigManager {
     this.runHistoryStore.init({ legacyTaskHistory });
     this.settings.appearance = this.normalizeAppearance(this.settings.appearance);
     this.settings.language = this.normalizeLanguage(this.settings.language);
+    this.settings.browserExtensionEnabled = this.settings.browserExtensionEnabled === true;
     this.settings.crtSkinEffectsEnabled = this.settings.crtSkinEffectsEnabled !== false;
     this.settings.crtDynamicHeatEnabled = this.settings.crtDynamicHeatEnabled === true;
     this.settings.crtTerminalFontSize = this.normalizeCrtTerminalFontSize(this.settings.crtTerminalFontSize);
     this.normalizeAgentLaunchSettings(launchRawSettings);
     this.pruneUnknownSettings();
     ensureMainAgentSkillFiles(this.farmingDir);
+    ensureFarmingAgentBootstrapFile(this.farmingDir);
     this.writeSettingsFile();
     console.log('Loaded settings:', this.settings);
   }
 
-  pruneUnknownSettings() {
-    for (const key of Object.keys(this.settings || {})) {
+  pruneUnknownSettings(settings = this.settings) {
+    for (const key of Object.keys(settings || {})) {
       if (!PERSISTED_SETTING_KEYS.has(key)) {
-        delete this.settings[key];
+        delete settings[key];
       }
     }
   }
@@ -498,16 +512,59 @@ class ConfigManager {
     return normalized;
   }
 
+  normalizeProjectOperations(projectOperations) {
+    if (!projectOperations || typeof projectOperations !== 'object' || Array.isArray(projectOperations)) return {};
+    const entries = Object.entries(projectOperations)
+      .filter(([id, operation]) => (
+        PROJECT_OPERATION_ID_PATTERN.test(id)
+        && operation
+        && typeof operation === 'object'
+        && ['create-worktree', 'delete-worktree'].includes(operation.type)
+        && ['pending', 'unknown', 'succeeded', 'failed', 'blocked'].includes(operation.state)
+      ))
+      .sort((left, right) => (Number(right[1].updatedAt) || 0) - (Number(left[1].updatedAt) || 0))
+      .map(([id, operation]) => [id, {
+        id,
+        type: operation.type,
+        state: operation.state,
+        signature: typeof operation.signature === 'string' ? operation.signature.slice(0, 128) : '',
+        request: operation.request && typeof operation.request === 'object'
+          ? JSON.parse(JSON.stringify(operation.request))
+          : {},
+        result: operation.result && typeof operation.result === 'object'
+          ? JSON.parse(JSON.stringify(operation.result))
+          : null,
+        error: typeof operation.error === 'string' ? operation.error.slice(0, 2000) : '',
+        startedAt: Number(operation.startedAt) || 0,
+        updatedAt: Number(operation.updatedAt) || 0,
+        finishedAt: Number(operation.finishedAt) || null,
+      }]);
+    const unresolved = entries.filter(([, operation]) => (
+      ['pending', 'unknown', 'blocked'].includes(operation.state)
+    ));
+    const terminal = entries.filter(([, operation]) => (
+      !['pending', 'unknown', 'blocked'].includes(operation.state)
+    ));
+    return Object.fromEntries([
+      ...unresolved,
+      ...terminal.slice(0, Math.max(0, MAX_PROJECT_OPERATIONS - unresolved.length)),
+    ]);
+  }
+
   setProjectName(workspace, name) {
     const normalized = this.normalizeProjectNames({ [workspace]: name });
     const entry = Object.entries(normalized)[0];
     if (!entry) throw new Error('Project workspace and name are required');
     const [normalizedWorkspace, normalizedName] = entry;
-    this.settings.projectNames = {
-      ...this.settings.projectNames,
-      [normalizedWorkspace]: normalizedName,
+    const nextSettings = {
+      ...this.settings,
+      projectNames: {
+        ...this.settings.projectNames,
+        [normalizedWorkspace]: normalizedName,
+      },
     };
-    this.writeSettingsFile();
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
     return {
       workspace: normalizedWorkspace,
       name: normalizedName,
@@ -668,23 +725,23 @@ class ConfigManager {
     return merged;
   }
 
-  applyCodexProfileToLegacySettings(codexProfile) {
-    this.settings.codexApprovalMode = codexProfile.approvalMode;
-    this.settings.codexModel = codexProfile.model;
-    this.settings.codexReasoningEffort = codexProfile.reasoningEffort;
-    this.settings.codexServiceTier = codexProfile.serviceTier;
-    this.settings.codexModelPreset = codexProfile.modelPreset;
+  applyCodexProfileToLegacySettings(codexProfile, settings = this.settings) {
+    settings.codexApprovalMode = codexProfile.approvalMode;
+    settings.codexModel = codexProfile.model;
+    settings.codexReasoningEffort = codexProfile.reasoningEffort;
+    settings.codexServiceTier = codexProfile.serviceTier;
+    settings.codexModelPreset = codexProfile.modelPreset;
   }
 
-  normalizeAgentLaunchSettings(rawSettings = {}) {
+  normalizeAgentLaunchSettings(rawSettings = {}, settings = this.settings) {
     const changedProfiles = this.getChangedAgentLaunchProfiles(rawSettings);
-    const mergedProfiles = this.mergeAgentLaunchProfiles(this.settings.agentLaunchProfiles, changedProfiles);
-    this.settings.agentLaunchProfiles = {
+    const mergedProfiles = this.mergeAgentLaunchProfiles(settings.agentLaunchProfiles, changedProfiles);
+    settings.agentLaunchProfiles = {
       codex: this.normalizeCodexLaunchProfile(mergedProfiles.codex, changedProfiles.codex || {}),
       claude: this.normalizeClaudeLaunchProfile(mergedProfiles.claude),
     };
-    this.settings.defaultLaunchAgent = this.normalizeDefaultLaunchAgent(this.settings.defaultLaunchAgent);
-    this.applyCodexProfileToLegacySettings(this.settings.agentLaunchProfiles.codex);
+    settings.defaultLaunchAgent = this.normalizeDefaultLaunchAgent(settings.defaultLaunchAgent);
+    this.applyCodexProfileToLegacySettings(settings.agentLaunchProfiles.codex, settings);
   }
   
   getWorkspace() {
@@ -760,8 +817,10 @@ class ConfigManager {
   }
 
   getSettings() {
+    const publicSettings = { ...this.settings };
+    delete publicSettings.projectOperations;
     return {
-      ...this.settings,
+      ...publicSettings,
       instanceName: this.getInstanceName(),
       workspace: this.farmingDir,
       mainPageSessionKeys: this.getMainPageSessionKeys(),
@@ -783,7 +842,6 @@ class ConfigManager {
     }
     if (
       !canonicalWorkspace
-      || canonicalWorkspace === path.parse(canonicalWorkspace).root
       || this.isInternalWorkspace(canonicalWorkspace)
     ) {
       throw new Error('Project workspace is invalid or unavailable');
@@ -860,6 +918,64 @@ class ConfigManager {
     }
   }
 
+  getProjectOperation(requestId) {
+    const id = String(requestId || '').trim();
+    if (!PROJECT_OPERATION_ID_PATTERN.test(id)) return null;
+    const operation = this.settings.projectOperations?.[id];
+    return operation ? JSON.parse(JSON.stringify(operation)) : null;
+  }
+
+  commitProjectOperation(operation, membership = {}) {
+    const normalized = this.normalizeProjectOperations({ [operation?.id]: operation });
+    const nextOperation = normalized[operation?.id];
+    if (!nextOperation) throw new Error('Project operation is invalid');
+    const existingOperation = this.settings.projectOperations?.[nextOperation.id];
+    const unresolvedCount = Object.values(this.settings.projectOperations || {})
+      .filter(candidate => ['pending', 'unknown', 'blocked'].includes(candidate.state)).length;
+    if (!existingOperation && nextOperation.state === 'pending' && unresolvedCount >= MAX_PROJECT_OPERATIONS) {
+      throw new Error('Too many unresolved Project operations require reconciliation');
+    }
+    const nextOperations = this.normalizeProjectOperations({
+      ...this.settings.projectOperations,
+      [nextOperation.id]: nextOperation,
+    });
+    const nextSettings = {
+      ...this.settings,
+      projectOperations: nextOperations,
+    };
+    if (membership.mountWorkspace) {
+      const mounted = this.normalizeProjectWorkspaces([
+        membership.mountWorkspace,
+        ...(this.settings.projectWorkspaces || []),
+      ]);
+      nextSettings.projectWorkspaces = mounted;
+      nextSettings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(
+        this.settings.pinnedProjectWorkspaces,
+      );
+    }
+    if (membership.removeWorkspace) {
+      const expanded = this.expandWorkspacePath(membership.removeWorkspace);
+      const resolved = expanded ? path.resolve(expanded) : '';
+      const candidates = new Set([expanded, resolved].filter(Boolean));
+      try {
+        candidates.add(fs.realpathSync(resolved));
+      } catch {
+        // A deleted worktree is removed by its last canonical path.
+      }
+      nextSettings.projectWorkspaces = (this.settings.projectWorkspaces || [])
+        .filter(workspace => !candidates.has(workspace));
+      nextSettings.pinnedProjectWorkspaces = (this.settings.pinnedProjectWorkspaces || [])
+        .filter(workspace => !candidates.has(workspace));
+    }
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
+    return {
+      operation: JSON.parse(JSON.stringify(nextOperation)),
+      projectWorkspaces: [...(nextSettings.projectWorkspaces || [])],
+      pinnedProjectWorkspaces: [...(nextSettings.pinnedProjectWorkspaces || [])],
+    };
+  }
+
   getMainPageSessionKeys() {
     return this.sessionStore ? this.sessionStore.getMainPageSessionKeys() : [];
   }
@@ -904,19 +1020,8 @@ class ConfigManager {
     return this.runHistoryStore ? this.runHistoryStore.getEntries() : [];
   }
 
-  writeSettingsFile() {
-    fs.mkdirSync(this.farmingDir, { recursive: true });
-    const tempFile = `${this.settingsFile}.${process.pid}.${Date.now()}.tmp`;
-    try {
-      fs.writeFileSync(tempFile, JSON.stringify(this.settings, null, 2));
-      fs.renameSync(tempFile, this.settingsFile);
-    } finally {
-      try {
-        fs.unlinkSync(tempFile);
-      } catch {
-        // A successful rename already removed the temporary path.
-      }
-    }
+  writeSettingsFile(settings = this.settings) {
+    this.writeJson(this.settingsFile, settings);
   }
 
   appendTaskHistory(entry) {
@@ -930,6 +1035,7 @@ class ConfigManager {
       : undefined;
     const settingsPatch = { ...(newSettings || {}) };
     delete settingsPatch.mainPageSessionKeys;
+    delete settingsPatch.projectOperations;
     const incomingTaskHistory = Object.prototype.hasOwnProperty.call(settingsPatch, 'taskHistory')
       ? settingsPatch.taskHistory
       : undefined;
@@ -937,38 +1043,41 @@ class ConfigManager {
     const previousMainWorkspace = this.settings.lastMainWorkspace || this.farmingDir;
     const previousProfiles = this.settings.agentLaunchProfiles || {};
     const incomingProfiles = settingsPatch.agentLaunchProfiles || {};
-    this.settings = {
+    const nextSettings = {
       ...this.settings,
       ...settingsPatch,
       agentLaunchProfiles: this.mergeAgentLaunchProfiles(previousProfiles, incomingProfiles),
       workspace: this.farmingDir
     };
-    this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, previousMainWorkspace);
-    this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
-    this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
-    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
-    this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
-    this.settings.instanceName = this.normalizeInstanceName(this.settings.instanceName);
-    this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
-    this.settings.updateUrl = this.normalizeUpdateUrl(this.settings.updateUrl);
-    this.settings.searchTimeoutMs = this.normalizeSearchTimeoutMs(this.settings.searchTimeoutMs);
-    delete this.settings.codexRuntimeMode;
-    delete this.settings.mainPageSessionKeys;
-    delete this.settings.taskHistory;
+    nextSettings.lastMainWorkspace = this.normalizeMainWorkspace(nextSettings.lastMainWorkspace, previousMainWorkspace);
+    nextSettings.workspaceHistory = this.normalizeWorkspaceHistory(nextSettings.workspaceHistory);
+    nextSettings.projectWorkspaces = this.normalizeProjectWorkspaces(nextSettings.projectWorkspaces);
+    nextSettings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(nextSettings.pinnedProjectWorkspaces);
+    nextSettings.projectNames = this.normalizeProjectNames(nextSettings.projectNames);
+    nextSettings.projectOperations = this.normalizeProjectOperations(nextSettings.projectOperations);
+    nextSettings.instanceName = this.normalizeInstanceName(nextSettings.instanceName);
+    nextSettings.agentHomes = this.normalizeAgentHomes(nextSettings.agentHomes);
+    nextSettings.updateUrl = this.normalizeUpdateUrl(nextSettings.updateUrl);
+    nextSettings.searchTimeoutMs = this.normalizeSearchTimeoutMs(nextSettings.searchTimeoutMs);
+    delete nextSettings.codexRuntimeMode;
+    delete nextSettings.mainPageSessionKeys;
+    delete nextSettings.taskHistory;
     if (incomingMainPageSessionKeys !== undefined) {
       this.setMainPageSessionKeys(incomingMainPageSessionKeys);
     }
     if (incomingTaskHistory !== undefined && this.runHistoryStore) {
       this.runHistoryStore.setEntries(incomingTaskHistory);
     }
-    this.settings.appearance = this.normalizeAppearance(this.settings.appearance);
-    this.settings.language = this.normalizeLanguage(this.settings.language);
-    this.settings.crtSkinEffectsEnabled = this.settings.crtSkinEffectsEnabled !== false;
-    this.settings.crtDynamicHeatEnabled = this.settings.crtDynamicHeatEnabled === true;
-    this.settings.crtTerminalFontSize = this.normalizeCrtTerminalFontSize(this.settings.crtTerminalFontSize);
-    this.normalizeAgentLaunchSettings(settingsPatch);
-    this.pruneUnknownSettings();
-    this.writeSettingsFile();
+    nextSettings.appearance = this.normalizeAppearance(nextSettings.appearance);
+    nextSettings.language = this.normalizeLanguage(nextSettings.language);
+    nextSettings.browserExtensionEnabled = nextSettings.browserExtensionEnabled === true;
+    nextSettings.crtSkinEffectsEnabled = nextSettings.crtSkinEffectsEnabled !== false;
+    nextSettings.crtDynamicHeatEnabled = nextSettings.crtDynamicHeatEnabled === true;
+    nextSettings.crtTerminalFontSize = this.normalizeCrtTerminalFontSize(nextSettings.crtTerminalFontSize);
+    this.normalizeAgentLaunchSettings(settingsPatch, nextSettings);
+    this.pruneUnknownSettings(nextSettings);
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
   }
 }
 

package/backend/control-api.js

@@ -419,9 +419,10 @@ function createControlRouter(agentManager, options = {}) {
 
   router.delete('/agents/:agentId', async (req, res) => {
     const agentId = req.params.agentId;
+    const recordHistory = req.query?.recordHistory !== '0';
     let requested;
     try {
-      requested = await agentManager.requestKillAgent(agentId);
+      requested = await agentManager.requestKillAgent(agentId, { recordHistory });
     } catch (error) {
       res.status(503).json({
         error: error?.message || 'Agent lifecycle recovery is unavailable',

package/backend/farming-agent-bootstrap.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+const storageLayout = require('./storage-layout');
+
+const sourceFile = path.join(__dirname, 'farming-agent-bootstrap.zh_cn.md');
+
+function renderFarmingAgentBootstrap() {
+  return fs.readFileSync(sourceFile, 'utf8').trim();
+}
+
+function ensureFarmingAgentBootstrapFile(configDir) {
+  const target = storageLayout.farmingAgentBootstrapFile(configDir);
+  const content = `${renderFarmingAgentBootstrap()}\n`;
+  try {
+    if (fs.readFileSync(target, 'utf8') === content) return target;
+  } catch {
+    // Install the current Farming-owned prompt below.
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, content, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temporary, target);
+  return target;
+}
+
+function appendOpenCodeBootstrap(env, bootstrapFile) {
+  const next = { ...env };
+  let config = {};
+  if (next.OPENCODE_CONFIG_CONTENT) {
+    try {
+      const parsed = JSON.parse(next.OPENCODE_CONFIG_CONTENT);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) config = parsed;
+    } catch {
+      return next;
+    }
+  }
+  const instructions = Array.isArray(config.instructions)
+    ? config.instructions.filter(value => typeof value === 'string')
+    : [];
+  config.instructions = [...new Set([...instructions, bootstrapFile])];
+  next.OPENCODE_CONFIG_CONTENT = JSON.stringify(config);
+  return next;
+}
+
+module.exports = {
+  appendOpenCodeBootstrap,
+  ensureFarmingAgentBootstrapFile,
+  renderFarmingAgentBootstrap,
+};

package/backend/farming-agent-bootstrap.zh_cn.md

@@ -0,0 +1,5 @@
+你由 Farming 启动并托管。Farming 是一个供用户同时运行、观察和管理多个 AI 编程 Agent 的工作区，统一承载 Agent 对话、终端、项目文件，以及可由用户和 Agent 共同使用的扩展资源。
+
+Farming 可能为当前会话提供系统浏览器、Agent 协作等能力。能力是否可用以 `farming capabilities` 的实时结果为准，不要自行假设。
+
+当任务需要查看或操作网页时，你可以主动查询能力，并自行决定是否创建新的 Farming Browser 或连接已有 Browser。Farming Browser 会显示在用户界面中，用户和你操作的是同一个浏览器会话。只启用完成当前任务所需的能力。

package/backend/farming-app-cli.js

@@ -22,8 +22,8 @@ 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', 'memory', 'report', 'list', 'spawn', 'output', 'send', 'kill']);
-const SERVER_BACKED_CONTROL_COMMANDS = new Set(['list', 'spawn', 'output', 'send', 'kill']);
+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']);
 
 function defaultConfigDir(env = process.env) {
   return storageLayout.farmingConfigDir(env);
@@ -1086,6 +1086,8 @@ function usage() {
 
 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 list [--json] [--parent <agentId>]
   farming spawn --workspace <repo> -- <command...>
   farming output <agentId> [--tail <chars>]
@@ -1125,6 +1127,11 @@ async function run(argv = process.argv.slice(2)) {
     return 0;
   }
 
+  if (argv[0] === 'browser') {
+    const { run: runBrowserCli } = require('../extensions/browser/bin/farming-browser');
+    return runBrowserCli(argv.slice(1));
+  }
+
   if (SERVER_BACKED_CONTROL_COMMANDS.has(argv[0])) {
     return runServerBackedControlCli(argv);
   }

package/backend/farming-cli.js

@@ -8,6 +8,7 @@ const storageLayout = require('./storage-layout');
 function usage() {
   return `Usage:
   farming skills
+  farming capabilities [--json]
   farming memory report [--period today|yesterday|week] [--since <time>] [--until <time>] [--home <path>] [--json]
   farming list [--json] [--parent <agentId>]
   farming spawn [--workspace <path>] [--task <text>] [--parent <agentId>] [--json] -- <command...>
@@ -20,6 +21,7 @@ Examples:
   farming memory report --period today
   farming memory report --period week --json
   farming skills
+  farming capabilities
   farming list --parent "$FARMING_AGENT_ID"
   farming output agent-123 --tail 2000
   farming send agent-123 "Please run the focused tests"`;
@@ -76,6 +78,13 @@ function parseArgs(argv) {
     return { command };
   }
 
+  if (command === 'capabilities') {
+    if (rest.some(arg => arg !== '--json')) {
+      throw new Error('capabilities accepts only --json');
+    }
+    return { command, options: { json: rest.includes('--json') } };
+  }
+
   if (command === 'memory' || command === 'report') {
     const subcommand = command === 'memory' ? rest.shift() : 'report';
     if (subcommand !== 'report') {
@@ -293,6 +302,42 @@ function formatAgent(agent) {
   return `${marker} ${agent.id} | ${agent.command} | ${agent.status} | ${agent.cwd}${parent}${task}`;
 }
 
+function farmingCapabilities(browser) {
+  const state = browser?.available === true
+    ? 'available'
+    : (browser?.enabled === true ? 'unavailable' : 'disabled');
+  return {
+    runtime: 'farming',
+    agentId: process.env.FARMING_AGENT_ID || '',
+    projectWorkspace: process.env.FARMING_PROJECT_WORKSPACE || '',
+    capabilities: [{
+      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.'),
+      commands: state === 'available'
+        ? {
+            list: 'farming browser list',
+            create: 'farming browser create',
+            help: 'farming browser --help',
+          }
+        : {},
+    }],
+  };
+}
+
+function formatCapabilities(report) {
+  const lines = ['Farming runtime capabilities:'];
+  for (const capability of report.capabilities) {
+    lines.push(`- ${capability.id}: ${capability.state} — ${capability.summary}`);
+    for (const [label, command] of Object.entries(capability.commands || {})) {
+      lines.push(`  ${label}: ${command}`);
+    }
+  }
+  return lines.join('\n');
+}
+
 async function run(argv = process.argv.slice(2), io = process) {
   const parsed = parseArgs(argv);
 
@@ -306,6 +351,14 @@ async function run(argv = process.argv.slice(2), io = process) {
     return 0;
   }
 
+  if (parsed.command === 'capabilities') {
+    const report = farmingCapabilities(await request('/api/browsers/capability'));
+    io.stdout.write(parsed.options.json
+      ? `${JSON.stringify(report, null, 2)}\n`
+      : `${formatCapabilities(report)}\n`);
+    return 0;
+  }
+
   if (parsed.command === 'memory-report') {
     const report = buildMemoryReport({
       period: parsed.options.period,
@@ -382,6 +435,8 @@ async function run(argv = process.argv.slice(2), io = process) {
 
 module.exports = {
   formatAgent,
+  farmingCapabilities,
+  formatCapabilities,
   getToken,
   httpRequest,
   isAuthDisabled,