farming-code 2.2.14 → 2.2.17

package/backend/provider-session-service.js

@@ -1,12 +1,16 @@
+const fs = require('fs');
 const path = require('path');
 const { findAgentSession } = require('./agent-session-history');
-const { listCodexSessions } = require('./codex-session-history');
-const { isLinkedWorktreeOf } = require('./git-worktree-info');
+const {
+  codexSessionDateKeys,
+  listCodexSessionIdentities,
+} = require('./codex-session-history');
 const { mainPageAgentSessionKey } = require('./main-page-session');
 const { isTemporaryProviderSessionId } = require('./provider-session-id');
 
 const CODEX_RESOLVE_COOLDOWN_MS = 1000;
-const CODEX_MATCH_GRACE_MS = 30 * 1000;
+const CODEX_MATCH_WINDOW_MS = 30 * 1000;
+const CODEX_STARTUP_RETRY_DELAYS_MS = [500, 1000, 2000, 4000, 8000, 12000];
 const TITLE_RESOLVE_COOLDOWN_MS = 30 * 1000;
 
 function normalizePath(value) {
@@ -16,6 +20,16 @@ function normalizePath(value) {
   return trimmed.replace(/[\\/]+$/, '');
 }
 
+function canonicalPath(value) {
+  const normalized = normalizePath(value);
+  if (!normalized) return '';
+  try {
+    return normalizePath(fs.realpathSync.native(normalized));
+  } catch {
+    return normalized;
+  }
+}
+
 function timestampMs(value) {
   const parsed = Date.parse(value || '');
   return Number.isFinite(parsed) ? parsed : 0;
@@ -26,10 +40,14 @@ class ProviderSessionService {
     this.agents = options.agents || new Map();
     this.getProviderHomes = options.getProviderHomes || (() => undefined);
     this.commit = options.commit || (() => {});
-    this.listCodexSessions = options.listCodexSessions || listCodexSessions;
+    this.listCodexSessionIdentities = options.listCodexSessionIdentities || listCodexSessionIdentities;
     this.findAgentSession = options.findAgentSession || findAgentSession;
-    this.isLinkedWorktreeOf = options.isLinkedWorktreeOf || isLinkedWorktreeOf;
+    this.codexStartupRetryDelaysMs = Array.isArray(options.codexStartupRetryDelaysMs)
+      ? options.codexStartupRetryDelaysMs
+      : CODEX_STARTUP_RETRY_DELAYS_MS;
     this.resolutions = new Map();
+    this.codexIdentityScans = new Map();
+    this.codexStartupRetries = new Map();
   }
 
   activate(agentId) {
@@ -38,6 +56,7 @@ class ProviderSessionService {
 
     if (agent.providerSessionProvider === 'codex' && agent.providerSessionTemporary === true) {
       this.observe(agentId, { force: true });
+      this.scheduleTemporaryCodexStartupRetry(agentId);
       return;
     }
 
@@ -54,10 +73,71 @@ class ProviderSessionService {
   stop(agentId) {
     this.resolutions.delete(`codex:${agentId}`);
     this.resolutions.delete(`title:${agentId}`);
+    const startupRetry = this.codexStartupRetries.get(agentId);
+    if (startupRetry?.timer) clearTimeout(startupRetry.timer);
+    this.codexStartupRetries.delete(agentId);
   }
 
   dispose() {
+    for (const startupRetry of this.codexStartupRetries.values()) {
+      if (startupRetry?.timer) clearTimeout(startupRetry.timer);
+    }
     this.resolutions.clear();
+    this.codexIdentityScans.clear();
+    this.codexStartupRetries.clear();
+  }
+
+  scheduleTemporaryCodexStartupRetry(agentId) {
+    if (this.codexStartupRetries.has(agentId)) return;
+    const agent = this.agents.get(agentId);
+    const retry = {
+      attempt: 0,
+      timer: null,
+      deadlineAt: (Number(agent?.startedAt) || Date.now()) + CODEX_MATCH_WINDOW_MS,
+    };
+    this.codexStartupRetries.set(agentId, retry);
+
+    const scheduleNext = () => {
+      if (this.codexStartupRetries.get(agentId) !== retry) return;
+      const agent = this.agents.get(agentId);
+      if (
+        !agent
+        || agent.providerSessionProvider !== 'codex'
+        || agent.providerSessionTemporary !== true
+      ) {
+        this.stop(agentId);
+        return;
+      }
+      const delayMs = Number(this.codexStartupRetryDelaysMs[retry.attempt]);
+      if (!Number.isFinite(delayMs) || delayMs < 0) {
+        this.codexStartupRetries.delete(agentId);
+        return;
+      }
+      if (Date.now() + delayMs > retry.deadlineAt) {
+        this.codexStartupRetries.delete(agentId);
+        return;
+      }
+      retry.attempt += 1;
+      retry.timer = setTimeout(async () => {
+        retry.timer = null;
+        if (
+          this.codexStartupRetries.get(agentId) !== retry
+          || Date.now() > retry.deadlineAt
+        ) {
+          if (this.codexStartupRetries.get(agentId) === retry) {
+            this.codexStartupRetries.delete(agentId);
+          }
+          return;
+        }
+        const resolved = await this.resolveTemporaryCodex(agentId, { force: true });
+        if (this.codexStartupRetries.get(agentId) !== retry) return;
+        if (resolved) return;
+        scheduleNext();
+      }, delayMs);
+      retry.timer.unref?.();
+    };
+
+    scheduleNext();
   }
 
   bindConfirmed(agentId, provider, sessionId) {
@@ -97,6 +177,14 @@ class ProviderSessionService {
       this.resolutions.delete(`codex:${agentId}`);
       return Promise.resolve(false);
     }
+    const startedAt = Number(agent.startedAt) || 0;
+    if (
+      options.force !== true
+      && startedAt
+      && Date.now() > startedAt + CODEX_MATCH_WINDOW_MS
+    ) {
+      return Promise.resolve(false);
+    }
 
     return this.runResolution(
       'codex',
@@ -167,15 +255,30 @@ class ProviderSessionService {
   }
 
   async findTemporaryCodexSession(agent) {
-    const sessions = await this.listCodexSessions({
-      codexHome: agent.providerHomePath || undefined,
-      limit: 100,
-      scanLimit: 1000,
-    });
+    const startedAt = Number(agent.startedAt) || 0;
+    const codexHome = agent.providerHomePath || '';
+    const scanKey = [
+      codexHome,
+      ...codexSessionDateKeys(startedAt, CODEX_MATCH_WINDOW_MS),
+    ].join('\0');
+    let scan = this.codexIdentityScans.get(scanKey);
+    if (!scan) {
+      scan = Promise.resolve(this.listCodexSessionIdentities({
+        codexHome: codexHome || undefined,
+        startedAt,
+        windowMs: CODEX_MATCH_WINDOW_MS,
+      })).finally(() => {
+        if (this.codexIdentityScans.get(scanKey) === scan) {
+          this.codexIdentityScans.delete(scanKey);
+        }
+      });
+      this.codexIdentityScans.set(scanKey, scan);
+    }
+    const sessions = await scan;
     const workspace = normalizePath(
-      agent?.gitWorktree?.workspace || agent?.projectWorkspace || agent?.cwd || ''
+      agent?.projectWorkspace || agent?.cwd || agent?.gitWorktree?.workspace || ''
     );
-    const startedAt = Number(agent.startedAt) || 0;
+    if (!workspace) return null;
     const homeId = String(agent.providerHomeId || 'default').trim() || 'default';
     const claimedSessionIds = new Set([...this.agents.values()]
       .filter(candidate => candidate?.id !== agent.id
@@ -189,35 +292,36 @@ class ProviderSessionService {
         if (!session?.id || claimedSessionIds.has(session.id)) return false;
         const sessionWorkspace = normalizePath(session.workspace || session.cwd);
         if (workspace && !sessionWorkspace) return false;
-        const sessionTime = timestampMs(session.createdAt || session.updatedAt);
-        if (!sessionTime || !startedAt) return true;
-        return sessionTime >= startedAt - CODEX_MATCH_GRACE_MS;
-      })
-      .sort((a, b) => {
-        const aTime = timestampMs(a.createdAt || a.updatedAt);
-        const bTime = timestampMs(b.createdAt || b.updatedAt);
-        const aDistance = startedAt && aTime ? Math.abs(aTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        const bDistance = startedAt && bTime ? Math.abs(bTime - startedAt) : Number.MAX_SAFE_INTEGER;
-        if (aDistance !== bDistance) return aDistance - bDistance;
-        return bTime - aTime;
+        const sessionTime = timestampMs(session.createdAt);
+        if (!sessionTime || !startedAt) return false;
+        return Math.abs(sessionTime - startedAt) <= CODEX_MATCH_WINDOW_MS;
       });
 
-    const exact = candidates.find(session => (
-      !workspace || workspace === normalizePath(session.workspace || session.cwd)
+    const exact = candidates.filter(session => (
+      workspace === normalizePath(session.workspace || session.cwd)
     ));
-    if (exact) return exact;
-    if (!workspace) return candidates[0] || null;
-
-    for (const session of candidates.slice(0, 12)) {
-      const sessionWorkspace = normalizePath(session.workspace || session.cwd);
-      if (!sessionWorkspace) continue;
-      if (await this.isLinkedWorktreeOf(workspace, sessionWorkspace)) return session;
-    }
+    if (exact.length === 1) return exact[0];
+    if (exact.length > 1) return null;
+    const canonicalWorkspace = canonicalPath(workspace);
+    const canonical = candidates.filter(session => (
+      canonicalWorkspace === canonicalPath(session.workspace || session.cwd)
+    ));
+    if (canonical.length === 1) return canonical[0];
     return null;
   }
 
   confirm(agentId, { provider, sessionId, source, title, workspace }) {
-    const previousSessionId = this.agents.get(agentId)?.providerSessionId || '';
+    const current = this.agents.get(agentId);
+    const homeId = String(current?.providerHomeId || 'default').trim() || 'default';
+    const claimedByAnotherAgent = [...this.agents.values()].some(candidate => (
+      candidate?.id !== agentId
+      && candidate?.providerSessionProvider === provider
+      && candidate?.providerSessionId === sessionId
+      && candidate?.providerSessionTemporary !== true
+      && (String(candidate.providerHomeId || 'default').trim() || 'default') === homeId
+    ));
+    if (claimedByAnotherAgent) return false;
+    const previousSessionId = current?.providerSessionId || '';
     const agent = this.bindConfirmed(agentId, provider, sessionId);
     if (!agent) return false;
     const providerSessionTitle = String(title || '').trim().slice(0, 160);

package/backend/server.js

@@ -50,7 +50,6 @@ const { discoverSlashCommands } = require('./slash-command-discovery');
 const { FarmingUpdateService } = require('./update-service');
 const { isRestartBlockingAgent } = require('./agent-activity');
 const { inputPartsFromMessage } = require('./input-parts');
-const { AppServerApiBridge, createAppServerApiRouter } = require('./app-server-api');
 const { cleanupTerminalRuntime } = require('./terminal-runtime-cleanup');
 const { QrShareTicketStore, SHARE_TICKET_TTL_MS } = require('./qr-share-tickets');
 const { ReviewStateStore } = require('./review-state-store');
@@ -123,8 +122,11 @@ const updateService = new FarmingUpdateService({
   packagedRuntime: Boolean(process.pkg || process.env.FARMING_PACKAGED_RUNTIME === '1'),
   getUpdateUrl: () => configManager.getSettings().updateUrl || '',
 });
-const appServerApiBridge = new AppServerApiBridge();
-const usageMonitor = new UsageMonitor({ agentManager, getProviderHomes: configuredProviderHomes });
+const usageMonitor = new UsageMonitor({
+  agentManager,
+  configDir: configManager.farmingDir,
+  getProviderHomes: configuredProviderHomes,
+});
 const codexContextWindowReader = new CodexContextWindowReader();
 const usageSummaryCache = new AsyncCache(() => usageMonitor.getUsageSummary(), {
   ttlMs: 15_000,
@@ -531,10 +533,6 @@ app.use(routePath(BASE_PATH, '/api/control'), createControlRouter(agentManager,
     && process.env.FARMING_E2E_FAKE_EXECUTABLES === '1',
 }));
 
-app.use(routePath(BASE_PATH, '/api/app-server'), createAppServerApiRouter({
-  bridge: appServerApiBridge,
-}));
-
 app.get([
   BASE_PATH || '/',
   `${BASE_PATH || ''}/`,
@@ -602,9 +600,21 @@ const IMAGE_ATTACHMENT_EXTENSIONS = {
   'image/gif': 'gif',
   'image/webp': 'webp',
 };
+const AUDIO_ATTACHMENT_EXTENSIONS = {
+  'audio/aac': 'aac',
+  'audio/flac': 'flac',
+  'audio/mp4': 'm4a',
+  'audio/mpeg': 'mp3',
+  'audio/ogg': 'ogg',
+  'audio/wav': 'wav',
+  'audio/wave': 'wav',
+  'audio/webm': 'webm',
+  'audio/x-wav': 'wav',
+};
 const IMAGE_ATTACHMENT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 const IMAGE_ATTACHMENT_GC_INTERVAL_MS = 60 * 60 * 1000;
 const IMAGE_ATTACHMENT_FILENAME_RE = /^pasted-image-\d+-[a-f0-9]{8}\.(?:png|jpg|gif|webp)$/;
+const AUDIO_ATTACHMENT_FILENAME_RE = /^pasted-audio-\d+-[a-f0-9]{8}\.(?:aac|flac|m4a|mp3|ogg|wav|webm)$/;
 let lastImageAttachmentGcAt = 0;
 
 function imageAttachmentExtension(contentType) {
@@ -612,6 +622,11 @@ function imageAttachmentExtension(contentType) {
   return IMAGE_ATTACHMENT_EXTENSIONS[normalized] || '';
 }
 
+function audioAttachmentExtension(contentType) {
+  const normalized = String(contentType || '').split(';')[0].trim().toLowerCase();
+  return AUDIO_ATTACHMENT_EXTENSIONS[normalized] || '';
+}
+
 function imageAttachmentsDir() {
   return path.join(configManager.farmingDir, 'attachments');
 }
@@ -634,7 +649,7 @@ async function cleanupExpiredImageAttachments(options = {}) {
 
   const cutoff = now - IMAGE_ATTACHMENT_RETENTION_MS;
   await Promise.all(entries.map(async (entry) => {
-    if (!entry.isFile() || !IMAGE_ATTACHMENT_FILENAME_RE.test(entry.name)) return;
+    if (!entry.isFile() || (!IMAGE_ATTACHMENT_FILENAME_RE.test(entry.name) && !AUDIO_ATTACHMENT_FILENAME_RE.test(entry.name))) return;
 
     const filePath = path.join(attachmentsDir, entry.name);
     try {
@@ -684,6 +699,30 @@ app.post(
   }
 );
 
+app.post(
+  routePath(BASE_PATH, '/api/attachments/audio'),
+  express.raw({ type: 'audio/*', limit: '25mb' }),
+  (req, res) => {
+    const contentType = String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+    const extension = audioAttachmentExtension(contentType);
+    if (!extension) {
+      res.status(415).json({ error: 'unsupported audio type' });
+      return;
+    }
+    if (!Buffer.isBuffer(req.body) || req.body.length === 0) {
+      res.status(400).json({ error: 'empty audio attachment' });
+      return;
+    }
+    const attachmentsDir = imageAttachmentsDir();
+    fs.mkdirSync(attachmentsDir, { recursive: true });
+    const filename = `pasted-audio-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.${extension}`;
+    const filePath = path.join(attachmentsDir, filename);
+    fs.writeFileSync(filePath, req.body);
+    void cleanupExpiredImageAttachments();
+    res.status(201).json({ path: filePath, name: filename, type: contentType, size: req.body.length });
+  }
+);
+
 app.get(routePath(BASE_PATH, '/api/codex/models'), async (req, res) => {
   try {
     const catalog = await codexModelOptionsCache.get('catalog');
@@ -968,8 +1007,8 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/session-view'), async (req, r
 });
 
 app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-transcript'), async (req, res) => {
-  // Legacy JSONL transcript reader. New App Server Agents use the dedicated
-  // structured endpoint below; Terminal Agents stay in their terminal UI.
+  // Legacy JSONL transcript reader. ACP Chat uses the dedicated ACP endpoint;
+  // Terminal Agents stay in their terminal UI.
   const providerSession = agentManager.getAgentProviderSession(req.params.agentId);
   if (!providerSession) {
     res.status(404).json({ error: 'Agent not found' });
@@ -999,9 +1038,7 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-transcript'), async (re
       : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
     const transcript = await readCodexTranscript(providerSession.sessionId, {
       maxTurns,
-      codexHome: runtimeKind(providerSession) === 'app-server'
-        ? (providerSession.codexAppServerHomePath || providerSession.providerHomePath || '')
-        : (providerSession.providerHomePath || ''),
+      codexHome: providerSession.providerHomePath || '',
     });
     res.json({ transcript });
   } catch (error) {
@@ -1010,20 +1047,6 @@ app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-transcript'), async (re
   }
 });
 
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-app-server-transcript'), async (req, res) => {
-  try {
-    const requestedMaxTurns = Number.parseInt(String(req.query.maxTurns || ''), 10);
-    const maxTurns = Number.isFinite(requestedMaxTurns)
-      ? Math.min(MAX_CODEX_TRANSCRIPT_TURNS, Math.max(20, requestedMaxTurns))
-      : DEFAULT_CODEX_TRANSCRIPT_MAX_TURNS;
-    const transcript = agentManager.getCodexAppServerTranscript(req.params.agentId, { maxTurns });
-    res.json({ transcript });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read Codex App Server transcript';
-    res.status(/not using the Codex App Server runtime/i.test(message) ? 409 : 500).json({ error: message });
-  }
-});
-
 app.get(routePath(BASE_PATH, '/api/agents/:agentId/json-cli-transcript'), async (req, res) => {
   try {
     const transcript = agentManager.getJsonCliTranscript(req.params.agentId, {
@@ -1191,6 +1214,15 @@ app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/authenticate'),
   }
 });
 
+app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/logout'), async (req, res) => {
+  try {
+    res.json(await agentManager.logoutAcpAgent(req.params.agentId));
+  } catch (error) {
+    const message = error && error.message ? error.message : 'Failed to log out ACP Agent';
+    res.status(message === 'Agent not found' ? 404 : 409).json({ error: message });
+  }
+});
+
 app.post(routePath(BASE_PATH, '/api/agents/:agentId/acp-session/fork'), express.json(), async (req, res) => {
   try {
     res.json(await agentManager.forkAcpSession(req.params.agentId, req.body || {}));
@@ -1243,41 +1275,6 @@ app.patch(routePath(BASE_PATH, '/api/agents/:agentId/acp-session'), express.json
   }
 });
 
-app.get(routePath(BASE_PATH, '/api/agents/:agentId/codex-goal'), async (req, res) => {
-  try {
-    const goal = await agentManager.getCodexAppServerGoal(req.params.agentId);
-    res.json({ goal });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to read Codex goal';
-    res.status(message === 'Agent not found' ? 404 : 400).json({ error: message });
-  }
-});
-
-app.patch(routePath(BASE_PATH, '/api/agents/:agentId/codex-goal'), express.json(), async (req, res) => {
-  try {
-    const body = req.body || {};
-    const goal = await agentManager.setCodexAppServerGoal(req.params.agentId, {
-      objective: typeof body.objective === 'string' ? body.objective : undefined,
-      status: typeof body.status === 'string' ? body.status : undefined,
-      ...(Object.prototype.hasOwnProperty.call(body, 'tokenBudget') ? { tokenBudget: body.tokenBudget } : {}),
-    });
-    res.json({ goal });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to update Codex goal';
-    res.status(message === 'Agent not found' ? 404 : 400).json({ error: message });
-  }
-});
-
-app.delete(routePath(BASE_PATH, '/api/agents/:agentId/codex-goal'), async (req, res) => {
-  try {
-    await agentManager.clearCodexAppServerGoal(req.params.agentId);
-    res.json({ goal: null });
-  } catch (error) {
-    const message = error && error.message ? error.message : 'Failed to clear Codex goal';
-    res.status(message === 'Agent not found' ? 404 : 400).json({ error: message });
-  }
-});
-
 app.post(routePath(BASE_PATH, '/api/agents/:agentId/codex-terminal-profile'), express.json(), async (req, res) => {
   const requestAbort = new globalThis.AbortController();
   const abortRequest = () => requestAbort.abort(new Error('Terminal profile request was canceled'));
@@ -1710,7 +1707,7 @@ async function resumeAgentSessionById(provider, rawSessionId, options = {}) {
         requiredCliVersion: normalizedProvider === 'codex' && session ? session.cliVersion : '',
         projectWorkspace: session ? (session.workspace || session.cwd || '') : '',
         source: shouldFork ? resumeSource.replace('-history:', '-history-fork:') : resumeSource,
-        agentRuntimeMode: options.agentRuntimeMode === 'acp' ? 'acp' : 'terminal',
+        agentRuntimeMode: ['chat', 'acp'].includes(options.agentRuntimeMode) ? 'chat' : 'terminal',
         acpHistoryMode: options.acpHistoryMode === 'resume' ? 'resume' : 'load',
         providerHomeId: resolvedProviderHomeId,
         providerHomePath: session ? (session.providerHomePath || '') : '',
@@ -1754,7 +1751,7 @@ async function startResumedAgentSession(req, res, provider, rawSessionId) {
     allowUnarchiveArchived,
     providerHomeId: req.body && typeof req.body.providerHomeId === 'string' ? req.body.providerHomeId : '',
     customTitle: req.body && typeof req.body.customTitle === 'string' ? req.body.customTitle : '',
-    agentRuntimeMode: req.body && req.body.agentRuntimeMode === 'acp' ? 'acp' : 'terminal',
+    agentRuntimeMode: req.body && ['chat', 'acp'].includes(req.body.agentRuntimeMode) ? 'chat' : 'terminal',
     acpHistoryMode: req.body && req.body.acpHistoryMode === 'resume' ? 'resume' : 'load',
   });
 
@@ -2018,66 +2015,66 @@ async function sendInputMessage(ws, data) {
 
 async function sendComposerInputMessage(ws, data) {
   const targetAgentId = resolveInputTargetAgentId(ws, data);
+  const requestId = typeof data.requestId === 'string' ? data.requestId : '';
+  const responseAgentId = targetAgentId || (typeof data.agentId === 'string' ? data.agentId : '');
+  const respond = (accepted, message = '') => {
+    if (!requestId || !responseAgentId) return;
+    ws.send(JSON.stringify({
+      type: 'composer-input-result',
+      requestId,
+      agentId: responseAgentId,
+      accepted,
+      ...(message ? { message } : {}),
+    }));
+  };
   const message = typeof data.message === 'string' ? data.message : '';
   const content = [];
   if (message.trim()) content.push({ type: 'text', text: message });
   const attachmentsRoot = path.resolve(imageAttachmentsDir());
   const attachments = Array.isArray(data.attachments) ? data.attachments.slice(0, 8) : [];
   for (const attachment of attachments) {
-    if (attachment?.kind !== 'image' || typeof attachment.path !== 'string') continue;
+    if (!['image', 'audio'].includes(attachment?.kind) || typeof attachment.path !== 'string') continue;
     const filePath = path.resolve(attachment.path);
     if (!filePath.startsWith(`${attachmentsRoot}${path.sep}`)) continue;
-    const mimeType = typeof attachment.type === 'string' && /^image\/(?:png|jpe?g|gif|webp)$/i.test(attachment.type)
+    const mimeType = typeof attachment.type === 'string' && attachment.kind === 'image' && /^image\/(?:png|jpe?g|gif|webp)$/i.test(attachment.type)
       ? attachment.type.toLowerCase()
-      : '';
+      : (typeof attachment.type === 'string' && attachment.kind === 'audio' && Object.hasOwn(AUDIO_ATTACHMENT_EXTENSIONS, attachment.type.toLowerCase())
+        ? attachment.type.toLowerCase()
+        : '');
     if (!mimeType) continue;
     try {
       const data = await fs.promises.readFile(filePath);
       if (data.length === 0 || data.length > 12 * 1024 * 1024) continue;
       content.push({
-        type: 'image',
+        type: attachment.kind,
         data: data.toString('base64'),
         mimeType,
+        path: filePath,
         uri: pathToFileURL(filePath).href,
       });
     } catch {
       // The text fallback already explains failed or unavailable uploads.
     }
   }
-  if (!targetAgentId || content.length === 0) return;
+  if (!targetAgentId || content.length === 0) {
+    respond(false, 'Composer message is empty');
+    return;
+  }
   const targetAgent = agentManager.getState().agents.find(agent => agent.id === targetAgentId);
   const structuredRuntime = targetAgent && runtimeKind(targetAgent) !== 'terminal';
   if (!structuredRuntime) {
-    ws.send(JSON.stringify({
-      type: 'error',
-      message: 'Terminal Composer input requires the active terminal owner',
-    }));
+    const error = 'Terminal Composer input requires the active terminal owner';
+    if (requestId) respond(false, error);
+    else ws.send(JSON.stringify({ type: 'error', message: error }));
     return;
   }
   try {
     await agentManager.sendComposerMessage(targetAgentId, content);
+    respond(true);
   } catch (error) {
-    ws.send(JSON.stringify({
-      type: 'error',
-      message: error && error.message ? error.message : 'Failed to send Composer message',
-    }));
-  }
-}
-
-async function respondToAppServerRequest(ws, data) {
-  const targetAgentId = resolveInputTargetAgentId(ws, data);
-  const requestId = typeof data.requestId === 'string' ? data.requestId : '';
-  if (!targetAgentId || !requestId) return;
-  try {
-    agentManager.respondToCodexAppServerRequest(targetAgentId, requestId, data.result, {
-      reject: data.reject === true,
-      reason: typeof data.reason === 'string' ? data.reason : '',
-    });
-  } catch (error) {
-    ws.send(JSON.stringify({
-      type: 'error',
-      message: error && error.message ? error.message : 'Failed to respond to Codex App Server request',
-    }));
+    const message = error && error.message ? error.message : 'Failed to send Composer message';
+    if (requestId) respond(false, message);
+    else ws.send(JSON.stringify({ type: 'error', message }));
   }
 }
 
@@ -2107,12 +2104,11 @@ function handleMessage(ws, data) {
         workflowTemplate: typeof data.workflowTemplate === 'string' ? data.workflowTemplate : '',
         customTitle: typeof data.customTitle === 'string' ? data.customTitle : '',
         codexApprovalMode: typeof data.codexApprovalMode === 'string' ? data.codexApprovalMode : undefined,
-        codexRuntimeMode: data.codexRuntimeMode === 'app-server' || data.codexRuntimeMode === 'cli'
-          ? data.codexRuntimeMode
-          : undefined,
-        agentRuntimeMode: ['json', 'acp'].includes(data.agentRuntimeMode) ? data.agentRuntimeMode : 'terminal',
+        agentRuntimeMode: ['json', 'acp', 'chat'].includes(data.agentRuntimeMode) ? data.agentRuntimeMode : 'terminal',
         acpHistoryMode: data.acpHistoryMode === 'resume' ? 'resume' : 'load',
         providerHomeId: typeof data.providerHomeId === 'string' ? data.providerHomeId : '',
+        ...(Array.isArray(data.additionalDirectories) ? { additionalDirectories: data.additionalDirectories } : {}),
+        ...(Array.isArray(data.mcpServers) ? { mcpServers: data.mcpServers } : {}),
         ...(data.dangerouslySkipPermissions === true ? { dangerouslySkipPermissions: true } : {}),
       });
       break;
@@ -2129,12 +2125,6 @@ function handleMessage(ws, data) {
       }
       break;
 
-    case 'app-server-request-response':
-      {
-        void respondToAppServerRequest(ws, data);
-      }
-      break;
-
     case 'acp-permission-response':
       try {
         agentManager.respondToAcpPermission(
@@ -2717,7 +2707,6 @@ module.exports = {
   server,
   wss,
   agentManager,
-  appServerApiBridge,
   workspaceFileService,
   handleMessage,
   resolveCliBinDir,

package/backend/storage-layout.js

@@ -1,6 +1,5 @@
 const os = require('os');
 const path = require('path');
-const crypto = require('crypto');
 
 function farmingConfigDir(env = process.env) {
   return env.FARMING_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.farming');
@@ -42,6 +41,10 @@ function reviewSessionsFile(configDir) {
   return path.join(historyDir(configDir), 'review-sessions.json');
 }
 
+function usageHistoryCacheFile(configDir) {
+  return path.join(historyDir(configDir), 'usage-history-v2.sqlite3');
+}
+
 function sessionIndexFile(configDir) {
   return path.join(sessionsDir(configDir), 'index.json');
 }
@@ -110,23 +113,8 @@ function farmingNetTrustFile(configDir) {
   return path.join(configDir, 'farming-net-trust.json');
 }
 
-function codexAppServerRuntimeDir(configDir) {
-  return path.join(configDir, 'c');
-}
-
-function codexAppServerAgentHome(configDir, agentId) {
-  const safeAgentId = String(agentId || '').trim();
-  if (!/^agent-[A-Za-z0-9_-]+$/.test(safeAgentId)) {
-    throw new Error('Invalid Codex App Server agent id');
-  }
-  const homeId = crypto.createHash('sha256').update(safeAgentId).digest('hex').slice(0, 16);
-  return path.join(codexAppServerRuntimeDir(configDir), homeId);
-}
-
 module.exports = {
   acpCheckpointsDir,
-  codexAppServerAgentHome,
-  codexAppServerRuntimeDir,
   farmingNetInstancesFile,
   farmingNetServerLogFile,
   farmingNetServerStateFile,
@@ -153,4 +141,5 @@ module.exports = {
   themeSettingsFile,
   updateLogFile,
   updateStateFile,
+  usageHistoryCacheFile,
 };