borgmcp 3.4.0 → 3.5.0

package/src/cubes.ts

@@ -76,6 +76,113 @@ export interface ActiveCube {
   worktree?: string;
 }
 
+export const BORG_LAUNCH_EXPECTED_SEAT_ENV = 'BORG_LAUNCH_EXPECTED_SEAT';
+
+export interface LaunchSeatExpectation {
+  credentialRef: string;
+  cubeId: string;
+  droneId: string;
+  worktree: string;
+  droneLabel: string;
+}
+
+export class LaunchSeatIdentityChangedError extends Error {
+  readonly code = 'LAUNCH_SEAT_IDENTITY_CHANGED';
+
+  constructor(droneLabel: string) {
+    super(
+      `borg launch: did not launch '${droneLabel}' — its seat registration changed before the launch could start. ` +
+      'Run `borg seats` to see the current state, then try again.',
+    );
+    this.name = 'LaunchSeatIdentityChangedError';
+  }
+}
+
+export function withLaunchSeatExpectationEnv(
+  env: NodeJS.ProcessEnv,
+  expectation: LaunchSeatExpectation,
+): NodeJS.ProcessEnv {
+  // The deterministic ref and public identity are sufficient; never copy the
+  // stored bearer into a process environment.
+  return {
+    ...env,
+    [BORG_LAUNCH_EXPECTED_SEAT_ENV]: JSON.stringify(expectation),
+  };
+}
+
+/** Codex MCP children do not inherit the wrapper environment, so carry the
+ * launch-scoped expected seat through the same per-invocation config channel as
+ * the Borg-session and state-root markers. */
+export function codexLaunchSeatExpectationConfigArgs(
+  env: NodeJS.ProcessEnv = process.env,
+): string[] {
+  const expectation = env[BORG_LAUNCH_EXPECTED_SEAT_ENV];
+  if (expectation === undefined) return [];
+  return [
+    '-c',
+    `mcp_servers.borg.env.${BORG_LAUNCH_EXPECTED_SEAT_ENV}=${JSON.stringify(expectation)}`,
+  ];
+}
+
+function readLaunchSeatExpectation(
+  env: NodeJS.ProcessEnv = process.env,
+): LaunchSeatExpectation | null {
+  const raw = env[BORG_LAUNCH_EXPECTED_SEAT_ENV];
+  // OpenCode substitutes an unset `{env:NAME}` reference with an empty string.
+  // That is an ordinary bare launch, not a malformed launch-seat expectation.
+  if (raw === undefined || raw === '') return null;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new LaunchSeatIdentityChangedError('<unknown>');
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new LaunchSeatIdentityChangedError('<unknown>');
+  }
+  const value = parsed as Record<string, unknown>;
+  const droneLabel = typeof value.droneLabel === 'string' ? value.droneLabel : '<unknown>';
+  if (
+    typeof value.credentialRef !== 'string' ||
+    typeof value.cubeId !== 'string' ||
+    typeof value.droneId !== 'string' ||
+    typeof value.worktree !== 'string' ||
+    typeof value.droneLabel !== 'string'
+  ) {
+    throw new LaunchSeatIdentityChangedError(droneLabel);
+  }
+  return {
+    credentialRef: value.credentialRef,
+    cubeId: value.cubeId,
+    droneId: value.droneId,
+    worktree: value.worktree,
+    droneLabel: value.droneLabel,
+  };
+}
+
+function assertLaunchSeatExpectation(
+  expectation: LaunchSeatExpectation,
+  active: ActiveCube | null | undefined,
+  worktree: string,
+  currentRecord: SeatRecord | null,
+): void {
+  if (
+    currentRecord === null ||
+    seatRef(currentRecord) !== expectation.credentialRef ||
+    currentRecord.cubeId !== expectation.cubeId ||
+    currentRecord.droneId !== expectation.droneId ||
+    resolve(worktree) !== resolve(expectation.worktree) ||
+    (active !== undefined && (
+      active === null ||
+      active.localSessionCredentialRef !== expectation.credentialRef ||
+      active.cubeId !== expectation.cubeId ||
+      active.droneId !== expectation.droneId
+    ))
+  ) {
+    throw new LaunchSeatIdentityChangedError(expectation.droneLabel);
+  }
+}
+
 export type ActiveCubeInput = Omit<ActiveCube, 'sessionToken'> & {
   sessionToken?: string;
 };
