agentp 1.12.1 → 1.14.0

package/bin/ocmux

@@ -24,7 +24,10 @@ const {
   resurrectServer,
   startServer,
   getActiveServer,
+  activateServer,
+  tuiAttachCommand,
 } = require('../lib/ocmux');
+const { listSessions, listModels, switchModel, resolveModelRef } = require('../lib/opencode');
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -182,6 +185,15 @@ function printHelp() {
   console.error('            Works even if no tmux window exists (stale state file).');
   console.error('            --print-logs  Pass --print-logs to the new opencode serve.');
   console.error('  list      List all running servers with their directories and URLs.');
+  console.error('  switch    Interactively select a server to switch to.');
+  console.error('            j/k or arrows to move, Enter/Space selects (menu stays open),');
+  console.error('            q or Ctrl+C quits. Prints the URL of the last selected server on exit.');
+  console.error('  model     Switch the model of the newest session on the current server.');
+  console.error('            With no argument: interactive model picker (requires a TTY).');
+  console.error('            With <ref>: switch directly and print the server URL on stdout,');
+  console.error('            so `agentp $(ocmux model <ref>)` switches before the next prompt.');
+  console.error('            Partial names work when unique (e.g. "ocmux model deepseek",');
+  console.error('            "opencode-go/deepseek", "...#high"). Multiple matches open the picker.');
   console.error('');
   console.error('  --         Treat the next argument as a directory even if it matches');
   console.error('            a subcommand name (e.g. "ocmux -- kill").');
@@ -234,13 +246,13 @@ function cmdSwitch(statefile, longMode) {
       const panesR = tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
       const panes = panesR.stdout.trim().split('\n').filter(Boolean);
       const lastPane = panes[panes.length - 1];
-      const respawnR = tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
+      const respawnR = tmux(['respawn-pane', '-k', '-t', lastPane, tuiAttachCommand(url)]);
       if (respawnR.status !== 0) {
-        tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
+        tmux(['send-keys', '-t', lastPane, tuiAttachCommand(url), 'Enter']);
       }
     } else {
       tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', serverDir,
-        `opencode attach --continue '${url}'`]);
+        tuiAttachCommand(url)]);
     }
   }
 
@@ -253,6 +265,278 @@ function cmdSwitch(statefile, longMode) {
   outputUrl(url, serverDir, longMode);
 }
 
