farming-code 2.2.14 → 2.2.17

package/backend/agent-provider-session.js

@@ -16,9 +16,13 @@ function emptyPlan(args) {
   return {
     provider: '',
     id: '',
+    precreate: false,
     temporary: false,
     source: '',
     forkedFromProviderSessionId: '',
+    identityWorkspace: '',
+    resumeInsertIndex: null,
+    error: '',
     args,
   };
 }
@@ -44,13 +48,23 @@ function buildAgentProviderSessionPlan({ command, program, args, source } = {})
   }
 
   const plan = adapter.planSession(rawParts.slice(1), launchArgs);
-  if (!plan?.id) return emptyPlan(launchArgs);
+  if (plan?.error) {
+    return {
+      ...emptyPlan(launchArgs),
+      provider,
+      error: String(plan.error),
+    };
+  }
+  if (!plan || (!plan.id && plan.precreate !== true)) return emptyPlan(launchArgs);
   return {
     provider,
     id: plan.id,
+    precreate: plan.precreate === true,
     temporary: plan.temporary === true,
     source: plan.source || '',
     forkedFromProviderSessionId: plan.forkedFromProviderSessionId || '',
+    identityWorkspace: plan.identityWorkspace || '',
+    resumeInsertIndex: Number.isInteger(plan.resumeInsertIndex) ? plan.resumeInsertIndex : null,
     args: Array.isArray(plan.args) ? plan.args : launchArgs,
   };
 }

package/backend/agent-runtime-binding.js

@@ -1,4 +1,4 @@
-const RUNTIME_KINDS = new Set(['terminal', 'acp', 'json', 'app-server']);
+const RUNTIME_KINDS = new Set(['terminal', 'acp', 'json']);
 
 function terminalBinding() {
   return { kind: 'terminal' };
@@ -10,6 +10,7 @@ function acpBinding(source = {}) {
     state: source.state || source.acpState || '',
     error: source.error || source.acpError || '',
     stopReason: source.stopReason || source.acpStopReason || '',
+    supportsSteer: source.supportsSteer === true,
     pendingPermission: source.pendingPermission || source.acpPendingPermission || null,
     pendingPermissions: source.pendingPermissions || source.acpPendingPermissions || [],
     pendingElicitation: source.pendingElicitation || source.acpPendingElicitation || null,
@@ -30,38 +31,24 @@ function jsonBinding(source = {}) {
   };
 }
 
-function appServerBinding(source = {}) {
-  return {
-    kind: 'app-server',
-    state: source.state || source.codexAppServerState || '',
-    endpoint: source.endpoint || source.codexAppServerEndpoint || '',
-    threadId: source.threadId || source.codexAppServerThreadId || '',
-    turnId: source.turnId || source.codexAppServerTurnId || '',
-    error: source.error || source.codexAppServerError || '',
-    pendingRequestId: source.pendingRequestId || source.codexAppServerPendingRequestId || '',
-    pendingRequestMethod: source.pendingRequestMethod || source.codexAppServerPendingRequestMethod || '',
-    pendingRequest: source.pendingRequest || source.codexAppServerPendingRequest || null,
-    notice: source.notice || source.codexAppServerNotice || null,
-    goal: source.goal || source.codexAppServerGoal || null,
-    observerDeferred: source.observerDeferred === true || source.codexCliObserverDeferred === true,
-    homePath: source.homePath || source.codexAppServerHomePath || '',
-    transcriptUpdatedAt: source.transcriptUpdatedAt || source.codexAppServerTranscriptUpdatedAt || '',
-  };
-}
-
 function runtimeKind(agent) {
   if (RUNTIME_KINDS.has(agent?.runtimeBinding?.kind)) return agent.runtimeBinding.kind;
+  // App Server was an experimental Codex runtime. Persisted records migrate to
+  // ACP because codex-acp uses the same Codex thread id as its session id.
+  if (agent?.runtimeBinding?.kind === 'app-server' || agent?.codexRuntimeMode === 'app-server') return 'acp';
   if (agent?.agentRuntimeMode === 'acp') return 'acp';
   if (agent?.agentRuntimeMode === 'json') return 'json';
-  return agent?.codexRuntimeMode === 'app-server' ? 'app-server' : 'terminal';
+  return 'terminal';
 }
 
 function bindingFromLegacy(agent) {
   if (RUNTIME_KINDS.has(agent?.runtimeBinding?.kind)) return agent.runtimeBinding;
+  if (agent?.runtimeBinding?.kind === 'app-server' || agent?.codexRuntimeMode === 'app-server') {
+    return acpBinding({ state: 'connecting' });
+  }
   switch (runtimeKind(agent)) {
     case 'acp': return acpBinding(agent);
     case 'json': return jsonBinding(agent);
-    case 'app-server': return appServerBinding(agent);
     default: return terminalBinding();
   }
 }
@@ -70,7 +57,6 @@ function runtimeBindingFor(kind, source = {}) {
   switch (kind) {
     case 'acp': return acpBinding(source);
     case 'json': return jsonBinding(source);
-    case 'app-server': return appServerBinding(source);
     default: return terminalBinding();
   }
 }
@@ -133,22 +119,6 @@ function publicRuntimeBinding(agent) {
       transcriptUpdatedAt: binding.transcriptUpdatedAt,
     };
   }
