borgmcp 2.7.1 → 2.7.3

package/src/assimilate-cmd.ts

@@ -540,11 +540,22 @@ function reportServerFailure(
     );
     return 1;
   }
+  if (/Borg server trust files were not found/i.test(message)) {
+    deps.stderr(
+      `This machine has no trust material for Borg server ${apiUrl}. ` +
+        'For a local server on this machine, run `borg server setup`, then run ' +
+        '`borg server start`, and rerun ' +
+        `${retryCommand}. A server on another machine requires a supported trust-bootstrap ` +
+        'step before enrollment; an invitation alone cannot establish server identity.\n',
+    );
+    return 1;
+  }
   if (/trust|certificate|\bCA\b|authority state|pinned identity|cross-authority/i.test(message)) {
     deps.stderr(
       `Borg could not verify the expected server identity for ${apiUrl}. ` +
-        'Verify that this is the expected server. If it was re-initialized, stop it, ' +
-        'run `borg-mcp-server start`, then rerun ' +
+        'Verify that this is the expected server. If it was re-initialized, ask the server ' +
+        'operator to restore the expected identity. For a local server on this machine, use ' +
+        '`borg server setup` and `borg server start`, then rerun ' +
         `${retryCommand}.\n`,
     );
     return 1;
@@ -1456,7 +1467,10 @@ export async function runAssimilate(
       }
     }
 
-    const repoBase = basename(projectRoot);
+    // The common Git directory identifies the repository across every linked
+    // worktree. Using projectRoot here fragments one repository's siblings when
+    // assimilation starts inside an existing sibling worktree.
+    const repoBase = basename(dirname(repositoryContext.commonDir));
     const suffix = args.flags.worktree ?? roleSlug(assignedRole.name);
     // gh#556 Part 1: empty-suffix guard (CR-binding). roleSlug can yield '' for a
     // pathological all-special-char role name; an empty leaf would let join() collapse