+// ---------------------------------------------------------------------------
+// Subcommand: switch — interactive session selection
+// ---------------------------------------------------------------------------
+
+function cmdSwitchMenu(longMode) {
+  const rows = listServers();
+  if (rows.length === 0) {
+    console.error('No opencode servers running.');
+    process.exit(1);
+  }
+  if (!process.stdin.isTTY) {
+    console.error('Error: "switch" is interactive and requires a TTY.');
+    console.error('Use "ocmux list" to list servers, or run "ocmux <dir>" to switch directly.');
+    process.exit(1);
+  }
+
+  const cols = process.stderr.columns || 80;
+  const nameW = Math.max(...rows.map(r => path.basename(r.dir).length), 4);
+  const stsW = Math.max(...rows.map(r => r.status.length), 6);
+  const urlW = Math.max(...rows.map(r => r.url.length), 3);
+  const dirW = Math.max(...rows.map(r => r.dir.length), 9);
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+  const lineWidth = Math.max(cols, nameW + 2 + stsW + 2 + urlW + 2 + dirW);
+
+  let cursor = 0;
+  let activeRow = 0;
+  let lastUrl = null;
+  let lastDir = null;
+  let exited = false;
+
+  // Query tmux for the currently active window and map it to a row. Called at
+  // init and on every draw, so the highlight always reflects tmux's real state.
+  const refreshActive = () => {
+    const idx = activeWindowIndex();
+    if (idx == null) return;
+    for (let i = 0; i < rows.length; i++) {
+      if (rows[i].index === idx) { activeRow = i; return; }
+    }
+  };
+
+  const cleanup = () => {
+    process.stderr.write('\x1b[?25h');
+    process.stderr.write('\x1b[?1049l');
+    try { process.stdin.setRawMode(false); } catch {}
+  };
+
+  const finish = () => {
+    if (exited) return;
+    exited = true;
+    cleanup();
+    process.stdin.pause();
+    if (lastUrl) outputUrl(lastUrl, lastDir, longMode);
+    process.exit(0);
+  };
+
+  const draw = () => {
+    refreshActive();
+    let out = '\x1b[2J\x1b[H';
+    out += 'ocmux switch — j/k or arrows: move, Enter/Space: select (keep switching), q/Ctrl+C: quit\n\n';
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const marker = i === cursor ? '▶ ' : '  ';
+      const line = `${marker}${pad(path.basename(row.dir), nameW)}  ${pad(row.status, stsW)}  ${pad(row.url, urlW)}  ${pad(row.dir, dirW)}`;
+      if (i === activeRow) {
+        out += '\x1b[7m' + pad(line, lineWidth) + '\x1b[0m\n';
+      } else {
+        out += line + '\n';
+      }
+    }
+    process.stderr.write(out);
+  };
+
+  const activate = (i) => {
+    const row = rows[i];
+    try {
+      activateServer(row.dir, row.index, row.url);
+      lastUrl = row.url;
+      lastDir = row.dir;
+    } catch (err) {
+      process.stderr.write(`\nError: ${err.message}\n`);
+    }
+    draw();
+  };
+
+  process.stdin.on('keypress', (str, key) => {
+    if (key.ctrl && key.name === 'c') return finish();
+    if (key.name === 'q') return finish();
+    if (key.name === 'up' || str === 'k') {
+      cursor = (cursor + rows.length - 1) % rows.length;
+      draw();
+    } else if (key.name === 'down' || str === 'j') {
+      cursor = (cursor + 1) % rows.length;
+      draw();
+    } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+      activate(cursor);
+    }
+  });
+
+  process.on('SIGINT', finish);
+  process.on('SIGTERM', finish);
+
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stderr.write('\x1b[?1049h\x1b[?25l');
+  refreshActive();
+  cursor = activeRow;
+  draw();
+}
+
+// ---------------------------------------------------------------------------
+// Subcommand: model — switch the model of the server's most recent session
+// ---------------------------------------------------------------------------
+
+// Newest session id for a server (same heuristic as agentp's default).
+function newestSessionId(sessions) {
+  if (!sessions || sessions.length === 0) return null;
+  const sorted = sessions
+    .filter(s => s && s.id && s.time && (s.time.updated || s.time.created))
+    .sort((a, b) => {
+      const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
+      const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
+      return bTime - aTime;
+    });
+  return sorted.length > 0 ? sorted[0].id : (sessions[0] && sessions[0].id) || null;
+}
+
+// Interactive model picker (mirrors the ocmux switch menu; single selection).
+// Resolves with the chosen model or null on quit.
+function modelMenu(rows) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY || rows.length === 0) return resolve(null);
+
+    // Display name when it differs from the canonical label (e.g. "Kimi K2 (opencode/kimi-k2)").
+    const display = (r) => (r.name && r.name !== r.label ? `${r.name} (${r.label})` : r.label);
+    const maxLen = Math.max(
+      ...rows.map(r => display(r).length),
+      ...rows.map(r => (r.variants || []).join(',').length),
+      8,
+    );
+    const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+    let cursor = 0;
+    let done = false;
+
+    const cleanup = () => {
+      process.stderr.write('\x1b[?25h');
+      process.stderr.write('\x1b[?1049l');
+      try { process.stdin.setRawMode(false); } catch {}
+      process.stdin.pause();
+    };
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      process.stdin.removeAllListeners('keypress');
+      process.removeListener('SIGINT', onSig);
+      resolve(value);
+    };
+    const onSig = () => finish(null);
+    process.on('SIGINT', onSig);
+
+    const draw = () => {
+      let out = '\x1b[2J\x1b[H';
+      out += 'ocmux model — j/k or arrows: move, Enter: switch, q/Ctrl+C: quit\n\n';
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const marker = i === cursor ? '▶ ' : '  ';
+        const variants = (row.variants || []).join(',') || '—';
+        out += `${marker}${pad(display(row), maxLen)}  ${variants}\n`;
+      }
+      process.stderr.write(out);
+    };
+
+    process.stdin.on('keypress', (str, key) => {
+      if (key.ctrl && key.name === 'c') return finish(null);
+      if (key.name === 'q') return finish(null);
+      if (key.name === 'up' || str === 'k') {
+        cursor = (cursor + rows.length - 1) % rows.length;
+        draw();
+      } else if (key.name === 'down' || str === 'j') {
+        cursor = (cursor + 1) % rows.length;
+        draw();
+      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+        finish(rows[cursor]);
+      }
+    });
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stderr.write('\x1b[?1049h\x1b[?25l');
+    draw();
+  });
+}
+
+async function cmdModel(modelRef, longMode) {
+  const sf = findParentStatefile(process.cwd());
+  if (!sf) {
+    console.error(`Error: no opencode server found in ${process.cwd()} or any of its parents.`);
+    console.error("Run 'ocmux serve' to create a new server.");
+    process.exit(1);
+  }
+  const state = readState(sf);
+  if (!state || !state.url) {
+    console.error(`Error: invalid state file ${sf}`);
+    process.exit(1);
+  }
+
+  // Fail fast before any HTTP: interactive picker requires a TTY.
+  if (!modelRef && !process.stdin.isTTY) {
+    console.error('Error: "model" with no argument is interactive and requires a TTY.');
+    console.error('Use "ocmux model <ref>" (partial matches allowed when unique) to switch directly.');
+    process.exit(1);
+  }
+
+  const sessions = await listSessions(state.url).catch((err) => {
+    console.error(`Error connecting to ${state.url}: ${err.message}`);
+    process.exit(1);
+  });
+  const sessionId = newestSessionId(sessions);
+  if (!sessionId) {
+    console.error(`Error: no sessions found on ${state.url} (${path.dirname(sf)}).`);
+    console.error('Open a session in the TUI first, or send a prompt with agentp.');
+    process.exit(1);
+  }
+
+  const models = await listModels(state.url).catch((err) => {
+    console.error(`Error listing models: ${err.message}`);
+    process.exit(1);
+  });
+  if (models.length === 0) {
+    console.error('Error: no models available from this server.');
+    process.exit(1);
+  }
+
+  let pick = null;
+  if (modelRef) {
+    const { model, matches, error } = resolveModelRef(models, modelRef);
+    if (model) {
+      pick = model;
+    } else if (matches.length > 1 && process.stdin.isTTY) {
+      console.error(`Multiple models match "${modelRef}", select one:`);
+      pick = await modelMenu(matches);
+    } else {
+      console.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  } else if (process.stdin.isTTY) {
+    pick = await modelMenu(models);
+  } else {
+    // Unreachable (guarded above) — kept for safety.
+    console.error('Error: "model" with no argument is interactive and requires a TTY.');
+    console.error('Use "ocmux model <ref>" (partial matches allowed when unique) to switch directly.');
+    process.exit(1);
+  }
+
+  if (!pick) {
+    console.error('Cancelled.');
+    return;
+  }
+
+  await switchModel(state.url, sessionId, pick).catch((err) => {
+    console.error(`Error switching model: ${err.message}`);
+    process.exit(1);
+  });
+  const label = pick.label + (pick.variant ? `#${pick.variant}` : '');
+  console.error(`Switched session ${sessionId} to ${label}.`);
+  // Print the URL on stdout so `agentp $(ocmux model <ref>)` composes: the
+  // switch (side effect) takes effect before agentp proceeds with the prompt.
+  outputUrl(state.url, path.dirname(sf), longMode);
+}
+
 // ---------------------------------------------------------------------------
 // Subcommand: list
 // ---------------------------------------------------------------------------
@@ -364,7 +648,7 @@ function doNew(targetDir, longMode, printLogs) {
   const tuiPane = splitResult.stdout.trim();
   sleep(0.2);
   tmux(['send-keys', '-t', tuiPane,
-    `opencode attach --continue '${url}'`, 'Enter']);
+    tuiAttachCommand(url), 'Enter']);
   sleep(0.5);
   if (tuiPane) tmux(['resize-pane', '-Z', '-t', tuiPane]);
 
