@yancyyu/openhermit 1.5.8

package/src/renderer/components/team/messages/OpenCodeDeliveryWarning.tsx

@@ -0,0 +1,151 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import {
+  formatOpenCodeRuntimeDeliveryDebugDetails,
+  type OpenCodeRuntimeDeliveryDebugDetails,
+} from '@renderer/utils/openCodeRuntimeDeliveryDiagnostics';
+import { AlertCircle } from 'lucide-react';
+
+import type { JSX } from 'react';
+
+interface OpenCodeDeliveryWarningProps {
+  warning: string | null;
+  debugDetails?: OpenCodeRuntimeDeliveryDebugDetails | null;
+  pendingDelayMs?: number;
+}
+
+export const OpenCodeDeliveryWarning = ({
+  warning,
+  debugDetails,
+  pendingDelayMs = 10_000,
+}: OpenCodeDeliveryWarningProps): JSX.Element | null => {
+  const detailsKey = `${warning ?? ''}:${debugDetails?.messageId ?? ''}`;
+  const delayPendingWarning =
+    debugDetails?.responsePending === true && debugDetails.delivered !== false;
+  const [expandedKey, setExpandedKey] = useState<string | null>(null);
+  const [copiedKey, setCopiedKey] = useState<string | null>(null);
+  const [pendingVisibleKey, setPendingVisibleKey] = useState<string | null>(() =>
+    delayPendingWarning ? null : detailsKey
+  );
+  const mountedRef = useRef(true);
+  const copiedResetTimerRef = useRef<number | null>(null);
+  const pendingTimerRef = useRef<number | null>(null);
+  const expanded = expandedKey === detailsKey;
+  const copied = copiedKey === detailsKey;
+  const copyText = useMemo(
+    () => (debugDetails ? formatOpenCodeRuntimeDeliveryDebugDetails(debugDetails) : ''),
+    [debugDetails]
+  );
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      if (copiedResetTimerRef.current !== null) {
+        window.clearTimeout(copiedResetTimerRef.current);
+      }
+      if (pendingTimerRef.current !== null) {
+        window.clearTimeout(pendingTimerRef.current);
+      }
+    };
+  }, []);
+
+  useEffect(() => {
+    if (pendingTimerRef.current !== null) {
+      window.clearTimeout(pendingTimerRef.current);
+      pendingTimerRef.current = null;
+    }
+    if (!warning) {
+      setPendingVisibleKey(null);
+      return;
+    }
+    if (!delayPendingWarning || pendingDelayMs <= 0) {
+      setPendingVisibleKey(detailsKey);
+      return;
+    }
+    setPendingVisibleKey(null);
+    pendingTimerRef.current = window.setTimeout(() => {
+      pendingTimerRef.current = null;
+      if (mountedRef.current) {
+        setPendingVisibleKey(detailsKey);
+      }
+    }, pendingDelayMs);
+  }, [delayPendingWarning, detailsKey, pendingDelayMs, warning]);
+
+  if (!warning) return null;
+  if (delayPendingWarning && pendingVisibleKey !== detailsKey) return null;
+
+  const handleCopy = async (): Promise<void> => {
+    if (!copyText || !navigator.clipboard?.writeText) return;
+    try {
+      await navigator.clipboard.writeText(copyText);
+    } catch {
+      return;
+    }
+    if (!mountedRef.current) return;
+    setCopiedKey(detailsKey);
+    if (copiedResetTimerRef.current !== null) {
+      window.clearTimeout(copiedResetTimerRef.current);
+    }
+    copiedResetTimerRef.current = window.setTimeout(() => {
+      copiedResetTimerRef.current = null;
+      if (mountedRef.current) {
+        setCopiedKey(null);
+      }
+    }, 1500);
+  };
+
+  return (
+    <span className="relative inline-flex flex-col items-start gap-1">
+      <span className="inline-flex items-center gap-1 rounded bg-amber-500/10 px-1.5 py-0.5 text-[10px] text-amber-300">
+        <AlertCircle size={10} className="shrink-0" />
+        <span>{warning}</span>
+        {debugDetails ? (
+          <button
+            type="button"
+            className="ml-1 rounded px-1 text-[10px] font-medium text-amber-200 underline decoration-amber-300/50 underline-offset-2 hover:text-amber-100"
+            aria-expanded={expanded}
+            onClick={() =>
+              setExpandedKey((currentKey) => (currentKey === detailsKey ? null : detailsKey))
+            }
+          >
+            Details
+          </button>
+        ) : null}
+      </span>
+      {expanded && debugDetails ? (
+        <span className="z-10 block max-w-[min(34rem,calc(100vw-3rem))] rounded border border-amber-500/20 bg-[var(--color-bg-primary)] p-2 text-left text-[10px] text-[var(--color-text-secondary)] shadow-xl">
+          <span className="grid grid-cols-[auto_1fr] gap-x-2 gap-y-1">
+            <span className="text-[var(--color-text-muted)]">messageId</span>
+            <span className="break-all">{debugDetails.messageId}</span>
+            <span className="text-[var(--color-text-muted)]">providerId</span>
+            <span>{debugDetails.providerId}</span>
+            <span className="text-[var(--color-text-muted)]">delivered</span>
+            <span>{String(debugDetails.delivered)}</span>
+            <span className="text-[var(--color-text-muted)]">responsePending</span>
+            <span>{String(debugDetails.responsePending)}</span>
+            <span className="text-[var(--color-text-muted)]">responseState</span>
+            <span>{debugDetails.responseState ?? 'null'}</span>
+            <span className="text-[var(--color-text-muted)]">ledgerStatus</span>
+            <span>{debugDetails.ledgerStatus ?? 'null'}</span>
+            <span className="text-[var(--color-text-muted)]">acceptanceUnknown</span>
+            <span>{String(debugDetails.acceptanceUnknown)}</span>
+            <span className="text-[var(--color-text-muted)]">reason</span>
+            <span>{debugDetails.reason ?? 'null'}</span>
+            <span className="text-[var(--color-text-muted)]">diagnostics</span>
+            <span>
+              {debugDetails.diagnostics.length ? debugDetails.diagnostics.join('; ') : '[]'}
+            </span>
+          </span>
+          <button
+            type="button"
+            className="mt-2 rounded border border-amber-500/20 px-2 py-1 text-[10px] text-amber-200 hover:border-amber-400/40 hover:text-amber-100"
+            onClick={() => void handleCopy()}
+          >
+            {copied ? 'Copied' : 'Copy debug details'}
+          </button>
+        </span>
+      ) : null}
+    </span>
+  );
+};