-  if (binding.kind === 'app-server') {
-    return {
-      kind: 'app-server',
-      state: binding.state,
-      endpoint: binding.endpoint,
-      threadId: binding.threadId,
-      turnId: binding.turnId,
-      error: binding.error,
-      pendingRequestId: binding.pendingRequestId,
-      pendingRequestMethod: binding.pendingRequestMethod,
-      pendingRequest: binding.pendingRequest,
-      notice: binding.notice,
-      goal: binding.goal,
-      observerDeferred: binding.observerDeferred,
-    };
-  }
   return { ...binding };
 }
 
@@ -162,7 +132,6 @@ function runtimeState(agent) {
 function legacyRuntimeMetadata(agent) {
   const binding = bindingFromLegacy(agent);
   const metadata = {
-    codexRuntimeMode: binding.kind === 'app-server' ? 'app-server' : 'cli',
     agentRuntimeMode: ['acp', 'json'].includes(binding.kind) ? binding.kind : 'terminal',
   };
   if (binding.kind === 'acp') {
@@ -188,21 +157,6 @@ function legacyRuntimeMetadata(agent) {
       jsonCliTranscriptUpdatedAt: binding.transcriptUpdatedAt,
     };
   }
-  if (binding.kind === 'app-server') {
-    return {
-      ...metadata,
-      codexAppServerHomePath: binding.homePath,
-      codexAppServerState: binding.state,
-      codexAppServerEndpoint: binding.endpoint,
-      codexAppServerThreadId: binding.threadId,
-      codexAppServerTurnId: binding.turnId,
-      codexAppServerError: binding.error,
-      codexAppServerPendingRequestId: binding.pendingRequestId,
-      codexAppServerPendingRequestMethod: binding.pendingRequestMethod,
-      codexAppServerPendingRequest: binding.pendingRequest,
-      codexCliObserverDeferred: binding.observerDeferred,
-    };
-  }
   return metadata;
 }
 

package/backend/chat-runtime.js

@@ -0,0 +1,28 @@
+// Chat is a product-level intent. ACP is the single structured Chat runtime for
+// every supported coding agent, including Codex.
+const CHAT_MODE = 'chat';
+
+function chatRuntimeForProvider() {
+  return 'acp';
+}
+
+function isChatMode(mode) {
+  return mode === CHAT_MODE;
+}
+
+function chatCapabilitiesForProvider(provider) {
+  const runtime = chatRuntimeForProvider(provider);
+  return {
+    chatRuntime: runtime,
+    supportsChat: true,
+    // ACP does not currently define a turn-versioned steer operation.
+    supportsSteer: false,
+  };
+}
+
+module.exports = {
+  CHAT_MODE,
+  chatRuntimeForProvider,
+  chatCapabilitiesForProvider,
+  isChatMode,
+};

package/backend/codex-rollout-follower.js

@@ -59,6 +59,88 @@ function findCodexRolloutFile(sessionId, options = {}) {
   return '';
 }
 
+function recentSessionDirectories(root, now = new Date()) {
+  const directories = [];
+  for (const offsetDays of [-1, 0, 1]) {
+    const date = new Date(now.getTime() + offsetDays * 24 * 60 * 60 * 1000);
+    directories.push(
+      path.join(
+        root,
+        String(date.getFullYear()),
+        String(date.getMonth() + 1).padStart(2, '0'),
+        String(date.getDate()).padStart(2, '0'),
+      ),
+      path.join(
+        root,
+        String(date.getUTCFullYear()),
+        String(date.getUTCMonth() + 1).padStart(2, '0'),
+        String(date.getUTCDate()).padStart(2, '0'),
+      ),
+    );
+  }
+  return [...new Set(directories)];
+}
+
+async function findCodexRolloutFileAsync(sessionId, options = {}) {
+  const normalizedSessionId = String(sessionId || '').trim();
+  if (!normalizedSessionId) return '';
+  const codexHome = normalizePathValue(options.codexHome || path.join(os.homedir(), '.codex'));
+  const maxEntries = Number.isFinite(options.maxEntries)
+    ? Math.max(1, Math.floor(options.maxEntries))
+    : 100_000;
+  const deadline = Number.isFinite(options.deadline)
+    ? Number(options.deadline)
+    : Date.now() + 5_000;
+  const sessionsRoot = path.join(codexHome, 'sessions');
+  const archivedRoot = path.join(codexHome, 'archived_sessions');
+  const preferredDirectories = [
+    ...recentSessionDirectories(sessionsRoot),
+    ...(options.recentOnly === true ? [] : [archivedRoot]),
+  ];
+  const visited = new Set();
+  let inspectedEntries = 0;
+
+  async function inspectDirectory(directory, descend) {
+    if (Date.now() > deadline || inspectedEntries >= maxEntries || visited.has(directory)) return '';
+    visited.add(directory);
+    let entries;
+    try {
+      entries = await fsp.readdir(directory, { withFileTypes: true });
+    } catch {
+      return '';
+    }
+    const subdirectories = [];
+    for (const entry of entries) {
+      inspectedEntries += 1;
+      if (Date.now() > deadline || inspectedEntries > maxEntries) return '';
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isFile() && entry.name.endsWith('.jsonl') && sessionIdFromFilePath(fullPath) === normalizedSessionId) {
+        return fullPath;
+      }
+      if (descend && entry.isDirectory()) subdirectories.push(fullPath);
+    }
+    return subdirectories;
+  }
+
+  for (const directory of preferredDirectories) {
+    const found = await inspectDirectory(directory, false);
+    if (typeof found === 'string' && found) return found;
+  }
+  if (options.recentOnly === true) return '';
+
+  const stack = [sessionsRoot, archivedRoot];
+  while (stack.length > 0 && Date.now() <= deadline && inspectedEntries < maxEntries) {
+    const directory = stack.pop();
+    const result = await inspectDirectory(directory, true);
+    if (typeof result === 'string') {
+      if (result) return result;
+      continue;
+    }
+    stack.push(...result);
+  }
+  return '';
+}
+
 function normalizePreviewText(value, maxLength = 400) {
   return String(value || '')
     .replace(/\r\n/g, '\n')
@@ -239,5 +321,6 @@ class CodexRolloutFollower extends EventEmitter {
 module.exports = {
   CodexRolloutFollower,
   findCodexRolloutFile,
+  findCodexRolloutFileAsync,
   formatCodexRolloutEvent,
 };

package/backend/codex-session-archive.js

@@ -1,4 +1,5 @@
 const { execFile } = require('child_process');
+const fs = require('fs');
 const os = require('os');
 const { promisify } = require('util');
 const { resolveCompatibleCodexExecutable } = require('./executable-discovery');
@@ -9,6 +10,13 @@ async function runCodexSessionArchiveCommand(action, sessionId, session = {}, op
   const resolveExecutable = options.resolveCompatibleCodexExecutable || resolveCompatibleCodexExecutable;
   const runExecFile = options.execFileAsync || execFileAsync;
   const processEnv = options.processEnv || process.env;
+  const directoryExists = options.directoryExists || ((directory) => {
+    try {
+      return fs.statSync(directory).isDirectory();
+    } catch {
+      return false;
+    }
+  });
   const codexResolution = resolveExecutable(session.cliVersion || '', processEnv.PATH || '');
   if (!codexResolution.compatible) {
     return {
@@ -18,8 +26,11 @@ async function runCodexSessionArchiveCommand(action, sessionId, session = {}, op
   }
 
   try {
+    const sessionCwd = session.cwd || session.workspace || '';
     await runExecFile(codexResolution.path || 'codex', [action, sessionId], {
-      cwd: session.cwd || session.workspace || os.homedir(),
+      cwd: sessionCwd && directoryExists(sessionCwd)
+        ? sessionCwd
+        : (processEnv.HOME || os.homedir()),
       env: session.providerHomePath
         ? { ...processEnv, CODEX_HOME: session.providerHomePath }
         : processEnv,

package/backend/codex-session-history.js

@@ -412,6 +412,98 @@ async function readSessionMetadata(filePath, maxLines = 80) {
   return metadata.id ? metadata : null;
 }
 
+function codexSessionDateKeys(startedAt, windowMs) {
+  const center = Number(startedAt);
+  const radius = Math.max(0, Number(windowMs) || 0);
+  if (!Number.isFinite(center) || center <= 0) return [];
+  const cursor = new Date(center - radius);
+  cursor.setHours(0, 0, 0, 0);
+  const lastDay = new Date(center + radius);
+  lastDay.setHours(0, 0, 0, 0);
+  const keys = [];
+  while (cursor <= lastDay) {
+    keys.push([
+      cursor.getFullYear(),
+      String(cursor.getMonth() + 1).padStart(2, '0'),
+      String(cursor.getDate()).padStart(2, '0'),
+    ].join('-'));
+    cursor.setDate(cursor.getDate() + 1);
+  }
+  return keys;
+}
+
+async function readCodexSessionIdentity(filePath) {
+  let handle;
+  try {
+    handle = await fs.promises.open(filePath, 'r');
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    const chunks = [];
+    let bytesReadTotal = 0;
+    let lineEnd = -1;
+    while (bytesReadTotal < 1024 * 1024 && lineEnd < 0) {
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, bytesReadTotal);
+      if (bytesRead <= 0) break;
+      const current = Buffer.from(chunk.subarray(0, bytesRead));
+      chunks.push(current);
+      const newlineIndex = current.indexOf(0x0a);
+      if (newlineIndex >= 0) lineEnd = bytesReadTotal + newlineIndex;
+      bytesReadTotal += bytesRead;
+    }
+    const header = Buffer.concat(chunks);
+    const firstLine = header.subarray(0, lineEnd >= 0 ? lineEnd : header.length).toString('utf8').replace(/\r$/, '');
+    const fileSessionId = sessionIdFromFilePath(filePath);
+    const event = JSON.parse(firstLine);
+    if (event?.type !== 'session_meta') return null;
+    const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
+    const id = typeof payload.id === 'string' ? payload.id.trim() : '';
+    if (!id || (fileSessionId && id !== fileSessionId)) return null;
+    const cwd = typeof payload.cwd === 'string' ? normalizePathValue(payload.cwd) : '';
+    return {
+      id,
+      createdAt: typeof event.timestamp === 'string' ? event.timestamp : '',
+      cwd,
+      workspace: cwd,
+    };
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+async function listCodexSessionIdentities(options = {}) {
+  const codexHome = options.codexHome || path.join(os.homedir(), '.codex');
+  const startedAt = Number(options.startedAt);
+  const windowMs = Math.max(0, Number(options.windowMs) || 0);
+  if (!Number.isFinite(startedAt) || startedAt <= 0) return [];
+
+  const files = [];
+  for (const dateKey of codexSessionDateKeys(startedAt, windowMs)) {
+    const [year, month, day] = dateKey.split('-');
+    const directory = path.join(codexHome, 'sessions', year, month, day);
+    let entries;
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      files.push(path.join(directory, entry.name));
+    }
+  }
+
+  const identities = [];
+  const batchSize = 32;
+  for (let offset = 0; offset < files.length; offset += batchSize) {
+    const batch = await Promise.all(
+      files.slice(offset, offset + batchSize).map(readCodexSessionIdentity)
+    );
+    identities.push(...batch.filter(Boolean));
+  }
+  return identities;
+}
+
 function getGlobalState(codexHome) {
   const state = readJsonFile(path.join(codexHome, '.codex-global-state.json'), {});
   const atom = state['electron-persisted-atom-state'] || {};
@@ -540,8 +632,10 @@ async function listCodexSessions(options = {}) {
 }
 
 module.exports = {
+  codexSessionDateKeys,
   hasTemporaryWorkspaceReference,
   isTemporaryWorkspace,
+  listCodexSessionIdentities,
   listCodexSessions,
   readSessionIndex,
   readSessionMetadata,

package/backend/codex-transcript.js

@@ -12,7 +12,8 @@ const {
 } = require('./codex-transcript-sanitizer');
 
 // @deprecated `readCodexTranscript` below is the legacy JSONL file reader.
-// App Server uses the generic event-to-turn projection exported here instead.
+// The generic event-to-turn projection remains for JSON compatibility feeds;
+// live structured Chat is reduced from ACP session updates instead.
 const DEFAULT_MAX_READ_BYTES = 32 * 1024 * 1024;
 const DEFAULT_MAX_TURNS = 240;
 const USER_MESSAGE_BEGIN = '## My request for Codex:';

package/backend/config-manager.js

@@ -67,6 +67,7 @@ const MAX_SEARCH_TIMEOUT_MS = 180000;
 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 PERSISTED_SETTING_KEYS = new Set([
   'workspace',
@@ -75,6 +76,7 @@ const PERSISTED_SETTING_KEYS = new Set([
   'projectWorkspaces',
   'pinnedProjectWorkspaces',
   'projectNames',
+  'instanceName',
   'theme',
   'appearance',
   'language',
@@ -88,7 +90,6 @@ const PERSISTED_SETTING_KEYS = new Set([
   'agentHomes',
   'updateUrl',
   'searchTimeoutMs',
-  'codexRuntimeMode',
   'codexApprovalMode',
   'codexModel',
   'codexReasoningEffort',
@@ -183,6 +184,19 @@ class ConfigManager {
     return this.farmingDir;
   }
 
+  normalizeInstanceName(value) {
+    if (typeof value !== 'string') return '';
+    return value
+      .replace(/[\x00-\x1f\x7f]/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .slice(0, MAX_INSTANCE_NAME_LENGTH);
+  }
+
+  getInstanceName() {
+    return this.settings?.instanceName || this.normalizeInstanceName(os.hostname()) || 'Farming';
+  }
+
   normalizeWorkspaceHistory(history) {
     const entries = Array.isArray(history) ? history : [];
     const result = [];
@@ -290,8 +304,9 @@ class ConfigManager {
         projectWorkspaces: [],
         pinnedProjectWorkspaces: [],
         projectNames: {},
+        instanceName: '',
         theme: 'terminal',
-        appearance: 'light',
+        appearance: 'system',
         language: 'en',
         heartbeatInterval: 1000,
         dangerouslySkipAgentPermissionsByDefault: false,
@@ -306,7 +321,6 @@ class ConfigManager {
         agentHomes: cloneAgentHomes(DEFAULT_AGENT_HOMES),
         updateUrl: DEFAULT_UPDATE_URL,
         searchTimeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
-        codexRuntimeMode: 'cli',
         codexApprovalMode: 'approve',
         codexModel: 'gpt-5.5',
         codexReasoningEffort: 'xhigh',
@@ -326,8 +340,9 @@ class ConfigManager {
       projectWorkspaces: [],
       pinnedProjectWorkspaces: [],
       projectNames: {},
+      instanceName: '',
       theme: 'terminal',
-      appearance: 'light',
+      appearance: 'system',
       language: 'en',
       heartbeatInterval: 1000,
       dangerouslySkipAgentPermissionsByDefault: false,
@@ -342,7 +357,6 @@ class ConfigManager {
       agentHomes: cloneAgentHomes(DEFAULT_AGENT_HOMES),
       updateUrl: DEFAULT_UPDATE_URL,
       searchTimeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
-      codexRuntimeMode: 'cli',
       codexApprovalMode: 'approve',
       codexModel: 'gpt-5.5',
       codexReasoningEffort: 'xhigh',
@@ -376,13 +390,14 @@ 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.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) {
       this.settings.updateUrl = DEFAULT_UPDATE_URL;
     }
     this.settings.updateUrl = this.normalizeUpdateUrl(this.settings.updateUrl);
     this.settings.searchTimeoutMs = this.normalizeSearchTimeoutMs(this.settings.searchTimeoutMs);
-    this.settings.codexRuntimeMode = this.normalizeCodexRuntimeMode(this.settings.codexRuntimeMode);
+    delete this.settings.codexRuntimeMode;
     const legacyMainPageSessionKeys = this.normalizeMainPageSessionKeys(this.settings.mainPageSessionKeys);
     delete this.settings.mainPageSessionKeys;
     this.sessionStore.init({ legacyMainPageSessionKeys });
@@ -483,7 +498,7 @@ class ConfigManager {
   }
 
   normalizeAppearance(appearance) {
-    return ['light', 'dark'].includes(appearance) ? appearance : 'light';
+    return ['system', 'light', 'dark'].includes(appearance) ? appearance : 'system';
   }
 
   normalizeLanguage(language) {
@@ -517,10 +532,6 @@ class ConfigManager {
     return ['ask', 'approve', 'full', 'custom'].includes(mode) ? mode : 'approve';
   }
 
-  normalizeCodexRuntimeMode(mode) {
-    return mode === 'app-server' ? 'app-server' : 'cli';
-  }
-
   normalizeCodexModelPreset(preset) {
     if (preset === 'config') return preset;
     if (typeof preset !== 'string') return 'gpt-5.5:xhigh';
@@ -676,11 +687,6 @@ class ConfigManager {
     return this.getAgentLaunchProfile('codex').approvalMode;
   }
 
-  getCodexRuntimeMode() {
-    if (!this.settings) return 'cli';
-    return this.normalizeCodexRuntimeMode(this.settings.codexRuntimeMode);
-  }
-
   getCodexModelPreset() {
     if (!this.settings) return 'gpt-5.5:xhigh';
     return this.getAgentLaunchProfile('codex').modelPreset;
@@ -739,6 +745,7 @@ class ConfigManager {
   getSettings() {
     return {
       ...this.settings,
+      instanceName: this.getInstanceName(),
       workspace: this.farmingDir,
       mainPageSessionKeys: this.getMainPageSessionKeys(),
       taskHistory: this.getTaskHistory(),
@@ -819,10 +826,11 @@ 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.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);
-    this.settings.codexRuntimeMode = this.normalizeCodexRuntimeMode(this.settings.codexRuntimeMode);
+    delete this.settings.codexRuntimeMode;
     delete this.settings.mainPageSessionKeys;
     delete this.settings.taskHistory;
     if (incomingMainPageSessionKeys !== undefined) {

package/backend/control-api.js

@@ -219,9 +219,11 @@ function createControlRouter(agentManager, options = {}) {
       parentAgentId: typeof body.parentAgentId === 'string' ? body.parentAgentId : '',
       task,
       source: 'control-cli',
-      agentRuntimeMode: ['json', 'acp'].includes(body.agentRuntimeMode) ? body.agentRuntimeMode : 'terminal',
+      agentRuntimeMode: ['json', 'acp', 'chat'].includes(body.agentRuntimeMode) ? body.agentRuntimeMode : 'terminal',
       acpHistoryMode: body.acpHistoryMode === 'resume' ? 'resume' : 'load',
       providerSessionTitle: typeof body.providerSessionTitle === 'string' ? body.providerSessionTitle : '',
+      ...(Array.isArray(body.additionalDirectories) ? { additionalDirectories: body.additionalDirectories } : {}),
+      ...(Array.isArray(body.mcpServers) ? { mcpServers: body.mcpServers } : {}),
       dangerouslySkipPermissions: body.dangerouslySkipPermissions === true,
     });
   });

package/backend/farming-app-cli.js

@@ -7,11 +7,13 @@ const path = require('path');
 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 storageLayout = require('./storage-layout');
 
 const SERVER_MODE_ARG = '--farming-server';
 const SERVER_MODE_ENV = 'FARMING_RUN_SERVER';
 const NATIVE_PTY_HOST_ARG = '--native-pty-host';
+const USAGE_HISTORY_SMOKE_ARG = '--farming-usage-history-smoke';
 const DEFAULT_PORT = '6694';
 const DEFAULT_BASE_PATH = '/farming';
 const DEFAULT_SERVER_START_TIMEOUT_MS = 30_000;
@@ -85,6 +87,13 @@ function appendNodeOption(existing, option) {
 function buildServerEnv(overrides = {}, baseEnv = process.env) {
   const env = { ...baseEnv, ...overrides };
   delete env.PKG_EXECPATH;
+  if (!process.pkg && !env.FARMING_MANAGED_PACKAGE_ROOT) {
+    try {
+      env.FARMING_MANAGED_PACKAGE_ROOT = fs.realpathSync(path.join(__dirname, '..'));
+    } catch {
+      // npm update verification will remain unavailable when the package root cannot be proven.
+    }
+  }
   const cliBinDir = process.pkg ? path.dirname(process.execPath) : path.join(__dirname, '..', 'bin');
   env.PORT = String(env.FARMING_PORT || env.PORT || DEFAULT_PORT);
   env.FARMING_BASE_PATH = env.FARMING_BASE_PATH || DEFAULT_BASE_PATH;
@@ -774,6 +783,18 @@ async function run(argv = process.argv.slice(2)) {
     return 0;
   }
 
+  if (argv[0] === PACKAGED_CODEX_ACP_ARG) {
+    runPackagedCodexAcp();
+    return 0;
+  }
+
+  if (argv[0] === USAGE_HISTORY_SMOKE_ARG) {
+    const { runUsageHistorySmoke } = require('./usage-history-smoke');
+    const result = await runUsageHistorySmoke();
+    console.log(JSON.stringify(result));
+    return 0;
+  }
+
   if (argv[0] === NATIVE_PTY_HOST_ARG || process.env.FARMING_RUN_NATIVE_PTY_HOST === '1') {
     runNativePtyHostInCurrentProcess();
     return 0;

package/backend/farming-session-store.js

@@ -25,8 +25,9 @@ function safeSessionFileName(id) {
 function atomicWriteJson(file, value) {
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const tmpFile = `${file}.${process.pid}.${Date.now()}.tmp`;
-  fs.writeFileSync(tmpFile, JSON.stringify(value, null, 2));
+  fs.writeFileSync(tmpFile, JSON.stringify(value, null, 2), { mode: 0o600 });
   fs.renameSync(tmpFile, file);
+  fs.chmodSync(file, 0o600);
 }
 
 function parseProviderSessionKey(key) {