@@ -303,9 +410,19 @@ export async function getActiveCube(): Promise<ActiveCube | null> {
 }
 
 export async function getActiveCubeForWorktree(worktree: string): Promise<ActiveCube | null> {
-  const record = await getActiveSeatForWorktree(findProjectRoot(worktree));
+  const projectRoot = findProjectRoot(worktree);
+  const expectation = readLaunchSeatExpectation();
+  const record = await getActiveSeatForWorktree(projectRoot);
+  // A launch-by-label child must hydrate the exact record selected by its
+  // parent. Check on both sides of bearer hydration so a concurrent preferred-
+  // seat replacement fails closed instead of launching a different drone.
+  if (expectation) assertLaunchSeatExpectation(expectation, undefined, projectRoot, record);
   if (!record || !record.cubeId || !record.droneId) return null;
   const active = await hydrateActiveCube(record);
+  if (expectation) {
+    const currentRecord = await getActiveSeatForWorktree(projectRoot);
+    assertLaunchSeatExpectation(expectation, active, projectRoot, currentRecord);
+  }
   if (active && pinnedMcpSeatIdentity && (
     resolve(active.worktree ?? '') !== pinnedMcpSeatIdentity.worktree ||
     active.cubeId !== pinnedMcpSeatIdentity.cubeId ||

package/src/ensure-mcp-config.ts

@@ -5,7 +5,7 @@ import {
   addOpenCodeMcpServer,
   isCodexMcpServerConfigured,
   isMcpServerConfigured,
-  isOpenCodeMcpServerConfigured,
+  isOpenCodeMcpServerConfiguredForLaunch,
 } from './config-utils.js';
 
 export interface EnsureMcpConfigDeps {
@@ -22,7 +22,7 @@ const defaultDeps: EnsureMcpConfigDeps = {
   addClaude: addMcpServer,
   isCodexConfigured: isCodexMcpServerConfigured,
   addCodex: addCodexMcpServer,
-  isOpenCodeConfigured: isOpenCodeMcpServerConfigured,
+  isOpenCodeConfigured: isOpenCodeMcpServerConfiguredForLaunch,
   addOpenCode: addOpenCodeMcpServer,
 };
 
@@ -49,6 +49,9 @@ export function ensureCliMcpConfigured(
     case 'opencode':
       if (deps.isOpenCodeConfigured()) return false;
       deps.addOpenCode();
+      if (!deps.isOpenCodeConfigured()) {
+        throw new Error('OpenCode MCP registration could not be verified after setup');
+      }
       return true;
   }
 }

package/src/launch-all-cmd.ts

@@ -11,10 +11,10 @@ import type { SeatStatus } from './seat-probe.js';
 import { resolveBorgPath } from './launch-all-command.js';
 import { sweepStaleLocks, isLockLive } from './launch-all-locks.js';
 import { runTmuxBackend } from './backends/launch-all-tmux.js';
-import { runWindowsBackend } from './backends/launch-all-windows.js';
+import { hasMacOSTerminalApp, runTerminalsBackend } from './backends/launch-all-terminals.js';
 import { runPastelistBackend } from './backends/launch-all-pastelist.js';
 
-type Backend = 'tmux' | 'windows' | 'pastelist';
+type Backend = 'tmux' | 'terminals' | 'pastelist';
 
 const TMUX_INSTALL_HINT =
   'borg launch-all: tmux not found.\n' +
@@ -82,10 +82,11 @@ async function resolveTargetCube(
   return { cubeId: active.cubeId, name: active.name };
 }
 
-/** Backend selection (spec §4.1): native-Windows / explicit / tmux-preflight / auto. */
+/** Backend selection: native-Windows / explicit / platform-specific auto. */
 function selectBackend(args: LaunchAllArgs, deps: LaunchAllDeps): { backend: Backend } | { hardFail: string } {
   const explicit = args.flags.mode;
-  const nativeWindows = deps.platform() === 'win32' && !isWSL(deps);
+  const platform = deps.platform();
+  const nativeWindows = platform === 'win32' && !isWSL(deps);
   if (nativeWindows) {
     deps.stderr(
       'native Windows is not supported for interactive launch; using pastelist mode instead ' +
@@ -93,13 +94,23 @@ function selectBackend(args: LaunchAllArgs, deps: LaunchAllDeps): { backend: Bac
     );
     return { backend: 'pastelist' };
   }
-  if (explicit === 'windows') return { backend: 'windows' };
+  if (explicit === 'terminals') return { backend: 'terminals' };
   if (explicit === 'pastelist') return { backend: 'pastelist' };
-
-  const tmuxAvail = checkTmuxAvailable(deps);
   if (explicit === 'tmux') {
-    return tmuxAvail ? { backend: 'tmux' } : { hardFail: TMUX_INSTALL_HINT };
+    return checkTmuxAvailable(deps) ? { backend: 'tmux' } : { hardFail: TMUX_INSTALL_HINT };
+  }
+
+  // macOS defaults to native terminal tabs/windows when either supported app
+  // is installed. Explicit modes above always win.
+  if (
+    platform === 'darwin' &&
+    deps.isTTY() &&
+    hasMacOSTerminalApp(deps)
+  ) {
+    return { backend: 'terminals' };
   }
+
+  const tmuxAvail = checkTmuxAvailable(deps);
   // auto (no explicit mode)
   if (tmuxAvail) return { backend: 'tmux' };
   deps.stderr(TMUX_INSTALL_HINT + 'Falling back to pastelist mode (paste the commands below).\n');
@@ -416,8 +427,8 @@ export async function runLaunchAll(
         }
         printCheatSheet(sessionName, deps);
       }
-    } else if (sel.backend === 'windows') {
-      await runWindowsBackend(launchable, { borgPath, platform: deps.platform(), launchedAtISO: launchStartISO, launchDelayMs, sleep }, deps);
+    } else if (sel.backend === 'terminals') {
+      await runTerminalsBackend(launchable, { borgPath, platform: deps.platform(), cubeName, launchedAtISO: launchStartISO, launchDelayMs, sleep }, deps);
     } else {
       runPastelistBackend(launchable, borgPath, deps);
       return 0; // pastelist: nothing to reconcile (operator pastes manually)
@@ -453,6 +464,8 @@ export async function runLaunchAll(
     const status = statuses ? (statuses.get(c.droneId) === 'verified' ? 'VERIFIED' : 'unconfirmed (may still be joining)') : 'launched';
     deps.stdout(`  ${c.droneLabel}  ${c.worktreeDir}  ${status}\n`);
   }
-  deps.stdout(`\nAttach: tmux attach -t ${sessionName}\n`);
+  if (sel.backend === 'tmux') {
+    deps.stdout(`\nAttach: tmux attach -t ${sessionName}\n`);
+  }
   return 0;
 }

package/src/parse-launch-all-args.ts

@@ -2,7 +2,7 @@
 // Pure: rawArgs → validated LaunchAllArgs | error. Mirror of parse-assimilate-args.
 
 export interface LaunchAllFlags {
-  mode?: 'tmux' | 'windows' | 'pastelist';
+  mode?: 'tmux' | 'terminals' | 'pastelist';
   only?: string;
   dryRun?: boolean;
   cli?: 'claude' | 'codex' | 'opencode';
@@ -28,7 +28,7 @@ export type ParseLaunchAllResult =
   | { ok: false; error: string };
 
 const SUPPORTED =
-  '--mode <tmux|windows|pastelist>, --only <name>, --dry-run, --cli <claude|codex|opencode>, ' +
+  '--mode <tmux|terminals|pastelist>, --only <name>, --dry-run, --cli <claude|codex|opencode>, ' +
   '--no-attach, --yes/-y, --force, --launch-delay <ms>';
 
 export function parseLaunchAllArgs(rawArgs: string[]): ParseLaunchAllResult {
@@ -40,8 +40,8 @@ export function parseLaunchAllArgs(rawArgs: string[]): ParseLaunchAllResult {
     switch (arg) {
       case '--mode': {
         const v = rawArgs[++i];
-        if (v !== 'tmux' && v !== 'windows' && v !== 'pastelist') {
-          return { ok: false, error: `--mode must be one of tmux|windows|pastelist (got: ${v ?? '<missing>'})` };
+        if (v !== 'tmux' && v !== 'terminals' && v !== 'pastelist') {
+          return { ok: false, error: `--mode must be one of tmux|terminals|pastelist (got: ${v ?? '<missing>'})` };
         }
         flags.mode = v;
         break;

package/src/seat-commands.ts

@@ -0,0 +1,322 @@
+import { spawn } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import {
+  getProjectCliPreferenceForPath,
+  readAllProjectIdentities,
+  withLaunchSeatExpectationEnv,
+  type ActiveCube,
+  type BorgCli,
+  type LaunchSeatExpectation,
+} from './cubes.js';
+import { resolveBorgPath } from './launch-all-command.js';
+import { getActiveSeatForWorktree, readAllBoundSeats, seatRef, type SeatRecord } from './seats.js';
+
+export type LocalSeatState = 'active' | 'pending';
+
+export interface LocalSeatRow {
+  droneLabel: string;
+  droneId: string;
+  cubeName: string;
+  cubeId: string;
+  worktree: string;
+  canonicalWorktree: string | null;
+  credentialRef: string;
+  cli: BorgCli | null;
+  state: LocalSeatState;
+}
+
+export interface SeatCommandDeps {
+  readAllProjectIdentities: () => Promise<Array<{ projectPath: string; cube: ActiveCube }>>;
+  readAllBoundSeats: () => Promise<Array<{ worktree: string; record: SeatRecord }>>;
+  getActiveSeatForWorktree: (worktree: string) => Promise<SeatRecord | null>;
+  getProjectCliPreference: (worktree: string) => Promise<BorgCli | null>;
+  pathExists: (path: string) => boolean;
+  realpath: (path: string) => string;
+  /** Run this same borg executable with no args from the selected worktree,
+   * carrying only the expected durable identity for child-side verification. */
+  launchBareBorg: (worktree: string, expectation: LaunchSeatExpectation) => Promise<number>;
+  stdout: (line: string) => void;
+  stderr: (line: string) => void;
+}
+
+export type ParsedSeatsArgs = { ok: true } | { ok: false; error: string };
+
+export function parseSeatsArgs(args: readonly string[]): ParsedSeatsArgs {
+  return args.length === 0
+    ? { ok: true }
+    : { ok: false, error: 'takes no arguments' };
+}
+
+export type ParsedLaunchSeatArgs =
+  | { ok: true; target: string; cube?: string }
+  | { ok: false; error: string };
+
+export function parseLaunchSeatArgs(args: readonly string[]): ParsedLaunchSeatArgs {
+  let target: string | undefined;
+  let cube: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--cube') {
+      const next = args[i + 1];
+      if (!next || next.startsWith('-')) {
+        return { ok: false, error: '--cube requires a cube name' };
+      }
+      cube = next;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--cube=')) {
+      const value = arg.slice('--cube='.length);
+      if (!value) return { ok: false, error: '--cube requires a cube name' };
+      cube = value;
+      continue;
+    }
+    if (arg.startsWith('-')) return { ok: false, error: `unknown option: ${arg}` };
+    if (target !== undefined) {
+      return { ok: false, error: 'accepts exactly one drone label or id prefix' };
+    }
+    target = arg;
+  }
+
+  if (!target) return { ok: false, error: 'requires a drone label or id prefix' };
+  return { ok: true, target, ...(cube ? { cube } : {}) };
+}
+
+function safeRealpath(deps: SeatCommandDeps, path: string): string | null {
+  try {
+    return deps.realpath(path);
+  } catch {
+    return null;
+  }
+}
+
+function seatKey(cubeId: string, droneId: string): string {
+  return `${cubeId}\0${droneId}`;
+}
+
+export async function readLocalSeatRows(deps: SeatCommandDeps): Promise<LocalSeatRow[]> {
+  const [identities, boundSeats] = await Promise.all([
+    deps.readAllProjectIdentities(),
+    deps.readAllBoundSeats(),
+  ]);
+  const identityBySeat = new Map(
+    identities.map((entry) => [seatKey(entry.cube.cubeId, entry.cube.droneId), entry]),
+  );
+  const identityByRealpath = new Map<string, { projectPath: string; cube: ActiveCube }>();
+  for (const entry of identities) {
+    const canonical = safeRealpath(deps, entry.projectPath);
+    if (canonical) identityByRealpath.set(canonical, entry);
+  }
+
+  const rows = await Promise.all(boundSeats.map(async ({ worktree, record }) => {
+    const exists = deps.pathExists(worktree);
+    const canonicalWorktree = exists ? safeRealpath(deps, worktree) : null;
+    const identity = (record.droneId ? identityBySeat.get(seatKey(record.cubeId, record.droneId)) : undefined)
+      ?? (canonicalWorktree ? identityByRealpath.get(canonicalWorktree) : undefined);
+    const cube = identity?.cube;
+    const launchPath = identity?.projectPath ?? worktree;
+    const launchCanonical = deps.pathExists(launchPath) ? safeRealpath(deps, launchPath) : null;
+    return {
+      droneLabel: cube?.droneLabel ?? record.droneLabel ?? '<unknown>',
+      droneId: cube?.droneId ?? record.droneId ?? '',
+      cubeName: cube?.name ?? record.name ?? '<unknown>',
+      cubeId: cube?.cubeId ?? record.cubeId,
+      worktree: launchPath,
+      canonicalWorktree: launchCanonical,
+      credentialRef: seatRef(record),
+      cli: await deps.getProjectCliPreference(launchPath),
+      state: record.state,
+    };
+  }));
+
+  return rows.sort((a, b) =>
+    a.droneLabel.localeCompare(b.droneLabel)
+      || a.cubeName.localeCompare(b.cubeName)
+      || a.worktree.localeCompare(b.worktree)
+  );
+}
+
+function oneLine(value: string): string {
+  return value.replace(/[\r\n\t]/g, ' ');
+}
+
+export function formatLocalSeatRows(rows: readonly LocalSeatRow[]): string {
+  if (rows.length === 0) {
+    return 'No drone seats are registered on this machine. Run `borg assimilate` in a project repository to create one.\n';
+  }
+  const headings = ['DRONE', 'CUBE', 'STATE', 'CLI', 'WORKTREE'];
+  const values = rows.map((row) => [
+    oneLine(row.droneLabel),
+    oneLine(row.cubeName),
+    row.state,
+    row.cli ?? '-',
+    oneLine(row.worktree),
+  ]);
+  const widths = headings.slice(0, -1).map((heading, index) =>
+    Math.max(heading.length, ...values.map((row) => row[index].length))
+  );
+  const render = (row: string[]) =>
+    row.slice(0, -1).map((value, index) => value.padEnd(widths[index] + 2)).join('') + row[row.length - 1];
+  return `${render(headings)}\n${values.map(render).join('\n')}\n`;
+}
+
+function formatAmbiguousMatches(rows: readonly LocalSeatRow[]): string {
+  const labels = rows.map((row) => row.droneLabel);
+  const cubes = rows.map((row) => row.cubeName);
+  const labelWidth = Math.max(...labels.map((label) => label.length));
+  const cubeWidth = Math.max(...cubes.map((cube) => cube.length));
+  return rows.map((row) =>
+    `  ${row.droneLabel.padEnd(labelWidth + 2)}${row.cubeName.padEnd(cubeWidth + 2)}id:${row.droneId.slice(0, 8)}`
+  ).join('\n');
+}
+
+export async function runSeats(deps: SeatCommandDeps): Promise<number> {
+  try {
+    deps.stdout(formatLocalSeatRows(await readLocalSeatRows(deps)));
+    return 0;
+  } catch (error) {
+    deps.stderr(`borg seats: could not read the local registry: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
+export async function runLaunchSeat(
+  args: { target: string; cube?: string },
+  deps: SeatCommandDeps,
+): Promise<number> {
+  let rows: LocalSeatRow[];
+  try {
+    rows = await readLocalSeatRows(deps);
+  } catch (error) {
+    deps.stderr(`borg launch: could not read the local registry: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  if (args.cube) {
+    const cubeIds = new Set(rows.filter((row) => row.cubeName === args.cube).map((row) => row.cubeId));
+    if (cubeIds.size === 0) {
+      deps.stderr(
+        `borg launch: no cube named '${args.cube}' is registered on this machine. ` +
+        `Run \`borg seats\` to list this machine's cubes and drones.\n`,
+      );
+      return 1;
+    }
+    rows = rows.filter((row) => cubeIds.has(row.cubeId));
+  }
+
+  const labelMatches = rows.filter((row) => row.droneLabel === args.target);
+  const matches = labelMatches.length > 0
+    ? labelMatches
+    : rows.filter((row) => row.droneId.toLowerCase().startsWith(args.target.toLowerCase()));
+  if (matches.length === 0) {
+    if (rows.length === 0) {
+      deps.stderr(
+        `borg launch: drone '${args.target}' is not in this machine's seat registry. ` +
+        `The registry is local to each machine and lists only drones assimilated here. ` +
+        `Run \`borg seats\` on the machine where the drone was created.\n`,
+      );
+    } else if (args.cube) {
+      deps.stderr(
+        `borg launch: no drone matches '${args.target}' in cube '${args.cube}'. ` +
+        `Run \`borg seats\` to list the drones you can launch.\n`,
+      );
+    } else {
+      deps.stderr(
+        `borg launch: no drone matches '${args.target}' on this machine. ` +
+        `Run \`borg seats\` to list the drones you can launch.\n`,
+      );
+    }
+    return 1;
+  }
+  if (matches.length > 1) {
+    deps.stderr(
+      `borg launch: '${args.target}' matches ${matches.length} drones:\n` +
+      `${formatAmbiguousMatches(matches)}\n` +
+      `Add --cube <name>, or use the drone id prefix: borg launch ${matches[0].droneId.slice(0, 8)}.\n`,
+    );
+    return 1;
+  }
+
+  const selected = matches[0];
+  if (!selected.canonicalWorktree) {
+    deps.stderr(
+      `borg launch: drone '${selected.droneLabel}' is registered at ${selected.worktree}, but that directory does not exist. ` +
+      `Restore the directory, or run \`borg cleanup\` to review orphaned worktrees.\n`,
+    );
+    return 1;
+  }
+  if (selected.state !== 'active') {
+    deps.stderr(
+      `borg launch: drone '${selected.droneLabel}' has a pending seat (shown as \`pending\` in \`borg seats\`) — ` +
+      `its assimilation did not complete, so launching now would start an unattached session. ` +
+      `To complete the seat, run \`borg assimilate\` in ${selected.worktree}, then run ` +
+      `\`borg launch ${selected.droneLabel}\` again.\n`,
+    );
+    return 1;
+  }
+
+  let preferred: SeatRecord | null;
+  try {
+    preferred = await deps.getActiveSeatForWorktree(selected.canonicalWorktree);
+  } catch {
+    preferred = null;
+  }
+  if (!preferred) {
+    deps.stderr(
+      `borg launch: did not launch '${selected.droneLabel}' — its seat registration changed before the launch could start. ` +
+      `Run \`borg seats\` to see the current state, then try again.\n`,
+    );
+    return 1;
+  }
+  if (
+    seatRef(preferred) !== selected.credentialRef ||
+    preferred.cubeId !== selected.cubeId ||
+    preferred.droneId !== selected.droneId
+  ) {
+    deps.stderr(
+      `borg launch: did not launch '${selected.droneLabel}' — the worktree at ${selected.worktree} would resume ` +
+      `'${preferred.droneLabel}' (cube '${preferred.name}') instead. To resume '${preferred.droneLabel}', run \`borg\` ` +
+      `in that worktree. To review this machine's seats, run \`borg seats\`.\n`,
+    );
+    return 1;
+  }
+
+  const expectation: LaunchSeatExpectation = {
+    credentialRef: selected.credentialRef,
+    cubeId: selected.cubeId,
+    droneId: selected.droneId,
+    worktree: selected.canonicalWorktree,
+    droneLabel: selected.droneLabel,
+  };
+
+  try {
+    return await deps.launchBareBorg(selected.canonicalWorktree, expectation);
+  } catch (error) {
+    deps.stderr(`borg launch: failed to start borg in ${selected.canonicalWorktree}: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
+export function buildDefaultSeatCommandDeps(): SeatCommandDeps {
+  return {
+    readAllProjectIdentities,
+    readAllBoundSeats,
+    getActiveSeatForWorktree,
+    getProjectCliPreference: getProjectCliPreferenceForPath,
+    pathExists: existsSync,
+    realpath: realpathSync,
+    launchBareBorg: (worktree, expectation) => new Promise((resolve, reject) => {
+      const child = spawn(resolveBorgPath(), [], {
+        cwd: worktree,
+        stdio: 'inherit',
+        shell: false,
+        env: withLaunchSeatExpectationEnv(process.env, expectation),
+      });
+      child.once('error', reject);
+      child.once('exit', (code, signal) => resolve(signal ? 1 : code ?? 1));
+    }),
+    stdout: (line) => process.stdout.write(line),
+    stderr: (line) => process.stderr.write(line),
+  };
+}

package/src/seats.ts

@@ -675,6 +675,21 @@ export async function readAllActiveSeats(): Promise<Array<{ worktree: string; re
   return out;
 }
 
+/** All valid worktree-bound registry entries, including a PENDING seat whose
+ * interrupted finalize preserved its worktree for a later resume. Read-only:
+ * pending records remain non-hydratable and getActiveSeatForWorktree stays
+ * active-only. */
+export async function readAllBoundSeats(): Promise<Array<{ worktree: string; record: SeatRecord }>> {
+  const store = await readStore();
+  const out: Array<{ worktree: string; record: SeatRecord }> = [];
+  for (const [ref, record] of Object.entries(store.seats)) {
+    if (typeof record.worktree === 'string' && seatRef(record) === ref) {
+      out.push({ worktree: record.worktree, record });
+    }
+  }
+  return out;
+}
+
 // ─── Reset / scrub / metadata (all single-commit) ────────────────────────────
 
 export type ResetSeatOutcome =

package/src/unknown-subcommand.ts

@@ -21,6 +21,8 @@ export const KNOWN_SUBCOMMANDS = [
   'recover-enrollment',
   'spawn',
   'cleanup',
+  'seats',
+  'launch',
   'launch-all',
   'server',
 ] as const;

package/dist/backends/launch-all-windows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"launch-all-windows.d.ts","sourceRoot":"","sources":["../../src/backends/launch-all-windows.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAI3D,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAuED,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,cAAc,EAAE,EAC5B,IAAI,EAAE,WAAW,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/dist/backends/launch-all-windows.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"launch-all-windows.js","sourceRoot":"","sources":["../../src/backends/launch-all-windows.ts"],"names":[],"mappings":"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"}