From bc2e1e43d82c49647666bf9f9fb44738d164912a Mon Sep 17 00:00:00 2001
From: 777genius <quantjumppro@gmail.com>
Date: Fri, 24 Apr 2026 00:40:11 +0300
Subject: [PATCH] feat: refine team provisioning and task log UX

---
 .../renderer/adapters/TeamGraphAdapter.ts     |    3 +-
 .../ClaudeRecentProjectsSourceAdapter.ts      |   11 +-
 .../CodexRecentProjectsSourceAdapter.ts       |    3 +-
 .../renderer/hooks/useOpenRecentProject.ts    |   18 +-
 .../utils/recentProjectOpenHistory.ts         |    5 +
 .../buildMixedPersistedLaunchSnapshot.ts      |    3 +
 .../CliProviderModelAvailabilityService.ts    |    2 +-
 .../services/team/TeamLaunchStateEvaluator.ts |   16 +
 .../team/TeamMemberRuntimeAdvisoryService.ts  |   81 +-
 .../services/team/TeamProvisioningService.ts  |  728 +++--
 src/renderer/App.tsx                          |   50 +-
 src/renderer/components/splash/splashScene.ts |  897 ++++++
 .../team/dialogs/CreateTeamDialog.tsx         |   59 +-
 .../team/dialogs/LaunchTeamDialog.tsx         |   43 +-
 .../ProvisioningProviderStatusList.tsx        |   80 +-
 .../team/dialogs/projectPathOptions.ts        |    5 +
 .../dialogs/providerPrepareDiagnostics.ts     |  109 +-
 .../components/team/members/MemberCard.tsx    |   33 +-
 .../team/members/MemberDetailHeader.tsx       |   16 +-
 .../team/members/MemberHoverCard.tsx          |   25 +-
 .../team/review/ChangeReviewDialog.tsx        |  103 +-
 .../team/review/ConfidenceBadge.tsx           |    9 +-
 .../team/review/ContinuousScrollView.tsx      |    2 +-
 .../team/review/FileSectionDiff.tsx           |   13 +-
 .../team/review/FileSectionHeader.tsx         |   43 +-
 .../team/review/FullDiffLoadingBanner.tsx     |    6 +-
 .../components/team/review/ReviewToolbar.tsx  |    8 +-
 .../team/review/ScopeWarningBanner.tsx        |   53 +-
 .../team/taskLogs/TaskLogStreamSection.tsx    |   14 +-
 src/renderer/index.html                       |  436 ++-
 src/renderer/utils/memberHelpers.ts           |   81 +-
 src/shared/types/team.ts                      |    7 +-
 .../__tests__/ephemeralProjectPath.test.ts    |   42 +
 src/shared/utils/ephemeralProjectPath.ts      |   41 +
 .../CodexRecentProjectsSourceAdapter.test.ts  |   50 +-
 .../utils/recentProjectOpenHistory.test.ts    |   28 +-
 ...liProviderModelAvailabilityService.test.ts |   15 +-
 .../TeamAgentLaunchMatrix.safe-e2e.test.ts    | 2641 ++++++++++++++++-
 .../TeamMemberRuntimeAdvisoryService.test.ts  |   70 +-
 .../TeamProvisioningServicePrepare.test.ts    |  550 +++-
 .../ProvisioningProviderStatusList.test.ts    |   43 +-
 .../team/dialogs/projectPathOptions.test.ts   |   23 +
 .../providerPrepareDiagnostics.test.ts        |  151 +-
 .../taskLogs/TaskLogStreamSection.test.ts     |  115 +-
 .../agent-graph/TeamGraphAdapter.test.ts      |   23 +
 test/renderer/utils/memberHelpers.test.ts     |   74 +-
 46 files changed, 6111 insertions(+), 717 deletions(-)
 create mode 100644 src/renderer/components/splash/splashScene.ts
 create mode 100644 src/shared/utils/__tests__/ephemeralProjectPath.test.ts
 create mode 100644 src/shared/utils/ephemeralProjectPath.ts