@@ -1473,6 +1487,15 @@ export async function runAssimilate(
     // (was a sibling <parent>/<repo>-<name>). Existing siblings are untouched
     // (absolute git-registered paths). Collision dedup KEPT (<name>-<n>).
     const homeDir = deps.homedir();
+    let registeredWorktrees = listRegisteredWorktrees(deps, projectRoot);
+    if (registeredWorktrees === null) {
+      deps.stderr(
+        'Borg could not enumerate this repository’s existing worktrees, so it did not risk creating a colliding sibling.\n' +
+        'Run `git worktree list` from this repository and resolve the reported Git error, then rerun `borg assimilate`.\n' +
+        'A seat was reserved and remains pending; rerunning after fixing the worktree issue resumes that seat.\n',
+      );
+      return 1;
+    }
     let candidate = computeWorktreePath(homeDir, repoBase, suffix);
     let wtBranch = perWorktreeBranchName(basename(candidate), repoBase);
     let n = 2;
@@ -1485,7 +1508,8 @@ export async function runAssimilate(
     // fresh suffix so we never reuse/clobber its work.
     while (
       deps.pathExists(candidate) ||
-      worktreeRegistered(deps, projectRoot, candidate) ||
+      registeredWorktrees.names.has(basename(candidate)) ||
+      registeredWorktrees.branches.has(wtBranch) ||
       (localBranchExists(deps.runSync, projectRoot, wtBranch) &&
         !isMerged(deps.runSync, projectRoot, wtBranch, startRef))
     ) {
@@ -1493,26 +1517,56 @@ export async function runAssimilate(
       wtBranch = perWorktreeBranchName(basename(candidate), repoBase);
       n++;
     }
-    // gh#556 Part 1: create the intermediate ~/.borg/worktrees/<repo>/ before
-    // `git worktree add` (git creates the leaf, not the parent chain). Plain
-    // recursive mkdir — NO chmod of the existing ~/.borg (credentials file).
-    deps.mkdirp(dirname(candidate));
-    // gh#33 (Q1/Q4): spawn on a named per-worktree branch (wt-<suffix>),
-    // NOT detached HEAD. The named branch is current with startRef and is
-    // where the drone's feature branches get cut from. Uniform for every
-    // role incl. coordinator — main is never a working branch (Q4).
-    // Branch naming is UNAFFECTED by the relocation: perWorktreeBranchName's
-    // as-is else-branch maps the new basename <suffix> → wt-<suffix> (== old).
-    //
-    // gh#864: if <wtBranch> already exists here it is MERGED (the loop bumped
-    // past any unmerged ref), so ADOPT it — `git worktree add <path> <branch>`
-    // (no -b) attaches the merged branch instead of failing on a create-
-    // collision. A fresh suffix has no ref → create it at startRef with -b.
-    const wt = localBranchExists(deps.runSync, projectRoot, wtBranch)
-      ? deps.runSync('git', ['worktree', 'add', candidate, wtBranch], projectRoot)
-      : deps.runSync('git', ['worktree', 'add', '-b', wtBranch, candidate, startRef], projectRoot);
+    let wt: ReturnType<AssimilateDeps['runSync']>;
+    let residualBranch: string | null = null;
+    while (true) {
+      // gh#556 Part 1: create the intermediate ~/.borg/worktrees/<repo>/ before
+      // `git worktree add` (git creates the leaf, not the parent chain). Plain
+      // recursive mkdir — NO chmod of the existing ~/.borg (credentials file).
+      deps.mkdirp(dirname(candidate));
+      const branchExisted = localBranchExists(deps.runSync, projectRoot, wtBranch);
+      wt = branchExisted
+        ? deps.runSync('git', ['worktree', 'add', candidate, wtBranch], projectRoot)
+        : deps.runSync('git', ['worktree', 'add', '-b', wtBranch, candidate, startRef], projectRoot);
+      if (wt.status === 0) break;
+
+      // Another assimilate may claim the name or branch after our first list.
+      // Refresh and suffix-bump instead of surfacing a collision to the operator.
+      const refreshed = listRegisteredWorktrees(deps, projectRoot);
+      const branchAppeared = !branchExisted && localBranchExists(deps.runSync, projectRoot, wtBranch);
+      const collision =
+        deps.pathExists(candidate) ||
+        refreshed?.names.has(basename(candidate)) === true ||
+        refreshed?.branches.has(wtBranch) === true ||
+        (!branchExisted && worktreeAddReportedCollision(wt.stderr));
+      if (!collision || refreshed === null) {
+        if (branchAppeared && refreshed?.branches.has(wtBranch) !== true) {
+          residualBranch = wtBranch;
+        }
+        break;
+      }
+      registeredWorktrees = refreshed;
+      do {
+        candidate = computeWorktreePath(homeDir, repoBase, suffix, n);
+        wtBranch = perWorktreeBranchName(basename(candidate), repoBase);
+        n++;
+      } while (
+        deps.pathExists(candidate) ||
+        registeredWorktrees.names.has(basename(candidate)) ||
+        registeredWorktrees.branches.has(wtBranch) ||
+        localBranchExists(deps.runSync, projectRoot, wtBranch)
+      );
+    }
     if (wt.status !== 0) {
-      deps.stderr(`git worktree add failed: ${safeStderr(wt.stderr)}\n`);
+      deps.stderr(
+        `Borg could not create sibling worktree ${candidate} on branch ${wtBranch}. ` +
+        `Git reported: ${safeStderr(wt.stderr)}\n` +
+        (residualBranch
+          ? `Git left branch ${residualBranch} without a registered worktree; Borg preserved it.\n`
+          : '') +
+        'Run `git worktree list` and `git status` to inspect repository state, resolve the reported Git error, then rerun `borg assimilate`.\n' +
+        'A seat was reserved and remains pending; rerunning after fixing the worktree issue resumes that seat.\n',
+      );
       return 1;
     }
     deps.stderr(
@@ -1958,10 +2012,24 @@ export function safeStderr(msg: string): string {
   return msg.replace(/[\x00-\x1F\x7F]/g, '');
 }
 
-function worktreeRegistered(deps: AssimilateDeps, projectRoot: string, candidate: string): boolean {
+function worktreeAddReportedCollision(stderr: string): boolean {
+  const message = safeStderr(stderr);
+  return /(?:branch named .* already exists|already checked out|already registered|already exists at)/i.test(message);
+}
+
+function listRegisteredWorktrees(
+  deps: AssimilateDeps,
+  projectRoot: string,
+): { names: Set<string>; branches: Set<string> } | null {
   const res = deps.runSync('git', ['worktree', 'list', '--porcelain'], projectRoot);
-  if (res.status !== 0) return false;
-  return res.stdout.split('\n').some((line) => line === `worktree ${candidate}`);
+  if (res.status !== 0) return null;
+  const names = new Set<string>();
+  const branches = new Set<string>();
+  for (const line of res.stdout.split('\n')) {
+    if (line.startsWith('worktree ')) names.add(basename(line.slice('worktree '.length)));
+    if (line.startsWith('branch refs/heads/')) branches.add(line.slice('branch refs/heads/'.length));
+  }
+  return { names, branches };
 }
 
 /**

package/src/claude.ts

@@ -28,7 +28,7 @@ import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget,
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
 import { formatSeatReattachRefusal, inspectLiveInboxMonitor } from './seat-reattach-guard.js';
 import { handleVersionFlag, getPackageVersion } from './version.js';
-import { isHelpFlag, setupHelpText, topLevelHelpText, assimilateHelpText, resetLocalSeatHelpText } from './cli-help.js';
+import { clientSubcommandHelpText, topLevelHelpText } from './cli-help.js';
 import { runSpawn } from './spawn.js';
 import { buildClaudeLaunchArgs } from './claude-launch-args.js';
 import { parseSyncArgs, runSync } from './sync.js';
@@ -142,31 +142,26 @@ async function main() {
     process.exit(0);
   }
 
+  const subcommandHelp = clientSubcommandHelpText(
+    process.argv[2],
+    process.argv.slice(3),
+    getPackageVersion(),
+  );
+  if (subcommandHelp !== null) {
+    process.stdout.write(subcommandHelp);
+    process.exit(0);
+  }
+
   // Re-route subcommands.
   if (process.argv[2] === 'setup') {
-    // gh#520: `borg setup --help` must show help, not run the wizard.
-    if (isHelpFlag(process.argv[3])) {
-      process.stdout.write(setupHelpText(getPackageVersion()));
-      process.exit(0);
-    }
     await import('./setup.js');
     return;
   }
   if (process.argv[2] === 'assimilate') {
-    // `borg assimilate --help` (or `... <role> --help`) must show help, not be
-    // rejected by the parser as an unknown flag.
-    if (process.argv.slice(3).some(isHelpFlag)) {
-      process.stdout.write(assimilateHelpText(getPackageVersion()));
-      process.exit(0);
-    }
     const code = await runAssimilateEntry(process.argv.slice(3));
     process.exit(code);
   }
   if (process.argv[2] === 'reset-local-seat') {
-    if (process.argv.slice(3).some(isHelpFlag)) {
-      process.stdout.write(resetLocalSeatHelpText(getPackageVersion()));
-      process.exit(0);
-    }
     const parsed = parseResetLocalSeatArgs(process.argv.slice(3));
     if (!parsed.ok) {
       process.stderr.write(

package/src/cli-help.ts

@@ -16,6 +16,70 @@ export function isHelpFlag(arg: string | undefined): boolean {
   return arg === '--help' || arg === '-h';
 }
 
+export function syncHelpText(version: string): string {
+  return (
+    `borg sync (borgmcp ${version}) — update this Borg worktree from origin/main\n\n` +
+    `Usage:\n` +
+    `  borg sync             Update safely; refuse if the worktree is dirty\n` +
+    `  borg sync --prune     Also delete a merged local feature branch\n` +
+    `  borg sync --help      Show this help\n`
+  );
+}
+
+export function cleanupHelpText(version: string): string {
+  return (
+    `borg cleanup (borgmcp ${version}) — review orphaned Borg-managed worktrees\n\n` +
+    `Usage:\n` +
+    `  borg cleanup          Report what is safe to remove; change nothing\n` +
+    `  borg cleanup --prune  Remove only worktrees proven safe to prune\n` +
+    `  borg cleanup --help   Show this help\n`
+  );
+}
+
+export function launchAllHelpText(version: string): string {
+  return (
+    `borg launch-all (borgmcp ${version}) — launch a cube's saved drone worktrees\n\n` +
+    `Usage:\n` +
+    `  borg launch-all [cube] [options]\n\n` +
+    `Options:\n` +
+    `  --mode <tmux|windows|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` +
+    `  --launch-delay <ms>                   Wait between launches\n` +
+    `  --help, -h                            Show this help\n`
+  );
+}
+
+export function clientSubcommandHelpText(
+  command: string | undefined,
+  args: readonly string[],
+  version: string,
+): string | null {
+  if (!args.some(isHelpFlag)) return null;
+  switch (command) {
+    case 'setup': return setupHelpText(version);
+    case 'assimilate': return assimilateHelpText(version);
+    case 'reset-local-seat': return resetLocalSeatHelpText(version);
+    case 'sync': return syncHelpText(version);
+    case 'cleanup': return cleanupHelpText(version);
+    case 'launch-all': return launchAllHelpText(version);
+    default: return null;
+  }
+}
+
+export function setupNextStepsText(): string {
+  return (
+    `◼ Next steps:\n` +
+    `1. Run \`borg server setup\` to prepare the local server.\n` +
+    `2. Run \`borg server start\` and leave that terminal open.\n` +
+    `3. In a second terminal, cd into your project and run \`borg assimilate\`.\n`
+  );
+}
+
 /**
  * Help text for top-level `borg --help`.
  *
@@ -130,7 +194,7 @@ export function assimilateHelpText(version: string): string {
     `  --enroll                   Prompt for a hidden enrollment invitation in the operator terminal\n` +
     `  --template ${NEW_CUBE_TEMPLATE_OPTIONS}   New-cube template (default: ${DEFAULT_NEW_CUBE_TEMPLATE})\n` +
     `  --no-template              Unsupported for repository cube creation\n` +
-    `  --cli claude|codex|opencode         Agent CLI to launch (default: claude)\n` +
+    `  --cli claude|codex|opencode         Agent CLI to launch\n` +
     `  --model claude:<model>   Legacy Claude model override (configure models in the agent CLI)\n` +
     `  --yes, -y                  Accept new-cube defaults; never adopt by name\n\n` +
     `Creation shows repository context, name, template, and one confirmation. An existing\n` +

package/src/cubes.ts

@@ -72,6 +72,8 @@ export interface ActiveCube {
   roleName?: string;
   roleClass?: 'queen' | 'worker';
   isHumanSeat?: boolean;
+  /** Canonical worktree bound to this exact durable seat. */
+  worktree?: string;
 }
 
 export type ActiveCubeInput = Omit<ActiveCube, 'sessionToken'> & {
@@ -97,7 +99,53 @@ interface CodexWakeTargetsFile {
  * directory. If not found by filesystem root, return the original cwd.
  * The returned absolute path is the "project key" used to scope cube state.
  */
-export function findProjectRoot(cwd: string = process.cwd()): string {
+let pinnedMcpProjectRoot: string | null = null;
+let pinnedMcpSeatIdentity: {
+  worktree: string;
+  cubeId: string;
+  droneId: string;
+  credentialRef?: string;
+} | null = null;
+
+export class McpSeatIdentityChangedError extends Error {
+  readonly code = 'SEAT_IDENTITY_CHANGED';
+  constructor() {
+    super('The saved Borg seat changed after this MCP session pinned its identity. Exit this session and relaunch from the intended worktree.');
+    this.name = 'McpSeatIdentityChangedError';
+  }
+}
+
+export function pinMcpProjectRoot(worktree: string): void {
+  const normalized = resolve(worktree);
+  if (pinnedMcpProjectRoot !== null && pinnedMcpProjectRoot !== normalized) {
+    throw new Error(`Borg MCP session project root is already pinned to ${pinnedMcpProjectRoot}`);
+  }
+  pinnedMcpProjectRoot = normalized;
+}
+
+export function pinMcpSeatIdentity(active: ActiveCube): void {
+  if (!active.worktree) throw new McpSeatIdentityChangedError();
+  pinMcpProjectRoot(active.worktree);
+  const next = {
+    worktree: resolve(active.worktree),
+    cubeId: active.cubeId,
+    droneId: active.droneId,
+    ...(active.localSessionCredentialRef
+      ? { credentialRef: active.localSessionCredentialRef }
+      : {}),
+  };
+  if (pinnedMcpSeatIdentity && (
+    pinnedMcpSeatIdentity.worktree !== next.worktree ||
+    pinnedMcpSeatIdentity.cubeId !== next.cubeId ||
+    pinnedMcpSeatIdentity.droneId !== next.droneId ||
+    pinnedMcpSeatIdentity.credentialRef !== next.credentialRef
+  )) {
+    throw new McpSeatIdentityChangedError();
+  }
+  pinnedMcpSeatIdentity = next;
+}
+
+export function findProjectRoot(cwd: string = pinnedMcpProjectRoot ?? process.cwd()): string {
   let dir = resolve(cwd);
   while (true) {
     if (existsSync(join(dir, '.git'))) return dir;
@@ -244,9 +292,22 @@ async function writeCodexWakeTargetsFile(data: CodexWakeTargetsFile): Promise<vo
  * refresh.
  */
 export async function getActiveCube(): Promise<ActiveCube | null> {
-  const record = await getActiveSeatForWorktree(findProjectRoot());
+  return getActiveCubeForWorktree(findProjectRoot());
+}
+
+export async function getActiveCubeForWorktree(worktree: string): Promise<ActiveCube | null> {
+  const record = await getActiveSeatForWorktree(findProjectRoot(worktree));
   if (!record || !record.cubeId || !record.droneId) return null;
-  return hydrateActiveCube(record);
+  const active = await hydrateActiveCube(record);
+  if (active && pinnedMcpSeatIdentity && (
+    resolve(active.worktree ?? '') !== pinnedMcpSeatIdentity.worktree ||
+    active.cubeId !== pinnedMcpSeatIdentity.cubeId ||
+    active.droneId !== pinnedMcpSeatIdentity.droneId ||
+    active.localSessionCredentialRef !== pinnedMcpSeatIdentity.credentialRef
+  )) {
+    throw new McpSeatIdentityChangedError();
+  }
+  return active;
 }
 
 /**
@@ -282,12 +343,18 @@ async function hydrateActiveCube(record: SeatRecord): Promise<ActiveCube | null>
     serverTrustIdentity: record.trustIdentity,
     localSessionCredentialRef: ref,
     operation: record.operation,
+    worktree: record.worktree,
     ...(record.roleName !== undefined ? { roleName: record.roleName } : {}),
     ...(record.roleClass !== undefined ? { roleClass: record.roleClass } : {}),
     ...(record.isHumanSeat !== undefined ? { isHumanSeat: record.isHumanSeat } : {}),
   };
 }
 
+export function __resetPinnedMcpProjectRootForTests(): void {
+  pinnedMcpProjectRoot = null;
+  pinnedMcpSeatIdentity = null;
+}
+
 /**
  * Token-free lookup used after an offline reset. A surviving seat is only
  * described as saved local state; the caller must still revalidate it with the

package/src/index.ts

@@ -64,9 +64,11 @@ import {
 import {
   activeCubeWithFreshRegenIdentity,
   getActiveCube,
+  getActiveCubeForWorktree,
   refreshActiveCubeMetadata,
   findProjectRoot,
   inboxPathForDrone,
+  pinMcpSeatIdentity,
 } from './cubes.js';
 import { isEntryInvocation, monitorStateRootForWorktree } from './inbox-monitor.js';
 import { addSessionStartHook, addUserPromptSubmitHook } from './config-utils.js';
@@ -140,6 +142,11 @@ import {
   normalizeDirectLogRecipients,
 } from './direct-log.js';
 import { formatLocalManageToolResult } from './local-manage-tool-result.js';
+import {
+  OpenCodeSeatIdentityError,
+  formatOpenCodeSeatIdentityError,
+  resolveOpenCodeSeatIdentity,
+} from './opencode-seat-identity.js';
 import {
   runEvictDroneTool,
   runReassignDroneTool,
@@ -216,8 +223,8 @@ export async function main() {
   // installed client version.
   handleVersionFlag();
   const readinessProbe = isMcpReadinessProbe();
-
-  await runMcpStartupServices(readinessProbe, {
+  const openCodeRuntime = resolveSessionAgentKind() === 'opencode';
+  const startupServices = {
     // Auto-register the SessionStart hook so existing users get borg-regen
     // auto-orientation on session start without re-running borg setup. Idempotent.
     sessionStartHook: () => {
@@ -255,19 +262,22 @@ export async function main() {
     openCode: async () => {
       installBorgPlugin();
       const active = await getActiveCube();
-      if (active && process.env.BORG_OPENCODE === '1') {
+      if (active && openCodeRuntime) {
         const port = computeOpenCodePort(active.droneId);
         const serverUrl = `http://127.0.0.1:${port}`;
         await connectOpenCodeDrone({
           serverUrl,
-          directory: process.cwd(),
+          directory: active.worktree ?? findProjectRoot(),
           droneLabel: active.droneLabel,
           cubeName: active.name,
         });
         setModuleInjectOpenCode(injectOpenCodeEntry);
       }
     },
-  });
+  };
+  // Claude and Codex retain their existing pre-handshake startup behavior.
+  // OpenCode must first obtain the session-scoped MCP root from its client.
+  if (!openCodeRuntime) await runMcpStartupServices(readinessProbe, startupServices);
 
   // Create MCP server. `version` is the installed borgmcp version
   // (T1.4 of 0.6.0): read at runtime from package.json so Claude
@@ -286,6 +296,16 @@ export async function main() {
     }
   );
 
+  let openCodeIdentityFailure: OpenCodeSeatIdentityError | null = null;
+  let finishOpenCodeIdentity: (() => void) | null = null;
+  const openCodeIdentityReady = openCodeRuntime && !readinessProbe
+    ? new Promise<void>((resolveIdentity) => { finishOpenCodeIdentity = resolveIdentity; })
+    : null;
+  const waitForOpenCodeIdentity = async (): Promise<OpenCodeSeatIdentityError | null> => {
+    if (openCodeIdentityReady) await openCodeIdentityReady;
+    return openCodeIdentityFailure;
+  };
+
   // gh#899: tool definitions built once at setup, then role-scoped per caller
   // in the ListTools handler below (the dispatcher reaches deferred tools).
   const allToolDefs: ToolManifestEntry[] = TOOL_MANIFEST;
@@ -294,6 +314,7 @@ export async function main() {
   // (old cubes.json / pre-assimilate) → full set; deferred tools stay reachable
   // via borg_tool. Never an auth boundary — live per-client cube grants govern.
   server.setRequestHandler(ListToolsRequestSchema, async () => {
+    await waitForOpenCodeIdentity();
     let scope: { roleName?: string; roleClass?: 'queen' | 'worker'; isHumanSeat?: boolean } | null = null;
     try {
       const active = await getActiveCube();
@@ -310,6 +331,17 @@ export async function main() {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     let { name, arguments: args } = request.params;
 
+    const identityFailure = await waitForOpenCodeIdentity();
+    if (identityFailure) {
+      return {
+        content: [{
+          type: 'text',
+          text: formatOpenCodeSeatIdentityError(identityFailure, process.cwd()),
+        }],
+        isError: true,
+      };
+    }
+
     // gh#899: borg_describe-tool — schema-only, NEVER executes. Returns the
     // named tool's def from allToolDefs so a role-scoped session can learn a
     // deferred tool's arguments before invoking it via borg_tool.
@@ -386,7 +418,7 @@ export async function main() {
               since,
               reportedModel,
               agentKind: resolveReportableSessionAgentKind(),
-              workingRepo: resolveWorkingRepo(),
+              workingRepo: resolveWorkingRepo(active.worktree),
               serverTrustIdentity: active.serverTrustIdentity,
             });
           } catch (error) {
@@ -467,7 +499,7 @@ export async function main() {
             seedDisplayIdentity(active!);
             const result = await regen(active!.sessionToken, active!.apiUrl, {
               agentKind: resolveReportableSessionAgentKind(),
-              workingRepo: resolveWorkingRepo(),
+              workingRepo: resolveWorkingRepo(active!.worktree),
               serverTrustIdentity: active!.serverTrustIdentity,
             });
             const displayIdentity = confirmDisplayIdentity(active!, identityFromRegen(result));
@@ -1259,9 +1291,36 @@ export async function main() {
   // Create stdio transport
   const transport = new StdioServerTransport();
 
+  if (openCodeIdentityReady) {
+    server.oninitialized = () => {
+      void resolveOpenCodeSeatIdentity({
+        listRoots: () => server.listRoots(),
+        findProjectRoot,
+        getActiveCubeForWorktree,
+        pinSeatIdentity: pinMcpSeatIdentity,
+        childCwd: process.cwd(),
+      }).catch((error) => {
+        openCodeIdentityFailure = error instanceof OpenCodeSeatIdentityError
+          ? error
+          : new OpenCodeSeatIdentityError('ROOTS_UNAVAILABLE', String(error));
+      }).finally(() => {
+        finishOpenCodeIdentity?.();
+      });
+    };
+  }
+
   // Connect server to transport
   await server.connect(transport);
 
+  if (openCodeIdentityReady) {
+    await openCodeIdentityReady;
+    if (openCodeIdentityFailure) {
+      console.error(formatOpenCodeSeatIdentityError(openCodeIdentityFailure, process.cwd()));
+    } else {
+      await runMcpStartupServices(false, startupServices, { openCodeFirst: true });
+    }
+  }
+
   // Resolve drone self-identification prefix before any console output
   // (gh#25). Falls back to `[unassimilated · <repo>]` if no cube cached.
   await initConsolePrefix();

package/src/log-stream.ts

@@ -496,7 +496,12 @@ async function runLoop(testDeps: RunLoopTestDeps = {}): Promise<void> {
         active.cubeId,
         active.droneId,
         STREAM_OWNER_STALE_MS,
-        { isPidAlive: isProcessAlive },
+        {
+          isPidAlive: isProcessAlive,
+          ...(active.worktree ? { worktree: active.worktree } : {}),
+          ...(active.droneLabel ? { droneLabel: active.droneLabel } : {}),
+          ...(active.name ? { cubeName: active.name } : {}),
+        },
       );
       leaseKey = lease ? nextLeaseKey : null;
     }
@@ -642,6 +647,9 @@ export interface ActiveCube {
   serverTrustIdentity?: string;
   localSessionCredentialRef?: string;
   localSessionExpiresAt?: string | null;
+  worktree?: string;
+  droneLabel?: string;
+  name?: string;
 }
 
 export async function streamOnce(