borgmcp 3.3.0 → 3.5.0

package/src/agent-integration-health.ts

@@ -3,12 +3,18 @@ import path from 'node:path';
 import which from 'which';
 import {
   inspectManagedAgentHookConfigs,
+  isOpenCodeMcpServerConfigured,
   type ManagedAgentHookConfigHealth,
   refreshManagedAgentHookConfigs,
   refreshManagedAgentMcpConfigs,
 } from './config-utils.js';
-import { borgHomeRoot } from './private-root.js';
+import { borgHomeRoot, isCanonicalPath } from './private-root.js';
 import { getPackageVersion } from './version.js';
+import {
+  buildBorgPluginSource,
+  installBorgPlugin,
+  openCodePluginPath,
+} from './opencode-plugin.js';
 
 export const AGENT_HOOK_BINS = [
   'borg-regen',
@@ -32,9 +38,17 @@ export interface AgentHookBinHealth {
 export interface AgentIntegrationHealth {
   expectedVersion: string;
   bins: AgentHookBinHealth[];
-  issues: Array<AgentHookBinHealth | ManagedAgentHookConfigHealth>;
+  issues: Array<AgentHookBinHealth | ManagedAgentHookConfigHealth | OpenCodePluginHealth>;
   hookConfigs: ManagedAgentHookConfigHealth[];
-  openCodePlugin: { path: string; present: boolean };
+  openCodePlugin: OpenCodePluginHealth;
+}
+
+export interface OpenCodePluginHealth {
+  path: string;
+  configured: boolean;
+  status: 'ok' | 'present' | 'absent' | 'missing' | 'outdated' | 'unreadable' | 'refused';
+  version?: string;
+  detail?: string;
 }
 
 export interface InspectAgentIntegrationHealthOptions {
@@ -70,6 +84,72 @@ function defaultResolveBin(name: AgentHookBinName, searchPath: string | undefine
   }
 }
 
+function inspectOpenCodePlugin(homeDir: string, expectedVersion: string): OpenCodePluginHealth {
+  const pluginPath = openCodePluginPath(homeDir);
+  const configured = isOpenCodeMcpServerConfigured(
+    path.join(homeDir, '.config', 'opencode', 'opencode.json'),
+  );
+  try {
+    let metadata: fs.Stats;
+    try {
+      metadata = fs.lstatSync(pluginPath);
+    } catch (error) {
+      if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        if (!isCanonicalPath(pluginPath)) {
+          return {
+            path: pluginPath,
+            configured,
+            status: 'refused',
+            detail: 'plugin path contains a symlink',
+          };
+        }
+        return { path: pluginPath, configured, status: configured ? 'missing' : 'absent' };
+      }
+      throw error;
+    }
+    if (metadata.isSymbolicLink()) {
+      return {
+        path: pluginPath,
+        configured,
+        status: 'refused',
+        detail: 'plugin path is a symlink',
+      };
+    }
+    if (!isCanonicalPath(pluginPath)) {
+      return {
+        path: pluginPath,
+        configured,
+        status: 'refused',
+        detail: 'plugin path contains a symlink',
+      };
+    }
+    if (!metadata.isFile()) {
+      return {
+        path: pluginPath,
+        configured,
+        status: 'refused',
+        detail: 'plugin path is not a regular file',
+      };
+    }
+    const source = fs.readFileSync(pluginPath, 'utf8');
+    const marker = source.match(/borgmcp-opencode-plugin:([^;\s]+);opencode=/)?.[1];
+    if (!configured) {
+      return { path: pluginPath, configured, status: 'present', version: marker ?? 'unknown' };
+    }
+    if (source === buildBorgPluginSource(expectedVersion)) {
+      return { path: pluginPath, configured, status: 'ok', version: expectedVersion };
+    }
+    return { path: pluginPath, configured, status: 'outdated', version: marker ?? 'unknown' };
+  } catch (error) {
+    return {
+      path: pluginPath,
+      configured,
+      status: 'unreadable',
+      detail: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 export function inspectAgentIntegrationHealth(
   options: InspectAgentIntegrationHealthOptions = {},
 ): AgentIntegrationHealth {
@@ -105,17 +185,22 @@ export function inspectAgentIntegrationHealth(
     }
     return { name, status: 'ok', resolvedPath, owner: owner.name, version: owner.version };
   });
-  const pluginPath = path.join(homeDir, '.config', 'opencode', 'plugins', 'borg-orient.js');
   const hookConfigs = inspectManagedAgentHookConfigs(homeDir);
+  const openCodePlugin = inspectOpenCodePlugin(homeDir, expectedVersion);
   return {
     expectedVersion,
     bins,
     issues: [
       ...bins.filter((bin) => bin.status !== 'ok'),
       ...hookConfigs.filter((config) => config.status === 'stale' || config.status === 'invalid'),
+      ...(openCodePlugin.status === 'unreadable' ||
+        (openCodePlugin.status === 'refused' && openCodePlugin.configured) ||
+        (openCodePlugin.configured && openCodePlugin.status !== 'ok')
+        ? [openCodePlugin]
+        : []),
     ],
     hookConfigs,
-    openCodePlugin: { path: pluginPath, present: fs.existsSync(pluginPath) },
+    openCodePlugin,
   };
 }
 
@@ -129,6 +214,22 @@ function renderBin(bin: AgentHookBinHealth, expectedVersion: string): string {
   }
 }
 
+function renderOpenCodePlugin(
+  plugin: OpenCodePluginHealth,
+  expectedVersion: string,
+): string {
+  const prefix = 'OpenCode borg-orient.js plugin:';
+  switch (plugin.status) {
+    case 'ok': return `${prefix} ok (${plugin.version})`;
+    case 'present': return `${prefix} present`;
+    case 'absent': return `${prefix} absent`;
+    case 'missing': return `${prefix} missing at ${plugin.path}`;
+    case 'outdated': return `${prefix} version ${plugin.version}, expected ${expectedVersion} at ${plugin.path}`;
+    case 'unreadable': return `${prefix} unreadable at ${plugin.path}${plugin.detail ? ` (${plugin.detail})` : ''}`;
+    case 'refused': return `${prefix} refused at ${plugin.path}${plugin.detail ? ` (${plugin.detail})` : ''}`;
+  }
+}
+
 export function renderAgentIntegrationHealth(report: AgentIntegrationHealth): string {
   const lines = [
     `Borg agent integration (borgmcp ${report.expectedVersion})`,
@@ -137,7 +238,7 @@ export function renderAgentIntegrationHealth(report: AgentIntegrationHealth): st
     ...report.hookConfigs.map((item) => (
       `  ${item.status}: ${item.path}${item.detail ? ` (${item.detail})` : ''}`
     )),
-    `OpenCode borg-orient.js plugin: ${report.openCodePlugin.present ? 'present' : 'absent'} (${report.openCodePlugin.path})`,
+    renderOpenCodePlugin(report.openCodePlugin, report.expectedVersion),
   ];
   for (const bin of report.bins) {
     switch (bin.status) {
@@ -168,6 +269,19 @@ export function renderAgentIntegrationHealth(report: AgentIntegrationHealth): st
         : `Repair invalid managed hook config ${config.path}, then run: borg update --yes`);
     }
   }
+  if (report.openCodePlugin.status === 'missing') {
+    lines.push('Repair missing OpenCode plugin: borg update --yes');
+  } else if (report.openCodePlugin.status === 'outdated' && report.openCodePlugin.configured) {
+    lines.push('Repair OpenCode plugin: borg update --yes');
+  } else if (report.openCodePlugin.status === 'unreadable') {
+    lines.push(report.openCodePlugin.configured
+      ? `Fix or replace unreadable OpenCode plugin ${report.openCodePlugin.path}, then run: borg update --yes`
+      : `Fix or remove unreadable OpenCode plugin ${report.openCodePlugin.path}`);
+  } else if (report.openCodePlugin.status === 'refused' && report.openCodePlugin.configured) {
+    lines.push(
+      `Remove or replace the OpenCode plugin path ${report.openCodePlugin.path}, then run: borg update --yes`,
+    );
+  }
   return `${lines.join('\n')}\n`;
 }
 