diff --git a/src/features/agent-graph/renderer/adapters/TeamGraphAdapter.ts b/src/features/agent-graph/renderer/adapters/TeamGraphAdapter.ts
index 91d9969a..98e6718e 100644
--- a/src/features/agent-graph/renderer/adapters/TeamGraphAdapter.ts
+++ b/src/features/agent-graph/renderer/adapters/TeamGraphAdapter.ts
@@ -642,8 +642,7 @@ export class TeamGraphAdapter {
         reviewerName: isReviewCycle ? reviewerName : null,
         reviewMode: isReviewCycle ? (reviewerName ? 'assigned' : 'manual') : undefined,
         reviewerColor: reviewerName ? memberColorByName.get(reviewerName) : undefined,
-        changePresence:
-          task.changePresence === 'needs_attention' ? 'has_changes' : task.changePresence,
+        changePresence: task.changePresence === 'needs_attention' ? 'unknown' : task.changePresence,
         displayId: task.displayId ?? undefined,
         ownerId: ownerMemberId,
         needsClarification: task.needsClarification ?? null,
diff --git a/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts b/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts
index 700b9122..d1d55a94 100644
--- a/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts
+++ b/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts
@@ -1,6 +1,7 @@
 import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
 import { WorktreeGrouper } from '@main/services/discovery/WorktreeGrouper';
 import { getProjectsBasePath } from '@main/utils/pathDecoder';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 
 import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
 import type {
@@ -16,11 +17,15 @@ function selectPreferredWorktree(worktrees: readonly Worktree[]): Worktree | und
 }
 
 function toCandidate(repo: RepositoryGroup): RecentProjectCandidate | null {
-  if (!repo.worktrees.length || !repo.mostRecentSession) {
+  const selectableWorktrees = repo.worktrees.filter(
+    (worktree) => !isEphemeralProjectPath(worktree.path)
+  );
+
+  if (!selectableWorktrees.length || !repo.mostRecentSession) {
     return null;
   }
 
-  const preferredWorktree = selectPreferredWorktree(repo.worktrees);
+  const preferredWorktree = selectPreferredWorktree(selectableWorktrees);
   if (!preferredWorktree) {
     return null;
   }
@@ -29,7 +34,7 @@ function toCandidate(repo: RepositoryGroup): RecentProjectCandidate | null {
     identity: repo.identity?.id ?? `path:${normalizeIdentityPath(preferredWorktree.path)}`,
     displayName: repo.name,
     primaryPath: preferredWorktree.path,
-    associatedPaths: repo.worktrees.map((worktree) => worktree.path),
+    associatedPaths: selectableWorktrees.map((worktree) => worktree.path),
     lastActivityAt: repo.mostRecentSession,
     providerIds: ['anthropic'],
     sourceKind: 'claude',
diff --git a/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts b/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts
index f597fcfe..19c2ad0c 100644
--- a/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts
+++ b/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts
@@ -1,4 +1,5 @@
 import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 import path from 'path';
 
 import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
@@ -186,7 +187,7 @@ export class CodexRecentProjectsSourceAdapter implements RecentProjectsSourcePor
 
   async #toCandidate(thread: CodexThreadSummary): Promise<RecentProjectCandidate | null> {
     const cwd = thread.cwd?.trim();
-    if (!cwd) {
+    if (!cwd || isEphemeralProjectPath(cwd)) {
       return null;
     }
 
diff --git a/src/features/recent-projects/renderer/hooks/useOpenRecentProject.ts b/src/features/recent-projects/renderer/hooks/useOpenRecentProject.ts
index 8f755deb..a4eb21d7 100644
--- a/src/features/recent-projects/renderer/hooks/useOpenRecentProject.ts
+++ b/src/features/recent-projects/renderer/hooks/useOpenRecentProject.ts
@@ -7,6 +7,7 @@ import {
 import { api } from '@renderer/api';
 import { useStore } from '@renderer/store';
 import { getWorktreeNavigationState } from '@renderer/store/utils/stateResetHelpers';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 import { createLogger } from '@shared/utils/logger';
 import { useShallow } from 'zustand/react/shallow';
 
@@ -44,8 +45,16 @@ export function useOpenRecentProject(): {
   const openSyntheticPath = useCallback(
     async (path: string, associatedPaths: readonly string[]): Promise<void> => {
       const candidatePaths = associatedPaths.length > 0 ? associatedPaths : [path];
+      const selectableCandidatePaths = candidatePaths.filter(
+        (candidatePath) => !isEphemeralProjectPath(candidatePath)
+      );
 
-      const initialMatch = findMatchingWorktree(repositoryGroups, candidatePaths);
+      if (selectableCandidatePaths.length === 0) {
+        logger.warn('Skipped ephemeral recent project path', { path });
+        return;
+      }
+
+      const initialMatch = findMatchingWorktree(repositoryGroups, selectableCandidatePaths);
       if (initialMatch) {
         navigateToMatch(initialMatch);
         return;
@@ -53,12 +62,17 @@ export function useOpenRecentProject(): {
 
       await fetchRepositoryGroups();
       const refreshedGroups = useStore.getState().repositoryGroups;
-      const refreshedMatch = findMatchingWorktree(refreshedGroups, candidatePaths);
+      const refreshedMatch = findMatchingWorktree(refreshedGroups, selectableCandidatePaths);
       if (refreshedMatch) {
         navigateToMatch(refreshedMatch);
         return;
       }
 
+      if (isEphemeralProjectPath(path)) {
+        logger.warn('Skipped adding ephemeral recent project path', { path });
+        return;
+      }
+
       await api.config.addCustomProjectPath(path);
 
       useStore.setState((state) => ({
diff --git a/src/features/recent-projects/renderer/utils/recentProjectOpenHistory.ts b/src/features/recent-projects/renderer/utils/recentProjectOpenHistory.ts
index 66c4cd3f..28d8b880 100644
--- a/src/features/recent-projects/renderer/utils/recentProjectOpenHistory.ts
+++ b/src/features/recent-projects/renderer/utils/recentProjectOpenHistory.ts
@@ -1,3 +1,5 @@
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
+
 import type { DashboardRecentProject } from '@features/recent-projects/contracts';
 
 const RECENT_PROJECT_OPEN_HISTORY_KEY = 'recent-projects:open-history';
@@ -24,6 +26,9 @@ function normalizeHistoryPath(projectPath: string): string | null {
   if (!normalizedPath) {
     return null;
   }
+  if (isEphemeralProjectPath(normalizedPath)) {
+    return null;
+  }
   if (normalizedPath !== '/' && !/^[A-Za-z]:\/$/.test(normalizedPath)) {
     while (normalizedPath.endsWith('/')) {
       normalizedPath = normalizedPath.slice(0, -1);
diff --git a/src/features/team-runtime-lanes/core/domain/buildMixedPersistedLaunchSnapshot.ts b/src/features/team-runtime-lanes/core/domain/buildMixedPersistedLaunchSnapshot.ts
index 9dc2a71b..651a0640 100644
--- a/src/features/team-runtime-lanes/core/domain/buildMixedPersistedLaunchSnapshot.ts
+++ b/src/features/team-runtime-lanes/core/domain/buildMixedPersistedLaunchSnapshot.ts
@@ -160,6 +160,9 @@ function createPrimaryLaneMemberState(params: {
     bootstrapConfirmed: runtime?.bootstrapConfirmed === true,
     hardFailure: runtime?.hardFailure === true || runtime?.launchState === 'failed_to_start',
     hardFailureReason: runtime?.hardFailureReason ?? runtime?.error,
+    pendingPermissionRequestIds: runtime?.pendingPermissionRequestIds?.length
+      ? [...new Set(runtime.pendingPermissionRequestIds)]
+      : undefined,
     firstSpawnAcceptedAt: runtime?.firstSpawnAcceptedAt,
     lastHeartbeatAt: runtime?.lastHeartbeatAt,
     lastRuntimeAliveAt: runtime?.runtimeAlive ? params.updatedAt : undefined,
diff --git a/src/main/services/runtime/CliProviderModelAvailabilityService.ts b/src/main/services/runtime/CliProviderModelAvailabilityService.ts
index 62e7f46d..c6d60986 100644
--- a/src/main/services/runtime/CliProviderModelAvailabilityService.ts
+++ b/src/main/services/runtime/CliProviderModelAvailabilityService.ts
@@ -274,7 +274,7 @@ export class CliProviderModelAvailabilityService {
       const { env, providerArgs } = await entry.cliEnvPromise;
       const { stdout } = await execCli(
         context.binaryPath,
-        [...buildProviderModelProbeArgs(modelId), ...providerArgs],
+        [...providerArgs, ...buildProviderModelProbeArgs(modelId)],
         {
           timeout: getProviderModelProbeTimeoutMs(context.provider.providerId),
           env,
diff --git a/src/main/services/team/TeamLaunchStateEvaluator.ts b/src/main/services/team/TeamLaunchStateEvaluator.ts
index a4e89493..136d4044 100644
--- a/src/main/services/team/TeamLaunchStateEvaluator.ts
+++ b/src/main/services/team/TeamLaunchStateEvaluator.ts
@@ -395,6 +395,22 @@ export function createPersistedLaunchSnapshot(params: {
   const members = params.members ?? {};
   const launchPhase = params.launchPhase ?? 'active';
 
+  for (const name of expectedMembers) {
+    if (members[name]) {
+      continue;
+    }
+    members[name] = {
+      name,
+      launchState: 'starting',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+      lastEvaluatedAt: updatedAt,
+      diagnostics: [],
+    };
+  }
+
   // When the launch is over (finished/reconciled), members still in 'starting' state
   // (never spawned — agentToolAccepted is false) are unreachable and should be marked
   // as failed. Without this, they stay as 'pending' forever, causing the UI to show
diff --git a/src/main/services/team/TeamMemberRuntimeAdvisoryService.ts b/src/main/services/team/TeamMemberRuntimeAdvisoryService.ts
index 86ad0465..70ce69e1 100644
--- a/src/main/services/team/TeamMemberRuntimeAdvisoryService.ts
+++ b/src/main/services/team/TeamMemberRuntimeAdvisoryService.ts
@@ -23,11 +23,16 @@ const RATE_LIMITED_TOKENS = [
   'cooling down',
 ];
 const AUTH_ERROR_TOKENS = [
+  'auth_unavailable',
+  'no auth available',
+  'authentication_failed',
   'unauthorized',
   'forbidden',
   'invalid api key',
   'authentication',
   'api key',
+  'does not have access',
+  'please run /login',
 ];
 const NETWORK_ERROR_TOKENS = [
   'timeout',
@@ -295,8 +300,11 @@ export class TeamMemberRuntimeAdvisoryService {
       if (start > 0) {
         lines.shift();
       }
+      const now = Date.now();
       for (let index = lines.length - 1; index >= 0; index -= 1) {
-        const advisory = this.extractApiRetryAdvisory(lines[index]?.trim() ?? '');
+        const line = lines[index]?.trim() ?? '';
+        const advisory =
+          this.extractApiRetryAdvisory(line, now) ?? this.extractApiErrorAdvisory(line, now);
         if (advisory) {
           return advisory;
         }
@@ -309,7 +317,7 @@ export class TeamMemberRuntimeAdvisoryService {
     }
   }
 
-  private extractApiRetryAdvisory(line: string): MemberRuntimeAdvisory | null {
+  private extractApiRetryAdvisory(line: string, now = Date.now()): MemberRuntimeAdvisory | null {
     if (
       !line ||
       (!line.includes('"subtype":"api_error"') && !line.includes('"subtype": "api_error"'))
@@ -351,7 +359,7 @@ export class TeamMemberRuntimeAdvisoryService {
       }
 
       const retryUntil = observedAt + retryInMs;
-      if (retryUntil <= Date.now()) {
+      if (retryUntil <= now) {
         return null;
       }
 
@@ -373,4 +381,71 @@ export class TeamMemberRuntimeAdvisoryService {
       return null;
     }
   }
+
+  private extractApiErrorAdvisory(line: string, now = Date.now()): MemberRuntimeAdvisory | null {
+    if (
+      !line ||
+      (!line.includes('"isApiErrorMessage":true') &&
+        !line.includes('"isApiErrorMessage": true') &&
+        !line.includes('"error":"authentication_failed"') &&
+        !line.includes('"error": "authentication_failed"'))
+    ) {
+      return null;
+    }
+
+    try {
+      const parsed = JSON.parse(line) as {
+        type?: string;
+        timestamp?: string;
+        error?: string;
+        isApiErrorMessage?: boolean;
+        message?: {
+          content?: Array<{ type?: string; text?: string }>;
+        };
+      };
+
+      if (parsed.type !== 'assistant') {
+        return null;
+      }
+
+      const observedAt =
+        typeof parsed.timestamp === 'string' ? Date.parse(parsed.timestamp) : Number.NaN;
+      if (!Number.isFinite(observedAt) || observedAt < now - LOOKBACK_MS) {
+        return null;
+      }
+
+      const message = this.extractAssistantText(parsed.message?.content);
+      if (!parsed.isApiErrorMessage && parsed.error !== 'authentication_failed') {
+        return null;
+      }
+      if (!message && parsed.error !== 'authentication_failed') {
+        return null;
+      }
+
+      const statusMatch = /^API Error:\s*(\d{3})/.exec(message);
+      return {
+        kind: 'api_error',
+        observedAt: new Date(observedAt).toISOString(),
+        reasonCode: classifyRetryReason(message || parsed.error),
+        ...(message ? { message } : {}),
+        ...(statusMatch ? { statusCode: Number(statusMatch[1]) } : {}),
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  private extractAssistantText(
+    content: Array<{ type?: string; text?: string }> | undefined
+  ): string {
+    if (!Array.isArray(content)) {
+      return '';
+    }
+    return content
+      .filter((item) => item.type === 'text' && typeof item.text === 'string')
+      .map((item) => item.text?.trim())
+      .filter(Boolean)
+      .join('\n')
+      .trim();
+  }
 }
diff --git a/src/main/services/team/TeamProvisioningService.ts b/src/main/services/team/TeamProvisioningService.ts
index f71b16b0..30e43f3f 100644
--- a/src/main/services/team/TeamProvisioningService.ts
+++ b/src/main/services/team/TeamProvisioningService.ts
@@ -101,12 +101,9 @@ import {
 } from '../runtime/geminiRuntimeAuth';
 import { buildProviderAwareCliEnv } from '../runtime/providerAwareCliEnv';
 import {
-  buildProviderModelProbeArgs,
   buildProviderPreflightPingArgs,
-  classifyProviderModelProbeFailure,
   getProviderModelProbeExpectedOutput,
   getProviderModelProbeTimeoutMs,
-  isProviderModelProbeSuccessOutput,
   normalizeProviderModelProbeFailureReason,
 } from '../runtime/providerModelProbe';
 import { resolveTeamProviderId } from '../runtime/providerRuntimeEnv';
@@ -438,7 +435,6 @@ const PREFLIGHT_BINARY_TIMEOUT_MS = 8000;
 const PREFLIGHT_AUTH_RETRY_DELAY_MS = 2000;
 const PREFLIGHT_AUTH_MAX_RETRIES = 2;
 const OPENCODE_PREFLIGHT_MODEL_PROBE_CONCURRENCY = 2;
-const PROVIDER_MODEL_PROBE_CONCURRENCY = 2;
 
 function applyDistinctProvisioningMemberColors<
   T extends { name: string; color?: string; removedAt?: number },
@@ -521,6 +517,10 @@ function getPreflightTimeoutMs(providerId: TeamProviderId | undefined): number {
   return getProviderModelProbeTimeoutMs(providerId);
 }
 
+function buildProviderCliCommandArgs(providerArgs: string[], args: string[]): string[] {
+  return [...providerArgs, ...args];
+}
+
 interface ProviderModelListCommandResponse {
   schemaVersion?: number;
   providers?: Record<
@@ -536,6 +536,12 @@ interface RuntimeStatusCommandResponse {
   providers?: Record<string, Partial<CliProviderStatus>>;
 }
 
+interface AuthStatusCommandResponse {
+  loggedIn?: boolean;
+  authMethod?: string | null;
+  providers?: Record<string, Partial<CliProviderStatus>>;
+}
+
 interface RuntimeProviderLaunchFacts {
   defaultModel: string | null;
   modelIds: Set<string>;
@@ -701,21 +707,6 @@ function isProbeTimeoutMessage(message: string): boolean {
   );
 }
 
-function isTransientModelProbeMessage(message: string): boolean {
-  const lower = message.toLowerCase();
-  return (
-    lower.includes('timeout') ||
-    lower.includes('timed out') ||
-    lower.includes('etimedout') ||
-    lower.includes('econnreset') ||
-    lower.includes('429') ||
-    lower.includes('500') ||
-    lower.includes('502') ||
-    lower.includes('503') ||
-    lower.includes('504')
-  );
-}
-
 function resolveRequestedLaunchModel(params: {
   providerId: TeamProviderId;
   selectedModel?: string;
@@ -1821,6 +1812,18 @@ function isMissingCwdSpawnError(message: string): boolean {
   return lower.includes('spawn ') && lower.includes(' enoent');
 }
 
+async function pathExistsAsDirectory(candidatePath: string): Promise<boolean> {
+  try {
+    const stat = await fs.promises.stat(candidatePath);
+    return stat.isDirectory();
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
 /** @deprecated Use wrapAgentBlock from @shared/constants/agentBlocks instead. */
 const wrapInAgentBlock = wrapAgentBlock;
 
@@ -3389,6 +3392,8 @@ function isTransientProbeWarning(warning: string): boolean {
   return (
     lower.includes('timeout running:') ||
     lower.includes('did not complete') ||
+    lower.includes('runtime status was unavailable') ||
+    lower.includes('runtime status check did not complete') ||
     lower.includes('timed out') ||
     lower.includes('etimedout') ||
     lower.includes('econnreset') ||
@@ -3396,14 +3401,6 @@ function isTransientProbeWarning(warning: string): boolean {
   );
 }
 
-function isRecoverableGenericPreflightWarning(warning: string): boolean {
-  const lower = warning.toLowerCase();
-  return (
-    lower.includes('preflight check failed') ||
-    lower.includes('preflight ping completed but did not return the expected pong')
-  );
-}
-
 function isBinaryProbeWarning(warning: string): boolean {
   const lower = warning.toLowerCase();
   return (
@@ -3570,7 +3567,13 @@ export class TeamProvisioningService {
     const providerArgs = params.providerArgs ?? [];
     const modelListPromise = execCli(
       params.claudePath,
-      ['model', 'list', '--json', '--provider', params.providerId, ...providerArgs],
+      buildProviderCliCommandArgs(providerArgs, [
+        'model',
+        'list',
+        '--json',
+        '--provider',
+        params.providerId,
+      ]),
       {
         cwd: params.cwd,
         env: params.env,
@@ -3581,7 +3584,13 @@ export class TeamProvisioningService {
       params.providerId === 'codex' || params.providerId === 'anthropic'
         ? execCli(
             params.claudePath,
-            ['runtime', 'status', '--json', '--provider', params.providerId, ...providerArgs],
+            buildProviderCliCommandArgs(providerArgs, [
+              'runtime',
+              'status',
+              '--json',
+              '--provider',
+              params.providerId,
+            ]),
             {
               cwd: params.cwd,
               env: params.env,
@@ -7425,8 +7434,39 @@ export class TeamProvisioningService {
         blockingMessages.push(...modelVerification.blockingMessages);
       };
 
+      const appendOneShotDiagnostic = async (): Promise<void> => {
+        if (opts?.modelVerificationMode !== 'deep') {
+          return;
+        }
+        const envResolution = await this.buildProvisioningEnv(providerId);
+        if (envResolution.warning) {
+          warnings.push(
+            providerIds.length > 1
+              ? `${providerLabel}: ${envResolution.warning}`
+              : envResolution.warning
+          );
+          return;
+        }
+        const diagnostic = await this.runProviderOneShotDiagnostic(
+          probeResult.claudePath,
+          targetCwd,
+          envResolution.env,
+          providerId,
+          envResolution.providerArgs
+        );
+        if (diagnostic.warning) {
+          warnings.push(
+            providerIds.length > 1 ? `${providerLabel}: ${diagnostic.warning}` : diagnostic.warning
+          );
+        }
+      };
+
       if (!probeResult.warning) {
+        const blockingCountBeforeModelChecks = blockingMessages.length;
         await appendSelectedModelVerification();
+        if (blockingMessages.length === blockingCountBeforeModelChecks) {
+          await appendOneShotDiagnostic();
+        }
         continue;
       }
 
@@ -7455,13 +7495,15 @@ export class TeamProvisioningService {
         } else {
           // Preflight warnings (including timeouts) should not block provisioning.
           warnings.push(prefixedWarning);
+          const blockingCountBeforeModelChecks = blockingMessages.length;
+          if (!isBlockingPreflightWarning && selectedModelIds.length > 0) {
+            await appendSelectedModelVerification();
+          }
           if (
             !isBlockingPreflightWarning &&
-            (isTransientProbeWarning(probeResult.warning) ||
-              isRecoverableGenericPreflightWarning(probeResult.warning)) &&
-            selectedModelIds.length > 0
+            blockingMessages.length === blockingCountBeforeModelChecks
           ) {
-            await appendSelectedModelVerification();
+            await appendOneShotDiagnostic();
           }
         }
       }
@@ -7826,6 +7868,89 @@ export class TeamProvisioningService {
     };
   }
 
+  private resolveProviderCompatibilityModel(params: {
+    providerId: TeamProviderId;
+    requestedModelId: string;
+    runtimeFacts: RuntimeProviderLaunchFacts;
+    limitContext: boolean;
+  }):
+    | { kind: 'available'; resolvedModelId: string | null }
+    | { kind: 'compatible'; reason: string }
+    | { kind: 'unavailable'; reason: string } {
+    const trimmedModelId = params.requestedModelId.trim();
+    if (!trimmedModelId) {
+      return {
+        kind: 'unavailable',
+        reason: 'Selected model id is empty.',
+      };
+    }
+
+    if (isDefaultProviderModelSelection(trimmedModelId)) {
+      return {
+        kind: 'available',
+        resolvedModelId: params.runtimeFacts.defaultModel,
+      };
+    }
+
+    const availableModels = params.runtimeFacts.modelIds;
+    let resolvedModelId: string | null = availableModels.has(trimmedModelId)
+      ? trimmedModelId
+      : null;
+
+    if (!resolvedModelId && params.providerId === 'anthropic') {
+      resolvedModelId =
+        resolveAnthropicLaunchModel({
+          selectedModel: trimmedModelId,
+          limitContext: params.limitContext,
+          availableLaunchModels: availableModels,
+          defaultLaunchModel: params.runtimeFacts.defaultModel,
+        }) ?? null;
+    }
+
+    if (!resolvedModelId && !trimmedModelId.includes('/')) {
+      const scopedMatches = Array.from(availableModels).filter(
+        (candidate) => candidate.split('/').at(-1) === trimmedModelId
+      );
+      if (scopedMatches.length === 1) {
+        resolvedModelId = scopedMatches[0];
+      } else if (scopedMatches.length > 1) {
+        return {
+          kind: 'unavailable',
+          reason:
+            `Selected model ${trimmedModelId} matched multiple live provider models: ` +
+            scopedMatches.join(', '),
+        };
+      }
+    }
+
+    if (resolvedModelId && (availableModels.size === 0 || availableModels.has(resolvedModelId))) {
+      return {
+        kind: 'available',
+        resolvedModelId,
+      };
+    }
+
+    const dynamicCatalog = params.runtimeFacts.runtimeCapabilities?.modelCatalog?.dynamic === true;
+    const hasAuthoritativeCatalog =
+      availableModels.size > 0 ||
+      params.runtimeFacts.modelCatalog != null ||
+      params.runtimeFacts.runtimeCapabilities?.modelCatalog?.dynamic === false;
+
+    if (dynamicCatalog || !hasAuthoritativeCatalog) {
+      return {
+        kind: 'compatible',
+        reason: dynamicCatalog
+          ? 'Runtime catalog allows dynamic model launch.'
+          : 'Runtime model catalog was unavailable.',
+      };
+    }
+
+    return {
+      kind: 'unavailable',
+      reason: `Selected model ${trimmedModelId} was not found in the live provider catalog.`,
+    };
+  }
+
   private async verifySelectedProviderModels({
     claudePath,
     cwd,
@@ -7861,39 +7986,28 @@ export class TeamProvisioningService {
       providerArgs,
       limitContext,
     });
-    const probeOutcomeByResolvedModelId = new Map<
-      string,
-      { kind: 'ready' | 'warning' | 'unavailable'; reason?: string }
-    >();
-    let resolvedDefaultModelId: string | null | undefined;
-    const plannedModels: (
-      | { requestedModelId: string; targetModelId: string }
-      | {
-          requestedModelId: string;
-          immediateOutcome: { kind: 'ready' | 'warning' | 'unavailable'; reason?: string };
-        }
-    )[] = [];
 
     const recordOutcome = (
       requestedModelId: string,
-      outcome: { kind: 'ready' | 'warning' | 'unavailable'; reason?: string }
+      outcome:
+        | { kind: 'available'; resolvedModelId: string | null }
+        | { kind: 'compatible'; reason: string }
+        | { kind: 'unavailable'; reason: string }
     ): void => {
-      if (outcome.kind === 'ready') {
-        details.push(`Selected model ${requestedModelId} verified for launch.`);
+      if (outcome.kind === 'available') {
+        details.push(`Selected model ${requestedModelId} is available for launch.`);
         return;
       }
-      if (outcome.kind === 'unavailable') {
-        blockingMessages.push(
-          `Selected model ${requestedModelId} is unavailable. ${outcome.reason ?? 'Model verification failed'}`
+      if (outcome.kind === 'compatible') {
+        details.push(
+          `Selected model ${requestedModelId} is compatible. Deep verification pending.`
         );
         return;
       }
-      warnings.push(
-        `Selected model ${requestedModelId} could not be verified. ${outcome.reason ?? 'Model verification failed'}`
-      );
+      blockingMessages.push(`Selected model ${requestedModelId} is unavailable. ${outcome.reason}`);
     };
 
-    appendPreflightDebugLog('provider_model_probe_batch_start', {
+    appendPreflightDebugLog('provider_model_catalog_check_start', {
       providerId,
       cwd,
       modelIds,
@@ -7905,162 +8019,23 @@ export class TeamProvisioningService {
         continue;
       }
 
-      let targetModelId = label;
-      if (isDefaultProviderModelSelection(label)) {
-        if (resolvedDefaultModelId === undefined) {
-          resolvedDefaultModelId = runtimeFacts.defaultModel;
-          if (!resolvedDefaultModelId) {
-            try {
-              resolvedDefaultModelId = await this.resolveProviderDefaultModel(
-                claudePath,
-                cwd,
-                providerId,
-                env,
-                providerArgs,
-                limitContext
-              );
-            } catch {
-              resolvedDefaultModelId = null;
-            }
-          }
-        }
-        if (!resolvedDefaultModelId) {
-          plannedModels.push({
-            requestedModelId: label,
-            immediateOutcome: {
-              kind: 'warning',
-              reason: 'Could not resolve the runtime default model',
-            },
-          });
-          continue;
-        }
-        targetModelId = resolvedDefaultModelId;
-      } else if (providerId === 'anthropic') {
-        const resolvedAnthropicModel = resolveAnthropicLaunchModel({
-          selectedModel: label,
+      recordOutcome(
+        label,
+        this.resolveProviderCompatibilityModel({
+          providerId,
+          requestedModelId: label,
+          runtimeFacts,
           limitContext,
-          availableLaunchModels: runtimeFacts.modelIds,
-          defaultLaunchModel: runtimeFacts.defaultModel,
-        });
-        if (resolvedAnthropicModel) {
-          targetModelId = resolvedAnthropicModel;
-        }
-      }
-
-      plannedModels.push({
-        requestedModelId: label,
-        targetModelId,
-      });
+        })
+      );
     }
 
-    const uniqueTargetModelIds = Array.from(
-      new Set(
-        plannedModels.flatMap((entry) => ('targetModelId' in entry ? [entry.targetModelId] : []))
-      )
-    );
-
-    const runProbeForModel = async (
-      targetModelId: string
-    ): Promise<{ kind: 'ready' | 'warning' | 'unavailable'; reason?: string }> => {
-      const cachedOutcome = probeOutcomeByResolvedModelId.get(targetModelId);
-      if (cachedOutcome) {
-        return cachedOutcome;
-      }
-
-      const probeStartedAt = Date.now();
-      try {
-        const result = await this.spawnProbe(
-          claudePath,
-          [...buildProviderModelProbeArgs(targetModelId), ...providerArgs],
-          cwd,
-          env,
-          getProviderModelProbeTimeoutMs(providerId),
-          {
-            resolveOnOutputMatch: ({ stdout, stderr }) =>
-              isProviderModelProbeSuccessOutput(`${stdout}\n${stderr}`),
-          }
-        );
-        const combinedOutput = buildCombinedLogs(result.stdout, result.stderr).trim();
-        const outcome =
-          result.exitCode === 0 && isProviderModelProbeSuccessOutput(combinedOutput)
-            ? ({ kind: 'ready' } as const)
-            : classifyProviderModelProbeFailure(
-                  combinedOutput || `Probe exited with code ${result.exitCode ?? 'unknown'}.`
-                ) === 'unavailable'
-              ? ({
-                  kind: 'unavailable',
-                  reason: normalizeProviderModelProbeFailureReason(
-                    combinedOutput || `Probe exited with code ${result.exitCode ?? 'unknown'}.`
-                  ),
-                } as const)
-              : ({
-                  kind: 'warning',
-                  reason: normalizeProviderModelProbeFailureReason(
-                    combinedOutput || `Probe exited with code ${result.exitCode ?? 'unknown'}.`
-                  ),
-                } as const);
-        probeOutcomeByResolvedModelId.set(targetModelId, outcome);
-        appendPreflightDebugLog('provider_model_probe_result', {
-          providerId,
-          cwd,
-          targetModelId,
-          durationMs: Date.now() - probeStartedAt,
-          outcome,
-        });
-        return outcome;
-      } catch (error) {
-        const message = error instanceof Error ? error.message.trim() : String(error).trim();
-        const normalizedMessage = normalizeProviderModelProbeFailureReason(message);
-        const outcome =
-          classifyProviderModelProbeFailure(message) === 'unavailable' &&
-          !isTransientModelProbeMessage(message)
-            ? ({ kind: 'unavailable', reason: normalizedMessage } as const)
-            : ({ kind: 'warning', reason: normalizedMessage } as const);
-        probeOutcomeByResolvedModelId.set(targetModelId, outcome);
-        appendPreflightDebugLog('provider_model_probe_result', {
-          providerId,
-          cwd,
-          targetModelId,
-          durationMs: Date.now() - probeStartedAt,
-          outcome,
-        });
-        return outcome;
-      }
-    };
-
-    const workerCount = Math.min(PROVIDER_MODEL_PROBE_CONCURRENCY, uniqueTargetModelIds.length);
-    let nextProbeIndex = 0;
-    await Promise.all(
-      Array.from({ length: workerCount }, async () => {
-        while (true) {
-          const currentIndex = nextProbeIndex;
-          nextProbeIndex += 1;
-          if (currentIndex >= uniqueTargetModelIds.length) {
-            return;
-          }
-          await runProbeForModel(uniqueTargetModelIds[currentIndex]);
-        }
-      })
-    );
-
-    for (const entry of plannedModels) {
-      if ('immediateOutcome' in entry) {
-        recordOutcome(entry.requestedModelId, entry.immediateOutcome);
-        continue;
-      }
-
-      const outcome = probeOutcomeByResolvedModelId.get(entry.targetModelId) ?? {
-        kind: 'warning' as const,
-        reason: 'Model verification failed',
-      };
-      recordOutcome(entry.requestedModelId, outcome);
-    }
-
-    appendPreflightDebugLog('provider_model_probe_batch_complete', {
+    appendPreflightDebugLog('provider_model_catalog_check_complete', {
       providerId,
       cwd,
       modelIds,
       durationMs: Date.now() - startedAt,
+      modelCount: runtimeFacts.modelIds.size,
       details,
       warnings,
       blockingMessages,
@@ -8079,7 +8054,7 @@ export class TeamProvisioningService {
   ): Promise<string | null> {
     const { stdout } = await execCli(
       claudePath,
-      ['model', 'list', '--json', '--provider', 'all', ...providerArgs],
+      buildProviderCliCommandArgs(providerArgs, ['model', 'list', '--json', '--provider', 'all']),
       {
         cwd,
         env,
@@ -11877,6 +11852,48 @@ export class TeamProvisioningService {
     });
   }
 
+  private filterRemovedMembersFromLaunchSnapshot(
+    snapshot: PersistedTeamLaunchSnapshot,
+    metaMembers: Awaited<ReturnType<TeamMembersMetaStore['getMembers']>>
+  ): PersistedTeamLaunchSnapshot {
+    const removedNames = new Set(
+      metaMembers
+        .filter((member) => Boolean(member.removedAt))
+        .map((member) => member.name?.trim().toLowerCase() ?? '')
+        .filter((name) => name.length > 0)
+    );
+    if (removedNames.size === 0) {
+      return snapshot;
+    }
+
+    const isRemoved = (name: string | undefined): boolean => {
+      const normalized = name?.trim().toLowerCase() ?? '';
+      return normalized.length > 0 && removedNames.has(normalized);
+    };
+    const expectedMembers = this.getPersistedLaunchMemberNames(snapshot).filter(
+      (name) => !isRemoved(name)
+    );
+    const members: Record<string, PersistedTeamLaunchMemberState> = {};
+    for (const [memberName, member] of Object.entries(snapshot.members)) {
+      if (isRemoved(memberName) || isRemoved(member.name)) {
+        continue;
+      }
+      members[memberName] = { ...member };
+    }
+
+    return createPersistedLaunchSnapshot({
+      teamName: snapshot.teamName,
+      expectedMembers,
+      bootstrapExpectedMembers: snapshot.bootstrapExpectedMembers?.filter(
+        (name) => !isRemoved(name)
+      ),
+      leadSessionId: snapshot.leadSessionId,
+      launchPhase: snapshot.launchPhase,
+      members,
+      updatedAt: snapshot.updatedAt,
+    });
+  }
+
   private findEffectiveRunMemberModel(
     run: ProvisioningRun | null,
     memberName: string
@@ -13234,25 +13251,39 @@ export class TeamProvisioningService {
   }> {
     const bootstrapSnapshot = await readBootstrapLaunchSnapshot(teamName);
     const persisted = await this.launchStateStore.read(teamName);
+    const metaMembers = await this.membersMetaStore.getMembers(teamName).catch(() => []);
     const recoveredMixedSnapshot = await this.recoverStaleMixedSecondaryLaunchSnapshot(
       teamName,
       bootstrapSnapshot,
       persisted
     );
     if (recoveredMixedSnapshot) {
+      const filteredSnapshot = this.filterRemovedMembersFromLaunchSnapshot(
+        recoveredMixedSnapshot,
+        metaMembers
+      );
       return {
-        snapshot: recoveredMixedSnapshot,
-        statuses: snapshotToMemberSpawnStatuses(recoveredMixedSnapshot),
+        snapshot: filteredSnapshot,
+        statuses: snapshotToMemberSpawnStatuses(filteredSnapshot),
       };
     }
-    const preferredSnapshot = choosePreferredLaunchSnapshot(bootstrapSnapshot, persisted);
-    if (preferredSnapshot && preferredSnapshot === bootstrapSnapshot) {
+    const filteredBootstrapSnapshot = bootstrapSnapshot
+      ? this.filterRemovedMembersFromLaunchSnapshot(bootstrapSnapshot, metaMembers)
+      : null;
+    const filteredPersisted = persisted
+      ? this.filterRemovedMembersFromLaunchSnapshot(persisted, metaMembers)
+      : null;
+    const preferredSnapshot = choosePreferredLaunchSnapshot(
+      filteredBootstrapSnapshot,
+      filteredPersisted
+    );
+    if (preferredSnapshot && preferredSnapshot === filteredBootstrapSnapshot) {
       return {
         snapshot: preferredSnapshot,
         statuses: snapshotToMemberSpawnStatuses(preferredSnapshot),
       };
     }
-    if (!persisted) {
+    if (!filteredPersisted) {
       return { snapshot: null, statuses: {} };
     }
 
@@ -13287,8 +13318,8 @@ export class TeamProvisioningService {
     }
 
     const liveAgentNames = await this.getLiveTeamAgentNames(teamName);
-    const nextMembers = { ...persisted.members };
-    const persistedMemberNames = this.getPersistedLaunchMemberNames(persisted);
+    const nextMembers = { ...filteredPersisted.members };
+    const persistedMemberNames = this.getPersistedLaunchMemberNames(filteredPersisted);
     const now = nowIso();
     for (const expected of persistedMemberNames) {
       const bootstrapMember = bootstrapSnapshot?.members[expected];
@@ -13431,8 +13462,8 @@ export class TeamProvisioningService {
     const reconciled = createPersistedLaunchSnapshot({
       teamName,
       expectedMembers: persistedMemberNames,
-      leadSessionId: persisted.leadSessionId,
-      launchPhase: persisted.launchPhase === 'active' ? 'active' : 'reconciled',
+      leadSessionId: filteredPersisted.leadSessionId,
+      launchPhase: filteredPersisted.launchPhase === 'active' ? 'active' : 'reconciled',
       members: nextMembers,
       updatedAt: now,
     });
@@ -18482,11 +18513,11 @@ export class TeamProvisioningService {
 
   /**
    * Two-stage preflight check:
-   * 1. `claude --version` — verifies binary is executable and returns version info.
-   *    (currently disabled for speed; keep commented for debugging)
-   * 2. `claude -p "ping"` — verifies that `-p` mode is actually authenticated.
-   *    This catches the common case where interactive `claude` works (OAuth/keychain)
-   *    but `-p` mode fails with "Not logged in" due to missing env vars.
+   * 1. `claude --version` verifies the binary is executable.
+   * 2. Runtime control-plane commands verify provider auth/team-launch readiness.
+   *
+   * Do not use `-p` here: full print mode can initialize MCP/plugin/LSP startup context
+   * before the first response, which makes Create Team preflight slow and flaky.
    */
   private async probeClaudeRuntime(
     claudePath: string,
@@ -18497,6 +18528,12 @@ export class TeamProvisioningService {
   ): Promise<{ warning?: string }> {
     const resolvedProviderId = resolveTeamProviderId(providerId);
     const cliCommandLabel = getConfiguredCliCommandLabel();
+    if (!(await pathExistsAsDirectory(cwd))) {
+      return {
+        warning: `Working directory does not exist: ${cwd}`,
+      };
+    }
+
     try {
       const versionProbe = await this.spawnProbe(
         claudePath,
@@ -18515,7 +18552,7 @@ export class TeamProvisioningService {
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (isMissingCwdSpawnError(message)) {
+      if (isMissingCwdSpawnError(message) && !(await pathExistsAsDirectory(cwd))) {
         return {
           warning: `Working directory does not exist: ${cwd}`,
         };
@@ -18537,30 +18574,221 @@ export class TeamProvisioningService {
       };
     }
 
-    // Stage 1: verify binary works (awaited first for clearer errors)
-    // Important: keep this sequential with Stage 2 to avoid auth/credential-store races
-    // when multiple `claude` processes start simultaneously (most visible on Windows).
-    // const versionProbe = await this.spawnProbe(
-    //   claudePath,
-    //   ['--version'],
-    //   cwd,
-    //   env,
-    //   CLI_PREPARE_TIMEOUT_MS
-    // );
-    // if (versionProbe.exitCode !== 0) {
-    //   const errorText =
-    //     buildCombinedLogs(versionProbe.stdout, versionProbe.stderr) ||
-    //     `Claude CLI exited with code ${versionProbe.exitCode ?? 'unknown'} during warm-up`;
-    //   throw new Error(`Failed to warm up Claude CLI: ${errorText}`);
-    // }
+    if (resolvedProviderId === 'anthropic' || resolvedProviderId === 'codex') {
+      return await this.probeProviderRuntimeControlPlane({
+        claudePath,
+        cwd,
+        env,
+        providerId: resolvedProviderId,
+        providerArgs,
+      });
+    }
+
+    return {};
+  }
+
+  private buildRuntimeProviderReadinessWarning(
+    providerId: TeamProviderId,
+    providerStatus: Partial<CliProviderStatus> | null | undefined
+  ): string | null {
+    const providerLabel = getTeamProviderLabel(providerId);
+    const detail = [providerStatus?.statusMessage?.trim(), providerStatus?.detailMessage?.trim()]
+      .filter((entry): entry is string => Boolean(entry))
+      .join(' ');
+
+    if (!providerStatus) {
+      return `${providerLabel} provider is not configured for runtime use. Runtime status did not include this provider.`;
+    }
+    if (providerStatus.supported === false) {
+      return `${providerLabel} provider is not configured for runtime use.${
+        detail ? ` ${detail}` : ''
+      }`;
+    }
+    if (providerStatus.authenticated === false) {
+      return `${providerLabel} provider is not authenticated.${detail ? ` ${detail}` : ''}`;
+    }
+    if (providerStatus.capabilities?.teamLaunch === false) {
+      return `${providerLabel} provider is not configured for runtime use. Team launch is unavailable.${
+        detail ? ` ${detail}` : ''
+      }`;
+    }
+
+    return null;
+  }
+
+  private extractAuthStatusReadiness(
+    providerId: TeamProviderId,
+    parsed: AuthStatusCommandResponse
+  ): {
+    authenticated: boolean | null;
+    providerStatus: Partial<CliProviderStatus> | null;
+  } {
+    const providerStatus = parsed.providers?.[providerId] ?? null;
+    if (typeof providerStatus?.authenticated === 'boolean') {
+      return {
+        authenticated: providerStatus.authenticated,
+        providerStatus,
+      };
+    }
+    if (typeof parsed.loggedIn === 'boolean') {
+      return {
+        authenticated: parsed.loggedIn,
+        providerStatus,
+      };
+    }
+    return {
+      authenticated: null,
+      providerStatus,
+    };
+  }
+
+  private async probeProviderRuntimeControlPlane({
+    claudePath,
+    cwd,
+    env,
+    providerId,
+    providerArgs,
+  }: {
+    claudePath: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    providerId: TeamProviderId;
+    providerArgs: string[];
+  }): Promise<{ warning?: string }> {
+    const cliCommandLabel = getConfiguredCliCommandLabel();
+    const providerLabel = getTeamProviderLabel(providerId);
+
+    try {
+      const runtimeStatus = await execCli(
+        claudePath,
+        buildProviderCliCommandArgs(providerArgs, [
+          'runtime',
+          'status',
+          '--json',
+          '--provider',
+          providerId,
+        ]),
+        {
+          cwd,
+          env,
+          timeout: 8_000,
+        }
+      );
+      const parsed = extractJsonObjectFromCli<RuntimeStatusCommandResponse>(runtimeStatus.stdout);
+      const providerStatus = parsed.providers?.[providerId] ?? null;
+      const warning = this.buildRuntimeProviderReadinessWarning(providerId, providerStatus);
+      appendPreflightDebugLog('provider_runtime_control_plane_status', {
+        providerId,
+        cwd,
+        ready: !warning,
+        authenticated: providerStatus?.authenticated,
+        teamLaunch: providerStatus?.capabilities?.teamLaunch,
+        oneShot: providerStatus?.capabilities?.oneShot,
+        warning,
+      });
+      return warning ? { warning } : {};
+    } catch (runtimeStatusError) {
+      const runtimeStatusMessage =
+        runtimeStatusError instanceof Error
+          ? runtimeStatusError.message
+          : String(runtimeStatusError);
+      try {
+        const authStatus = await execCli(
+          claudePath,
+          buildProviderCliCommandArgs(providerArgs, [
+            'auth',
+            'status',
+            '--json',
+            '--provider',
+            providerId,
+          ]),
+          {
+            cwd,
+            env,
+            timeout: 8_000,
+          }
+        );
+        const parsed = extractJsonObjectFromCli<AuthStatusCommandResponse>(authStatus.stdout);
+        const authReadiness = this.extractAuthStatusReadiness(providerId, parsed);
+        const readinessWarning = authReadiness.providerStatus
+          ? this.buildRuntimeProviderReadinessWarning(providerId, authReadiness.providerStatus)
+          : null;
+        if (authReadiness.authenticated === false || readinessWarning) {
+          const authWarning =
+            readinessWarning ??
+            `${providerLabel} provider is not authenticated. Runtime auth status reported logged out.`;
+          appendPreflightDebugLog('provider_runtime_control_plane_auth_fallback', {
+            providerId,
+            cwd,
+            ready: false,
+            runtimeStatusError: runtimeStatusMessage,
+            warning: authWarning,
+          });
+          return { warning: authWarning };
+        }
+        if (authReadiness.authenticated === true) {
+          const warning =
+            `${cliCommandLabel} runtime status was unavailable, but auth status passed. ` +
+            `Proceeding with catalog checks. Details: ${runtimeStatusMessage}`;
+          appendPreflightDebugLog('provider_runtime_control_plane_auth_fallback', {
+            providerId,
+            cwd,
+            ready: true,
+            runtimeStatusError: runtimeStatusMessage,
+            warning,
+          });
+          return { warning };
+        }
+      } catch (authStatusError) {
+        const authStatusMessage =
+          authStatusError instanceof Error ? authStatusError.message : String(authStatusError);
+        appendPreflightDebugLog('provider_runtime_control_plane_auth_fallback', {
+          providerId,
+          cwd,
+          ready: false,
+          runtimeStatusError: runtimeStatusMessage,
+          authStatusError: authStatusMessage,
+        });
+        return {
+          warning:
+            `${cliCommandLabel} runtime status check did not complete. ` +
+            `Proceeding with catalog checks. Details: ${runtimeStatusMessage}; auth status failed: ${authStatusMessage}`,
+        };
+      }
+
+      return {
+        warning:
+          `${cliCommandLabel} runtime status was unavailable and auth status did not report ${providerLabel} authentication. ` +
+          `Proceeding with catalog checks. Details: ${runtimeStatusMessage}`,
+      };
+    }
+  }
+
+  private async runProviderOneShotDiagnostic(
+    claudePath: string,
+    cwd: string,
+    env: NodeJS.ProcessEnv,
+    providerId: TeamProviderId | undefined = 'anthropic',
+    providerArgs: string[] = []
+  ): Promise<{ warning?: string }> {
+    const cliCommandLabel = getConfiguredCliCommandLabel();
+    const resolvedProviderId = resolveTeamProviderId(providerId);
+
+    if (!(await pathExistsAsDirectory(cwd))) {
+      appendPreflightDebugLog('provider_one_shot_diagnostic_skipped', {
+        providerId: resolvedProviderId,
+        cwd,
+        reason: 'missing_cwd',
+      });
+      return {};
+    }
 
-    // Stage 2: verify `-p` mode auth actually works (with retry for stale locks after Ctrl+C)
     for (let attempt = 1; attempt <= PREFLIGHT_AUTH_MAX_RETRIES; attempt++) {
       let pingProbe: { exitCode: number | null; stdout: string; stderr: string } | null = null;
       try {
         pingProbe = await this.spawnProbe(
           claudePath,
-          [...getPreflightPingArgs(providerId), ...providerArgs],
+          buildProviderCliCommandArgs(providerArgs, getPreflightPingArgs(providerId)),
           cwd,
           env,
           getPreflightTimeoutMs(providerId),
@@ -18575,16 +18803,19 @@ export class TeamProvisioningService {
         const message = error instanceof Error ? error.message : String(error);
         if (!isProbeTimeoutMessage(message) && attempt < PREFLIGHT_AUTH_MAX_RETRIES) {
           logger.warn(
-            `Preflight ping failed (attempt ${attempt}/${PREFLIGHT_AUTH_MAX_RETRIES}), ` +
+            `One-shot diagnostic failed (attempt ${attempt}/${PREFLIGHT_AUTH_MAX_RETRIES}), ` +
               `retrying in ${PREFLIGHT_AUTH_RETRY_DELAY_MS}ms: ${message}`
           );
           await new Promise((resolve) => setTimeout(resolve, PREFLIGHT_AUTH_RETRY_DELAY_MS));
           continue;
         }
+        const normalizedMessage = normalizeProviderModelProbeFailureReason(message);
         return {
           warning:
-            `Preflight check for \`${cliCommandLabel} -p\` did not complete. ` +
-            `Proceeding anyway. Details: ${message}`,
+            (isProbeTimeoutMessage(message)
+              ? 'One-shot diagnostic timed out after runtime readiness passed. '
+              : 'One-shot diagnostic did not complete after runtime readiness passed. ') +
+            `This does not mark selected models unavailable. Details: ${normalizedMessage}`,
         };
       }
 
@@ -18593,8 +18824,8 @@ export class TeamProvisioningService {
 
       if (isAuthFailure && attempt < PREFLIGHT_AUTH_MAX_RETRIES) {
         logger.warn(
-          `Preflight auth failure detected (attempt ${attempt}/${PREFLIGHT_AUTH_MAX_RETRIES}), ` +
-            `retrying in ${PREFLIGHT_AUTH_RETRY_DELAY_MS}ms — likely stale locks from interrupted process`
+          `One-shot diagnostic auth failure detected (attempt ${attempt}/${PREFLIGHT_AUTH_MAX_RETRIES}), ` +
+            `retrying in ${PREFLIGHT_AUTH_RETRY_DELAY_MS}ms - likely stale locks from interrupted process`
         );
         await new Promise((resolve) => setTimeout(resolve, PREFLIGHT_AUTH_RETRY_DELAY_MS));
         continue;
@@ -18617,7 +18848,11 @@ export class TeamProvisioningService {
           : normalizedOutput
             ? `${cliCommandLabel} preflight check failed (exit code ${pingProbe.exitCode ?? 'unknown'}). Details: ${normalizedOutput}`
             : `${cliCommandLabel} preflight check failed (exit code ${pingProbe.exitCode ?? 'unknown'}).`;
-        return { warning: hint };
+        return {
+          warning:
+            'One-shot diagnostic failed after runtime readiness passed. ' +
+            `This does not mark selected models unavailable. Details: ${hint}`,
+        };
       }
 
       const pongCandidate = pingProbe.stdout.trim() || pingProbe.stderr.trim();
@@ -18627,14 +18862,15 @@ export class TeamProvisioningService {
       if (!isPong) {
         return {
           warning:
-            'Preflight ping completed but did not return the expected PONG. ' +
+            'One-shot diagnostic completed but did not return the expected PONG. ' +
+            'This does not mark selected models unavailable. ' +
             `Output: ${combinedOutput || '(empty)'}`,
         };
       }
 
       if (attempt > 1) {
         logger.info(
-          `Preflight auth succeeded on attempt ${attempt} (previous attempt had auth failure)`
+          `One-shot diagnostic succeeded on attempt ${attempt} (previous attempt had auth failure)`
         );
       }
       return {};
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index fc9771c4..9a564a02 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -6,22 +6,66 @@ import { ConfirmDialog } from './components/common/ConfirmDialog';
 import { ContextSwitchOverlay } from './components/common/ContextSwitchOverlay';
 import { ErrorBoundary } from './components/common/ErrorBoundary';
 import { TabbedLayout } from './components/layout/TabbedLayout';
+import { type SplashSceneHandle, startSplashScene } from './components/splash/splashScene';
 import { ToolApprovalSheet } from './components/team/ToolApprovalSheet';
 import { useTheme } from './hooks/useTheme';
 import { api } from './api';
 import { useStore } from './store';
 
+declare global {
+  interface Window {
+    __claudeTeamsSplashEnhancedStartedAt?: number;
+    __claudeTeamsSplashScene?: SplashSceneHandle;
+    __claudeTeamsSplashStartedAt?: number;
+  }
+}
+
+const SPLASH_MIN_DURATION_MS = 1600;
+const SPLASH_ENHANCED_HOLD_MS = 600;
+const SPLASH_FADE_MS = 480;
+const SPLASH_REDUCED_MIN_DURATION_MS = 320;
+const SPLASH_REDUCED_HOLD_MS = 120;
+const SPLASH_REDUCED_FADE_MS = 180;
+
 export const App = (): React.JSX.Element => {
   // Initialize theme on app load
   useTheme();
 
-  // Dismiss splash screen once React is ready
+  // Upgrade the static preload splash, then dismiss it after the scene is visible.
   useEffect(() => {
     const splash = document.getElementById('splash');
     if (splash) {
-      splash.style.opacity = '0';
-      setTimeout(() => splash.remove(), 300);
+      const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+      const scene = window.__claudeTeamsSplashScene ?? startSplashScene(splash, { reducedMotion });
+      const startedAt = window.__claudeTeamsSplashStartedAt ?? performance.now();
+      const enhancedStartedAt = window.__claudeTeamsSplashEnhancedStartedAt ?? performance.now();
+      const elapsed = performance.now() - startedAt;
+      const enhancedElapsed = performance.now() - enhancedStartedAt;
+      const minDuration = reducedMotion ? SPLASH_REDUCED_MIN_DURATION_MS : SPLASH_MIN_DURATION_MS;
+      const enhancedHold = reducedMotion ? SPLASH_REDUCED_HOLD_MS : SPLASH_ENHANCED_HOLD_MS;
+      const fadeDuration = reducedMotion ? SPLASH_REDUCED_FADE_MS : SPLASH_FADE_MS;
+      const exitDelay = Math.max(minDuration - elapsed, enhancedHold - enhancedElapsed, 0);
+      let removeTimer: number | undefined;
+
+      const exitTimer = window.setTimeout(() => {
+        splash.classList.add('splash-exiting');
+        removeTimer = window.setTimeout(() => {
+          scene.stop();
+          window.__claudeTeamsSplashScene = undefined;
+          window.__claudeTeamsSplashEnhancedStartedAt = undefined;
+          splash.remove();
+        }, fadeDuration);
+      }, exitDelay);
+
+      return () => {
+        window.clearTimeout(exitTimer);
+        if (removeTimer !== undefined) {
+          window.clearTimeout(removeTimer);
+        }
+      };
     }
+
+    return undefined;
   }, []);
 
   // Initialize context system lazily when SSH connection state changes.
diff --git a/src/renderer/components/splash/splashScene.ts b/src/renderer/components/splash/splashScene.ts
new file mode 100644
index 00000000..fa419d35
--- /dev/null
+++ b/src/renderer/components/splash/splashScene.ts
@@ -0,0 +1,897 @@
+export interface SplashSceneHandle {
+  stop: () => void;
+}
+
+export interface SplashSceneOptions {
+  reducedMotion?: boolean;
+}
+
+declare global {
+  interface Window {
+    __claudeTeamsSplashEnhancedStartedAt?: number;
+    __claudeTeamsSplashScene?: SplashSceneHandle;
+  }
+}
+
+interface Point {
+  x: number;
+  y: number;
+}
+
+interface RobotNode extends Point {
+  teamIndex: number;
+  robotIndex: number;
+  color: string;
+  size: number;
+  bob: number;
+}
+
+interface TeamNode {
+  index: number;
+  center: Point;
+  color: string;
+  radius: number;
+  robots: RobotNode[];
+}
+
+interface DepthParticle {
+  x: number;
+  y: number;
+  size: number;
+  speed: number;
+  phase: number;
+  alpha: number;
+}
+
+interface Palette {
+  isLight: boolean;
+  centerGlow: string;
+  teamColors: string[];
+  teamLineAlpha: number;
+  robotBody: string;
+  robotShade: string;
+  robotEye: string;
+  messageAccent: string;
+  particle: string;
+}
+
+const TAU = Math.PI * 2;
+const TEAM_MEMBER_COUNTS = [4, 3, 5] as const;
+const MAX_DPR = 2;
+
+export function startSplashScene(
+  splash: HTMLElement,
+  options: SplashSceneOptions = {}
+): SplashSceneHandle {
+  const existingScene = window.__claudeTeamsSplashScene;
+  if (existingScene && splash.querySelector('#splash-enhanced-canvas')) {
+    return existingScene;
+  }
+
+  const previousCanvas = splash.querySelector<HTMLCanvasElement>('#splash-enhanced-canvas');
+  previousCanvas?.remove();
+
+  const canvas = document.createElement('canvas');
+  canvas.id = 'splash-enhanced-canvas';
+  canvas.setAttribute('aria-hidden', 'true');
+  splash.appendChild(canvas);
+
+  const ctx = canvas.getContext('2d', { alpha: true });
+  if (!ctx) {
+    const emptyHandle = {
+      stop: () => {
+        canvas.remove();
+      },
+    };
+    return emptyHandle;
+  }
+
+  const reducedMotion =
+    options.reducedMotion ?? window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+  const state = {
+    width: 1,
+    height: 1,
+    dpr: 1,
+    particles: [] as DepthParticle[],
+    running: true,
+    frameId: 0,
+    startedAt: performance.now(),
+  };
+
+  const resize = (): void => {
+    const rect = splash.getBoundingClientRect();
+    const width = Math.max(1, Math.round(rect.width));
+    const height = Math.max(1, Math.round(rect.height));
+    const dpr = Math.min(MAX_DPR, window.devicePixelRatio || 1);
+
+    if (state.width === width && state.height === height && state.dpr === dpr) {
+      return;
+    }
+
+    state.width = width;
+    state.height = height;
+    state.dpr = dpr;
+    canvas.width = Math.ceil(width * dpr);
+    canvas.height = Math.ceil(height * dpr);
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    state.particles = createDepthParticles(width, height);
+  };
+
+  const render = (now: number): void => {
+    if (!state.running) return;
+
+    resize();
+    const time = (now - state.startedAt) / 1000;
+    drawScene(ctx, state.width, state.height, time, state.particles, reducedMotion);
+
+    if (!reducedMotion) {
+      state.frameId = window.requestAnimationFrame(render);
+    }
+  };
+
+  const onResize = (): void => resize();
+  window.addEventListener('resize', onResize);
+  resize();
+  render(performance.now());
+
+  const handle: SplashSceneHandle = {
+    stop: () => {
+      state.running = false;
+      window.cancelAnimationFrame(state.frameId);
+      window.removeEventListener('resize', onResize);
+      canvas.remove();
+      if (window.__claudeTeamsSplashScene === handle) {
+        window.__claudeTeamsSplashScene = undefined;
+        window.__claudeTeamsSplashEnhancedStartedAt = undefined;
+      }
+    },
+  };
+  window.__claudeTeamsSplashScene = handle;
+  window.__claudeTeamsSplashEnhancedStartedAt = performance.now();
+
+  return handle;
+}
+
+function drawScene(
+  ctx: CanvasRenderingContext2D,
+  width: number,
+  height: number,
+  time: number,
+  particles: DepthParticle[],
+  reducedMotion: boolean
+): void {
+  ctx.clearRect(0, 0, width, height);
+  const palette = resolvePalette();
+  const mobile = width < 560 || height < 620;
+  const sceneTime = reducedMotion ? 1.2 : time;
+  const teams = buildTeams(width, height, sceneTime, mobile, palette);
+  const center = getCenter(width, height, mobile);
+
+  drawAmbientField(ctx, width, height, sceneTime, particles, palette, mobile);
+  drawCenterAura(ctx, center, sceneTime, palette, mobile);
+  drawCrossTeamGuides(ctx, teams, center, sceneTime, palette, mobile);
+
+  for (const team of teams) {
+    drawTeamHalo(ctx, team, sceneTime, palette);
+  }
+
+  drawMessages(ctx, teams, center, sceneTime, palette, mobile);
+
+  for (const team of teams) {
+    drawTeamLinks(ctx, team, palette);
+  }
+
+  for (const team of teams) {
+    for (const robot of team.robots) {
+      drawRobot(ctx, robot, sceneTime, palette);
+    }
+  }
+
+  clearCentralContentReserve(ctx, center, mobile);
+}
+
+function resolvePalette(): Palette {
+  const isLight = document.documentElement.classList.contains('light');
+  return isLight
+    ? {
+        isLight,
+        centerGlow: '#4f46e5',
+        teamColors: ['#0284c7', '#059669', '#d97706'],
+        teamLineAlpha: 0.34,
+        robotBody: '#eef2ff',
+        robotShade: '#c7d2fe',
+        robotEye: '#ffffff',
+        messageAccent: '#db2777',
+        particle: '#312e81',
+      }
+    : {
+        isLight,
+        centerGlow: '#818cf8',
+        teamColors: ['#38bdf8', '#34d399', '#f59e0b'],
+        teamLineAlpha: 0.42,
+        robotBody: '#111827',
+        robotShade: '#27324a',
+        robotEye: '#e0f2fe',
+        messageAccent: '#f472b6',
+        particle: '#c4b5fd',
+      };
+}
+
+function getCenter(width: number, height: number, mobile: boolean): Point {
+  return {
+    x: width / 2,
+    y: height * (mobile ? 0.47 : 0.49),
+  };
+}
+
+function buildTeams(
+  width: number,
+  height: number,
+  time: number,
+  mobile: boolean,
+  palette: Palette
+): TeamNode[] {
+  const center = getCenter(width, height, mobile);
+  const spreadX = mobile ? Math.min(width * 0.3, 126) : Math.min(width * 0.26, 320);
+  const spreadY = mobile ? Math.min(height * 0.17, 132) : Math.min(height * 0.19, 190);
+  const teamRadius = mobile
+    ? clamp(Math.min(width, height) * 0.09, 30, 40)
+    : clamp(Math.min(width, height) * 0.075, 44, 62);
+  const robotSize = mobile ? 11 : 14;
+  const centers: Point[] = [
+    {
+      x: center.x - spreadX,
+      y: center.y - spreadY * (mobile ? 0.6 : 0.45),
+    },
+    {
+      x: center.x + spreadX,
+      y: center.y - spreadY * (mobile ? 0.6 : 0.45),
+    },
+    {
+      x: center.x,
+      y: center.y + spreadY * (mobile ? 1.22 : 0.95),
+    },
+  ];
+
+  return centers.map((teamCenter, teamIndex) => {
+    const drift = Math.sin(time * 0.75 + teamIndex * 1.7) * (mobile ? 3 : 6);
+    const centerWithDrift = {
+      x: teamCenter.x + Math.cos(teamIndex * 2.1 + time * 0.35) * (mobile ? 2 : 4),
+      y: teamCenter.y + drift,
+    };
+    const color = palette.teamColors[teamIndex % palette.teamColors.length] ?? palette.centerGlow;
+    const memberCount = TEAM_MEMBER_COUNTS[teamIndex] ?? 3;
+    const robots = Array.from({ length: memberCount }, (_, robotIndex) => {
+      const baseAngle =
+        -Math.PI / 2 + robotIndex * (TAU / memberCount) + (teamIndex === 2 ? TAU / 20 : 0);
+      const orbit = baseAngle + Math.sin(time * 0.55 + teamIndex + robotIndex) * 0.1;
+      const orbitRadius =
+        teamRadius * (0.88 + (memberCount > 4 ? 0.08 : 0) + 0.05 * Math.sin(time + robotIndex));
+      return {
+        teamIndex,
+        robotIndex,
+        color,
+        size: memberCount > 4 ? robotSize * 0.88 : robotSize,
+        bob: Math.sin(time * 2.2 + teamIndex * 0.8 + robotIndex * 1.1),
+        x: centerWithDrift.x + Math.cos(orbit) * orbitRadius,
+        y: centerWithDrift.y + Math.sin(orbit) * orbitRadius,
+      };
+    });
+
+    return {
+      index: teamIndex,
+      center: centerWithDrift,
+      color,
+      radius: teamRadius,
+      robots,
+    };
+  });
+}
+
+function drawAmbientField(
+  ctx: CanvasRenderingContext2D,
+  width: number,
+  height: number,
+  time: number,
+  particles: DepthParticle[],
+  palette: Palette,
+  mobile: boolean
+): void {
+  const visibleParticles = mobile ? Math.floor(particles.length * 0.6) : particles.length;
+  for (let i = 0; i < visibleParticles; i++) {
+    const particle = particles[i];
+    if (!particle) continue;
+    const y = (particle.y + time * particle.speed) % (height + 24);
+    const x = particle.x + Math.sin(time * 0.45 + particle.phase) * 8;
+    const pulse = 0.78 + Math.sin(time * 1.8 + particle.phase) * 0.22;
+    ctx.beginPath();
+    ctx.fillStyle = withAlpha(palette.particle, particle.alpha * pulse);
+    ctx.arc(x, y - 12, particle.size, 0, TAU);
+    ctx.fill();
+  }
+}
+
+function drawCenterAura(
+  ctx: CanvasRenderingContext2D,
+  center: Point,
+  time: number,
+  palette: Palette,
+  mobile: boolean
+): void {
+  const radius = mobile ? 86 : 128;
+  const glow = ctx.createRadialGradient(center.x, center.y, 20, center.x, center.y, radius);
+  glow.addColorStop(0, withAlpha(palette.centerGlow, palette.isLight ? 0.13 : 0.2));
+  glow.addColorStop(0.48, withAlpha(palette.messageAccent, palette.isLight ? 0.07 : 0.11));
+  glow.addColorStop(1, withAlpha(palette.centerGlow, 0));
+  ctx.fillStyle = glow;
+  ctx.beginPath();
+  ctx.arc(center.x, center.y, radius, 0, TAU);
+  ctx.fill();
+
+  for (let i = 0; i < 3; i++) {
+    const ringRadius = radius * (0.42 + i * 0.18) + Math.sin(time * 1.1 + i) * 3;
+    ctx.beginPath();
+    ctx.strokeStyle = withAlpha(palette.centerGlow, 0.1 - i * 0.018);
+    ctx.lineWidth = 1;
+    ctx.setLineDash([8 + i * 2, 12 + i * 3]);
+    ctx.lineDashOffset = -time * (18 + i * 8);
+    ctx.arc(center.x, center.y, ringRadius, 0, TAU);
+    ctx.stroke();
+  }
+  ctx.setLineDash([]);
+}
+
+function drawCrossTeamGuides(
+  ctx: CanvasRenderingContext2D,
+  teams: TeamNode[],
+  center: Point,
+  time: number,
+  palette: Palette,
+  mobile: boolean
+): void {
+  for (let i = 0; i < teams.length; i++) {
+    const from = teams[i];
+    const to = teams[(i + 1) % teams.length];
+    if (!from || !to) continue;
+    const anchor = getCrossTeamAnchor(center, i, mobile);
+    const cp1 = mix(from.center, anchor, 0.62);
+    const cp2 = mix(to.center, anchor, 0.62);
+    ctx.beginPath();
+    ctx.moveTo(from.center.x, from.center.y);
+    ctx.bezierCurveTo(cp1.x, cp1.y, cp2.x, cp2.y, to.center.x, to.center.y);
+    ctx.strokeStyle = withAlpha(palette.messageAccent, palette.isLight ? 0.16 : 0.2);
+    ctx.lineWidth = 1.2;
+    ctx.setLineDash([2, 13]);
+    ctx.lineDashOffset = -time * 28;
+    ctx.stroke();
+  }
+  ctx.setLineDash([]);
+}
+
+function drawTeamHalo(
+  ctx: CanvasRenderingContext2D,
+  team: TeamNode,
+  time: number,
+  palette: Palette
+): void {
+  const pulse = 1 + Math.sin(time * 1.8 + team.index) * 0.035;
+  const radiusX = team.radius * 1.56 * pulse;
+  const radiusY = team.radius * 1.14 * pulse;
+  const glow = ctx.createRadialGradient(
+    team.center.x,
+    team.center.y,
+    team.radius * 0.35,
+    team.center.x,
+    team.center.y,
+    team.radius * 2
+  );
+  glow.addColorStop(0, withAlpha(team.color, palette.isLight ? 0.08 : 0.12));
+  glow.addColorStop(1, withAlpha(team.color, 0));
+  ctx.fillStyle = glow;
+  ctx.beginPath();
+  ctx.ellipse(team.center.x, team.center.y, team.radius * 2, team.radius * 1.56, 0, 0, TAU);
+  ctx.fill();
+
+  ctx.beginPath();
+  ctx.ellipse(team.center.x, team.center.y, radiusX, radiusY, time * 0.08, 0, TAU);
+  ctx.strokeStyle = withAlpha(team.color, palette.isLight ? 0.28 : 0.34);
+  ctx.lineWidth = 1.25;
+  ctx.setLineDash([10, 8]);
+  ctx.lineDashOffset = -time * (22 + team.index * 4);
+  ctx.stroke();
+  ctx.setLineDash([]);
+}
+
+function drawTeamLinks(ctx: CanvasRenderingContext2D, team: TeamNode, palette: Palette): void {
+  const pairs = getTeamConnectionPairs(team.robots.length);
+
+  for (const [fromIndex, toIndex] of pairs) {
+    const from = team.robots[fromIndex];
+    const to = team.robots[toIndex];
+    if (!from || !to) continue;
+    ctx.beginPath();
+    ctx.moveTo(from.x, from.y);
+    ctx.lineTo(to.x, to.y);
+    ctx.strokeStyle = withAlpha(team.color, palette.teamLineAlpha);
+    ctx.lineWidth = 1;
+    ctx.stroke();
+  }
+}
+
+function drawMessages(
+  ctx: CanvasRenderingContext2D,
+  teams: TeamNode[],
+  center: Point,
+  time: number,
+  palette: Palette,
+  mobile: boolean
+): void {
+  for (const team of teams) {
+    drawLocalMessages(ctx, team, time, palette, mobile);
+  }
+  drawCrossTeamMessages(ctx, teams, center, time, palette, mobile);
+}
+
+function drawLocalMessages(
+  ctx: CanvasRenderingContext2D,
+  team: TeamNode,
+  time: number,
+  palette: Palette,
+  mobile: boolean
+): void {
+  const pairs = getLocalMessagePairs(team.index, team.robots.length);
+  const activeWindow = 0.76;
+  const period = 2.15 + team.index * 0.12;
+
+  for (let pairIndex = 0; pairIndex < pairs.length; pairIndex++) {
+    const [fromIndex, toIndex] = pairs[pairIndex] ?? [0, 1];
+    const from = team.robots[fromIndex];
+    const to = team.robots[toIndex];
+    if (!from || !to) continue;
+    const raw = positiveModulo(time + team.index * 0.7 + pairIndex * 0.36, period) / period;
+    if (raw > activeWindow) continue;
+    const progress = easeInOutCubic(raw / activeWindow);
+    const curve = makeLocalCurve(from, to, team.center, team.radius * 0.42);
+    drawMessageFlight(ctx, curve, progress, team.color, time, mobile ? 5.5 : 7, palette);
+  }
+}
+
+function drawCrossTeamMessages(
+  ctx: CanvasRenderingContext2D,
+  teams: TeamNode[],
+  center: Point,
+  time: number,
+  palette: Palette,
+  mobile: boolean
+): void {
+  const activeWindow = 0.64;
+  const period = 4.25;
+  const routes = [
+    { fromTeam: 0, fromRobot: 3, toTeam: 1, toRobot: 1, delay: 0, anchor: 0 },
+    { fromTeam: 2, fromRobot: 4, toTeam: 0, toRobot: 1, delay: 0.82, anchor: 2 },
+    { fromTeam: 1, fromRobot: 2, toTeam: 2, toRobot: 0, delay: 1.68, anchor: 1, accent: true },
+    { fromTeam: 0, fromRobot: 0, toTeam: 2, toRobot: 3, delay: 2.54, anchor: 2 },
+  ];
+
+  for (const route of routes) {
+    const fromTeam = teams[route.fromTeam];
+    const toTeam = teams[route.toTeam];
+    if (!fromTeam || !toTeam) continue;
+    const raw = positiveModulo(time + route.delay, period) / period;
+    if (raw > activeWindow) continue;
+
+    const from = fromTeam.robots[route.fromRobot % fromTeam.robots.length];
+    const to = toTeam.robots[route.toRobot % toTeam.robots.length];
+    if (!from || !to) continue;
+    const progress = easeInOutCubic(raw / activeWindow);
+    const curve = makeCrossCurve(from, to, center, route.anchor, mobile);
+    drawMessageFlight(
+      ctx,
+      curve,
+      progress,
+      route.accent ? palette.messageAccent : fromTeam.color,
+      time,
+      mobile ? 6 : 8.5,
+      palette,
+      true
+    );
+  }
+}
+
+function drawMessageFlight(
+  ctx: CanvasRenderingContext2D,
+  curve: [Point, Point, Point, Point],
+  progress: number,
+  color: string,
+  time: number,
+  size: number,
+  palette: Palette,
+  crossTeam = false
+): void {
+  const [p0, p1, p2, p3] = curve;
+  ctx.save();
+  ctx.beginPath();
+  ctx.moveTo(p0.x, p0.y);
+  ctx.bezierCurveTo(p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
+  ctx.strokeStyle = withAlpha(color, crossTeam ? 0.24 : 0.18);
+  ctx.lineWidth = crossTeam ? 1.25 : 1;
+  ctx.setLineDash(crossTeam ? [8, 10] : [4, 8]);
+  ctx.lineDashOffset = -time * (crossTeam ? 52 : 34);
+  ctx.stroke();
+  ctx.setLineDash([]);
+
+  for (let i = 7; i >= 1; i--) {
+    const t = progress - i * 0.036;
+    if (t <= 0) continue;
+    const point = cubicPoint(p0, p1, p2, p3, t);
+    const alpha = (1 - i / 8) * (palette.isLight ? 0.22 : 0.32);
+    ctx.fillStyle = withAlpha(color, alpha);
+    ctx.beginPath();
+    ctx.arc(point.x, point.y, size * (0.18 + i * 0.025), 0, TAU);
+    ctx.fill();
+  }
+
+  const position = cubicPoint(p0, p1, p2, p3, progress);
+  const tangent = cubicTangent(p0, p1, p2, p3, progress);
+  const angle = Math.atan2(tangent.y, tangent.x);
+  drawMessageBubble(ctx, position, angle, size, color, palette, crossTeam);
+  ctx.restore();
+}
+
+function drawMessageBubble(
+  ctx: CanvasRenderingContext2D,
+  position: Point,
+  angle: number,
+  size: number,
+  color: string,
+  palette: Palette,
+  crossTeam: boolean
+): void {
+  ctx.save();
+  ctx.translate(position.x, position.y);
+  ctx.rotate(angle * 0.14);
+  ctx.shadowColor = withAlpha(color, palette.isLight ? 0.22 : 0.5);
+  ctx.shadowBlur = crossTeam ? 18 : 12;
+
+  const width = size * (crossTeam ? 2.5 : 2.25);
+  const height = size * 1.62;
+  roundRectPath(ctx, -width / 2, -height / 2, width, height, size * 0.45);
+  ctx.fillStyle = color;
+  ctx.fill();
+
+  ctx.beginPath();
+  ctx.moveTo(-width * 0.24, height * 0.42);
+  ctx.lineTo(-width * 0.36, height * 0.78);
+  ctx.lineTo(-width * 0.05, height * 0.44);
+  ctx.closePath();
+  ctx.fill();
+
+  ctx.shadowBlur = 0;
+  ctx.fillStyle = palette.robotEye;
+  for (let i = -1; i <= 1; i++) {
+    ctx.beginPath();
+    ctx.arc(i * size * 0.43, -size * 0.02, size * 0.12, 0, TAU);
+    ctx.fill();
+  }
+  ctx.restore();
+}
+
+function drawRobot(
+  ctx: CanvasRenderingContext2D,
+  robot: RobotNode,
+  time: number,
+  palette: Palette
+): void {
+  const size = robot.size;
+  const x = robot.x;
+  const y = robot.y + robot.bob * 1.6;
+  const tilt = Math.sin(time * 1.5 + robot.teamIndex + robot.robotIndex * 0.8) * 0.08;
+
+  ctx.save();
+  ctx.translate(x, y);
+  ctx.rotate(tilt);
+  ctx.shadowColor = withAlpha(robot.color, palette.isLight ? 0.2 : 0.42);
+  ctx.shadowBlur = size * 1.6;
+
+  ctx.strokeStyle = withAlpha(robot.color, palette.isLight ? 0.64 : 0.82);
+  ctx.lineWidth = Math.max(1, size * 0.11);
+  ctx.beginPath();
+  ctx.moveTo(-size * 0.78, size * 0.22);
+  ctx.lineTo(-size * 1.12, size * 0.55);
+  ctx.moveTo(size * 0.78, size * 0.22);
+  ctx.lineTo(size * 1.12, size * 0.55);
+  ctx.stroke();
+
+  const bodyGradient = ctx.createLinearGradient(0, -size, 0, size);
+  bodyGradient.addColorStop(0, mixColor(robot.color, palette.robotBody, 0.28));
+  bodyGradient.addColorStop(1, mixColor(robot.color, palette.robotShade, 0.62));
+  roundRectPath(ctx, -size * 0.78, -size * 0.74, size * 1.56, size * 1.48, size * 0.42);
+  ctx.fillStyle = bodyGradient;
+  ctx.fill();
+  ctx.strokeStyle = withAlpha(robot.color, palette.isLight ? 0.74 : 0.9);
+  ctx.stroke();
+
+  ctx.shadowBlur = 0;
+  ctx.strokeStyle = withAlpha(robot.color, 0.75);
+  ctx.beginPath();
+  ctx.moveTo(0, -size * 0.76);
+  ctx.lineTo(0, -size * 1.18);
+  ctx.stroke();
+  ctx.fillStyle = robot.color;
+  ctx.beginPath();
+  ctx.arc(0, -size * 1.25, size * 0.16, 0, TAU);
+  ctx.fill();
+
+  ctx.fillStyle = palette.robotEye;
+  ctx.beginPath();
+  ctx.arc(-size * 0.3, -size * 0.2, size * 0.16, 0, TAU);
+  ctx.arc(size * 0.3, -size * 0.2, size * 0.16, 0, TAU);
+  ctx.fill();
+
+  ctx.strokeStyle = withAlpha(palette.robotEye, 0.72);
+  ctx.lineWidth = Math.max(1, size * 0.09);
+  ctx.beginPath();
+  ctx.moveTo(-size * 0.36, size * 0.24);
+  ctx.quadraticCurveTo(0, size * 0.5, size * 0.36, size * 0.24);
+  ctx.stroke();
+
+  ctx.fillStyle = withAlpha(robot.color, palette.isLight ? 0.58 : 0.82);
+  ctx.fillRect(-size * 0.42, size * 0.82, size * 0.28, size * 0.22);
+  ctx.fillRect(size * 0.14, size * 0.82, size * 0.28, size * 0.22);
+  ctx.restore();
+}
+
+function getTeamConnectionPairs(memberCount: number): [number, number][] {
+  if (memberCount <= 3) {
+    return [
+      [0, 1],
+      [1, 2],
+      [2, 0],
+    ];
+  }
+
+  const pairs: [number, number][] = [];
+  for (let index = 0; index < memberCount; index++) {
+    pairs.push([index, (index + 1) % memberCount]);
+  }
+  if (memberCount >= 4) pairs.push([0, 2]);
+  if (memberCount >= 5) pairs.push([1, 4]);
+  return pairs;
+}
+
+function getLocalMessagePairs(teamIndex: number, memberCount: number): [number, number][] {
+  const routeMap: [number, number][][] = [
+    [
+      [0, 2],
+      [3, 1],
+      [1, 0],
+    ],
+    [
+      [2, 0],
+      [0, 1],
+      [1, 2],
+    ],
+    [
+      [4, 1],
+      [0, 3],
+      [2, 4],
+      [3, 0],
+    ],
+  ];
+  return (routeMap[teamIndex] ?? routeMap[0]).filter(
+    ([fromIndex, toIndex]) => fromIndex < memberCount && toIndex < memberCount
+  );
+}
+
+function makeLocalCurve(
+  from: Point,
+  to: Point,
+  center: Point,
+  lift: number
+): [Point, Point, Point, Point] {
+  const mid = mix(from, to, 0.5);
+  const away = normalize({ x: mid.x - center.x, y: mid.y - center.y });
+  const control = {
+    x: mid.x + away.x * lift,
+    y: mid.y + away.y * lift,
+  };
+  return [from, mix(from, control, 0.72), mix(to, control, 0.72), to];
+}
+
+function makeCrossCurve(
+  from: Point,
+  to: Point,
+  center: Point,
+  index: number,
+  mobile: boolean
+): [Point, Point, Point, Point] {
+  const anchor = getCrossTeamAnchor(center, index, mobile);
+  const curveLift = 0.32 + index * 0.06;
+  const cp1 = mix(from, anchor, curveLift);
+  const cp2 = mix(to, anchor, curveLift);
+  const normal = normalize({ x: to.y - from.y, y: from.x - to.x });
+  const offset = mobile ? 22 + index * 6 : 42 + index * 12;
+  return [
+    from,
+    { x: cp1.x + normal.x * offset, y: cp1.y + normal.y * offset },
+    { x: cp2.x + normal.x * offset, y: cp2.y + normal.y * offset },
+    to,
+  ];
+}
+
+function getCrossTeamAnchor(center: Point, index: number, mobile: boolean): Point {
+  const horizontalOffset = mobile ? 108 : 178;
+  const topOffset = mobile ? 94 : 138;
+  const lowerOffset = mobile ? 106 : 112;
+  if (index === 0) {
+    return {
+      x: center.x,
+      y: center.y - topOffset,
+    };
+  }
+  if (index === 1) {
+    return {
+      x: center.x + horizontalOffset,
+      y: center.y + lowerOffset,
+    };
+  }
+  return {
+    x: center.x - horizontalOffset,
+    y: center.y + lowerOffset,
+  };
+}
+
+function clearCentralContentReserve(
+  ctx: CanvasRenderingContext2D,
+  center: Point,
+  mobile: boolean
+): void {
+  const width = mobile ? 260 : 330;
+  const height = mobile ? 166 : 184;
+  const y = center.y + (mobile ? 12 : 10);
+  ctx.save();
+  ctx.globalCompositeOperation = 'destination-out';
+  roundRectPath(ctx, center.x - width / 2, y - height / 2, width, height, mobile ? 32 : 40);
+  ctx.fillStyle = 'rgba(0, 0, 0, 0.98)';
+  ctx.fill();
+
+  const glow = ctx.createRadialGradient(center.x, y, 8, center.x, y, width * 0.62);
+  glow.addColorStop(0, 'rgba(0, 0, 0, 0.96)');
+  glow.addColorStop(0.68, 'rgba(0, 0, 0, 0.9)');
+  glow.addColorStop(1, 'rgba(0, 0, 0, 0)');
+  ctx.fillStyle = glow;
+  roundRectPath(ctx, center.x - width / 2, y - height / 2, width, height, mobile ? 32 : 40);
+  ctx.fill();
+  ctx.restore();
+}
+
+function createDepthParticles(width: number, height: number): DepthParticle[] {
+  const count = width < 560 ? 46 : 78;
+  return Array.from({ length: count }, (_, index) => {
+    const seed = index * 97.13;
+    return {
+      x: pseudoRandom(seed) * width,
+      y: pseudoRandom(seed + 12.4) * (height + 24),
+      size: 0.45 + pseudoRandom(seed + 22.8) * 1.15,
+      speed: 8 + pseudoRandom(seed + 31.2) * 18,
+      phase: pseudoRandom(seed + 48.7) * TAU,
+      alpha: 0.06 + pseudoRandom(seed + 72.1) * 0.16,
+    };
+  });
+}
+
+function pseudoRandom(seed: number): number {
+  const value = Math.sin(seed * 12.9898) * 43758.5453;
+  return value - Math.floor(value);
+}
+
+function cubicPoint(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point {
+  const clamped = clamp(t, 0, 1);
+  const mt = 1 - clamped;
+  const mt2 = mt * mt;
+  const t2 = clamped * clamped;
+  return {
+    x: mt2 * mt * p0.x + 3 * mt2 * clamped * p1.x + 3 * mt * t2 * p2.x + t2 * clamped * p3.x,
+    y: mt2 * mt * p0.y + 3 * mt2 * clamped * p1.y + 3 * mt * t2 * p2.y + t2 * clamped * p3.y,
+  };
+}
+
+function cubicTangent(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point {
+  const clamped = clamp(t, 0, 1);
+  const mt = 1 - clamped;
+  return {
+    x:
+      3 * mt * mt * (p1.x - p0.x) +
+      6 * mt * clamped * (p2.x - p1.x) +
+      3 * clamped * clamped * (p3.x - p2.x),
+    y:
+      3 * mt * mt * (p1.y - p0.y) +
+      6 * mt * clamped * (p2.y - p1.y) +
+      3 * clamped * clamped * (p3.y - p2.y),
+  };
+}
+
+function mix(from: Point, to: Point, amount: number): Point {
+  return {
+    x: from.x + (to.x - from.x) * amount,
+    y: from.y + (to.y - from.y) * amount,
+  };
+}
+
+function normalize(point: Point): Point {
+  const length = Math.hypot(point.x, point.y) || 1;
+  return {
+    x: point.x / length,
+    y: point.y / length,
+  };
+}
+
+function easeInOutCubic(value: number): number {
+  const t = clamp(value, 0, 1);
+  return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+
+function positiveModulo(value: number, divisor: number): number {
+  return ((value % divisor) + divisor) % divisor;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function roundRectPath(
+  ctx: CanvasRenderingContext2D,
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  radius: number
+): void {
+  const r = Math.min(radius, width / 2, height / 2);
+  ctx.beginPath();
+  ctx.moveTo(x + r, y);
+  ctx.lineTo(x + width - r, y);
+  ctx.quadraticCurveTo(x + width, y, x + width, y + r);
+  ctx.lineTo(x + width, y + height - r);
+  ctx.quadraticCurveTo(x + width, y + height, x + width - r, y + height);
+  ctx.lineTo(x + r, y + height);
+  ctx.quadraticCurveTo(x, y + height, x, y + height - r);
+  ctx.lineTo(x, y + r);
+  ctx.quadraticCurveTo(x, y, x + r, y);
+  ctx.closePath();
+}
+
+function withAlpha(hex: string, alpha: number): string {
+  const normalized = normalizeHex(hex);
+  const r = Number.parseInt(normalized.slice(1, 3), 16);
+  const g = Number.parseInt(normalized.slice(3, 5), 16);
+  const b = Number.parseInt(normalized.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${clamp(alpha, 0, 1)})`;
+}
+
+function mixColor(hexA: string, hexB: string, amount: number): string {
+  const a = hexToRgb(normalizeHex(hexA));
+  const b = hexToRgb(normalizeHex(hexB));
+  const t = clamp(amount, 0, 1);
+  return `rgb(${Math.round(a.r + (b.r - a.r) * t)}, ${Math.round(
+    a.g + (b.g - a.g) * t
+  )}, ${Math.round(a.b + (b.b - a.b) * t)})`;
+}
+
+function normalizeHex(hex: string): string {
+  if (/^#[0-9a-fA-F]{6}$/.test(hex)) return hex;
+  if (/^#[0-9a-fA-F]{3}$/.test(hex)) {
+    return `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}`;
+  }
+  return '#ffffff';
+}
+
+function hexToRgb(hex: string): { r: number; g: number; b: number } {
+  return {
+    r: Number.parseInt(hex.slice(1, 3), 16),
+    g: Number.parseInt(hex.slice(3, 5), 16),
+    b: Number.parseInt(hex.slice(5, 7), 16),
+  };
+}
diff --git a/src/renderer/components/team/dialogs/CreateTeamDialog.tsx b/src/renderer/components/team/dialogs/CreateTeamDialog.tsx
index 701a58a2..b9307d2e 100644
--- a/src/renderer/components/team/dialogs/CreateTeamDialog.tsx
+++ b/src/renderer/components/team/dialogs/CreateTeamDialog.tsx
@@ -26,7 +26,6 @@ import {
   normalizeProviderForMode,
   validateMemberNameInline,
 } from '@renderer/components/team/members/MembersEditorSection';
-import type { MemberDraft } from '@renderer/components/team/members/MembersEditorSection';
 import { TeamRosterEditorSection } from '@renderer/components/team/members/TeamRosterEditorSection';
 import { AutoResizeTextarea } from '@renderer/components/ui/auto-resize-textarea';
 import { Button } from '@renderer/components/ui/button';
@@ -53,18 +52,18 @@ import { useTheme } from '@renderer/hooks/useTheme';
 import { cn } from '@renderer/lib/utils';
 import {
   applyStoredCreateTeamMemberRuntimePreferences,
-  getStoredCreateTeamMemberRuntimePreferences,
   getStoredCreateTeamEffort,
   getStoredCreateTeamFastMode as getStoredTeamFastMode,
   getStoredCreateTeamLimitContext,
+  getStoredCreateTeamMemberRuntimePreferences,
   getStoredCreateTeamModel as getStoredTeamModel,
   getStoredCreateTeamProvider as getStoredTeamProvider,
   getStoredCreateTeamSkipPermissions,
   migrateLegacyCreateTeamPreferences,
-  setStoredCreateTeamMemberRuntimePreferences,
   setStoredCreateTeamEffort,
   setStoredCreateTeamFastMode,
   setStoredCreateTeamLimitContext,
+  setStoredCreateTeamMemberRuntimePreferences,
   setStoredCreateTeamModel,
   setStoredCreateTeamProvider,
   setStoredCreateTeamSkipPermissions,
@@ -80,6 +79,7 @@ import {
   normalizeExplicitTeamModelForUi,
 } from '@renderer/utils/teamModelAvailability';
 import { getTeamProviderLabel as getCatalogTeamProviderLabel } from '@renderer/utils/teamModelCatalog';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 import { DEFAULT_PROVIDER_MODEL_SELECTION } from '@shared/utils/providerModelSelection';
 import { resolveTeamLeadColorName } from '@shared/utils/teamMemberColors';
 import { isTeamProviderId, normalizeOptionalTeamProviderId } from '@shared/utils/teamProvider';
@@ -99,15 +99,15 @@ import {
   type ProviderPrepareDiagnosticsModelResult,
   runProviderPrepareDiagnostics,
 } from './providerPrepareDiagnostics';
-import {
-  getShortLivedProviderPrepareModelResults,
-  storeShortLivedProviderPrepareModelResults,
-} from './providerPrepareShortLivedCache';
 import {
   buildProviderPrepareMembersSignature,
   buildProviderPrepareRequestSignature,
   buildProviderPrepareRuntimeStatusSignature,
 } from './providerPrepareRequestSignature';
+import {
+  getShortLivedProviderPrepareModelResults,
+  storeShortLivedProviderPrepareModelResults,
+} from './providerPrepareShortLivedCache';
 import { getProvisioningModelIssue } from './provisioningModelIssues';
 import {
   deriveEffectiveProvisioningPrepareState,
@@ -124,6 +124,8 @@ import { SkipPermissionsCheckbox } from './SkipPermissionsCheckbox';
 import { computeEffectiveTeamModel } from './TeamModelSelector';
 import { getNextSuggestedTeamName } from './teamNameSets';
 
+import type { MemberDraft } from '@renderer/components/team/members/MembersEditorSection';
+
 const TEAM_COLOR_NAMES = [
   'blue',
   'green',
@@ -146,15 +148,6 @@ import type {
   TeamProvisioningMemberInput,
 } from '@shared/types';
 
-function isEphemeralRenderedProjectPath(projectPath: string | null | undefined): boolean {
-  const normalized = normalizePath(projectPath ?? '').toLowerCase();
-  return (
-    normalized.includes('rendered_mcp_') ||
-    normalized.includes('rendered_mcp_config') ||
-    normalized.includes('/portable-mcp-live')
-  );
-}
-
 function getProviderLabel(providerId: TeamProviderId): string {
   return getCatalogTeamProviderLabel(providerId) ?? 'Anthropic';
 }
@@ -523,7 +516,10 @@ export const CreateTeamDialog = ({
     [members]
   );
 
-  const effectiveCwd = cwdMode === 'project' ? selectedProjectPath.trim() : customCwd.trim();
+  const selectedProjectCwd = isEphemeralProjectPath(selectedProjectPath)
+    ? ''
+    : selectedProjectPath.trim();
+  const effectiveCwd = cwdMode === 'project' ? selectedProjectCwd : customCwd.trim();
   const dialogTeamNameKey = sanitizeTeamName(teamName.trim());
   /** All taken names: existing teams + teams currently being provisioned. */
   const allTakenTeamNames = useMemo(
@@ -913,7 +909,9 @@ export const CreateTeamDialog = ({
     let cancelled = false;
     void (async () => {
       try {
-        const nextProjects = await api.getProjects();
+        const nextProjects = (await api.getProjects()).filter(
+          (project) => !isEphemeralProjectPath(project.path)
+        );
         if (cancelled) {
           return;
         }
@@ -921,10 +919,14 @@ export const CreateTeamDialog = ({
         // If defaultProjectPath is set but not in the fetched list (e.g. new project
         // without Claude sessions), add it as a synthetic entry so the Combobox can
         // display and select it.
+        const normalizedDefaultProjectPath = defaultProjectPath
+          ? normalizePath(defaultProjectPath)
+          : null;
         if (
           defaultProjectPath &&
-          !isEphemeralRenderedProjectPath(defaultProjectPath) &&
-          !nextProjects.some((p) => normalizePath(p.path) === defaultProjectPath)
+          normalizedDefaultProjectPath &&
+          !isEphemeralProjectPath(defaultProjectPath) &&
+          !nextProjects.some((p) => normalizePath(p.path) === normalizedDefaultProjectPath)
         ) {
           const folderName =
             defaultProjectPath.split(/[/\\]/).filter(Boolean).pop() ?? defaultProjectPath;
@@ -1066,24 +1068,31 @@ export const CreateTeamDialog = ({
     if (cwdMode !== 'project') {
       return;
     }
-    if (selectedProjectPath || projects.length === 0) {
+    if (selectedProjectPath) {
       return;
     }
-    if (defaultProjectPath && !isEphemeralRenderedProjectPath(defaultProjectPath)) {
-      const match = projects.find((p) => normalizePath(p.path) === defaultProjectPath);
+    const selectableProjects = projects.filter((project) => !isEphemeralProjectPath(project.path));
+    if (selectableProjects.length === 0) {
+      return;
+    }
+    if (defaultProjectPath && !isEphemeralProjectPath(defaultProjectPath)) {
+      const normalizedDefaultProjectPath = normalizePath(defaultProjectPath);
+      const match = selectableProjects.find(
+        (p) => normalizePath(p.path) === normalizedDefaultProjectPath
+      );
       if (match) {
         setSelectedProjectPath(match.path);
         return;
       }
     }
-    setSelectedProjectPath(projects[0].path);
+    setSelectedProjectPath(selectableProjects[0].path);
   }, [open, cwdMode, projects, selectedProjectPath, defaultProjectPath]);
 
   useEffect(() => {
     if (!open || cwdMode !== 'project' || !selectedProjectPath) {
       return;
     }
-    if (!isEphemeralRenderedProjectPath(selectedProjectPath)) {
+    if (!isEphemeralProjectPath(selectedProjectPath)) {
       return;
     }
     setSelectedProjectPath('');
diff --git a/src/renderer/components/team/dialogs/LaunchTeamDialog.tsx b/src/renderer/components/team/dialogs/LaunchTeamDialog.tsx
index 05536833..d2f64803 100644
--- a/src/renderer/components/team/dialogs/LaunchTeamDialog.tsx
+++ b/src/renderer/components/team/dialogs/LaunchTeamDialog.tsx
@@ -69,6 +69,7 @@ import {
   normalizeExplicitTeamModelForUi,
 } from '@renderer/utils/teamModelAvailability';
 import { getTeamProviderLabel as getCatalogTeamProviderLabel } from '@renderer/utils/teamModelCatalog';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 import { migrateProviderBackendId } from '@shared/utils/providerBackend';
 import { DEFAULT_PROVIDER_MODEL_SELECTION } from '@shared/utils/providerModelSelection';
 import { isTeamProviderId, normalizeOptionalTeamProviderId } from '@shared/utils/teamProvider';
@@ -104,15 +105,15 @@ import {
   type ProviderPrepareDiagnosticsModelResult,
   runProviderPrepareDiagnostics,
 } from './providerPrepareDiagnostics';
-import {
-  getShortLivedProviderPrepareModelResults,
-  storeShortLivedProviderPrepareModelResults,
-} from './providerPrepareShortLivedCache';
 import {
   buildProviderPrepareModelChecksSignature,
   buildProviderPrepareRequestSignature,
   buildProviderPrepareRuntimeStatusSignature,
 } from './providerPrepareRequestSignature';
+import {
+  getShortLivedProviderPrepareModelResults,
+  storeShortLivedProviderPrepareModelResults,
+} from './providerPrepareShortLivedCache';
 import { getProvisioningModelIssue } from './provisioningModelIssues';
 import {
   deriveEffectiveProvisioningPrepareState,
@@ -1206,7 +1207,10 @@ export const LaunchTeamDialog = (props: LaunchTeamDialogProps): React.JSX.Elemen
   // Launch-only effects
   // ---------------------------------------------------------------------------
 
-  const effectiveCwd = cwdMode === 'project' ? selectedProjectPath.trim() : customCwd.trim();
+  const selectedProjectCwd = isEphemeralProjectPath(selectedProjectPath)
+    ? ''
+    : selectedProjectPath.trim();
+  const effectiveCwd = cwdMode === 'project' ? selectedProjectCwd : customCwd.trim();
   const prepareRuntimeStatusSignature = useMemo(
     () =>
       buildProviderPrepareRuntimeStatusSignature(
@@ -1445,14 +1449,16 @@ export const LaunchTeamDialog = (props: LaunchTeamDialogProps): React.JSX.Elemen
     let cancelled = false;
     void (async () => {
       try {
-        const apiProjects = await api.getProjects();
+        const apiProjects = (await api.getProjects()).filter(
+          (project) => !isEphemeralProjectPath(project.path)
+        );
         if (cancelled) return;
 
         const pathSet = new Set(apiProjects.map((p) => p.path));
         const extras: Project[] = [];
         for (const repo of repositoryGroups) {
           for (const wt of repo.worktrees) {
-            if (!pathSet.has(wt.path)) {
+            if (!isEphemeralProjectPath(wt.path) && !pathSet.has(wt.path)) {
               pathSet.add(wt.path);
               extras.push({
                 id: wt.id,
@@ -1485,17 +1491,32 @@ export const LaunchTeamDialog = (props: LaunchTeamDialogProps): React.JSX.Elemen
   const defaultProjectPath = isLaunchMode ? props.defaultProjectPath : undefined;
 
   useEffect(() => {
-    if (!open || cwdMode !== 'project' || selectedProjectPath || projects.length === 0) return;
-    if (defaultProjectPath) {
-      const match = projects.find((p) => p.path === defaultProjectPath);
+    if (!open || cwdMode !== 'project' || selectedProjectPath) return;
+    const selectableProjects = projects.filter((project) => !isEphemeralProjectPath(project.path));
+    if (selectableProjects.length === 0) return;
+    if (defaultProjectPath && !isEphemeralProjectPath(defaultProjectPath)) {
+      const normalizedDefaultProjectPath = normalizePath(defaultProjectPath);
+      const match = selectableProjects.find(
+        (p) => normalizePath(p.path) === normalizedDefaultProjectPath
+      );
       if (match) {
         setSelectedProjectPath(match.path);
         return;
       }
     }
-    setSelectedProjectPath(projects[0].path);
+    setSelectedProjectPath(selectableProjects[0].path);
   }, [open, cwdMode, projects, selectedProjectPath, defaultProjectPath]);
 
+  useEffect(() => {
+    if (!open || cwdMode !== 'project' || !selectedProjectPath) {
+      return;
+    }
+    if (!isEphemeralProjectPath(selectedProjectPath)) {
+      return;
+    }
+    setSelectedProjectPath('');
+  }, [open, cwdMode, selectedProjectPath, setSelectedProjectPath]);
+
   // Pre-warm file list cache so @-mention file search is instant
   useFileListCacheWarmer(effectiveCwd || null);
 
diff --git a/src/renderer/components/team/dialogs/ProvisioningProviderStatusList.tsx b/src/renderer/components/team/dialogs/ProvisioningProviderStatusList.tsx
index 710a666e..a092ec38 100644
--- a/src/renderer/components/team/dialogs/ProvisioningProviderStatusList.tsx
+++ b/src/renderer/components/team/dialogs/ProvisioningProviderStatusList.tsx
@@ -1,11 +1,10 @@
 import React from 'react';
 
-import { getTeamProviderLabel as getCatalogTeamProviderLabel } from '@renderer/utils/teamModelCatalog';
 import { formatProviderBackendLabel } from '@renderer/utils/providerBackendIdentity';
+import { getTeamProviderLabel as getCatalogTeamProviderLabel } from '@renderer/utils/teamModelCatalog';
 import { AlertTriangle, CheckCircle2, Loader2 } from 'lucide-react';
 
-import type { TeamProviderId } from '@shared/types';
-import type { CliProviderStatus } from '@shared/types';
+import type { CliProviderStatus, TeamProviderId } from '@shared/types';
 
 export type ProvisioningProviderCheckStatus = 'pending' | 'checking' | 'ready' | 'notes' | 'failed';
 export type ProvisioningPrepareState = 'idle' | 'loading' | 'ready' | 'failed';
@@ -141,6 +140,7 @@ type ProvisioningDetailSummary =
   | 'Runtime provider is not configured'
   | 'CLI preflight failed'
   | 'Selected model compatibility pending'
+  | 'Selected model available'
   | 'Selected model verified'
   | 'Selected model unavailable'
   | 'Selected model verification timed out'
@@ -148,6 +148,25 @@ type ProvisioningDetailSummary =
   | 'Ready with notes'
   | 'Needs attention';
 
+function isSelectedModelDetail(lower: string): boolean {
+  return lower.includes('selected model');
+}
+
+function isFormattedModelDetail(lower: string): boolean {
+  return (
+    lower.includes(' - checking...') ||
+    lower.includes(' - verified') ||
+    lower.includes(' - available for launch') ||
+    lower.includes(' - compatible, deep verification pending') ||
+    lower.includes(' - unavailable') ||
+    lower.includes(' - check failed')
+  );
+}
+
+function isModelDetail(lower: string): boolean {
+  return isSelectedModelDetail(lower) || isFormattedModelDetail(lower);
+}
+
 function getStatusLabel(status: ProvisioningProviderCheckStatus): string {
   switch (status) {
     case 'checking':
@@ -199,32 +218,38 @@ function summarizeDetail(
   if (lower.includes('claude cli preflight check failed')) {
     return 'CLI preflight failed';
   }
-  if (lower.includes('compatible, deep verification pending')) {
+  if (isModelDetail(lower) && lower.includes('compatible, deep verification pending')) {
     return 'Selected model compatibility pending';
   }
-  if (lower.includes('selected model') && lower.includes('verified for launch')) {
+  if (isSelectedModelDetail(lower) && lower.includes('verified for launch')) {
     return 'Selected model verified';
   }
-  if (lower.includes('selected model') && lower.includes('is unavailable')) {
+  if (isSelectedModelDetail(lower) && lower.includes('available for launch')) {
+    return 'Selected model available';
+  }
+  if (isSelectedModelDetail(lower) && lower.includes('is unavailable')) {
     return 'Selected model unavailable';
   }
   if (
-    lower.includes('selected model') &&
+    isSelectedModelDetail(lower) &&
     lower.includes('could not be verified') &&
     lower.includes('timed out')
   ) {
     return 'Selected model verification timed out';
   }
-  if (lower.includes('selected model') && lower.includes('could not be verified')) {
+  if (isSelectedModelDetail(lower) && lower.includes('could not be verified')) {
     return 'Selected model check failed';
   }
   if (lower.includes(' - verified')) {
     return 'Selected model verified';
   }
+  if (lower.includes(' - available for launch')) {
+    return 'Selected model available';
+  }
   if (lower.includes(' - unavailable -')) {
     return 'Selected model unavailable';
   }
-  if (lower.includes('timed out')) {
+  if (lower.includes(' - check failed') && lower.includes('timed out')) {
     return 'Selected model verification timed out';
   }
   if (lower.includes(' - check failed -')) {
@@ -242,6 +267,7 @@ function summarizeDetail(
 
 function getModelDetailSummary(details: string[]): string | null {
   let compatibilityPendingCount = 0;
+  let availableCount = 0;
   let verifiedCount = 0;
   let unavailableCount = 0;
   let timedOutCount = 0;
@@ -250,23 +276,46 @@ function getModelDetailSummary(details: string[]): string | null {
 
   for (const detail of details) {
     const lower = detail.toLowerCase();
+    if (!isModelDetail(lower)) {
+      continue;
+    }
     if (lower.includes('compatible, deep verification pending')) {
       compatibilityPendingCount += 1;
       continue;
     }
-    if (lower.includes(' - verified')) {
+    if (
+      lower.includes(' - available for launch') ||
+      (isSelectedModelDetail(lower) && lower.includes('is available for launch'))
+    ) {
+      availableCount += 1;
+      continue;
+    }
+    if (
+      lower.includes(' - verified') ||
+      (isSelectedModelDetail(lower) && lower.includes('verified for launch'))
+    ) {
       verifiedCount += 1;
       continue;
     }
-    if (lower.includes(' - unavailable -')) {
+    if (
+      lower.includes(' - unavailable -') ||
+      (isSelectedModelDetail(lower) && lower.includes('is unavailable'))
+    ) {
       unavailableCount += 1;
       continue;
     }
-    if (lower.includes('timed out')) {
+    if (
+      lower.includes('timed out') &&
+      (lower.includes('check failed') ||
+        (isSelectedModelDetail(lower) && lower.includes('could not be verified')))
+    ) {
       timedOutCount += 1;
       continue;
     }
-    if (lower.includes(' - check failed -')) {
+    if (
+      lower.includes(' - check failed -') ||
+      (isSelectedModelDetail(lower) && lower.includes('could not be verified'))
+    ) {
       checkFailedCount += 1;
       continue;
     }
@@ -291,6 +340,9 @@ function getModelDetailSummary(details: string[]): string | null {
   if (checkingCount > 0) {
     parts.push(`${checkingCount} checking`);
   }
+  if (availableCount > 0) {
+    parts.push(`${availableCount} available`);
+  }
   if (verifiedCount > 0) {
     parts.push(`${verifiedCount} verified`);
   }
@@ -337,7 +389,7 @@ function getDetailTone(
   status: ProvisioningProviderCheckStatus
 ): 'success' | 'failure' | 'checking' | 'neutral' {
   const summary = summarizeDetail(detail, status);
-  if (summary === 'Selected model verified') {
+  if (summary === 'Selected model verified' || summary === 'Selected model available') {
     return 'success';
   }
   if (summary === 'Selected model verification timed out') {
diff --git a/src/renderer/components/team/dialogs/projectPathOptions.ts b/src/renderer/components/team/dialogs/projectPathOptions.ts
index 579f17e8..36540b90 100644
--- a/src/renderer/components/team/dialogs/projectPathOptions.ts
+++ b/src/renderer/components/team/dialogs/projectPathOptions.ts
@@ -1,4 +1,5 @@
 import { normalizePath } from '@renderer/utils/pathNormalize';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
 
 import type { ComboboxOption } from '@renderer/components/ui/combobox';
 import type { Project } from '@shared/types';
@@ -24,6 +25,10 @@ export function buildProjectPathOptions(
   const normalizedPreferredPath = preferredPath ? normalizePath(preferredPath) : null;
 
   for (const project of projects) {
+    if (isEphemeralProjectPath(project.path)) {
+      continue;
+    }
+
     const normalizedProjectPath = normalizePath(project.path);
     const existingIndex = optionIndexByNormalizedPath.get(normalizedProjectPath);
 
diff --git a/src/renderer/components/team/dialogs/providerPrepareDiagnostics.ts b/src/renderer/components/team/dialogs/providerPrepareDiagnostics.ts
index 26d65df4..18896cd3 100644
--- a/src/renderer/components/team/dialogs/providerPrepareDiagnostics.ts
+++ b/src/renderer/components/team/dialogs/providerPrepareDiagnostics.ts
@@ -75,6 +75,10 @@ function buildModelSuccessLine(providerId: TeamProviderId, modelId: string): str
   return `${getModelLabel(providerId, modelId)} - verified`;
 }
 
+function buildModelAvailableLine(providerId: TeamProviderId, modelId: string): string {
+  return `${getModelLabel(providerId, modelId)} - available for launch`;
+}
+
 function buildModelCompatibilityPendingLine(providerId: TeamProviderId, modelId: string): string {
   return `${getModelLabel(providerId, modelId)} - compatible, deep verification pending...`;
 }
@@ -132,6 +136,11 @@ function stripSelectedModelPrefix(modelId: string, message: string): string {
     new RegExp(`^Selected model ${escapeRegExp(modelId)} is unavailable\\.\\s*`, 'i'),
     new RegExp(`^Selected model ${escapeRegExp(modelId)} could not be verified\\.\\s*`, 'i'),
     new RegExp(`^Selected model ${escapeRegExp(modelId)} verified for launch\\.\\s*`, 'i'),
+    new RegExp(`^Selected model ${escapeRegExp(modelId)} is available for launch\\.\\s*`, 'i'),
+    new RegExp(
+      `^Selected model ${escapeRegExp(modelId)} is compatible\\. Deep verification pending\\.\\s*`,
+      'i'
+    ),
   ];
   for (const pattern of patterns) {
     if (pattern.test(trimmed)) {
@@ -389,6 +398,28 @@ function resolveModelResultFromBatch(
     };
   }
 
+  const hasAvailableLine = modelScopedEntries.some((entry) =>
+    /selected model .* is available for launch\./i.test(entry)
+  );
+  if (hasAvailableLine) {
+    return {
+      status: 'ready',
+      line: buildModelAvailableLine(providerId, modelId),
+      warningLine: null,
+    };
+  }
+
+  const hasCompatibilityLine = modelScopedEntries.some((entry) =>
+    /selected model .* is compatible\. deep verification pending\./i.test(entry)
+  );
+  if (hasCompatibilityLine) {
+    return {
+      status: 'notes',
+      line: buildModelCompatibilityPendingLine(providerId, modelId),
+      warningLine: null,
+    };
+  }
+
   const hasUnavailableLine = modelScopedEntries.some((entry) =>
     /selected model .* is unavailable\./i.test(entry)
   );
@@ -421,16 +452,10 @@ function resolveModelResultFromBatch(
   }
 
   if (result.ready && (result.warnings?.length ?? 0) > 0 && !hasModelScopedEntries) {
-    const line = buildModelFailureLine(
-      providerId,
-      modelId,
-      'check failed',
-      'Verification did not complete after runtime preflight warning'
-    );
     return {
       status: 'notes',
-      line,
-      warningLine: line,
+      line: buildModelCompatibilityPendingLine(providerId, modelId),
+      warningLine: null,
     };
   }
 
@@ -474,6 +499,20 @@ function resolveModelResultFromCompatibilityBatch(
     return { kind: 'compatible' };
   }
 
+  const hasAvailableLine = modelScopedEntries.some((entry) =>
+    /selected model .* is available for launch\./i.test(entry)
+  );
+  if (hasAvailableLine) {
+    return {
+      kind: 'terminal',
+      result: {
+        status: 'ready',
+        line: buildModelAvailableLine(providerId, modelId),
+        warningLine: null,
+      },
+    };
+  }
+
   const hasUnavailableLine = modelScopedEntries.some((entry) =>
     /selected model .* is unavailable\./i.test(entry)
   );
@@ -856,30 +895,31 @@ export async function runProviderPrepareDiagnostics({
       }
     } else {
       try {
-        const batchedModelResult = await prepareProvisioning(
+        const compatibilityResult = await prepareProvisioning(
           cwd,
           providerId,
           [providerId],
           uncachedModelIds,
-          limitContext
+          limitContext,
+          'compatibility'
         );
-        runtimeDetailLines = createRuntimeDetailLines(batchedModelResult).filter(
+        runtimeDetailLines = createRuntimeDetailLines(compatibilityResult).filter(
           (entry) => !isModelScopedEntryForAnyModel(uncachedModelIds, entry)
         );
-        runtimeWarnings = [...(batchedModelResult.warnings ?? [])].filter(
+        runtimeWarnings = [...(compatibilityResult.warnings ?? [])].filter(
           (entry) => !isModelScopedEntryForAnyModel(uncachedModelIds, entry)
         );
 
         const hasModelScopedEntries = uncachedModelIds.some(
-          (modelId) => getModelScopedEntries(modelId, batchedModelResult).length > 0
+          (modelId) => getModelScopedEntries(modelId, compatibilityResult).length > 0
         );
         const hasNonModelScopedDiagnostics =
           runtimeDetailLines.length > 0 || runtimeWarnings.length > 0;
         const hasSingleModelFallbackReason =
           uncachedModelIds.length === 1 &&
-          looksLikeSingleModelBatchFailure(uncachedModelIds[0], batchedModelResult);
+          looksLikeSingleModelBatchFailure(uncachedModelIds[0], compatibilityResult);
         if (
-          !batchedModelResult.ready &&
+          !compatibilityResult.ready &&
           !hasModelScopedEntries &&
           (uncachedModelIds.length > 1 ||
             (!hasNonModelScopedDiagnostics && !hasSingleModelFallbackReason))
@@ -888,7 +928,7 @@ export async function runProviderPrepareDiagnostics({
             status: 'failed',
             details: [
               ...runtimeDetailLines,
-              ...(batchedModelResult.message ? [batchedModelResult.message] : []),
+              ...(compatibilityResult.message ? [compatibilityResult.message] : []),
             ],
             warnings: runtimeWarnings,
             modelResultsById: {},
@@ -905,11 +945,46 @@ export async function runProviderPrepareDiagnostics({
             resolveModelResultFromBatch(
               providerId,
               modelId,
-              batchedModelResult,
+              compatibilityResult,
               uncachedModelIds.length === 1
             )
           );
         }
+
+        emitProgress();
+
+        if (!hasFailure) {
+          try {
+            const deepResult = await prepareProvisioning(
+              cwd,
+              providerId,
+              [providerId],
+              undefined,
+              limitContext,
+              'deep'
+            );
+            runtimeDetailLines = createRuntimeDetailLines(deepResult).filter(
+              (entry) => !isModelScopedEntryForAnyModel(uncachedModelIds, entry)
+            );
+            runtimeWarnings = [...(deepResult.warnings ?? [])].filter(
+              (entry) => !isModelScopedEntryForAnyModel(uncachedModelIds, entry)
+            );
+            if (
+              !deepResult.ready &&
+              runtimeDetailLines.length === 0 &&
+              runtimeWarnings.length === 0
+            ) {
+              runtimeWarnings = deepResult.message ? [deepResult.message] : [];
+            }
+          } catch (deepError) {
+            hasNotes = true;
+            runtimeWarnings = [
+              normalizeModelReason(
+                deepError instanceof Error ? deepError.message.trim() : String(deepError).trim()
+              ) ?? 'One-shot diagnostic failed',
+            ];
+          }
+        }
       } catch (error) {
         hasNotes = true;
         const reason = normalizeModelReason(
diff --git a/src/renderer/components/team/members/MemberCard.tsx b/src/renderer/components/team/members/MemberCard.tsx
index 55db083a..552e59b2 100644
--- a/src/renderer/components/team/members/MemberCard.tsx
+++ b/src/renderer/components/team/members/MemberCard.tsx
@@ -122,6 +122,7 @@ export const MemberCard = ({
   const dotClass = launchPresentation.dotClass;
   const runtimeAdvisoryLabel = launchPresentation.runtimeAdvisoryLabel;
   const runtimeAdvisoryTitle = launchPresentation.runtimeAdvisoryTitle;
+  const runtimeAdvisoryTone = launchPresentation.runtimeAdvisoryTone;
   const presenceLabel = launchPresentation.presenceLabel;
   const spawnCardClass = launchPresentation.cardClass;
   const launchVisualState = launchPresentation.launchVisualState;
@@ -236,12 +237,22 @@ export const MemberCard = ({
               ) : null}
               {!activityTask && isAwaitingReply ? (
                 <>
-                  <Loader2
-                    className={`size-3 shrink-0 animate-spin ${runtimeAdvisoryLabel ? 'text-amber-400' : ''}`}
-                    style={runtimeAdvisoryLabel ? undefined : { color: colors.border }}
-                  />
+                  {runtimeAdvisoryTone === 'error' ? (
+                    <AlertTriangle className="size-3 shrink-0 text-red-400" />
+                  ) : (
+                    <Loader2
+                      className={`size-3 shrink-0 animate-spin ${runtimeAdvisoryLabel ? 'text-amber-400' : ''}`}
+                      style={runtimeAdvisoryLabel ? undefined : { color: colors.border }}
+                    />
+                  )}
                   <span
-                    className={`shrink-0 text-[10px] ${runtimeAdvisoryLabel ? 'text-amber-300' : 'text-[var(--color-text-muted)]'}`}
+                    className={`shrink-0 text-[10px] ${
+                      runtimeAdvisoryTone === 'error'
+                        ? 'text-red-300'
+                        : runtimeAdvisoryLabel
+                          ? 'text-amber-300'
+                          : 'text-[var(--color-text-muted)]'
+                    }`}
                     title={runtimeAdvisoryTitle ?? 'Message sent, awaiting reply'}
                   >
                     {runtimeAdvisoryLabel ?? 'awaiting reply'}
@@ -308,10 +319,18 @@ export const MemberCard = ({
             <Tooltip>
               <TooltipTrigger asChild>
                 <span className="flex shrink-0 items-center gap-1">
-                  <AlertTriangle className="size-3.5 shrink-0 text-amber-400" />
+                  <AlertTriangle
+                    className={`size-3.5 shrink-0 ${
+                      runtimeAdvisoryTone === 'error' ? 'text-red-400' : 'text-amber-400'
+                    }`}
+                  />
                   <Badge
                     variant="secondary"
-                    className="shrink-0 bg-amber-500/15 px-1.5 py-0.5 text-[10px] font-normal leading-none text-amber-300"
+                    className={`shrink-0 px-1.5 py-0.5 text-[10px] font-normal leading-none ${
+                      runtimeAdvisoryTone === 'error'
+                        ? 'bg-red-500/15 text-red-300'
+                        : 'bg-amber-500/15 text-amber-300'
+                    }`}
                     title={runtimeAdvisoryTitle}
                   >
                     {runtimeAdvisoryLabel}
diff --git a/src/renderer/components/team/members/MemberDetailHeader.tsx b/src/renderer/components/team/members/MemberDetailHeader.tsx
index e159488a..992c9934 100644
--- a/src/renderer/components/team/members/MemberDetailHeader.tsx
+++ b/src/renderer/components/team/members/MemberDetailHeader.tsx
@@ -85,11 +85,15 @@ export const MemberDetailHeader = ({
   const launchVisualState = launchPresentation.launchVisualState;
   const launchStatusLabel = launchPresentation.launchStatusLabel;
   const dotClass = launchPresentation.dotClass;
+  const runtimeAdvisoryLabel = launchPresentation.runtimeAdvisoryLabel;
   const runtimeAdvisoryTitle = launchPresentation.runtimeAdvisoryTitle;
+  const runtimeAdvisoryTone = launchPresentation.runtimeAdvisoryTone;
   const badgeLabel =
-    launchVisualState === 'runtime_pending' || launchVisualState === 'permission_pending'
-      ? (launchStatusLabel ?? presenceLabel)
-      : presenceLabel;
+    runtimeAdvisoryTone === 'error' && runtimeAdvisoryLabel
+      ? runtimeAdvisoryLabel
+      : launchVisualState === 'runtime_pending' || launchVisualState === 'permission_pending'
+        ? (launchStatusLabel ?? presenceLabel)
+        : presenceLabel;
 
   const canEditRole =
     !isLeadMember(member) && !member.removedAt && !isTeamProvisioning && !!onUpdateRole;
@@ -147,7 +151,11 @@ export const MemberDetailHeader = ({
               <>
                 <Badge
                   variant="secondary"
-                  className="px-1.5 py-0.5 text-[10px] font-normal leading-none text-[var(--color-text-muted)]"
+                  className={`px-1.5 py-0.5 text-[10px] font-normal leading-none ${
+                    runtimeAdvisoryTone === 'error'
+                      ? 'bg-red-500/15 text-red-300'
+                      : 'text-[var(--color-text-muted)]'
+                  }`}
                   title={runtimeAdvisoryTitle}
                 >
                   {badgeLabel}
diff --git a/src/renderer/components/team/members/MemberHoverCard.tsx b/src/renderer/components/team/members/MemberHoverCard.tsx
index 2ab37e50..8c85df45 100644
--- a/src/renderer/components/team/members/MemberHoverCard.tsx
+++ b/src/renderer/components/team/members/MemberHoverCard.tsx
@@ -124,11 +124,15 @@ export const MemberHoverCard = ({
   const launchVisualState = launchPresentation.launchVisualState;
   const launchStatusLabel = launchPresentation.launchStatusLabel;
   const dotClass = launchPresentation.dotClass;
+  const runtimeAdvisoryLabel = launchPresentation.runtimeAdvisoryLabel;
   const runtimeAdvisoryTitle = launchPresentation.runtimeAdvisoryTitle;
+  const runtimeAdvisoryTone = launchPresentation.runtimeAdvisoryTone;
   const badgeLabel =
-    launchVisualState === 'runtime_pending' || launchVisualState === 'permission_pending'
-      ? (launchStatusLabel ?? presenceLabel)
-      : presenceLabel;
+    runtimeAdvisoryTone === 'error' && runtimeAdvisoryLabel
+      ? runtimeAdvisoryLabel
+      : launchVisualState === 'runtime_pending' || launchVisualState === 'permission_pending'
+        ? (launchStatusLabel ?? presenceLabel)
+        : presenceLabel;
   const currentTask: TeamTaskWithKanban | null = member.currentTaskId
     ? (tasks.find((t) => t.id === member.currentTaskId) ?? null)
     : null;
@@ -173,9 +177,18 @@ export const MemberHoverCard = ({
                   className="shrink-0 px-1.5 py-0 text-[10px] font-normal leading-tight"
                   title={runtimeAdvisoryTitle}
                   style={{
-                    backgroundColor: getThemedBadge(colors, isLight),
-                    color: getThemedText(colors, isLight),
-                    border: `1px solid ${getThemedBorder(colors, isLight)}40`,
+                    backgroundColor:
+                      runtimeAdvisoryTone === 'error'
+                        ? 'rgba(239, 68, 68, 0.16)'
+                        : getThemedBadge(colors, isLight),
+                    color:
+                      runtimeAdvisoryTone === 'error'
+                        ? 'rgb(252, 165, 165)'
+                        : getThemedText(colors, isLight),
+                    border:
+                      runtimeAdvisoryTone === 'error'
+                        ? '1px solid rgba(248, 113, 113, 0.35)'
+                        : `1px solid ${getThemedBorder(colors, isLight)}40`,
                   }}
                 >
                   {badgeLabel}
diff --git a/src/renderer/components/team/review/ChangeReviewDialog.tsx b/src/renderer/components/team/review/ChangeReviewDialog.tsx
index 68a00a78..2678550b 100644
--- a/src/renderer/components/team/review/ChangeReviewDialog.tsx
+++ b/src/renderer/components/team/review/ChangeReviewDialog.tsx
@@ -21,7 +21,7 @@ import {
   type TaskChangeRequestOptions,
 } from '@renderer/utils/taskChangeRequest';
 import { normalizePathForComparison } from '@shared/utils/platformPath';
-import { ChevronDown, Clock, X } from 'lucide-react';
+import { AlertTriangle, ChevronDown, Clock, FileSearch, X } from 'lucide-react';
 
 import { ChangesLoadingAnimation } from './ChangesLoadingAnimation';
 import { acceptAllChunks, computeChunkIndexAtPos, rejectAllChunks } from './CodeMirrorDiffUtils';
@@ -67,6 +67,41 @@ function isTaskChangeSetV2(cs: { teamName: string }): cs is TaskChangeSetV2 {
   return 'scope' in cs;
 }
 
+const TaskChangesEmptyState = ({
+  changeSet,
+}: {
+  changeSet: TaskChangeSetV2 | null;
+}): React.ReactElement => {
+  const warnings = changeSet?.warnings ?? [];
+  const hasWarnings = warnings.length > 0;
+  const Icon = hasWarnings ? AlertTriangle : FileSearch;
+
+  return (
+    <div className="flex w-full items-center justify-center px-6">
+      <div className="max-w-xl rounded-lg border border-border bg-surface-sidebar px-5 py-4 text-center">
+        <Icon
+          className={cn('mx-auto mb-2 size-5', hasWarnings ? 'text-amber-300' : 'text-text-muted')}
+        />
+        <div className="text-sm font-medium text-text">
+          {hasWarnings ? 'No reviewable file changes' : 'No file changes recorded'}
+        </div>
+        <p className="mt-1 text-xs leading-5 text-text-muted">
+          {hasWarnings
+            ? 'The task ledger did not expose any safe file diff for this task. The diagnostics below explain why.'
+            : 'The task ledger has no file events for this task.'}
+        </p>
+        {warnings.length > 0 && (
+          <div className="mt-3 space-y-1 rounded border border-amber-500/20 bg-amber-500/10 px-3 py-2 text-left text-xs text-amber-200">
+            {warnings.map((warning, index) => (
+              <div key={`${warning}:${index}`}>{warning}</div>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};
+
 export const ChangeReviewDialog = ({
   open,
   onOpenChange,
@@ -1213,6 +1248,16 @@ export const ChangeReviewDialog = ({
     resetAllReviewState,
   ]);
 
+  const taskChangeSet =
+    activeChangeSet && isTaskChangeSetV2(activeChangeSet) ? activeChangeSet : null;
+  const hasReviewFiles = (activeChangeSet?.files.length ?? 0) > 0;
+  const shouldShowScopeBanner =
+    mode === 'task' &&
+    !!taskChangeSet &&
+    (taskChangeSet.provenance?.sourceKind !== 'ledger' ||
+      taskChangeSet.warnings.length > 0 ||
+      taskChangeSet.scope.confidence.tier > 1);
+
   // Active file for timeline (derived from scroll-spy)
   const activeFile = useMemo(() => {
     if (!activeChangeSet || !activeFilePath) return null;
@@ -1224,7 +1269,7 @@ export const ChangeReviewDialog = ({
     const task = taskId ? globalTasks.find((t) => t.id === taskId) : undefined;
     const shortId = task?.displayId ?? taskId?.slice(0, 8) ?? '?';
     const subject = task?.subject;
-    return subject ? `Changes for task #${shortId} — ${subject}` : `Changes for task #${shortId}`;
+    return subject ? `Changes for task #${shortId} - ${subject}` : `Changes for task #${shortId}`;
   }, [mode, memberName, taskId, globalTasks]);
 
   const isMacElectron =
@@ -1272,33 +1317,31 @@ export const ChangeReviewDialog = ({
       />
 
       {/* Review toolbar */}
-      {!changeSetLoading &&
-        !changeSetError &&
-        activeChangeSet &&
-        activeChangeSet.files.length > 0 && (
-          <ReviewToolbar
-            stats={reviewStats}
-            changeStats={changeStats}
-            collapseUnchanged={collapseUnchanged}
-            applying={applying}
-            autoViewed={autoViewed}
-            onAutoViewedChange={setAutoViewed}
-            onAcceptAll={handleAcceptAll}
-            onRejectAll={handleRejectAll}
-            onApply={handleApply}
-            onCollapseUnchangedChange={setCollapseUnchanged}
-            instantApply={REVIEW_INSTANT_APPLY}
-            editedCount={editedCount}
-            canUndo={reviewUndoStack.length > 0}
-            onUndo={handleUndoBulk}
-          />
-        )}
+      {!changeSetLoading && !changeSetError && activeChangeSet && hasReviewFiles && (
+        <ReviewToolbar
+          stats={reviewStats}
+          changeStats={changeStats}
+          collapseUnchanged={collapseUnchanged}
+          applying={applying}
+          autoViewed={autoViewed}
+          onAutoViewedChange={setAutoViewed}
+          onAcceptAll={handleAcceptAll}
+          onRejectAll={handleRejectAll}
+          onApply={handleApply}
+          onCollapseUnchangedChange={setCollapseUnchanged}
+          instantApply={REVIEW_INSTANT_APPLY}
+          editedCount={editedCount}
+          canUndo={reviewUndoStack.length > 0}
+          onUndo={handleUndoBulk}
+        />
+      )}
 
       {/* Scope info / warnings + confidence badge */}
-      {mode === 'task' && activeChangeSet && isTaskChangeSetV2(activeChangeSet) && (
+      {shouldShowScopeBanner && taskChangeSet && (
         <ScopeWarningBanner
-          warnings={activeChangeSet.warnings}
-          confidence={activeChangeSet.scope.confidence}
+          warnings={taskChangeSet.warnings}
+          confidence={taskChangeSet.scope.confidence}
+          sourceKind={taskChangeSet.provenance?.sourceKind}
         />
       )}
 
@@ -1319,7 +1362,7 @@ export const ChangeReviewDialog = ({
           </div>
         )}
 
-        {!changeSetLoading && !changeSetError && activeChangeSet && (
+        {!changeSetLoading && !changeSetError && activeChangeSet && hasReviewFiles && (
           <>
             {/* File tree */}
             <div className="w-64 shrink-0 overflow-y-auto border-r border-border bg-surface-sidebar">
@@ -1425,10 +1468,8 @@ export const ChangeReviewDialog = ({
           </>
         )}
 
-        {!changeSetLoading && !changeSetError && activeChangeSet?.files.length === 0 && (
-          <div className="flex w-full items-center justify-center text-sm text-text-muted">
-            No file changes detected
-          </div>
+        {!changeSetLoading && !changeSetError && activeChangeSet && !hasReviewFiles && (
+          <TaskChangesEmptyState changeSet={taskChangeSet} />
         )}
       </div>
     </div>
diff --git a/src/renderer/components/team/review/ConfidenceBadge.tsx b/src/renderer/components/team/review/ConfidenceBadge.tsx
index 6b902228..a4578061 100644
--- a/src/renderer/components/team/review/ConfidenceBadge.tsx
+++ b/src/renderer/components/team/review/ConfidenceBadge.tsx
@@ -3,6 +3,7 @@ import type { TaskScopeConfidence } from '@shared/types';
 interface ConfidenceBadgeProps {
   confidence: TaskScopeConfidence;
   showTooltip?: boolean;
+  label?: string;
 }
 
 const TIER_COLORS: Record<number, string> = {
@@ -19,13 +20,17 @@ const TIER_LABELS: Record<number, string> = {
   4: 'Best effort',
 };
 
-export const ConfidenceBadge = ({ confidence, showTooltip = true }: ConfidenceBadgeProps) => {
+export const ConfidenceBadge = ({
+  confidence,
+  showTooltip = true,
+  label,
+}: ConfidenceBadgeProps) => {
   return (
     <span
       className={`inline-flex items-center rounded border px-2 py-0.5 text-xs ${TIER_COLORS[confidence.tier] ?? TIER_COLORS[4]}`}
       title={showTooltip ? confidence.reason : undefined}
     >
-      {TIER_LABELS[confidence.tier] ?? TIER_LABELS[4]}
+      {label ?? TIER_LABELS[confidence.tier] ?? TIER_LABELS[4]}
     </span>
   );
 };
diff --git a/src/renderer/components/team/review/ContinuousScrollView.tsx b/src/renderer/components/team/review/ContinuousScrollView.tsx
index d6fc2ec1..cdd71ba6 100644
--- a/src/renderer/components/team/review/ContinuousScrollView.tsx
+++ b/src/renderer/components/team/review/ContinuousScrollView.tsx
@@ -239,7 +239,7 @@ export const ContinuousScrollView = ({
   if (files.length === 0) {
     return (
       <div className="flex h-full items-center justify-center text-sm text-text-muted">
-        No file changes detected
+        No reviewable file changes
       </div>
     );
   }
diff --git a/src/renderer/components/team/review/FileSectionDiff.tsx b/src/renderer/components/team/review/FileSectionDiff.tsx
index 73d151cd..912cef97 100644
--- a/src/renderer/components/team/review/FileSectionDiff.tsx
+++ b/src/renderer/components/team/review/FileSectionDiff.tsx
@@ -117,6 +117,7 @@ export const FileSectionDiff = ({
 
   const resolvedOriginal = fileContent?.originalFullContent ?? null;
   const isMissingOnDisk = fileContent ? fileContent.modifiedFullContent == null : false;
+  const isContentUnavailable = fileContent?.contentSource === 'unavailable';
   const hasLedgerManualAction = file.snippets.some(
     (snippet) =>
       !!snippet.ledger &&
@@ -143,11 +144,13 @@ export const FileSectionDiff = ({
       <div className="overflow-auto">
         <OversizedDiffNotice
           message={
-            canRenderCodeMirror && !canRenderSnippetPreview
-              ? 'Full diff skipped because it is large enough to risk a renderer out-of-memory crash.'
-              : canRenderCodeMirror
-                ? 'Large diff opened in safe preview mode to avoid a renderer out-of-memory crash.'
-                : 'Diff preview skipped because the available change data is too large to render safely.'
+            hasLedgerManualAction || isContentUnavailable
+              ? 'No text diff is available for this ledger change. Binary, large, or metadata-only content requires manual review.'
+              : canRenderCodeMirror && !canRenderSnippetPreview
+                ? 'Full diff skipped because it is large enough to risk a renderer out-of-memory crash.'
+                : canRenderCodeMirror
+                  ? 'Large diff opened in safe preview mode to avoid a renderer out-of-memory crash.'
+                  : 'Diff preview skipped because the available change data is too large to render safely.'
           }
         />
         {canRenderSnippetPreview ? <ReviewDiffContent file={file} /> : null}
diff --git a/src/renderer/components/team/review/FileSectionHeader.tsx b/src/renderer/components/team/review/FileSectionHeader.tsx
index b6d61c6f..03bb7e0d 100644
--- a/src/renderer/components/team/review/FileSectionHeader.tsx
+++ b/src/renderer/components/team/review/FileSectionHeader.tsx
@@ -9,13 +9,13 @@ import type { FileChangeWithContent, HunkDecision } from '@shared/types';
 import type { FileChangeSummary } from '@shared/types/review';
 
 const CONTENT_SOURCE_LABELS: Record<string, string> = {
-  'ledger-exact': 'Ledger Exact',
+  'ledger-exact': 'Task Ledger',
   'ledger-snapshot': 'Ledger Snapshot',
   'file-history': 'File History',
   'snippet-reconstruction': 'Reconstructed',
   'disk-current': 'Current Disk',
   'git-fallback': 'Git Fallback',
-  unavailable: 'Missing on disk',
+  unavailable: 'Content unavailable',
 };
 
 interface FileSectionHeaderProps {
@@ -58,7 +58,8 @@ export const FileSectionHeader = ({
   onRejectFile,
 }: FileSectionHeaderProps): React.ReactElement => {
   const isMissingOnDisk = fileContent ? fileContent.modifiedFullContent == null : false;
-  const isPreviewOnly = isMissingOnDisk || fileContent?.contentSource === 'unavailable';
+  const isContentUnavailable = fileContent?.contentSource === 'unavailable';
+  const isPreviewOnly = isMissingOnDisk || isContentUnavailable;
   const requiresManualLedgerReview = file.snippets.some(
     (snippet) =>
       !!snippet.ledger &&
@@ -76,7 +77,12 @@ export const FileSectionHeader = ({
       if (writeSnippets.length === 0) return null;
       return writeSnippets[writeSnippets.length - 1].newString;
     })();
-  const canRestore = !!onRestoreMissingFile && isPreviewOnly && !hasEdits && restoreContent != null;
+  const canRestore =
+    !!onRestoreMissingFile &&
+    isMissingOnDisk &&
+    !isContentUnavailable &&
+    !hasEdits &&
+    restoreContent != null;
   const externalChangeLabel =
     externalChange?.type === 'unlink'
       ? 'Deleted on disk'
@@ -147,13 +153,26 @@ export const FileSectionHeader = ({
                 isPreviewOnly ? 'bg-red-500/20 text-red-300' : 'bg-surface-raised text-text-muted',
               ].join(' ')}
             >
-              {isPreviewOnly
-                ? 'Missing on disk'
-                : (CONTENT_SOURCE_LABELS[fileContent.contentSource] ?? fileContent.contentSource)}
+              {isContentUnavailable
+                ? 'Content unavailable'
+                : isMissingOnDisk
+                  ? 'Missing on disk'
+                  : (CONTENT_SOURCE_LABELS[fileContent.contentSource] ?? fileContent.contentSource)}
             </span>
           </TooltipTrigger>
           <TooltipContent side="bottom" className="max-w-xs">
-            {isPreviewOnly ? (
+            {isContentUnavailable ? (
+              <div className="space-y-1">
+                <div className="font-medium text-text">Text content is unavailable</div>
+                <div className="text-text-muted">
+                  The ledger recorded metadata for this change, but full text content is not
+                  available. This usually means binary, large, or hash-only content.
+                </div>
+                <div className="text-text-muted">
+                  Automatic accept/reject is disabled for this file to avoid unsafe disk writes.
+                </div>
+              </div>
+            ) : isMissingOnDisk ? (
               <div className="space-y-1">
                 <div className="font-medium text-text">File is missing on disk</div>
                 <div className="text-text-muted">
@@ -269,7 +288,9 @@ export const FileSectionHeader = ({
                 </TooltipTrigger>
                 {isPreviewOnly && (
                   <TooltipContent side="bottom">
-                    Accept/Reject is disabled while the file is missing on disk.
+                    {isContentUnavailable
+                      ? 'Accept/Reject is disabled because full text content is unavailable.'
+                      : 'Accept/Reject is disabled while the file is missing on disk.'}
                   </TooltipContent>
                 )}
               </Tooltip>
@@ -296,7 +317,9 @@ export const FileSectionHeader = ({
                   <TooltipContent side="bottom">
                     {requiresManualLedgerReview
                       ? 'Reject is disabled because this ledger change has binary, large, or unavailable content.'
-                      : 'Accept/Reject is disabled while the file is missing on disk.'}
+                      : isContentUnavailable
+                        ? 'Reject is disabled because full text content is unavailable.'
+                        : 'Accept/Reject is disabled while the file is missing on disk.'}
                   </TooltipContent>
                 )}
               </Tooltip>
diff --git a/src/renderer/components/team/review/FullDiffLoadingBanner.tsx b/src/renderer/components/team/review/FullDiffLoadingBanner.tsx
index 707ff4c9..9cbca533 100644
--- a/src/renderer/components/team/review/FullDiffLoadingBanner.tsx
+++ b/src/renderer/components/team/review/FullDiffLoadingBanner.tsx
@@ -57,7 +57,7 @@ export const FullDiffLoadingBanner = ({
             <div className="mt-2 flex flex-wrap gap-2">
               <span className="inline-flex items-center gap-1 rounded-full border border-border bg-surface-sidebar px-2 py-1 text-[11px] text-text-secondary">
                 <FileDiff className="size-3.5" strokeWidth={1.8} />
-                {snippetCount} snippet{snippetCount === 1 ? '' : 's'} ready
+                {snippetCount} preview{snippetCount === 1 ? '' : 's'} ready
               </span>
               <span className="inline-flex items-center gap-1 rounded-full border border-border bg-surface-sidebar px-2 py-1 text-[11px] text-text-secondary">
                 <Clock3 className="size-3.5" strokeWidth={1.8} />
@@ -91,8 +91,8 @@ export const FullDiffLoadingBanner = ({
           </div>
           <p className="mt-2 text-[11px] text-text-muted">
             {showFileProgress
-              ? `${readyFilesCount} ready, ${loadingFilesCount} still loading. Snippet previews stay visible below while the remaining baselines are reconstructed.`
-              : 'Snippet previews stay visible below while the exact baseline is reconstructed.'}
+              ? `${readyFilesCount} ready, ${loadingFilesCount} still loading. Preview diffs stay visible below while the remaining baselines are resolved.`
+              : 'Preview diffs stay visible below while the exact baseline is resolved.'}
           </p>
         </div>
       </div>
diff --git a/src/renderer/components/team/review/ReviewToolbar.tsx b/src/renderer/components/team/review/ReviewToolbar.tsx
index dde07a11..4424402c 100644
--- a/src/renderer/components/team/review/ReviewToolbar.tsx
+++ b/src/renderer/components/team/review/ReviewToolbar.tsx
@@ -157,7 +157,7 @@ export const ReviewToolbar = ({
         </Tooltip>
       )}
 
-      {/* Actions — hidden when all hunks are already decided */}
+      {/* Actions hidden when all hunks are already decided */}
       {stats.pending > 0 && (
         <>
           <Tooltip>
@@ -206,10 +206,12 @@ export const ReviewToolbar = ({
               ) : (
                 <GitMerge className="size-3" />
               )}
-              {applying ? 'Applying...' : 'Apply All Changes'}
+              {applying ? 'Applying...' : 'Apply Rejections'}
             </button>
           </TooltipTrigger>
-          <TooltipContent side="bottom">Apply review decisions across all files</TooltipContent>
+          <TooltipContent side="bottom">
+            Apply rejected hunks to disk; accepted changes are kept as-is
+          </TooltipContent>
         </Tooltip>
       )}
     </div>
diff --git a/src/renderer/components/team/review/ScopeWarningBanner.tsx b/src/renderer/components/team/review/ScopeWarningBanner.tsx
index 418f4ff5..79be7bbb 100644
--- a/src/renderer/components/team/review/ScopeWarningBanner.tsx
+++ b/src/renderer/components/team/review/ScopeWarningBanner.tsx
@@ -11,6 +11,7 @@ import type { FC } from 'react';
 interface ScopeWarningBannerProps {
   warnings: string[];
   confidence: TaskScopeConfidence;
+  sourceKind?: 'ledger' | 'legacy';
   onDismiss?: () => void;
 }
 
@@ -21,6 +22,7 @@ interface TierConfig {
   accentColor: string;
   title: string;
   detail: string;
+  badgeLabel?: string;
 }
 
 const TIER_CONFIGS: Record<number, TierConfig> = {
@@ -31,7 +33,7 @@ const TIER_CONFIGS: Record<number, TierConfig> = {
     accentColor: 'text-emerald-400',
     title: 'Task scope determined precisely',
     detail:
-      'Both start and completion markers found in the session log. The diff includes only changes made during this specific task — other tasks that modified the same files are excluded.',
+      'Both start and completion markers found in the session log. The diff includes only changes made during this specific task - other tasks that modified the same files are excluded.',
   },
   2: {
     Icon: Info,
@@ -40,7 +42,7 @@ const TIER_CONFIGS: Record<number, TierConfig> = {
     accentColor: 'text-blue-400',
     title: 'End boundary estimated',
     detail:
-      'Only the start marker was found — the task has no completion marker yet. Changes shown from task start to end of session. If other tasks ran after this one in the same session, their changes may also be included.',
+      'Only the start marker was found - the task has no completion marker yet. Changes shown from task start to end of session. If other tasks ran after this one in the same session, their changes may also be included.',
   },
   3: {
     Icon: AlertTriangle,
@@ -49,7 +51,7 @@ const TIER_CONFIGS: Record<number, TierConfig> = {
     accentColor: 'text-orange-400',
     title: 'Start boundary estimated',
     detail:
-      'Only the completion marker was found — the start of work was not captured. If other tasks ran before this one in the same session, their changes to the same files may also be included.',
+      'Only the completion marker was found - the start of work was not captured. If other tasks ran before this one in the same session, their changes to the same files may also be included.',
   },
   4: {
     Icon: AlertTriangle,
@@ -58,17 +60,56 @@ const TIER_CONFIGS: Record<number, TierConfig> = {
     accentColor: 'text-red-400',
     title: 'Showing all session changes',
     detail:
-      'No task markers found in the session log. Cannot isolate this task — all file changes from the entire session are shown, including changes from other tasks. This can happen with older CLI versions or non-standard workflows.',
+      'No task markers found in the session log. Cannot isolate this task - all file changes from the entire session are shown, including changes from other tasks. This can happen with older CLI versions or non-standard workflows.',
   },
 };
 
 export const ScopeWarningBanner = ({
   warnings,
   confidence,
+  sourceKind = 'legacy',
   onDismiss,
 }: ScopeWarningBannerProps): JSX.Element => {
   const [expanded, setExpanded] = useState(false);
-  const config = TIER_CONFIGS[confidence.tier] ?? TIER_CONFIGS[4];
+  const ledgerConfig: TierConfig | null =
+    sourceKind === 'ledger'
+      ? {
+          Icon: confidence.tier <= 1 ? ShieldCheck : confidence.tier === 2 ? Info : AlertTriangle,
+          border:
+            confidence.tier <= 1
+              ? 'border-emerald-500/15'
+              : confidence.tier === 2
+                ? 'border-blue-500/15'
+                : 'border-orange-500/20',
+          bg:
+            confidence.tier <= 1
+              ? 'bg-emerald-500/5'
+              : confidence.tier === 2
+                ? 'bg-blue-500/5'
+                : 'bg-orange-500/5',
+          accentColor:
+            confidence.tier <= 1
+              ? 'text-emerald-400'
+              : confidence.tier === 2
+                ? 'text-blue-400'
+                : 'text-orange-400',
+          title:
+            confidence.tier <= 1
+              ? 'Changes captured by task ledger'
+              : 'Changes captured with limited reviewability',
+          detail:
+            confidence.tier <= 1
+              ? 'The orchestrator captured these file changes while the agent was working on this task.'
+              : 'The orchestrator captured these file changes for this task, but at least one change was captured from a snapshot or metadata-only source. Review exact text diffs where available; binary or unavailable content may require manual review.',
+          badgeLabel:
+            confidence.tier <= 1
+              ? 'Ledger exact'
+              : confidence.tier === 2
+                ? 'Mixed reviewability'
+                : 'Needs review',
+        }
+      : null;
+  const config = ledgerConfig ?? TIER_CONFIGS[confidence.tier] ?? TIER_CONFIGS[4];
   const { Icon } = config;
 
   return (
@@ -86,7 +127,7 @@ export const ScopeWarningBanner = ({
 
         <div className="flex-1" />
 
-        <ConfidenceBadge confidence={confidence} />
+        <ConfidenceBadge confidence={confidence} label={config.badgeLabel} />
 
         {onDismiss && (
           <button onClick={onDismiss} className="text-text-muted hover:text-text">
diff --git a/src/renderer/components/team/taskLogs/TaskLogStreamSection.tsx b/src/renderer/components/team/taskLogs/TaskLogStreamSection.tsx
index bb4910e7..e02dacd3 100644
--- a/src/renderer/components/team/taskLogs/TaskLogStreamSection.tsx
+++ b/src/renderer/components/team/taskLogs/TaskLogStreamSection.tsx
@@ -60,6 +60,14 @@ function normalizeResponse(response: BoardTaskLogStreamResponse): BoardTaskLogSt
   };
 }
 
+function buildStableSegmentRenderKey(segment: BoardTaskLogSegment): string {
+  const firstChunkId = segment.chunks[0]?.id;
+  if (firstChunkId) {
+    return `${segment.participantKey}:${firstChunkId}`;
+  }
+  return `${segment.participantKey}:${segment.startTimestamp}`;
+}
+
 function describeStreamSource(stream: BoardTaskLogStreamResponse | null): string {
   if (stream?.source === 'opencode_runtime_attribution') {
     return 'Task-scoped OpenCode runtime logs projected from explicit task attribution into the same execution-log components used in Logs.';
@@ -357,7 +365,11 @@ export const TaskLogStreamSection = ({
       ) : (
         <div className="space-y-6">
           {visibleSegments.map((segment) => (
-            <SegmentBlock key={segment.id} segment={segment} showHeader={showSegmentHeaders} />
+            <SegmentBlock
+              key={buildStableSegmentRenderKey(segment)}
+              segment={segment}
+              showHeader={showSegmentHeaders}
+            />
           ))}
         </div>
       )}
diff --git a/src/renderer/index.html b/src/renderer/index.html
index 1f849482..2e8ab5a8 100644
--- a/src/renderer/index.html
+++ b/src/renderer/index.html
@@ -1,132 +1,310 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <link rel="icon" type="image/png" href="./favicon.png" />
-  <title>Agent Teams UI</title>
-  <style>
-    /* Splash: animated gradient background */
-    #splash {
-      position: fixed; inset: 0; z-index: 9999;
-      display: flex; flex-direction: column;
-      align-items: center; justify-content: center;
-      background: linear-gradient(
-        180deg,
-        #0c0d13 0%,
-        #1a1535 20%,
-        #1e1245 35%,
-        #231740 50%,
-        #1a1535 65%,
-        #151230 80%,
-        #0c0d13 100%
-      );
-      background-size: 100% 300%;
-      animation: splash-bg 6s ease infinite;
-      transition: opacity 0.3s ease-out;
-    }
-    @keyframes splash-bg {
-      0% { background-position: 50% 0%; }
-      50% { background-position: 50% 100%; }
-      100% { background-position: 50% 0%; }
-    }
-    #splash-noise {
-      position: absolute; inset: 0; width: 100%; height: 100%;
-      opacity: 0.03; pointer-events: none;
-    }
-    #splash-logo {
-      margin-bottom: 18px;
-      animation: splash-breathe 3s ease-in-out infinite, splash-glow 3s ease-in-out infinite;
-    }
-    @keyframes splash-breathe {
-      0%, 100% { transform: scale(1); }
-      50% { transform: scale(1.08); }
-    }
-    @keyframes splash-glow {
-      0%, 100% { filter: drop-shadow(0 0 12px rgba(129,140,248,0.4)) drop-shadow(0 0 28px rgba(167,139,250,0.18)); }
-      50% { filter: drop-shadow(0 0 20px rgba(129,140,248,0.6)) drop-shadow(0 0 42px rgba(167,139,250,0.3)); }
-    }
-    #splash-text {
-      font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace;
-      font-size: 15px; font-weight: 500; letter-spacing: 0.05em;
-      color: #a1a1aa;
-    }
-
-    /* Logo node breathing — cycles through 3 agent nodes */
-    @keyframes splash-node {
-      0%, 100% { opacity: 0.18; }
-      12%, 28% { opacity: 1; }
-      45% { opacity: 0.18; }
-    }
-    .splash-node {
-      animation: splash-node 3s cubic-bezier(0.4, 0, 0.2, 1) infinite both;
-    }
-    .splash-edge { transition: opacity 0.3s; }
-
-    /* Light theme splash overrides */
-    :root.light #splash {
-      background: linear-gradient(
-        180deg,
-        #e0e7ff 0%,
-        #c7d2fe 18%,
-        #ddd6fe 36%,
-        #f0abfc 50%,
-        #ddd6fe 64%,
-        #c7d2fe 82%,
-        #e0e7ff 100%
-      );
-      background-size: 100% 300%;
-    }
-    :root.light #splash-text { color: #52525b; }
-    :root.light #splash-noise { opacity: 0.02; }
-    :root.light #splash-logo {
-      animation: splash-breathe 3s ease-in-out infinite, splash-glow-light 3s ease-in-out infinite;
-    }
-    @keyframes splash-glow-light {
-      0%, 100% { filter: drop-shadow(0 0 10px rgba(79,70,229,0.3)) drop-shadow(0 0 24px rgba(139,92,246,0.15)); }
-      50% { filter: drop-shadow(0 0 16px rgba(79,70,229,0.45)) drop-shadow(0 0 36px rgba(139,92,246,0.25)); }
-    }
-  </style>
-  <script>
-    // Flash prevention: Apply cached theme before React loads
-    (function() {
-      try {
-        var theme = localStorage.getItem('claude-devtools-theme-cache');
-        if (theme === 'light') {
-          document.documentElement.classList.add('light');
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" type="image/png" href="./favicon.png" />
+    <title>Agent Teams UI</title>
+    <style>
+      /* Splash: animated gradient background */
+      #splash {
+        position: fixed;
+        inset: 0;
+        z-index: 9999;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        overflow: hidden;
+        isolation: isolate;
+        background: linear-gradient(
+          180deg,
+          #0c0d13 0%,
+          #1a1535 20%,
+          #1e1245 35%,
+          #231740 50%,
+          #1a1535 65%,
+          #151230 80%,
+          #0c0d13 100%
+        );
+        background-size: 100% 300%;
+        animation: splash-bg 6s ease infinite;
+        transition:
+          opacity 0.42s ease-out,
+          filter 0.42s ease-out;
+      }
+      #splash.splash-exiting {
+        opacity: 0;
+        filter: blur(8px);
+      }
+      @keyframes splash-bg {
+        0% {
+          background-position: 50% 0%;
         }
-      } catch(e) {}
-    })();
-  </script>
-</head>
-<body>
-  <div id="splash">
-    <!-- SVG noise texture — matte paper grain -->
-    <svg id="splash-noise" xmlns="http://www.w3.org/2000/svg">
-      <filter id="noiseFilter">
-        <feTurbulence type="fractalNoise" baseFrequency="0.65" numOctaves="3" stitchTiles="stitch"/>
-      </filter>
-      <rect width="100%" height="100%" filter="url(#noiseFilter)"/>
-    </svg>
-    <!-- Logo with animated agent nodes -->
-    <svg id="splash-logo" viewBox="0 0 56 56" width="56" height="56" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <rect class="splash-logo-bg" width="56" height="56" rx="14" fill="#151620"/>
-      <!-- Edges connecting nodes -->
-      <line class="splash-edge" x1="19" y1="19" x2="37" y2="19" stroke="#818cf8" stroke-width="2" stroke-linecap="round" opacity="0.35"/>
-      <line class="splash-edge" x1="37" y1="19" x2="28" y2="37" stroke="#a78bfa" stroke-width="2" stroke-linecap="round" opacity="0.35"/>
-      <line class="splash-edge" x1="28" y1="37" x2="19" y2="19" stroke="#c084fc" stroke-width="2" stroke-linecap="round" opacity="0.35"/>
-      <!-- Agent nodes -->
-      <circle class="splash-node splash-node-fill" style="animation-delay:0s" cx="19" cy="19" r="5.5" fill="#818cf8"/>
-      <circle class="splash-node splash-node-fill" style="animation-delay:1s" cx="37" cy="19" r="5.5" fill="#a78bfa"/>
-      <circle class="splash-node splash-node-fill" style="animation-delay:2s" cx="28" cy="37" r="6" fill="#c084fc"/>
-      <!-- Core highlights -->
-      <circle class="splash-node splash-core-fill" style="animation-delay:0s" cx="19" cy="19" r="2" fill="#e0e7ff"/>
-      <circle class="splash-node splash-core-fill" style="animation-delay:1s" cx="37" cy="19" r="2" fill="#ede9fe"/>
-      <circle class="splash-node splash-core-fill" style="animation-delay:2s" cx="28" cy="37" r="2.2" fill="#f3e8ff"/>
-    </svg>
-    <div id="splash-text">Agent Teams UI</div>
-  </div>
-  <div id="root"></div>
-  <script type="module" src="./main.tsx"></script>
-</body>
+        50% {
+          background-position: 50% 100%;
+        }
+        100% {
+          background-position: 50% 0%;
+        }
+      }
+      #splash-noise {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        opacity: 0.03;
+        pointer-events: none;
+        z-index: 0;
+      }
+      #splash-enhanced-canvas {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        pointer-events: none;
+        z-index: 1;
+        opacity: 1;
+      }
+      #splash-logo,
+      #splash-text {
+        position: relative;
+        z-index: 3;
+      }
+      #splash-logo {
+        margin-bottom: 18px;
+        animation:
+          splash-breathe 3s ease-in-out infinite,
+          splash-glow 3s ease-in-out infinite;
+      }
+      @keyframes splash-breathe {
+        0%,
+        100% {
+          transform: scale(1);
+        }
+        50% {
+          transform: scale(1.08);
+        }
+      }
+      @keyframes splash-glow {
+        0%,
+        100% {
+          filter: drop-shadow(0 0 12px rgba(129, 140, 248, 0.4))
+            drop-shadow(0 0 28px rgba(167, 139, 250, 0.18));
+        }
+        50% {
+          filter: drop-shadow(0 0 20px rgba(129, 140, 248, 0.6))
+            drop-shadow(0 0 42px rgba(167, 139, 250, 0.3));
+        }
+      }
+      #splash-text {
+        font-family:
+          ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace;
+        font-size: 15px;
+        font-weight: 500;
+        letter-spacing: 0.05em;
+        color: #a1a1aa;
+        text-shadow: 0 0 22px rgba(129, 140, 248, 0.26);
+      }
+
+      /* Logo node breathing — cycles through 3 agent nodes */
+      @keyframes splash-node {
+        0%,
+        100% {
+          opacity: 0.18;
+        }
+        12%,
+        28% {
+          opacity: 1;
+        }
+        45% {
+          opacity: 0.18;
+        }
+      }
+      .splash-node {
+        animation: splash-node 3s cubic-bezier(0.4, 0, 0.2, 1) infinite both;
+      }
+      .splash-edge {
+        transition: opacity 0.3s;
+      }
+
+      /* Light theme splash overrides */
+      :root.light #splash {
+        background: linear-gradient(
+          180deg,
+          #e0e7ff 0%,
+          #c7d2fe 18%,
+          #ddd6fe 36%,
+          #f0abfc 50%,
+          #ddd6fe 64%,
+          #c7d2fe 82%,
+          #e0e7ff 100%
+        );
+        background-size: 100% 300%;
+      }
+      :root.light #splash-text {
+        color: #52525b;
+      }
+      :root.light #splash-noise {
+        opacity: 0.02;
+      }
+      :root.light #splash-logo {
+        animation:
+          splash-breathe 3s ease-in-out infinite,
+          splash-glow-light 3s ease-in-out infinite;
+      }
+      @keyframes splash-glow-light {
+        0%,
+        100% {
+          filter: drop-shadow(0 0 10px rgba(79, 70, 229, 0.3))
+            drop-shadow(0 0 24px rgba(139, 92, 246, 0.15));
+        }
+        50% {
+          filter: drop-shadow(0 0 16px rgba(79, 70, 229, 0.45))
+            drop-shadow(0 0 36px rgba(139, 92, 246, 0.25));
+        }
+      }
+      @media (prefers-reduced-motion: reduce) {
+        #splash,
+        #splash-logo,
+        .splash-node {
+          animation: none !important;
+        }
+      }
+    </style>
+    <script>
+      // Flash prevention: Apply cached theme before React loads
+      (function () {
+        try {
+          window.__claudeTeamsSplashStartedAt = performance.now();
+          var theme = localStorage.getItem('claude-devtools-theme-cache');
+          if (theme === 'light') {
+            document.documentElement.classList.add('light');
+          }
+        } catch (e) {}
+      })();
+    </script>
+  </head>
+  <body>
+    <div id="splash">
+      <!-- SVG noise texture — matte paper grain -->
+      <svg id="splash-noise" xmlns="http://www.w3.org/2000/svg">
+        <filter id="noiseFilter">
+          <feTurbulence
+            type="fractalNoise"
+            baseFrequency="0.65"
+            numOctaves="3"
+            stitchTiles="stitch"
+          />
+        </filter>
+        <rect width="100%" height="100%" filter="url(#noiseFilter)" />
+      </svg>
+      <!-- Logo with animated agent nodes -->
+      <svg
+        id="splash-logo"
+        viewBox="0 0 56 56"
+        width="56"
+        height="56"
+        fill="none"
+        xmlns="http://www.w3.org/2000/svg"
+      >
+        <rect class="splash-logo-bg" width="56" height="56" rx="14" fill="#151620" />
+        <!-- Edges connecting nodes -->
+        <line
+          class="splash-edge"
+          x1="19"
+          y1="19"
+          x2="37"
+          y2="19"
+          stroke="#818cf8"
+          stroke-width="2"
+          stroke-linecap="round"
+          opacity="0.35"
+        />
+        <line
+          class="splash-edge"
+          x1="37"
+          y1="19"
+          x2="28"
+          y2="37"
+          stroke="#a78bfa"
+          stroke-width="2"
+          stroke-linecap="round"
+          opacity="0.35"
+        />
+        <line
+          class="splash-edge"
+          x1="28"
+          y1="37"
+          x2="19"
+          y2="19"
+          stroke="#c084fc"
+          stroke-width="2"
+          stroke-linecap="round"
+          opacity="0.35"
+        />
+        <!-- Agent nodes -->
+        <circle
+          class="splash-node splash-node-fill"
+          style="animation-delay: 0s"
+          cx="19"
+          cy="19"
+          r="5.5"
+          fill="#818cf8"
+        />
+        <circle
+          class="splash-node splash-node-fill"
+          style="animation-delay: 1s"
+          cx="37"
+          cy="19"
+          r="5.5"
+          fill="#a78bfa"
+        />
+        <circle
+          class="splash-node splash-node-fill"
+          style="animation-delay: 2s"
+          cx="28"
+          cy="37"
+          r="6"
+          fill="#c084fc"
+        />
+        <!-- Core highlights -->
+        <circle
+          class="splash-node splash-core-fill"
+          style="animation-delay: 0s"
+          cx="19"
+          cy="19"
+          r="2"
+          fill="#e0e7ff"
+        />
+        <circle
+          class="splash-node splash-core-fill"
+          style="animation-delay: 1s"
+          cx="37"
+          cy="19"
+          r="2"
+          fill="#ede9fe"
+        />
+        <circle
+          class="splash-node splash-core-fill"
+          style="animation-delay: 2s"
+          cx="28"
+          cy="37"
+          r="2.2"
+          fill="#f3e8ff"
+        />
+      </svg>
+      <div id="splash-text">Agent Teams UI</div>
+    </div>
+    <div id="root"></div>
+    <script type="module">
+      import { startSplashScene } from './components/splash/splashScene.ts';
+
+      const splash = document.getElementById('splash');
+      if (splash && !window.__claudeTeamsSplashScene) {
+        window.__claudeTeamsSplashScene = startSplashScene(splash);
+      }
+    </script>
+    <script type="module" src="./main.tsx"></script>
+  </body>
 </html>
diff --git a/src/renderer/utils/memberHelpers.ts b/src/renderer/utils/memberHelpers.ts
index 3ae2b0dd..86f128f4 100644
--- a/src/renderer/utils/memberHelpers.ts
+++ b/src/renderer/utils/memberHelpers.ts
@@ -312,6 +312,26 @@ function formatRuntimeAdvisoryBaseLabel(
   providerId: TeamProviderId | undefined
 ): string {
   const providerLabel = getRuntimeAdvisoryProviderLabel(providerId);
+  if (advisory.kind === 'api_error') {
+    switch (advisory.reasonCode) {
+      case 'quota_exhausted':
+        return providerLabel ? `${providerLabel} quota error` : 'Quota error';
+      case 'rate_limited':
+        return providerLabel ? `${providerLabel} rate limit` : 'Rate limit';
+      case 'auth_error':
+        return providerLabel ? `${providerLabel} auth error` : 'Auth error';
+      case 'network_error':
+        return 'Network error';
+      case 'provider_overloaded':
+        return providerLabel ? `${providerLabel} overload` : 'Provider overload';
+      case 'backend_error':
+      case 'unknown':
+        return providerLabel ? `${providerLabel} API error` : 'API error';
+      default:
+        return 'API error';
+    }
+  }
+
   switch (advisory.reasonCode) {
     case 'quota_exhausted':
       return providerLabel ? `${providerLabel} quota retry` : 'Quota retry';
@@ -336,6 +356,41 @@ function formatRuntimeAdvisoryTitle(
   providerId: TeamProviderId | undefined
 ): string {
   const providerLabel = getRuntimeAdvisoryProviderLabel(providerId);
+  if (advisory.kind === 'api_error') {
+    switch (advisory.reasonCode) {
+      case 'quota_exhausted':
+        return appendRuntimeAdvisoryRawMessage(
+          `${providerLabel ?? 'Provider'} quota exhausted.`,
+          advisory.message
+        );
+      case 'rate_limited':
+        return appendRuntimeAdvisoryRawMessage(
+          `${providerLabel ?? 'Provider'} rate limited the request.`,
+          advisory.message
+        );
+      case 'auth_error':
+        return appendRuntimeAdvisoryRawMessage(
+          `${providerLabel ?? 'Provider'} authentication error.`,
+          advisory.message
+        );
+      case 'network_error':
+        return appendRuntimeAdvisoryRawMessage('Network or connectivity error.', advisory.message);
+      case 'provider_overloaded':
+        return appendRuntimeAdvisoryRawMessage(
+          'Provider is temporarily overloaded.',
+          advisory.message
+        );
+      case 'backend_error':
+      case 'unknown':
+        return appendRuntimeAdvisoryRawMessage(
+          `${providerLabel ?? 'Provider'} API error.`,
+          advisory.message
+        );
+      default:
+        return advisory.message?.trim() || 'Provider API error.';
+    }
+  }
+
   switch (advisory.reasonCode) {
     case 'quota_exhausted':
       return appendRuntimeAdvisoryRawMessage(
@@ -381,11 +436,17 @@ export function getMemberRuntimeAdvisoryLabel(
   providerId?: TeamProviderId,
   nowMs = Date.now()
 ): string | null {
-  if (advisory?.kind !== 'sdk_retrying') {
+  if (!advisory) {
     return null;
   }
   const baseLabel = formatRuntimeAdvisoryBaseLabel(advisory, providerId);
-  const retryUntilMs = Date.parse(advisory.retryUntil);
+  if (advisory.kind === 'api_error') {
+    return baseLabel;
+  }
+  if (advisory.kind !== 'sdk_retrying') {
+    return null;
+  }
+  const retryUntilMs = advisory.retryUntil ? Date.parse(advisory.retryUntil) : Number.NaN;
   if (!Number.isFinite(retryUntilMs)) {
     return baseLabel;
   }
@@ -400,12 +461,21 @@ export function getMemberRuntimeAdvisoryTitle(
   advisory: MemberRuntimeAdvisory | undefined,
   providerId?: TeamProviderId
 ): string | undefined {
-  if (advisory?.kind !== 'sdk_retrying') {
+  if (!advisory || (advisory.kind !== 'sdk_retrying' && advisory.kind !== 'api_error')) {
     return undefined;
   }
   return formatRuntimeAdvisoryTitle(advisory, providerId);
 }
 
+export function getMemberRuntimeAdvisoryTone(
+  advisory: MemberRuntimeAdvisory | undefined
+): 'error' | 'warning' | null {
+  if (!advisory) {
+    return null;
+  }
+  return advisory.kind === 'api_error' ? 'error' : 'warning';
+}
+
 export function getLaunchAwarePresenceLabel(
   member: ResolvedTeamMember,
   spawnStatus: MemberSpawnStatus | undefined,
@@ -457,6 +527,7 @@ export interface MemberLaunchPresentation {
   cardClass: string;
   runtimeAdvisoryLabel: string | null;
   runtimeAdvisoryTitle?: string;
+  runtimeAdvisoryTone: 'error' | 'warning' | null;
   launchVisualState: MemberLaunchVisualState;
   launchStatusLabel: string | null;
   spawnBadgeLabel: string | null;
@@ -536,6 +607,7 @@ export function buildMemberLaunchPresentation({
   );
   const runtimeAdvisoryLabel = getMemberRuntimeAdvisoryLabel(runtimeAdvisory, member.providerId);
   const runtimeAdvisoryTitle = getMemberRuntimeAdvisoryTitle(runtimeAdvisory, member.providerId);
+  const runtimeAdvisoryTone = getMemberRuntimeAdvisoryTone(runtimeAdvisory);
   const keepLaunchSettlingVisuals = isTeamProvisioning === true || isLaunchSettling;
 
   let launchVisualState: MemberLaunchVisualState = null;
@@ -578,10 +650,11 @@ export function buildMemberLaunchPresentation({
 
   return {
     presenceLabel,
-    dotClass,
+    dotClass: runtimeAdvisoryTone === 'error' ? STATUS_DOT_COLORS.terminated : dotClass,
     cardClass,
     runtimeAdvisoryLabel,
     runtimeAdvisoryTitle,
+    runtimeAdvisoryTone,
     launchVisualState,
     launchStatusLabel,
     spawnBadgeLabel,
diff --git a/src/shared/types/team.ts b/src/shared/types/team.ts
index 6e87ec12..8dcac0af 100644
--- a/src/shared/types/team.ts
+++ b/src/shared/types/team.ts
@@ -734,10 +734,10 @@ export interface ResolvedTeamMember {
 }
 
 export interface MemberRuntimeAdvisory {
-  kind: 'sdk_retrying';
+  kind: 'sdk_retrying' | 'api_error';
   observedAt: string;
-  retryUntil: string;
-  retryDelayMs: number;
+  retryUntil?: string;
+  retryDelayMs?: number;
   reasonCode?:
     | 'quota_exhausted'
     | 'rate_limited'
@@ -747,6 +747,7 @@ export interface MemberRuntimeAdvisory {
     | 'backend_error'
     | 'unknown';
   message?: string;
+  statusCode?: number;
 }
 
 export interface TeamProcess {
diff --git a/src/shared/utils/__tests__/ephemeralProjectPath.test.ts b/src/shared/utils/__tests__/ephemeralProjectPath.test.ts
new file mode 100644
index 00000000..63ef1877
--- /dev/null
+++ b/src/shared/utils/__tests__/ephemeralProjectPath.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEphemeralProjectPath } from '../ephemeralProjectPath';
+
+function absolutePath(...segments: string[]): string {
+  return `/${segments.join('/')}`;
+}
+
+describe('isEphemeralProjectPath', () => {
+  it('detects generated MCP project paths', () => {
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'rendered_mcp_config', 'project'))).toBe(
+      true
+    );
+    expect(isEphemeralProjectPath('/Users/test/rendered_mcp_123/project')).toBe(true);
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'portable-mcp-live', 'project'))).toBe(true);
+  });
+
+  it('detects Codex appstyle temp workspaces only under temp roots', () => {
+    expect(
+      isEphemeralProjectPath(
+        '/private/var/folders/7b/ydmc_b0n251bc4hss4tz8y880000gn/T/codex-agent-teams-appstyle-zudek6i9'
+      )
+    ).toBe(true);
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'codex-agent-teams-appstyle-zudek6i9'))).toBe(
+      true
+    );
+    expect(
+      isEphemeralProjectPath(
+        'C:\\Users\\test\\AppData\\Local\\Temp\\codex-agent-teams-appstyle-zudek6i9'
+      )
+    ).toBe(true);
+    expect(isEphemeralProjectPath('/Users/test/projects/codex-agent-teams-appstyle-real')).toBe(
+      false
+    );
+  });
+
+  it('keeps normal project paths selectable', () => {
+    expect(isEphemeralProjectPath('/Users/test/projects/claude_team')).toBe(false);
+    expect(isEphemeralProjectPath('')).toBe(false);
+    expect(isEphemeralProjectPath(null)).toBe(false);
+  });
+});
diff --git a/src/shared/utils/ephemeralProjectPath.ts b/src/shared/utils/ephemeralProjectPath.ts
new file mode 100644
index 00000000..00ddc4cd
--- /dev/null
+++ b/src/shared/utils/ephemeralProjectPath.ts
@@ -0,0 +1,41 @@
+const TMP_SEGMENT = 'tmp';
+const POSIX_TMP_ROOT = `/${TMP_SEGMENT}/`;
+const PRIVATE_TMP_ROOT = `/private/${TMP_SEGMENT}/`;
+
+function normalizePathForEphemeralCheck(projectPath: string): string {
+  return projectPath.trim().replace(/\\/g, '/').toLowerCase();
+}
+
+function getBasename(normalizedPath: string): string {
+  const segments = normalizedPath.split('/').filter(Boolean);
+  return segments[segments.length - 1] ?? '';
+}
+
+function isKnownTempRoot(normalizedPath: string): boolean {
+  return (
+    normalizedPath.startsWith('/private/var/folders/') ||
+    normalizedPath.startsWith('/var/folders/') ||
+    normalizedPath.startsWith(PRIVATE_TMP_ROOT) ||
+    normalizedPath.startsWith(POSIX_TMP_ROOT) ||
+    normalizedPath.includes('/appdata/local/temp/') ||
+    normalizedPath.includes('/appdata/locallow/temp/')
+  );
+}
+
+export function isEphemeralProjectPath(projectPath: string | null | undefined): boolean {
+  const normalizedPath = normalizePathForEphemeralCheck(projectPath ?? '');
+  if (!normalizedPath) {
+    return false;
+  }
+
+  if (
+    normalizedPath.includes('rendered_mcp_') ||
+    normalizedPath.includes('rendered_mcp_config') ||
+    normalizedPath.includes('/portable-mcp-live')
+  ) {
+    return true;
+  }
+
+  const basename = getBasename(normalizedPath);
+  return basename.startsWith('codex-agent-teams-appstyle-') && isKnownTempRoot(normalizedPath);
+}
diff --git a/test/features/recent-projects/main/adapters/output/CodexRecentProjectsSourceAdapter.test.ts b/test/features/recent-projects/main/adapters/output/CodexRecentProjectsSourceAdapter.test.ts
index 40b2f9ee..634aabff 100644
--- a/test/features/recent-projects/main/adapters/output/CodexRecentProjectsSourceAdapter.test.ts
+++ b/test/features/recent-projects/main/adapters/output/CodexRecentProjectsSourceAdapter.test.ts
@@ -133,9 +133,12 @@ describe('CodexRecentProjectsSourceAdapter', () => {
 
     expect(appServerClient.listRecentThreads).toHaveBeenCalledTimes(1);
     expect(appServerClient.listRecentLiveThreads).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith('codex recent-projects recovered with live-only fallback', {
-      liveCount: 1,
-    });
+    expect(logger.info).toHaveBeenCalledWith(
+      'codex recent-projects recovered with live-only fallback',
+      {
+        liveCount: 1,
+      }
+    );
   });
 
   it('does not spend extra time on live-only fallback after a full session timeout', async () => {
@@ -165,4 +168,45 @@ describe('CodexRecentProjectsSourceAdapter', () => {
     });
     expect(appServerClient.listRecentLiveThreads).not.toHaveBeenCalled();
   });
+
+  it('drops Codex appstyle temp workspaces from dashboard candidates', async () => {
+    const logger = createLogger();
+    const appServerClient = {
+      listRecentThreads: vi.fn().mockResolvedValue({
+        live: {
+          threads: [
+            {
+              id: 'thread-temp',
+              cwd: '/private/var/folders/7b/cache/T/codex-agent-teams-appstyle-zudek6i9',
+              source: 'cli',
+              updatedAt: 1_700_000_000,
+            },
+          ],
+        },
+        archived: {
+          threads: [],
+        },
+      }),
+      listRecentLiveThreads: vi.fn(),
+    } as unknown as CodexAppServerClient;
+    const identityResolver = {
+      resolve: vi.fn(),
+    } as unknown as RecentProjectIdentityResolver;
+
+    const adapter = new CodexRecentProjectsSourceAdapter({
+      getActiveContext: () => ({ type: 'local', id: 'local-1' }) as never,
+      getLocalContext: () => ({ type: 'local', id: 'local-1' }) as never,
+      resolveBinary: vi.fn().mockResolvedValue('/usr/local/bin/codex'),
+      appServerClient,
+      identityResolver,
+      logger,
+    });
+
+    await expect(adapter.list()).resolves.toEqual({
+      candidates: [],
+      degraded: false,
+    });
+
+    expect(identityResolver.resolve).not.toHaveBeenCalled();
+  });
 });
diff --git a/test/features/recent-projects/renderer/utils/recentProjectOpenHistory.test.ts b/test/features/recent-projects/renderer/utils/recentProjectOpenHistory.test.ts
index 12b489e8..147ae8b6 100644
--- a/test/features/recent-projects/renderer/utils/recentProjectOpenHistory.test.ts
+++ b/test/features/recent-projects/renderer/utils/recentProjectOpenHistory.test.ts
@@ -9,9 +9,7 @@ import {
 
 import type { DashboardRecentProject } from '@features/recent-projects/contracts';
 
-function makeProject(
-  overrides: Partial<DashboardRecentProject> = {}
-): DashboardRecentProject {
+function makeProject(overrides: Partial<DashboardRecentProject> = {}): DashboardRecentProject {
   return {
     id: 'repo:alpha',
     name: 'alpha',
@@ -130,4 +128,28 @@ describe('recentProjectOpenHistory', () => {
       )
     ).toBe(0);
   });
+
+  it('does not record generated ephemeral project paths', () => {
+    recordRecentProjectOpenPaths(
+      ['/private/var/folders/7b/cache/T/codex-agent-teams-appstyle-zudek6i9', '/workspace/opened'],
+      10_000
+    );
+
+    expect(
+      getRecentProjectLastOpenedAt(
+        makeProject({
+          primaryPath: '/private/var/folders/7b/cache/T/codex-agent-teams-appstyle-zudek6i9',
+          associatedPaths: ['/private/var/folders/7b/cache/T/codex-agent-teams-appstyle-zudek6i9'],
+        })
+      )
+    ).toBe(0);
+    expect(
+      getRecentProjectLastOpenedAt(
+        makeProject({
+          primaryPath: '/workspace/opened',
+          associatedPaths: ['/workspace/opened'],
+        })
+      )
+    ).toBe(10_000);
+  });
 });
diff --git a/test/main/services/runtime/CliProviderModelAvailabilityService.test.ts b/test/main/services/runtime/CliProviderModelAvailabilityService.test.ts
index f0afb968..541cebb7 100644
--- a/test/main/services/runtime/CliProviderModelAvailabilityService.test.ts
+++ b/test/main/services/runtime/CliProviderModelAvailabilityService.test.ts
@@ -153,7 +153,7 @@ describe('CliProviderModelAvailabilityService', () => {
     });
   });
 
-  it('passes provider launch args into codex model probes', async () => {
+  it('passes provider launch args before codex model probe flags', async () => {
     buildProviderAwareCliEnvMock.mockResolvedValue({
       env: { HOME: '/Users/tester' },
       providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
@@ -167,10 +167,19 @@ describe('CliProviderModelAvailabilityService', () => {
     await vi.waitFor(() => {
       expect(execCliMock).toHaveBeenCalledWith(
         '/usr/local/bin/claude',
-        expect.arrayContaining([
+        [
           '--settings',
           '{"codex":{"forced_login_method":"chatgpt"}}',
-        ]),
+          '-p',
+          'Output only the single word PONG.',
+          '--output-format',
+          'text',
+          '--model',
+          'gpt-5.4',
+          '--max-turns',
+          '1',
+          '--no-session-persistence',
+        ],
         expect.objectContaining({
           env: { HOME: '/Users/tester' },
         })
diff --git a/test/main/services/team/TeamAgentLaunchMatrix.safe-e2e.test.ts b/test/main/services/team/TeamAgentLaunchMatrix.safe-e2e.test.ts
index 0d96159a..273f4ac9 100644
--- a/test/main/services/team/TeamAgentLaunchMatrix.safe-e2e.test.ts
+++ b/test/main/services/team/TeamAgentLaunchMatrix.safe-e2e.test.ts
@@ -487,6 +487,1163 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('does not resurrect removed OpenCode secondary teammates in mixed Anthropic launch recovery', async () => {
+    const teamName = 'mixed-anthropic-removed-opencode-stale-state-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, { primaryProviderId: 'anthropic', removedMembers: ['tom'] });
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+          laneId: 'secondary:opencode:bob',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        tom: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/nemotron-3-super-free',
+          laneId: 'secondary:opencode:tom',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'stale removed OpenCode lane failure',
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 0,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toBeUndefined();
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+    expect(runtimeSnapshot.members.tom).toBeUndefined();
+  });
+
+  it('keeps active suffixed OpenCode secondary teammates in mixed Anthropic recovery', async () => {
+    const teamName = 'mixed-anthropic-suffixed-opencode-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      primaryProviderId: 'anthropic',
+      removedMembers: ['bob', 'tom'],
+      extraMembers: [
+        {
+          name: 'bob-2',
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+        },
+      ],
+    });
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        'bob-2': mixedMemberState({
+          name: 'bob-2',
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+          laneId: 'secondary:opencode:bob-2',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob-2']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.statuses.bob).toBeUndefined();
+    expect(statuses.statuses.tom).toBeUndefined();
+    expect(statuses.statuses['bob-2']).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toBeUndefined();
+    expect(runtimeSnapshot.members.tom).toBeUndefined();
+    expect(runtimeSnapshot.members['bob-2']).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+  });
+
+  it('ignores stale active OpenCode lane index entries for removed teammates in mixed Anthropic recovery', async () => {
+    const teamName = 'mixed-anthropic-removed-stale-lane-index-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      primaryProviderId: 'anthropic',
+      removedMembers: ['bob', 'tom'],
+    });
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:bob',
+      state: 'active',
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:tom',
+      state: 'active',
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toBeUndefined();
+    expect(statuses.statuses.tom).toBeUndefined();
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.bob).toBeUndefined();
+    expect(runtimeSnapshot.members.tom).toBeUndefined();
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {
+        'secondary:opencode:bob': { state: 'active' },
+        'secondary:opencode:tom': { state: 'active' },
+      },
+    });
+  });
+
+  it('recovers pure Anthropic status and model metadata from persisted state after service restart', async () => {
+    const teamName = 'pure-persisted-anthropic-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 0,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('recovers pure Anthropic partial failure from persisted state after service restart', async () => {
+    const teamName = 'pure-persisted-anthropic-failure-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'Anthropic pane exited before bootstrap',
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'Anthropic pane exited before bootstrap',
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('does not resurrect removed pure Anthropic teammates from stale persisted launch state', async () => {
+    const teamName = 'pure-anthropic-removed-member-stale-state-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName, { removedMembers: ['bob'] });
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      expectedMembers: ['alice', 'bob'],
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'stale removed member failure',
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toBeUndefined();
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.bob).toBeUndefined();
+  });
+
+  it('keeps active suffixed pure Anthropic teammates when the removed base member is stale', async () => {
+    const teamName = 'pure-anthropic-suffixed-active-member-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName, {
+      removedMembers: ['bob'],
+      extraMembers: [{ name: 'bob-2', providerId: 'anthropic', model: 'sonnet' }],
+    });
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      expectedMembers: ['alice', 'bob-2'],
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        'bob-2': mixedMemberState({
+          name: 'bob-2',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob-2']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.statuses.bob).toBeUndefined();
+    expect(statuses.statuses['bob-2']).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toBeUndefined();
+    expect(runtimeSnapshot.members['bob-2']).toMatchObject({
+      providerId: 'anthropic',
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('filters removed pure Anthropic teammates from bootstrap-only launch recovery', async () => {
+    const teamName = 'pure-anthropic-removed-bootstrap-state-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName, { removedMembers: ['bob'] });
+    await writeBootstrapState(teamName, [
+      {
+        name: 'alice',
+        status: 'bootstrap_confirmed',
+        lastAttemptAt: Date.parse('2026-04-23T10:00:00.000Z'),
+        lastObservedAt: Date.parse('2026-04-23T10:00:05.000Z'),
+      },
+      {
+        name: 'bob',
+        status: 'failed',
+        lastAttemptAt: Date.parse('2026-04-23T10:00:00.000Z'),
+        lastObservedAt: Date.parse('2026-04-23T10:00:04.000Z'),
+        failureReason: 'stale removed bootstrap failure',
+      },
+    ]);
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice']);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      bootstrapConfirmed: true,
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toBeUndefined();
+  });
+
+  it('recovers pure Anthropic runtime-pending bootstrap from persisted state after service restart', async () => {
+    const teamName = 'pure-persisted-anthropic-bootstrap-pending-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'runtime_pending_bootstrap',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_bootstrap',
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+    });
+  });
+
+  it('recovers pure Anthropic runtime-pending permission from persisted state after service restart', async () => {
+    const teamName = 'pure-persisted-anthropic-permission-pending-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'runtime_pending_permission',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+          pendingPermissionRequestIds: ['perm-bob'],
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      runtimeAlive: true,
+      pendingPermissionRequestIds: ['perm-bob'],
+      hardFailure: false,
+    });
+  });
+
+  it('keeps active pure Anthropic starting teammates pending after service restart', async () => {
+    const teamName = 'pure-active-anthropic-starting-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'active',
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'starting',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.launchPhase).toBe('active');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'spawning',
+      launchState: 'starting',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'anthropic',
+      alive: false,
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('fails finished pure Anthropic starting teammates after service restart', async () => {
+    const teamName = 'pure-finished-anthropic-never-spawned-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'finished',
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'starting',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.launchPhase).toBe('finished');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      hardFailure: true,
+      hardFailureReason: 'Teammate was never spawned during launch.',
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'anthropic',
+      alive: false,
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('keeps active pure Anthropic missing member state pending after service restart', async () => {
+    const teamName = 'pure-active-anthropic-missing-state-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'active',
+      expectedMembers: ['alice', 'bob'],
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.launchPhase).toBe('active');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'spawning',
+      launchState: 'starting',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      hardFailure: false,
+    });
+  });
+
+  it('fails finished pure Anthropic missing member state after service restart', async () => {
+    const teamName = 'pure-finished-anthropic-missing-state-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'finished',
+      expectedMembers: ['alice', 'bob'],
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.launchPhase).toBe('finished');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      hardFailure: true,
+      hardFailureReason: 'Teammate was never spawned during launch.',
+    });
+  });
+
+  it('recovers legacy pure Anthropic partial launch marker without leaving missing teammates joining', async () => {
+    const teamName = 'legacy-pure-anthropic-partial-marker-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writeLegacyPartialLaunchState({
+      teamName,
+      expectedMembers: ['alice', 'bob'],
+      confirmedMembers: ['alice'],
+      missingMembers: ['bob'],
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'bob']);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.launchPhase).toBe('reconciled');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 0,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      agentToolAccepted: true,
+      runtimeAlive: false,
+      bootstrapConfirmed: true,
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: true,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: true,
+      hardFailureReason: 'Legacy partial launch marker reported teammate missing.',
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'anthropic',
+      alive: false,
+      runtimeModel: 'sonnet',
+    });
+  });
+
+  it('keeps finished pure Anthropic runtime-pending bootstrap teammates pending after service restart', async () => {
+    const teamName = 'pure-finished-anthropic-bootstrap-pending-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'finished',
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'runtime_pending_bootstrap',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.launchPhase).toBe('finished');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_bootstrap',
+      agentToolAccepted: true,
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+    });
+  });
+
+  it('keeps finished pure Anthropic runtime-pending permission teammates pending after service restart', async () => {
+    const teamName = 'pure-finished-anthropic-permission-pending-safe-e2e';
+    await writePureAnthropicTeamConfig({ teamName, projectPath });
+    await writePureAnthropicTeamMeta(teamName, projectPath);
+    await writePureAnthropicMembersMeta(teamName);
+    await writePureAnthropicTeamLaunchState({
+      teamName,
+      launchPhase: 'finished',
+      members: {
+        alice: mixedMemberState({
+          name: 'alice',
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          name: 'bob',
+          providerId: 'anthropic',
+          model: 'sonnet',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'runtime_pending_permission',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+          pendingPermissionRequestIds: ['perm-bob'],
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.launchPhase).toBe('finished');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 1,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      agentToolAccepted: true,
+      runtimeAlive: true,
+      pendingPermissionRequestIds: ['perm-bob'],
+      hardFailure: false,
+    });
+  });
+
+  it('recovers mixed Anthropic and Gemini failure with split OpenCode lane truth after service restart', async () => {
+    const teamName = 'mixed-persisted-anthropic-gemini-failure-opencode-split-safe-e2e';
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        reviewer: mixedMemberState({
+          providerId: 'gemini',
+          model: 'gemini-2.5-flash',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'gemini',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'Gemini pane exited before bootstrap',
+        }),
+        bob: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+          laneId: 'secondary:opencode:bob',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        tom: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/nemotron-3-super-free',
+          laneId: 'secondary:opencode:tom',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'runtime_pending_permission',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+          pendingPermissionRequestIds: ['perm-tom'],
+        }),
+      },
+    });
+
+    const restartedService = new TeamProvisioningService();
+    const statuses = await restartedService.getMemberSpawnStatuses(teamName);
+
+    expect(statuses.expectedMembers).toEqual(['alice', 'reviewer', 'bob', 'tom']);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 1,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.reviewer).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'Gemini pane exited before bootstrap',
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      hardFailure: false,
+      pendingPermissionRequestIds: ['perm-tom'],
+    });
+
+    const runtimeSnapshot = await restartedService.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.reviewer).toMatchObject({
+      providerId: 'gemini',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'gemini-2.5-flash',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/nemotron-3-super-free',
+    });
+  });
+
   it('recovers mixed Gemini failure and split OpenCode lane truth after service restart', async () => {
     const teamName = 'mixed-persisted-gemini-failure-opencode-split-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath, includeGeminiPrimary: true });
@@ -882,6 +2039,133 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps OpenCode side-lane pid and memory visible after Anthropic and Gemini mixed failure recovery', async () => {
+    const teamName = 'mixed-anthropic-gemini-failure-opencode-memory-safe-e2e';
+    const sharedHostPid = 51_515;
+    const sharedRssBytes = 219.2 * 1024 * 1024;
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        reviewer: mixedMemberState({
+          providerId: 'gemini',
+          model: 'gemini-2.5-flash',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'gemini',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'Gemini pane exited before bootstrap',
+        }),
+        bob: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+          laneId: 'secondary:opencode:bob',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        tom: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/nemotron-3-super-free',
+          laneId: 'secondary:opencode:tom',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'runtime_pending_permission',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+          pendingPermissionRequestIds: ['perm-tom'],
+        }),
+      },
+    });
+    const svc = new TeamProvisioningService();
+    (svc as any).getLiveTeamAgentRuntimeMetadata = async () =>
+      new Map([
+        [
+          'bob',
+          {
+            alive: true,
+            metricsPid: sharedHostPid,
+            model: 'opencode/minimax-m2.5-free',
+          },
+        ],
+        [
+          'tom',
+          {
+            alive: true,
+            metricsPid: sharedHostPid,
+            model: 'opencode/nemotron-3-super-free',
+          },
+        ],
+      ]);
+    (svc as any).readProcessRssBytesByPid = async () => new Map([[sharedHostPid, sharedRssBytes]]);
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.reviewer).toMatchObject({
+      providerId: 'gemini',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'gemini-2.5-flash',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:bob',
+      laneKind: 'secondary',
+      alive: true,
+      restartable: false,
+      pid: sharedHostPid,
+      runtimeModel: 'opencode/minimax-m2.5-free',
+      rssBytes: sharedRssBytes,
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:tom',
+      laneKind: 'secondary',
+      alive: true,
+      restartable: false,
+      pid: sharedHostPid,
+      runtimeModel: 'opencode/nemotron-3-super-free',
+      rssBytes: sharedRssBytes,
+    });
+  });
+
   it('infers OpenCode runtime provider from model after restart when provider metadata is missing', async () => {
     const teamName = 'mixed-opencode-model-inference-safe-e2e';
     const sharedHostPid = 24_243;
@@ -1286,6 +2570,126 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps Anthropic mixed launch pending while primary is still joining and OpenCode lanes are ready', async () => {
+    const teamName = 'mixed-anthropic-starting-opencode-ready-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+    run.memberSpawnStatuses.set('alice', {
+      status: 'starting',
+      launchState: 'starting',
+      agentToolAccepted: true,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+      lastEvaluatedAt: '2026-04-23T10:00:00.000Z',
+      updatedAt: '2026-04-23T10:00:00.000Z',
+    });
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'confirmed_alive');
+    await waitForCondition(() => run.memberSpawnStatuses.get('tom')?.launchState === 'confirmed_alive');
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 1,
+      failedCount: 0,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'waiting',
+      launchState: 'runtime_pending_bootstrap',
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      bootstrapConfirmed: true,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      bootstrapConfirmed: true,
+    });
+  });
+
+  it('keeps Anthropic mixed launch pending while primary awaits permission and OpenCode lanes are ready', async () => {
+    const teamName = 'mixed-anthropic-permission-opencode-ready-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+    run.memberSpawnStatuses.set('alice', {
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      agentToolAccepted: true,
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+      pendingPermissionRequestIds: ['perm-alice'],
+      lastRuntimeAliveAt: '2026-04-23T10:00:00.000Z',
+      lastEvaluatedAt: '2026-04-23T10:00:00.000Z',
+      updatedAt: '2026-04-23T10:00:00.000Z',
+    });
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'confirmed_alive');
+    await waitForCondition(() => run.memberSpawnStatuses.get('tom')?.launchState === 'confirmed_alive');
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 1,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      pendingPermissionRequestIds: ['perm-alice'],
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      bootstrapConfirmed: true,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      bootstrapConfirmed: true,
+    });
+  });
+
   it('keeps Anthropic primary online while mixed OpenCode lanes split ready and bootstrap pending', async () => {
     const teamName = 'mixed-anthropic-opencode-split-bootstrap-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
@@ -1357,6 +2761,225 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps mixed Anthropic launch partial when Gemini primary fails and OpenCode lanes split ready and bootstrap pending', async () => {
+    const teamName = 'mixed-anthropic-gemini-failed-opencode-split-safe-e2e';
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'launching',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const reviewer = {
+      name: 'reviewer',
+      role: 'Reviewer',
+      providerId: 'gemini',
+      model: 'gemini-2.5-flash',
+    };
+    run.expectedMembers = ['alice', 'reviewer'];
+    run.effectiveMembers = [...run.effectiveMembers, reviewer];
+    run.allEffectiveMembers = [
+      ...run.effectiveMembers,
+      ...run.allEffectiveMembers.filter((member: { providerId?: string }) => member.providerId === 'opencode'),
+    ];
+    run.memberSpawnStatuses.set('reviewer', {
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: true,
+      hardFailureReason: 'Gemini pane exited before bootstrap',
+      lastEvaluatedAt: '2026-04-23T10:00:00.000Z',
+      updatedAt: '2026-04-23T10:00:00.000Z',
+    });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(
+      () => run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'confirmed_alive');
+    await waitForCondition(
+      () => run.memberSpawnStatuses.get('tom')?.launchState === 'runtime_pending_bootstrap'
+    );
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      pendingCount: 1,
+      failedCount: 1,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.reviewer).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'Gemini pane exited before bootstrap',
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      bootstrapConfirmed: true,
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_bootstrap',
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: true,
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.reviewer).toMatchObject({
+      providerId: 'gemini',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'gemini-2.5-flash',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      alive: true,
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneKind: 'secondary',
+      alive: true,
+      runtimeModel: 'opencode/nemotron-3-super-free',
+    });
+  });
+
+  it('keeps OpenCode side-lane pid and memory visible during mixed Anthropic launch when Gemini failed and a sibling lane is still bootstrapping', async () => {
+    const teamName = 'mixed-anthropic-gemini-bootstrap-memory-safe-e2e';
+    const sharedHostPid = 52_525;
+    const sharedRssBytes = 221.7 * 1024 * 1024;
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'launching',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const reviewer = {
+      name: 'reviewer',
+      role: 'Reviewer',
+      providerId: 'gemini',
+      model: 'gemini-2.5-flash',
+    };
+    run.expectedMembers = ['alice', 'reviewer'];
+    run.effectiveMembers = [...run.effectiveMembers, reviewer];
+    run.allEffectiveMembers = [
+      ...run.effectiveMembers,
+      ...run.allEffectiveMembers.filter((member: { providerId?: string }) => member.providerId === 'opencode'),
+    ];
+    run.memberSpawnStatuses.set('reviewer', {
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: true,
+      hardFailureReason: 'Gemini pane exited before bootstrap',
+      lastEvaluatedAt: '2026-04-23T10:00:00.000Z',
+      updatedAt: '2026-04-23T10:00:00.000Z',
+    });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(
+      () => run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'confirmed_alive');
+    await waitForCondition(
+      () => run.memberSpawnStatuses.get('tom')?.launchState === 'runtime_pending_bootstrap'
+    );
+
+    ;(svc as any).getLiveTeamAgentRuntimeMetadata = async () =>
+      new Map([
+        [
+          'bob',
+          {
+            alive: true,
+            metricsPid: sharedHostPid,
+            model: 'opencode/minimax-m2.5-free',
+          },
+        ],
+        [
+          'tom',
+          {
+            alive: true,
+            metricsPid: sharedHostPid,
+            model: 'opencode/nemotron-3-super-free',
+          },
+        ],
+      ]);
+    ;(svc as any).readProcessRssBytesByPid = async () => new Map([[sharedHostPid, sharedRssBytes]]);
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.reviewer).toMatchObject({
+      providerId: 'gemini',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'gemini-2.5-flash',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:bob',
+      laneKind: 'secondary',
+      alive: true,
+      restartable: false,
+      pid: sharedHostPid,
+      runtimeModel: 'opencode/minimax-m2.5-free',
+      rssBytes: sharedRssBytes,
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:tom',
+      laneKind: 'secondary',
+      alive: true,
+      restartable: false,
+      pid: sharedHostPid,
+      runtimeModel: 'opencode/nemotron-3-super-free',
+      rssBytes: sharedRssBytes,
+    });
+  });
+
   it('keeps mixed launch partial when Gemini primary fails and OpenCode lanes split ready and pending', async () => {
     const teamName = 'mixed-gemini-failed-opencode-split-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath, includeGeminiPrimary: true });
@@ -1475,6 +3098,58 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps Anthropic primary online when a mixed OpenCode secondary lane fails', async () => {
+    const teamName = 'mixed-anthropic-secondary-failure-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'failed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'failed_to_start');
+    await waitForCondition(() => run.memberSpawnStatuses.get('tom')?.launchState === 'confirmed_alive');
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'fake_open_code_launch_failure',
+    });
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: true,
+      runtimeModel: 'haiku',
+    });
+  });
+
   it('keeps OpenCode secondary lanes online when the primary Codex member failed to spawn', async () => {
     const teamName = 'mixed-primary-failure-opencode-ready-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1544,6 +3219,81 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps OpenCode secondary lanes online when the primary Anthropic member failed to spawn', async () => {
+    const teamName = 'mixed-anthropic-primary-failure-opencode-ready-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+    run.memberSpawnStatuses.set('alice', {
+      status: 'error',
+      launchState: 'failed_to_start',
+      agentToolAccepted: false,
+      runtimeAlive: false,
+      bootstrapConfirmed: false,
+      hardFailure: true,
+      hardFailureReason: 'Anthropic pane exited before bootstrap',
+      lastEvaluatedAt: '2026-04-23T10:00:00.000Z',
+      updatedAt: '2026-04-23T10:00:00.000Z',
+    });
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    await waitForCondition(() => run.memberSpawnStatuses.get('bob')?.launchState === 'confirmed_alive');
+    await waitForCondition(() => run.memberSpawnStatuses.get('tom')?.launchState === 'confirmed_alive');
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 2,
+      failedCount: 1,
+    });
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'Anthropic pane exited before bootstrap',
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: false,
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:bob',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:tom',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/nemotron-3-super-free',
+    });
+  });
+
   it('fails mixed OpenCode secondary lanes clearly when the runtime adapter is not registered', async () => {
     const teamName = 'mixed-missing-opencode-adapter-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1582,6 +3332,52 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('keeps Anthropic primary online when OpenCode secondary adapter is not registered', async () => {
+    const teamName = 'mixed-anthropic-missing-opencode-adapter-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const svc = new TeamProvisioningService();
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    const snapshot = await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+
+    expect(snapshot).toMatchObject({
+      teamName,
+      teamLaunchState: 'partial_failure',
+    });
+    expect(run.mixedSecondaryLanes.map((lane: { state: string }) => lane.state)).toEqual([
+      'finished',
+      'finished',
+    ]);
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'opencode_runtime_adapter_missing',
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailure: true,
+      hardFailureReason: 'opencode_runtime_adapter_missing',
+    });
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      alive: true,
+      runtimeModel: 'haiku',
+    });
+  });
+
   it('restarts one mixed OpenCode secondary lane without touching other live teammates', async () => {
     const teamName = 'mixed-opencode-manual-restart-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1634,6 +3430,78 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('restarts one Anthropic mixed OpenCode secondary lane without touching other live teammates', async () => {
+    const teamName = 'mixed-anthropic-opencode-manual-restart-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+
+    adapter.setLaunchResult('partial_pending', { bob: 'permission' });
+
+    await svc.restartMember(teamName, 'bob');
+
+    await waitForCondition(() => adapter.launchInputs.length === 3);
+    expect(adapter.stopInputs).toHaveLength(1);
+    expect(adapter.stopInputs[0]).toMatchObject({
+      laneId: 'secondary:opencode:bob',
+      reason: 'relaunch',
+    });
+    expect(adapter.launchInputs.at(-1)).toMatchObject({
+      laneId: 'secondary:opencode:bob',
+      expectedMembers: [expect.objectContaining({ name: 'bob', providerId: 'opencode' })],
+    });
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      pendingPermissionRequestIds: ['perm-bob'],
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+
+    const runtimeSnapshot = await svc.getTeamAgentRuntimeSnapshot(teamName);
+    expect(runtimeSnapshot.members.alice).toMatchObject({
+      providerId: 'anthropic',
+      laneKind: 'primary',
+      runtimeModel: 'haiku',
+    });
+    expect(runtimeSnapshot.members.bob).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:bob',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/minimax-m2.5-free',
+    });
+    expect(runtimeSnapshot.members.tom).toMatchObject({
+      providerId: 'opencode',
+      laneId: 'secondary:opencode:tom',
+      laneKind: 'secondary',
+      runtimeModel: 'opencode/nemotron-3-super-free',
+    });
+  });
+
   it('detaches one mixed OpenCode secondary lane and keeps remaining teammates launchable', async () => {
     const teamName = 'mixed-opencode-detach-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1682,6 +3550,55 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('detaches one Anthropic mixed OpenCode secondary lane and keeps remaining teammates launchable', async () => {
+    const teamName = 'mixed-anthropic-opencode-detach-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+
+    await svc.detachOpenCodeOwnedMemberLane(teamName, 'bob');
+
+    expect(adapter.stopInputs).toHaveLength(1);
+    expect(adapter.stopInputs[0]).toMatchObject({
+      laneId: 'secondary:opencode:bob',
+      reason: 'cleanup',
+    });
+    expect(run.mixedSecondaryLanes.map((lane: { member: { name: string } }) => lane.member.name)).toEqual([
+      'tom',
+    ]);
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.expectedMembers).toEqual(['alice', 'tom']);
+    expect(statuses.statuses.bob).toBeUndefined();
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {
+        'secondary:opencode:tom': { state: 'active' },
+      },
+    });
+  });
+
   it('shows mixed OpenCode secondary lanes as spawning while runtime adapter launch is in flight', async () => {
     const teamName = 'mixed-live-inflight-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1738,6 +3655,67 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('shows Anthropic mixed OpenCode secondary lanes as spawning while runtime adapter launch is in flight', async () => {
+    const teamName = 'mixed-anthropic-live-inflight-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    const initialSnapshot = await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+
+    expect(initialSnapshot.teamLaunchState).toBe('partial_pending');
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    const inFlightStatuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(inFlightStatuses.teamLaunchState).toBe('partial_pending');
+    expect(inFlightStatuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 2,
+      failedCount: 0,
+    });
+    expect(inFlightStatuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+    });
+    expect(inFlightStatuses.statuses.bob).toMatchObject({
+      status: 'spawning',
+      launchState: 'starting',
+      hardFailure: false,
+    });
+    expect(inFlightStatuses.statuses.tom).toMatchObject({
+      status: 'spawning',
+      launchState: 'starting',
+      hardFailure: false,
+    });
+
+    adapter.releaseLaunches();
+
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+    const finalStatuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(finalStatuses.teamLaunchState).toBe('clean_success');
+    expect(finalStatuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(finalStatuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+    });
+    expect(finalStatuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+    });
+  });
+
   it('does not double-dispatch mixed OpenCode secondary lanes when launch handoff is retried in flight', async () => {
     const teamName = 'mixed-retry-inflight-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1789,6 +3767,62 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('does not double-dispatch Anthropic mixed OpenCode secondary lanes when launch handoff is retried in flight', async () => {
+    const teamName = 'mixed-anthropic-retry-inflight-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+    const firstLaneRunIds = run.mixedSecondaryLanes.map(
+      (lane: { runId: string | null }) => lane.runId
+    );
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+
+    expect(adapter.pendingLaunchInputs).toHaveLength(2);
+    expect(adapter.launchInputs).toHaveLength(0);
+    expect(run.mixedSecondaryLanes.map((lane: { state: string }) => lane.state)).toEqual([
+      'launching',
+      'launching',
+    ]);
+    expect(run.mixedSecondaryLanes.map((lane: { runId: string | null }) => lane.runId)).toEqual(
+      firstLaneRunIds
+    );
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+    await waitForCondition(() =>
+      run.mixedSecondaryLanes.every((lane: { state: string }) => lane.state === 'finished')
+    );
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+
+    expect(adapter.launchInputs).toHaveLength(2);
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('clean_success');
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+    });
+  });
+
   it('does not dispatch mixed OpenCode secondary lanes after the primary launch run is cancelled', async () => {
     const teamName = 'mixed-cancel-before-handoff-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1814,6 +3848,35 @@ describe('Team agent launch matrix safe e2e', () => {
     ]);
   });
 
+  it('does not dispatch Anthropic mixed OpenCode secondary lanes after the primary launch run is cancelled', async () => {
+    const teamName = 'mixed-anthropic-cancel-before-handoff-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+    run.cancelRequested = true;
+    run.processKilled = true;
+
+    const snapshot = await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+
+    expect(snapshot).toBeNull();
+    expect(adapter.pendingLaunchInputs).toHaveLength(0);
+    expect(adapter.launchInputs).toHaveLength(0);
+    expect(run.mixedSecondaryLanes.map((lane: { state: string }) => lane.state)).toEqual([
+      'queued',
+      'queued',
+    ]);
+    expect(run.memberSpawnStatuses.get('alice')).toMatchObject({
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+  });
+
   it('does not resurrect a stopped mixed launch when in-flight OpenCode lanes finish late', async () => {
     const teamName = 'mixed-stop-inflight-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1848,6 +3911,43 @@ describe('Team agent launch matrix safe e2e', () => {
     expect(statuses.statuses.tom?.launchState).not.toBe('confirmed_alive');
   });
 
+  it('does not resurrect a stopped Anthropic mixed launch when in-flight OpenCode lanes finish late', async () => {
+    const teamName = 'mixed-anthropic-stop-inflight-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    svc.stopTeam(teamName);
+
+    await waitForCondition(() => !svc.isTeamAlive(teamName));
+    await waitForCondition(() => adapter.stopInputs.length === 2);
+    expect(adapter.stopInputs.map((input) => input.laneId).sort()).toEqual([
+      'secondary:opencode:bob',
+      'secondary:opencode:tom',
+    ]);
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(svc.isTeamAlive(teamName)).toBe(false);
+    expect(statuses.teamLaunchState).not.toBe('clean_success');
+    expect(statuses.statuses.alice).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('confirmed_alive');
+    expect(statuses.statuses.tom?.launchState).not.toBe('confirmed_alive');
+  });
+
   it('does not let a stopped run late result overwrite newer mixed launch truth', async () => {
     const teamName = 'mixed-late-old-result-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1932,6 +4032,90 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('does not let a stopped Anthropic run late result overwrite newer mixed launch truth', async () => {
+    const teamName = 'mixed-anthropic-late-old-result-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const oldRun = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, oldRun);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(oldRun);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    svc.stopTeam(teamName);
+    await waitForCondition(() => !svc.isTeamAlive(teamName));
+    await waitForCondition(() => adapter.stopInputs.length === 2);
+
+    await writeMixedTeamLaunchState({
+      teamName,
+      members: {
+        alice: mixedMemberState({
+          providerId: 'anthropic',
+          model: 'haiku',
+          laneId: 'primary',
+          laneKind: 'primary',
+          laneOwnerProviderId: 'anthropic',
+          launchState: 'confirmed_alive',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: true,
+          hardFailure: false,
+        }),
+        bob: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/minimax-m2.5-free',
+          laneId: 'secondary:opencode:bob',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'runtime_pending_permission',
+          agentToolAccepted: true,
+          runtimeAlive: true,
+          bootstrapConfirmed: false,
+          hardFailure: false,
+          pendingPermissionRequestIds: ['new-perm-bob'],
+        }),
+        tom: mixedMemberState({
+          providerId: 'opencode',
+          model: 'opencode/nemotron-3-super-free',
+          laneId: 'secondary:opencode:tom',
+          laneKind: 'secondary',
+          laneOwnerProviderId: 'opencode',
+          launchState: 'failed_to_start',
+          agentToolAccepted: false,
+          runtimeAlive: false,
+          bootstrapConfirmed: false,
+          hardFailure: true,
+          hardFailureReason: 'new Anthropic run explicit failure',
+        }),
+      },
+    });
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).toBe('partial_failure');
+    expect(statuses.statuses.alice).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      launchState: 'runtime_pending_permission',
+      pendingPermissionRequestIds: ['new-perm-bob'],
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      hardFailureReason: 'new Anthropic run explicit failure',
+    });
+  });
+
   it('does not degrade stopped mixed launch lanes when in-flight OpenCode launch errors late', async () => {
     const teamName = 'mixed-stop-late-error-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1966,6 +4150,43 @@ describe('Team agent launch matrix safe e2e', () => {
     expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
   });
 
+  it('does not degrade stopped Anthropic mixed launch lanes when in-flight OpenCode launch errors late', async () => {
+    const teamName = 'mixed-anthropic-stop-late-error-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new RejectingBlockingOpenCodeRuntimeAdapter('late fake Anthropic bridge failure');
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    svc.stopTeam(teamName);
+    await waitForCondition(() => !svc.isTeamAlive(teamName));
+    await waitForCondition(() => adapter.stopInputs.length === 2);
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.rejectedLaunchCount === 2);
+
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {},
+    });
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).not.toBe('partial_failure');
+    expect(statuses.statuses.alice).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.tom).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
+  });
+
   it('stops mixed OpenCode secondary lanes when provisioning is cancelled mid-launch', async () => {
     const teamName = 'mixed-cancel-inflight-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -1999,6 +4220,42 @@ describe('Team agent launch matrix safe e2e', () => {
     expect(statuses.statuses.tom?.launchState).not.toBe('confirmed_alive');
   });
 
+  it('stops Anthropic mixed OpenCode secondary lanes when provisioning is cancelled mid-launch', async () => {
+    const teamName = 'mixed-anthropic-cancel-inflight-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new BlockingOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'confirmed',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    await svc.cancelProvisioning(run.runId);
+
+    await waitForCondition(() => adapter.stopInputs.length === 2);
+    expect(adapter.stopInputs.map((input) => input.laneId).sort()).toEqual([
+      'secondary:opencode:bob',
+      'secondary:opencode:tom',
+    ]);
+    expect(svc.isTeamAlive(teamName)).toBe(false);
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.launchInputs.length === 2);
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).not.toBe('clean_success');
+    expect(statuses.statuses.alice).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('confirmed_alive');
+    expect(statuses.statuses.tom?.launchState).not.toBe('confirmed_alive');
+  });
+
   it('does not degrade mixed OpenCode lanes when in-flight launch errors after cancel', async () => {
     const teamName = 'mixed-cancel-late-error-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -2032,6 +4289,42 @@ describe('Team agent launch matrix safe e2e', () => {
     expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
   });
 
+  it('does not degrade Anthropic mixed OpenCode lanes when in-flight launch errors after cancel', async () => {
+    const teamName = 'mixed-anthropic-cancel-late-error-safe-e2e';
+    await writeMixedTeamConfig({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    const adapter = new RejectingBlockingOpenCodeRuntimeAdapter('late fake Anthropic cancel bridge failure');
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+    const run = createMixedLiveRun({ teamName, projectPath, primaryProviderId: 'anthropic' });
+    trackLiveRun(svc, run);
+
+    await (svc as any).launchMixedSecondaryLaneIfNeeded(run);
+    await waitForCondition(() => adapter.pendingLaunchInputs.length === 2);
+
+    await svc.cancelProvisioning(run.runId);
+    await waitForCondition(() => adapter.stopInputs.length === 2);
+
+    adapter.releaseLaunches();
+    await waitForCondition(() => adapter.rejectedLaunchCount === 2);
+
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {},
+    });
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+    expect(statuses.teamLaunchState).not.toBe('partial_failure');
+    expect(statuses.statuses.alice).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.tom).toMatchObject({
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
+  });
+
   it('degrades stale active mixed OpenCode lanes when lane state is missing on disk', async () => {
     const teamName = 'mixed-stale-lanes-safe-e2e';
     await writeMixedTeamConfig({ teamName, projectPath });
@@ -2100,7 +4393,6 @@ describe('Team agent launch matrix safe e2e', () => {
     svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
 
     const statuses = await svc.getMemberSpawnStatuses(teamName);
-
     expect(adapter.reconcileInputs.map((input) => input.laneId).sort()).toEqual([
       'secondary:opencode:bob',
       'secondary:opencode:tom',
@@ -2147,7 +4439,6 @@ describe('Team agent launch matrix safe e2e', () => {
     svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
 
     const statuses = await svc.getMemberSpawnStatuses(teamName);
-
     expect(adapter.reconcileInputs.map((input) => input.laneId).sort()).toEqual([
       'secondary:opencode:bob',
       'secondary:opencode:tom',
@@ -2233,6 +4524,144 @@ describe('Team agent launch matrix safe e2e', () => {
     });
   });
 
+  it('recovers stale active Anthropic and Gemini configured OpenCode lanes into ready and permission-pending states before degrading them', async () => {
+    const teamName = 'mixed-anthropic-gemini-configured-runtime-recover-split-permission-safe-e2e';
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:bob',
+      state: 'active',
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:tom',
+      state: 'active',
+    });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'permission',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+
+    expect(adapter.reconcileInputs.map((input) => input.laneId).sort()).toEqual([
+      'secondary:opencode:bob',
+      'secondary:opencode:tom',
+    ]);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 3,
+      failedCount: 0,
+    });
+    expect(statuses.expectedMembers).toEqual(expect.arrayContaining(['alice', 'reviewer', 'bob', 'tom']));
+    expect(statuses.statuses.alice?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.reviewer?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_permission',
+      hardFailure: false,
+      pendingPermissionRequestIds: ['perm-tom'],
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {
+        'secondary:opencode:bob': { state: 'active' },
+        'secondary:opencode:tom': { state: 'active' },
+      },
+    });
+  });
+
+  it('recovers stale active Anthropic and Gemini configured OpenCode lanes into ready and bootstrap-pending states before degrading them', async () => {
+    const teamName = 'mixed-anthropic-gemini-configured-runtime-recover-split-bootstrap-safe-e2e';
+    await writeMixedTeamConfig({
+      teamName,
+      projectPath,
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await writeTeamMeta(teamName, projectPath, { primaryProviderId: 'anthropic' });
+    await writeMembersMeta(teamName, {
+      includeGeminiPrimary: true,
+      primaryProviderId: 'anthropic',
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:bob',
+      state: 'active',
+    });
+    await upsertOpenCodeRuntimeLaneIndexEntry({
+      teamsBasePath: getTeamsBasePath(),
+      teamName,
+      laneId: 'secondary:opencode:tom',
+      state: 'active',
+    });
+    const adapter = new FakeOpenCodeRuntimeAdapter('clean_success', {
+      bob: 'confirmed',
+      tom: 'launching',
+    });
+    const svc = new TeamProvisioningService();
+    svc.setRuntimeAdapterRegistry(new TeamRuntimeAdapterRegistry([adapter]));
+
+    const statuses = await svc.getMemberSpawnStatuses(teamName);
+
+    expect(adapter.reconcileInputs.map((input) => input.laneId).sort()).toEqual([
+      'secondary:opencode:bob',
+      'secondary:opencode:tom',
+    ]);
+    expect(statuses.teamLaunchState).toBe('partial_pending');
+    expect(statuses.summary).toMatchObject({
+      confirmedCount: 1,
+      pendingCount: 3,
+      failedCount: 0,
+      runtimeAlivePendingCount: 1,
+    });
+    expect(statuses.expectedMembers).toEqual(expect.arrayContaining(['alice', 'reviewer', 'bob', 'tom']));
+    expect(statuses.statuses.alice?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.reviewer?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.bob).toMatchObject({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      hardFailure: false,
+    });
+    expect(statuses.statuses.tom).toMatchObject({
+      status: 'online',
+      launchState: 'runtime_pending_bootstrap',
+      runtimeAlive: true,
+      bootstrapConfirmed: false,
+      hardFailure: false,
+    });
+    expect(statuses.statuses.bob?.launchState).not.toBe('failed_to_start');
+    expect(statuses.statuses.tom?.launchState).not.toBe('failed_to_start');
+    await expect(readOpenCodeRuntimeLaneIndex(getTeamsBasePath(), teamName)).resolves.toMatchObject({
+      lanes: {
+        'secondary:opencode:bob': { state: 'active' },
+        'secondary:opencode:tom': { state: 'active' },
+      },
+    });
+  });
+
   it('recovers pure OpenCode launch statuses from disk after service restart', async () => {
     const adapter = new FakeOpenCodeRuntimeAdapter();
     const firstService = new TeamProvisioningService();
@@ -2775,6 +5204,48 @@ async function writeOpenCodeTeamConfig(input: {
   );
 }
 
+async function writePureAnthropicTeamConfig(input: {
+  teamName: string;
+  projectPath: string;
+}): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), input.teamName);
+  await fs.mkdir(teamDir, { recursive: true });
+  await fs.writeFile(
+    path.join(teamDir, 'config.json'),
+    `${JSON.stringify(
+      {
+        name: input.teamName,
+        projectPath: input.projectPath,
+        providerId: 'anthropic',
+        model: 'sonnet',
+        members: [
+          {
+            name: 'team-lead',
+            agentType: 'team-lead',
+            providerId: 'anthropic',
+            model: 'sonnet',
+          },
+          {
+            name: 'alice',
+            role: 'Reviewer',
+            providerId: 'anthropic',
+            model: 'haiku',
+          },
+          {
+            name: 'bob',
+            role: 'Developer',
+            providerId: 'anthropic',
+            model: 'sonnet',
+          },
+        ],
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+}
+
 async function writeMixedTeamConfig(input: {
   teamName: string;
   projectPath: string;
@@ -2910,6 +5381,85 @@ async function writeMixedTeamLaunchState(input: {
   );
 }
 
+async function writePureAnthropicTeamLaunchState(input: {
+  teamName: string;
+  launchPhase?: 'active' | 'finished' | 'reconciled';
+  expectedMembers?: string[];
+  members: Record<string, ReturnType<typeof mixedMemberState>>;
+}): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), input.teamName);
+  await fs.mkdir(teamDir, { recursive: true });
+  const expectedMembers = input.expectedMembers ?? Object.keys(input.members);
+  const snapshot = createPersistedLaunchSnapshot({
+    teamName: input.teamName,
+    leadSessionId: 'lead-session',
+    launchPhase: input.launchPhase ?? 'active',
+    expectedMembers,
+    bootstrapExpectedMembers: expectedMembers,
+    members: input.members as any,
+  });
+  await fs.writeFile(
+    path.join(teamDir, 'launch-state.json'),
+    `${JSON.stringify(snapshot, null, 2)}\n`,
+    'utf8'
+  );
+}
+
+async function writeLegacyPartialLaunchState(input: {
+  teamName: string;
+  expectedMembers: string[];
+  confirmedMembers: string[];
+  missingMembers: string[];
+}): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), input.teamName);
+  await fs.mkdir(teamDir, { recursive: true });
+  await fs.writeFile(
+    path.join(teamDir, 'launch-state.json'),
+    `${JSON.stringify(
+      {
+        state: 'partial_launch_failure',
+        expectedMembers: input.expectedMembers,
+        confirmedMembers: input.confirmedMembers,
+        missingMembers: input.missingMembers,
+        leadSessionId: 'lead-session',
+        updatedAt: '2026-04-23T10:00:00.000Z',
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+}
+
+async function writeBootstrapState(
+  teamName: string,
+  members: Array<{
+    name: string;
+    status: string;
+    lastAttemptAt?: number;
+    lastObservedAt?: number;
+    failureReason?: string;
+  }>
+): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), teamName);
+  await fs.mkdir(teamDir, { recursive: true });
+  await fs.writeFile(
+    path.join(teamDir, 'bootstrap-state.json'),
+    `${JSON.stringify(
+      {
+        version: 1,
+        teamName,
+        updatedAt: '2026-04-23T10:00:06.000Z',
+        phase: 'completed',
+        members,
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+}
+
 function mixedMemberState(overrides: Record<string, unknown>): Record<string, unknown> {
   return {
     name: overrides.name,
@@ -2976,12 +5526,87 @@ async function writeTeamMeta(
   );
 }
 
+async function writePureAnthropicTeamMeta(
+  teamName: string,
+  projectPath: string
+): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), teamName);
+  await fs.mkdir(teamDir, { recursive: true });
+  await fs.writeFile(
+    path.join(teamDir, 'team.meta.json'),
+    `${JSON.stringify(
+      {
+        version: 1,
+        cwd: projectPath,
+        providerId: 'anthropic',
+        model: 'sonnet',
+        effort: 'medium',
+        createdAt: Date.now(),
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+}
+
+async function writePureAnthropicMembersMeta(
+  teamName: string,
+  options: {
+    removedMembers?: string[];
+    extraMembers?: Array<{ name: string; providerId: 'anthropic'; model: string }>;
+  } = {}
+): Promise<void> {
+  const teamDir = path.join(getTeamsBasePath(), teamName);
+  const removedMembers = new Set(options.removedMembers ?? []);
+  const extraMembers = options.extraMembers ?? [];
+  await fs.mkdir(teamDir, { recursive: true });
+  await fs.writeFile(
+    path.join(teamDir, 'members.meta.json'),
+    `${JSON.stringify(
+      {
+        version: 1,
+        members: [
+          {
+            name: 'alice',
+            providerId: 'anthropic',
+            model: 'haiku',
+            ...(removedMembers.has('alice') ? { removedAt: 1_777_000_000_000 } : {}),
+          },
+          {
+            name: 'bob',
+            providerId: 'anthropic',
+            model: 'sonnet',
+            ...(removedMembers.has('bob') ? { removedAt: 1_777_000_000_000 } : {}),
+          },
+          ...extraMembers.map((member) => ({
+            name: member.name,
+            providerId: member.providerId,
+            model: member.model,
+            ...(removedMembers.has(member.name) ? { removedAt: 1_777_000_000_000 } : {}),
+          })),
+        ],
+      },
+      null,
+      2
+    )}\n`,
+    'utf8'
+  );
+}
+
 async function writeMembersMeta(
   teamName: string,
-  options: { includeGeminiPrimary?: boolean; primaryProviderId?: MixedPrimaryProviderId } = {}
+  options: {
+    includeGeminiPrimary?: boolean;
+    primaryProviderId?: MixedPrimaryProviderId;
+    removedMembers?: string[];
+    extraMembers?: Array<{ name: string; providerId: 'opencode'; model: string }>;
+  } = {}
 ): Promise<void> {
   const teamDir = path.join(getTeamsBasePath(), teamName);
   const primary = getMixedPrimaryFixture(options.primaryProviderId);
+  const removedMembers = new Set(options.removedMembers ?? []);
+  const extraMembers = options.extraMembers ?? [];
   await fs.mkdir(teamDir, { recursive: true });
   await fs.writeFile(
     path.join(teamDir, 'members.meta.json'),
@@ -2997,6 +5622,7 @@ async function writeMembersMeta(
               ? { providerBackendId: primary.providerBackendId }
               : {}),
             model: primary.memberModel,
+            ...(removedMembers.has('alice') ? { removedAt: 1_777_000_000_000 } : {}),
           },
           ...(options.includeGeminiPrimary
             ? [
@@ -3004,6 +5630,7 @@ async function writeMembersMeta(
                   name: 'reviewer',
                   providerId: 'gemini',
                   model: 'gemini-2.5-flash',
+                  ...(removedMembers.has('reviewer') ? { removedAt: 1_777_000_000_000 } : {}),
                 },
               ]
             : []),
@@ -3011,12 +5638,20 @@ async function writeMembersMeta(
             name: 'bob',
             providerId: 'opencode',
             model: 'opencode/minimax-m2.5-free',
+            ...(removedMembers.has('bob') ? { removedAt: 1_777_000_000_000 } : {}),
           },
           {
             name: 'tom',
             providerId: 'opencode',
             model: 'opencode/nemotron-3-super-free',
+            ...(removedMembers.has('tom') ? { removedAt: 1_777_000_000_000 } : {}),
           },
+          ...extraMembers.map((member) => ({
+            name: member.name,
+            providerId: member.providerId,
+            model: member.model,
+            ...(removedMembers.has(member.name) ? { removedAt: 1_777_000_000_000 } : {}),
+          })),
         ],
       },
       null,
diff --git a/test/main/services/team/TeamMemberRuntimeAdvisoryService.test.ts b/test/main/services/team/TeamMemberRuntimeAdvisoryService.test.ts
index d5ae6870..e2babc6f 100644
--- a/test/main/services/team/TeamMemberRuntimeAdvisoryService.test.ts
+++ b/test/main/services/team/TeamMemberRuntimeAdvisoryService.test.ts
@@ -120,7 +120,10 @@ describe('TeamMemberRuntimeAdvisoryService', () => {
         JSON.stringify({
           timestamp: nowIso,
           type: 'user',
-          message: { role: 'user', content: 'You are alice, a reviewer on team "signal-ops" (signal-ops).' },
+          message: {
+            role: 'user',
+            content: 'You are alice, a reviewer on team "signal-ops" (signal-ops).',
+          },
         }),
         JSON.stringify({
           timestamp: nowIso,
@@ -152,7 +155,10 @@ describe('TeamMemberRuntimeAdvisoryService', () => {
 
   it.each([
     ['rate_limited', 'Provider returned 429 rate limit for this request.'],
-    ['rate_limited', 'All credentials for model claude-opus-4-6 are cooling down via provider claude.'],
+    [
+      'rate_limited',
+      'All credentials for model claude-opus-4-6 are cooling down via provider claude.',
+    ],
     ['auth_error', 'Authentication failed due to invalid API key.'],
     ['network_error', 'Fetch failed because the network connection timed out.'],
     ['provider_overloaded', 'Service unavailable: provider temporarily unavailable (503).'],
@@ -192,6 +198,61 @@ describe('TeamMemberRuntimeAdvisoryService', () => {
     expect(advisory?.reasonCode).toBe('unknown');
   });
 
+  it('keeps terminal API errors visible after retries stop', () => {
+    const service = new TeamMemberRuntimeAdvisoryService({} as never);
+    const observedAt = '2099-04-09T10:00:00.000Z';
+    const advisory = (service as any).extractApiErrorAdvisory(
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: observedAt,
+        isApiErrorMessage: true,
+        error: 'unknown',
+        message: {
+          content: [
+            {
+              type: 'text',
+              text: 'API Error: 500 {"error":{"message":"auth_unavailable: no auth available","type":"server_error"}}',
+            },
+          ],
+        },
+      }),
+      Date.parse(observedAt)
+    ) as MemberRuntimeAdvisory | null;
+
+    expect(advisory).toMatchObject({
+      kind: 'api_error',
+      reasonCode: 'auth_error',
+      statusCode: 500,
+    });
+    expect(advisory?.retryUntil).toBeUndefined();
+    expect(advisory?.message).toContain('auth_unavailable');
+  });
+
+  it('treats Claude Code account access failures as auth errors', () => {
+    const service = new TeamMemberRuntimeAdvisoryService({} as never);
+    const observedAt = '2099-04-09T10:00:00.000Z';
+    const advisory = (service as any).extractApiErrorAdvisory(
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: observedAt,
+        isApiErrorMessage: true,
+        error: 'authentication_failed',
+        message: {
+          content: [
+            {
+              type: 'text',
+              text: 'Your account does not have access to Claude Code. Please run /login.',
+            },
+          ],
+        },
+      }),
+      Date.parse(observedAt)
+    ) as MemberRuntimeAdvisory | null;
+
+    expect(advisory?.kind).toBe('api_error');
+    expect(advisory?.reasonCode).toBe('auth_error');
+  });
+
   it('ignores expired retry advisories', async () => {
     tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-team-advisory-'));
     setClaudeBasePathOverride(tmpDir);
@@ -234,7 +295,10 @@ describe('TeamMemberRuntimeAdvisoryService', () => {
         JSON.stringify({
           timestamp: new Date(Date.now() - 60_000).toISOString(),
           type: 'user',
-          message: { role: 'user', content: 'You are alice, a reviewer on team "signal-ops" (signal-ops).' },
+          message: {
+            role: 'user',
+            content: 'You are alice, a reviewer on team "signal-ops" (signal-ops).',
+          },
         }),
         JSON.stringify({
           timestamp: new Date(Date.now() - 60_000).toISOString(),
diff --git a/test/main/services/team/TeamProvisioningServicePrepare.test.ts b/test/main/services/team/TeamProvisioningServicePrepare.test.ts
index 5777476a..27e304c2 100644
--- a/test/main/services/team/TeamProvisioningServicePrepare.test.ts
+++ b/test/main/services/team/TeamProvisioningServicePrepare.test.ts
@@ -29,7 +29,7 @@ vi.mock('@main/services/infrastructure/NotificationManager', () => ({
   },
 }));
 
-const execCliMock = vi.fn(async (_binaryPath: string | null, args: string[]) => {
+const defaultExecCliMockImplementation = async (_binaryPath: string | null, args: string[]) => {
   if (args[0] === 'model') {
     return {
       stdout: JSON.stringify({
@@ -48,7 +48,11 @@ const execCliMock = vi.fn(async (_binaryPath: string | null, args: string[]) =>
           },
           codex: {
             defaultModel: 'gpt-5.4-mini',
-            models: [{ id: 'gpt-5.4-mini', label: 'GPT-5.4 Mini', description: 'Codex default' }],
+            models: [
+              { id: 'gpt-5.4', label: 'GPT-5.4', description: 'Codex selected model' },
+              { id: 'gpt-5.4-mini', label: 'GPT-5.4 Mini', description: 'Codex default' },
+              { id: 'gpt-5.3-codex', label: 'GPT-5.3 Codex', description: 'Codex model' },
+            ],
           },
           gemini: {
             defaultModel: 'gemini-2.5-pro',
@@ -83,7 +87,8 @@ const execCliMock = vi.fn(async (_binaryPath: string | null, args: string[]) =>
   }
 
   return { stdout: '', stderr: '', exitCode: 0 };
-});
+};
+const execCliMock = vi.fn(defaultExecCliMockImplementation);
 vi.mock('@main/utils/childProcess', () => ({
   execCli: (...args: Parameters<typeof execCliMock>) => execCliMock(...args),
   spawnCli: vi.fn(),
@@ -258,7 +263,8 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    execCliMock.mockClear();
+    execCliMock.mockReset();
+    execCliMock.mockImplementation(defaultExecCliMockImplementation);
     addTeamNotificationMock.mockResolvedValue(null);
     tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-team-prepare-'));
     vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
@@ -294,6 +300,85 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     expect(fs.existsSync(missingCwd)).toBe(false);
   });
 
+  it('skips advisory one-shot diagnostics when the prepare cwd is missing', async () => {
+    const svc = new TeamProvisioningService();
+    const missingCwd = path.join(tempRoot, 'missing-project');
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe');
+
+    const result = await (svc as any).runProviderOneShotDiagnostic(
+      '/fake/claude',
+      missingCwd,
+      {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      'codex'
+    );
+
+    expect(result).toEqual({});
+    expect(spawnProbe).not.toHaveBeenCalled();
+  });
+
+  it('does not add one-shot ENOENT warnings after a missing cwd preflight warning', async () => {
+    const svc = new TeamProvisioningService();
+    const missingCwd = path.join(tempRoot, 'missing-project');
+    vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
+      claudePath: '/fake/claude',
+      authSource: 'codex_runtime',
+      warning: `Working directory does not exist: ${missingCwd}`,
+    });
+    vi.spyOn(svc as any, 'buildProvisioningEnv').mockResolvedValue({
+      env: {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      authSource: 'codex_runtime',
+      geminiRuntimeAuth: null,
+    });
+    vi.spyOn(svc as any, 'readRuntimeProviderLaunchFacts').mockResolvedValue({
+      defaultModel: null,
+      modelIds: new Set(['gpt-5.4']),
+      modelCatalog: null,
+      runtimeCapabilities: null,
+      providerStatus: null,
+    });
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe');
+
+    const result = await svc.prepareForProvisioning(missingCwd, {
+      forceFresh: true,
+      providerId: 'codex',
+      modelIds: ['gpt-5.4'],
+      modelVerificationMode: 'deep',
+    });
+
+    expect(result.ready).toBe(true);
+    expect(result.details).toContain('Selected model gpt-5.4 is available for launch.');
+    expect(result.warnings).toEqual([`Working directory does not exist: ${missingCwd}`]);
+    expect(result.warnings?.join('\n')).not.toContain('One-shot diagnostic');
+    expect(result.warnings?.join('\n')).not.toContain('ENOENT');
+    expect(spawnProbe).not.toHaveBeenCalled();
+  });
+
+  it('does not misclassify binary ENOENT as a missing cwd when cwd exists', async () => {
+    const svc = new TeamProvisioningService();
+    vi.spyOn(svc as any, 'spawnProbe').mockRejectedValue(new Error('spawn /missing/cli ENOENT'));
+
+    const result = await (svc as any).probeClaudeRuntime(
+      '/missing/cli',
+      tempRoot,
+      {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      'codex',
+      []
+    );
+
+    expect(result.warning).toContain('binary failed to start');
+    expect(result.warning).toContain('spawn /missing/cli ENOENT');
+    expect(result.warning).not.toContain('Working directory does not exist');
+  });
+
   it('blocks OpenCode prepare without probing the legacy Claude stream-json runtime', async () => {
     const svc = new TeamProvisioningService();
     const probeSpy = vi.spyOn(svc as any, 'getCachedOrProbeResult');
@@ -506,10 +591,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     });
 
     await vi.waitFor(() =>
-      expect(started).toEqual([
-        'opencode/minimax-m2.5-free',
-        'opencode/nemotron-3-super-free',
-      ])
+      expect(started).toEqual(['opencode/minimax-m2.5-free', 'opencode/nemotron-3-super-free'])
     );
     expect(maxActiveCount).toBe(2);
     expect(releases.has('opencode/big-pickle')).toBe(false);
@@ -555,10 +637,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
           state: 'ready',
           launchAllowed: true,
           modelId: 'openrouter/minimax-m2.5-free',
-          availableModels: [
-            'opencode/minimax-m2.5-free',
-            'opencode/nemotron-3-super-free',
-          ],
+          availableModels: ['opencode/minimax-m2.5-free', 'opencode/nemotron-3-super-free'],
           opencodeVersion: '1.0.0',
           installMethod: 'unknown',
           binaryPath: 'opencode',
@@ -677,7 +756,9 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     });
 
     expect(result.ready).toBe(false);
-    expect(result.details).toEqual(['Selected model opencode/minimax-m2.5-free verified for launch.']);
+    expect(result.details).toEqual([
+      'Selected model opencode/minimax-m2.5-free verified for launch.',
+    ]);
     expect(result.message).toBe(
       'Selected model opencode/nemotron-3-super-free is unavailable. bridge exploded'
     );
@@ -735,7 +816,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     ]);
   });
 
-  it('verifies the selected Codex model during prepare and records a success detail', async () => {
+  it('checks the selected Codex model from the runtime catalog during prepare', async () => {
     const svc = new TeamProvisioningService();
     vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
       claudePath: '/fake/claude',
@@ -762,18 +843,11 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     });
 
     expect(result.ready).toBe(true);
-    expect(result.details).toContain('Selected model gpt-5.4 verified for launch.');
-    expect(spawnProbe).toHaveBeenCalledWith(
-      '/fake/claude',
-      expect.arrayContaining(['--model', 'gpt-5.4']),
-      tempRoot,
-      expect.any(Object),
-      60_000,
-      expect.any(Object)
-    );
+    expect(result.details).toContain('Selected model gpt-5.4 is available for launch.');
+    expect(spawnProbe).not.toHaveBeenCalled();
   });
 
-  it('verifies the resolved Codex default model during prepare', async () => {
+  it('checks the Codex default model without running a print-mode probe', async () => {
     const svc = new TeamProvisioningService();
     vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
       claudePath: '/fake/claude',
@@ -802,19 +876,12 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
 
     expect(result.ready).toBe(true);
     expect(result.details).toContain(
-      `Selected model ${DEFAULT_PROVIDER_MODEL_SELECTION} verified for launch.`
-    );
-    expect(spawnProbe).toHaveBeenCalledWith(
-      '/fake/claude',
-      expect.arrayContaining(['--model', 'gpt-5.4-mini']),
-      tempRoot,
-      expect.any(Object),
-      60_000,
-      expect.any(Object)
+      `Selected model ${DEFAULT_PROVIDER_MODEL_SELECTION} is available for launch.`
     );
+    expect(spawnProbe).not.toHaveBeenCalled();
   });
 
-  it('verifies the resolved Anthropic default model during prepare with limitContext', async () => {
+  it('checks the Anthropic default model during prepare with limitContext without print mode', async () => {
     const svc = new TeamProvisioningService();
     vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
       claudePath: '/fake/claude',
@@ -843,16 +910,49 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
 
     expect(result.ready).toBe(true);
     expect(result.details).toContain(
-      `Selected model ${DEFAULT_PROVIDER_MODEL_SELECTION} verified for launch.`
+      `Selected model ${DEFAULT_PROVIDER_MODEL_SELECTION} is available for launch.`
     );
-    expect(spawnProbe).toHaveBeenCalledWith(
-      '/fake/claude',
-      expect.arrayContaining(['--model', 'opus']),
-      tempRoot,
-      expect.any(Object),
-      60_000,
-      expect.any(Object)
+    expect(spawnProbe).not.toHaveBeenCalled();
+  });
+
+  it('keeps Anthropic selected-model prepare terminal when compatibility mode is requested', async () => {
+    const svc = new TeamProvisioningService();
+    vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
+      claudePath: '/fake/claude',
+      authSource: 'oauth_token',
+    });
+    const verifySelectedProviderModels = vi
+      .spyOn(svc as any, 'verifySelectedProviderModels')
+      .mockResolvedValue({
+        details: [
+          'Selected model opus verified for launch.',
+          'Selected model sonnet verified for launch.',
+        ],
+        warnings: [],
+        blockingMessages: [],
+      });
+    const runProviderOneShotDiagnostic = vi.spyOn(svc as any, 'runProviderOneShotDiagnostic');
+
+    const result = await svc.prepareForProvisioning(tempRoot, {
+      forceFresh: true,
+      providerId: 'anthropic',
+      modelIds: ['opus', 'sonnet'],
+      modelVerificationMode: 'compatibility',
+    });
+
+    expect(result.ready).toBe(true);
+    expect(result.details).toEqual([
+      'Selected model opus verified for launch.',
+      'Selected model sonnet verified for launch.',
+    ]);
+    expect(result.details?.some((line) => line.includes('compatible'))).toBe(false);
+    expect(verifySelectedProviderModels).toHaveBeenCalledWith(
+      expect.objectContaining({
+        providerId: 'anthropic',
+        modelIds: ['opus', 'sonnet'],
+      })
     );
+    expect(runProviderOneShotDiagnostic).not.toHaveBeenCalled();
   });
 
   it('falls back from an unavailable Anthropic 1M launch id to the base model during prepare', async () => {
@@ -902,15 +1002,8 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     });
 
     expect(result.ready).toBe(true);
-    expect(result.details).toContain('Selected model opus[1m] verified for launch.');
-    expect(spawnProbe).toHaveBeenCalledWith(
-      '/fake/claude',
-      expect.arrayContaining(['--model', 'opus']),
-      tempRoot,
-      expect.any(Object),
-      60_000,
-      expect.any(Object)
-    );
+    expect(result.details).toContain('Selected model opus[1m] is available for launch.');
+    expect(spawnProbe).not.toHaveBeenCalled();
   });
 
   it('fails prepare when the selected Codex model is unavailable', async () => {
@@ -927,11 +1020,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
       authSource: 'codex_runtime',
       geminiRuntimeAuth: null,
     });
-    vi.spyOn(svc as any, 'spawnProbe').mockRejectedValue(
-      new Error(
-        "The 'gpt-5.2-codex' model is not supported when using Codex with a ChatGPT account."
-      )
-    );
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe');
 
     const result = await svc.prepareForProvisioning(tempRoot, {
       forceFresh: true,
@@ -941,10 +1030,11 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
 
     expect(result.ready).toBe(false);
     expect(result.message).toContain('Selected model gpt-5.2-codex is unavailable.');
-    expect(result.message).toContain('Not available on this Codex native runtime');
+    expect(result.message).toContain('was not found in the live provider catalog');
+    expect(spawnProbe).not.toHaveBeenCalled();
   });
 
-  it('keeps timed out Codex model verification as a warning with a clean generic reason', async () => {
+  it('keeps timed out Codex one-shot diagnostics as a runtime warning', async () => {
     const svc = new TeamProvisioningService();
     vi.spyOn(svc as any, 'getCachedOrProbeResult').mockResolvedValue({
       claudePath: '/fake/claude',
@@ -960,7 +1050,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     });
     vi.spyOn(svc as any, 'spawnProbe').mockRejectedValue(
       new Error(
-        'Timeout running: orchestrator-cli -p Output only the single word PONG. --output-format text --model gpt-5.3-codex --max-turns 1 --no-session-persistence'
+        'Timeout running: orchestrator-cli -p Output only the single word PONG. --output-format text --model haiku --max-turns 1 --no-session-persistence'
       )
     );
 
@@ -968,11 +1058,16 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
       forceFresh: true,
       providerId: 'codex',
       modelIds: ['gpt-5.3-codex'],
+      modelVerificationMode: 'deep',
     });
 
     expect(result.ready).toBe(true);
-    expect(result.warnings).toContain(
-      'Selected model gpt-5.3-codex could not be verified. Model verification timed out'
+    expect(result.details).toContain('Selected model gpt-5.3-codex is available for launch.');
+    expect(result.warnings?.join('\n')).toContain(
+      'One-shot diagnostic timed out after runtime readiness passed'
+    );
+    expect(result.warnings?.join('\n')).not.toContain(
+      'Selected model gpt-5.3-codex could not be verified'
     );
   });
 
@@ -996,21 +1091,179 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     );
   });
 
-  it('includes CLI output in generic preflight failures', async () => {
+  it('uses runtime status for codex primary preflight without print mode', async () => {
     const svc = new TeamProvisioningService();
-    vi.spyOn(svc as any, 'spawnProbe')
-      .mockResolvedValueOnce({
-        stdout: 'orchestrator-cli 1.2.3',
-        stderr: '',
-        exitCode: 0,
-      })
-      .mockResolvedValueOnce({
-        stdout: 'upstream unavailable',
-        stderr: 'request id: req_123',
-        exitCode: 1,
-      });
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe').mockResolvedValue({
+      stdout: 'orchestrator-cli 1.2.3',
+      stderr: '',
+      exitCode: 0,
+    });
 
-    const result = await (svc as any).probeClaudeRuntime(
+    const result = await svc.prepareForProvisioning(tempRoot, {
+      forceFresh: true,
+      providerId: 'codex',
+    });
+
+    expect(result.ready).toBe(true);
+    expect(execCliMock).toHaveBeenCalledWith(
+      '/fake/claude',
+      ['runtime', 'status', '--json', '--provider', 'codex'],
+      expect.objectContaining({ cwd: tempRoot })
+    );
+    expect(spawnProbe).toHaveBeenCalledTimes(1);
+    const spawnedArgLists = spawnProbe.mock.calls.map((call) => call[1] as string[]);
+    expect(spawnedArgLists.some((args) => args.includes('-p'))).toBe(false);
+  });
+
+  it('passes provider launch args before codex runtime status subcommands', async () => {
+    execCliMock.mockResolvedValue({
+      stdout: JSON.stringify({
+        providers: {
+          codex: {
+            supported: true,
+            authenticated: true,
+            capabilities: { teamLaunch: true, oneShot: true },
+          },
+        },
+      }),
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const svc = new TeamProvisioningService();
+    const result = await (svc as any).probeProviderRuntimeControlPlane({
+      claudePath: '/fake/claude',
+      cwd: tempRoot,
+      env: {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      providerId: 'codex',
+      providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
+    });
+
+    expect(result.warning).toBeUndefined();
+    expect(execCliMock).toHaveBeenCalledWith(
+      '/fake/claude',
+      [
+        '--settings',
+        '{"codex":{"forced_login_method":"chatgpt"}}',
+        'runtime',
+        'status',
+        '--json',
+        '--provider',
+        'codex',
+      ],
+      expect.objectContaining({ cwd: tempRoot })
+    );
+  });
+
+  it('falls back from runtime status timeout to auth status and still checks selected models', async () => {
+    execCliMock.mockImplementation(async (_binaryPath: string | null, args: string[]) => {
+      if (args[0] === 'runtime' && args[1] === 'status') {
+        throw new Error('Timeout running: orchestrator-cli runtime status --json --provider codex');
+      }
+      if (args[0] === 'auth') {
+        return {
+          stdout: JSON.stringify({ loggedIn: true, authMethod: 'chatgpt' }),
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      if (args[0] === 'model') {
+        return {
+          stdout: JSON.stringify({
+            schemaVersion: 1,
+            providers: {
+              codex: {
+                defaultModel: 'gpt-5.4-mini',
+                models: [{ id: 'gpt-5.4', label: 'GPT-5.4' }],
+              },
+            },
+          }),
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    const svc = new TeamProvisioningService();
+    vi.spyOn(svc as any, 'spawnProbe').mockResolvedValue({
+      stdout: 'orchestrator-cli 1.2.3',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const result = await svc.prepareForProvisioning(tempRoot, {
+      forceFresh: true,
+      providerId: 'codex',
+      modelIds: ['gpt-5.4'],
+    });
+
+    expect(result.ready).toBe(true);
+    expect(result.details).toContain('Selected model gpt-5.4 is available for launch.');
+    expect(result.warnings?.join('\n')).toContain('runtime status was unavailable');
+    expect(execCliMock).toHaveBeenCalledWith(
+      '/fake/claude',
+      ['auth', 'status', '--json', '--provider', 'codex'],
+      expect.objectContaining({ cwd: tempRoot })
+    );
+  });
+
+  it('passes provider launch args before auth status fallback subcommands', async () => {
+    execCliMock.mockImplementation(async (_binaryPath: string | null, args: string[]) => {
+      if (args.includes('runtime')) {
+        throw new Error('runtime status failed');
+      }
+      if (args.includes('auth')) {
+        return {
+          stdout: JSON.stringify({ loggedIn: true, authMethod: 'chatgpt' }),
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    const svc = new TeamProvisioningService();
+    const result = await (svc as any).probeProviderRuntimeControlPlane({
+      claudePath: '/fake/claude',
+      cwd: tempRoot,
+      env: {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      providerId: 'codex',
+      providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
+    });
+
+    expect(result.warning).toContain('runtime status was unavailable');
+    expect(execCliMock).toHaveBeenNthCalledWith(
+      2,
+      '/fake/claude',
+      [
+        '--settings',
+        '{"codex":{"forced_login_method":"chatgpt"}}',
+        'auth',
+        'status',
+        '--json',
+        '--provider',
+        'codex',
+      ],
+      expect.objectContaining({ cwd: tempRoot })
+    );
+  });
+
+  it('includes CLI output in advisory one-shot diagnostic failures', async () => {
+    const svc = new TeamProvisioningService();
+    vi.spyOn(svc as any, 'spawnProbe').mockResolvedValueOnce({
+      stdout: 'upstream unavailable',
+      stderr: 'request id: req_123',
+      exitCode: 1,
+    });
+
+    const result = await (svc as any).runProviderOneShotDiagnostic(
       '/fake/claude',
       tempRoot,
       {
@@ -1020,27 +1273,21 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
       'codex'
     );
 
+    expect(result.warning).toContain('One-shot diagnostic failed after runtime readiness passed');
     expect(result.warning).toContain('preflight check failed (exit code 1). Details:');
     expect(result.warning).toContain('upstream unavailable');
     expect(result.warning).toContain('request id: req_123');
   });
 
-  it('passes provider launch args into codex preflight ping probes', async () => {
+  it('passes provider launch args before codex advisory one-shot probe flags', async () => {
     const svc = new TeamProvisioningService();
-    const spawnProbe = vi
-      .spyOn(svc as any, 'spawnProbe')
-      .mockResolvedValueOnce({
-        stdout: 'orchestrator-cli 1.2.3',
-        stderr: '',
-        exitCode: 0,
-      })
-      .mockResolvedValueOnce({
-        stdout: 'PONG',
-        stderr: '',
-        exitCode: 0,
-      });
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe').mockResolvedValueOnce({
+      stdout: 'PONG',
+      stderr: '',
+      exitCode: 0,
+    });
 
-    const result = await (svc as any).probeClaudeRuntime(
+    const result = await (svc as any).runProviderOneShotDiagnostic(
       '/fake/claude',
       tempRoot,
       {
@@ -1053,12 +1300,21 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
 
     expect(result.warning).toBeUndefined();
     expect(spawnProbe).toHaveBeenNthCalledWith(
-      2,
+      1,
       '/fake/claude',
-      expect.arrayContaining([
+      [
         '--settings',
         '{"codex":{"forced_login_method":"chatgpt"}}',
-      ]),
+        '-p',
+        'Output only the single word PONG.',
+        '--output-format',
+        'text',
+        '--model',
+        'gpt-5.4-mini',
+        '--max-turns',
+        '1',
+        '--no-session-persistence',
+      ],
       tempRoot,
       expect.any(Object),
       60_000,
@@ -1132,7 +1388,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
     );
   });
 
-  it('passes provider launch args into selected codex model probes', async () => {
+  it('passes provider launch args into selected codex catalog checks', async () => {
     const svc = new TeamProvisioningService();
     vi.spyOn(svc as any, 'buildProvisioningEnv').mockResolvedValue({
       env: {
@@ -1152,11 +1408,7 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
         runtimeCapabilities: null,
         providerStatus: null,
       });
-    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe').mockResolvedValue({
-      stdout: 'PONG',
-      stderr: '',
-      exitCode: 0,
-    });
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe');
 
     const result = await (svc as any).verifySelectedProviderModels({
       claudePath: '/fake/claude',
@@ -1166,25 +1418,113 @@ describe('TeamProvisioningService prepare/auth behavior', () => {
       limitContext: false,
     });
 
-    expect(result.details).toEqual(['Selected model gpt-5.4 verified for launch.']);
+    expect(result.details).toEqual(['Selected model gpt-5.4 is available for launch.']);
     expect(readRuntimeProviderLaunchFacts).toHaveBeenCalledWith(
       expect.objectContaining({
         providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
       })
     );
-    expect(spawnProbe).toHaveBeenCalledWith(
+    expect(spawnProbe).not.toHaveBeenCalled();
+  });
+
+  it('passes provider launch args before model-list catalog subcommands', async () => {
+    execCliMock.mockImplementation(async (_binaryPath: string | null, args: string[]) => {
+      if (args.includes('model')) {
+        return {
+          stdout: JSON.stringify({
+            schemaVersion: 1,
+            providers: {
+              codex: {
+                defaultModel: 'gpt-5.4-mini',
+                models: [{ id: 'gpt-5.4', label: 'GPT-5.4' }],
+              },
+            },
+          }),
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      if (args.includes('runtime')) {
+        return {
+          stdout: JSON.stringify({
+            providers: {
+              codex: {
+                runtimeCapabilities: {
+                  modelCatalog: { dynamic: false, source: 'runtime' },
+                },
+              },
+            },
+          }),
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    const svc = new TeamProvisioningService();
+    await (svc as any).readRuntimeProviderLaunchFacts({
+      claudePath: '/fake/claude',
+      cwd: tempRoot,
+      providerId: 'codex',
+      env: {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
+      limitContext: false,
+    });
+
+    expect(execCliMock).toHaveBeenCalledWith(
       '/fake/claude',
-      expect.arrayContaining([
+      [
         '--settings',
         '{"codex":{"forced_login_method":"chatgpt"}}',
-      ]),
-      tempRoot,
-      expect.any(Object),
-      60_000,
-      expect.any(Object)
+        'model',
+        'list',
+        '--json',
+        '--provider',
+        'codex',
+      ],
+      expect.objectContaining({ cwd: tempRoot })
     );
   });
 
+  it('keeps missing models compatible when the runtime catalog is dynamic', async () => {
+    const svc = new TeamProvisioningService();
+    vi.spyOn(svc as any, 'buildProvisioningEnv').mockResolvedValue({
+      env: {
+        PATH: '/usr/bin',
+        SHELL: '/bin/zsh',
+      },
+      authSource: 'codex_runtime',
+      geminiRuntimeAuth: null,
+    });
+    vi.spyOn(svc as any, 'readRuntimeProviderLaunchFacts').mockResolvedValue({
+      defaultModel: null,
+      modelIds: new Set(),
+      modelCatalog: null,
+      runtimeCapabilities: { modelCatalog: { dynamic: true, source: 'runtime' } },
+      providerStatus: null,
+    });
+    const spawnProbe = vi.spyOn(svc as any, 'spawnProbe');
+
+    const result = await (svc as any).verifySelectedProviderModels({
+      claudePath: '/fake/claude',
+      cwd: tempRoot,
+      providerId: 'codex',
+      modelIds: ['future-model'],
+      limitContext: false,
+    });
+
+    expect(result).toEqual({
+      details: ['Selected model future-model is compatible. Deep verification pending.'],
+      warnings: [],
+      blockingMessages: [],
+    });
+    expect(spawnProbe).not.toHaveBeenCalled();
+  });
+
   it('maps ANTHROPIC_AUTH_TOKEN into ANTHROPIC_API_KEY for headless preflight', async () => {
     const svc = new TeamProvisioningService();
     vi.mocked(resolveInteractiveShellEnv).mockResolvedValue({
diff --git a/test/renderer/components/team/dialogs/ProvisioningProviderStatusList.test.ts b/test/renderer/components/team/dialogs/ProvisioningProviderStatusList.test.ts
index d4859a99..6fe64e72 100644
--- a/test/renderer/components/team/dialogs/ProvisioningProviderStatusList.test.ts
+++ b/test/renderer/components/team/dialogs/ProvisioningProviderStatusList.test.ts
@@ -54,7 +54,7 @@ describe('ProvisioningProviderStatusList', () => {
               status: 'failed',
               backendSummary: 'Codex native',
               details: [
-                '5.4 Mini - verified',
+                '5.4 Mini - available for launch',
                 '5.1 Codex Max - unavailable - Not available on this Codex native runtime',
               ],
             },
@@ -65,9 +65,9 @@ describe('ProvisioningProviderStatusList', () => {
     });
 
     expect(host.textContent).toContain(
-      'Codex (Codex native): Selected model checks - 1 model unavailable, 1 verified'
+      'Codex (Codex native): Selected model checks - 1 model unavailable, 1 available'
     );
-    expect(host.textContent).toContain('5.4 Mini - verified');
+    expect(host.textContent).toContain('5.4 Mini - available for launch');
     expect(host.textContent).toContain(
       '5.1 Codex Max - unavailable - Not available on this Codex native runtime'
     );
@@ -131,6 +131,43 @@ describe('ProvisioningProviderStatusList', () => {
     });
   });
 
+  it('does not count generic one-shot diagnostic timeouts as model timeouts', async () => {
+    vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(
+        React.createElement(ProvisioningProviderStatusList, {
+          checks: [
+            {
+              providerId: 'anthropic',
+              status: 'notes',
+              details: [
+                'One-shot diagnostic timed out after runtime readiness passed. This does not mark selected models unavailable. Details: Model verification timed out',
+                'Opus 4.6 - available for launch',
+                'Opus 4.7 - available for launch',
+              ],
+            },
+          ],
+        })
+      );
+      await Promise.resolve();
+    });
+
+    expect(host.textContent).toContain('Anthropic: Selected model checks - 2 available');
+    expect(host.textContent).not.toContain('1 model timed out');
+    expect(host.textContent).toContain(
+      'One-shot diagnostic timed out after runtime readiness passed'
+    );
+
+    await act(async () => {
+      root.unmount();
+      await Promise.resolve();
+    });
+  });
+
   it('summarizes compatibility-pending OpenCode model checks separately from verified ones', async () => {
     vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
     const host = document.createElement('div');
diff --git a/test/renderer/components/team/dialogs/projectPathOptions.test.ts b/test/renderer/components/team/dialogs/projectPathOptions.test.ts
index f59e99dd..33685f88 100644
--- a/test/renderer/components/team/dialogs/projectPathOptions.test.ts
+++ b/test/renderer/components/team/dialogs/projectPathOptions.test.ts
@@ -65,4 +65,27 @@ describe('buildProjectPathOptions', () => {
       },
     ]);
   });
+
+  it('excludes generated ephemeral project paths', () => {
+    const options = buildProjectPathOptions([
+      createProject({
+        id: 'project-temp',
+        name: 'codex-agent-teams-appstyle-zudek6i9',
+        path: '/private/var/folders/7b/cache/T/codex-agent-teams-appstyle-zudek6i9',
+      }),
+      createProject({
+        id: 'project-real',
+        name: 'claude_team',
+        path: '/Users/belief/dev/projects/claude/claude_team',
+      }),
+    ]);
+
+    expect(options).toEqual([
+      {
+        value: '/Users/belief/dev/projects/claude/claude_team',
+        label: 'claude_team',
+        description: '/Users/belief/dev/projects/claude/claude_team',
+      },
+    ]);
+  });
 });
diff --git a/test/renderer/components/team/dialogs/providerPrepareDiagnostics.test.ts b/test/renderer/components/team/dialogs/providerPrepareDiagnostics.test.ts
index b0bbced7..46a183da 100644
--- a/test/renderer/components/team/dialogs/providerPrepareDiagnostics.test.ts
+++ b/test/renderer/components/team/dialogs/providerPrepareDiagnostics.test.ts
@@ -54,19 +54,21 @@ describe('runProviderPrepareDiagnostics', () => {
   });
 
   it('returns a failed provider result immediately when runtime preflight fails', async () => {
-    const prepareProvisioning = vi.fn<
-      (
-        cwd?: string,
-        providerId?: TeamProviderId,
-        providerIds?: TeamProviderId[],
-        selectedModels?: string[],
-        limitContext?: boolean,
-        modelVerificationMode?: 'compatibility' | 'deep'
-      ) => Promise<TeamProvisioningPrepareResult>
-    >().mockResolvedValue({
-      ready: false,
-      message: 'Codex runtime is not authenticated.',
-    });
+    const prepareProvisioning = vi
+      .fn<
+        (
+          cwd?: string,
+          providerId?: TeamProviderId,
+          providerIds?: TeamProviderId[],
+          selectedModels?: string[],
+          limitContext?: boolean,
+          modelVerificationMode?: 'compatibility' | 'deep'
+        ) => Promise<TeamProvisioningPrepareResult>
+      >()
+      .mockResolvedValue({
+        ready: false,
+        message: 'Codex runtime is not authenticated.',
+      });
 
     const result = await runProviderPrepareDiagnostics({
       cwd: '/tmp/project',
@@ -265,8 +267,7 @@ describe('runProviderPrepareDiagnostics', () => {
     >((_, __, ___, selectedModels) => {
       return Promise.resolve({
         ready: false,
-        message:
-          `API Error: 400 {"type":"error","error":{"type":"api_error","message":"Codex API error (400): {\\"detail\\":\\"The 'gpt-5.1-codex-max' model is not supported when using Codex with a ChatGPT account.\\"}"}}`,
+        message: `API Error: 400 {"type":"error","error":{"type":"api_error","message":"Codex API error (400): {\\"detail\\":\\"The 'gpt-5.1-codex-max' model is not supported when using Codex with a ChatGPT account.\\"}"}}`,
       });
     });
 
@@ -378,9 +379,95 @@ describe('runProviderPrepareDiagnostics', () => {
     });
 
     expect(result.details).toEqual(['Default - verified']);
-    expect(prepareProvisioning).toHaveBeenNthCalledWith(1, '/tmp/project', 'anthropic', ['anthropic'], [
-      DEFAULT_PROVIDER_MODEL_SELECTION,
-    ], true);
+    expect(prepareProvisioning).toHaveBeenNthCalledWith(
+      1,
+      '/tmp/project',
+      'anthropic',
+      ['anthropic'],
+      [DEFAULT_PROVIDER_MODEL_SELECTION],
+      true,
+      'compatibility'
+    );
+  });
+
+  it('checks multiple Anthropic selected models without OpenCode compatibility-pending progress', async () => {
+    const progressUpdates: Array<{
+      status: 'checking' | 'ready' | 'notes' | 'failed';
+      details: string[];
+      completedCount: number;
+      totalCount: number;
+    }> = [];
+    const prepareProvisioning = vi.fn<
+      (
+        cwd?: string,
+        providerId?: TeamProviderId,
+        providerIds?: TeamProviderId[],
+        selectedModels?: string[],
+        limitContext?: boolean,
+        modelVerificationMode?: 'compatibility' | 'deep'
+      ) => Promise<TeamProvisioningPrepareResult>
+    >((_, __, ___, selectedModels, ____, modelVerificationMode) => {
+      if (selectedModels) {
+        expect(modelVerificationMode).toBe('compatibility');
+        expect(selectedModels).toEqual(['claude-test-a', 'claude-test-b']);
+        return Promise.resolve({
+          ready: true,
+          message: 'CLI is warmed up and ready to launch',
+          details: [
+            'Selected model claude-test-a verified for launch.',
+            'Selected model claude-test-b verified for launch.',
+          ],
+        });
+      }
+
+      expect(modelVerificationMode).toBe('deep');
+      return Promise.resolve({
+        ready: true,
+        message: 'CLI is warmed up and ready to launch',
+        details: [],
+      });
+    });
+
+    const result = await runProviderPrepareDiagnostics({
+      cwd: '/tmp/project',
+      providerId: 'anthropic',
+      selectedModelIds: ['claude-test-a', 'claude-test-b'],
+      prepareProvisioning,
+      onModelProgress: (progress) => progressUpdates.push(progress),
+    });
+
+    expect(result.status).toBe('ready');
+    expect(result.details).toEqual(['claude-test-a - verified', 'claude-test-b - verified']);
+    expect(progressUpdates[0]).toEqual({
+      status: 'checking',
+      completedCount: 0,
+      totalCount: 2,
+      details: ['claude-test-a - checking...', 'claude-test-b - checking...'],
+    });
+    expect(
+      progressUpdates
+        .flatMap((progress) => progress.details)
+        .some((line) => line.includes('compatible'))
+    ).toBe(false);
+    expect(prepareProvisioning).toHaveBeenCalledTimes(2);
+    expect(prepareProvisioning).toHaveBeenNthCalledWith(
+      1,
+      '/tmp/project',
+      'anthropic',
+      ['anthropic'],
+      ['claude-test-a', 'claude-test-b'],
+      undefined,
+      'compatibility'
+    );
+    expect(prepareProvisioning).toHaveBeenNthCalledWith(
+      2,
+      '/tmp/project',
+      'anthropic',
+      ['anthropic'],
+      undefined,
+      undefined,
+      'deep'
+    );
   });
 
   it('reuses cached model results and probes only newly selected models', async () => {
@@ -438,9 +525,15 @@ describe('runProviderPrepareDiagnostics', () => {
       '5.2 Codex - unavailable - Not available on this Codex native runtime',
     ]);
     expect(prepareProvisioning).toHaveBeenCalledTimes(1);
-    expect(prepareProvisioning).toHaveBeenNthCalledWith(1, '/tmp/project', 'codex', ['codex'], [
-      'gpt-5.2-codex',
-    ], undefined);
+    expect(prepareProvisioning).toHaveBeenNthCalledWith(
+      1,
+      '/tmp/project',
+      'codex',
+      ['codex'],
+      ['gpt-5.2-codex'],
+      undefined,
+      'compatibility'
+    );
   });
 
   it('suppresses a timed out runtime preflight note when that same model later verifies', async () => {
@@ -501,18 +594,16 @@ describe('runProviderPrepareDiagnostics', () => {
     });
 
     expect(result.status).toBe('notes');
-    expect(result.warnings).toEqual([
-      '5.4 - check failed - Verification did not complete after runtime preflight warning',
-    ]);
+    expect(result.warnings).toEqual(['orchestrator-cli preflight check failed (exit code 1).']);
     expect(result.details).toEqual([
-      '5.4 - check failed - Verification did not complete after runtime preflight warning',
+      'orchestrator-cli preflight check failed (exit code 1).',
+      '5.4 - compatible, deep verification pending...',
     ]);
     expect(result.modelResultsById).toEqual({
       'gpt-5.4': {
         status: 'notes',
-        line: '5.4 - check failed - Verification did not complete after runtime preflight warning',
-        warningLine:
-          '5.4 - check failed - Verification did not complete after runtime preflight warning',
+        line: '5.4 - compatible, deep verification pending...',
+        warningLine: null,
       },
     });
   });
@@ -530,7 +621,9 @@ describe('runProviderPrepareDiagnostics', () => {
         ready: true,
         message: 'CLI is ready to launch (see notes)',
         details: ['Selected model gpt-5.4 verified for launch.'],
-        warnings: ['orchestrator-cli preflight check failed (exit code 1). Details: upstream unavailable'],
+        warnings: [
+          'orchestrator-cli preflight check failed (exit code 1). Details: upstream unavailable',
+        ],
       });
     });
 
diff --git a/test/renderer/components/team/taskLogs/TaskLogStreamSection.test.ts b/test/renderer/components/team/taskLogs/TaskLogStreamSection.test.ts
index b0a30f25..610d2356 100644
--- a/test/renderer/components/team/taskLogs/TaskLogStreamSection.test.ts
+++ b/test/renderer/components/team/taskLogs/TaskLogStreamSection.test.ts
@@ -33,12 +33,25 @@ vi.mock('@renderer/components/team/members/MemberExecutionLog', () => ({
   }: {
     memberName?: string;
     chunks: { id: string }[];
-  }) =>
-    React.createElement(
+  }) => {
+    const [expanded, setExpanded] = React.useState(true);
+    return React.createElement(
       'div',
-      { 'data-testid': 'member-execution-log' },
-      `${memberName ?? 'lead'}:${chunks.length}`
-    ),
+      {
+        'data-testid': 'member-execution-log',
+        'data-expanded': expanded ? 'true' : 'false',
+      },
+      React.createElement(
+        'button',
+        {
+          type: 'button',
+          'data-testid': `member-execution-log-toggle:${memberName ?? 'lead'}`,
+          onClick: () => setExpanded((prev) => !prev),
+        },
+        `${memberName ?? 'lead'}:${chunks.length}`
+      )
+    );
+  },
 }));
 
 import { TaskLogStreamSection } from '@renderer/components/team/taskLogs/TaskLogStreamSection';
@@ -63,7 +76,9 @@ function buildSegment(args: {
   memberName: string;
   startTimestamp: string;
   endTimestamp: string;
+  chunkIds?: string[];
 }) {
+  const chunkIds = args.chunkIds ?? [`chunk-${args.id}`];
   return {
     id: args.id,
     participantKey: args.participantKey,
@@ -76,7 +91,11 @@ function buildSegment(args: {
     },
     startTimestamp: args.startTimestamp,
     endTimestamp: args.endTimestamp,
-    chunks: [{ id: `chunk-${args.id}`, chunkType: 'user', rawMessages: [] }] as never,
+    chunks: chunkIds.map((chunkId) => ({
+      id: chunkId,
+      chunkType: 'user',
+      rawMessages: [],
+    })) as never,
   };
 }
 
@@ -499,6 +518,90 @@ describe('TaskLogStreamSection', () => {
     });
   });
 
+  it('preserves expanded state when a live refresh extends the current segment tail', async () => {
+    vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+    vi.useFakeTimers();
+
+    let handler: ((event: unknown, data: TeamChangeEvent) => void) | null = null;
+    apiState.onTeamChange.mockImplementation((callback) => {
+      handler = callback;
+      return () => {
+        handler = null;
+      };
+    });
+
+    apiState.getTaskLogStream
+      .mockResolvedValueOnce({
+        participants: [buildParticipant('member:alice', 'alice')],
+        defaultFilter: 'all',
+        segments: [
+          buildSegment({
+            id: 'member:alice:chunk-start:chunk-start',
+            participantKey: 'member:alice',
+            memberName: 'alice',
+            startTimestamp: '2026-04-24T10:00:00.000Z',
+            endTimestamp: '2026-04-24T10:01:00.000Z',
+            chunkIds: ['chunk-start'],
+          }),
+        ],
+      })
+      .mockResolvedValueOnce({
+        participants: [buildParticipant('member:alice', 'alice')],
+        defaultFilter: 'all',
+        segments: [
+          buildSegment({
+            id: 'member:alice:chunk-start:chunk-next',
+            participantKey: 'member:alice',
+            memberName: 'alice',
+            startTimestamp: '2026-04-24T10:00:00.000Z',
+            endTimestamp: '2026-04-24T10:02:00.000Z',
+            chunkIds: ['chunk-start', 'chunk-next'],
+          }),
+        ],
+      });
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(React.createElement(TaskLogStreamSection, { teamName: 'demo', taskId: 'task-a' }));
+      await flushMicrotasks();
+    });
+
+    const logNodeBefore = host.querySelector('[data-testid="member-execution-log"]');
+    const toggle = host.querySelector(
+      '[data-testid="member-execution-log-toggle:alice"]'
+    ) as HTMLButtonElement | null;
+    expect(logNodeBefore?.getAttribute('data-expanded')).toBe('true');
+    expect(toggle).not.toBeNull();
+
+    await act(async () => {
+      toggle?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+      await flushMicrotasks();
+    });
+
+    expect(
+      host.querySelector('[data-testid="member-execution-log"]')?.getAttribute('data-expanded')
+    ).toBe('false');
+
+    await act(async () => {
+      handler?.(null, { teamName: 'demo', type: 'task-log-change', taskId: 'task-a' });
+      vi.advanceTimersByTime(400);
+      await flushMicrotasks();
+    });
+
+    const logNodeAfter = host.querySelector('[data-testid="member-execution-log"]');
+    expect(apiState.getTaskLogStream).toHaveBeenCalledTimes(2);
+    expect(logNodeAfter?.getAttribute('data-expanded')).toBe('false');
+    expect(logNodeAfter?.textContent).toBe('alice:2');
+
+    await act(async () => {
+      root.unmount();
+      await flushMicrotasks();
+    });
+  });
+
   it('does not subscribe to live refresh when live mode is disabled', async () => {
     vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
 
diff --git a/test/renderer/features/agent-graph/TeamGraphAdapter.test.ts b/test/renderer/features/agent-graph/TeamGraphAdapter.test.ts
index 48b7d81b..7439b827 100644
--- a/test/renderer/features/agent-graph/TeamGraphAdapter.test.ts
+++ b/test/renderer/features/agent-graph/TeamGraphAdapter.test.ts
@@ -1580,6 +1580,29 @@ describe('TeamGraphAdapter particles', () => {
     });
   });
 
+  it('does not project warning-only change presence as file changes', () => {
+    const adapter = TeamGraphAdapter.create();
+    const graph = adapter.adapt(
+      createBaseTeamData({
+        tasks: [
+          {
+            id: 'task-warning-only',
+            displayId: '#6',
+            subject: 'Needs attention without file diff',
+            owner: 'alice',
+            status: 'in_progress',
+            changePresence: 'needs_attention',
+          } as TeamTaskWithKanban,
+        ],
+      }),
+      'my-team'
+    );
+
+    expect(findNode(graph, 'task:my-team:task-warning-only')).toMatchObject({
+      changePresence: 'unknown',
+    });
+  });
+
   it('adds compact runtime labels for lead and members and refreshes when runtime changes', () => {
     const adapter = TeamGraphAdapter.create();
     adapter.adapt(createBaseTeamData(), 'my-team');
diff --git a/test/renderer/utils/memberHelpers.test.ts b/test/renderer/utils/memberHelpers.test.ts
index 7c6ba261..d3e59230 100644
--- a/test/renderer/utils/memberHelpers.test.ts
+++ b/test/renderer/utils/memberHelpers.test.ts
@@ -87,9 +87,7 @@ describe('memberHelpers spawn-aware presence', () => {
 
     expect(
       getSpawnAwareDotClass(member, 'spawning', 'starting', false, false, true, false, undefined)
-    ).toContain(
-      'bg-amber-400'
-    );
+    ).toContain('bg-amber-400');
 
     expect(getSpawnCardClass('spawning', 'starting', false, false)).toContain(
       'member-waiting-shimmer'
@@ -112,16 +110,7 @@ describe('memberHelpers spawn-aware presence', () => {
     ).toBe('offline');
 
     expect(
-      getSpawnAwareDotClass(
-        member,
-        'spawning',
-        'starting',
-        false,
-        false,
-        false,
-        false,
-        undefined
-      )
+      getSpawnAwareDotClass(member, 'spawning', 'starting', false, false, false, false, undefined)
     ).toContain('bg-red-400');
 
     expect(getSpawnCardClass('spawning', 'starting', false, false, false, false)).toBe('');
@@ -155,9 +144,9 @@ describe('memberHelpers spawn-aware presence', () => {
       )
     ).toContain('bg-zinc-400');
 
-    expect(getSpawnCardClass('online', 'runtime_pending_bootstrap', true, true, true, false)).toContain(
-      'member-waiting-shimmer'
-    );
+    expect(
+      getSpawnCardClass('online', 'runtime_pending_bootstrap', true, true, true, false)
+    ).toContain('member-waiting-shimmer');
   });
 
   it('shows confirmed teammates as ready instead of idle while launch is still settling', () => {
@@ -345,6 +334,59 @@ describe('memberHelpers spawn-aware presence', () => {
     ).toContain('Connection timed out while contacting provider.');
   });
 
+  it('renders terminal API errors as errors instead of retrying status', () => {
+    expect(
+      getMemberRuntimeAdvisoryLabel(
+        {
+          kind: 'api_error',
+          observedAt: '2026-04-07T09:00:00.000Z',
+          reasonCode: 'auth_error',
+          statusCode: 500,
+          message: 'API Error: 500 {"error":{"message":"auth_unavailable: no auth available"}}',
+        },
+        'anthropic',
+        Date.parse('2026-04-07T09:00:00.000Z')
+      )
+    ).toBe('Anthropic auth error');
+
+    expect(
+      getMemberRuntimeAdvisoryTitle(
+        {
+          kind: 'api_error',
+          observedAt: '2026-04-07T09:00:00.000Z',
+          reasonCode: 'auth_error',
+          statusCode: 500,
+          message: 'auth_unavailable: no auth available',
+        },
+        'anthropic'
+      )
+    ).toContain('Anthropic authentication error');
+  });
+
+  it('marks launch presentation as an error when the runtime has a terminal API error', () => {
+    const presentation = buildMemberLaunchPresentation({
+      member: { ...member, providerId: 'anthropic' },
+      spawnStatus: 'online',
+      spawnLaunchState: 'runtime_pending_bootstrap',
+      spawnLivenessSource: 'process',
+      spawnRuntimeAlive: true,
+      runtimeAdvisory: {
+        kind: 'api_error',
+        observedAt: '2026-04-07T09:00:00.000Z',
+        reasonCode: 'auth_error',
+        statusCode: 500,
+        message: 'auth_unavailable: no auth available',
+      },
+      isLaunchSettling: false,
+      isTeamAlive: true,
+      isTeamProvisioning: false,
+    });
+
+    expect(presentation.presenceLabel).toBe('Anthropic auth error');
+    expect(presentation.runtimeAdvisoryTone).toBe('error');
+    expect(presentation.dotClass).toContain('bg-red-400');
+  });
+
   it('falls back to the existing generic retry wording when no structured reason is present', () => {
     expect(
       getMemberRuntimeAdvisoryLabel(