borgmcp 2.7.0 → 2.7.2

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(

package/src/opencode-seat-identity.ts

@@ -0,0 +1,111 @@
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+import type { ActiveCube } from './cubes.js';
+
+export type OpenCodeSeatIdentityErrorCode =
+  | 'ROOTS_UNAVAILABLE'
+  | 'ROOTS_INVALID'
+  | 'SEAT_NOT_FOUND'
+  | 'SEAT_WORKTREE_MISMATCH';
+
+export class OpenCodeSeatIdentityError extends Error {
+  constructor(
+    public readonly code: OpenCodeSeatIdentityErrorCode,
+    message: string,
+    public readonly sessionDirectory?: string,
+    public readonly seat?: Pick<ActiveCube, 'droneLabel' | 'worktree'>,
+  ) {
+    super(message);
+    this.name = 'OpenCodeSeatIdentityError';
+  }
+}
+
+export interface OpenCodeSeatIdentityDeps {
+  listRoots: () => Promise<{ roots?: Array<{ uri?: string }> }>;
+  findProjectRoot: (directory: string) => string;
+  getActiveCubeForWorktree: (worktree: string) => Promise<ActiveCube | null>;
+  pinSeatIdentity: (active: ActiveCube) => void;
+  childCwd: string;
+}
+
+export async function resolveOpenCodeSeatIdentity(
+  deps: OpenCodeSeatIdentityDeps,
+): Promise<ActiveCube> {
+  let roots: { roots?: Array<{ uri?: string }> };
+  try {
+    roots = await deps.listRoots();
+  } catch {
+    throw new OpenCodeSeatIdentityError(
+      'ROOTS_UNAVAILABLE',
+      'OpenCode did not provide its session directory.',
+    );
+  }
+  if (!Array.isArray(roots.roots) || roots.roots.length !== 1) {
+    throw new OpenCodeSeatIdentityError(
+      'ROOTS_INVALID',
+      'OpenCode must provide exactly one local session directory.',
+    );
+  }
+  const uri = roots.roots[0]?.uri;
+  let sessionDirectory: string;
+  try {
+    const parsed = new URL(typeof uri === 'string' ? uri : '');
+    if (parsed.protocol !== 'file:' || parsed.hostname || parsed.search || parsed.hash) throw new Error();
+    sessionDirectory = resolve(fileURLToPath(parsed));
+  } catch {
+    throw new OpenCodeSeatIdentityError(
+      'ROOTS_INVALID',
+      'OpenCode provided an invalid or non-local session directory.',
+    );
+  }
+
+  const sessionWorktree = deps.findProjectRoot(sessionDirectory);
+  const cwdWorktree = deps.findProjectRoot(deps.childCwd);
+  // Direct `borg` launch keeps cwd as its seat source. When a shared OpenCode
+  // server spawns the MCP child elsewhere, the session-scoped root is the
+  // launcher-conferred pin and replaces that ambient cwd inference.
+  const identityWorktree = cwdWorktree === sessionWorktree
+    ? cwdWorktree
+    : sessionWorktree;
+  const active = await deps.getActiveCubeForWorktree(identityWorktree);
+  if (!active) {
+    throw new OpenCodeSeatIdentityError(
+      'SEAT_NOT_FOUND',
+      'No active Borg seat is bound to the OpenCode session directory.',
+      sessionWorktree,
+    );
+  }
+  if (typeof active.worktree !== 'string' || resolve(active.worktree) !== resolve(sessionWorktree)) {
+    throw new OpenCodeSeatIdentityError(
+      'SEAT_WORKTREE_MISMATCH',
+      'The resolved Borg seat belongs to a different worktree than the OpenCode session.',
+      sessionWorktree,
+      active,
+    );
+  }
+
+  deps.pinSeatIdentity(active);
+  return active;
+}
+
+export function formatOpenCodeSeatIdentityError(
+  error: OpenCodeSeatIdentityError,
+  childCwd: string,
+): string {
+  const lines = [
+    `Borg OpenCode seat identity error [${error.code}]`,
+    '',
+    error.message,
+    `- OpenCode session directory: ${error.sessionDirectory ?? 'unavailable'}`,
+    `- Borg MCP child cwd: ${childCwd}`,
+  ];
+  if (error.seat) {
+    lines.push(`- Resolved seat: ${error.seat.droneLabel} (${error.seat.worktree})`);
+  }
+  lines.push(
+    '',
+    'The Borg stream and OpenCode wake injection were not started.',
+    'Exit this session and run `borg --cli opencode` from the intended worktree. If that worktree’s saved seat is stale, run `borg reset-local-seat` from that exact worktree before assimilating again.',
+  );
+  return lines.join('\n');
+}

package/src/repository-cube-init.ts

@@ -33,6 +33,17 @@ export interface RepositoryCubeCreation {
   cube: RepositoryCubeDetail;
 }
 
+type NewCubeTemplate = Exclude<CubeTemplate, 'default'>;
+
+const NEW_CUBE_TEMPLATE_NAMES: readonly NewCubeTemplate[] =
+  NEW_CUBE_TEMPLATE_PRESENTATIONS.map(({ name }) => name);
+const NEW_CUBE_TEMPLATE_OPTIONS = NEW_CUBE_TEMPLATE_NAMES.join('|');
+const NEW_CUBE_TEMPLATE_LIST = NEW_CUBE_TEMPLATE_NAMES.join(', ');
+
+function parseNewCubeTemplate(value: string): NewCubeTemplate | undefined {
+  return NEW_CUBE_TEMPLATE_PRESENTATIONS.find(({ name }) => name === value)?.name;
+}
+
 export type RepositoryCubeResolution = ResolveRepositoryCubeResponse;
 
 export interface RepositoryCubeInitFlags {
@@ -63,7 +74,7 @@ export interface RepositoryCubeInitDeps {
     name: string;
     workingRepoName: string;
     repository: CreateCubeRepository;
-    template: Exclude<CubeTemplate, 'default'>;
+    template: NewCubeTemplate;
   }): Promise<RepositoryCubeCreation>;
 }
 
