borgmcp 3.5.0 → 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/log-stream.ts

@@ -142,11 +142,8 @@ export function setModuleInjectOpenCode(
  */
 const RECENT_IDS_CAP = 50;
 
-function formatOpenCodeWakePrompt(line: string, wakeNonce?: string): string {
-  const prompt = formatCubeActivityWakeMessage(line);
-  return wakeNonce === undefined
-    ? prompt
-    : `${prompt}\n\n<!-- borg-wake-nonce:${wakeNonce} -->`;
+function formatOpenCodeWakePrompt(line: string): string {
+  return formatCubeActivityWakeMessage(line);
 }
 
 export const INBOX_TAIL_LINES_CAP = 512;
@@ -875,7 +872,7 @@ export async function streamOnce(
       // exception: each wake nonce is a new delivery identity even when the
       // underlying inbox line is already durable.
       if (isReping) {
-        await injectOpenCode(formatOpenCodeWakePrompt(line, ev.wake_nonce), deliveryId, true);
+        await injectOpenCode(formatOpenCodeWakePrompt(line), deliveryId, true);
       }
       markEventPersisted(ev.id, ev.data?.created_at ?? '');
       return 'persisted-skip';
@@ -883,7 +880,7 @@ export async function streamOnce(
     // The inbox append is the durable record. OpenCode injection is only the
     // wake attempt and may return before the agent finishes processing.
     await appendLine(active.cubeId, active.droneId, line);
-    if (!(await injectOpenCode(formatOpenCodeWakePrompt(line, ev.wake_nonce), deliveryId, true))) {
+    if (!(await injectOpenCode(formatOpenCodeWakePrompt(line), deliveryId, true))) {
       if (ev.wake_nonce === undefined) wakeCodex(formatCodexWakePrompt(line));
       else wakeCodex(formatCodexWakePrompt(line), ev.wake_nonce);
     }
@@ -1201,7 +1198,7 @@ export async function streamOnce(
         if (isRecentWakeReplay) {
           const line = formatInboxLine(withSseEventId(event.data, event.id));
           const wakeNonce = event.wake_nonce;
-          if (wakeNonce !== undefined && !(await injectOpenCode(formatOpenCodeWakePrompt(line, wakeNonce), wakeNonce, true))) {
+          if (wakeNonce !== undefined && !(await injectOpenCode(formatOpenCodeWakePrompt(line), wakeNonce, true))) {
             wakeCodex(formatCodexWakePrompt(line), wakeNonce);
           }
           continue;

package/src/opencode-drone.ts

@@ -3,7 +3,10 @@ import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { OPENCODE_INJECTED_ENTRY_METADATA_KEY } from './opencode-plugin.js';
+import {
+  OPENCODE_INJECTED_ENTRY_METADATA_KEY,
+  OPENCODE_WAKE_IDENTITY_METADATA_KEY,
+} from './opencode-plugin.js';
 
 const LOG_FILE = join(tmpdir(), 'borg-opencode-drone.log');
 function log(msg: string) {
@@ -57,6 +60,7 @@ interface OCMessage {
   parts?: Array<{
     type?: string;
     text?: string;
+    metadata?: Record<string, unknown>;
   }>;
 }
 
@@ -213,12 +217,20 @@ async function listSessionMessages(id: string): Promise<OCMessage[]> {
   return JSON.parse(body);
 }
 
-async function findInjectedMessage(sessionId: string, text: string): Promise<string | null> {
+async function findInjectedMessage(
+  sessionId: string,
+  expectedWakeIdentity: string,
+): Promise<string | null> {
   const messages = await listSessionMessages(sessionId);
   for (let index = messages.length - 1; index >= 0; index--) {
     const message = messages[index];
     if (message?.info?.role !== 'user' || typeof message.info.id !== 'string') continue;
-    if (message.parts?.some((part) => part.type === 'text' && part.text === text)) {
+    const part = message.parts?.[0];
+    if (
+      part?.type === 'text' &&
+      part.metadata?.[OPENCODE_INJECTED_ENTRY_METADATA_KEY] === true &&
+      part.metadata?.[OPENCODE_WAKE_IDENTITY_METADATA_KEY] === expectedWakeIdentity
+    ) {
       return message.info.id;
     }
   }
@@ -493,7 +505,7 @@ async function deliverOpenCodeEntry(
     }
 
     try {
-      if (await findInjectedMessage(target.id, delivery.text)) {
+      if (await findInjectedMessage(target.id, delivery.entryId)) {
         log(`entry ${delivery.entryId} already present in session ${target.id}`);
         return 'delivered';
       }
@@ -515,7 +527,10 @@ async function deliverOpenCodeEntry(
         parts: [{
           type: 'text',
           text: delivery.text,
-          metadata: { [OPENCODE_INJECTED_ENTRY_METADATA_KEY]: true },
+          metadata: {
+            [OPENCODE_INJECTED_ENTRY_METADATA_KEY]: true,
+            [OPENCODE_WAKE_IDENTITY_METADATA_KEY]: delivery.entryId,
+          },
         }],
       });
     } catch (err) {
@@ -541,7 +556,7 @@ async function deliverOpenCodeEntry(
         delivery.state = 'delivered-unconfirmed';
       }
       try {
-        if (await findInjectedMessage(target.id, delivery.text)) {
+        if (await findInjectedMessage(target.id, delivery.entryId)) {
           return 'delivered';
         }
       } catch (err) {
@@ -640,10 +655,9 @@ export async function injectInitialKickoff(launch: OpenCodeLaunchKickoff): Promi
 
 /**
  * Queue one durable inbox entry for delivery into the bound OpenCode session.
- * The injected text identifies the OpenCode-generated user message, so retries
- * and replay can confirm an earlier ambiguous submission without supplying an
- * ordering-breaking caller message ID or running it twice. Normal delivery uses
- * canonical inbox text; wake re-pings include their stable nonce marker.
+ * The delivery identity is stored in TextPart metadata, so retries and replay
+ * can confirm an earlier ambiguous submission without supplying an
+ * ordering-breaking caller message ID or exposing the identity in delivered text.
  */
 export function injectOpenCodeEntry(
   text: string,

package/src/opencode-plugin.ts

@@ -18,6 +18,7 @@ const COMPACT_FALLBACK =
   '## Borg Cube\nYou are in a Borg MCP multi-agent coordination cube. ' +
   'Use MCP tool borg_regen to get full context and recent activity.';
 export const OPENCODE_INJECTED_ENTRY_METADATA_KEY = 'borgOpenCodeInjectedEntry';
+export const OPENCODE_WAKE_IDENTITY_METADATA_KEY = 'borgOpenCodeWakeIdentity';
 export const OPENCODE_RECOVERY_METADATA_KEY = 'borgOpenCodeSessionOrientation';
 const PLUGIN_REL_PATH = path.join('.config', 'opencode', 'plugins', 'borg-orient.js');
 
@@ -146,7 +147,7 @@ export function createOpenCodePluginCore(
 }
 
 export function buildBorgPluginSource(version: string): string {
-  const marker = `borgmcp-opencode-plugin:${version};opencode=${OPENCODE_COMPATIBILITY.opencode};sdk=${OPENCODE_COMPATIBILITY.sdk};textpart-metadata=exists+persisted+tui-hidden+model-hidden`;
+  const marker = `borgmcp-opencode-plugin:${version};opencode=${OPENCODE_COMPATIBILITY.opencode};sdk=${OPENCODE_COMPATIBILITY.sdk};textpart-metadata=exists+persisted+tui-hidden+model-hidden;wake-identity-key=${OPENCODE_WAKE_IDENTITY_METADATA_KEY}`;
   return `// ${marker}
 // Generated by borgmcp. Self-contained; do not edit.
 const createCore = ${createOpenCodePluginCore.toString()};

package/src/opencode-wake-copy.ts

@@ -3,7 +3,7 @@ import { CUBE_ACTIVITY_RESUME_WAKE_MESSAGE } from './cube-activity-wake-copy.js'
 export const OPENCODE_WAKE_PATH_GUIDANCE =
   'OpenCode wakes through HTTP entry injection into its session through the local HTTP API. ' +
   'Borg writes each entry to the durable inbox before one injection attempt and ' +
-  'confirms delivery by the unique persisted entry text; no inbox Monitor or secondary wake loop is used. ' +
+  'confirms delivery by its unique persisted metadata identity; no inbox Monitor or secondary wake loop is used. ' +
   'If injection is rejected or cannot be ' +
   'confirmed, the durable entry remains available and `borg_stream-status` reports ' +
   'it as failed or delivered-unconfirmed; run `borg_read-log unread_only=true` and ' +

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);