package/src/renderer/components/team/messages/StatusBlock.tsx

@@ -0,0 +1,126 @@
+import { useEffect, useMemo, useState } from 'react';
+
+import { computePendingCrossTeamReplies } from '@renderer/utils/crossTeamPendingReplies';
+import { ChevronRight } from 'lucide-react';
+
+import { ActiveTasksBlock } from '../activity/ActiveTasksBlock';
+import { PendingRepliesBlock } from '../activity/PendingRepliesBlock';
+
+import type { InboxMessage, ResolvedTeamMember, TeamTaskWithKanban } from '@shared/types';
+
+interface StatusBlockProps {
+  members: ResolvedTeamMember[];
+  tasks: TeamTaskWithKanban[];
+  messages: InboxMessage[];
+  pendingRepliesByMember: Record<string, number>;
+  /** Where the Messages panel is rendered — 'sidebar' hides "In progress" (already visible in MemberList). */
+  position?: 'sidebar' | 'inline';
+  /** Overlay keeps the toggle hovering over the previous section, flow keeps it in normal layout. */
+  layout?: 'overlay' | 'flow';
+  onMemberClick?: (member: ResolvedTeamMember) => void;
+  onTaskClick?: (task: TeamTaskWithKanban) => void;
+}
+
+/**
+ * Self-contained status section that owns its own 1-second timer for
+ * cross-team pending reply TTL tracking. Isolates the timer-driven
+ * re-renders from the rest of MessagesPanel / ActivityTimeline so that
+ * text selection in messages is not disrupted.
+ */
+export const StatusBlock = ({
+  members,
+  tasks,
+  messages,
+  pendingRepliesByMember,
+  position,
+  layout = 'overlay',
+  onMemberClick,
+  onTaskClick,
+}: StatusBlockProps): React.JSX.Element | null => {
+  const [collapsed, setCollapsed] = useState(false);
+  const [nowMs, setNowMs] = useState(() => Date.now());
+
+  const pendingCrossTeamReplies = useMemo(
+    () => computePendingCrossTeamReplies(messages, nowMs),
+    [messages, nowMs]
+  );
+  const hasPendingReplies = useMemo(() => {
+    const hasMemberPendingReplies = Object.keys(pendingRepliesByMember).some((name) =>
+      members.some((m) => m.name === name)
+    );
+    return hasMemberPendingReplies || pendingCrossTeamReplies.length > 0;
+  }, [members, pendingRepliesByMember, pendingCrossTeamReplies.length]);
+  const hasActiveTasks = useMemo(() => {
+    const tMap = new Map(tasks.map((t) => [t.id, t]));
+    return members.some((m) => {
+      if (!m.currentTaskId) return false;
+      const task = tMap.get(m.currentTaskId);
+      if (task && (task.reviewState === 'approved' || task.status === 'completed')) return false;
+      return true;
+    });
+  }, [members, tasks]);
+
+  /** Whether the Status block has any visible items. */
+  const hasItems = useMemo(() => {
+    if (hasPendingReplies) return true;
+    return hasActiveTasks;
+  }, [hasActiveTasks, hasPendingReplies]);
+
+  // Only run the 1-second timer when the block actually has content to show.
+  useEffect(() => {
+    if (!hasItems) return;
+    const id = window.setInterval(() => setNowMs(Date.now()), 1000);
+    return () => window.clearInterval(id);
+  }, [hasItems]);
+
+  if (!hasItems) return null;
+
+  const toggleButton = (
+    <button
+      type="button"
+      className="flex items-center gap-1 text-[10px] font-medium uppercase tracking-wide text-[var(--color-text-muted)] transition-colors hover:text-[var(--color-text-secondary)]"
+      onClick={() => setCollapsed((prev) => !prev)}
+      aria-label={collapsed ? 'Expand status' : 'Collapse status'}
+    >
+      <ChevronRight
+        size={12}
+        className={`shrink-0 transition-transform duration-150 ${collapsed ? '' : 'rotate-90'}`}
+      />
+      Status
+    </button>
+  );
+  const flowInlineToggle = layout === 'flow' && !collapsed ? toggleButton : null;
+
+  return (
+    <>
+      {layout === 'overlay' ? (
+        <div className="relative h-0">
+          <div className="absolute -top-[19px] right-0 z-10">{toggleButton}</div>
+        </div>
+      ) : collapsed ? (
+        <div className="mb-2 flex justify-end">{toggleButton}</div>
+      ) : null}
+      {!collapsed && (
+        <div className={layout === 'overlay' ? 'mt-5' : ''}>
+          {hasPendingReplies ? (
+            <PendingRepliesBlock
+              members={members}
+              pendingRepliesByMember={pendingRepliesByMember}
+              pendingCrossTeamReplies={pendingCrossTeamReplies}
+              headerRight={flowInlineToggle}
+              onMemberClick={onMemberClick}
+            />
+          ) : null}
+          <ActiveTasksBlock
+            members={members}
+            tasks={tasks}
+            defaultCollapsed={position === 'sidebar'}
+            headerRight={!hasPendingReplies ? flowInlineToggle : undefined}
+            onMemberClick={onMemberClick}
+            onTaskClick={onTaskClick}
+          />
+        </div>
+      )}
+    </>
+  );
+};

