diff --git a/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx b/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx
index dd80e95d78..26176ba410 100644
--- a/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx
+++ b/client/src/components/Chat/Messages/Content/CodeAnalyze.tsx
@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react';
 import { useRecoilValue } from 'recoil';
 import { Terminal } from 'lucide-react';
+import type { ToolCallPhase } from '~/utils/toolCallPhase';
 import { useProgress, useLocalize } from '~/hooks';
 import ProgressText from './ProgressText';
 import MarkdownLite from './MarkdownLite';
@@ -46,14 +47,22 @@ export default function CodeAnalyze({
     return acc;
   }, '');
 
+  /**
+   * The legacy assistants-endpoint card: it never receives run-step metadata,
+   * so it genuinely has only these two states and maps them directly rather
+   * than through `resolveToolCallPhase`, which needs signals this card has no
+   * access to. The announcement and the icon below read this same value.
+   */
+  const phase: ToolCallPhase = progress < 1 ? 'running' : 'completed';
+
   return (
     <>
       <span className="sr-only" aria-live="polite" aria-atomic="true">
-        {progress < 1 ? localize('com_ui_analyzing') : localize('com_ui_analyzing_finished')}
+        {phase === 'running' ? localize('com_ui_analyzing') : localize('com_ui_analyzing_finished')}
       </span>
       <div className="my-1 flex items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={handleToggleCode}
           inProgressText={localize('com_ui_analyzing')}
           finishedText={localize('com_ui_analyzing_finished')}
@@ -61,7 +70,10 @@ export default function CodeAnalyze({
           isExpanded={showCode}
           icon={
             <Terminal
-              className={cn('size-4 shrink-0 text-text-secondary', progress < 1 && 'animate-pulse')}
+              className={cn(
+                'size-4 shrink-0 text-text-secondary',
+                phase === 'running' && 'animate-pulse',
+              )}
               aria-hidden="true"
             />
           }
diff --git a/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx b/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx
index f839e76bbf..570e370370 100644
--- a/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/BashCall.tsx
@@ -49,20 +49,15 @@ export default function BashCall({
   const isWritingCommand = !command || !areToolCallArgsComplete(args);
   const sandboxStarting = useRecoilValue(sandboxStartingByToolCallId(toolCallId ?? ''));
 
-  const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =
-    useToolCallState(initialProgress, isSubmitting, output, !!command, onExpand, runStepStatus);
-
-  const highlighted = useLazyHighlight(command || undefined, 'bash');
-  const { ref: commandPaneRef, onScroll: onCommandPaneScroll } = useFollowScroll<HTMLDivElement>(
-    highlighted ?? command,
-    progress < 1 && !cancelled,
-    showCode,
-  );
   const outputHasError = useMemo(() => ERROR_PATTERNS.test(output), [output]);
   /** A backgrounded call's persisted output stays the dispatch handle until
    *  the detached run settles and patches it; render a background state
    *  instead of the handle JSON. Completion arrives live as the status marker
-   *  attachment (also covers stdout-only runs) or as harvested files. */
+   *  attachment (also covers stdout-only runs) or as harvested files.
+   *
+   *  Resolved before the phase, which folds `backgroundFailed` in: the
+   *  detached task's outcome is this card's outcome, and the dispatch step's
+   *  own output cannot express it. */
   const backgroundHandle = useMemo(() => parseBackgroundHandle(output), [output]);
   const { fileAttachments, backgroundStatus } = useMemo(
     () => splitBackgroundAttachments(attachments, toolCallId),
@@ -77,6 +72,23 @@ export default function BashCall({
       )
     : null;
 
+  const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: !!command,
+    onExpand,
+    runStepStatus,
+    extraError: backgroundFailed,
+  });
+
+  const highlighted = useLazyHighlight(command || undefined, 'bash');
+  const { ref: commandPaneRef, onScroll: onCommandPaneScroll } = useFollowScroll<HTMLDivElement>(
+    highlighted ?? command,
+    phase === 'running',
+    showCode,
+  );
+
   const [isCopied, setIsCopied] = useState(false);
   const timerRef = useRef<ReturnType<typeof setTimeout>>();
   useEffect(() => () => clearTimeout(timerRef.current), []);
@@ -110,11 +122,11 @@ export default function BashCall({
     <>
       <div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={toggleCode}
           inProgressText={inProgressText}
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (backgroundFinishedText ?? intent ?? localize('com_ui_command_finished'))
           }
@@ -127,23 +139,17 @@ export default function BashCall({
           durationMs={
             backgroundHandle == null && backgrounded !== true ? runStepDurationMs : undefined
           }
-          errorSuffix={
-            (hasError && !cancelled) || backgroundFailed
-              ? localize('com_ui_tool_failed')
-              : undefined
-          }
           icon={
             <LangIcon
               lang="bash"
               className={cn(
                 'size-4 shrink-0 text-text-secondary',
-                progress < 1 && !cancelled && !hasError && 'animate-pulse',
+                phase === 'running' && 'animate-pulse',
               )}
             />
           }
           hasInput={!!command || hasOutput}
           isExpanded={showCode}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
diff --git a/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx b/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx
index 1ce61a3442..d2d776384a 100644
--- a/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/ExecuteCode.tsx
@@ -87,20 +87,15 @@ export default function ExecuteCode({
   const intent = useToolCallIntent(args);
   const sandboxStarting = useRecoilValue(sandboxStartingByToolCallId(toolCallId ?? ''));
 
-  const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =
-    useToolCallState(initialProgress, isSubmitting, output, !!code, onExpand, runStepStatus);
-
-  const highlighted = useLazyHighlight(code, lang);
-  const { ref: codePaneRef, onScroll: onCodePaneScroll } = useFollowScroll<HTMLPreElement>(
-    highlighted ?? code ?? '',
-    progress < 1 && !cancelled,
-    showCode,
-  );
   const outputHasError = useMemo(() => ERROR_PATTERNS.test(output), [output]);
   /** A backgrounded call's persisted output stays the dispatch handle until
    *  the detached run settles and patches it; render a background state
    *  instead of the handle JSON. Completion arrives live as the status marker
-   *  attachment (also covers stdout-only runs) or as harvested files. */
+   *  attachment (also covers stdout-only runs) or as harvested files.
+   *
+   *  Resolved before the phase, which folds `backgroundFailed` in: the
+   *  detached task's outcome is this card's outcome, and the dispatch step's
+   *  own output cannot express it. */
   const backgroundHandle = useMemo(() => parseBackgroundHandle(output), [output]);
   const { fileAttachments, backgroundStatus } = useMemo(
     () => splitBackgroundAttachments(attachments, toolCallId),
@@ -115,18 +110,35 @@ export default function ExecuteCode({
       )
     : null;
 
+  const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: !!code,
+    onExpand,
+    runStepStatus,
+    extraError: backgroundFailed,
+  });
+
+  const highlighted = useLazyHighlight(code, lang);
+  const { ref: codePaneRef, onScroll: onCodePaneScroll } = useFollowScroll<HTMLPreElement>(
+    highlighted ?? code ?? '',
+    phase === 'running',
+    showCode,
+  );
+
   return (
     <>
       <div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={toggleCode}
           inProgressText={
             intent ??
             (sandboxStarting ? localize('com_ui_sandbox_starting') : localize('com_ui_analyzing'))
           }
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (backgroundFinishedText ?? intent ?? localize('com_ui_analyzing_finished'))
           }
@@ -139,23 +151,17 @@ export default function ExecuteCode({
           durationMs={
             backgroundHandle == null && backgrounded !== true ? runStepDurationMs : undefined
           }
-          errorSuffix={
-            (hasError && !cancelled) || backgroundFailed
-              ? localize('com_ui_tool_failed')
-              : undefined
-          }
           icon={
             <SquareTerminal
               className={cn(
                 'size-4 shrink-0 text-text-secondary',
-                progress < 1 && !cancelled && !hasError && 'animate-pulse',
+                phase === 'running' && 'animate-pulse',
               )}
               aria-hidden="true"
             />
           }
           hasInput={!!code?.length}
           isExpanded={showCode}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
diff --git a/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx b/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx
index 6b788e9c60..90d20a2e90 100644
--- a/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/FileAuthoringCall.tsx
@@ -152,20 +152,19 @@ export default function FileAuthoringCall({
     previewLang = fileLang;
   }
 
-  const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError } =
-    useToolCallState(
-      initialProgress,
-      isSubmitting,
-      output,
-      !!filePath || !!preview,
-      onExpand,
-      runStepStatus,
-    );
+  const { showCode, toggleCode, expandStyle, expandRef, phase } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: !!filePath || !!preview,
+    onExpand,
+    runStepStatus,
+  });
 
   const highlighted = useLazyHighlight(preview || undefined, previewLang);
   const { ref: previewPaneRef, onScroll: onPreviewPaneScroll } = useFollowScroll<HTMLPreElement>(
     highlighted ?? preview,
-    progress < 1 && !cancelled,
+    phase === 'running',
     showCode,
   );
   const Icon = isCreate && !overwrote ? FilePlus2 : FilePenLine;
@@ -179,7 +178,7 @@ export default function FileAuthoringCall({
     <>
       <div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={toggleCode}
           inProgressText={
             intent ??
@@ -188,24 +187,22 @@ export default function FileAuthoringCall({
             })
           }
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (intent ?? localize(finishedKey, { 0: fileName }))
           }
           durationMs={runStepDurationMs}
-          errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}
           icon={
             <Icon
               className={cn(
                 'size-4 shrink-0 text-text-secondary',
-                progress < 1 && !cancelled && !hasError && 'animate-pulse',
+                phase === 'running' && 'animate-pulse',
               )}
               aria-hidden="true"
             />
           }
           hasInput={!!filePath || !!preview}
           isExpanded={showCode}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
@@ -226,7 +223,7 @@ export default function FileAuthoringCall({
                 <pre
                   className={cn(
                     'max-h-[300px] overflow-auto whitespace-pre-wrap break-words border-t border-border-light px-3 py-2.5 font-mono text-xs',
-                    hasError ? 'text-status-error' : 'text-text-primary',
+                    phase === 'failed' ? 'text-status-error' : 'text-text-primary',
                   )}
                 >
                   {output}
diff --git a/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx b/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx
index 2e93348d1a..6d8440e1e0 100644
--- a/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/ReadFileCall.tsx
@@ -89,8 +89,14 @@ export default function ReadFileCall({
   const fileName = filePath.split('/').pop() || filePath;
   const lang = useMemo(() => langFromPath(filePath), [filePath]);
 
-  const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =
-    useToolCallState(initialProgress, isSubmitting, output, !!filePath, onExpand, runStepStatus);
+  const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: !!filePath,
+    onExpand,
+    runStepStatus,
+  });
 
   const highlighted = useLazyHighlight(hasOutput ? output : undefined, lang);
 
@@ -98,28 +104,26 @@ export default function ReadFileCall({
     <>
       <div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={toggleCode}
           inProgressText={intent ?? localize('com_ui_reading_file', { 0: fileName })}
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (intent ?? localize('com_ui_read_file', { 0: fileName }))
           }
           durationMs={runStepDurationMs}
-          errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}
           icon={
             <FileText
               className={cn(
                 'size-4 shrink-0 text-text-secondary',
-                progress < 1 && !cancelled && !hasError && 'animate-pulse',
+                phase === 'running' && 'animate-pulse',
               )}
               aria-hidden="true"
             />
           }
           hasInput={!!filePath || hasOutput}
           isExpanded={showCode}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
diff --git a/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx b/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx
index cd73e73223..55d1e8be0b 100644
--- a/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/SkillCall.tsx
@@ -35,35 +35,39 @@ export default function SkillCall({
   const skillName = useMemo(() => parseJsonField(args, 'skillName'), [args]);
   const intent = useToolCallIntent(args);
 
-  const { showCode, toggleCode, expandStyle, expandRef, progress, cancelled, hasError, hasOutput } =
-    useToolCallState(initialProgress, isSubmitting, output, !!skillName, onExpand, runStepStatus);
+  const { showCode, toggleCode, expandStyle, expandRef, phase, hasOutput } = useToolCallState({
+    initialProgress,
+    isSubmitting,
+    output,
+    hasInput: !!skillName,
+    onExpand,
+    runStepStatus,
+  });
 
   return (
     <>
       <div className="relative my-1.5 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={toggleCode}
           inProgressText={intent ?? localize('com_ui_skill_running', { 0: skillName })}
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (intent ?? localize('com_ui_skill_finished', { 0: skillName }))
           }
           durationMs={runStepDurationMs}
-          errorSuffix={hasError && !cancelled ? localize('com_ui_tool_failed') : undefined}
           icon={
             <ScrollText
               className={cn(
                 'size-4 shrink-0 text-text-secondary',
-                progress < 1 && !cancelled && !hasError && 'animate-pulse',
+                phase === 'running' && 'animate-pulse',
               )}
               aria-hidden="true"
             />
           }
           hasInput={!!skillName || hasOutput}
           isExpanded={showCode}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx
index 701159aa84..7775c80e02 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/BashCall.test.tsx
@@ -33,20 +33,20 @@ jest.mock('~/hooks', () => ({
 
 jest.mock('~/components/Chat/Messages/Content/ProgressText', () => ({
   __esModule: true,
+  /** Mirrors the real component's contract: one `phase` drives both the
+   *  label and the failure suffix. */
   default: ({
-    progress,
+    phase,
     inProgressText,
     finishedText,
-    errorSuffix,
   }: {
-    progress: number;
+    phase: 'running' | 'completed' | 'cancelled' | 'failed';
     inProgressText: string;
     finishedText: string;
-    errorSuffix?: string;
   }) => (
     <div data-testid="progress-text">
-      {progress < 1 ? inProgressText : finishedText}
-      {errorSuffix != null ? ` — ${errorSuffix}` : ''}
+      {phase === 'running' ? inProgressText : finishedText}
+      {phase === 'failed' ? ' — tool failed' : ''}
     </div>
   ),
 }));
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx
index ddfed3b06e..db8266c33a 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/FileAuthoringCall.test.tsx
@@ -26,14 +26,16 @@ jest.mock('~/utils', () => ({
 jest.mock('~/components/Chat/Messages/Content/ProgressText', () => ({
   __esModule: true,
   default: ({
-    progress,
+    phase,
     inProgressText,
     finishedText,
   }: {
-    progress: number;
+    phase: 'running' | 'completed' | 'cancelled' | 'failed';
     inProgressText: string;
     finishedText: string;
-  }) => <div data-testid="progress-text">{progress < 1 ? inProgressText : finishedText}</div>,
+  }) => (
+    <div data-testid="progress-text">{phase === 'running' ? inProgressText : finishedText}</div>
+  ),
 }));
 
 jest.mock('../CodeWindowHeader', () => ({
@@ -64,14 +66,14 @@ jest.mock('../useLazyHighlight', () => {
 
 jest.mock('../useToolCallState', () => ({
   __esModule: true,
-  default: (initialProgress: number) => ({
+  /** Mirrors the real hook: options object in, a single `phase` out. */
+  default: ({ initialProgress }: { initialProgress: number }) => ({
     showCode: true,
     toggleCode: jest.fn(),
     expandStyle: {},
     expandRef: { current: null },
     progress: initialProgress,
-    cancelled: false,
-    hasError: false,
+    phase: initialProgress < 1 ? 'running' : 'completed',
   }),
 }));
 
diff --git a/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts b/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts
index 47483c33a4..18e0aae1cf 100644
--- a/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts
+++ b/client/src/components/Chat/Messages/Content/Parts/useToolCallState.ts
@@ -1,7 +1,9 @@
 import { useState, useEffect, useCallback } from 'react';
 import { useRecoilValue } from 'recoil';
 import type { PartMetadata } from 'librechat-data-provider';
+import type { ToolCallPhase } from '~/utils/toolCallPhase';
 import { isError } from '~/components/Chat/Messages/Content/ToolOutput';
+import { resolveToolCallPhase } from '~/utils/toolCallPhase';
 import { useProgress, useExpandCollapse } from '~/hooks';
 import store from '~/store';
 
@@ -10,24 +12,44 @@ interface ToolCallState {
   toggleCode: () => void;
   expandStyle: React.CSSProperties;
   expandRef: React.RefObject<HTMLDivElement>;
-  progress: number;
-  cancelled: boolean;
-  hasError: boolean;
+  /**
+   * The card's settled state, resolved once. Label, announcement, icon and
+   * animation all read this — deriving any of them separately is what let
+   * them disagree.
+   */
+  phase: ToolCallPhase;
   hasOutput: boolean;
   hasContent: boolean;
 }
 
-export default function useToolCallState(
-  initialProgress: number,
-  isSubmitting: boolean,
-  output: string,
-  hasInput: boolean,
-  onExpand?: () => void,
-  runStepStatus?: PartMetadata['runStepStatus'],
-): ToolCallState {
+export interface UseToolCallStateInput {
+  initialProgress: number;
+  isSubmitting: boolean;
+  output: string;
+  hasInput: boolean;
+  onExpand?: () => void;
+  runStepStatus?: PartMetadata['runStepStatus'];
+  /**
+   * A failure this call's own output cannot express — currently a
+   * backgrounded task that settled as `error`, where the dispatch step's
+   * output is the handle rather than the task's result. Folded into the
+   * phase so those cards resolve their state through the same path as
+   * every other card instead of patching the result afterwards.
+   */
+  extraError?: boolean;
+}
+
+export default function useToolCallState({
+  initialProgress,
+  isSubmitting,
+  output,
+  hasInput,
+  onExpand,
+  runStepStatus,
+  extraError = false,
+}: UseToolCallStateInput): ToolCallState {
   const autoExpand = useRecoilValue(store.autoExpandTools);
   const hasOutput = output.length > 0;
-  const hasError = (hasOutput && isError(output)) || runStepStatus === 'failed';
   const hasContent = hasInput || hasOutput;
 
   const [showCode, setShowCode] = useState(() => autoExpand && hasContent);
@@ -41,12 +63,13 @@ export default function useToolCallState(
 
   const isClosed = runStepStatus != null;
   /**
-   * Both halves are load-bearing: passing 1 in stops `useProgress` scheduling
-   * its 200ms interval, and masking the result makes the terminal value
-   * observable on the same render rather than after the hook settles.
+   * Passing 1 in for a closed step stops `useProgress` scheduling its 200ms
+   * interval, which it keeps alive for any input below 1. The result no
+   * longer needs masking: the phase treats an explicit close as terminal
+   * outright, so a step that closes while the hook is still settling through
+   * 0.99 can no longer read as in-flight.
    */
   const rawProgress = useProgress(isClosed ? 1 : initialProgress);
-  const progress = isClosed ? 1 : rawProgress;
   const toggleCode = useCallback(() => {
     setShowCode((prev) => {
       const next = !prev;
@@ -56,28 +79,26 @@ export default function useToolCallState(
       return next;
     });
   }, [onExpand]);
+
   /**
-   * The step's own terminal status wins when the run emitted one; the
-   * `isSubmitting` heuristic is a whole-message inference that cannot tell
-   * which step stopped. Kept as the fallback for messages saved before
-   * `on_run_step_closed` and endpoints that do not emit it.
-   *
-   * The status is authoritative on its own terms — it is deliberately not
-   * gated on `hasError`, so that parsing the output text can never demote a
-   * step the run reported as stopped back into an in-flight state.
+   * One resolution; everything the card shows is a read of this value. The
+   * two progress inputs are deliberately distinct — see `resolveToolCallPhase`
+   * for why the cancellation inference must not read the animated one.
    */
-  const cancelled = isClosed
-    ? runStepStatus === 'cancelled'
-    : !isSubmitting && rawProgress < 1 && !hasError;
+  const phase = resolveToolCallPhase({
+    runStepStatus,
+    displayProgress: rawProgress,
+    reportedProgress: initialProgress,
+    isSubmitting,
+    hasError: (hasOutput && isError(output)) || extraError,
+  });
 
   return {
     showCode,
     toggleCode,
     expandStyle,
     expandRef,
-    progress,
-    cancelled,
-    hasError,
+    phase,
     hasOutput,
     hasContent,
   };
diff --git a/client/src/components/Chat/Messages/Content/ProgressText.tsx b/client/src/components/Chat/Messages/Content/ProgressText.tsx
index 5ff5a79ba8..323d715ea9 100644
--- a/client/src/components/Chat/Messages/Content/ProgressText.tsx
+++ b/client/src/components/Chat/Messages/Content/ProgressText.tsx
@@ -3,6 +3,7 @@ import { Button } from '@librechat/client';
 import { useTranslation } from 'react-i18next';
 import * as Popover from '@radix-ui/react-popover';
 import { isReportableRunStepDuration } from 'librechat-data-provider';
+import type { ToolCallPhase } from '~/utils/toolCallPhase';
 import { cn, getRunStepDurationLabels } from '~/utils';
 import CancelledIcon from './CancelledIcon';
 import { useLocalize } from '~/hooks';
@@ -39,73 +40,60 @@ const Wrapper = ({ popover, children }: { popover: boolean; children: React.Reac
 };
 
 export default function ProgressText({
-  progress,
+  phase,
   onClick,
   inProgressText,
   finishedText,
   authText,
   icon: iconProp,
   subtitle,
-  errorSuffix,
   durationMs,
   hasInput = true,
   popover = false,
   isExpanded = false,
-  error = false,
 }: {
-  progress: number;
+  /**
+   * The card's settled state, resolved once by the caller via
+   * `resolveToolCallPhase`. Replaces the former `error` + `errorSuffix`
+   * pair, which encoded three terminal states in two booleans — `error`
+   * meant cancelled, a present `errorSuffix` meant failed, and every
+   * consumer had to reconstruct the distinction. That shape is what let a
+   * duration render beside "failed" and a live region announce "completed"
+   * over a visibly failed card.
+   */
+  phase: ToolCallPhase;
   onClick?: () => void;
   inProgressText: string;
   finishedText: string;
   authText?: string;
   icon?: React.ReactNode;
   subtitle?: string;
-  errorSuffix?: string;
   /** Wall-clock duration of the run step, from `PartMetadata.runStepDurationMs`. */
   durationMs?: number;
   hasInput?: boolean;
   popover?: boolean;
   isExpanded?: boolean;
-  error?: boolean;
 }) {
   const localize = useLocalize();
   /** For locale-aware decimal formatting of the sub-10s duration value. */
   const { i18n } = useTranslation();
-  const getText = () => {
-    if (error) {
-      return finishedText;
-    }
-    if (progress < 1) {
-      return authText ?? inProgressText;
-    }
-    return finishedText;
-  };
+  const isRunning = phase === 'running';
 
-  const getIcon = () => {
-    if (error && !errorSuffix) {
-      return <CancelledIcon />;
-    }
-    return iconProp ?? null;
-  };
-
-  const text = getText();
-  const icon = getIcon();
-  const showShimmer = progress < 1 && !error;
+  /** Every branch below reads `phase`, so the label, the icon, the shimmer,
+   *  the failure suffix and the duration cannot disagree about what state
+   *  the card is in. */
+  const text = isRunning ? (authText ?? inProgressText) : finishedText;
+  const icon = phase === 'cancelled' ? <CancelledIcon /> : (iconProp ?? null);
+  const showShimmer = isRunning;
+  const errorSuffix = phase === 'failed' ? localize('com_ui_tool_failed') : undefined;
   /**
    * Shown only on a settled, successful card. While the step is still running
    * the number would be stale the instant it rendered, and on a cancelled or
    * failed card "how long it took" is not the fact the reader needs — that
-   * slot already carries the cancelled icon or the error suffix.
-   *
-   * Both terminal-failure channels must be checked: at every call site
-   * `error` carries cancellation while failure arrives as `errorSuffix`
-   * alone, so gating on `error` by itself would print a duration beside
-   * "failed". Gating here on the component's own props rather than on a
-   * separate caller-supplied flag keeps this consistent with the label
-   * beside it by construction; the callers only forward the number.
+   * slot already carries the cancelled icon or the failure suffix.
    */
   const duration =
-    progress >= 1 && !error && !errorSuffix && isReportableRunStepDuration(durationMs)
+    phase === 'completed' && isReportableRunStepDuration(durationMs)
       ? getRunStepDurationLabels(durationMs, i18n.language)
       : undefined;
 
diff --git a/client/src/components/Chat/Messages/Content/RetrievalCall.tsx b/client/src/components/Chat/Messages/Content/RetrievalCall.tsx
index 9cbd74580c..73a1d67d20 100644
--- a/client/src/components/Chat/Messages/Content/RetrievalCall.tsx
+++ b/client/src/components/Chat/Messages/Content/RetrievalCall.tsx
@@ -6,6 +6,7 @@ import { FileText, FileSpreadsheet, FileCode, FileImage, File } from 'lucide-rea
 import type { TAttachment, TFile, PartMetadata } from 'librechat-data-provider';
 import { useLocalize, useProgress, useExpandCollapse } from '~/hooks';
 import { ToolIcon, OutputRenderer, isError } from './ToolOutput';
+import { resolveToolCallPhase } from '~/utils/toolCallPhase';
 import FilePreviewDialog from './FilePreviewDialog';
 import { sortPagesByRelevance, cn } from '~/utils';
 import { useToolCallIntent } from './Parts/intent';
@@ -350,25 +351,25 @@ export default function RetrievalCall({
    * mounted would otherwise render as still in progress for that window.
    */
   const rawProgress = useProgress(isClosed ? 1 : initialProgress);
-  const progress = isClosed ? 1 : rawProgress;
   const localize = useLocalize();
   /** Model-authored live label (injected when file_search is opted into
    *  describe_intent); persists as the settled label. The sr-only live
    *  region below deliberately keeps its stable generic value. */
   const intent = useToolCallIntent(args);
 
-  const errorState = (typeof output === 'string' && isError(output)) || runStepStatus === 'failed';
   /**
-   * The step's own terminal status wins when the run emitted one; the
-   * `isSubmitting` heuristic is a whole-message inference that cannot tell
-   * which step stopped. Authoritative on its own terms — not gated on
-   * `errorState`, so output parsing cannot demote a stopped step back into an
-   * in-flight state. Fallback retained for messages saved before
-   * `on_run_step_closed` and endpoints that do not emit it.
+   * One resolution, read by the label, the live region and the icon alike.
+   * It also unifies two inputs that had drifted apart: the cancellation
+   * inference read `initialProgress` while the label read the animated
+   * `rawProgress`.
    */
-  const cancelled = isClosed
-    ? runStepStatus === 'cancelled'
-    : !isSubmitting && initialProgress < 1 && !errorState;
+  const phase = resolveToolCallPhase({
+    runStepStatus,
+    displayProgress: rawProgress,
+    reportedProgress: initialProgress,
+    isSubmitting,
+    hasError: typeof output === 'string' && isError(output),
+  });
   const hasOutput = !!output && !isError(output);
   const autoExpand = useRecoilValue(store.autoExpandTools);
   const [showOutput, setShowOutput] = useState(() => autoExpand && hasOutput);
@@ -446,16 +447,16 @@ export default function RetrievalCall({
     <div className="my-1">
       <span className="sr-only" aria-live="polite" aria-atomic="true">
         {(() => {
-          if (progress < 1 && !cancelled) {
+          if (phase === 'running') {
             return localize('com_ui_searching_files');
           }
-          if (cancelled) {
+          if (phase === 'cancelled') {
             return localize('com_ui_cancelled');
           }
-          /** Announced before the success string: a terminal step that errored
-           *  must not reach the live region as "retrieved files", which would
-           *  tell a screen-reader user the opposite of what the card shows. */
-          if (errorState) {
+          /** A terminal step that errored must not reach the live region as
+           *  "retrieved files", which would tell a screen-reader user the
+           *  opposite of what the card shows. */
+          if (phase === 'failed') {
             return localize('com_ui_failed');
           }
           return intent ?? localize('com_ui_retrieved_files');
@@ -463,24 +464,20 @@ export default function RetrievalCall({
       </span>
       <div className="relative my-1 flex h-5 shrink-0 items-center gap-2.5">
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={hasOutput ? handleToggleOutput : undefined}
           inProgressText={intent ?? localize('com_ui_searching_files')}
           /** A cancelled step must not read "Retrieved files" beside a
            *  cancellation icon while the live region says "Cancelled". */
           finishedText={
-            cancelled
+            phase === 'cancelled'
               ? localize('com_ui_cancelled')
               : (intent ?? localize('com_ui_retrieved_files'))
           }
           durationMs={runStepDurationMs}
-          errorSuffix={errorState && !cancelled ? localize('com_ui_tool_failed') : undefined}
-          icon={
-            <ToolIcon type="file_search" isAnimating={progress < 1 && !cancelled && !errorState} />
-          }
+          icon={<ToolIcon type="file_search" isAnimating={phase === 'running'} />}
           hasInput={hasOutput}
           isExpanded={showOutput}
-          error={cancelled}
         />
       </div>
       <div style={expandStyle}>
diff --git a/client/src/components/Chat/Messages/Content/ToolCall.tsx b/client/src/components/Chat/Messages/Content/ToolCall.tsx
index cdd5096692..25f0d3d3cc 100644
--- a/client/src/components/Chat/Messages/Content/ToolCall.tsx
+++ b/client/src/components/Chat/Messages/Content/ToolCall.tsx
@@ -13,6 +13,7 @@ import type { TAttachment, PartMetadata } from 'librechat-data-provider';
 import { useLocalize, useProgress, useExpandCollapse, useLazyCollapseBody } from '~/hooks';
 import { ToolIcon, getToolIconType, isError } from './ToolOutput';
 import { useMCPIconMap, useMCPServerNames } from '~/hooks/MCP';
+import { resolveToolCallPhase } from '~/utils/toolCallPhase';
 import { useToolCallIntent } from './Parts/intent';
 import { AttachmentGroup } from './Parts';
 import ToolCallInfo from './ToolCallInfo';
@@ -156,10 +157,6 @@ export default function ToolCall({
    * in-flight state.
    */
   const isClosed = runStepStatus != null;
-  const cancelled = isClosed
-    ? runStepStatus === 'cancelled'
-    : !isSubmitting && initialProgress < 1 && !hasError;
-  const errorState = hasError;
 
   const args = useMemo(() => {
     if (typeof _args === 'string') {
@@ -191,8 +188,19 @@ export default function ToolCall({
    * observable on the same render rather than after the hook settles.
    */
   const rawProgress = useProgress(isClosed ? 1 : initialProgress);
-  const progress = isClosed ? 1 : rawProgress;
-  const showCancelled = cancelled || (errorState && !output);
+  /**
+   * One resolution, read by the label, the live region, the icon and the
+   * shimmer alike. It also unifies two inputs that had drifted apart: the
+   * cancellation inference read `initialProgress` while the label read the
+   * animated `rawProgress`.
+   */
+  const phase = resolveToolCallPhase({
+    runStepStatus,
+    displayProgress: rawProgress,
+    reportedProgress: initialProgress,
+    isSubmitting,
+    hasError,
+  });
 
   const handleToggleInfo = useCallback(() => {
     mountBody();
@@ -221,7 +229,7 @@ export default function ToolCall({
   const intent = useToolCallIntent(_args);
 
   const getFinishedText = () => {
-    if (cancelled) {
+    if (phase === 'cancelled') {
       return localize('com_ui_cancelled');
     }
     /**
@@ -229,7 +237,7 @@ export default function ToolCall({
      * errored must not reach the live region as "completed", which would tell
      * a screen-reader user the opposite of what the card shows.
      */
-    if (errorState) {
+    if (phase === 'failed') {
       return function_name
         ? `${localize('com_ui_failed')}: ${function_name}`
         : localize('com_ui_failed');
@@ -258,7 +266,7 @@ export default function ToolCall({
           announced once via getFinishedText. */}
       <span className="sr-only" aria-live="polite" aria-atomic="true">
         {(() => {
-          if (progress < 1 && !showCancelled) {
+          if (phase === 'running') {
             return function_name
               ? localize('com_assistants_running_var', { 0: function_name })
               : localize('com_assistants_running_action');
@@ -272,7 +280,7 @@ export default function ToolCall({
         data-tool-call-id={toolCallId}
       >
         <ProgressText
-          progress={progress}
+          phase={phase}
           onClick={handleToggleInfo}
           inProgressText={
             intent ??
@@ -281,22 +289,18 @@ export default function ToolCall({
               : localize('com_assistants_running_action'))
           }
           authText={
-            !showCancelled && authDomain.length > 0 ? localize('com_ui_requires_auth') : undefined
+            phase === 'running' && authDomain.length > 0
+              ? localize('com_ui_requires_auth')
+              : undefined
           }
           finishedText={getFinishedText()}
           subtitle={subtitle}
           durationMs={runStepDurationMs}
-          errorSuffix={errorState && !cancelled ? localize('com_ui_tool_failed') : undefined}
           icon={
-            <ToolIcon
-              type={toolIconType}
-              iconUrl={mcpIconUrl}
-              isAnimating={progress < 1 && !showCancelled && !errorState}
-            />
+            <ToolIcon type={toolIconType} iconUrl={mcpIconUrl} isAnimating={phase === 'running'} />
           }
           hasInput={hasInfo}
           isExpanded={showInfo}
-          error={showCancelled}
         />
       </div>
       <div
@@ -312,7 +316,7 @@ export default function ToolCall({
           )}
         </div>
       </div>
-      {auth != null && auth && progress < 1 && !showCancelled && (
+      {auth != null && auth && phase === 'running' && (
         <div className="flex w-full flex-col gap-2.5">
           <div className="mb-1 mt-2">
             <Button
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx
index 56ce5a9b3b..3ef9fd2a5c 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ProgressText.test.tsx
@@ -28,7 +28,7 @@ jest.mock('../CancelledIcon', () => ({
 }));
 
 const defaults = {
-  progress: 1,
+  phase: 'completed' as const,
   inProgressText: 'Running foo',
   finishedText: 'Completed foo',
 };
@@ -52,25 +52,25 @@ describe('ProgressText duration', () => {
    * is still the in-progress one.
    */
   it('does not render while the step is still running', () => {
-    renderProgressText({ progress: 0.4, durationMs: 3500 });
+    renderProgressText({ phase: 'running', durationMs: 3500 });
     expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();
   });
 
   /**
    * On a cancelled or failed card the slot already carries the cancelled icon
-   * or the error suffix, and "how long it took" is not the fact the reader
-   * needs. The two states arrive through different props — `error` carries
-   * cancellation, `errorSuffix` alone carries failure — so both are pinned
-   * separately; gating on `error` alone rendered a duration beside "failed"
-   * (Codex round 1 on #14892).
+   * or the failure suffix, and "how long it took" is not the fact the reader
+   * needs. Both terminal-failure states are pinned: they used to arrive
+   * through two different props (`error` for cancellation, `errorSuffix` for
+   * failure), and gating on one of them alone rendered a duration beside
+   * "failed" (Codex round 1 on #14892). They are now one value.
    */
   it('does not render on a cancelled card', () => {
-    renderProgressText({ error: true, durationMs: 3500 });
+    renderProgressText({ phase: 'cancelled', durationMs: 3500 });
     expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();
   });
 
-  it('does not render on a failed card, where failure arrives as errorSuffix alone', () => {
-    renderProgressText({ errorSuffix: 'failed', durationMs: 3500 });
+  it('does not render on a failed card', () => {
+    renderProgressText({ phase: 'failed', durationMs: 3500 });
     expect(screen.queryByText('· 3.5s')).not.toBeInTheDocument();
     expect(screen.queryByText('took 3.5 seconds')).not.toBeInTheDocument();
   });
diff --git a/client/src/utils/__tests__/toolCallPhase.spec.ts b/client/src/utils/__tests__/toolCallPhase.spec.ts
new file mode 100644
index 0000000000..d82522c69d
--- /dev/null
+++ b/client/src/utils/__tests__/toolCallPhase.spec.ts
@@ -0,0 +1,153 @@
+import type { ToolCallPhaseInput } from '../toolCallPhase';
+import { resolveToolCallPhase } from '../toolCallPhase';
+
+const resolve = (overrides: Partial<ToolCallPhaseInput> = {}) =>
+  resolveToolCallPhase({
+    displayProgress: 1,
+    reportedProgress: 1,
+    isSubmitting: false,
+    hasError: false,
+    ...overrides,
+  });
+
+describe('resolveToolCallPhase', () => {
+  describe('with an explicit run-step status', () => {
+    it('reports a completed close as completed', () => {
+      expect(resolve({ runStepStatus: 'completed' })).toBe('completed');
+    });
+
+    it('reports a failed close as failed', () => {
+      expect(resolve({ runStepStatus: 'failed' })).toBe('failed');
+    });
+
+    it('reports a cancelled close as cancelled', () => {
+      expect(resolve({ runStepStatus: 'cancelled' })).toBe('cancelled');
+    });
+
+    /**
+     * The status is authoritative on its own terms. Gating it on output
+     * parsing let a step the run reported as stopped be demoted back into an
+     * in-flight state.
+     */
+    it('never returns running for a closed step, whatever progress says', () => {
+      expect(
+        resolve({ runStepStatus: 'completed', displayProgress: 0.4, reportedProgress: 0.4 }),
+      ).toBe('completed');
+      expect(
+        resolve({
+          runStepStatus: 'cancelled',
+          displayProgress: 0.1,
+          reportedProgress: 0.1,
+          isSubmitting: true,
+        }),
+      ).toBe('cancelled');
+    });
+
+    /** Explicit cancellation outranks a failure-shaped result. */
+    it('keeps a cancelled close cancelled even when the output parses as an error', () => {
+      expect(resolve({ runStepStatus: 'cancelled', hasError: true })).toBe('cancelled');
+    });
+
+    /** A completed close whose result reads as a failure is still a failure —
+     *  the card must not present an error as a clean success. */
+    it('reports a completed close with error output as failed', () => {
+      expect(resolve({ runStepStatus: 'completed', hasError: true })).toBe('failed');
+    });
+  });
+
+  describe('under the legacy heuristic', () => {
+    it('reports an in-flight call as running', () => {
+      expect(resolve({ displayProgress: 0.4, reportedProgress: 0.4, isSubmitting: true })).toBe(
+        'running',
+      );
+    });
+
+    it('reports a settled call as completed', () => {
+      expect(resolve({ displayProgress: 1, reportedProgress: 1, isSubmitting: true })).toBe(
+        'completed',
+      );
+    });
+
+    /** Unfinished progress with the message no longer streaming is the only
+     *  signal the pre-`on_run_step_closed` path had for a stop. */
+    it('infers cancellation from an unfinished call once submission ends', () => {
+      expect(resolve({ displayProgress: 0.4, reportedProgress: 0.4, isSubmitting: false })).toBe(
+        'cancelled',
+      );
+    });
+
+    /**
+     * The precedence inverts here, deliberately: the cancellation inference
+     * ("not submitting and not finished") is also satisfied by a genuine
+     * failure, so applying the explicit-close ordering relabelled real
+     * failures as user stops on historical messages.
+     */
+    it('lets failure outrank the cancellation inference', () => {
+      expect(
+        resolve({
+          displayProgress: 0.4,
+          reportedProgress: 0.4,
+          isSubmitting: false,
+          hasError: true,
+        }),
+      ).toBe('failed');
+    });
+
+    it('reports a failure even while the message is still streaming', () => {
+      expect(
+        resolve({
+          displayProgress: 0.4,
+          reportedProgress: 0.4,
+          isSubmitting: true,
+          hasError: true,
+        }),
+      ).toBe('failed');
+    });
+  });
+
+  describe('the useProgress settle window', () => {
+    /**
+     * `useProgress` holds below 1 for ~200ms after a call reports completion
+     * (it emits `0.99`, then `1` on a timeout). Inferring cancellation from
+     * that animated value labelled — and announced — a successful call as
+     * "Cancelled" whenever submission ended inside the window
+     * (Codex round 1 on #14934).
+     */
+    it('does not call a reported-complete call cancelled while the animation settles', () => {
+      expect(resolve({ displayProgress: 0.99, reportedProgress: 1, isSubmitting: false })).toBe(
+        'running',
+      );
+    });
+
+    /** The inference still fires for a call that genuinely never finished. */
+    it('still infers cancellation when the stream itself never reported completion', () => {
+      expect(resolve({ displayProgress: 0.99, reportedProgress: 0.4, isSubmitting: false })).toBe(
+        'cancelled',
+      );
+    });
+
+    /** Once the animation catches up the card settles, without a cancelled
+     *  frame in between. */
+    it('settles to completed once the animation catches up', () => {
+      expect(resolve({ displayProgress: 1, reportedProgress: 1, isSubmitting: false })).toBe(
+        'completed',
+      );
+    });
+  });
+
+  /**
+   * The two precedence rules are opposites and have been collapsed into one
+   * another twice under review. Pinned side by side so a future edit cannot
+   * quietly unify them.
+   */
+  it('applies opposite precedence for an explicit close and the heuristic', () => {
+    const withError = {
+      hasError: true,
+      displayProgress: 0.4,
+      reportedProgress: 0.4,
+      isSubmitting: false,
+    };
+    expect(resolve({ ...withError, runStepStatus: 'cancelled' })).toBe('cancelled');
+    expect(resolve(withError)).toBe('failed');
+  });
+});
diff --git a/client/src/utils/index.ts b/client/src/utils/index.ts
index 332852028f..77d93e4fec 100644
--- a/client/src/utils/index.ts
+++ b/client/src/utils/index.ts
@@ -45,6 +45,7 @@ export * from './approval';
 export * from './steer';
 export * from './activityLabels';
 export * from './runStepDuration';
+export * from './toolCallPhase';
 export * from './documentTitle';
 export * from './reasoningLabels';
 export * from './numbers';
diff --git a/client/src/utils/toolCallPhase.ts b/client/src/utils/toolCallPhase.ts
new file mode 100644
index 0000000000..df43424456
--- /dev/null
+++ b/client/src/utils/toolCallPhase.ts
@@ -0,0 +1,88 @@
+import type { PartMetadata } from 'librechat-data-provider';
+
+/**
+ * The settled state of one tool call, as every part of its card should read
+ * it: the visible label, the `aria-live` announcement, the icon, the shimmer,
+ * and whether a duration is worth showing.
+ *
+ * Before this existed each card derived those independently — the label from
+ * one expression, the announcement from another, the animation from a third —
+ * and a change to one kept missing the others. Thirteen of the seventeen
+ * review findings on #14873 were instances of that drift, and #14892 added a
+ * fourteenth. One value, read everywhere, is what stops it: two presentations
+ * of the same card can no longer disagree about what happened.
+ */
+export type ToolCallPhase = 'running' | 'completed' | 'cancelled' | 'failed';
+
+export interface ToolCallPhaseInput {
+  /**
+   * The run's own terminal verdict from `on_run_step_closed`. Absent on parts
+   * saved before the event existed and on endpoints that never emit it, which
+   * is what the heuristic below is for.
+   */
+  runStepStatus?: PartMetadata['runStepStatus'];
+  /**
+   * The animated value from `useProgress` — what the card is showing right
+   * now. Drives `running` vs `completed` so the label and shimmer follow the
+   * animation rather than snapping.
+   */
+  displayProgress: number;
+  /**
+   * The progress the stream actually reported, before display animation.
+   * Kept separate because `useProgress` holds below 1 for ~200ms after a call
+   * reports completion (it emits `0.99`, then `1` on a timeout), and the
+   * cancellation inference must not read that lag as an unfinished call.
+   */
+  reportedProgress: number;
+  /** Whether the whole message is still streaming — a message-level fact. */
+  isSubmitting: boolean;
+  /**
+   * Whether this call's own result reads as a failure: parsed error output,
+   * or a card-specific signal such as a backgrounded task settling as `error`.
+   */
+  hasError: boolean;
+}
+
+/**
+ * Resolve a tool call's phase from every signal that bears on it.
+ *
+ * The precedence rules encoded here were each established by a specific
+ * review finding, and each is load-bearing:
+ *
+ * - **An explicit status is authoritative and never gated on output parsing.**
+ *   Reading the result text can otherwise demote a step the run reported as
+ *   stopped back into an in-flight state.
+ * - **Explicit cancellation outranks a failure-shaped result.** A step the
+ *   user stopped is cancelled even if its partial output parses as an error.
+ * - **Under the legacy heuristic the opposite holds: failure outranks
+ *   cancellation**, because that inference reads "not submitting and not
+ *   finished" as a stop, which a genuine failure also satisfies. Applying the
+ *   explicit-close precedence there relabelled real failures as user stops.
+ * - **A closed step is never `running`**, whatever progress says.
+ * - **Cancellation is inferred from reported progress, never from the
+ *   animation.** `useProgress` lags a completed call by ~200ms; reading that
+ *   lag would label — and announce — a successful call as cancelled whenever
+ *   submission ended inside the window.
+ */
+export function resolveToolCallPhase({
+  runStepStatus,
+  displayProgress,
+  reportedProgress,
+  isSubmitting,
+  hasError,
+}: ToolCallPhaseInput): ToolCallPhase {
+  if (runStepStatus != null) {
+    if (runStepStatus === 'cancelled') {
+      return 'cancelled';
+    }
+    return runStepStatus === 'failed' || hasError ? 'failed' : 'completed';
+  }
+
+  if (hasError) {
+    return 'failed';
+  }
+  if (!isSubmitting && reportedProgress < 1) {
+    return 'cancelled';
+  }
+  return displayProgress < 1 ? 'running' : 'completed';
+}