@@ -332,16 +343,19 @@ export async function initializeRepositoryCube(input: {
   }
 
   if (input.flags.noTemplate) {
-    deps.write('--no-template is not supported for repository cube creation. Use --template software-dev or --template starter.\n');
+    deps.write(`--no-template is not supported for repository cube creation. Use --template ${NEW_CUBE_TEMPLATE_OPTIONS}.\n`);
     return { kind: 'stop', code: 1 };
   }
-  if (input.flags.template !== undefined && input.flags.template !== 'software-dev' && input.flags.template !== 'starter') {
+  const requestedTemplate = input.flags.template === undefined
+    ? undefined
+    : parseNewCubeTemplate(input.flags.template);
+  if (input.flags.template !== undefined && requestedTemplate === undefined) {
     const safe = input.flags.template.replace(/[\u0000-\u001f\u007f]/g, '?').slice(0, 120);
-    deps.write(`Unknown template '${safe}'. Use software-dev or starter.\n`);
+    deps.write(`Unknown template '${safe}'. Available templates: ${NEW_CUBE_TEMPLATE_LIST}.\n`);
     return { kind: 'stop', code: 1 };
   }
   if (!deps.isTTY() && !input.flags.yes && (!input.flags.cubeName || !input.flags.template)) {
-    deps.write('Non-interactive cube creation requires --cube-name <name> and --template software-dev|starter, or --yes to use repository defaults.\n');
+    deps.write(`Non-interactive cube creation requires --cube-name <name> and --template ${NEW_CUBE_TEMPLATE_OPTIONS}, or --yes to use repository defaults.\n`);
     return { kind: 'stop', code: 1 };
   }
 
@@ -370,7 +384,7 @@ export async function initializeRepositoryCube(input: {
     if (editedNameAdoption) return editedNameAdoption;
   }
 
-  let template = input.flags.template as 'software-dev' | 'starter' | undefined;
+  let template = requestedTemplate;
   if (!template && deps.isTTY() && !input.flags.yes) {
     let menu = 'Choose a template:\n';
     for (let i = 0; i < NEW_CUBE_TEMPLATE_PRESENTATIONS.length; i += 1) {
@@ -384,12 +398,15 @@ export async function initializeRepositoryCube(input: {
       const answer = await ask(deps, 'Template [1]: ');
       if ('stop' in answer) return { kind: 'stop', code: answer.stop };
       const selected = answer.value.trim();
-      if (selected === '' || selected === '1') template = 'software-dev';
-      else if (selected === '2') template = 'starter';
-      else deps.write('Choose 1 or 2.\n');
+      const selectedIndex = selected === ''
+        ? 0
+        : /^[1-9]\d*$/.test(selected) ? Number(selected) - 1 : -1;
+      const selectedPresentation = NEW_CUBE_TEMPLATE_PRESENTATIONS[selectedIndex];
+      if (selectedPresentation) template = selectedPresentation.name;
+      else deps.write(`Choose 1-${NEW_CUBE_TEMPLATE_PRESENTATIONS.length}.\n`);
     }
   }
-  template ??= 'software-dev';
+  template ??= NEW_CUBE_TEMPLATE_PRESENTATIONS[0].name;
 
   if (deps.isTTY() && !input.flags.yes) {
     let confirmed = false;

package/src/repository-identity.ts

@@ -2,7 +2,7 @@ import { createHmac, randomBytes, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { basename, isAbsolute, join } from 'node:path';
 import { realpath } from 'node:fs/promises';
-import type { CreateCubeRepository, CubeTemplate } from 'borgmcp-shared/protocol';
+import { CUBE_TEMPLATES, type CreateCubeRepository, type CubeTemplate } from 'borgmcp-shared/protocol';
 import { canonicalizeWorkingRepoIdentity } from './working-repo.js';
 import { normalizeCubeName } from './cube-name.js';
 import { borgConfigRoot, ensurePrivateBorgConfigRoot } from './private-root.js';
@@ -118,7 +118,7 @@ function parseState(raw: string | null): RepositoryIdentityState {
       !DISPLAY_NAME_RE.test(value.name) ||
       typeof value.workingRepoName !== 'string' || Buffer.byteLength(value.workingRepoName, 'utf8') > 120 ||
       !DISPLAY_NAME_RE.test(value.workingRepoName) ||
-      (value.template !== 'software-dev' && value.template !== 'starter' && value.template !== 'default')
+      !CUBE_TEMPLATES.some((template) => template === value.template)
     ) {
       throw new Error('Borg repository identity store is malformed or unsupported');
     }

package/src/startup-services.ts

@@ -16,10 +16,16 @@ export interface McpStartupServices {
  */
 export async function runMcpStartupServices(
   readinessProbe: boolean,
-  services: McpStartupServices
+  services: McpStartupServices,
+  options: { openCodeFirst?: boolean } = {},
 ): Promise<void> {
   if (readinessProbe) return;
-  const tasks = [
+  const tasks = options.openCodeFirst ? [
+    services.sessionStartHook,
+    services.auditHook,
+    services.openCode,
+    services.sseStream,
+  ] : [
     services.sessionStartHook,
     services.auditHook,
     services.sseStream,

package/src/stream-owner.ts

@@ -24,6 +24,9 @@ export interface StreamOwnerRecord {
   cwd: string;
   startedAt: string;
   heartbeatAt: string;
+  worktree?: string;
+  droneLabel?: string;
+  cubeName?: string;
 }
 
 export interface StreamOwnershipSnapshot {
@@ -33,6 +36,9 @@ export interface StreamOwnershipSnapshot {
   cwd?: string;
   startedAt?: string;
   heartbeatAt?: string;
+  worktree?: string;
+  droneLabel?: string;
+  cubeName?: string;
   ageMs?: number;
   lockPath?: string;
   /** Opened-directory identity used to bind inspection to later takeover. */
@@ -54,6 +60,9 @@ export interface StreamOwnerDeps {
   locksDir?: string;
   processNonce?: string;
   processStartedAt?: string;
+  worktree?: string;
+  droneLabel?: string;
+  cubeName?: string;
   isPidAlive?: (pid: number) => boolean;
   beforeTakeoverVerify?: (takeoverPath: string) => Promise<void>;
   beforeLeaseRefreshMutation?: (lockPath: string) => Promise<void>;
@@ -177,6 +186,9 @@ export async function readOwnershipSnapshot(
     cwd: parsed.cwd,
     startedAt: parsed.startedAt,
     heartbeatAt: parsed.heartbeatAt,
+    worktree: parsed.worktree,
+    droneLabel: parsed.droneLabel,
+    cubeName: parsed.cubeName,
     ageMs,
     lockPath,
     lockDev: lockStat.dev,
@@ -572,7 +584,10 @@ function sameOwner(left: StreamOwnerRecord, right: StreamOwnerRecord): boolean {
     left.processNonce === right.processNonce &&
     left.cwd === right.cwd &&
     left.startedAt === right.startedAt &&
-    left.heartbeatAt === right.heartbeatAt;
+    left.heartbeatAt === right.heartbeatAt &&
+    left.worktree === right.worktree &&
+    left.droneLabel === right.droneLabel &&
+    left.cubeName === right.cubeName;
 }
 
 async function readOwnershipRecord(lockPath: string): Promise<StreamOwnerRecord | null> {
@@ -655,6 +670,9 @@ function makeRecord(deps: StreamOwnerDeps): StreamOwnerRecord {
     cwd: deps.cwd ?? process.cwd(),
     startedAt: deps.processStartedAt ?? processStartedAt,
     heartbeatAt: now().toISOString(),
+    ...(deps.worktree ? { worktree: deps.worktree } : {}),
+    ...(deps.droneLabel ? { droneLabel: deps.droneLabel } : {}),
+    ...(deps.cubeName ? { cubeName: deps.cubeName } : {}),
   };
 }
 
@@ -668,7 +686,10 @@ function isRecord(value: any): value is StreamOwnerRecord {
     isSafeLeaseText(value.processNonce, 128) &&
     isSafeLeaseText(value.cwd, 4096) &&
     isIsoTimestamp(value.startedAt) &&
-    isIsoTimestamp(value.heartbeatAt)
+    isIsoTimestamp(value.heartbeatAt) &&
+    (value.worktree === undefined || isSafeLeaseText(value.worktree, 4096)) &&
+    (value.droneLabel === undefined || isSafeLeaseText(value.droneLabel, 256)) &&
+    (value.cubeName === undefined || isSafeLeaseText(value.cubeName, 256))
   );
 }
 

package/src/stream-status.ts

@@ -161,7 +161,10 @@ export function renderStreamStatus(inputs: RenderInputs): string {
   if (orphanedInitialization) {
     summary = '**Stream blocked by an orphaned initialization lock.**';
   } else if (ownedByOther) {
-    summary = '**Stream owned by another Borg MCP process.**';
+    const owner = status.ownership!;
+    summary = owner.droneLabel && owner.worktree
+      ? `**Stream owned by seat ${owner.droneLabel} in \`${owner.worktree}\`.**`
+      : '**Stream owned by another Borg MCP process.**';
   } else if (isNotStarted) {
     summary = '**Stream not started.**';
   } else if (!status.connected) {
@@ -245,6 +248,8 @@ export function renderStreamStatus(inputs: RenderInputs): string {
 
   if (ownedByOther) {
     const owner = status.ownership!;
+    lines.push(`- **stream owner seat**: ${owner.droneLabel ?? '_(unknown)_'}`);
+    lines.push(`- **stream owner worktree**: ${owner.worktree ?? '_(unknown)_'}`);
     lines.push(`- **stream owner pid**: ${owner.pid ?? '_(unknown)_'}`);
     lines.push(`- **stream owner cwd**: ${owner.cwd ?? '_(unknown)_'}`);
     lines.push(
@@ -254,6 +259,8 @@ export function renderStreamStatus(inputs: RenderInputs): string {
           : '_(unknown)_'
       }`
     );
+    lines.push('');
+    lines.push('Continue in the owning seat, or close its duplicate agent session before relaunching from the intended worktree. The live owner releases this lock on exit; a stale lock is reclaimed automatically.');
   }
 
   if (wakePath.agentKind === 'opencode' && wakePath.openCode) {