@@ -223,6 +337,7 @@ export function refreshAndVerifyManagedAgentIntegrations(): void {
       'Repair the named managed hook config, then rerun borg update --yes',
     );
   }
+  if (isOpenCodeMcpServerConfigured()) installBorgPlugin();
   try {
     assertAgentIntegrationHealthy(inspectAgentIntegrationHealth());
   } catch (error) {

package/src/backends/{launch-all-windows.ts → launch-all-terminals.ts}

@@ -1,4 +1,4 @@
-// gh#556 Part 2 — windows backend (explicit `--mode windows` only, spec §4.2).
+// client#400 — terminals backend (`--mode terminals`; macOS auto default).
 // Opens each worktree as a new terminal window/tab. macOS: iTerm/Terminal via
 // osascript. Linux: $BORG_TERMINAL / $TERMINAL / probed emulator. No shared
 // session, so no post-launch attach. Hard-fails if no compatible terminal found.
@@ -7,10 +7,20 @@ import type { DroneCandidate } from '../launch-all-discovery.js';
 import type { LaunchAllDeps } from '../launch-all-deps.js';
 import { buildLaunchCommand } from '../launch-all-command.js';
 import { writeLockMarker } from '../launch-all-locks.js';
+import { composeTerminalTitle } from '../terminal-title.js';
+import { shellEscape } from '../shell-escape.js';
 
-export interface WindowsOpts {
+const ITERM_APP = '/Applications/iTerm.app';
+const TERMINAL_APPS = [
+  '/System/Applications/Utilities/Terminal.app',
+  '/Applications/Utilities/Terminal.app',
+  '/Applications/Terminal.app',
+] as const;
+
+export interface TerminalsOpts {
   borgPath: string;
   platform: NodeJS.Platform;
+  cubeName: string;
   launchedAtISO: string;
   /** Stagger between drone launches (ms) to avoid the rate limiter; 0 disables. */
   launchDelayMs: number;
@@ -25,13 +35,17 @@ function appleScriptEscape(s: string): string {
 
 class NoTerminalError extends Error {}
 
+export function hasMacOSTerminalApp(deps: Pick<LaunchAllDeps, 'pathExists'>): boolean {
+  return deps.pathExists(ITERM_APP) || TERMINAL_APPS.some((path) => deps.pathExists(path));
+}
+
 /** macOS: open each candidate in iTerm or Terminal via osascript. */
-async function launchMacOS(candidates: DroneCandidate[], opts: WindowsOpts, deps: LaunchAllDeps): Promise<void> {
-  const hasITerm = deps.pathExists('/Applications/iTerm.app');
-  const hasTerminal = deps.pathExists('/Applications/Terminal.app');
+async function launchMacOS(candidates: DroneCandidate[], opts: TerminalsOpts, deps: LaunchAllDeps): Promise<void> {
+  const hasITerm = deps.pathExists(ITERM_APP);
+  const hasTerminal = TERMINAL_APPS.some((path) => deps.pathExists(path));
   if (!hasITerm && !hasTerminal) {
     throw new NoTerminalError(
-      'borg launch-all: --mode windows requires a compatible terminal app.\n' +
+      'borg launch-all: --mode terminals requires a compatible terminal app.\n' +
         'Not found: iTerm.app, Terminal.app\n' +
         'Install iTerm2 (https://iterm2.com) or use --mode tmux (brew install tmux).\n'
     );
@@ -40,16 +54,17 @@ async function launchMacOS(candidates: DroneCandidate[], opts: WindowsOpts, deps
     const c = candidates[i];
     if (i > 0 && opts.launchDelayMs > 0) await opts.sleep(opts.launchDelayMs); // rate-limit stagger
     const cmd = buildLaunchCommand(c.worktreeDir, opts.borgPath);
+    const title = composeTerminalTitle({ label: c.droneLabel, cubeName: opts.cubeName }, '');
     const script = hasITerm
-      ? `tell application "iTerm"\n  tell current window to create tab with default profile command "${appleScriptEscape(cmd)}"\nend tell`
-      : `tell application "Terminal"\n  do script "${appleScriptEscape(cmd)}"\n  activate\nend tell`;
+      ? `tell application "iTerm"\n  if (count of windows) = 0 then\n    set launchedWindow to (create window with default profile command "${appleScriptEscape(cmd)}")\n    tell current session of launchedWindow to set name to "${appleScriptEscape(title)}"\n  else\n    tell current window\n      set launchedTab to (create tab with default profile command "${appleScriptEscape(cmd)}")\n      tell current session of launchedTab to set name to "${appleScriptEscape(title)}"\n    end tell\n  end if\nend tell`
+      : `tell application "Terminal"\n  set launchedTab to do script "${appleScriptEscape(cmd)}"\n  set custom title of launchedTab to "${appleScriptEscape(title)}"\n  set title displays custom title of launchedTab to true\n  activate\nend tell`;
     deps.runSync('osascript', ['-e', script]);
     writeLockMarker(deps, c.cubeId, c.droneLabel, c.worktreeDir, opts.launchedAtISO);
   }
 }
 
 /** Linux: open each candidate in the first available terminal emulator. */
-async function launchLinux(candidates: DroneCandidate[], opts: WindowsOpts, deps: LaunchAllDeps): Promise<void> {
+async function launchLinux(candidates: DroneCandidate[], opts: TerminalsOpts, deps: LaunchAllDeps): Promise<void> {
   const explicit = deps.getEnv('BORG_TERMINAL') || deps.getEnv('TERMINAL');
   const probe = ['gnome-terminal', 'konsole', 'kitty', 'wezterm', 'xterm'];
   let term: string | undefined = explicit;
@@ -63,14 +78,17 @@ async function launchLinux(candidates: DroneCandidate[], opts: WindowsOpts, deps
   }
   if (!term) {
     throw new NoTerminalError(
-      'borg launch-all: --mode windows requires a terminal emulator.\n' +
+      'borg launch-all: --mode terminals requires a terminal emulator.\n' +
         'Not found. Set $BORG_TERMINAL=<path> or use --mode tmux.\n'
     );
   }
   for (let i = 0; i < candidates.length; i++) {
     const c = candidates[i];
     if (i > 0 && opts.launchDelayMs > 0) await opts.sleep(opts.launchDelayMs); // rate-limit stagger
-    const cmd = buildLaunchCommand(c.worktreeDir, opts.borgPath, { keepOpenOnFail: true });
+    const title = composeTerminalTitle({ label: c.droneLabel, cubeName: opts.cubeName }, '');
+    const cmd =
+      `printf '\\033]0;%s\\007' ${shellEscape(title)}; ` +
+      buildLaunchCommand(c.worktreeDir, opts.borgPath, { keepOpenOnFail: true });
     // `<term> -e sh -c '<cmd>'` opens a new window running the command.
     deps.runSync(term, ['-e', 'sh', '-c', cmd]);
     writeLockMarker(deps, c.cubeId, c.droneLabel, c.worktreeDir, opts.launchedAtISO);
@@ -83,20 +101,20 @@ async function launchLinux(candidates: DroneCandidate[], opts: WindowsOpts, deps
  * string literal (parse error). Reject such paths up front (the user's own path;
  * pathological) — fail-loud + skip, never silently mangle. Applies to both
  * platforms defensively (the tmux primary handles control chars fine via
- * shellEscape + array-args, so this guard is windows-backend-specific).
+ * shellEscape + array-args, so this guard is terminals-backend-specific).
  */
 const CONTROL_CHAR_RE = /[\x00-\x1f\x7f]/;
 
-export async function runWindowsBackend(
+export async function runTerminalsBackend(
   candidates: DroneCandidate[],
-  opts: WindowsOpts,
+  opts: TerminalsOpts,
   deps: LaunchAllDeps
 ): Promise<void> {
   const safe = candidates.filter((c) => {
     if (CONTROL_CHAR_RE.test(c.worktreeDir)) {
       deps.stderr(
         `skipping ${c.droneLabel} (${JSON.stringify(c.worktreeDir)}): worktree path contains a control ` +
-          `character — unsafe for --mode windows; use --mode tmux instead.\n`
+          `character — unsafe for --mode terminals; use --mode tmux instead.\n`
       );
       return false;
     }

package/src/bare-launch-menu.ts

@@ -1,27 +1,34 @@
 /**
  * gh#853 — bare `borg` (no-args) interactive launch menu.
  *
- * When `borg` is run with NO arguments in a TTY, offer a small launch selector
- * instead of launching immediately:
- *   1. Launch (default)             — the configured agent (Enter selects).
- *   2. Launch with <other> instead  — the OTHER configured agent, ONE-SHOT
- *                                      (does NOT persist the preference).
- *   3. Launch all                   — runLaunchAll for the active cube.
+ * When `borg` is run with NO arguments in a TTY outside an active seat, offer
+ * a small launch selector. In a repository with live sibling drones, those
+ * drones come first; otherwise the existing agent choices remain unchanged.
  *
  * The option-set, the selection→action mapping, and the show/collapse decision
  * are pure functions so they're unit-testable without a real TTY. claude.ts
- * main() is thin glue: it computes the inputs (default cli, other-configured cli,
- * launch-all targets), gates on shouldShowLaunchMenu, runs the orchestrator with
- * the real readline prompt, then dispatches the returned action.
+ * main() is thin glue: it computes the available candidates and agent choices,
+ * gates on shouldShowLaunchMenu, runs the orchestrator with the real readline
+ * prompt, then dispatches the returned action.
  *
- * Load-bearing safety: TTY-only + bare-args-only (shouldShowLaunchMenu) so every
- * scripted/programmatic `borg` and every explicit subcommand/flag is untouched.
+ * Load-bearing safety: TTY-only + bare-args-only + no-active-seat
+ * (shouldShowLaunchMenu), so scripted/programmatic invocations and direct
+ * worktree resumes are untouched.
  */
-import type { BorgCli } from './cubes.js';
+import type { ActiveCube, BorgCli } from './cubes.js';
+import type { DroneCandidate } from './launch-all-discovery.js';
+import type { SeatStatus } from './seat-probe.js';
 
 export type LaunchMenuAction =
   | { kind: 'launch'; cli: BorgCli }
-  | { kind: 'launch-all' };
+  | { kind: 'launch-seat'; target: string }
+  | { kind: 'launch-all'; cubeId?: string };
+
+export interface LaunchMenuDroneCandidate {
+  droneLabel: string;
+  target: string;
+  worktree: string;
+}
 
 export interface LaunchMenuOption {
   /** The keystroke that selects this option (sequential: '1', '2', …). */
@@ -35,8 +42,87 @@ export interface LaunchMenuInputs {
   defaultCli: BorgCli;
   /** All configured agents that are NOT the default, in display order. */
   otherConfiguredClis: BorgCli[];
-  /** True iff there's an active cube with >=1 discoverable drone (option 3). */
+  /** True iff the current menu context has launch-all targets. */
   hasLaunchAllTargets: boolean;
+  /** Live sibling drones offered before the unattached launch choices. */
+  droneCandidates?: LaunchMenuDroneCandidate[];
+  /** Cube selected by the sibling-drone context for its launch-all action. */
+  launchAllCubeId?: string;
+}
+
+interface LaunchMenuCandidateDeps {
+  readAllProjectIdentities: () => Promise<Array<{ projectPath: string; cube: ActiveCube }>>;
+  discoverDroneCandidates: (cubeId: string) => Promise<DroneCandidate[]>;
+  getActiveSeatForWorktree: (
+    worktree: string,
+  ) => Promise<{ cubeId: string; droneId?: string } | null>;
+  pathExists: (worktree: string) => boolean;
+  probeSeat: (candidate: DroneCandidate) => Promise<SeatStatus>;
+}
+
+const TERMINAL_SEAT_STATUSES = new Set<SeatStatus>([
+  'evicted',
+  'revoked',
+  'rejected',
+  'credential-rejected',
+  'trust-mismatch',
+]);
+
+/**
+ * Find linked sibling worktrees that still own their preferred active seat.
+ * Authoritative terminal probe results are omitted; transient/unknown probe
+ * results stay visible, matching launch-all's constructive fail-open behavior.
+ */
+export async function discoverLiveLaunchMenuCandidates(
+  deps: LaunchMenuCandidateDeps,
+): Promise<{ candidates: LaunchMenuDroneCandidate[]; launchAllCubeId?: string }> {
+  const identities = await deps.readAllProjectIdentities();
+  const cubeIds = [...new Set(identities.map(({ cube }) => cube.cubeId))];
+  const discovered = (
+    await Promise.all(cubeIds.map((cubeId) => deps.discoverDroneCandidates(cubeId)))
+  ).flat();
+
+  const candidates: Array<LaunchMenuDroneCandidate & { cubeId: string }> = [];
+  const seen = new Set<string>();
+  for (const candidate of discovered) {
+    if (!deps.pathExists(candidate.worktreeDir)) continue;
+    const preferred = await deps.getActiveSeatForWorktree(candidate.worktreeDir);
+    if (
+      !preferred ||
+      preferred.cubeId !== candidate.cubeId ||
+      preferred.droneId !== candidate.droneId
+    ) continue;
+
+    let status: SeatStatus;
+    try {
+      status = await deps.probeSeat(candidate);
+    } catch {
+      status = 'indeterminate';
+    }
+    if (TERMINAL_SEAT_STATUSES.has(status)) continue;
+
+    const key = `${candidate.cubeId}\0${candidate.droneId}\0${candidate.worktreeDir}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    candidates.push({
+      cubeId: candidate.cubeId,
+      droneLabel: candidate.droneLabel,
+      target: candidate.droneId,
+      worktree: candidate.worktreeDir,
+    });
+  }
+
+  candidates.sort((a, b) =>
+    a.droneLabel.localeCompare(b.droneLabel) || a.worktree.localeCompare(b.worktree)
+  );
+  const candidateCubeIds = new Set(candidates.map((candidate) => candidate.cubeId));
+  const launchAllCubeId = candidateCubeIds.size === 1
+    ? candidates[0].cubeId
+    : undefined;
+  return {
+    candidates: candidates.map(({ cubeId: _cubeId, ...candidate }) => candidate),
+    ...(launchAllCubeId ? { launchAllCubeId } : {}),
+  };
 }
 
 /**
@@ -59,16 +145,20 @@ export function configureSelectedLaunchCli(
 const PRETTY: Record<BorgCli, string> = { claude: 'Claude', codex: 'Codex', opencode: 'OpenCode' };
 
 /**
- * Gate: the menu fires ONLY for bare `borg` (no args) in a TTY. Any explicit
- * subcommand/flag, or a non-TTY (piped/scripted/CI) invocation, falls straight
- * through to the existing default launch — no menu, no behavior change.
+ * Gate: the menu fires ONLY for bare `borg` (no args) in a TTY without an
+ * active seat. Explicit invocations, non-TTY launches, and direct worktree
+ * resumes fall straight through to the existing launch path.
  */
 export function shouldShowLaunchMenu(args: {
   extraArgs: string[];
   stdinIsTTY: boolean;
   stdoutIsTTY: boolean;
+  hasActiveSeat?: boolean;
 }): boolean {
-  return args.extraArgs.length === 0 && args.stdinIsTTY && args.stdoutIsTTY;
+  return args.extraArgs.length === 0
+    && args.stdinIsTTY
+    && args.stdoutIsTTY
+    && !args.hasActiveSeat;
 }
 
 export function explicitCliLaunchHint(args: {
@@ -98,6 +188,39 @@ export function shouldResolveExplicitCliLaunchHintTargets(args: {
  * middle option never produces a "1) … 3) …" gap menu.
  */
 export function buildLaunchMenuOptions(inputs: LaunchMenuInputs): LaunchMenuOption[] {
+  if (inputs.droneCandidates && inputs.droneCandidates.length > 0) {
+    const options: LaunchMenuOption[] = [...inputs.droneCandidates]
+      .sort((a, b) => a.droneLabel.localeCompare(b.droneLabel) || a.worktree.localeCompare(b.worktree))
+      .map((candidate, index) => ({
+        key: String(index + 1),
+        label: `Resume ${candidate.droneLabel} (${candidate.worktree})`,
+        action: { kind: 'launch-seat' as const, target: candidate.target },
+      }));
+    if (inputs.hasLaunchAllTargets) {
+      options.push({
+        key: String(options.length + 1),
+        label: "Launch all (this cube's drone worktrees)",
+        action: {
+          kind: 'launch-all',
+          ...(inputs.launchAllCubeId ? { cubeId: inputs.launchAllCubeId } : {}),
+        },
+      });
+    }
+    options.push({
+      key: String(options.length + 1),
+      label: `Launch ${PRETTY[inputs.defaultCli]} here without a drone`,
+      action: { kind: 'launch', cli: inputs.defaultCli },
+    });
+    for (const cli of inputs.otherConfiguredClis) {
+      options.push({
+        key: String(options.length + 1),
+        label: `Launch with ${PRETTY[cli]} here without a drone (one-shot)`,
+        action: { kind: 'launch', cli },
+      });
+    }
+    return options;
+  }
+
   const options: LaunchMenuOption[] = [
     {
       key: '1',