feat(team): enhance team provisioning with runtime model handling

- Added support for live runtime model metadata in team provisioning.
- Implemented functions to extract and manage CLI flag values for team members.
- Updated member specifications to include effective models based on provider defaults.
- Enhanced UI dialogs to check selected providers in parallel, improving responsiveness.
- Added tests for handling model unavailability during team bootstrap and launch processes.

src/main/services/team/TeamProvisioningService.ts

@@ -783,6 +783,36 @@ function createInitialMemberSpawnStatusEntry(): MemberSpawnStatusEntry {
   };
 }
 
+interface LiveTeamAgentRuntimeMetadata {
+  model?: string;
+}
+
+function stripWrappedCliFlagValue(raw: string | undefined): string | undefined {
+  const trimmed = raw?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    const unwrapped = trimmed.slice(1, -1).trim();
+    return unwrapped.length > 0 ? unwrapped : undefined;
+  }
+  return trimmed;
+}
+
+function extractCliFlagValue(command: string, flagName: string): string | undefined {
+  const escapedFlag = flagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = new RegExp(`(?:^|\\s)${escapedFlag}\\s+("([^"]*)"|'([^']*)'|([^\\s]+))`).exec(
+    command
+  );
+  if (!match) {
+    return undefined;
+  }
+  return stripWrappedCliFlagValue(match[2] ?? match[3] ?? match[4] ?? match[1]);
+}
+
 export function shouldAcceptDeterministicBootstrapEvent(params: {
   runId: string;
   teamName: string;
@@ -911,11 +941,17 @@ function buildEffectiveTeamMemberSpec(
 ): TeamMemberInput {
   const memberProviderId = normalizeTeamMemberProviderId(member.providerId);
   const defaultProviderId = normalizeTeamMemberProviderId(defaults.providerId);
-  const model = member.model?.trim() || defaults.model?.trim() || undefined;
+  const effectiveProviderId = memberProviderId ?? defaultProviderId ?? 'anthropic';
+  const model =
+    member.model?.trim() ||
+    (memberProviderId == null || memberProviderId === defaultProviderId
+      ? defaults.model?.trim()
+      : undefined) ||
+    undefined;
 
   return {
     ...member,
-    providerId: memberProviderId ?? defaultProviderId ?? 'anthropic',
+    providerId: effectiveProviderId,
     model,
     effort: member.effort ?? defaults.effort,
   };
@@ -3396,16 +3432,19 @@ export class TeamProvisioningService {
   }> {
     const runId = this.getTrackedRunId(teamName);
     if (!runId) {
-      return this.reconcilePersistedLaunchState(teamName).then(({ snapshot, statuses }) => ({
+      return this.reconcilePersistedLaunchState(teamName).then(({ snapshot, statuses }) => {
-        statuses,
+        this.attachLiveRuntimeMetadataToStatuses(teamName, statuses);
-        runId: null,
+        return {
-        teamLaunchState: snapshot?.teamLaunchState,
+          statuses,
-        launchPhase: snapshot?.launchPhase,
+          runId: null,
-        expectedMembers: snapshot?.expectedMembers,
+          teamLaunchState: snapshot?.teamLaunchState,
-        updatedAt: snapshot?.updatedAt,
+          launchPhase: snapshot?.launchPhase,
-        summary: snapshot?.summary,
+          expectedMembers: snapshot?.expectedMembers,
-        source: snapshot ? 'persisted' : 'persisted',
+          updatedAt: snapshot?.updatedAt,
-      }));
+          summary: snapshot?.summary,
+          source: snapshot ? 'persisted' : 'persisted',
+        };
+      });
     }
     const run = this.runs.get(runId);
     if (!run) {
@@ -3426,6 +3465,7 @@ export class TeamProvisioningService {
     });
     const snapshot = persisted ?? liveSnapshot;
     const statuses = snapshotToMemberSpawnStatuses(snapshot);
+    this.attachLiveRuntimeMetadataToStatuses(teamName, statuses);
     return {
       statuses,
       runId,
@@ -3552,7 +3592,6 @@ export class TeamProvisioningService {
         !current ||
         current.launchState === 'failed_to_start' ||
         current.launchState === 'confirmed_alive' ||
-        current.runtimeAlive === true ||
         current.hardFailure === true ||
         current.agentToolAccepted !== true
       ) {
@@ -3902,6 +3941,89 @@ export class TeamProvisioningService {
       : null;
   }
 
+  private async materializeEffectiveTeamMemberSpecs(params: {
+    claudePath: string;
+    cwd: string;
+    members: TeamCreateRequest['members'];
+    defaults: {
+      providerId?: TeamProviderId;
+      model?: string;
+      effort?: TeamCreateRequest['effort'];
+    };
+    primaryProviderId?: TeamProviderId;
+    primaryEnv?: ProvisioningEnvResolution;
+    limitContext?: boolean;
+  }): Promise<TeamCreateRequest['members']> {
+    const envByProvider = new Map<TeamProviderId, Promise<ProvisioningEnvResolution>>();
+    const defaultModelByProvider = new Map<TeamProviderId, Promise<string>>();
+    const normalizedPrimaryProviderId = resolveTeamProviderId(params.primaryProviderId);
+
+    const getProvisioningEnv = (providerId: TeamProviderId): Promise<ProvisioningEnvResolution> => {
+      if (normalizedPrimaryProviderId === providerId && params.primaryEnv != null) {
+        return Promise.resolve(params.primaryEnv);
+      }
+
+      const cached = envByProvider.get(providerId);
+      if (cached) {
+        return cached;
+      }
+
+      const created = this.buildProvisioningEnv(providerId);
+      envByProvider.set(providerId, created);
+      return created;
+    };
+
+    const getResolvedDefaultModel = (providerId: TeamProviderId): Promise<string> => {
+      const cached = defaultModelByProvider.get(providerId);
+      if (cached) {
+        return cached;
+      }
+
+      const providerLabel = getTeamProviderLabel(providerId);
+      const created = (async () => {
+        const envResolution = await getProvisioningEnv(providerId);
+        if (envResolution.warning) {
+          throw new Error(envResolution.warning);
+        }
+
+        const resolvedDefaultModel = await this.resolveProviderDefaultModel(
+          params.claudePath,
+          params.cwd,
+          providerId,
+          envResolution.env,
+          params.limitContext === true
+        );
+        const normalized = resolvedDefaultModel?.trim();
+        if (!normalized) {
+          throw new Error(
+            `Could not resolve the runtime default model for ${providerLabel} teammates. Select an explicit model and retry.`
+          );
+        }
+        return normalized;
+      })();
+
+      defaultModelByProvider.set(providerId, created);
+      return created;
+    };
+
+    const effectiveMembers: TeamCreateRequest['members'] = [];
+    for (const member of params.members) {
+      const effectiveMember = buildEffectiveTeamMemberSpec(member, params.defaults);
+      const providerId = normalizeTeamMemberProviderId(effectiveMember.providerId) ?? 'anthropic';
+      if (providerId === 'anthropic' || effectiveMember.model?.trim()) {
+        effectiveMembers.push(effectiveMember);
+        continue;
+      }
+
+      effectiveMembers.push({
+        ...effectiveMember,
+        model: await getResolvedDefaultModel(providerId),
+      });
+    }
+
+    return effectiveMembers;
+  }
+
   private getFreshCachedProbeResult(
     cwd: string,
     providerId: TeamProviderId | undefined
@@ -4756,10 +4878,23 @@ export class TeamProvisioningService {
         throw new Error('Claude CLI not found; install it or provide a valid path');
       }
 
-      const effectiveMemberSpecs = buildEffectiveTeamMemberSpecs(request.members, {
+      const provisioningEnv = await this.buildProvisioningEnv(request.providerId);
-        providerId: request.providerId,
+      const { env: shellEnv, geminiRuntimeAuth, warning: envWarning } = provisioningEnv;
-        model: request.model,
+      if (envWarning) {
-        effort: request.effort,
+        throw new Error(envWarning);
+      }
+      const effectiveMemberSpecs = await this.materializeEffectiveTeamMemberSpecs({
+        claudePath,
+        cwd: request.cwd,
+        members: request.members,
+        defaults: {
+          providerId: request.providerId,
+          model: request.model,
+          effort: request.effort,
+        },
+        primaryProviderId: request.providerId,
+        primaryEnv: provisioningEnv,
+        limitContext: request.limitContext,
       });
       const runId = randomUUID();
       const startedAt = nowIso();
@@ -4864,14 +4999,6 @@ export class TeamProvisioningService {
       const initialUserPrompt = request.prompt?.trim() ?? '';
       const promptSize = getPromptSizeSummary(initialUserPrompt);
       let child: ReturnType<typeof spawn>;
-      const {
-        env: shellEnv,
-        geminiRuntimeAuth,
-        warning: envWarning,
-      } = await this.buildProvisioningEnv(request.providerId);
-      if (envWarning) {
-        throw new Error(envWarning);
-      }
       shellEnv.CLAUDE_ENABLE_DETERMINISTIC_TEAM_BOOTSTRAP = '1';
       const teammateModeDecision = await resolveDesktopTeammateModeDecision(request.extraCliArgs);
       if (teammateModeDecision.forceProcessTeammates) {
@@ -4963,10 +5090,16 @@ export class TeamProvisioningService {
         });
         await this.membersMetaStore.writeMembers(
           request.teamName,
-          request.members.map((m) => ({
+          effectiveMemberSpecs.map((m) => ({
             name: m.name.trim(),
             role: m.role?.trim() || undefined,
             workflow: m.workflow?.trim() || undefined,
+            providerId: normalizeOptionalTeamProviderId(m.providerId),
+            model: m.model?.trim() || undefined,
+            effort:
+              m.effort === 'low' || m.effort === 'medium' || m.effort === 'high'
+                ? m.effort
+                : undefined,
             agentType: 'general-purpose' as const,
             color: getMemberColorByName(m.name.trim()),
             joinedAt: Date.now(),
@@ -5300,16 +5433,30 @@ export class TeamProvisioningService {
       const runId = randomUUID();
       const startedAt = nowIso();
 
-      const effectiveMemberSpecs = buildEffectiveTeamMemberSpecs(expectedMemberSpecs, {
+      const provisioningEnv = await this.buildProvisioningEnv(request.providerId);
-        providerId: request.providerId,
+      const { env: shellEnv, geminiRuntimeAuth, warning: envWarning } = provisioningEnv;
-        model: request.model,
+      if (envWarning) {
-        effort: request.effort,
+        throw new Error(envWarning);
+      }
+
+      const effectiveMemberSpecs = await this.materializeEffectiveTeamMemberSpecs({
+        claudePath,
+        cwd: request.cwd,
+        members: expectedMemberSpecs,
+        defaults: {
+          providerId: request.providerId,
+          model: request.model,
+          effort: request.effort,
+        },
+        primaryProviderId: request.providerId,
+        primaryEnv: provisioningEnv,
+        limitContext: request.limitContext,
       });
 
       // Build a synthetic TeamCreateRequest for reuse by shared infrastructure
       const syntheticRequest: TeamCreateRequest = {
         teamName: request.teamName,
-        members: expectedMemberSpecs,
+        members: effectiveMemberSpecs,
         cwd: request.cwd,
         providerId: request.providerId,
         model: request.model,
@@ -5448,14 +5595,6 @@ export class TeamProvisioningService {
       );
       const promptSize = getPromptSizeSummary(prompt);
       let child: ReturnType<typeof spawn>;
-      const {
-        env: shellEnv,
-        geminiRuntimeAuth,
-        warning: envWarning,
-      } = await this.buildProvisioningEnv(request.providerId);
-      if (envWarning) {
-        throw new Error(envWarning);
-      }
       shellEnv.CLAUDE_ENABLE_DETERMINISTIC_TEAM_BOOTSTRAP = '1';
       const teammateModeDecision = await resolveDesktopTeammateModeDecision(request.extraCliArgs);
       if (teammateModeDecision.forceProcessTeammates) {
@@ -6842,12 +6981,34 @@ export class TeamProvisioningService {
   }
 
   private hasLiveTeamAgentProcess(teamName: string, memberName: string): boolean {
-    return this.getLiveTeamAgentNames(teamName).has(memberName);
+    return this.getLiveTeamAgentRuntimeMetadata(teamName).has(memberName);
+  }
+
+  private attachLiveRuntimeMetadataToStatuses(
+    teamName: string,
+    statuses: Record<string, MemberSpawnStatusEntry>
+  ): void {
+    for (const [memberName, metadata] of this.getLiveTeamAgentRuntimeMetadata(teamName).entries()) {
+      const current = statuses[memberName];
+      if (!current || !metadata.model) {
+        continue;
+      }
+      statuses[memberName] = {
+        ...current,
+        runtimeModel: metadata.model,
+      };
+    }
   }
 
   private getLiveTeamAgentNames(teamName: string): Set<string> {
+    return new Set(this.getLiveTeamAgentRuntimeMetadata(teamName).keys());
+  }
+
+  private getLiveTeamAgentRuntimeMetadata(
+    teamName: string
+  ): Map<string, LiveTeamAgentRuntimeMetadata> {
     if (process.platform === 'win32') {
-      return new Set();
+      return new Map();
     }
 
     let output = '';
@@ -6857,11 +7018,11 @@ export class TeamProvisioningService {
         stdio: ['ignore', 'pipe', 'ignore'],
       });
     } catch {
-      return new Set();
+      return new Map();
     }
 
     const teamMarker = `--team-name ${teamName}`;
-    const names = new Set<string>();
+    const metadataByAgent = new Map<string, LiveTeamAgentRuntimeMetadata>();
     for (const line of output.split('\n')) {
       const trimmed = line.trim();
       if (!trimmed.includes(teamMarker)) continue;
@@ -6869,10 +7030,13 @@ export class TeamProvisioningService {
       if (!match) continue;
       const agentName = match[1]?.trim();
       if (agentName) {
-        names.add(agentName);
+        const model = extractCliFlagValue(trimmed, '--model');
+        metadataByAgent.set(agentName, {
+          ...(model ? { model } : {}),
+        });
       }
     }
-    return names;
+    return metadataByAgent;
   }
 
   private async clearPersistedLaunchState(teamName: string): Promise<void> {
@@ -7107,7 +7271,7 @@ export class TeamProvisioningService {
         current.hardFailure = false;
         current.hardFailureReason = undefined;
       }
-      if (!current.bootstrapConfirmed && !runtimeAlive && !current.hardFailure) {
+      if (!current.bootstrapConfirmed && !current.hardFailure) {
         const transcriptFailureReason = await this.findBootstrapTranscriptFailureReason(
           teamName,
           expected,

src/renderer/components/team/dialogs/CreateTeamDialog.tsx

@@ -593,7 +593,7 @@ export const CreateTeamDialog = ({
       selectedMemberProviders
     );
     setPrepareState('loading');
-    setPrepareMessage('Checking selected providers...');
+    setPrepareMessage('Checking selected providers in parallel...');
     setPrepareWarnings([]);
     setPrepareChecks(initialChecks);
 
@@ -601,118 +601,128 @@ export const CreateTeamDialog = ({
     const timer = setTimeout(() => {
       void (async () => {
         let checks = initialChecks;
-        let anyFailure = false;
+        const providerPlans = selectedMemberProviders.map((providerId) => {
-        let anyNotes = false;
+          const selectedModelChecks = (() => {
-        const collectedWarnings: string[] = [];
+            const next = new Set<string>();
-
+            let hasDefaultSelection = false;
-        try {
+            const supportsProviderDefaultCheck =
-          for (const providerId of selectedMemberProviders) {
+              providerId === 'codex' ||
-            const selectedModelChecks = (() => {
+              providerId === 'gemini' ||
-              const next = new Set<string>();
+              (providerId === 'anthropic' && selectedProviderId === 'anthropic');
-              let hasDefaultSelection = false;
+            const leadModel = computeEffectiveTeamModel(
-              const supportsProviderDefaultCheck =
+              selectedModel,
-                providerId === 'codex' ||
+              limitContext,
-                providerId === 'gemini' ||
+              selectedProviderId
-                (providerId === 'anthropic' && selectedProviderId === 'anthropic');
+            );
-              const leadModel = computeEffectiveTeamModel(
+            if (selectedProviderId === providerId && selectedModel.trim()) {
-                selectedModel,
+              if (leadModel?.trim()) {
-                limitContext,
+                next.add(leadModel.trim());
-                selectedProviderId
+              }
-              );
+            } else if (selectedProviderId === providerId && supportsProviderDefaultCheck) {
-              if (selectedProviderId === providerId && selectedModel.trim()) {
+              hasDefaultSelection = true;
-                if (leadModel?.trim()) {
+            }
-                  next.add(leadModel.trim());
+            for (const member of effectiveMemberDrafts) {
-                }
+              if (member.removedAt) {
-              } else if (selectedProviderId === providerId && supportsProviderDefaultCheck) {
+                continue;
+              }
+              const memberProviderId =
+                normalizeOptionalTeamProviderId(member.providerId) ?? selectedProviderId;
+              if (memberProviderId !== providerId) {
+                continue;
+              }
+              const memberModel = member.model?.trim();
+              if (memberModel) {
+                next.add(memberModel);
+              } else if (supportsProviderDefaultCheck) {
                 hasDefaultSelection = true;
               }
-              for (const member of effectiveMemberDrafts) {
-                if (member.removedAt) {
-                  continue;
-                }
-                const memberProviderId =
-                  normalizeOptionalTeamProviderId(member.providerId) ?? selectedProviderId;
-                if (memberProviderId !== providerId) {
-                  continue;
-                }
-                const memberModel = member.model?.trim();
-                if (memberModel) {
-                  next.add(memberModel);
-                } else if (supportsProviderDefaultCheck) {
-                  hasDefaultSelection = true;
-                }
-              }
-              if (supportsProviderDefaultCheck && hasDefaultSelection) {
-                next.add(DEFAULT_PROVIDER_MODEL_SELECTION);
-              }
-              return Array.from(next);
-            })();
-            const backendSummary =
-              runtimeBackendSummaryByProviderRef.current.get(providerId) ?? null;
-            const cacheKey = buildPrepareModelCacheKey(effectiveCwd, providerId, backendSummary);
-            const cachedModelResultsById = prepareModelResultsCacheRef.current.get(cacheKey) ?? {};
-            const cachedSnapshot = getProviderPrepareCachedSnapshot({
-              providerId,
-              selectedModelIds: selectedModelChecks,
-              cachedModelResultsById,
-            });
-            checks = updateProviderCheck(checks, providerId, {
-              status: selectedModelChecks.length > 0 ? cachedSnapshot.status : 'checking',
-              backendSummary,
-              details: cachedSnapshot.details,
-            });
-            if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-              setPrepareChecks(checks);
-              setPrepareMessage(
-                selectedModelChecks.length > 0
-                  ? `Checking ${getProviderLabel(providerId)} runtime and selected model checks ${cachedSnapshot.completedCount}/${cachedSnapshot.totalCount}...`
-                  : `Checking ${getProviderLabel(providerId)} runtime...`
-              );
             }
+            if (supportsProviderDefaultCheck && hasDefaultSelection) {
+              next.add(DEFAULT_PROVIDER_MODEL_SELECTION);
+            }
+            return Array.from(next);
+          })();
+          const backendSummary = runtimeBackendSummaryByProviderRef.current.get(providerId) ?? null;
+          const cacheKey = buildPrepareModelCacheKey(effectiveCwd, providerId, backendSummary);
+          const cachedModelResultsById = prepareModelResultsCacheRef.current.get(cacheKey) ?? {};
+          const cachedSnapshot = getProviderPrepareCachedSnapshot({
+            providerId,
+            selectedModelIds: selectedModelChecks,
+            cachedModelResultsById,
+          });
+          return {
+            providerId,
+            selectedModelChecks,
+            backendSummary,
+            cacheKey,
+            cachedModelResultsById,
+            cachedSnapshot,
+          };
+        });
 
-            const prepResult = await runProviderPrepareDiagnostics({
+        try {
-              cwd: effectiveCwd,
+          for (const plan of providerPlans) {
-              providerId,
+            checks = updateProviderCheck(checks, plan.providerId, {
-              selectedModelIds: selectedModelChecks,
+              status: plan.selectedModelChecks.length > 0 ? plan.cachedSnapshot.status : 'checking',
-              prepareProvisioning: api.teams.prepareProvisioning,
+              backendSummary: plan.backendSummary,
-              limitContext,
+              details: plan.cachedSnapshot.details,
-              cachedModelResultsById,
-              onModelProgress: ({ details, completedCount, totalCount }) => {
-                checks = updateProviderCheck(checks, providerId, {
-                  status: 'checking',
-                  backendSummary,
-                  details,
-                });
-                if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-                  setPrepareChecks(checks);
-                  setPrepareMessage(
-                    `Checking ${getProviderLabel(providerId)} runtime and selected model checks ${completedCount}/${totalCount}...`
-                  );
-                }
-              },
             });
-            if (prepResult.warnings.length > 0) {
+          }
+          if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+            setPrepareChecks(checks);
+          }
+          const providerResults = await Promise.all(
+            providerPlans.map(async (plan) => {
+              const prepResult = await runProviderPrepareDiagnostics({
+                cwd: effectiveCwd,
+                providerId: plan.providerId,
+                selectedModelIds: plan.selectedModelChecks,
+                prepareProvisioning: api.teams.prepareProvisioning,
+                limitContext,
+                cachedModelResultsById: plan.cachedModelResultsById,
+                onModelProgress: ({ details }) => {
+                  checks = updateProviderCheck(checks, plan.providerId, {
+                    status: 'checking',
+                    backendSummary: plan.backendSummary,
+                    details,
+                  });
+                  if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+                    setPrepareChecks(checks);
+                  }
+                },
+              });
+              return { ...plan, prepResult };
+            })
+          );
+          let anyFailure = false;
+          let anyNotes = false;
+          const collectedWarnings: string[] = [];
+          for (const plan of providerResults) {
+            if (plan.prepResult.warnings.length > 0) {
               anyNotes = true;
               collectedWarnings.push(
-                ...prepResult.warnings.map(
+                ...plan.prepResult.warnings.map(
-                  (warning) => `${getProviderLabel(providerId)}: ${warning}`
+                  (warning) => `${getProviderLabel(plan.providerId)}: ${warning}`
                 )
               );
             }
-            if (prepResult.status === 'failed') {
+            if (plan.prepResult.status === 'failed') {
               anyFailure = true;
-            } else if (prepResult.status === 'notes') {
+            } else if (plan.prepResult.status === 'notes') {
               anyNotes = true;
             }
-            prepareModelResultsCacheRef.current.set(cacheKey, prepResult.modelResultsById);
+            prepareModelResultsCacheRef.current.set(
-            checks = updateProviderCheck(checks, providerId, {
+              plan.cacheKey,
-              status: prepResult.status,
+              plan.prepResult.modelResultsById
-              backendSummary,
+            );
-              details: prepResult.details,
+            checks = updateProviderCheck(checks, plan.providerId, {
+              status: plan.prepResult.status,
+              backendSummary: plan.backendSummary,
+              details: plan.prepResult.details,
             });
-            if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+          }
-              setPrepareChecks(checks);
+          if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-            }
+            setPrepareChecks(checks);
           }
           if (cancelled || prepareRequestSeqRef.current !== requestSeq) return;
           const failureMessage =

src/renderer/components/team/dialogs/LaunchTeamDialog.tsx

@@ -920,82 +920,92 @@ export const LaunchTeamDialog = (props: LaunchTeamDialogProps): React.JSX.Elemen
       selectedMemberProviders
     );
     setPrepareState('loading');
-    setPrepareMessage('Checking selected providers...');
+    setPrepareMessage('Checking selected providers in parallel...');
     setPrepareWarnings([]);
     setPrepareChecks(initialChecks);
 
     void (async () => {
       let checks = initialChecks;
-      let anyFailure = false;
+      const providerPlans = selectedMemberProviders.map((providerId) => {
-      let anyNotes = false;
+        const selectedModelChecks = selectedModelChecksByProvider.get(providerId) ?? [];
-      const collectedWarnings: string[] = [];
+        const backendSummary = runtimeBackendSummaryByProviderRef.current.get(providerId) ?? null;
+        const cacheKey = buildPrepareModelCacheKey(effectiveCwd, providerId, backendSummary);
+        const cachedModelResultsById = prepareModelResultsCacheRef.current.get(cacheKey) ?? {};
+        const cachedSnapshot = getProviderPrepareCachedSnapshot({
+          providerId,
+          selectedModelIds: selectedModelChecks,
+          cachedModelResultsById,
+        });
+        return {
+          providerId,
+          selectedModelChecks,
+          backendSummary,
+          cacheKey,
+          cachedModelResultsById,
+          cachedSnapshot,
+        };
+      });
 
       try {
-        for (const providerId of selectedMemberProviders) {
+        for (const plan of providerPlans) {
-          const selectedModelChecks = selectedModelChecksByProvider.get(providerId) ?? [];
+          checks = updateProviderCheck(checks, plan.providerId, {
-          const backendSummary = runtimeBackendSummaryByProviderRef.current.get(providerId) ?? null;
+            status: plan.selectedModelChecks.length > 0 ? plan.cachedSnapshot.status : 'checking',
-          const cacheKey = buildPrepareModelCacheKey(effectiveCwd, providerId, backendSummary);
+            backendSummary: plan.backendSummary,
-          const cachedModelResultsById = prepareModelResultsCacheRef.current.get(cacheKey) ?? {};
+            details: plan.cachedSnapshot.details,
-          const cachedSnapshot = getProviderPrepareCachedSnapshot({
-            providerId,
-            selectedModelIds: selectedModelChecks,
-            cachedModelResultsById,
           });
-          checks = updateProviderCheck(checks, providerId, {
+        }
-            status: selectedModelChecks.length > 0 ? cachedSnapshot.status : 'checking',
+        if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-            backendSummary,
+          setPrepareChecks(checks);
-            details: cachedSnapshot.details,
+        }
-          });
+        const providerResults = await Promise.all(
-          if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+          providerPlans.map(async (plan) => {
-            setPrepareChecks(checks);
+            const prepResult = await runProviderPrepareDiagnostics({
-            setPrepareMessage(
+              cwd: effectiveCwd,
-              selectedModelChecks.length > 0
+              providerId: plan.providerId,
-                ? `Checking ${getProviderLabel(providerId)} runtime and selected model checks ${cachedSnapshot.completedCount}/${cachedSnapshot.totalCount}...`
+              selectedModelIds: plan.selectedModelChecks,
-                : `Checking ${getProviderLabel(providerId)} runtime...`
+              prepareProvisioning: api.teams.prepareProvisioning,
-            );
+              limitContext,
-          }
+              cachedModelResultsById: plan.cachedModelResultsById,
-
+              onModelProgress: ({ details }) => {
-          const prepResult = await runProviderPrepareDiagnostics({
+                checks = updateProviderCheck(checks, plan.providerId, {
-            cwd: effectiveCwd,
+                  status: 'checking',
-            providerId,
+                  backendSummary: plan.backendSummary,
-            selectedModelIds: selectedModelChecks,
+                  details,
-            prepareProvisioning: api.teams.prepareProvisioning,
+                });
-            limitContext,
+                if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-            cachedModelResultsById,
+                  setPrepareChecks(checks);
-            onModelProgress: ({ details, completedCount, totalCount }) => {
+                }
-              checks = updateProviderCheck(checks, providerId, {
+              },
-                status: 'checking',
+            });
-                backendSummary,
+            return { ...plan, prepResult };
-                details,
+          })
-              });
+        );
-              if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+        let anyFailure = false;
-                setPrepareChecks(checks);
+        let anyNotes = false;
-                setPrepareMessage(
+        const collectedWarnings: string[] = [];
-                  `Checking ${getProviderLabel(providerId)} runtime and selected model checks ${completedCount}/${totalCount}...`
+        for (const plan of providerResults) {
-                );
+          if (plan.prepResult.warnings.length > 0) {
-              }
-            },
-          });
-          if (prepResult.warnings.length > 0) {
             anyNotes = true;
             collectedWarnings.push(
-              ...prepResult.warnings.map((warning) => `${getProviderLabel(providerId)}: ${warning}`)
+              ...plan.prepResult.warnings.map(
+                (warning) => `${getProviderLabel(plan.providerId)}: ${warning}`
+              )
             );
           }
-          if (prepResult.status === 'failed') {
+          if (plan.prepResult.status === 'failed') {
             anyFailure = true;
-          } else if (prepResult.status === 'notes') {
+          } else if (plan.prepResult.status === 'notes') {
             anyNotes = true;
           }
-          prepareModelResultsCacheRef.current.set(cacheKey, prepResult.modelResultsById);
+          prepareModelResultsCacheRef.current.set(plan.cacheKey, plan.prepResult.modelResultsById);
-          checks = updateProviderCheck(checks, providerId, {
+          checks = updateProviderCheck(checks, plan.providerId, {
-            status: prepResult.status,
+            status: plan.prepResult.status,
-            backendSummary,
+            backendSummary: plan.backendSummary,
-            details: prepResult.details,
+            details: plan.prepResult.details,
           });
-          if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
+        }
-            setPrepareChecks(checks);
+        if (!cancelled && prepareRequestSeqRef.current === requestSeq) {
-          }
+          setPrepareChecks(checks);
         }
         if (cancelled || prepareRequestSeqRef.current !== requestSeq) return;
         const failureMessage =

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

@@ -111,7 +111,8 @@ export const MemberCard = ({
     !isRemoved &&
     presenceLabel === 'starting' &&
     spawnLaunchState !== 'failed_to_start' &&
-    !activityTask;
+    !activityTask &&
+    !runtimeSummary;
   const showStartingBadge = !isRemoved && presenceLabel === 'starting' && !activityTask;
   const showRuntimeAdvisoryBadge =
     !isRemoved &&

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

@@ -1,13 +1,8 @@
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import {
+import { resolveMemberRuntimeSummary } from '@renderer/utils/memberRuntimeSummary';
-  formatTeamModelSummary,
-  getTeamEffortLabel,
-  getTeamModelLabel,
-  getTeamProviderLabel,
-} from '@renderer/components/team/dialogs/TeamModelSelector';
 import { buildMemberColorMap } from '@renderer/utils/memberHelpers';
-import { isLeadAgentType, isLeadMember } from '@shared/utils/leadDetection';
+import { isLeadMember } from '@shared/utils/leadDetection';
 
 import { MemberCard } from './MemberCard';
 
@@ -152,6 +147,7 @@ function areMemberSpawnStatusesEquivalent(
       leftEntry.launchState !== rightEntry.launchState ||
       leftEntry.error !== rightEntry.error ||
       leftEntry.livenessSource !== rightEntry.livenessSource ||
+      leftEntry.runtimeModel !== rightEntry.runtimeModel ||
       leftEntry.runtimeAlive !== rightEntry.runtimeAlive
     ) {
       return false;
@@ -242,12 +238,11 @@ export const MemberList = memo(function MemberList({
   const colorMap = useMemo(() => buildMemberColorMap(members), [members]);
 
   const buildRuntimeSummary = useCallback(
-    (member: ResolvedTeamMember): string | undefined => {
+    (
-      const effectiveProvider = member.providerId ?? launchParams?.providerId ?? 'anthropic';
+      member: ResolvedTeamMember,
-      const effectiveModel = member.model?.trim() || launchParams?.model?.trim() || '';
+      spawnEntry: MemberSpawnStatusEntry | undefined
-      const effectiveEffort = member.effort ?? launchParams?.effort;
+    ): string | undefined => {
-
+      return resolveMemberRuntimeSummary(member, launchParams, spawnEntry);
-      return formatTeamModelSummary(effectiveProvider, effectiveModel, effectiveEffort);
     },
     [launchParams]
   );
@@ -293,7 +288,7 @@ export const MemberList = memo(function MemberList({
         reviewTask={isRemoved ? null : reviewTask}
         isAwaitingReply={isRemoved ? false : awaitingReply}
         isRemoved={isRemoved}
-        runtimeSummary={isRemoved ? buildRuntimeSummary(member) : buildRuntimeSummary(member)}
+        runtimeSummary={buildRuntimeSummary(member, isRemoved ? undefined : spawnEntry)}
         spawnStatus={isRemoved ? undefined : spawnEntry?.status}
         spawnError={isRemoved ? undefined : spawnEntry?.error}
         spawnLivenessSource={isRemoved ? undefined : spawnEntry?.livenessSource}

src/renderer/store/slices/teamSlice.ts

@@ -372,6 +372,7 @@ function areMemberSpawnStatusEntriesEqual(
     left.error === right.error &&
     left.livenessSource === right.livenessSource &&
     left.runtimeAlive === right.runtimeAlive &&
+    left.runtimeModel === right.runtimeModel &&
     left.bootstrapConfirmed === right.bootstrapConfirmed &&
     left.hardFailure === right.hardFailure
   );

src/renderer/utils/memberRuntimeSummary.ts

@@ -0,0 +1,41 @@
+import { formatTeamModelSummary } from '@renderer/components/team/dialogs/TeamModelSelector';
+
+import type { TeamLaunchParams } from '@renderer/store/slices/teamSlice';
+import type { MemberSpawnStatusEntry, ResolvedTeamMember, TeamProviderId } from '@shared/types';
+import { inferTeamProviderIdFromModel } from '@shared/utils/teamProvider';
+
+function isMemberLaunchPending(spawnEntry: MemberSpawnStatusEntry | undefined): boolean {
+  if (!spawnEntry) {
+    return false;
+  }
+
+  return (
+    spawnEntry.launchState === 'starting' ||
+    spawnEntry.launchState === 'runtime_pending_bootstrap' ||
+    spawnEntry.status === 'waiting' ||
+    spawnEntry.status === 'spawning'
+  );
+}
+
+export function resolveMemberRuntimeSummary(
+  member: ResolvedTeamMember,
+  launchParams: TeamLaunchParams | undefined,
+  spawnEntry: MemberSpawnStatusEntry | undefined
+): string | undefined {
+  const configuredProvider: TeamProviderId =
+    member.providerId ?? launchParams?.providerId ?? 'anthropic';
+  const configuredModel = member.model?.trim() || launchParams?.model?.trim() || '';
+  const configuredEffort = member.effort ?? launchParams?.effort;
+  const runtimeModel = spawnEntry?.runtimeModel?.trim();
+
+  if (runtimeModel && (isMemberLaunchPending(spawnEntry) || configuredModel.length === 0)) {
+    const runtimeProvider = inferTeamProviderIdFromModel(runtimeModel) ?? configuredProvider;
+    return formatTeamModelSummary(runtimeProvider, runtimeModel, configuredEffort);
+  }
+
+  if (isMemberLaunchPending(spawnEntry)) {
+    return undefined;
+  }
+
+  return formatTeamModelSummary(configuredProvider, configuredModel, configuredEffort);
+}

src/shared/types/team.ts

@@ -908,6 +908,8 @@ export interface MemberSpawnStatusEntry {
   firstSpawnAcceptedAt?: string;
   /** ISO timestamp of the latest confirmed heartbeat/bootstrap message. */
   lastHeartbeatAt?: string;
+  /** Live runtime model observed from the teammate process, when available. */
+  runtimeModel?: string;
   /** ISO timestamp of the last status change. */
   updatedAt: string;
 }

test/main/services/team/TeamProvisioningService.test.ts

@@ -752,7 +752,7 @@ describe('TeamProvisioningService', () => {
     expect(result.teamLaunchState).toBe('partial_failure');
   });
 
-  it('marks a live teammate bootstrap as failed when transcript shows model unavailability', async () => {
+  it('marks an online teammate bootstrap as failed when transcript shows model unavailability', async () => {
     allowConsoleLogs();
     const teamName = 'zz-live-bootstrap-model-unavailable';
     const leadSessionId = 'lead-session';
@@ -816,8 +816,8 @@ describe('TeamProvisioningService', () => {
             launchState: 'runtime_pending_bootstrap',
             error: undefined,
             updatedAt: acceptedAt,
-            runtimeAlive: false,
+            runtimeAlive: true,
-            livenessSource: undefined,
+            livenessSource: 'process',
             bootstrapConfirmed: false,
             hardFailure: false,
             agentToolAccepted: true,
@@ -846,4 +846,77 @@ describe('TeamProvisioningService', () => {
     );
     expect(run.provisioningOutputParts.join('\n')).toContain('requested model is not available');
   });
+
+  it('marks a persisted online teammate bootstrap as failed when transcript shows model unavailability', async () => {
+    allowConsoleLogs();
+    const teamName = 'zz-persisted-live-bootstrap-model-unavailable';
+    const leadSessionId = 'lead-session';
+    const memberSessionId = 'jack-session';
+    const projectPath = '/Users/test/proj';
+    const projectId = '-Users-test-proj';
+    const acceptedAt = new Date(Date.now() - 5_000).toISOString();
+    const errorAt = new Date(Date.now() - 4_000).toISOString();
+
+    writeLaunchConfig(teamName, projectPath, leadSessionId, ['jack']);
+    writeLaunchState(teamName, leadSessionId, {
+      jack: {
+        launchState: 'runtime_pending_bootstrap',
+        agentToolAccepted: true,
+        runtimeAlive: false,
+        bootstrapConfirmed: false,
+        hardFailure: false,
+        hardFailureReason: undefined,
+        firstSpawnAcceptedAt: acceptedAt,
+      },
+    });
+
+    const projectRoot = path.join(tempProjectsBase, projectId);
+    fs.mkdirSync(projectRoot, { recursive: true });
+    fs.writeFileSync(
+      path.join(projectRoot, `${memberSessionId}.jsonl`),
+      [
+        JSON.stringify({
+          timestamp: acceptedAt,
+          teamName,
+          agentName: 'jack',
+          type: 'user',
+          message: {
+            role: 'user',
+            content: `You are bootstrapping into team "${teamName}" as member "jack".`,
+          },
+        }),
+        JSON.stringify({
+          timestamp: errorAt,
+          teamName,
+          agentName: 'jack',
+          type: 'assistant',
+          isApiErrorMessage: true,
+          message: {
+            role: 'assistant',
+            content: [
+              {
+                type: 'text',
+                text: 'API Error: 400 {"detail":"The requested model is not available for your account."}',
+              },
+            ],
+          },
+        }),
+      ].join('\n') + '\n',
+      'utf8'
+    );
+
+    const svc = new TeamProvisioningService();
+    (svc as any).getLiveTeamAgentNames = vi.fn(() => new Set(['jack']));
+
+    const result = await svc.getMemberSpawnStatuses(teamName);
+
+    expect(result.statuses.jack).toMatchObject({
+      status: 'error',
+      launchState: 'failed_to_start',
+      runtimeAlive: true,
+    });
+    expect(result.statuses.jack?.error).toContain('requested model is not available');
+    expect(result.statuses.jack?.hardFailureReason).toContain('requested model is not available');
+    expect(result.teamLaunchState).toBe('partial_failure');
+  });
 });

test/main/services/team/TeamProvisioningServicePrompts.test.ts

@@ -276,6 +276,76 @@ describe('TeamProvisioningService prompt content (solo mode discipline)', () =>
     await svc.cancelProvisioning(runId);
   });
 
+  it('createTeam materializes an explicit Codex default model for teammates before bootstrap spawn', async () => {
+    vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
+    const { child } = createFakeChild();
+    vi.mocked(spawnCli).mockReturnValue(child as any);
+
+    const svc = new TeamProvisioningService();
+    (svc as any).buildProvisioningEnv = vi.fn(async () => ({
+      env: { PATH: '/usr/bin' },
+      authSource: 'codex_runtime',
+      geminiRuntimeAuth: null,
+    }));
+    (svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
+    (svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
+    (svc as any).startFilesystemMonitor = vi.fn();
+    (svc as any).pathExists = vi.fn(async () => false);
+
+    const { runId } = await svc.createTeam(
+      {
+        teamName: 'codex-default-team',
+        cwd: process.cwd(),
+        providerId: 'codex',
+        members: [{ name: 'alice', role: 'developer', providerId: 'codex' }],
+      },
+      () => {}
+    );
+
+    const bootstrapSpec = extractBootstrapSpec();
+    expect(bootstrapSpec.members).toEqual([
+      expect.objectContaining({
+        name: 'alice',
+        provider: 'codex',
+        model: 'gpt-5.4',
+      }),
+    ]);
+
+    await svc.cancelProvisioning(runId);
+  });
+
+  it('createTeam fails fast when a Codex teammate default model cannot be resolved', async () => {
+    vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
+    vi.mocked(spawnCli).mockReset();
+
+    const svc = new TeamProvisioningService();
+    (svc as any).buildProvisioningEnv = vi.fn(async () => ({
+      env: { PATH: '/usr/bin' },
+      authSource: 'codex_runtime',
+      geminiRuntimeAuth: null,
+    }));
+    (svc as any).resolveProviderDefaultModel = vi.fn(async () => null);
+    (svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
+    (svc as any).startFilesystemMonitor = vi.fn();
+    (svc as any).pathExists = vi.fn(async () => false);
+
+    await expect(
+      svc.createTeam(
+        {
+          teamName: 'codex-default-missing',
+          cwd: process.cwd(),
+          providerId: 'codex',
+          members: [{ name: 'alice', providerId: 'codex' }],
+        },
+        () => {}
+      )
+    ).rejects.toThrow(
+      'Could not resolve the runtime default model for Codex teammates. Select an explicit model and retry.'
+    );
+
+    expect(spawnCli).not.toHaveBeenCalled();
+  });
+
   it('add-member spawn prompt tells teammates to keep review on the same task', () => {
     const prompt = buildAddMemberSpawnMessage('my-team', 'My Team', 'team-lead', {
       name: 'alice',
@@ -429,4 +499,67 @@ describe('TeamProvisioningService prompt content (solo mode discipline)', () =>
 
     await svc.cancelProvisioning(runId);
   });
+
+  it('launchTeam materializes an explicit Codex default model for launch teammates before bootstrap spawn', async () => {
+    const teamName = 'codex-default-launch';
+    const teamDir = path.join(tempTeamsBase, teamName);
+    fs.mkdirSync(teamDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(teamDir, 'config.json'),
+      JSON.stringify({
+        name: teamName,
+        members: [
+          { name: 'team-lead', agentType: 'team-lead', providerId: 'codex' },
+          { name: 'alice', agentType: 'teammate', role: 'developer', providerId: 'codex' },
+        ],
+      }),
+      'utf8'
+    );
+
+    vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
+    const { child } = createFakeChild();
+    vi.mocked(spawnCli).mockReturnValue(child as any);
+
+    const svc = new TeamProvisioningService();
+    (svc as any).buildProvisioningEnv = vi.fn(async () => ({
+      env: { PATH: '/usr/bin' },
+      authSource: 'codex_runtime',
+      geminiRuntimeAuth: null,
+    }));
+    (svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
+    (svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
+    (svc as any).updateConfigProjectPath = vi.fn(async () => {});
+    (svc as any).restorePrelaunchConfig = vi.fn(async () => {});
+    (svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
+    (svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
+    (svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
+      members: [{ name: 'alice', role: 'developer', providerId: 'codex' }],
+      source: 'config-fallback',
+      warning: undefined,
+    }));
+    (svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
+    (svc as any).pathExists = vi.fn(async () => false);
+    (svc as any).startFilesystemMonitor = vi.fn();
+
+    const { runId } = await svc.launchTeam(
+      {
+        teamName,
+        cwd: process.cwd(),
+        providerId: 'codex',
+        clearContext: true,
+      } as any,
+      () => {}
+    );
+
+    const bootstrapSpec = extractBootstrapSpec();
+    expect(bootstrapSpec.members).toEqual([
+      expect.objectContaining({
+        name: 'alice',
+        provider: 'codex',
+        model: 'gpt-5.4',
+      }),
+    ]);
+
+    await svc.cancelProvisioning(runId);
+  });
 });

test/renderer/utils/memberRuntimeSummary.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveMemberRuntimeSummary } from '@renderer/utils/memberRuntimeSummary';
+
+import type { MemberSpawnStatusEntry, ResolvedTeamMember } from '@shared/types';
+
+function createMember(overrides: Partial<ResolvedTeamMember> = {}): ResolvedTeamMember {
+  return {
+    name: 'alice',
+    agentId: 'alice@test-team',
+    agentType: 'general-purpose',
+    role: 'developer',
+    providerId: 'codex',
+    effort: 'medium',
+    status: 'idle',
+    currentTaskId: null,
+    taskCount: 0,
+    lastActiveAt: null,
+    messageCount: 0,
+    color: 'blue',
+    ...overrides,
+  };
+}
+
+function createSpawnEntry(overrides: Partial<MemberSpawnStatusEntry> = {}): MemberSpawnStatusEntry {
+  return {
+    status: 'waiting',
+    launchState: 'starting',
+    runtimeAlive: false,
+    bootstrapConfirmed: false,
+    hardFailure: false,
+    agentToolAccepted: true,
+    updatedAt: '2026-04-16T17:10:48.646Z',
+    ...overrides,
+  };
+}
+
+describe('resolveMemberRuntimeSummary', () => {
+  it('shows the live runtime model for loading members when available', () => {
+    const member = createMember();
+    const spawnEntry = createSpawnEntry({ runtimeModel: 'claude-opus-4-6', runtimeAlive: true });
+
+    expect(resolveMemberRuntimeSummary(member, undefined, spawnEntry)).toBe(
+      'Anthropic · Opus 4.6 · Medium'
+    );
+  });
+
+  it('keeps the loading skeleton when a pending member has no live runtime model yet', () => {
+    const member = createMember();
+    const spawnEntry = createSpawnEntry();
+
+    expect(resolveMemberRuntimeSummary(member, undefined, spawnEntry)).toBeUndefined();
+  });
+
+  it('uses the live runtime model as a fallback when config has no explicit model', () => {
+    const member = createMember({ providerId: 'codex', model: undefined });
+    const spawnEntry = createSpawnEntry({
+      status: 'online',
+      launchState: 'confirmed_alive',
+      runtimeAlive: true,
+      runtimeModel: 'gpt-5.4-mini',
+    });
+
+    expect(resolveMemberRuntimeSummary(member, undefined, spawnEntry)).toBe('5.4 Mini · Medium');
+  });
+});