borgmcp 3.5.1 → 3.6.1

package/src/cli-help.ts

@@ -35,7 +35,6 @@ export function launchAllHelpText(version: string): string {
     `  --mode <tmux|terminals|pastelist>     Select the launch backend\n` +
     `  --only <name>                         Launch one role or drone label\n` +
     `  --dry-run                             Show what would launch\n` +
-    `  --cli <claude|codex|opencode>         Select the agent CLI\n` +
     `  --no-attach                           Do not attach to the tmux session\n` +
     `  --yes, -y                             Skip the large-fleet confirmation\n` +
     `  --force                               Override live-session skips\n` +
@@ -126,7 +125,7 @@ export function topLevelHelpText(version: string): string {
     `Install Claude Code, Codex, or OpenCode first. Type \`borg ...\` in your terminal;\n` +
     `type \`borg_...\` inside your agent session once you've joined a cube ("assimilate").\n\n` +
     `Usage:\n` +
-    `  borg                     Launch your agent CLI; in a TTY, bare borg may show the launch menu\n` +
+    `  borg                     Show the launch menu in a repository root; resume directly in a linked worktree\n` +
     `  borg setup               Set up borg MCP server + agent CLI integration\n` +
     `  borg update              Update the client and installed local server together\n` +
     `  borg doctor              Check agent hook commands, versions, configs, and the OpenCode plugin\n` +
@@ -140,8 +139,6 @@ export function topLevelHelpText(version: string): string {
     `  borg seats               List this machine's registered drones and worktrees\n` +
     `  borg launch <drone-label-or-id-prefix>  Reopen one registered drone from its worktree\n` +
     `  borg launch-all [cube]   Launch all drone worktrees of a cube (default: active cube)\n` +
-    `  borg launch-all [cube] --cli claude|codex|opencode\n` +
-    `                           Launch all drone worktrees with that agent CLI\n` +
     `  borg server <command> [arguments]\n` +
     `  borg --cli claude|codex|opencode  Launch that agent CLI directly\n` +
     `  borg --version           Show installed version\n\n` +
@@ -230,17 +227,17 @@ export function assimilateHelpText(version: string): string {
   return (
     `borg assimilate (borgmcp ${version}) — join or create a cube under a role\n\n` +
     `Usage:\n` +
-    `  borg assimilate [role]               Join the active cube under [role] (default role if omitted)\n` +
-    `  borg assimilate [role] --worktree <name>   Spawn the drone in an isolated git worktree\n` +
+    `  borg assimilate [role]               Create the drone in a managed git worktree\n` +
+    `  borg assimilate [role] --worktree <name>   Name the drone's managed git worktree\n` +
     `                                       (~/.borg/worktrees/<repo>/<name>)\n` +
-    `  borg assimilate --here               Assimilate in the current worktree (no sibling spawn)\n` +
+    `  borg assimilate --here               Resume this worktree's saved drone\n` +
     `  borg assimilate --here --force       Reattach despite a still-live inbox monitor\n` +
     `  borg assimilate --host <host>        Join an authorized self-hosted cube\n` +
     `  borg assimilate --host <host> --enroll   Operator-terminal enrollment, then create/join (preview)\n` +
     `  borg assimilate --help               Show this help\n\n` +
     `Flags:\n` +
-    `  --worktree <name>          Create + launch the drone in a sibling git worktree\n` +
-    `  --here                     Stay in the current worktree (no sibling spawn)\n` +
+    `  --worktree <name>          Name the managed worktree created for the new drone\n` +
+    `  --here                     Resume this worktree's saved drone\n` +
     `  --force                    Reattach despite a still-live inbox monitor in this worktree\n` +
     `  --cube-name <name>         Repository cube name (otherwise edit the proposed name)\n` +
     `  --host <host>              Borg server host or URL (bare hosts default to HTTPS)\n` +

package/src/console-prefix.ts

@@ -26,7 +26,7 @@
 
 import { basename } from 'node:path';
 import chalk from 'chalk';
-import { getActiveCube } from './cubes.js';
+import { getActiveCube, LaunchSeatIdentityChangedError } from './cubes.js';
 import {
   _resetDisplayIdentityForTests,
   currentDisplayIdentity,
@@ -55,7 +55,11 @@ export async function initConsolePrefix(): Promise<string> {
       initialized = true;
       return droneIdPrefix();
     }
-  } catch {
+  } catch (error) {
+    // A targeted `borg launch` child must stop before CLI selection can write
+    // launch.json. This identity guard is a launch boundary, not a cosmetic
+    // prefix read failure, so never collapse it into the neutral fallback.
+    if (error instanceof LaunchSeatIdentityChangedError) throw error;
     // Fall through to unassimilated fallback.
   }
   initialized = true;

package/src/index.ts

@@ -601,11 +601,7 @@ export async function main() {
           seedDisplayIdentity(active);
           let result: Awaited<ReturnType<typeof whoami>>;
           try {
-            result = await whoami(
-              active.sessionToken,
-              active.apiUrl,
-              active.serverTrustIdentity,
-            );
+            result = await whoami(active);
           } catch (error) {
             markDisplayIdentityReadFailed(active);
             throw error;
@@ -737,12 +733,7 @@ export async function main() {
         case 'borg_roster': {
           const active = await requireActiveCube();
           const since = typeof args?.since === 'string' ? args.since : undefined;
-          const { drones, roles, since: resolvedSince } = await getRoster(
-            active.sessionToken,
-            active.apiUrl,
-            since,
-            active.serverTrustIdentity,
-          );
+          const { drones, roles, since: resolvedSince } = await getRoster(active, since);
           const text = renderRoster({
             cubeName: active.name,
             drones,

package/src/launch-all-cmd.ts

@@ -55,28 +55,60 @@ async function resolveTargetCube(
     if (matches.length === 0) {
       return { error: `no cube named '${args.cubeName}' found among this machine's saved connections — has any drone assimilated into it?` };
     }
+    const matchesByCubeId = new Map<string, typeof matches>();
+    for (const match of matches) {
+      const sameCube = matchesByCubeId.get(match.cube.cubeId) ?? [];
+      sameCube.push(match);
+      matchesByCubeId.set(match.cube.cubeId, sameCube);
+    }
     // gh#850: distinct cubes can share a name (same name across accounts/
     // environments, or a stale seat). Silently taking matches[0] could launch
     // the wrong fleet, so when the name is ambiguous, surface each match's
-    // cubeId + the project that holds the seat and refuse to guess.
-    if (matches.length > 1) {
-      const list = matches
-        .map((m) => `  ${m.cube.cubeId}  (drone in ${m.projectPath})`)
+    // cubeId + one project that holds a seat and refuse to guess. Multiple
+    // seats for the SAME cube are one fleet, not ambiguity.
+    if (matchesByCubeId.size > 1) {
+      const list = [...matchesByCubeId.entries()]
+        .map(([cubeId, sameCube]) => `  ${cubeId}  (drone in ${sameCube[0].projectPath})`)
         .join('\n');
       return {
         error:
-          `'${args.cubeName}' is ambiguous — ${matches.length} saved connections on this machine share that name:\n${list}\n` +
+          `'${args.cubeName}' is ambiguous — ${matchesByCubeId.size} distinct cubes on this machine share that name:\n${list}\n` +
           'cd into the intended project and re-run as `borg launch-all` without the positional cube name (resolves the active cube), ' +
           'or clear the stale connection(s) by running `borg reset-local-connection` from the worktree that holds each.',
       };
     }
-    return { cubeId: matches[0].cube.cubeId, name: args.cubeName };
+    return { cubeId: matchesByCubeId.keys().next().value!, name: args.cubeName };
   }
   const active = await deps.getActiveCube();
   if (!active) {
+    const identities = await deps.readAllProjectIdentities();
+    const knownCubeIds = [...new Set(identities.map(({ cube }) => cube.cubeId))];
+    const candidates = (
+      await Promise.all(knownCubeIds.map((cubeId) =>
+        discoverDroneCandidates({ targetCubeId: cubeId }, deps)
+      ))
+    ).flat();
+    const candidatesByCubeId = new Map<string, DroneCandidate[]>();
+    for (const candidate of candidates) {
+      const sameCube = candidatesByCubeId.get(candidate.cubeId) ?? [];
+      sameCube.push(candidate);
+      candidatesByCubeId.set(candidate.cubeId, sameCube);
+    }
+    if (candidatesByCubeId.size === 1) {
+      const [cubeId, sameCube] = candidatesByCubeId.entries().next().value!;
+      return { cubeId, name: sameCube[0].seat.name };
+    }
+    if (candidatesByCubeId.size === 0) {
+      return {
+        error:
+          'no saved drone worktrees were found for this repository; pass a cube name explicitly as ' +
+          '`borg launch-all <cube-name>`, or cd into a drone worktree and rerun `borg launch-all`',
+      };
+    }
     return {
       error:
-        'no active cube in this directory; run `borg assimilate` first, or pass a cube name explicitly',
+        `linked drone worktrees for this repository belong to ${candidatesByCubeId.size} cubes; ` +
+        'pass the intended cube name as `borg launch-all <cube-name>`, or cd into a drone worktree and rerun `borg launch-all`',
     };
   }
   return { cubeId: active.cubeId, name: active.name };
@@ -138,9 +170,7 @@ function sanitizeSessionName(cubeName: string): string {
 /** Roster reconciliation (spec §7.2). Returns droneId → 'verified'|'unconfirmed'. */
 async function reconcileRoster(
   deps: LaunchAllDeps,
-  token: string,
-  apiUrl: string,
-  serverTrustIdentity: string | undefined,
+  seat: DroneCandidate['seat'],
   launchStartISO: string,
   launchedDroneIds: string[],
   now: () => number = Date.now,
@@ -156,10 +186,8 @@ async function reconcileRoster(
     let roster: { drones: Array<{ id: string; seen_since?: boolean }> };
     try {
       roster = await deps.getRoster(
-        token,
-        apiUrl,
+        seat,
         launchStartISO,
-        serverTrustIdentity,
       );
     } catch (err) {
       // gh#850: the roster-reconcile token can rotate mid-launch — authedFetch
@@ -294,7 +322,7 @@ export async function runLaunchAll(
   for (const c of lockLaunchable) {
     let status: SeatStatus;
     try {
-      status = await deps.probeSeat(c.sessionToken, c.apiUrl, c.serverTrustIdentity);
+      status = await deps.probeSeat(c.seat);
     } catch {
       status = 'indeterminate';
     }
@@ -310,7 +338,7 @@ export async function runLaunchAll(
       revokedCount += 1;
       deps.stderr(
         `Local session was revoked.\n` +
-          `Next: run borg reset-local-connection, then borg assimilate --host ${c.apiUrl} --enroll.\n`
+          `Next: run borg reset-local-connection, then borg assimilate --host ${c.seat.apiUrl} --enroll.\n`
       );
       continue;
     }
@@ -318,7 +346,7 @@ export async function runLaunchAll(
       rejectedCount += 1;
       deps.stderr(
         `Local session was superseded by a newer enrollment.\n` +
-          `Next: run borg reset-local-connection, then borg assimilate --host ${c.apiUrl} --enroll.\n`
+          `Next: run borg reset-local-connection, then borg assimilate --host ${c.seat.apiUrl} --enroll.\n`
       );
       continue;
     }
@@ -328,7 +356,7 @@ export async function runLaunchAll(
       trustMismatchCount += 1;
       deps.stderr(
         `skipping ${c.droneLabel} (${c.worktreeDir}): could not verify the server identity ` +
-          `(pinned trust changed) — this is terminal. Confirm ${c.apiUrl} is the expected server; ` +
+          `(pinned trust changed) — this is terminal. Confirm ${c.seat.apiUrl} is the expected server; ` +
           'if it was re-initialized, restore the expected identity before relaunching.\n'
       );
       continue;
@@ -339,7 +367,7 @@ export async function runLaunchAll(
       credentialRejectedCount += 1;
       deps.stderr(
         `skipping ${c.droneLabel} (${c.worktreeDir}): saved credential was rejected (not a takeover) — ` +
-          `re-enroll from that worktree with \`borg assimilate --host ${c.apiUrl} --enroll\`.\n`
+          `re-enroll from that worktree with \`borg assimilate --host ${c.seat.apiUrl} --enroll\`.\n`
       );
       continue;
     }
@@ -438,25 +466,15 @@ export async function runLaunchAll(
     return 1;
   }
 
-  // 9. roster reconciliation (best-effort; uses the OLD saved token from the first candidate)
-  const reconToken = launchable[0].sessionToken;
-  const reconApiUrl = launchable[0].apiUrl;
-  const reconServerTrustIdentity = launchable[0].serverTrustIdentity;
-  let statuses: Map<string, 'verified' | 'unconfirmed'> | null = null;
-  if (reconToken && reconApiUrl) {
-    statuses = await reconcileRoster(
-      deps,
-      reconToken,
-      reconApiUrl,
-      reconServerTrustIdentity,
-      launchStartISO,
-      launchable.map((c) => c.droneId),
-      opts.now,
-      opts.sleep
-    );
-  } else {
-    deps.stderr('roster reconciliation skipped — no session token available\n');
-  }
+  // 9. roster reconciliation (best-effort; uses the first launchable seat)
+  const statuses = await reconcileRoster(
+    deps,
+    launchable[0].seat,
+    launchStartISO,
+    launchable.map((c) => c.droneId),
+    opts.now,
+    opts.sleep
+  );
 
   // 10. summary
   deps.stdout(`\nborg launch-all: launched ${launchable.length} drones for cube '${cubeName}'\n\n`);

package/src/launch-all-command.ts

@@ -13,18 +13,23 @@ export function resolveBorgPath(): string {
 
 /**
  * The shell command run inside each worktree's window/tab.
- * `keepOpenOnFail` wraps a `|| read` pause so a failed assimilate doesn't close
+ * `borg launch <droneId>` is a prompt-free, network-free preflight that pins the
+ * saved seat. The spawned child fail-closes through BORG_LAUNCH_EXPECTED_SEAT if
+ * the worktree's seat changed instead of silently resuming a different drone.
+ * `keepOpenOnFail` wraps a `|| read` pause so a failed launch doesn't close
  * the tmux window before the operator reads the error (tmux convenience only;
  * the pastelist backend omits it — the operator owns their own shell).
  */
 export function buildLaunchCommand(
-  worktreeDir: string,
+  candidate: { worktreeDir: string; droneId: string },
   borgPath: string,
   opts: { keepOpenOnFail?: boolean } = {}
 ): string {
-  const base = `cd ${shellEscape(worktreeDir)} && ${shellEscape(borgPath)} assimilate --here`;
+  const base =
+    `cd ${shellEscape(candidate.worktreeDir)} && ` +
+    `${shellEscape(borgPath)} launch ${shellEscape(candidate.droneId)}`;
   if (opts.keepOpenOnFail) {
-    return `${base} || { echo "borg assimilate failed — press Enter to close"; read _; }`;
+    return `${base} || { echo "borg launch failed — press Enter to close"; read _; }`;
   }
   return base;
 }

package/src/launch-all-deps.ts

@@ -62,10 +62,8 @@ export interface LaunchAllDeps {
   listDir: (p: string) => string[];
   /** Roster call (wraps getRoster from remote-client.ts). */
   getRoster: (
-    token: string,
-    apiUrl: string,
+    seat: ActiveCube,
     since?: string,
-    serverTrustIdentity?: string,
   ) => Promise<{ drones: Array<{ id: string; seen_since?: boolean }> }>;
   /** getCube for --only tier-2 role-name resolution (best-effort). */
   getCube: (
@@ -79,9 +77,7 @@ export interface LaunchAllDeps {
    * of relaunching them (which silently re-mints a fresh drone — resurrection).
    */
   probeSeat: (
-    sessionToken: string,
-    apiUrl: string,
-    serverTrustIdentity?: string,
+    seat: ActiveCube,
   ) => Promise<SeatStatus>;
   /** Saved CLI preference for a worktree path (launch.json). */
   getCliPreferenceForPath: (projectPath: string) => Promise<'claude' | 'codex' | 'opencode' | null>;
@@ -157,12 +153,10 @@ export function buildDefaultLaunchAllDeps(): LaunchAllDeps {
         return [];
       }
     },
-    getRoster: (token, apiUrl, since, serverTrustIdentity) =>
-      getRoster(token, apiUrl, since, serverTrustIdentity),
+    getRoster: (seat, since) => getRoster(seat, since),
     // getCube uses the drone session token via authedFetch (cubeId-only); apiUrl/token unused.
     getCube: (_apiUrl, _token, cubeId) => getCube(cubeId),
-    probeSeat: (sessionToken, apiUrl, serverTrustIdentity) =>
-      defaultProbeSeat(sessionToken, apiUrl, serverTrustIdentity),
+    probeSeat: (seat) => defaultProbeSeat(seat),
     getCliPreferenceForPath: (projectPath) => getProjectCliPreferenceForPath(projectPath),
     readAllProjectIdentities: () => cubesReadAllProjectIdentities(),
     findProjectRoot: (dir) => findProjectRoot(dir),

package/src/launch-all-discovery.ts

@@ -6,15 +6,14 @@
 // only worktrees whose saved identity has cubeId === target.
 
 import type { LaunchAllDeps, RunSyncFn } from './launch-all-deps.js';
+import type { ActiveCube } from './cubes.js';
 
 export interface DroneCandidate {
   worktreeDir: string;
   cubeId: string;
   droneId: string;
   droneLabel: string;
-  sessionToken: string;
-  apiUrl: string;
-  serverTrustIdentity?: string;
+  seat: ActiveCube;
 }
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -107,11 +106,7 @@ export async function discoverDroneCandidates(
       cubeId: cube.cubeId,
       droneId: cube.droneId,
       droneLabel: cube.droneLabel,
-      sessionToken: cube.sessionToken,
-      apiUrl: cube.apiUrl,
-      ...(cube.serverTrustIdentity === undefined
-        ? {}
-        : { serverTrustIdentity: cube.serverTrustIdentity }),
+      seat: cube,
     });
   }
   return candidates;

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

@@ -5,7 +5,6 @@ export interface LaunchAllFlags {
   mode?: 'tmux' | 'terminals' | 'pastelist';
   only?: string;
   dryRun?: boolean;
-  cli?: 'claude' | 'codex' | 'opencode';
   noAttach?: boolean;
   yes?: boolean;
   force?: boolean;
@@ -28,7 +27,7 @@ export type ParseLaunchAllResult =
   | { ok: false; error: string };
 
 const SUPPORTED =
-  '--mode <tmux|terminals|pastelist>, --only <name>, --dry-run, --cli <claude|codex|opencode>, ' +
+  '--mode <tmux|terminals|pastelist>, --only <name>, --dry-run, ' +
   '--no-attach, --yes/-y, --force, --launch-delay <ms>';
 
 export function parseLaunchAllArgs(rawArgs: string[]): ParseLaunchAllResult {
@@ -54,14 +53,6 @@ export function parseLaunchAllArgs(rawArgs: string[]): ParseLaunchAllResult {
         flags.only = v;
         break;
       }
-      case '--cli': {
-        const v = rawArgs[++i];
-        if (v !== 'claude' && v !== 'codex' && v !== 'opencode') {
-          return { ok: false, error: `--cli must be one of claude|codex|opencode (got: ${v ?? '<missing>'})` };
-        }
-        flags.cli = v;
-        break;
-      }
       case '--launch-delay': {
         const v = rawArgs[++i];
         const n = v === undefined ? NaN : Number(v);

package/src/remote-client.ts

@@ -244,6 +244,15 @@ async function localAuthorityContext(
   return matched;
 }
 
+function assertSeatAuthority(active: ActiveCube): ActiveCube {
+  if (!active.serverTrustIdentity) {
+    throw new Error('Selected Borg server authority state is missing or unreadable');
+  }
+  assertUuidShape(active.cubeId, 'cube_id');
+  assertUuidShape(active.droneId, 'drone_id');
+  return active;
+}
+
 function localUnsupported(capability: string): never {
   throw new LocalUnsupportedError(capability);
 }
@@ -942,11 +951,9 @@ export async function getRoleInfoByName(
 }
 
 export async function whoami(
-  sessionToken: string,
-  apiUrl: string,
-  serverTrustIdentity?: string,
+  active: ActiveCube,
 ): Promise<{ cube_id: string; cube_name: string; drone_id: string; drone_label: string; role_id: string; role_name: string; runtime_metadata: { agent_kind: AgentKind | null; reported_model: string | null; working_repo_name: string | null; working_repo_origin: string | null }; runtime_metadata_reported: boolean }> {
-  const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
+  const local = assertSeatAuthority(active);
   const composed = await localCubeComposition(local);
   return {
     cube_id: composed.cube.id,
@@ -978,12 +985,10 @@ export async function whoami(
  *     even when the caller passed an entry-id)
  */
 export async function getRoster(
-  sessionToken: string,
-  apiUrl: string,
+  active: ActiveCube,
   since?: string,
-  serverTrustIdentity?: string,
 ): Promise<{ drones: any[]; roles: any[]; message_taxonomy?: MessageTaxonomy | null; since?: string | null }> {
-  const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
+  const local = assertSeatAuthority(active);
   if (since !== undefined) {
     const [dronePayload, rolePayload, cubePayload] = await Promise.all([
       localServerRequest<{ drones: any[]; since?: string | null }>(

package/src/seat-probe.ts

@@ -6,6 +6,7 @@
 // graph. cleanup-cmd re-exports `SeatStatus` for backwards compatibility.
 
 import { whoami } from './remote-client.js';
+import type { ActiveCube } from './cubes.js';
 import { DroneEvictedError } from './drone-lifecycle.js';
 import {
   BorgServerError,
@@ -87,12 +88,10 @@ function isTransportFailure(err: unknown): boolean {
  * fail-OPEN.
  */
 export async function defaultProbeSeat(
-  sessionToken: string,
-  apiUrl: string,
-  serverTrustIdentity?: string,
+  seat: ActiveCube,
 ): Promise<SeatStatus> {
   try {
-    await whoami(sessionToken, apiUrl, serverTrustIdentity);
+    await whoami(seat);
     return 'live';
   } catch (err) {
     if (err instanceof DroneEvictedError) return 'evicted';

package/src/seat-store.ts

@@ -408,6 +408,24 @@ export async function withStoreLock<T>(
           await new Promise((resolvePromise) => setTimeout(resolvePromise, waitMs));
           continue;
         }
+        // The holder may have released cleanly between our payload read and the
+        // liveness check. Revalidate the exact observation before diagnosing it as
+        // stale: a missing or changed pathname is lock turnover, so retry acquisition.
+        // An unchanged dead/corrupt observation still fails closed below; we never
+        // delete, reclaim, or steal it.
+        let currentRaw: string | null;
+        try {
+          currentRaw = await readStoreFile(
+            lockPath,
+            opts.secureRoot
+              ? { secureRoot: opts.secureRoot, rootMode: opts.rootMode }
+              : {},
+          );
+        } catch (readErr) {
+          if ((readErr as NodeJS.ErrnoException).code === 'ENOENT') continue;
+          throw readErr;
+        }
+        if (currentRaw === null || currentRaw !== raw) continue;
         // Dead recorded holder, or a missing/unparseable payload → fail closed. The
         // operator must confirm no borg process is running and delete the file by hand.
         throw staleLockError(lockPath, held);

package/src/worktree-lifecycle.ts

@@ -123,56 +123,11 @@ export function isMerged(runSync: RunSync, cwd: string, branch: string, ref: str
   return runSync('git', ['merge-base', '--is-ancestor', branch, ref], cwd).status === 0;
 }
 
-export interface AdoptResult {
-  action: 'adopted' | 'blocked-unmerged' | 'blocked-target-unmerged' | 'skipped-dirty';
-  message?: string;
-}
-
 /** True iff a local branch named `branch` already exists. */
 export function localBranchExists(runSync: RunSync, cwd: string, branch: string): boolean {
   return runSync('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], cwd).status === 0;
 }
 
-/**
- * Migration (Q4/Q5/§4.5): bring a detached/stale worktree onto
- * `wt-<basename>` at `ref`. Idempotent: re-running on an already-adopted
- * clean worktree is a lossless reset to `ref`. Never discards:
- *   - dirty work tree            -> skipped-dirty (surface)
- *   - current HEAD unmerged      -> blocked-unmerged (surface)
- *   - TARGET `branch` exists with commits not on `ref` -> blocked-target-
- *     unmerged (surface). This is load-bearing: the switch uses `-C`
- *     (force-create/reset), which would ORPHAN commits on a pre-existing
- *     `wt-` branch. The HEAD-merged check alone misses this when the
- *     target branch != HEAD (e.g. on `main` while a prior `wt-x` holds
- *     committed-but-unmerged work). gh#33 CR-v2 blocker 078d1630.
- */
-export function adoptWorktree(runSync: RunSync, cwd: string, branch: string, ref: string): AdoptResult {
-  if (!isCleanTree(runSync, cwd)) {
-    return {
-      action: 'skipped-dirty',
-      message: 'uncommitted changes present; not switching (nothing discarded)',
-    };
-  }
-  if (!isMerged(runSync, cwd, 'HEAD', ref)) {
-    return {
-      action: 'blocked-unmerged',
-      message: `current HEAD has commits not on ${ref}; commit/push or set aside before adopting`,
-    };
-  }
-  // Guard the TARGET branch ref before the `switch -C` force-reset. If
-  // `branch` already exists and is NOT an ancestor of `ref`, it carries
-  // committed-unmerged work that `-C` would discard — block instead.
-  // (Absent, or an ancestor of `ref` = a clean reset target → proceed.)
-  if (localBranchExists(runSync, cwd, branch) && !isMerged(runSync, cwd, branch, ref)) {
-    return {
-      action: 'blocked-target-unmerged',
-      message: `branch ${branch} exists with commits not on ${ref}; resolve before adopting (a force-switch would discard them)`,
-    };
-  }
-  runSync('git', ['switch', '-C', branch, ref], cwd);
-  return { action: 'adopted' };
-}
-
 export interface CleanupResult {
   action: 'pruned' | 'announced' | 'not-merged';
   /** The feature branch this result concerns (for the announce message). */