farming-code 2.2.16 → 2.2.18

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/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/config-manager.js

@@ -306,7 +306,7 @@ class ConfigManager {
         projectNames: {},
         instanceName: '',
         theme: 'terminal',
-        appearance: 'light',
+        appearance: 'system',
         language: 'en',
         heartbeatInterval: 1000,
         dangerouslySkipAgentPermissionsByDefault: false,
@@ -342,7 +342,7 @@ class ConfigManager {
       projectNames: {},
       instanceName: '',
       theme: 'terminal',
-      appearance: 'light',
+      appearance: 'system',
       language: 'en',
       heartbeatInterval: 1000,
       dangerouslySkipAgentPermissionsByDefault: false,
@@ -498,7 +498,7 @@ class ConfigManager {
   }
 
   normalizeAppearance(appearance) {
-    return ['light', 'dark'].includes(appearance) ? appearance : 'light';
+    return ['system', 'light', 'dark'].includes(appearance) ? appearance : 'system';
   }
 
   normalizeLanguage(language) {

package/backend/farming-app-cli.js

@@ -13,6 +13,7 @@ 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;
@@ -787,6 +788,13 @@ async function run(argv = process.argv.slice(2)) {
     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/native-pty-host-client.js

@@ -14,7 +14,9 @@ const {
   allocateNativePtyControllerGeneration,
   positiveGeneration,
 } = require('./native-pty-controller-generation');
+const { isTemporaryProviderSessionId } = require('./provider-session-id');
 const storageLayout = require('./storage-layout');
+const { deserializeTerminalState } = require('./terminal-state-serialization');
 
 const DEFAULT_CONNECT_RETRIES = 300;
 const DEFAULT_CONNECT_RETRY_MS = 50;
@@ -463,6 +465,23 @@ class NativePtyHostClient extends EventEmitter {
     });
   }
 
+  async requirePreparedHostRotationResume(preparationToken, actual, primaryError) {
+    if (!preparationToken) return;
+    try {
+      await this.resumePreparedHostRotation(preparationToken);
+    } catch (resumeError) {
+      const recoveryError = new Error(
+        `Cannot confirm recovery of incompatible native PTY host (${actual}) after aborting rotation`
+      );
+      recoveryError.code = 'FARMING_NATIVE_HOST_ROTATION_RECOVERY_FAILED';
+      recoveryError.cause = new AggregateError(
+        [primaryError, resumeError].filter(Boolean),
+        'Native PTY rotation failed and the prepared host could not be resumed'
+      );
+      throw recoveryError;
+    }
+  }
+
   async rotateMismatchedHost(hostInfo) {
     const expected = runtimeIdentityLabel(this.expectedRuntimeIdentity);
     const actual = runtimeIdentityLabel(hostInfo && hostInfo.runtimeIdentity);
@@ -513,7 +532,11 @@ class NativePtyHostClient extends EventEmitter {
         throw new Error('The native PTY host returned an invalid rotation checkpoint');
       }
     } catch (error) {
-      await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+      if (preparationToken) {
+        await this.requirePreparedHostRotationResume(preparationToken, actual, error);
+      } else {
+        await this.resumePreparedHostRotation('').catch(() => {});
+      }
       const recovered = await this.requestOnce('recoverSessions', {}, {
         ensureConnected: false,
         retryOnDisconnect: false,
@@ -532,6 +555,40 @@ class NativePtyHostClient extends EventEmitter {
       }
     }
 
+    let unresumableCodex;
+    try {
+      unresumableCodex = deserializeTerminalState(serializedTerminalState).find(entry => {
+        const metadata = entry.metadata || {};
+        const provider = String(metadata.providerSessionProvider || metadata.provider || '').trim();
+        return provider === 'codex'
+          && metadata.terminalInputReceived === true
+          && (
+            metadata.providerSessionTemporary === true
+            || isTemporaryProviderSessionId(metadata.providerSessionId)
+          );
+      });
+    } catch (error) {
+      await this.requirePreparedHostRotationResume(preparationToken, actual, error);
+      const mismatchError = new Error(
+        `Cannot rotate incompatible native PTY host (${actual}) with an invalid terminal checkpoint`
+      );
+      mismatchError.code = 'FARMING_NATIVE_HOST_RUNTIME_MISMATCH';
+      mismatchError.cause = error;
+      throw mismatchError;
+    }
+    if (unresumableCodex) {
+      const unresumableError = new Error(
+        `Codex session ${unresumableCodex.id} has user input but no exact resume id`
+      );
+      await this.requirePreparedHostRotationResume(preparationToken, actual, unresumableError);
+      const mismatchError = new Error(
+        `Cannot rotate incompatible native PTY host (${actual}) while Codex session ${unresumableCodex.id} has user input but no exact resume id`
+      );
+      mismatchError.code = 'FARMING_NATIVE_HOST_UNRESUMABLE_SESSION';
+      mismatchError.cause = unresumableError;
+      throw mismatchError;
+    }
+
     const socket = this.socket;
     if (socket) this.suppressedDisconnectSockets.add(socket);
     let shutdownUncertain = false;
@@ -546,7 +603,7 @@ class NativePtyHostClient extends EventEmitter {
       });
     } catch (error) {
       if (!isConnectRetryable(error)) {
-        await this.resumePreparedHostRotation(preparationToken).catch(() => {});
+        await this.requirePreparedHostRotationResume(preparationToken, actual, error);
         const mismatchError = new Error(
           `Cannot rotate incompatible native PTY host (${actual}); stop the old host and restart Farming`
         );

package/backend/provider-adapters.js

@@ -7,45 +7,73 @@ const {
 } = require('./provider-session-id');
 
 const CODEX_VALUE_OPTIONS = new Set([
-  '-a', '-c', '-C', '-m', '-s', '--ask-for-approval', '--cd', '--config',
-  '--config-profile', '--model', '--profile', '--sandbox',
+  '-a', '-c', '-C', '-m', '-p', '-s', '--ask-for-approval', '--cd', '--config',
+  '--config-profile', '--model', '--profile', '--sandbox', '--add-dir',
+  '--enable', '--disable', '--remote', '--remote-auth-token-env',
+  '--local-provider', '-i', '--image',
 ]);
+const OPENCODE_VALUE_OPTIONS = new Set([
+  '-m', '-s', '--agent', '--hostname', '--log-level', '--mdns-domain',
+  '--model', '--port', '--prompt', '--replay-limit', '--session',
+]);
+const CODEX_SUBCOMMANDS = new Set([
+  'exec', 'e', 'review', 'login', 'logout', 'mcp', 'plugin', 'mcp-server',
+  'app-server', 'remote-control', 'app', 'completion', 'update', 'doctor',
+  'sandbox', 'debug', 'apply', 'a', 'resume', 'archive', 'delete', 'unarchive',
+  'fork', 'cloud', 'exec-server', 'features', 'help',
+]);
+const OPENCODE_SUBCOMMANDS = new Set([
+  'completion', 'acp', 'mcp', 'attach', 'run', 'debug', 'providers', 'auth',
+  'agent', 'upgrade', 'uninstall', 'serve', 'web', 'models', 'stats', 'export',
+  'import', 'github', 'pr', 'session', 'plugin', 'plug', 'db',
+]);
+const CODEX_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 function optionTakesValue(option, valueOptions) {
   return Boolean(option && !option.includes('=') && valueOptions.has(option));
 }
 
-function firstCodexSubcommand(args) {
+function scanPositionals(args, valueOptions, options = {}) {
+  const positionals = [];
   for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
+    const arg = String(args[index] || '');
     if (!arg) continue;
+    if (arg === '--') {
+      for (let positionalIndex = index + 1; positionalIndex < args.length; positionalIndex += 1) {
+        const value = String(args[positionalIndex] || '');
+        if (value) positionals.push({ value, index: positionalIndex, afterDelimiter: true });
+      }
+      break;
+    }
     if (arg.startsWith('-')) {
-      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
+      if (
+        options.multiValueOptions?.has(arg)
+        && !arg.includes('=')
+      ) {
+        while (index + 1 < args.length && !String(args[index + 1] || '').startsWith('-')) index += 1;
+        continue;
+      }
+      if (optionTakesValue(arg, valueOptions)) index += 1;
       continue;
     }
-    return { value: arg, index };
+    positionals.push({ value: arg, index, afterDelimiter: false });
   }
-  return null;
+  return positionals;
 }
 
 function codexSessionIdAfterSubcommand(args, subcommandIndex) {
-  const positional = [];
-  for (let index = subcommandIndex + 1; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg) continue;
-    if (arg.startsWith('-')) {
-      if (optionTakesValue(arg, CODEX_VALUE_OPTIONS)) index += 1;
-      continue;
-    }
-    positional.push(arg);
-  }
-  const sessionId = positional.at(-1) || '';
-  return isSafeProviderSessionId(sessionId) ? sessionId : '';
+  const sessionId = scanPositionals(
+    args.slice(subcommandIndex + 1),
+    CODEX_VALUE_OPTIONS,
+    { multiValueOptions: new Set(['-i', '--image']) },
+  )[0]?.value || '';
+  return CODEX_SESSION_ID_RE.test(sessionId) ? sessionId.toLowerCase() : '';
 }
 
 function argValue(args, names) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
+    if (arg === '--') break;
     for (const name of names) {
       if (arg === name) return args[index + 1] || '';
       if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
@@ -55,13 +83,26 @@ function argValue(args, names) {
 }
 
 function hasArg(args, names) {
-  return args.some(arg => names.includes(arg) || names.some(name => arg.startsWith(`${name}=`)));
+  for (const arg of args) {
+    if (arg === '--') break;
+    if (names.includes(arg) || names.some(name => arg.startsWith(`${name}=`))) return true;
+  }
+  return false;
 }
 
-function codexSessionPlan(rawArgs) {
-  const subcommand = firstCodexSubcommand(rawArgs);
+function codexSessionPlan(rawArgs, _launchArgs) {
+  const positional = scanPositionals(rawArgs, CODEX_VALUE_OPTIONS, {
+    multiValueOptions: new Set(['-i', '--image']),
+  });
+  const subcommand = positional[0]
+    && positional[0].afterDelimiter !== true
+    && CODEX_SUBCOMMANDS.has(positional[0].value)
+    ? positional[0]
+    : null;
   if (subcommand?.value === 'resume') {
-    const id = codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
+    const id = hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
+      ? ''
+      : codexSessionIdAfterSubcommand(rawArgs, subcommand.index);
     if (id) return { id, temporary: false, source: 'resume' };
   }
   if (subcommand?.value === 'fork') {
@@ -69,11 +110,22 @@ function codexSessionPlan(rawArgs) {
       id: createTemporaryProviderSessionId(),
       temporary: true,
       source: 'codex-fork-temporary',
-      forkedFromProviderSessionId: codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
+      forkedFromProviderSessionId: hasArg(rawArgs.slice(subcommand.index + 1), ['--last'])
+        ? ''
+        : codexSessionIdAfterSubcommand(rawArgs, subcommand.index),
     };
   }
-  if (subcommand?.value) return null;
-  return { id: createTemporaryProviderSessionId(), temporary: true, source: 'codex-temporary' };
+  if (subcommand) return null;
+  if (hasArg(rawArgs, ['--remote'])) {
+    return {
+      error: 'A fresh Codex --remote Terminal cannot be correlated with a local resumable session id; resume an explicit remote session id instead',
+    };
+  }
+  return {
+    id: createTemporaryProviderSessionId(),
+    temporary: true,
+    source: 'codex-temporary',
+  };
 }
 
 function explicitSessionPlan(provider, rawArgs, launchArgs) {
@@ -103,17 +155,35 @@ function explicitSessionPlan(provider, rawArgs, launchArgs) {
   };
 }
 
-function openCodeSessionPlan(rawArgs) {
+function openCodeSessionPlan(rawArgs, launchArgs) {
   const id = argValue(rawArgs, ['--session', '-s']);
-  if (!id || !isSafeProviderSessionId(id)) return null;
-  return hasArg(rawArgs, ['--fork'])
-    ? {
-      id: createTemporaryProviderSessionId(),
-      temporary: true,
-      source: 'opencode-fork-temporary',
-      forkedFromProviderSessionId: id,
-    }
-    : { id, temporary: false, source: 'resume' };
+  if (id && isSafeProviderSessionId(id)) {
+    return hasArg(rawArgs, ['--fork'])
+      ? {
+        id: createTemporaryProviderSessionId(),
+        temporary: true,
+        source: 'opencode-fork-temporary',
+        forkedFromProviderSessionId: id,
+      }
+      : { id, temporary: false, source: 'resume' };
+  }
+  if (hasArg(rawArgs, ['--session', '-s', '--continue', '-c', '--fork'])) return null;
+  const positional = scanPositionals(rawArgs, OPENCODE_VALUE_OPTIONS, {
+    multiValueOptions: new Set(['--cors']),
+  });
+  if (
+    positional[0]
+    && positional[0].afterDelimiter !== true
+    && OPENCODE_SUBCOMMANDS.has(positional[0].value)
+  ) return null;
+  return {
+    id: '',
+    precreate: true,
+    temporary: false,
+    source: 'opencode-precreate',
+    identityWorkspace: positional[0]?.value || '',
+    resumeInsertIndex: launchArgs.length,
+  };
 }
 
 function codexAcpEnvironment(options = {}) {
@@ -148,6 +218,7 @@ const PROVIDER_ADAPTERS = Object.freeze([
     commands: ['codex'],
     supportedRuntimes: ['terminal', 'acp', 'json'],
     planSession: codexSessionPlan,
+    terminalResumeArgs: (args, sessionId) => ['resume', sessionId, ...args],
     acp: { packageName: '@agentclientprotocol/codex-acp', version: '1.1.4' },
     prepareAcpEnvironment: codexAcpEnvironment,
     capabilities: { runtimeSwitch: true, terminalProfile: true, goals: false },
@@ -175,6 +246,16 @@ const PROVIDER_ADAPTERS = Object.freeze([
     commands: ['opencode'],
     supportedRuntimes: ['terminal', 'acp', 'json'],
     planSession: openCodeSessionPlan,
+    terminalResumeArgs: (args, sessionId) => {
+      const delimiterIndex = args.indexOf('--');
+      const insertIndex = delimiterIndex >= 0 ? delimiterIndex : args.length;
+      return [
+        ...args.slice(0, insertIndex),
+        '--session',
+        sessionId,
+        ...args.slice(insertIndex),
+      ];
+    },
     acp: {
       version: 'native',
       launch: options => ({