@ordewell/core 0.6.2 → 0.6.4

package/dist/index.mjs

@@ -2345,7 +2345,10 @@ var WRAPPER_FAMILY = {
   // The multi-call binary ships its own `rm`, `mv` and `sh`, so the refused
   // name arrives as its first argument.
   busybox: { booleanFlags: ["--list", "--install", ...HELP_FLAGS] },
-  command: { booleanFlags: ["-p"], noExecFlags: ["-v", "-V"] }
+  command: { booleanFlags: ["-p"], noExecFlags: ["-v", "-V"] },
+  // Runs the named shell builtin, so `builtin eval …` is an `eval`. Classified
+  // on its own name it only asked, and a grant for `builtin echo` covered it.
+  builtin: {}
 };
 var XARGS_SPEC = {
   valueFlags: [
@@ -2477,6 +2480,8 @@ function lex(command, nested, dialect) {
   let unbalanced = false;
   let grouped = false;
   let joinedBy;
+  let followable = true;
+  let bareSegment = false;
   let tokens = [];
   let expandable = false;
   let current = "";
@@ -2506,9 +2511,20 @@ function lex(command, nested, dialect) {
     current = "";
     started = false;
   };
-  const endSegment = (nextPiped, next = "other") => {
+  const endSegment = (nextPiped, next = "other", last = false) => {
     endToken();
-    if (tokens.length > 0) segments.push({ ...toSegment(tokens, piped, dialect), expandable, inputs, joinedBy });
+    if (!last && next === "other") followable = false;
+    if (tokens.length > 0) {
+      const seg = toSegment(tokens, piped, dialect);
+      if (!seg.binary) {
+        followable = false;
+        bareSegment = true;
+      }
+      segments.push({ ...seg, expandable, inputs, joinedBy });
+    } else if (!last || segments.length > 0 || joinedBy !== void 0) {
+      followable = false;
+      bareSegment = true;
+    }
     tokens = [];
     inputs = [];
     expandable = false;
@@ -2663,8 +2679,8 @@ function lex(command, nested, dialect) {
     i++;
   }
   if (quote !== "") unbalanced = true;
-  endSegment(false);
-  return { segments, unsafeRedirect, processSubstitution, unbalanced, grouped };
+  endSegment(false, "other", true);
+  return { segments, unsafeRedirect, processSubstitution, unbalanced, grouped, followable, bareSegment };
 }
 function binaryName(token, dialect) {
   const base = token.split(/[/\\]/).pop() ?? "";
@@ -2808,7 +2824,8 @@ function lexAll(command, dialect, cdpathSet = false) {
   const queue = [];
   const top = lex(command, queue, dialect);
   const all = { ...top, segments: top.segments.filter((s) => s.binary) };
-  if (!top.grouped && queue.length === 0 && !cdpathSet) followCd(all.segments);
+  markShellState(all.segments, top.bareSegment);
+  if (top.followable && !top.grouped && queue.length === 0 && !cdpathSet) followCd(all.segments);
   for (let depth = 0; depth < 32 && queue.length > 0; depth++) {
     const inner = lex(queue.shift(), queue, dialect);
     all.segments.push(...inner.segments.filter((s) => s.binary));
@@ -2825,22 +2842,51 @@ function literalCdTarget(seg) {
   return target === "" || target.startsWith("-") || target.startsWith("~") || /[*?[]/.test(target) ? void 0 : target;
 }
 function followCd(segments) {
-  if (segments.some((s) => s.joinedBy === "other")) return;
+  if (segments.some((s) => s.joinedBy === "other" || SHELL_STATE_COMMANDS.has(s.binary))) return;
+  const inPipeline = (i) => segments[i].joinedBy === "pipe" || segments[i + 1]?.joinedBy === "pipe";
+  if (segments.some((s, i) => s.binary === "cd" && !inPipeline(i) && literalCdTarget(s) === void 0)) return;
   let chain = [];
   segments.forEach((seg, i) => {
     seg.cwd = chain;
-    const inPipeline = seg.joinedBy === "pipe" || segments[i + 1]?.joinedBy === "pipe";
-    const target = inPipeline ? void 0 : literalCdTarget(seg);
+    const target = inPipeline(i) ? void 0 : literalCdTarget(seg);
     if (target !== void 0) chain = [...chain, target];
   });
 }
+function markShellState(segments, bareSegment) {
+  if (!bareSegment && !segments.some((s) => SHELL_STATE_COMMANDS.has(s.binary))) return;
+  for (const seg of segments) if (seg.binary === "cd") seg.cdSteered = true;
+}
+var SHELL_STATE_COMMANDS = /* @__PURE__ */ new Set([
+  "export",
+  "set",
+  "shopt",
+  "declare",
+  "typeset",
+  "readonly",
+  "local",
+  "unset",
+  "let",
+  "source",
+  ".",
+  "eval",
+  "exec",
+  "pushd",
+  "popd",
+  "alias",
+  "unalias",
+  "builtin",
+  "command",
+  "enable",
+  "hash",
+  "trap"
+]);
 function looksLikePath(arg) {
   if (arg.startsWith("--") && arg.includes("=")) return looksLikePath(arg.slice(arg.indexOf("=") + 1));
   return arg.startsWith("/") || arg.startsWith("~") || arg.startsWith("../") || arg === ".." || arg.startsWith("./") || /^[A-Za-z]:/.test(arg) || arg.startsWith("\\") || arg.startsWith("..\\") || arg.startsWith(".\\") || /(^|[\\/])\.\.([\\/]|$)/.test(arg);
 }
 function pathRefs(command, opts = {}) {
   const dialect = dialectFor(opts.dialect);
-  return lexAll(command, dialect, opts.cdpathSet).segments.flatMap((seg) => {
+  return lexAll(command.trim(), dialect, opts.cdpathSet).segments.flatMap((seg) => {
     const patterns = patternArgs(seg);
     const cwd = seg.cwd ?? [];
     return [...seg.args.filter((_, i) => !patterns.has(i)), ...seg.inputs].flatMap(pathIn).map((path26) => ({ path: path26, cwd }));
@@ -3008,7 +3054,7 @@ function scopeFor(seg) {
   return [seg.binary, ...lead].join(" ");
 }
 function isAuto(seg, opts) {
-  if (seg.binary === "cd") return !opts.cdpathSet && literalCdTarget(seg) !== void 0;
+  if (seg.binary === "cd") return !opts.cdpathSet && !seg.cdSteered && literalCdTarget(seg) !== void 0;
   if (!AUTO_COMMANDS.includes(seg.binary)) return false;
   if (seg.expandable) return false;
   if (seg.binary !== "git") return true;
@@ -3032,6 +3078,9 @@ function refusalFor(seg) {
   if (seg.binary === "source" || seg.binary === ".") {
     return `"${seg.binary}" runs a file's contents as commands, which this classifier cannot inspect. Use the read-only research tools, or describe it as a task.`;
   }
+  if (seg.binary === "enable" && seg.args.some((a) => /^-[a-zA-Z]*f/.test(a))) {
+    return `"enable -f" loads a shared library into the shell, which runs its code. Use the read-only research tools, or describe it as a task.`;
+  }
   if (SHELL_KEYWORDS.includes(seg.binary)) {
     return `"${seg.binary}" is a shell keyword or compound-command opener. This classifier only inspects the command that runs first, and a keyword hides the real one from it. Run the inner command directly, or describe it as a task.`;
   }
@@ -3142,6 +3191,9 @@ function classifyCommand(command, opts = {}) {
   }
   const nonAuto = unwrapped.filter((u) => u.runner !== void 0 || !isAuto(u.seg, opts));
   if (nonAuto.length === 0) return { tier: "auto", scope: "" };
+  if (nonAuto.some((u) => u.seg.binary === "cd" || u.seg.binary !== "command" && SHELL_STATE_COMMANDS.has(u.seg.binary))) {
+    return { tier: "ask", scope: trimmed };
+  }
   const scope = [...new Set(nonAuto.map((u) => u.runner ? `${u.runner} ${scopeFor(u.seg)}` : scopeFor(u.seg)))].sort().join(" + ");
   return { tier: "ask", scope };
 }
@@ -3210,6 +3262,9 @@ function researchShellWarning(shell) {
   if (shell.dialect !== "cmd") return null;
   return "No POSIX shell was found on this machine, so research commands run through cmd.exe, where most read-only tools (ls, cat, wc, head, grep, find) do not exist. Installing Git for Windows provides one and restores the full research toolset.";
 }
+function researchPolicyOptions(shell) {
+  return { dialect: shell.dialect, cdpathSet: !!process.env.CDPATH };
+}
 
 // src/services/pathScope.ts
 import * as os from "os";
@@ -3443,7 +3498,7 @@ ${refs.output.trim()}`);
     return [...found].map(([scope, abs]) => ({ abs, scope }));
   }
   policyOptions() {
-    return { dialect: this.researchShell.dialect, cdpathSet: !!process.env.CDPATH };
+    return researchPolicyOptions(this.researchShell);
   }
   /**
    * Three tiers (see `commandPolicy.ts`): read-only inspection runs silently,
@@ -7726,16 +7781,15 @@ function nonPromptingFs(fs16) {
     findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs16.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
     listDir: (p, depth) => withinWorkspace(p) ? fs16.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
     bash: async (command, signal) => {
-      const dialect = resolveResearchShell().dialect;
-      const policy = { dialect, cdpathSet: !!process.env.CDPATH };
+      const policy = researchPolicyOptions(resolveResearchShell());
       const { tier, reason } = classifyCommand(command, policy);
       if (tier !== "auto") {
         return refused2(
           tier === "refuse" ? `Command refused: ${reason}` : `"${command}" needs user approval, and research agents run in the background where nothing can be approved. Use the read-only research tools, and note in your digest that this command would answer the question.`
         );
       }
-      const escaping = pathRefs(command, policy).find((ref) => !resolveRef(fs16.getWorkspaceRoot(), ref).inside);
-      if (escaping) return outsideRefusal(escaping.path);
+      const escaping = pathRefs(command, policy).map((ref) => resolveRef(fs16.getWorkspaceRoot(), ref)).find((r) => !r.inside);
+      if (escaping) return outsideRefusal(escaping.abs);
       return fs16.bash(command, signal);
     }
   };
@@ -10774,11 +10828,17 @@ function buildShellInvocation(command, args) {
   const inner = [command, ...args].map(posixShellQuote).join(" ");
   return { shellPath: "/bin/bash", shellArgs: ["-lc", inner] };
 }
+var BSD_SCRIPT_PLATFORMS = /* @__PURE__ */ new Set(["darwin", "freebsd", "openbsd", "netbsd"]);
+var BSD_SCRIPT_FEED = 'exec 5<&0; p=$(mktemp) || exit 1; { cat <&5 & echo $! >"$p"; wait; } 2>/dev/null | { script -q -e -F /dev/null /bin/sh -c "$0"; s=$?; kill "$(cat "$p")" 2>/dev/null; rm -f "$p"; exit $s; }';
 function wrapWithPty(command, args, opts = {}) {
   const inner = [command, ...args].map(posixShellQuote).join(" ");
   const watcher = opts.controlChannel ? 'exec 4<&0; ( while read -r C R <&3; do stty cols "$C" rows "$R" <&4; done ) & ' : "";
   const setup = opts.size ? `stty cols ${opts.size.cols} rows ${opts.size.rows}; ` : "";
-  return { command: "script", args: ["-q", "-e", "-f", "-c", `${watcher}${setup}${inner}`, "/dev/null"] };
+  const line = `${watcher}${setup}${inner}`;
+  if (BSD_SCRIPT_PLATFORMS.has(opts.platform ?? process.platform)) {
+    return { command: "/bin/sh", args: ["-c", BSD_SCRIPT_FEED, line] };
+  }
+  return { command: "script", args: ["-q", "-e", "-f", "-c", line, "/dev/null"] };
 }
 
 // src/services/blockingPrompts.ts
@@ -10973,24 +11033,37 @@ var Block = /* @__PURE__ */ ((Block2) => {
   Block2[Block2["IfHeadlessSession"] = 8] = "IfHeadlessSession";
   Block2[Block2["IfInteractiveVariant"] = 9] = "IfInteractiveVariant";
   Block2[Block2["IfProjectTrust"] = 10] = "IfProjectTrust";
+  Block2[Block2["IfHeadlessModel"] = 11] = "IfHeadlessModel";
   return Block2;
 })(Block || {});
 function isInteractive(ctx) {
   return ctx.interactive ?? !ctx.headless;
 }
+function majorVersion(version) {
+  const match = version?.match(/(\d+)\.\d+/);
+  return match ? Number(match[1]) : void 0;
+}
+function versionedInvocation(manifest, ctx) {
+  const major = majorVersion(ctx.runnerVersion);
+  if (major === void 0) return void 0;
+  return (manifest.runner.versioned ?? []).filter((v) => major >= v.minMajor).sort((a, b) => b.minMajor - a.minMajor)[0];
+}
 function resolveArgs(manifest, ctx) {
   const args = [];
   const env = {};
-  if (manifest.runner.env) {
-    for (const [key, value] of Object.entries(manifest.runner.env)) {
+  const versioned = versionedInvocation(manifest, ctx);
+  const argsTemplate = versioned?.argsTemplate ?? manifest.runner.argsTemplate;
+  const envTemplate = versioned ? versioned.env : manifest.runner.env;
+  if (envTemplate) {
+    for (const [key, value] of Object.entries(envTemplate)) {
       const resolved = substituteSimple(value, ctx);
       if (resolved.length > 0) env[key] = resolved;
     }
   }
   let block = 0 /* None */;
   let include = true;
-  for (let i = 0; i < manifest.runner.argsTemplate.length; i++) {
-    const raw = manifest.runner.argsTemplate[i];
+  for (let i = 0; i < argsTemplate.length; i++) {
+    const raw = argsTemplate[i];
     const blockOpen = parseBlockOpen(raw);
     if (blockOpen !== null) {
       if (block !== 0 /* None */) throw new ResolveError(`Nested conditional block at position ${i}: "${raw}"`);
@@ -11049,6 +11122,8 @@ function parseBlockOpen(raw) {
       return 9 /* IfInteractiveVariant */;
     case "{{if projectTrust}}":
       return 10 /* IfProjectTrust */;
+    case "{{if headlessModel}}":
+      return 11 /* IfHeadlessModel */;
     default:
       return null;
   }
@@ -11088,6 +11163,9 @@ function shouldIncludeBlock(block, ctx) {
     // there is no cwd to name.
     case 10 /* IfProjectTrust */:
       return isInteractive(ctx) && !!ctx.cwd;
+    // A model flag that only the non-interactive subcommand takes.
+    case 11 /* IfHeadlessModel */:
+      return !!ctx.model && !isInteractive(ctx);
     default:
       return true;
   }
@@ -11133,6 +11211,10 @@ function resolveToken(token, manifest, ctx) {
   if (token === "{{model}}") return ctx.model || "";
   if (token === "{{thinkingEffort}}") return ctx.thinkingEffort || "";
   if (token === "{{mode}}") return ctx.mode || "build";
+  if (token === "{{modelWithVariant}}") {
+    if (!ctx.model) return "";
+    return ctx.thinkingEffort ? `${ctx.model}#${ctx.thinkingEffort}` : ctx.model;
+  }
   if (token === "{{projectTrust}}") {
     if (!ctx.cwd) return "";
     return `projects.${JSON.stringify(ctx.cwd)}.trust_level="trusted"`;
@@ -11207,13 +11289,21 @@ function resolveOpencodeVariantConfig(ctx) {
   }
   return JSON.stringify(config);
 }
+function resolveOpencodeSessionConfig(ctx) {
+  const mode = ctx.mode || "build";
+  const pinned = resolveOpencodeVariantConfig(ctx);
+  const config = pinned ? JSON.parse(pinned) : {};
+  config.default_agent = mode;
+  if (ctx.model && !pinned) config.agent = { [mode]: { model: ctx.model } };
+  return JSON.stringify(config);
+}
 function substituteSimple(value, ctx) {
   const conditioned = value.replace(/\{\{if (\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (match, name, body) => {
     const block = parseBlockOpen(`{{if ${name}}}`);
     if (block === null) return match;
     return shouldIncludeBlock(block, ctx) ? body : "";
   });
-  return conditioned.replace(/\{\{opencodeVariantConfig\}\}/g, () => resolveOpencodeVariantConfig(ctx)).replace(/\{\{prompt\}\}/g, ctx.prompt).replace(/\{\{model\}\}/g, ctx.model || "").replace(/\{\{thinkingEffort\}\}/g, ctx.thinkingEffort || "").replace(/\{\{mode\}\}/g, ctx.mode || "build");
+  return conditioned.replace(/\{\{opencodeVariantConfig\}\}/g, () => resolveOpencodeVariantConfig(ctx)).replace(/\{\{opencodeSessionConfig\}\}/g, () => resolveOpencodeSessionConfig(ctx)).replace(/\{\{prompt\}\}/g, ctx.prompt).replace(/\{\{model\}\}/g, ctx.model || "").replace(/\{\{thinkingEffort\}\}/g, ctx.thinkingEffort || "").replace(/\{\{mode\}\}/g, ctx.mode || "build");
 }
 
 // src/utils/launch.ts
@@ -20138,13 +20228,33 @@ function buildRunnerInvocation(opts) {
     mode: opts.mode ?? "build",
     headless: opts.headless,
     interactive: opts.interactive,
-    cwd: opts.cwd
+    cwd: opts.cwd,
+    runnerVersion: opts.runnerVersion
   });
 }
 
 // src/services/HeadlessRunner.ts
 import { spawn as nodeSpawn2, execSync } from "child_process";
 
+// src/services/runnerVersion.ts
+import { execFile as execFile4 } from "child_process";
+var VERSION_TIMEOUT_MS = 5e3;
+var cache = /* @__PURE__ */ new Map();
+var probeRunnerVersion = (command, PATH) => {
+  const key = `${command}\0${PATH}`;
+  let pending = cache.get(key);
+  if (!pending) {
+    pending = new Promise((resolve7) => {
+      execFile4(command, ["--version"], { env: { ...process.env, PATH }, timeout: VERSION_TIMEOUT_MS }, (err, stdout) => {
+        const line = String(stdout ?? "").trim();
+        resolve7(err || !line ? void 0 : line);
+      });
+    });
+    cache.set(key, pending);
+  }
+  return pending;
+};
+
 // src/services/AbstractRunner.ts
 import { EventEmitter } from "events";
 var AbstractTerminalSession = class {
@@ -20265,6 +20375,10 @@ Process error: ${err.message}
       this.process.stdin.write(text);
     }
   }
+  /** Closes the runner's stdin: what it has read so far is all it will get. */
+  endInput() {
+    this.process?.stdin?.end();
+  }
   /** PTY resize requests from a surface that owns the terminal rendering the wrapper. */
   writeControl(text) {
     if (this.controlStream && !this.controlStream.destroyed) {
@@ -20277,6 +20391,7 @@ var HeadlessRunner = class extends AbstractRunner {
   hasScriptCmd;
   resolvePath;
   launchDeps;
+  runnerVersion;
   spawnCount = 0;
   /**
    * Session shape: a piped subprocess is not a terminal, so runners get their
@@ -20292,6 +20407,7 @@ var HeadlessRunner = class extends AbstractRunner {
     this.hasScriptCmd = deps.hasScriptCmd ?? defaultHasScriptCmd;
     this.resolvePath = deps.resolvePath ?? augmentedPath;
     this.launchDeps = { resolvePath: this.resolvePath, ...deps.launchDeps };
+    this.runnerVersion = deps.runnerVersion ?? probeRunnerVersion;
   }
   /**
    * Unique per spawn, not per task: a retry reuses its task id and ids often
@@ -20309,6 +20425,9 @@ var HeadlessRunner = class extends AbstractRunner {
   /** Everything up to, but not including, spawning — so a surface that owns its own child reaches the same decisions. */
   async prepareLaunch(opts, ptyOptions) {
     const interactive = this.defaultInteractive;
+    const resolvedPath = await this.resolvePath();
+    const manifest = opts.registry?.get(opts.runner)?.manifest;
+    const runnerVersion = manifest?.runner.versioned?.length ? await this.runnerVersion(manifest.runner.command, resolvedPath) : void 0;
     const invocation = buildRunnerInvocation({
       runner: opts.runner,
       prompt: opts.prompt,
@@ -20319,18 +20438,18 @@ var HeadlessRunner = class extends AbstractRunner {
       headless: opts.headless ?? true,
       interactive,
       cwd: opts.cwd,
+      runnerVersion,
       registry: opts.registry
     });
-    const manifest = opts.registry?.get(opts.runner)?.manifest;
     const pty = (manifest?.runner.requiresTty === true || interactive) && this.hasScriptCmd();
-    const resolvedPath = await this.resolvePath();
-    const { command, args } = pty ? wrapWithPty(invocation.command, invocation.args, ptyOptions) : { command: invocation.command, args: invocation.args };
+    const { command, args } = pty ? wrapWithPty(invocation.command, invocation.args, { platform: this.launchDeps.platform, ...ptyOptions }) : { command: invocation.command, args: invocation.args };
     return {
       launch: await planDirectLaunch(command, args, this.launchDeps),
       resolvedPath,
       env: { ...opts.env, ...invocation.env },
       pty,
-      submitPromptKey: invocation.submitPromptKey
+      submitPromptKey: invocation.submitPromptKey,
+      closeStdin: !pty && !interactive && invocation.promptInArgs
     };
   }
   async spawn(opts) {
@@ -20341,13 +20460,14 @@ var HeadlessRunner = class extends AbstractRunner {
     console.error(`[headless] Starting ${opts.runner} [${modeStr}] (${opts.modelId || "default"}) for task ${opts.taskId.slice(0, 8)}${prepared.pty ? " (PTY)" : ""}`);
     session.start(prepared.launch, opts.cwd, prepared.resolvedPath, prepared.env);
     if (prepared.submitPromptKey) session.write("\r");
+    if (prepared.closeStdin) session.endInput();
     this.registerSession(id, session);
     return session;
   }
 };
 
 // src/services/TmuxRunner.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { tmpdir } from "os";
 import { join as join19 } from "path";
@@ -20404,7 +20524,7 @@ function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platfor
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
 var LIVENESS_INTERVAL_MS = 5e3;
 var LIVENESS_MISSES = 2;
-var execFileAsync2 = promisify5(execFile4);
+var execFileAsync2 = promisify5(execFile5);
 var defaultExecFile3 = async (command, args) => {
   const { stdout, stderr } = await execFileAsync2(command, args);
   return { stdout: String(stdout), stderr: String(stderr) };
@@ -20554,6 +20674,7 @@ var TmuxRunner = class extends AbstractRunner {
   pollIntervalMs;
   logDir;
   clipboardCommand;
+  runnerVersion;
   /** Retries get a freshly named window so a failed attempt's output stays inspectable. */
   attempts = /* @__PURE__ */ new Map();
   ready = null;
@@ -20566,6 +20687,7 @@ var TmuxRunner = class extends AbstractRunner {
     this.pollIntervalMs = deps.pollIntervalMs ?? 500;
     this.logDir = deps.logDir ?? tmpdir();
     this.clipboardCommand = deps.clipboardCommand ?? (() => clipboardCopyCommand());
+    this.runnerVersion = deps.runnerVersion ?? probeRunnerVersion;
   }
   /**
    * Reaps a session orphaned by a crashed prior daemon on the same port, then
@@ -20649,6 +20771,8 @@ var TmuxRunner = class extends AbstractRunner {
     }
   }
   async spawn(opts) {
+    const manifest = opts.registry?.get(opts.runner)?.manifest;
+    const runnerVersion = manifest?.runner.versioned?.length ? await this.runnerVersion(manifest.runner.command, await this.resolvePath()) : void 0;
     const invocation = buildRunnerInvocation({
       runner: opts.runner,
       prompt: opts.prompt,
@@ -20664,6 +20788,7 @@ var TmuxRunner = class extends AbstractRunner {
       headless: opts.headless ?? true,
       interactive: true,
       cwd: opts.cwd,
+      runnerVersion,
       registry: opts.registry
     });
     await this.ensureSession();
@@ -21580,6 +21705,37 @@ var OPENCODE_MANIFEST = {
     env: {
       OPENCODE_CONFIG_CONTENT: "{{if interactiveVariant}}{{opencodeVariantConfig}}{{/if}}"
     },
+    // OpenCode 2.x changed both shapes. Its TUI takes no `--model`/`--agent`,
+    // so they ride on OPENCODE_CONFIG_CONTENT instead, and its `run` has no
+    // `--variant` — the variant is a `#suffix` on the model id. Both run
+    // `--standalone`: without it the TUI and `run` attach to the user's
+    // background service, which neither reads this process's config nor
+    // starts in the task's directory and environment.
+    versioned: [{
+      minMajor: 2,
+      argsTemplate: [
+        "{{if headlessSession}}",
+        "run",
+        "--agent",
+        "{{mode}}",
+        "{{/if}}",
+        "{{if headlessModel}}",
+        "--model",
+        "{{modelWithVariant}}",
+        "{{/if}}",
+        "--standalone",
+        "{{if buildMode}}",
+        "--auto",
+        "{{/if}}",
+        "{{if interactive}}",
+        "--prompt",
+        "{{/if}}",
+        "{{prompt}}"
+      ],
+      env: {
+        OPENCODE_CONFIG_CONTENT: "{{if interactive}}{{opencodeSessionConfig}}{{/if}}"
+      }
+    }],
     promptInArgs: true,
     requiresTty: true,
     // `--prompt` only pre-fills the TUI's composer; it does not submit it.