fix(runtime): keep opencode liveness in sync

Author: 777genius

src/main/index.ts

@@ -57,6 +57,7 @@ import {
   type RuntimeProviderManagementFeatureFacade,
 } from '@features/runtime-provider-management/main';
 import { createWorkspaceTrustCoordinator } from '@features/workspace-trust/main';
+import { ensureOpenCodeBridgeRuntimeBinaryEnv } from '@main/services/runtime/openCodeBridgeRuntimeEnv';
 import { ClaudeMultimodelBridgeService } from '@main/services/runtime/ClaudeMultimodelBridgeService';
 import { applyOpenCodeAutoUpdatePolicy } from '@main/services/runtime/openCodeAutoUpdatePolicy';
 import { providerConnectionService } from '@main/services/runtime/ProviderConnectionService';
@@ -411,18 +412,15 @@ async function createOpenCodeRuntimeAdapterRegistry(
       copyOpenCodeLocalMcpLaunchEnv(targetEnv, bridgeEnv);
     }
   };
-  try {
-    const appManagedOpenCodeBinary = await resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath();
-    if (appManagedOpenCodeBinary && !bridgeEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH) {
-      bridgeEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH = appManagedOpenCodeBinary;
-    }
-  } catch (error) {
-    logger.warn(
-      `[OpenCode] Runtime adapter bundled OpenCode binary unresolved: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
+  const ensureOpenCodeRuntimeBinaryEnv = async (targetEnv: NodeJS.ProcessEnv): Promise<void> => {
+    await ensureOpenCodeBridgeRuntimeBinaryEnv({
+      targetEnv,
+      bridgeEnv,
+      resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath,
+      onWarning: (message) => logger.warn(message),
+    });
+  };
+  await ensureOpenCodeRuntimeBinaryEnv(bridgeEnv);
   try {
     reportProgress('runtime-work-sync', 'Preparing runtime work sync hooks...');
     const turnSettledEnv = await buildMemberWorkSyncRuntimeTurnSettledEnvironment({
@@ -465,6 +463,7 @@ async function createOpenCodeRuntimeAdapterRegistry(
   reportProgress('runtime-bridge', 'Preparing OpenCode bridge...');
   const resolveBridgeCommandEnv = async (): Promise<NodeJS.ProcessEnv> => {
     const nextEnv = { ...bridgeEnv };
+    await ensureOpenCodeRuntimeBinaryEnv(nextEnv);
     if (!useHttpMcpBridge) {
       return nextEnv;
     }
@@ -897,6 +896,23 @@ function isShutdownStarted(): boolean {
   return shutdownComplete || shutdownPromise !== null;
 }
 
+function hasActiveTeamRuntimesForWindowClose(): boolean {
+  if (!servicesReady || !teamProvisioningService) {
+    return false;
+  }
+
+  try {
+    return teamProvisioningService.hasActiveTeamRuntimes();
+  } catch (error) {
+    logger.warn(
+      `Failed to check active team runtimes before closing last window: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+    return false;
+  }
+}
+
 function scheduleStartupTask(action: () => void, delayMs: number): void {
   const timer = setTimeout(() => {
     startupTimers.delete(timer);
@@ -2748,10 +2764,16 @@ void app.whenReady().then(async () => {
  * All windows closed handler.
  */
 app.on('window-all-closed', () => {
+  const hasActiveTeamRuntimes = hasActiveTeamRuntimesForWindowClose();
   const shouldQuitWhenAllWindowsClosed =
-    process.platform !== 'darwin' || !configManager.getConfig().general.showDockIcon;
+    hasActiveTeamRuntimes ||
+    process.platform !== 'darwin' ||
+    !configManager.getConfig().general.showDockIcon;
 
   if (shouldQuitWhenAllWindowsClosed) {
+    if (hasActiveTeamRuntimes) {
+      logger.info('Quitting after last window closed because active team runtimes are running');
+    }
     app.quit();
   }
 });

src/main/services/runtime/openCodeBridgeRuntimeEnv.ts

@@ -0,0 +1,38 @@
+import { getErrorMessage } from '@shared/utils/errorHandling';
+
+import { applyOpenCodeRuntimeBinaryEnv } from './openCodeRuntimeBinaryEnv';
+
+export interface EnsureOpenCodeBridgeRuntimeBinaryEnvOptions {
+  targetEnv: NodeJS.ProcessEnv;
+  bridgeEnv?: NodeJS.ProcessEnv;
+  resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath: () => Promise<string | null>;
+  onWarning?: (message: string) => void;
+}
+
+export async function ensureOpenCodeBridgeRuntimeBinaryEnv({
+  targetEnv,
+  bridgeEnv = targetEnv,
+  resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath,
+  onWarning,
+}: EnsureOpenCodeBridgeRuntimeBinaryEnvOptions): Promise<void> {
+  if (targetEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH?.trim()) {
+    applyOpenCodeRuntimeBinaryEnv(targetEnv, null);
+    return;
+  }
+
+  try {
+    const appManagedOpenCodeBinary = await resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath();
+    applyOpenCodeRuntimeBinaryEnv(targetEnv, appManagedOpenCodeBinary);
+    if (
+      targetEnv !== bridgeEnv &&
+      targetEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH &&
+      !bridgeEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH
+    ) {
+      applyOpenCodeRuntimeBinaryEnv(bridgeEnv, targetEnv.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH);
+    }
+  } catch (error) {
+    onWarning?.(
+      `[OpenCode] Runtime adapter bundled OpenCode binary unresolved: ${getErrorMessage(error)}`
+    );
+  }
+}

src/main/services/runtime/openCodeRuntimeBinaryEnv.ts

@@ -0,0 +1,54 @@
+import path from 'node:path';
+
+export const OPENCODE_RUNTIME_BINARY_PATH_ENV = 'CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH';
+
+function normalizePathEntryForCompare(value: string): string {
+  const normalized = path.resolve(value.trim());
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+function prependPathEntry(env: NodeJS.ProcessEnv, directory: string): void {
+  const trimmedDirectory = directory.trim();
+  if (!trimmedDirectory) {
+    return;
+  }
+
+  const currentPath = env.PATH ?? '';
+  const currentEntries = currentPath.split(path.delimiter).filter(Boolean);
+  const normalizedDirectory = normalizePathEntryForCompare(trimmedDirectory);
+  const alreadyPresent = currentEntries.some(
+    (entry) => normalizePathEntryForCompare(entry) === normalizedDirectory
+  );
+
+  if (alreadyPresent) {
+    env.PATH = currentEntries.join(path.delimiter);
+    return;
+  }
+
+  env.PATH = [trimmedDirectory, ...currentEntries].join(path.delimiter);
+}
+
+export function applyOpenCodeRuntimeBinaryEnv(
+  env: NodeJS.ProcessEnv,
+  discoveredBinaryPath: string | null | undefined
+): void {
+  const existingBinaryPath = env[OPENCODE_RUNTIME_BINARY_PATH_ENV]?.trim();
+  const nextBinaryPath = existingBinaryPath || discoveredBinaryPath?.trim() || '';
+  if (!nextBinaryPath) {
+    return;
+  }
+
+  if (!existingBinaryPath) {
+    env[OPENCODE_RUNTIME_BINARY_PATH_ENV] = nextBinaryPath;
+  }
+
+  if (!path.isAbsolute(nextBinaryPath)) {
+    return;
+  }
+
+  // Facts:
+  // - The app-managed OpenCode status is resolved from the app runtime manifest.
+  // - Older claude-multimodel readiness inventory still resolves "opencode" through PATH.
+  // - Exposing the selected binary directory keeps both checks on the same runtime.
+  prependPathEntry(env, path.dirname(nextBinaryPath));
+}

src/main/services/runtime/providerAwareCliEnv.ts

@@ -5,6 +5,7 @@ import { resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath } from '../infrastru
 
 import { ensureAgentTeamsMcpLocalLaunchEnv } from './agentTeamsMcpLaunchEnv';
 import { buildRuntimeBaseEnv } from './buildRuntimeBaseEnv';
+import { applyOpenCodeRuntimeBinaryEnv } from './openCodeRuntimeBinaryEnv';
 import { providerConnectionService } from './ProviderConnectionService';
 
 import type { CliProviderId, TeamProviderId } from '@shared/types';
@@ -43,13 +44,9 @@ export async function buildProviderAwareCliEnv(
     shellEnv,
     env: options.env,
   });
-  const appManagedOpenCodeBinary = await resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath();
-  if (
-    appManagedOpenCodeBinary &&
-    !env.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH &&
-    (!resolvedProviderId || resolvedProviderId === 'opencode')
-  ) {
-    env.CLAUDE_MULTIMODEL_OPENCODE_BIN_PATH = appManagedOpenCodeBinary;
+  if (!resolvedProviderId || resolvedProviderId === 'opencode') {
+    const appManagedOpenCodeBinary = await resolveVerifiedAppManagedOpenCodeRuntimeBinaryPath();
+    applyOpenCodeRuntimeBinaryEnv(env, appManagedOpenCodeBinary);
   }
   const appManagedCodexBinary = await resolveVerifiedAppManagedCodexRuntimeBinaryPath();
   if (

src/main/services/team/TeamProvisioningService.ts

@@ -24376,6 +24376,15 @@ export class TeamProvisioningService {
     return Array.from(this.aliveRunByTeam.keys()).filter((name) => this.isTeamAlive(name));
   }
 
+  /**
+   * True when shutdown has team runtime state that must not be left headless.
+   * Includes active leads, provisioning runs, runtime-adapter runs, secondary lanes,
+   * and in-flight team operations that may expose a runtime shortly.
+   */
+  hasActiveTeamRuntimes(): boolean {
+    return this.getShutdownTrackedTeamNames().length > 0;
+  }
+
   async getRuntimeState(teamName: string): Promise<TeamRuntimeState> {
     const runId = this.getTrackedRunId(teamName);
     const run = runId ? (this.runs.get(runId) ?? null) : null;

src/renderer/components/team/members/MemberList.tsx

@@ -780,7 +780,10 @@ export const MemberList = memo(function MemberList({
       ) {
         return false;
       }
-      if (spawnEntry?.runtimeAlive === false && spawnEntry.status !== 'online') {
+      if (spawnEntry?.runtimeAlive === false) {
+        return false;
+      }
+      if (runtimeEntry?.alive === false) {
         return false;
       }
       if (

src/renderer/utils/memberHelpers.ts

@@ -797,7 +797,7 @@ function getLaunchVisualStateDotClass(visualState: MemberLaunchVisualState): str
     case 'starting_stale':
       return 'bg-amber-400';
     case 'registered_only':
-      return SPAWN_DOT_COLORS.waiting;
+      return STATUS_DOT_COLORS.terminated;
     case 'shell_only':
       return 'bg-amber-400';
     case 'stale_runtime':
@@ -807,6 +807,38 @@ function getLaunchVisualStateDotClass(visualState: MemberLaunchVisualState): str
   }
 }
 
+function getCurrentRuntimeOfflineVisualState(
+  runtimeEntry: TeamAgentRuntimeEntry | undefined,
+  spawnStatus: MemberSpawnStatus | undefined,
+  spawnLaunchState: MemberLaunchState | undefined,
+  spawnRuntimeAlive: boolean | undefined
+): MemberLaunchVisualState {
+  if (runtimeEntry?.livenessKind === 'registered_only') {
+    return 'registered_only';
+  }
+  if (
+    runtimeEntry?.livenessKind === 'stale_metadata' ||
+    runtimeEntry?.livenessKind === 'not_found'
+  ) {
+    return 'stale_runtime';
+  }
+  if (
+    runtimeEntry?.alive === false &&
+    (runtimeEntry.livenessKind == null ||
+      runtimeEntry.livenessKind === 'runtime_process' ||
+      runtimeEntry.livenessKind === 'confirmed_bootstrap')
+  ) {
+    return 'stale_runtime';
+  }
+  if (
+    spawnRuntimeAlive === false &&
+    (spawnStatus === 'online' || spawnLaunchState === 'confirmed_alive')
+  ) {
+    return 'stale_runtime';
+  }
+  return null;
+}
+
 export function shouldDisplayMemberCurrentTask({
   member,
   isTeamAlive,
@@ -846,10 +878,10 @@ export function shouldDisplayMemberCurrentTask({
   ) {
     return false;
   }
-  if (runtimeEntry?.alive === false && spawnStatus !== 'online') {
+  if (runtimeEntry?.alive === false) {
     return false;
   }
-  if (spawnRuntimeAlive === false && spawnStatus !== 'online') {
+  if (spawnRuntimeAlive === false) {
     return false;
   }
   return true;
@@ -1039,13 +1071,26 @@ export function buildMemberLaunchPresentation({
   leadActivity?: LeadActivityState;
   nowMs?: number;
 }): MemberLaunchPresentation {
+  const currentRuntimeOfflineVisualState = getCurrentRuntimeOfflineVisualState(
+    runtimeEntry,
+    spawnStatus,
+    spawnLaunchState,
+    spawnRuntimeAlive
+  );
   const hasConfirmedSpawnLaunch =
     spawnLaunchState === 'confirmed_alive' && spawnBootstrapConfirmed === true;
   const effectiveSpawnStatus =
-    hasConfirmedSpawnLaunch && (spawnStatus === 'waiting' || spawnStatus === 'spawning')
+    hasConfirmedSpawnLaunch &&
+    currentRuntimeOfflineVisualState == null &&
+    (spawnStatus === 'waiting' || spawnStatus === 'spawning')
       ? 'online'
       : spawnStatus;
-  const effectiveSpawnRuntimeAlive = hasConfirmedSpawnLaunch ? true : spawnRuntimeAlive;
+  const effectiveSpawnRuntimeAlive =
+    currentRuntimeOfflineVisualState != null
+      ? false
+      : hasConfirmedSpawnLaunch
+        ? true
+        : spawnRuntimeAlive;
   const presenceLabel = getLaunchAwarePresenceLabel(
     member,
     effectiveSpawnStatus,
@@ -1100,21 +1145,12 @@ export function buildMemberLaunchPresentation({
       launchVisualState = 'permission_pending';
     } else if (spawnBootstrapStalled === true) {
       launchVisualState = 'bootstrap_stalled';
-    } else if (!hasConfirmedSpawnLaunch && runtimeEntry?.livenessKind === 'shell_only') {
+    } else if (currentRuntimeOfflineVisualState != null) {
+      launchVisualState = currentRuntimeOfflineVisualState;
+    } else if (runtimeEntry?.livenessKind === 'shell_only') {
       launchVisualState = 'shell_only';
-    } else if (
-      !hasConfirmedSpawnLaunch &&
-      runtimeEntry?.livenessKind === 'runtime_process_candidate'
-    ) {
+    } else if (runtimeEntry?.livenessKind === 'runtime_process_candidate') {
       launchVisualState = 'runtime_candidate';
-    } else if (!hasConfirmedSpawnLaunch && runtimeEntry?.livenessKind === 'registered_only') {
-      launchVisualState = 'registered_only';
-    } else if (
-      !hasConfirmedSpawnLaunch &&
-      (runtimeEntry?.livenessKind === 'stale_metadata' ||
-        runtimeEntry?.livenessKind === 'not_found')
-    ) {
-      launchVisualState = 'stale_runtime';
     } else if (!hasConfirmedSpawnLaunch && startingIsStale) {
       launchVisualState = 'starting_stale';
     } else if (