borgmcp 3.4.0 → 3.5.1

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/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

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