farming-code 2.2.27 → 2.2.29

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,18 @@ const PERSISTED_SETTING_KEYS = new Set([
   'projectWorkspaces',
   'pinnedProjectWorkspaces',
   'projectNames',
+  'projectOperations',
   'instanceName',
   'theme',
   'appearance',
   'language',
+  'restReminderIntervalSeconds',
   'heartbeatInterval',
   'dangerouslySkipAgentPermissionsByDefault',
+  'browserExtensionEnabled',
+  'browserSource',
+  'browserExecutablePath',
+  'browserExternalCdpUrl',
   'crtSkinEffectsEnabled',
   'crtDynamicHeatEnabled',
   'crtTerminalFontSize',
@@ -113,8 +123,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 +132,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 +232,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 +316,18 @@ class ConfigManager {
         projectWorkspaces: [],
         pinnedProjectWorkspaces: [],
         projectNames: {},
+        projectOperations: {},
         instanceName: '',
         theme: 'terminal',
         appearance: 'system',
         language: 'en',
+        restReminderIntervalSeconds: null,
         heartbeatInterval: 1000,
         dangerouslySkipAgentPermissionsByDefault: false,
+        browserExtensionEnabled: false,
+        browserSource: process.env.FARMING_BROWSER_CDP_URL ? 'external-cdp' : 'system',
+        browserExecutablePath: process.env.FARMING_BROWSER_EXECUTABLE || '',
+        browserExternalCdpUrl: process.env.FARMING_BROWSER_CDP_URL || 'http://127.0.0.1:9222',
         crtSkinEffectsEnabled: true,
         crtDynamicHeatEnabled: false,
         crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
@@ -329,7 +346,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 +358,18 @@ class ConfigManager {
       projectWorkspaces: [],
       pinnedProjectWorkspaces: [],
       projectNames: {},
+      projectOperations: {},
       instanceName: '',
       theme: 'terminal',
       appearance: 'system',
       language: 'en',
+      restReminderIntervalSeconds: null,
       heartbeatInterval: 1000,
       dangerouslySkipAgentPermissionsByDefault: false,
+      browserExtensionEnabled: false,
+      browserSource: process.env.FARMING_BROWSER_CDP_URL ? 'external-cdp' : 'system',
+      browserExecutablePath: process.env.FARMING_BROWSER_EXECUTABLE || '',
+      browserExternalCdpUrl: process.env.FARMING_BROWSER_CDP_URL || 'http://127.0.0.1:9222',
       crtSkinEffectsEnabled: true,
       crtDynamicHeatEnabled: false,
       crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
@@ -391,6 +414,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 +431,29 @@ class ConfigManager {
     this.runHistoryStore.init({ legacyTaskHistory });
     this.settings.appearance = this.normalizeAppearance(this.settings.appearance);
     this.settings.language = this.normalizeLanguage(this.settings.language);
+    this.settings.restReminderIntervalSeconds = this.normalizeRestReminderIntervalSeconds(
+      this.settings.restReminderIntervalSeconds,
+    );
+    this.settings.browserExtensionEnabled = this.settings.browserExtensionEnabled === true;
+    this.settings.browserSource = this.normalizeBrowserSource(this.settings.browserSource);
+    this.settings.browserExecutablePath = this.normalizeBrowserSetting(this.settings.browserExecutablePath);
+    this.settings.browserExternalCdpUrl = this.normalizeBrowserSetting(this.settings.browserExternalCdpUrl)
+      || 'http://127.0.0.1:9222';
     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];
       }
     }
   }
@@ -438,6 +471,16 @@ class ConfigManager {
     );
   }
 
+  normalizeRestReminderIntervalSeconds(value) {
+    if (value === null || value === undefined || value === '') return null;
+    const seconds = Number(value);
+    if (!Number.isInteger(seconds)) return null;
+    if (seconds === 0 || seconds === 5) return seconds;
+    return seconds >= 60 && seconds <= 240 * 60 && seconds % 60 === 0
+      ? seconds
+      : null;
+  }
+
   normalizeCrtTerminalFontSize(value) {
     const fontSize = Number(value);
     if (!Number.isFinite(fontSize)) return DEFAULT_CRT_TERMINAL_FONT_SIZE;
@@ -498,16 +541,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,
@@ -522,6 +608,14 @@ class ConfigManager {
     return ['en', 'zh'].includes(language) ? language : 'en';
   }
 
+  normalizeBrowserSource(source) {
+    return source === 'external-cdp' ? source : 'system';
+  }
+
+  normalizeBrowserSetting(value) {
+    return String(value || '').trim().slice(0, 2000);
+  }
+
   normalizeUpdateUrl(value) {
     const url = String(value || '').trim();
     if (!url) return DEFAULT_UPDATE_URL;
@@ -668,23 +762,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 +854,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 +879,6 @@ class ConfigManager {
     }
     if (
       !canonicalWorkspace
-      || canonicalWorkspace === path.parse(canonicalWorkspace).root
       || this.isInternalWorkspace(canonicalWorkspace)
     ) {
       throw new Error('Project workspace is invalid or unavailable');
@@ -860,6 +955,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 +1057,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 +1072,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 +1080,48 @@ 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.restReminderIntervalSeconds = this.normalizeRestReminderIntervalSeconds(
+      nextSettings.restReminderIntervalSeconds,
+    );
+    nextSettings.browserExtensionEnabled = nextSettings.browserExtensionEnabled === true;
+    nextSettings.browserSource = this.normalizeBrowserSource(nextSettings.browserSource);
+    nextSettings.browserExecutablePath = this.normalizeBrowserSetting(nextSettings.browserExecutablePath);
+    nextSettings.browserExternalCdpUrl = this.normalizeBrowserSetting(nextSettings.browserExternalCdpUrl)
+      || 'http://127.0.0.1:9222';
+    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',