borgmcp 4.6.0 → 4.6.2

package/src/opencode-drone.ts

@@ -14,7 +14,7 @@ import {
 } from 'fs';
 import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import {
   borgConfigRoot,
@@ -44,8 +44,9 @@ 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');
-  return createHash('sha256').update(key).digest('hex').slice(0, 24);
+  // Diagnostic files follow the stable worktree location; launch placeholders
+  // must not select a second log before session identity resolves.
+  return createHash('sha256').update(resolve(current.directory)).digest('hex').slice(0, 24);
 }
 
 export function openCodeStartupDiagnosticLogPath(): string {
@@ -166,6 +167,7 @@ interface OpenCodeDroneState {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
   connected: boolean;
   totalEntriesInjected: number;
   totalEntriesRetried: number;
@@ -204,6 +206,7 @@ interface ConnectDeps {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
 }
 
 interface OCSession {
@@ -211,8 +214,6 @@ interface OCSession {
   directory: string;
   time: { created: number };
   parentID?: string;
-  agent?: string;
-  model?: { providerID: string; modelID: string };
 }
 
 interface OCMessage {
@@ -272,7 +273,7 @@ const OPEN_CODE_RECONCILIATION_ATTEMPTS = 20;
 const OPEN_CODE_DELIVERY_HISTORY_LIMIT = 256;
 
 interface SessionBinding {
-  version: 4;
+  version: 5;
   sessionId: string;
   sessionCreatedAt: number;
   knownRootSessionIds: string[];
@@ -280,6 +281,7 @@ interface SessionBinding {
   directory: string;
   droneLabel: string;
   cubeName: string;
+  launchIdentity: string;
   pendingSubmissions: Array<{
     entryId: string;
     sourceEntryId: string;
@@ -287,6 +289,13 @@ interface SessionBinding {
   }>;
 }
 
+interface SessionBindingClaim {
+  version: 1;
+  directory: string;
+  droneLabel: string;
+  cubeName: string;
+}
+
 export interface OpenCodeLaunchKickoff {
   prompt: string;
   apiPassword: string;
@@ -325,6 +334,9 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
   if (!isOpenCode256BitIdentity(deps.apiPassword)) {
     throw new OpenCodeAuthenticationError('OpenCode API password is missing or unverifiable');
   }
+  if (!isOpenCode256BitIdentity(deps.launchIdentity)) {
+    throw new OpenCodeAuthenticationError('OpenCode launch identity is missing or unverifiable');
+  }
   await ensurePrivateBorgConfigRoot(borgConfigRoot());
   abandonOpenCodeDeliveries(state);
   state = {
@@ -336,6 +348,7 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
     directory: deps.directory,
     droneLabel: deps.droneLabel,
     cubeName: deps.cubeName,
+    launchIdentity: deps.launchIdentity,
     connected: true,
     totalEntriesInjected: 0,
     totalEntriesRetried: 0,
@@ -461,12 +474,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();
   }
@@ -554,18 +561,28 @@ async function promptSession(id: string, bodyObj: Record<string, unknown>): Prom
 
 function bindingPath(): string {
   const current = state!;
-  const path = join(tmpdir(), `borg-opencode-session-${stateIdentityDigest(current)}.json`);
+  const identity = createHash('sha256').update(current.launchIdentity).digest('hex').slice(0, 24);
+  const path = join(tmpdir(), `borg-opencode-session-${identity}.json`);
   bindingPathsForTests.add(path);
   return path;
 }
 
+function bindingClaimPath(): string {
+  return `${bindingPath()}.claim`;
+}
+
 function bindingMatchesState(binding: SessionBinding): boolean {
   const current = state!;
-  return binding.version === 4
-    && binding.serverUrl === current.serverUrl
+  const sameResolvedSeat = binding.droneLabel === current.droneLabel
+    && binding.cubeName === current.cubeName;
+  // The 256-bit launch identity lets the resolved MCP child claim only its
+  // launcher's placeholder binding; resolved ownership still requires labels.
+  const unclaimedLaunch = binding.droneLabel === 'opencode'
+    && binding.cubeName === 'borg';
+  return binding.version === 5
     && binding.directory === current.directory
-    && binding.droneLabel === current.droneLabel
-    && binding.cubeName === current.cubeName
+    && binding.launchIdentity === current.launchIdentity
+    && (sameResolvedSeat || unclaimedLaunch)
     && typeof binding.sessionId === 'string'
     && typeof binding.sessionCreatedAt === 'number'
     && Array.isArray(binding.knownRootSessionIds)
@@ -608,15 +625,14 @@ function clearBinding(): void {
 
 function writeBinding(binding: SessionBinding): boolean {
   const current = state!;
-  current.sessionId = binding.sessionId;
-  current.sessionCreatedAt = binding.sessionCreatedAt;
-  current.knownRootSessionIds = binding.knownRootSessionIds;
-
   try {
     const path = bindingPath();
     const temporary = `${path}.${process.pid}.tmp`;
     writeFileSync(temporary, JSON.stringify(binding), { mode: 0o600 });
     renameSync(temporary, path);
+    current.sessionId = binding.sessionId;
+    current.sessionCreatedAt = binding.sessionCreatedAt;
+    current.knownRootSessionIds = binding.knownRootSessionIds;
     return true;
   } catch (err) {
     log(`session binding write failed: ${err}`);
@@ -624,10 +640,46 @@ function writeBinding(binding: SessionBinding): boolean {
   }
 }
 
+function claimPlaceholderBinding(): boolean {
+  const current = state!;
+  const claim: SessionBindingClaim = {
+    version: 1,
+    directory: current.directory,
+    droneLabel: current.droneLabel,
+    cubeName: current.cubeName,
+  };
+  const path = bindingClaimPath();
+  try {
+    writeFileSync(path, JSON.stringify(claim), { mode: 0o600, flag: 'wx' });
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
+      log(`session binding claim failed: ${error}`);
+      return false;
+    }
+  }
+  try {
+    const existing = JSON.parse(readFileSync(path, 'utf8')) as SessionBindingClaim;
+    return existing.version === 1
+      && existing.directory === claim.directory
+      && existing.droneLabel === claim.droneLabel
+      && existing.cubeName === claim.cubeName;
+  } catch {
+    return false;
+  }
+}
+
+function dropCachedBinding(): void {
+  if (!state) return;
+  state.sessionId = null;
+  state.sessionCreatedAt = null;
+  state.knownRootSessionIds = [];
+}
+
 function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
   const current = state!;
   const binding: SessionBinding = {
-    version: 4,
+    version: 5,
     sessionId: session.id,
     sessionCreatedAt: session.time.created,
     knownRootSessionIds,
@@ -635,6 +687,7 @@ function saveBinding(session: OCSession, knownRootSessionIds: string[]): void {
     directory: current.directory,
     droneLabel: current.droneLabel,
     cubeName: current.cubeName,
+    launchIdentity: current.launchIdentity,
     pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
       entryId,
       sourceEntryId: pending.sourceEntryId,
@@ -648,7 +701,7 @@ function persistCurrentBinding(): boolean {
   const current = state;
   if (!current?.sessionId || current.sessionCreatedAt === null) return false;
   return writeBinding({
-    version: 4,
+    version: 5,
     sessionId: current.sessionId,
     sessionCreatedAt: current.sessionCreatedAt,
     knownRootSessionIds: current.knownRootSessionIds,
@@ -656,6 +709,7 @@ function persistCurrentBinding(): boolean {
     directory: current.directory,
     droneLabel: current.droneLabel,
     cubeName: current.cubeName,
+    launchIdentity: current.launchIdentity,
     pendingSubmissions: [...current.pendingSubmissions].map(([entryId, pending]) => ({
       entryId,
       sourceEntryId: pending.sourceEntryId,
@@ -667,25 +721,34 @@ function persistCurrentBinding(): boolean {
 function restoreBinding(): SessionBinding | null {
   if (!state) return null;
   if (state.sessionId && state.sessionCreatedAt !== null) {
-    return {
-      version: 4,
-      sessionId: state.sessionId,
-      sessionCreatedAt: state.sessionCreatedAt,
-      knownRootSessionIds: state.knownRootSessionIds,
-      serverUrl: state.serverUrl,
-      directory: state.directory,
-      droneLabel: state.droneLabel,
-      cubeName: state.cubeName,
-      pendingSubmissions: [...state.pendingSubmissions].map(([entryId, pending]) => ({
-        entryId,
-        sourceEntryId: pending.sourceEntryId,
-        sessionId: pending.sessionId,
-      })),
-    };
+    const persisted = readBinding();
+    if (
+      persisted?.droneLabel === state.droneLabel
+      && persisted.cubeName === state.cubeName
+    ) return persisted;
+    dropCachedBinding();
+    return null;
   }
 
-  const binding = readBinding();
+  let binding = readBinding();
   if (!binding) return null;
+  if (binding.droneLabel === 'opencode' && binding.cubeName === 'borg') {
+    if (!claimPlaceholderBinding()) return null;
+    if (!writeBinding({
+      ...binding,
+      droneLabel: state.droneLabel,
+      cubeName: state.cubeName,
+    })) return null;
+    binding = readBinding();
+    if (
+      !binding
+      || binding.droneLabel !== state.droneLabel
+      || binding.cubeName !== state.cubeName
+    ) {
+      dropCachedBinding();
+      return null;
+    }
+  }
   state.sessionId = binding.sessionId;
   state.sessionCreatedAt = binding.sessionCreatedAt;
   state.knownRootSessionIds = binding.knownRootSessionIds;
@@ -747,35 +810,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 +990,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 +1351,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);
@@ -1438,11 +1632,24 @@ export function __getOpenCodeDiagnosticLogPathForTests(): string {
   return diagnosticLogPath(state);
 }
 
+export function __getOpenCodeBindingPathForTests(): string {
+  if (!state) throw new Error('OpenCode drone is not connected');
+  return bindingPath();
+}
+
 export function __getOpenCodeLastObservationForTests(): OpenCodeLastObservation {
   if (!state) throw new Error('OpenCode drone is not connected');
   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++) {
@@ -1519,6 +1726,11 @@ export function __resetOpenCodeDroneForTests(): void {
     } catch {
       // Already removed.
     }
+    try {
+      unlinkSync(`${path}.claim`);
+    } catch {
+      // Already removed.
+    }
   }
   bindingPathsForTests.clear();
   for (const path of diagnosticLogPathsForTests) {

package/src/opencode-launch-trust.ts

@@ -44,3 +44,8 @@ export function openCodeApiPasswordFromEnv(env: NodeJS.ProcessEnv): string | nul
   const password = env[OPENCODE_SERVER_PASSWORD_ENV];
   return isOpenCode256BitIdentity(password) ? password : null;
 }
+
+export function openCodeLaunchCorrelationFromEnv(env: NodeJS.ProcessEnv): string | null {
+  const identity = env[BORG_OPENCODE_LAUNCH_CORRELATION_ENV];
+  return isOpenCode256BitIdentity(identity) ? identity : null;
+}

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