@@ -497,6 +781,7 @@ function main() {
 
   let subcommand = null;
   let targetDir = null;
+  let modelRef = null;
 
   for (const arg of positional) {
     if (dirIsForced) {
@@ -506,12 +791,15 @@ function main() {
         process.exit(1);
       }
       targetDir = resolveDir(arg);
-    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list' || arg === 'resurrect') {
+    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list' || arg === 'resurrect' || arg === 'switch' || arg === 'model') {
       if (subcommand) {
         console.error(`Error: multiple subcommands specified: '${subcommand}' and '${arg}'`);
         process.exit(1);
       }
       subcommand = arg;
+    } else if (subcommand === 'model' && modelRef === null) {
+      // model reference (supports partial matches) — not a directory
+      modelRef = arg;
     } else {
       if (targetDir) {
         console.error(`Error: unexpected argument '${arg}'`);
@@ -566,6 +854,41 @@ function main() {
       process.exit(1);
     }
     cmdList();
+  } else if (subcommand === 'switch') {
+    if (gitMode) {
+      console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (targetDir !== process.cwd()) {
+      console.error("Error: 'switch' does not accept a directory path.");
+      process.exit(1);
+    }
+    ensureSession();
+    cmdSwitchMenu(longMode);
+  } else if (subcommand === 'model') {
+    if (gitMode) {
+      console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (targetDir !== process.cwd()) {
+      console.error("Error: 'model' does not accept a directory path.");
+      process.exit(1);
+    }
+    // cmdModel is async; swallow the (test-mocked) process.exit throw.
+    cmdModel(modelRef, longMode).catch((err) => {
+      if (!err || !err.message || !err.message.startsWith('EXIT:')) {
+        console.error(err ? err.message : String(err));
+        process.exit(1);
+      }
+    });
   } else if (subcommand === 'kill') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
@@ -606,7 +929,7 @@ function main() {
     // Default mode — find an existing server and switch to it
     let sf = findParentStatefile(targetDir);
     if (!sf) {
-      console.error(`Error: no opencode server found in ${targetDir} or any of its parents.`);
+      console.log(`Error: no opencode server found in ${targetDir} or any of its parents.`);
       console.error("Run 'ocmux serve' to create a new server.");
       process.exit(1);
     }
@@ -628,4 +951,8 @@ function main() {
   }
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

package/docs/specification.md

@@ -31,13 +31,25 @@ Reads stdin, sends to the most recent or named OpenCode session, streams answer
 **Options:**
 
 | Flag | Effect |
-|---|---|
+|---|---|---|
 | `--qa` | Print prompt/answer with rulers; auto-detect tgagentp |
+| `--defer [N]` | Deferred execution — submit a prompt and get a ticket immediately, or wait up to N seconds (default `0`) for the answer; piping the ticket back retrieves the result later |
+| `--onlineTicket` | Print deferred tickets on a single line (default: pretty-printed JSON) |
 | `--tg` | Forward answer via tgagentp gateway (error if unavailable) |
 | `--no-tg` | Explicitly disable Telegram forwarding |
 | `--flush` | Flush recorded buffer without prepending |
 | `--getLast N` | Retrieve last N assistant answers from session history |
 
+**Deferred tickets (`--defer`):**
+
+Ticket format on stdout: `agentp_ticket` followed by a JSON object `{ ctime, path, server, sessionId, elapsed, defer }`, printed as pretty-printed (multi-line) JSON by default or on a single line with `--onlineTicket`. Both formats are accepted when piping a ticket back.
+
+- First print omits `elapsed`; `defer` is included only when it was `> 0`.
+- Re-prints (answer not ready yet) include `elapsed` computed from `ctime` (0 when `ctime` is missing/unparseable).
+- A ticket piped back to `agentp --defer` ignores the CLI `--defer` value and uses the ticket's own `defer` (default 0): ready → print answer + delete temp file; not ready → re-print the ticket with updated `elapsed`; file missing → error, exit 1.
+- If a ticket is followed by additional text and the answer is not ready, `agentp --defer` sends that text to the ticket's `server`/`sessionId` with `sendToSessionAsync()` (`POST /session/:id/prompt_async`), stores it in a ticket sidecar file, and re-prints the ticket without echoing the extra text. When the final answer is retrieved with `--qa`, stored follow-ups are injected into the prompt block under `📝` separators; without `--qa`, they are omitted from output. If the answer is ready, appended text is not sent and is printed after the returned answer. Older tickets without `server`/`sessionId` can retrieve results but cannot queue follow-up text.
+- New run with `--defer N` (N > 0): wait up to N seconds polling the temp file; answer arrives in time → print + delete; else print the ticket and keep the background child alive.
+
 **Protocol:**
 
 1. Reads all stdin → string
@@ -63,15 +75,23 @@ Manages per-project OpenCode servers in a persistent `Opencode` tmux session.
 | `new [dir]` | Alias for `serve` (deprecated) |
 | `kill [dir]` | Kill server, remove tmux window + `.ocmux.json` |
 | `resurrect [dir]` | Recover dead server: kill old window, remove state file, create fresh server + TUI |
+| `model [ref]` | Switch the model of the newest session (interactive picker without `ref`; prints the server URL on success so `agentp $(ocmux model <ref>)` composes) |
+| `switch` | Interactive session picker (TTY required) |
 | `list [-l]` | List all running servers |
 | _(no arg)_ | Switch to existing server (searches upward for `.ocmux.json`) |
 
+**`model` behavior:** Targets the newest session on the server found upward from `$PWD`. With no argument it opens an interactive model picker (all models, arrow/`j`/`k`, Enter to switch, `q`/`Ctrl+C` to quit; requires a TTY). With a reference it switches directly; references may be full (`providerID/modelID`), partial (matched uniquely against label or bare id), and carry a variant suffix (`#variant`). On success it writes the server URL to stdout (plus a confirmation to stderr), so `agentp $(ocmux model <ref>)` switches the model before the next prompt is sent. Multiple matches open the picker on a TTY, otherwise error listing the candidates. Rejects `--git`, `--GIT`, `--print-logs`, and directory arguments.
+
+**`switch` behavior:** Renders an interactive menu of all running servers on an alt screen with columns `dirname | status | url | full path`. `j`/`k` or arrow keys move the cursor; `Enter`/`Space` activates the selected server (switches its tmux window) and keeps the menu open; `q`/`Ctrl+C` exits and prints the URL of the last selected server (if any). The row matching the tmux-active window (queried live from tmux via `activeWindowIndex()` on every redraw) is highlighted across the full line width, so the highlight tracks both local activations and external tmux window switches. Errors (exit 1) when no TTY or no servers. Rejects `--git`, `--GIT`, `--print-logs`, and directory arguments.
+
+**Default no-server behavior:** When no `.ocmux.json` is found for the current/target directory or any parent, default mode prints the primary `Error: no opencode server found...` line to stdout and the `Run 'ocmux serve'...` hint to stderr. This makes command substitution (`agentp $(ocmux)`) fail safely instead of passing no argument and falling back to `agentp`'s default server.
+
 **Flags:** `--git`, `--GIT`, `--print-logs`, `-l`, `--version`
 
 **Window layout:**
 
 - Pane 0: server (`opencode serve --port 0 2>&1 | tee <logfile>`)
-- Pane 1+: TUI (`opencode attach --continue '<url>'`)
+- Pane 1+: TUI (`opencode --server '<url>' --continue` on OpenCode v2; `opencode attach --continue '<url>'` on older versions — chosen automatically via `opencode --version`)
 - Log: `/tmp/opencode-serve-<hashDir(dir)>.log`
 - State: `<dir>/.ocmux.json` (contains `url`, `logfile`, `window_index`)
 
@@ -218,6 +238,8 @@ Server log file. Continuously written by `tee` in the server pane. Polled by `do
 opencode server listening on http://localhost:40999
 ```
 
+OpenCode v2 prints `server listening on http://...` (without the `opencode ` prefix); both formats are matched for URL extraction.
+
 ---
 
 ## Inter-Process Communication
@@ -264,10 +286,10 @@ All servers live in a single tmux session named `Opencode`. Each project gets on
 Session: Opencode
 ├── Window 3: /home/user/project-a
 │   ├── Pane 0: opencode serve --port 0 ...   (server)
-│   └── Pane 1: opencode attach --continue ...  (TUI, zoomed)
+│   └── Pane 1: TUI (opencode --server <url> --continue / attach, zoomed)
 ├── Window 4: /home/user/project-b
 │   ├── Pane 0: opencode serve --port 0 ...
-│   └── Pane 1: opencode attach --continue ...
+│   └── Pane 1: TUI (opencode --server <url> --continue / attach)
 ```
 
 Window names are the full project directory path. Pane 0 is always the server; pane 1+ is the TUI. The TUI pane is zoomed on switch/create. Dead TUI panes are auto-restarted on switch.

package/lib/ocmux.js

@@ -6,7 +6,30 @@ const crypto = require('crypto');
 const child_process = require('child_process');
 
 const SESSION = 'Opencode';
-const URL_RE = /opencode server listening on (http:\/\/[^\s]*)/;
+// OpenCode v2 prints `server listening on http://...`; older versions printed
+// `opencode server listening on http://...`. Accept both.
+const URL_RE = /(?:opencode )?server listening on (http:\/\/[^\s]*)/;
+
+// Detect the OpenCode major version: v2 runs the TUI with `opencode --server`,
+// older versions used the `attach` subcommand. Returns null when undetectable.
+function detectOcMajor() {
+  const r = child_process.spawnSync('opencode', ['--version'], { encoding: 'utf8' });
+  const out = (r.stdout || '') + (r.stderr || '');
+  const m = out.match(/v?(\d+)\.(\d+)\./);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+// Command to attach the TUI to a running server. OpenCode v2 dropped the
+// `attach` subcommand in favor of `opencode --server <url>`; older versions
+// still use `opencode attach --continue <url>`. Falls back to the legacy form
+// when the version cannot be detected (keeps old installations working).
+function tuiAttachCommand(url) {
+  const major = detectOcMajor();
+  if (major !== null && major >= 2) {
+    return `opencode --server '${url}' --continue`;
+  }
+  return `opencode attach --continue '${url}'`;
+}
 
 function _tmux(args) {
   const result = child_process.spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
@@ -182,14 +205,14 @@ function activateServer(dir, index, url) {
       if (panesR.status === 0) {
         const panes = panesR.stdout.trim().split('\n').filter(Boolean);
         const lastPane = panes[panes.length - 1];
-        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
+        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, tuiAttachCommand(url)]);
         if (respawnR.status !== 0) {
-          _tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
+          _tmux(['send-keys', '-t', lastPane, tuiAttachCommand(url), 'Enter']);
         }
       }
     } else {
       _tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', dir,
-        `opencode attach --continue '${url}'`]);
+        tuiAttachCommand(url)]);
     }
   }
 
@@ -312,7 +335,7 @@ function startServer(dir, printLogs) {
   const splitResult = _tmux(['split-window', '-v', '-P', '-F', '#{pane_id}', '-t', `${SESSION}:${winIdx}`, '-c', dir]);
   const tuiPane = splitResult.stdout.trim();
   sleep(0.2);
-  _tmux(['send-keys', '-t', tuiPane, `opencode attach --continue '${url}'`, 'Enter']);
+  _tmux(['send-keys', '-t', tuiPane, tuiAttachCommand(url), 'Enter']);
   sleep(0.5);
   if (tuiPane) _tmux(['resize-pane', '-Z', '-t', tuiPane]);
 
@@ -346,4 +369,6 @@ module.exports = {
   startServer,
   serverStatus,
   listDeadServers,
+  detectOcMajor,
+  tuiAttachCommand,
 };