package/src/renderer/components/team/provisioningSteps.ts

@@ -0,0 +1,363 @@
+import { isLeadMember } from '@shared/utils/leadDetection';
+
+import type {
+  MemberSpawnStatusEntry,
+  MemberSpawnStatusesSnapshot,
+  TeamProvisioningProgress,
+} from '@shared/types';
+
+interface LaunchJoinMemberLike {
+  name: string;
+  removedAt?: number;
+}
+
+/** Display steps for the provisioning stepper (0-indexed). */
+export const DISPLAY_STEPS = [
+  { key: 'starting', label: '启动中' },
+  { key: 'configuring', label: '团队设置' },
+  { key: 'assembling', label: '成员加入' },
+  { key: 'finalizing', label: '收尾确认' },
+] as const;
+
+export const DISPLAY_COMPLETE_STEP_INDEX = DISPLAY_STEPS.length;
+
+export interface LaunchJoinMilestones {
+  expectedTeammateCount: number;
+  heartbeatConfirmedCount: number;
+  processOnlyAliveCount: number;
+  pendingSpawnCount: number;
+  failedSpawnCount: number;
+  skippedSpawnCount: number;
+}
+
+type DisplayStepMilestones = LaunchJoinMilestones & {
+  progress: Pick<TeamProvisioningProgress, 'configReady' | 'pid' | 'state'>;
+};
+
+type MemberSpawnStatusCollection =
+  | Record<string, MemberSpawnStatusEntry>
+  | Map<string, MemberSpawnStatusEntry>
+  | undefined;
+
+function getSpawnEntry(
+  memberSpawnStatuses: MemberSpawnStatusCollection,
+  memberName: string
+): MemberSpawnStatusEntry | undefined {
+  if (!memberSpawnStatuses) {
+    return undefined;
+  }
+  if (memberSpawnStatuses instanceof Map) {
+    return memberSpawnStatuses.get(memberName);
+  }
+  return memberSpawnStatuses[memberName];
+}
+
+function parseStatusUpdatedAtMs(value: string | undefined): number | null {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function isFailedSpawnEntry(entry: MemberSpawnStatusEntry | undefined): boolean {
+  return entry?.launchState === 'failed_to_start' || entry?.status === 'error';
+}
+
+function isStrongRuntimeProcessSpawnEntry(entry: MemberSpawnStatusEntry): boolean {
+  return entry.runtimeAlive === true && entry.livenessKind === 'runtime_process';
+}
+
+function shouldPreferSnapshotEntryOverLive(
+  liveEntry: MemberSpawnStatusEntry | undefined,
+  snapshotEntry: MemberSpawnStatusEntry | undefined,
+  snapshotUpdatedAt: string | undefined
+): boolean {
+  if (!liveEntry || !snapshotEntry) {
+    return false;
+  }
+  if (!isFailedSpawnEntry(liveEntry) || isFailedSpawnEntry(snapshotEntry)) {
+    return false;
+  }
+
+  const liveUpdatedAtMs = parseStatusUpdatedAtMs(liveEntry.updatedAt);
+  const snapshotUpdatedAtMs =
+    parseStatusUpdatedAtMs(snapshotEntry.updatedAt) ?? parseStatusUpdatedAtMs(snapshotUpdatedAt);
+  return (
+    snapshotUpdatedAtMs != null &&
+    (liveUpdatedAtMs == null || snapshotUpdatedAtMs >= liveUpdatedAtMs)
+  );
+}
+
+function summarizeLiveLaunchJoinMilestones(params: {
+  teammateNames: readonly string[];
+  memberSpawnStatuses?: MemberSpawnStatusCollection;
+  memberSpawnSnapshotStatuses?: MemberSpawnStatusesSnapshot['statuses'];
+  memberSpawnSnapshotUpdatedAt?: string;
+}): Omit<LaunchJoinMilestones, 'expectedTeammateCount'> & {
+  observedTeammateCount: number;
+} {
+  const {
+    teammateNames,
+    memberSpawnStatuses,
+    memberSpawnSnapshotStatuses,
+    memberSpawnSnapshotUpdatedAt,
+  } = params;
+  let heartbeatConfirmedCount = 0;
+  let processOnlyAliveCount = 0;
+  let pendingSpawnCount = 0;
+  let failedSpawnCount = 0;
+  let skippedSpawnCount = 0;
+  let observedTeammateCount = 0;
+
+  for (const memberName of teammateNames) {
+    const liveEntry = getSpawnEntry(memberSpawnStatuses, memberName);
+    const snapshotEntry = memberSpawnSnapshotStatuses?.[memberName];
+    const entry = shouldPreferSnapshotEntryOverLive(
+      liveEntry,
+      snapshotEntry,
+      memberSpawnSnapshotUpdatedAt
+    )
+      ? snapshotEntry
+      : liveEntry;
+    if (!entry) {
+      pendingSpawnCount += 1;
+      continue;
+    }
+    observedTeammateCount += 1;
+    if (entry.launchState === 'failed_to_start') {
+      failedSpawnCount += 1;
+      continue;
+    }
+    if (entry.launchState === 'skipped_for_launch' || entry.skippedForLaunch === true) {
+      skippedSpawnCount += 1;
+      continue;
+    }
+    if (entry.launchState === 'confirmed_alive') {
+      heartbeatConfirmedCount += 1;
+      continue;
+    }
+    if (entry.launchState === 'runtime_pending_permission') {
+      pendingSpawnCount += 1;
+      continue;
+    }
+    if (entry.launchState === 'runtime_pending_bootstrap') {
+      if (isStrongRuntimeProcessSpawnEntry(entry)) {
+        processOnlyAliveCount += 1;
+      } else {
+        pendingSpawnCount += 1;
+      }
+      continue;
+    }
+    if (entry.launchState === 'starting') {
+      pendingSpawnCount += 1;
+    }
+  }
+
+  return {
+    heartbeatConfirmedCount,
+    processOnlyAliveCount,
+    pendingSpawnCount,
+    failedSpawnCount,
+    skippedSpawnCount,
+    observedTeammateCount,
+  };
+}
+
+export function getLaunchJoinMilestonesFromMembers({
+  members,
+  memberSpawnStatuses,
+  memberSpawnSnapshot,
+}: {
+  members: readonly LaunchJoinMemberLike[];
+  memberSpawnStatuses?: MemberSpawnStatusCollection;
+  memberSpawnSnapshot?: Pick<
+    MemberSpawnStatusesSnapshot,
+    'expectedMembers' | 'summary' | 'updatedAt'
+  > & {
+    statuses?: MemberSpawnStatusesSnapshot['statuses'];
+  };
+}): LaunchJoinMilestones {
+  const removedTeammateNameSet = new Set(
+    members
+      .filter((member) => member.removedAt && !isLeadMember(member))
+      .map((member) => member.name)
+  );
+  const teammates = members.filter((member) => !member.removedAt && !isLeadMember(member));
+  const activeTeammateNames = teammates.map((member) => member.name);
+  const snapshotExpectedNames = memberSpawnSnapshot?.expectedMembers ?? [];
+  const snapshotStatusNames = Object.keys(memberSpawnSnapshot?.statuses ?? {});
+  const teammateNames =
+    snapshotExpectedNames.length > 0 || snapshotStatusNames.length > 0
+      ? Array.from(
+          new Set([...snapshotExpectedNames, ...snapshotStatusNames, ...activeTeammateNames])
+        ).filter(
+          (memberName) =>
+            memberName.trim().length > 0 &&
+            !isLeadMember({ name: memberName }) &&
+            !removedTeammateNameSet.has(memberName)
+        )
+      : activeTeammateNames;
+  const expectedTeammateCount = teammateNames.length;
+  const snapshotSummary = memberSpawnSnapshot?.summary;
+  const liveSummary = summarizeLiveLaunchJoinMilestones({
+    teammateNames,
+    memberSpawnStatuses,
+    memberSpawnSnapshotStatuses: memberSpawnSnapshot?.statuses,
+    memberSpawnSnapshotUpdatedAt: memberSpawnSnapshot?.updatedAt,
+  });
+
+  if (snapshotSummary) {
+    const snapshotProcessOnlyAliveCount = snapshotSummary.runtimeProcessPendingCount ?? 0;
+    const snapshotMilestones = {
+      expectedTeammateCount,
+      heartbeatConfirmedCount: snapshotSummary.confirmedCount,
+      processOnlyAliveCount: snapshotProcessOnlyAliveCount,
+      pendingSpawnCount: Math.max(0, snapshotSummary.pendingCount - snapshotProcessOnlyAliveCount),
+      failedSpawnCount: snapshotSummary.failedCount,
+      skippedSpawnCount: snapshotSummary.skippedCount ?? 0,
+    };
+    const snapshotAllExpectedConfirmed =
+      expectedTeammateCount > 0 &&
+      snapshotMilestones.failedSpawnCount === 0 &&
+      snapshotMilestones.skippedSpawnCount === 0 &&
+      snapshotMilestones.pendingSpawnCount === 0 &&
+      snapshotMilestones.heartbeatConfirmedCount >= expectedTeammateCount;
+
+    if (snapshotAllExpectedConfirmed) {
+      return snapshotMilestones;
+    }
+
+    const snapshotAccountedFor =
+      snapshotMilestones.heartbeatConfirmedCount +
+      snapshotMilestones.processOnlyAliveCount +
+      snapshotMilestones.failedSpawnCount +
+      snapshotMilestones.skippedSpawnCount;
+    const liveAccountedFor =
+      liveSummary.heartbeatConfirmedCount +
+      liveSummary.processOnlyAliveCount +
+      liveSummary.failedSpawnCount +
+      liveSummary.skippedSpawnCount;
+
+    const liveSummaryIsMoreAdvanced =
+      liveSummary.failedSpawnCount > snapshotMilestones.failedSpawnCount ||
+      liveSummary.skippedSpawnCount > snapshotMilestones.skippedSpawnCount ||
+      liveSummary.heartbeatConfirmedCount > snapshotMilestones.heartbeatConfirmedCount ||
+      liveSummary.processOnlyAliveCount > snapshotMilestones.processOnlyAliveCount ||
+      (snapshotMilestones.failedSpawnCount === 0 &&
+        liveSummary.observedTeammateCount > 0 &&
+        liveSummary.pendingSpawnCount > snapshotMilestones.pendingSpawnCount) ||
+      liveAccountedFor > snapshotAccountedFor;
+
+    return liveSummaryIsMoreAdvanced
+      ? {
+          expectedTeammateCount,
+          ...liveSummary,
+        }
+      : snapshotMilestones;
+  }
+
+  return {
+    expectedTeammateCount,
+    ...liveSummary,
+  };
+}
+
+export function getLaunchJoinState({
+  expectedTeammateCount,
+  heartbeatConfirmedCount,
+  processOnlyAliveCount,
+  pendingSpawnCount,
+  failedSpawnCount,
+  skippedSpawnCount,
+}: LaunchJoinMilestones): {
+  allTeammatesConfirmedAlive: boolean;
+  hasMembersStillJoining: boolean;
+  remainingJoinCount: number;
+} {
+  const aliveCount = heartbeatConfirmedCount + processOnlyAliveCount;
+  const allTeammatesConfirmedAlive =
+    expectedTeammateCount > 0 &&
+    failedSpawnCount === 0 &&
+    skippedSpawnCount === 0 &&
+    aliveCount >= expectedTeammateCount;
+  const remainingJoinCount =
+    expectedTeammateCount > 0 && failedSpawnCount === 0 && skippedSpawnCount === 0
+      ? Math.max(0, expectedTeammateCount - aliveCount)
+      : 0;
+  const hasMembersStillJoining =
+    expectedTeammateCount > 0 &&
+    failedSpawnCount === 0 &&
+    skippedSpawnCount === 0 &&
+    remainingJoinCount > 0 &&
+    pendingSpawnCount > 0;
+
+  return {
+    allTeammatesConfirmedAlive,
+    hasMembersStillJoining,
+    remainingJoinCount,
+  };
+}
+
+/**
+ * Maps launch progress to the visible stepper milestone.
+ *
+ * The renderer intentionally derives these steps from observable launch evidence
+ * instead of raw backend phase names. The backend can move through
+ * validating/spawning/configuring very quickly, but the UI milestones should
+ * reflect what the user can actually observe:
+ * - Starting: waiting for a real CLI/runtime process
+ * - Team setup: process exists, but config is not readable yet
+ * - Members joining: config is ready, but teammate runtimes are still attaching
+ * - Finalizing: teammate runtimes are attached and bootstrap/contact is settling
+ *
+ * Returns DISPLAY_COMPLETE_STEP_INDEX for 'ready', -1 for failed/cancelled.
+ */
+export function getDisplayStepIndex({
+  progress,
+  expectedTeammateCount,
+  heartbeatConfirmedCount,
+  processOnlyAliveCount,
+  pendingSpawnCount,
+  failedSpawnCount,
+  skippedSpawnCount,
+}: DisplayStepMilestones): number {
+  switch (progress.state) {
+    case 'ready':
+      return DISPLAY_COMPLETE_STEP_INDEX;
+    case 'failed':
+    case 'disconnected':
+    case 'cancelled':
+      return -1;
+    default:
+      break;
+  }
+
+  if (!progress.pid) {
+    return 0;
+  }
+
+  if (progress.configReady !== true) {
+    return 1;
+  }
+
+  if (expectedTeammateCount <= 0) {
+    return 3;
+  }
+
+  if (failedSpawnCount > 0) {
+    return 2;
+  }
+  if (skippedSpawnCount > 0 && skippedSpawnCount < expectedTeammateCount) {
+    return 2;
+  }
+
+  const accountedForTeammates =
+    heartbeatConfirmedCount + processOnlyAliveCount + failedSpawnCount + skippedSpawnCount;
+
+  if (pendingSpawnCount > 0 || accountedForTeammates < expectedTeammateCount) {
+    return 2;
+  }
+
+  return 3;
+}