borgmcp 4.5.1 → 4.6.1

package/src/opencode-drone.ts

@@ -44,7 +44,7 @@ const OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES = 64 * 1024;
 const diagnosticLogPathsForTests = new Set<string>();
 
 function stateIdentityDigest(current: OpenCodeDroneState): string {
-  const key = [current.serverUrl, current.directory, current.cubeName, current.droneLabel].join('\0');
+  const key = [current.directory, current.cubeName, current.droneLabel].join('\0');
   return createHash('sha256').update(key).digest('hex').slice(0, 24);
 }
 
@@ -211,8 +211,6 @@ interface OCSession {
   directory: string;
   time: { created: number };
   parentID?: string;
-  agent?: string;
-  model?: { providerID: string; modelID: string };
 }
 
 interface OCMessage {
@@ -461,12 +459,6 @@ function decodeSession(value: unknown): OCSession {
     || typeof value.time.created !== 'number'
     || !Number.isFinite(value.time.created)
     || (value.parentID !== undefined && typeof value.parentID !== 'string')
-    || (value.agent !== undefined && typeof value.agent !== 'string')
-    || (value.model !== undefined && (
-      !isRecord(value.model)
-      || typeof value.model.providerID !== 'string'
-      || typeof value.model.modelID !== 'string'
-    ))
   ) {
     throw new OpenCodeResponseError();
   }
@@ -562,7 +554,6 @@ function bindingPath(): string {
 function bindingMatchesState(binding: SessionBinding): boolean {
   const current = state!;
   return binding.version === 4
-    && binding.serverUrl === current.serverUrl
     && binding.directory === current.directory
     && binding.droneLabel === current.droneLabel
     && binding.cubeName === current.cubeName
@@ -747,35 +738,126 @@ function launchCorrelationMatchCount(messages: OCMessage[], correlationIdentity:
  * therefore allowed only when it received this launch's correlation metadata.
  */
 async function findLaunchSession(correlationIdentity: string): Promise<{
+  kind: 'found';
   session: OCSession;
   knownRootSessionIds: string[];
-} | null> {
+} | {
+  kind: 'superseded';
+} | {
+  kind: 'list-failed';
+  failureCode: string;
+  errorClass: string;
+  httpStatus: number | null;
+} | {
+  kind: 'directory-miss';
+  listedCount: number;
+  directoryCount: 0;
+} | {
+  kind: 'message-list-failed';
+  listedCount: number;
+  directoryCount: number;
+  failureCode: string;
+  errorClass: string;
+  httpStatus: number | null;
+} | {
+  kind: 'correlation-mismatch';
+  listedCount: number;
+  directoryCount: number;
+  matchCount: number;
+}> {
   const owner = state!;
   const observationSequence = ++owner.nextObservationSequence;
+  let listedSessions: OCSession[];
   try {
-    const listedSessions = await listSessions();
-    if (state !== owner) return null;
-    const sessions = listedSessions.filter(
-      (session) => session.directory === owner.directory,
-    );
-    const knownRootSessionIds = sessions
-      .filter(isTopLevelSession)
-      .map((session) => session.id);
-    const candidates = await Promise.all(sessions.map(async (session) => ({
+    listedSessions = await listSessions();
+  } catch (error) {
+    if (state === owner) recordOpenCodeFailure(owner, error, observationSequence);
+    return { kind: 'list-failed', ...openCodeFailureDiagnostic(error) };
+  }
+  if (state !== owner) return { kind: 'superseded' };
+  const sessions = listedSessions.filter(
+    (session) => session.directory === owner.directory,
+  );
+  if (sessions.length === 0) {
+    return { kind: 'directory-miss', listedCount: listedSessions.length, directoryCount: 0 };
+  }
+  const knownRootSessionIds = sessions
+    .filter(isTopLevelSession)
+    .map((session) => session.id);
+  let candidates: Array<{ session: OCSession; matchCount: number }>;
+  try {
+    candidates = await Promise.all(sessions.map(async (session) => ({
       session,
       matchCount: launchCorrelationMatchCount(
         await listSessionMessages(session.id),
         correlationIdentity,
       ),
     })));
-    if (state !== owner) return null;
-    const totalMatches = candidates.reduce((total, candidate) => total + candidate.matchCount, 0);
-    if (totalMatches !== 1) return null;
-    const matched = candidates.find((candidate) => candidate.matchCount === 1);
-    return matched ? { session: matched.session, knownRootSessionIds } : null;
   } catch (error) {
     if (state === owner) recordOpenCodeFailure(owner, error, observationSequence);
-    return null;
+    return {
+      kind: 'message-list-failed',
+      listedCount: listedSessions.length,
+      directoryCount: sessions.length,
+      ...openCodeFailureDiagnostic(error),
+    };
+  }
+  if (state !== owner) return { kind: 'superseded' };
+  const totalMatches = candidates.reduce((total, candidate) => total + candidate.matchCount, 0);
+  if (totalMatches !== 1) {
+    return {
+      kind: 'correlation-mismatch',
+      listedCount: listedSessions.length,
+      directoryCount: sessions.length,
+      matchCount: totalMatches,
+    };
+  }
+  const matched = candidates.find((candidate) => candidate.matchCount === 1)!;
+  return { kind: 'found', session: matched.session, knownRootSessionIds };
+}
+
+type LaunchSessionSearchFailure = Exclude<Awaited<ReturnType<typeof findLaunchSession>>, {
+  kind: 'found' | 'superseded';
+}>;
+
+function logLaunchSessionSearchFailure(
+  failure: LaunchSessionSearchFailure,
+  attempts: number,
+  owner: OpenCodeDroneState,
+): void {
+  switch (failure.kind) {
+    case 'list-failed':
+      log(
+        `kickoff: session search list-failed code=${failure.failureCode} `
+        + `class=${failure.errorClass} status=${failure.httpStatus ?? 'none'} `
+        + `listed=unknown directory=unknown matches=unknown attempts=${attempts}`,
+        owner,
+      );
+      break;
+    case 'directory-miss':
+      log(
+        `kickoff: session search directory-miss listed=${failure.listedCount} `
+        + `directory=${failure.directoryCount} matches=0 attempts=${attempts}`,
+        owner,
+      );
+      break;
+    case 'message-list-failed':
+      log(
+        `kickoff: session search messages-failed code=${failure.failureCode} `
+        + `class=${failure.errorClass} status=${failure.httpStatus ?? 'none'} `
+        + `listed=${failure.listedCount} directory=${failure.directoryCount} `
+        + `matches=unknown attempts=${attempts}`,
+        owner,
+      );
+      break;
+    case 'correlation-mismatch':
+      log(
+        `kickoff: session search correlation-mismatch listed=${failure.listedCount} `
+        + `directory=${failure.directoryCount} `
+        + `matches=${failure.matchCount} attempts=${attempts}`,
+        owner,
+      );
+      break;
   }
 }
 
@@ -836,6 +918,18 @@ function openCodeFailureCode(error: unknown): string {
   return error instanceof Error && error.name ? error.name : 'unknown';
 }
 
+function openCodeFailureDiagnostic(error: unknown): {
+  failureCode: string;
+  errorClass: string;
+  httpStatus: number | null;
+} {
+  return {
+    failureCode: openCodeFailureCode(error),
+    errorClass: error instanceof Error && error.name ? error.name : 'unknown',
+    httpStatus: error instanceof OpenCodeHttpError ? error.status : null,
+  };
+}
+
 function updateLastOpenCodeObservation(
   owner: OpenCodeDroneState,
   sequence: number,
@@ -1185,31 +1279,59 @@ export async function injectInitialKickoff(launch: OpenCodeLaunchKickoff): Promi
 
   try {
     // Wait for the server.
+    let serverReady = false;
+    let lastServerError: unknown;
     for (let i = 0; i < 30; i++) {
       try {
         await listSessions();
+        if (state !== owner) return false;
+        serverReady = true;
         log(`kickoff: server ready (attempt ${i + 1})`, owner);
         break;
-      } catch {
-        // not ready yet
+      } catch (error) {
+        if (state !== owner) return false;
+        lastServerError = error;
       }
-      await new Promise((r) => setTimeout(r, 1000));
+      if (i < 29) await new Promise((r) => setTimeout(r, 1000));
+    }
+    if (!serverReady) {
+      const observationSequence = ++owner.nextObservationSequence;
+      recordOpenCodeFailure(owner, lastServerError, observationSequence);
+      const failure = openCodeFailureDiagnostic(lastServerError);
+      log(
+        `kickoff: server unavailable code=${failure.failureCode} `
+        + `class=${failure.errorClass} status=${failure.httpStatus ?? 'none'} attempts=30`,
+        owner,
+      );
+      return false;
     }
 
     // Capture the launch-selected session, including explicit resume/fork
     // targets. Unrelated sessions do not contain this launch's metadata identity.
+    let lastSearchFailure: LaunchSessionSearchFailure | null = null;
     for (let i = 0; i < 30; i++) {
-      const binding = await findLaunchSession(launch.correlationIdentity);
-      if (binding) {
-        if (state !== owner) return false;
-        saveBinding(binding.session, binding.knownRootSessionIds);
-        log(`kickoff: bound session ${binding.session.id.slice(0, 8)}…`, owner);
+      const result = await findLaunchSession(launch.correlationIdentity);
+      if (result.kind === 'superseded') return false;
+      if (result.kind === 'found') {
+        saveBinding(result.session, result.knownRootSessionIds);
+        log(`kickoff: bound session ${result.session.id.slice(0, 8)}…`, owner);
         return true;
       }
-      await new Promise((r) => setTimeout(r, 1000));
+      lastSearchFailure = result;
+      if (i < 29) await new Promise((r) => setTimeout(r, 1000));
     }
 
-    log('kickoff: no session found', owner);
+    if (lastSearchFailure) {
+      logLaunchSessionSearchFailure(lastSearchFailure, 30, owner);
+      if (
+        lastSearchFailure.kind === 'directory-miss'
+        || lastSearchFailure.kind === 'correlation-mismatch'
+      ) {
+        updateLastOpenCodeObservation(owner, ++owner.nextObservationSequence, {
+          lastFailureCode: 'no-target',
+        });
+      }
+    }
     return false;
   } catch (err) {
     log(`kickoff error: ${err}`, owner);
@@ -1443,6 +1565,14 @@ export function __getOpenCodeLastObservationForTests(): OpenCodeLastObservation
   return { ...state.lastObservation };
 }
 
+export function __decodeOpenCodeSessionForTests(value: unknown): unknown {
+  return decodeSession(value);
+}
+
+export async function __listOpenCodeSessionsForTests(): Promise<unknown[]> {
+  return listSessions();
+}
+
 export function computeOpenCodePort(droneId: string, base: number = 14096): number {
   let hash = 0;
   for (let i = 0; i < droneId.length; i++) {

package/src/seats.ts

@@ -50,6 +50,8 @@ export interface SeatRecord {
   sessionId?: string;
   // binding + display (set atomically at FINALIZE; absent while pending)
   worktree?: string;
+  commonDir?: string;
+  repositoryOrigin?: string;
   name?: string;
   droneLabel?: string;
   roleName?: string;
@@ -149,6 +151,8 @@ function isValidSeatRecord(ref: string, value: unknown): value is SeatRecord {
   if (r.roleClass !== undefined && (typeof r.roleClass !== 'string' || !ROLE_CLASSES.has(r.roleClass))) return false;
   if (r.isHumanSeat !== undefined && typeof r.isHumanSeat !== 'boolean') return false;
   if (r.worktree !== undefined && typeof r.worktree !== 'string') return false;
+  if (r.commonDir !== undefined && !isNonEmptyString(r.commonDir)) return false;
+  if (r.repositoryOrigin !== undefined && !isNonEmptyString(r.repositoryOrigin)) return false;
   if (r.droneId !== undefined && (typeof r.droneId !== 'string' || !UUID_RE.test(r.droneId))) return false;
   if (r.sessionId !== undefined && (typeof r.sessionId !== 'string' || !UUID_RE.test(r.sessionId))) return false;
   // State-consistency invariants (no inconsistent active|pending).
@@ -447,6 +451,8 @@ export type ActivateSeatOutcome = 'activated' | 'missing' | 'replaced';
  *  worktree is decided). Merged atomically with activation by activateAndBindSeat. */
 export interface SeatBinding {
   worktree: string;
+  commonDir?: string;
+  repositoryOrigin?: string;
   name: string;
   droneLabel: string;
   roleName?: string;
@@ -475,6 +481,8 @@ export async function activateAndBindSeat(input: {
   sessionId: string;
   expectedPendingDigest: string;
   worktree: string;
+  commonDir?: string;
+  repositoryOrigin?: string;
   name: string;
   droneLabel: string;
   roleName?: string;
@@ -496,6 +504,8 @@ export async function activateAndBindSeat(input: {
       droneId: input.droneId,
       sessionId: input.sessionId,
       worktree: input.worktree,
+      ...(input.commonDir !== undefined ? { commonDir: input.commonDir } : {}),
+      ...(input.repositoryOrigin !== undefined ? { repositoryOrigin: input.repositoryOrigin } : {}),
       name: input.name,
       droneLabel: input.droneLabel,
       ...(input.roleName !== undefined ? { roleName: input.roleName } : {}),
@@ -675,6 +685,23 @@ export async function readAllActiveSeats(): Promise<Array<{ worktree: string; re
   return out;
 }
 
+/** Whether this cube has an active seat on the SAME repository from a different
+ *  clone family. Repositories without a remote have no identity shared across
+ *  clones, so their separate clones are undetectable here — see client#264. */
+export async function hasActiveSeatInDifferentCloneFamily(
+  cubeId: string,
+  repositoryOrigin: string,
+  commonDir: string,
+): Promise<boolean> {
+  const seats = await readAllActiveSeats();
+  return seats.some(({ record }) =>
+    record.cubeId === cubeId &&
+    record.repositoryOrigin === repositoryOrigin &&
+    record.commonDir !== undefined &&
+    record.commonDir !== commonDir
+  );
+}
+
 /** All valid worktree-bound registry entries, including a PENDING seat whose
  * interrupted finalize preserved its worktree for a later resume. Read-only:
  * pending records remain non-hydratable and getActiveSeatForWorktree stays

package/src/server-handshake.ts

@@ -410,6 +410,8 @@ export async function sendBorgServerAttach(
           sessionId: decoded.session.id,
           expectedPendingDigest: pendingBearerDigest,
           worktree: binding.worktree,
+          ...(binding.commonDir !== undefined ? { commonDir: binding.commonDir } : {}),
+          ...(binding.repositoryOrigin !== undefined ? { repositoryOrigin: binding.repositoryOrigin } : {}),
           name: binding.name,
           droneLabel: binding.droneLabel,
           ...(binding.roleName !== undefined ? { roleName: binding.roleName } : {}),

package/src/wake-path-health.ts

@@ -49,7 +49,9 @@ export function openCodeWakePathHealthy(
   ) {
     return null;
   }
-  if (state.sessionId === null) return null;
+  if (state.sessionId === null) {
+    return state.lastFailureCode === null ? null : false;
+  }
   return true;
 }