diff --git a/apps/mobile/src/components/agents/message-bubble.test.ts b/apps/mobile/src/components/agents/message-bubble.test.ts
index ece3b83d92..4cd18985bd 100644
--- a/apps/mobile/src/components/agents/message-bubble.test.ts
+++ b/apps/mobile/src/components/agents/message-bubble.test.ts
@@ -303,6 +303,26 @@ describe('MessageBubble failure footer', () => {
     expect(findElementByType(tree, 'Button', p => p.accessibilityLabel === 'Retry')).toBeNull();
   });
 
+  it('states a generic assistant failure once, without a detail line repeating the title', async () => {
+    const tree = await renderBubbleWithHandlers(
+      assistantMessageWithError('m-asst-laconic', 'APIError'),
+      {
+        onRetryMessage: vi.fn<(message: StoredMessage) => void>(),
+      }
+    );
+    expect(findText(tree, t => t === 'Response failed')).toBe(true);
+    expect(findText(tree, t => t === 'The response failed.')).toBe(false);
+  });
+
+  it('keeps the classified detail line for a known assistant error', async () => {
+    const tree = await renderBubbleWithHandlers(
+      assistantMessageWithError('m-asst-known', 'ProviderAuthError'),
+      { onRetryMessage: vi.fn<(message: StoredMessage) => void>() }
+    );
+    expect(findText(tree, t => t === 'Response failed')).toBe(true);
+    expect(findText(tree, t => t === 'The provider rejected the request.')).toBe(true);
+  });
+
   it('does not render the footer when no handler is supplied', async () => {
     const tree = await renderBubbleWithHandlers(userMessage('m-nohandler'), {
       deliveryState: { status: 'failed', error: 'nope', reason: 'exhausted' },
diff --git a/apps/mobile/src/components/agents/message-bubble.tsx b/apps/mobile/src/components/agents/message-bubble.tsx
index 081a00c041..b8dcef0b74 100644
--- a/apps/mobile/src/components/agents/message-bubble.tsx
+++ b/apps/mobile/src/components/agents/message-bubble.tsx
@@ -162,7 +162,9 @@ function MessageBubbleImpl({
         >
           {failure.title}
         </Text>
-        <Text className="text-xs text-muted-foreground">{failure.detail}</Text>
+        {failure.detail !== null ? (
+          <Text className="text-xs text-muted-foreground">{failure.detail}</Text>
+        ) : null}
         <View className="flex-row gap-2">
           {failure.canRetry && onRetryMessage ? (
             <Button
diff --git a/apps/mobile/src/components/agents/message-failure-state.test.ts b/apps/mobile/src/components/agents/message-failure-state.test.ts
index 78a02e3501..2a3f19558b 100644
--- a/apps/mobile/src/components/agents/message-failure-state.test.ts
+++ b/apps/mobile/src/components/agents/message-failure-state.test.ts
@@ -112,10 +112,11 @@ describe('selectMessageFailure', () => {
       expect(result?.canCopy).toBe(false);
     });
 
-    it('falls back to the generic line for an unknown error name', () => {
+    it('adds no detail line for an unknown error name, which the title states', () => {
       const result = selectMessageFailure({ info: assistantInfo('UnknownError') });
-      expect(result?.detail).toBe('The response failed.');
-      expect(result?.detail).not.toContain('RAW_PROVIDER_TEXT');
+      expect(result?.title).toBe('Response failed');
+      expect(result?.detail).toBeNull();
+      expect(JSON.stringify(result)).not.toContain('RAW_PROVIDER_TEXT');
     });
 
     it('sets canRetry false only for NON_RETRYABLE_ASSISTANT_ERRORS', () => {
diff --git a/apps/mobile/src/components/agents/message-failure-state.ts b/apps/mobile/src/components/agents/message-failure-state.ts
index d3f70a49fc..dfcf8d49d9 100644
--- a/apps/mobile/src/components/agents/message-failure-state.ts
+++ b/apps/mobile/src/components/agents/message-failure-state.ts
@@ -25,10 +25,13 @@ export const NON_RETRYABLE_ASSISTANT_ERRORS: readonly string[] = [
 ];
 
 /**
- * Fixed, safe copy for a known assistant error name. Unknown names fall back
- * to the generic line. Never surfaces `error.data` or provider message text.
+ * Fixed, safe copy for a known assistant error name. An unknown name has no
+ * line of its own: the title already states that the response failed, so the
+ * footer adds no detail rather than repeating the title in a sentence
+ * (`messageFailure.assistantFailed` is the fixed footer's line, not the
+ * message row's). Never surfaces `error.data` or provider message text.
  */
-function assistantDetail(errorName: string): string {
+function assistantDetail(errorName: string): string | null {
   switch (errorName) {
     case 'ProviderAuthError': {
       return i18n.t('agentChat.messageFailure.assistantProviderRejected');
@@ -40,7 +43,7 @@ function assistantDetail(errorName: string): string {
       return i18n.t('agentChat.messageFailure.assistantContextOverflow');
     }
     default: {
-      return i18n.t('agentChat.messageFailure.assistantFailed');
+      return null;
     }
   }
 }
@@ -48,7 +51,12 @@ function assistantDetail(errorName: string): string {
 export type MessageFailure = {
   kind: 'delivery' | 'assistant';
   title: string;
-  detail: string;
+  /**
+   * The explanation line under the title, or `null` when the title alone says
+   * it (an assistant failure with no classified reason). The footer then shows
+   * one statement plus the action rather than the same sentence twice.
+   */
+  detail: string | null;
   /**
    * The untranslated transport text for a failed delivery ("Unauthorized:
    * Unauthorized"), for the copy action only — same split as the terminal
diff --git a/apps/mobile/src/components/agents/session-detail-content-helpers.test.ts b/apps/mobile/src/components/agents/session-detail-content-helpers.test.ts
index b8c15a2acf..2b4b6c891c 100644
--- a/apps/mobile/src/components/agents/session-detail-content-helpers.test.ts
+++ b/apps/mobile/src/components/agents/session-detail-content-helpers.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { type MessageDeliveryState, type StoredMessage } from '@kilocode/cloud-agent-sdk';
 import {
   countInFlightMessages,
+  lastVisibleMessageFailure,
   resolveRetryPrompt,
   retryFailedMessage,
 } from './session-detail-content-helpers';
@@ -118,3 +119,131 @@ describe('resolveRetryPrompt', () => {
     expect(resolveRetryPrompt(assistant, [assistant])).toBeNull();
   });
 });
+
+describe('lastVisibleMessageFailure', () => {
+  function assistantMessageWithText(id: string): StoredMessage {
+    const message = assistantMessage(id);
+    // `mergeSessionTranscript` keeps a message only when a part renders content,
+    // so a row that states a failure needs a part the transcript renders.
+    message.parts = [
+      { id: `${id}-text`, sessionID: 'ses_1', messageID: id, type: 'text', text: 'reply' },
+    ] as typeof message.parts;
+    return message;
+  }
+
+  function assistantMessageWithError(id: string, errorName: string): StoredMessage {
+    const message = assistantMessageWithText(id);
+    (message.info as { error?: { name: string; data: unknown } }).error = {
+      name: errorName,
+      data: { message: 'raw' },
+    };
+    return message;
+  }
+
+  const noPending = new Map<string, MessageDeliveryState>();
+  const nothingCanceled = new Map<string, StoredMessage>();
+
+  it('returns null when the last row has no failure', () => {
+    const messages: StoredMessage[] = [userMessage('m1'), assistantMessageWithText('m2')];
+    expect(
+      lastVisibleMessageFailure({
+        displayedMessages: messages,
+        messages,
+        pendingMessages: noPending,
+        canceledQueuedMessages: nothingCanceled,
+      })
+    ).toBeNull();
+  });
+
+  it('returns the assistant failure the last row renders with a Retry', () => {
+    const messages: StoredMessage[] = [
+      userMessage('m1'),
+      assistantMessageWithError('m2', 'APIError'),
+    ];
+    const failure = lastVisibleMessageFailure({
+      displayedMessages: messages,
+      messages,
+      pendingMessages: noPending,
+      canceledQueuedMessages: nothingCanceled,
+    });
+    expect(failure?.kind).toBe('assistant');
+    expect(failure?.title).toBe('Response failed');
+    expect(failure?.detail).toBeNull();
+  });
+
+  it('returns null for an assistant failure with no preceding user row (no Retry)', () => {
+    const messages: StoredMessage[] = [assistantMessageWithError('m1', 'APIError')];
+    expect(
+      lastVisibleMessageFailure({
+        displayedMessages: messages,
+        messages,
+        pendingMessages: noPending,
+        canceledQueuedMessages: nothingCanceled,
+      })
+    ).toBeNull();
+  });
+
+  it('returns the delivery failure the last row renders', () => {
+    const messages: StoredMessage[] = [userMessage('m1')];
+    const pendingMessages = new Map<string, MessageDeliveryState>([
+      ['m1', { status: 'failed', error: 'nope', reason: 'exhausted' }],
+    ]);
+    const failure = lastVisibleMessageFailure({
+      displayedMessages: messages,
+      messages,
+      pendingMessages,
+      canceledQueuedMessages: nothingCanceled,
+    });
+    expect(failure?.kind).toBe('delivery');
+    expect(failure?.title).toBe('Failed to deliver');
+  });
+
+  it('ignores a cancelled queued row', () => {
+    const messages: StoredMessage[] = [userMessage('m1')];
+    const pendingMessages = new Map<string, MessageDeliveryState>([
+      ['m1', { status: 'failed', error: 'nope', reason: 'exhausted' }],
+    ]);
+    expect(
+      lastVisibleMessageFailure({
+        displayedMessages: messages,
+        messages,
+        pendingMessages,
+        canceledQueuedMessages: new Map<string, StoredMessage>([['m1', userMessage('m1')]]),
+      })
+    ).toBeNull();
+  });
+
+  it('ignores a failure that is not the last row', () => {
+    const messages: StoredMessage[] = [
+      userMessage('m1'),
+      assistantMessageWithError('m2', 'APIError'),
+      assistantMessageWithText('m3'),
+    ];
+    expect(
+      lastVisibleMessageFailure({
+        displayedMessages: messages,
+        messages,
+        pendingMessages: noPending,
+        canceledQueuedMessages: nothingCanceled,
+      })
+    ).toBeNull();
+  });
+
+  it('falls back past a message the transcript drops, which states no failure', () => {
+    // `mergeSessionTranscript` drops an assistant row whose parts render
+    // nothing (no delivery failure keeps it), so it owns no row and cannot
+    // state a failure. Treating it as the last row suppressed the footer's own
+    // line and left the failure with no surface at all.
+    const dropped = assistantMessageWithError('m2', 'APIError');
+    dropped.parts = [];
+    const messages: StoredMessage[] = [userMessage('m1'), dropped];
+    expect(
+      lastVisibleMessageFailure({
+        displayedMessages: messages,
+        messages,
+        pendingMessages: noPending,
+        canceledQueuedMessages: nothingCanceled,
+      })
+    ).toBeNull();
+  });
+});
diff --git a/apps/mobile/src/components/agents/session-detail-content-helpers.ts b/apps/mobile/src/components/agents/session-detail-content-helpers.ts
index 617b92904c..bae4eb8dc6 100644
--- a/apps/mobile/src/components/agents/session-detail-content-helpers.ts
+++ b/apps/mobile/src/components/agents/session-detail-content-helpers.ts
@@ -1,6 +1,8 @@
 import { type MessageDeliveryState, type StoredMessage } from '@kilocode/cloud-agent-sdk';
 
+import { type MessageFailure, selectMessageFailure } from './message-failure-state';
 import { firstHumanText } from './part-types';
+import { transcriptRendersMessage } from './session-transcript';
 
 /**
  * Counts pending messages that are still in flight. A terminal delivery
@@ -61,3 +63,69 @@ export function resolveRetryPrompt(
   }
   return null;
 }
+
+type LastVisibleFailureInput = {
+  /** The rendered list, in order. Its last entry the transcript renders owns
+   * the row above the footer. */
+  displayedMessages: readonly StoredMessage[];
+  /** The full list, for the retry prompt's preceding-user search. */
+  messages: readonly StoredMessage[];
+  pendingMessages: ReadonlyMap<string, MessageDeliveryState>;
+  /** Canceled rows kept locally, keyed by message id. */
+  canceledQueuedMessages: ReadonlyMap<string, StoredMessage>;
+};
+
+/**
+ * The failure footer the transcript's last message row renders, or `null` when
+ * that row renders none. The fixed footer's status indicator uses this to tell
+ * a failure the row already states (which it must not repeat) from a
+ * session-level error the row does not carry (which only the footer can show).
+ *
+ * Mirrors MessageBubble's own gate: a footer needs a failure and a wired
+ * action. Copy to composer is always wired on a delivery failure, so only an
+ * assistant failure can be left without one (no preceding user row).
+ */
+export function lastVisibleMessageFailure({
+  displayedMessages,
+  messages,
+  pendingMessages,
+  canceledQueuedMessages,
+}: LastVisibleFailureInput): MessageFailure | null {
+  // The transcript drops a message whose parts render nothing (unless its
+  // delivery failed and its typed footer is the row's surface), so such a
+  // message owns no row and cannot state a failure. Walk back to the last row
+  // `mergeSessionTranscript` actually renders: reading `displayedMessages.at(-1)`
+  // let a dropped failure suppress the footer's own line and leave the failure
+  // with no surface at all.
+  const last = lastRenderedMessage(displayedMessages, pendingMessages);
+  if (last === undefined) {
+    return null;
+  }
+  const deliveryState =
+    last.info.role === 'user' && !canceledQueuedMessages.has(last.info.id)
+      ? pendingMessages.get(last.info.id)
+      : undefined;
+  const failure = selectMessageFailure({ deliveryState, info: last.info });
+  if (failure === null || failure.kind === 'delivery') {
+    return failure;
+  }
+  return resolveRetryPrompt(last, messages) !== null ? failure : null;
+}
+
+/**
+ * The last message `mergeSessionTranscript` renders, or `undefined` when it
+ * renders none. A dropped message is invisible, so the row above the footer is
+ * the one before it.
+ */
+function lastRenderedMessage(
+  displayedMessages: readonly StoredMessage[],
+  pendingMessages: ReadonlyMap<string, MessageDeliveryState>
+): StoredMessage | undefined {
+  for (let i = displayedMessages.length - 1; i >= 0; i -= 1) {
+    const message = displayedMessages[i];
+    if (message !== undefined && transcriptRendersMessage(message, pendingMessages)) {
+      return message;
+    }
+  }
+  return undefined;
+}
diff --git a/apps/mobile/src/components/agents/session-detail-content.test.ts b/apps/mobile/src/components/agents/session-detail-content.test.ts
index deb9c32ba0..07e1cda3db 100644
--- a/apps/mobile/src/components/agents/session-detail-content.test.ts
+++ b/apps/mobile/src/components/agents/session-detail-content.test.ts
@@ -34,7 +34,7 @@ import { ChildSessionModelLabel } from '@/components/agents/child-session-model-
 import { ChildSessionSheet } from '@/components/agents/child-session-sheet';
 import { getTaskToolSessionId } from '@/components/agents/child-session-card-state';
 import { MessageBubble } from '@/components/agents/message-bubble';
-import { assistantMessage } from '@/components/agents/message-bubble-test-utils';
+import { assistantMessage, userMessage } from '@/components/agents/message-bubble-test-utils';
 import {
   exitRemoteSessionWithFeedback,
   type RetryableExitFailure,
@@ -2469,3 +2469,99 @@ describe('SessionDetailContent send transcript take-over', () => {
     expect(followTailNonceOf(view)).toBe(1);
   });
 });
+
+describe('session detail duplicate failure state', () => {
+  // Stored messages are ordered by id, which is time-sortable ascending, so the
+  // user row must sort before the assistant row for the Retry prompt to resolve.
+  const USER_ID = 'msg_1761000000000_user';
+  const ASSISTANT_ID = 'msg_1761000000010_assistant';
+
+  function rootUserMessage(text: string): StoredMessage {
+    const message = userMessage(USER_ID);
+    return {
+      info: { ...message.info, sessionID: ROOT_ID },
+      parts: [
+        stubTextPart({ id: `${USER_ID}-text`, sessionID: ROOT_ID, messageID: USER_ID, text }),
+      ],
+    };
+  }
+
+  function rootFailedAssistantMessage(text: string): StoredMessage {
+    const message = assistantMessage(ASSISTANT_ID);
+    message.info = { ...message.info, sessionID: ROOT_ID };
+    (message.info as { error?: { name: string; data: unknown } }).error = {
+      name: 'APIError',
+      data: { message: 'raw provider text' },
+    };
+    return {
+      info: message.info,
+      parts: [
+        stubTextPart({
+          id: `${ASSISTANT_ID}-text`,
+          sessionID: ROOT_ID,
+          messageID: ASSISTANT_ID,
+          text,
+        }),
+      ],
+    };
+  }
+
+  async function mountFailedTurn(indicator: SessionStatusIndicator) {
+    const view = await mountDetails([
+      rootUserMessage('please refactor'),
+      rootFailedAssistantMessage('matching the requested refactor.'),
+    ]);
+    act(() => {
+      view.store.set<SessionStatusIndicator | null, [SessionStatusIndicator | null], unknown>(
+        view.manager.atoms.statusIndicator,
+        indicator
+      );
+    });
+    return view;
+  }
+
+  it('states the failure once: no repeated detail line and no repeated footer error', async () => {
+    const view = await mountFailedTurn({ type: 'error', message: 'simulated error', timestamp: 0 });
+    const text = renderedText(view.renderer.root);
+    expect(text).toContain('Response failed');
+    expect(text).not.toContain('The response failed.');
+    expect(indicatorNodes(view)).toHaveLength(0);
+  });
+
+  it('keeps a classified session error the message row does not carry', async () => {
+    const view = await mountFailedTurn({
+      type: 'error',
+      message: 'Insufficient credits. Please add at least $1 to continue using Cloud Agent.',
+      timestamp: 0,
+    });
+    const nodes = indicatorNodes(view);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]?.props).toMatchObject({
+      indicator: { message: expect.stringContaining('Insufficient credits') },
+    });
+  });
+
+  it('keeps the footer line when the transcript drops the failed row it names', async () => {
+    // A failed assistant row whose parts render nothing is dropped by
+    // `mergeSessionTranscript`; it owns no row, so the footer is the failure's
+    // only surface and must not be suppressed by it.
+    const dropped = rootFailedAssistantMessage('partial reply');
+    dropped.parts = [];
+    const view = await mountDetails([rootUserMessage('please refactor'), dropped]);
+    act(() => {
+      view.store.set<SessionStatusIndicator | null, [SessionStatusIndicator | null], unknown>(
+        view.manager.atoms.statusIndicator,
+        { type: 'error', message: 'simulated error', timestamp: 0 }
+      );
+    });
+    const nodes = indicatorNodes(view);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]?.props).toMatchObject({
+      indicator: { message: 'simulated error' },
+    });
+  });
+});
+
+function indicatorNodes(view: Awaited<ReturnType<typeof mountDetails>>) {
+  return view.renderer.root.findAll(node => Object.is(node.type, 'SessionStatusIndicator'));
+}
diff --git a/apps/mobile/src/components/agents/session-detail-content.tsx b/apps/mobile/src/components/agents/session-detail-content.tsx
index a80bf99318..3804dc9a88 100644
--- a/apps/mobile/src/components/agents/session-detail-content.tsx
+++ b/apps/mobile/src/components/agents/session-detail-content.tsx
@@ -99,6 +99,7 @@ import {
 } from '@/components/agents/session-working-state';
 import {
   countInFlightMessages,
+  lastVisibleMessageFailure,
   resolveRetryPrompt,
   retryFailedMessage,
 } from '@/components/agents/session-detail-content-helpers';
@@ -146,6 +147,7 @@ import { ToolRunSheetHost } from '@/components/agents/tool-run-sheet-host';
 import {
   buildTerminalErrorCopyText,
   resolveSessionTerminalError,
+  statusIndicatorDuplicatesMessageFailure,
 } from '@/components/agents/session-terminal-error';
 import { performCopy } from '@/components/agents/use-message-copy';
 import { QueryError } from '@/components/query-error';
@@ -1469,8 +1471,30 @@ export function SessionDetailContent({
     isStreaming,
     pendingMessageCount: inFlightMessageCount,
   });
+  // A failed last row states its own failure and carries the action. The fixed
+  // footer's error line must not state the same failure a second time (explorer
+  // finding: the same failure stated three times), so a status error the row
+  // already carries is dropped — a classified one the row does not carry stays.
+  const footerMessageFailure = useMemo(
+    () =>
+      lastVisibleMessageFailure({
+        displayedMessages,
+        messages,
+        pendingMessages,
+        canceledQueuedMessages,
+      }),
+    [displayedMessages, messages, pendingMessages, canceledQueuedMessages]
+  );
+  const footerStatusIndicator =
+    statusIndicator !== null &&
+    !statusIndicatorDuplicatesMessageFailure({
+      indicator: statusIndicator,
+      failure: footerMessageFailure,
+    })
+      ? statusIndicator
+      : null;
   const hasFooterStatusIndicator =
-    (!cachedMetadataRefresh && statusIndicator !== null) ||
+    (!cachedMetadataRefresh && footerStatusIndicator !== null) ||
     (cloudStatus !== null && cloudStatus.type !== 'ready');
   const shouldShowFooterWorking = shouldShowFooterWorkingIndicator({
     isAgentWorking: shouldShowWorkingIndicator,
@@ -1487,7 +1511,7 @@ export function SessionDetailContent({
     cloudStatusType: cloudStatus?.type,
     hasInProgressTranscriptPreparation,
     shouldShowFooterWorking,
-    hasStatusIndicator: !cachedMetadataRefresh && statusIndicator !== null,
+    hasStatusIndicator: !cachedMetadataRefresh && footerStatusIndicator !== null,
     messageCount: messages.length,
   });
 
@@ -2093,7 +2117,9 @@ export function SessionDetailContent({
                 spinner reads Thinking during a reasoning stream in both modes.
                 Feeding it displayedMessages would drop that label. */}
             <WorkingIndicator messages={messages} isStreaming={shouldShowFooterWorking} />
-            {statusIndicator ? <SessionStatusIndicator indicator={statusIndicator} /> : null}
+            {footerStatusIndicator ? (
+              <SessionStatusIndicator indicator={footerStatusIndicator} />
+            ) : null}
           </Animated.View>
         ) : null}
 
diff --git a/apps/mobile/src/components/agents/session-detail-queue.test.ts b/apps/mobile/src/components/agents/session-detail-queue.test.ts
index 9936248f0c..7f9e983879 100644
--- a/apps/mobile/src/components/agents/session-detail-queue.test.ts
+++ b/apps/mobile/src/components/agents/session-detail-queue.test.ts
@@ -386,6 +386,7 @@ vi.mock('@/components/agents/use-message-copy', () => ({
 }));
 vi.mock('@/components/agents/session-detail-content-helpers', () => ({
   countInFlightMessages: () => 0,
+  lastVisibleMessageFailure: () => null,
   resolveRetryPrompt: () => null,
   retryFailedMessage: vi.fn(),
 }));
diff --git a/apps/mobile/src/components/agents/session-terminal-error.test.ts b/apps/mobile/src/components/agents/session-terminal-error.test.ts
index b014c318bf..bad7a34487 100644
--- a/apps/mobile/src/components/agents/session-terminal-error.test.ts
+++ b/apps/mobile/src/components/agents/session-terminal-error.test.ts
@@ -1,10 +1,12 @@
 import { describe, expect, it } from 'vitest';
 
+import { type MessageFailure } from './message-failure-state';
 import {
   buildTerminalErrorCopyText,
   classifyTerminalError,
   resolveSessionTerminalError,
   sessionStatusErrorMessage,
+  statusIndicatorDuplicatesMessageFailure,
 } from './session-terminal-error';
 
 describe('classifyTerminalError', () => {
@@ -246,3 +248,73 @@ describe('sessionStatusErrorMessage', () => {
     expect(sessionStatusErrorMessage(raw)).not.toContain('Service Unavailable');
   });
 });
+
+function assistantFailure(detail: string | null): MessageFailure {
+  return {
+    kind: 'assistant',
+    title: 'Response failed',
+    detail,
+    copyDetail: '',
+    canRetry: true,
+    canCopy: false,
+  };
+}
+
+describe('statusIndicatorDuplicatesMessageFailure', () => {
+  const deliveryFailure: MessageFailure = {
+    kind: 'delivery',
+    title: 'Failed to deliver',
+    detail: 'We could not deliver this message after several attempts.',
+    copyDetail: 'Unauthorized: Unauthorized',
+    canRetry: true,
+    canCopy: true,
+  };
+
+  it('suppresses an unclassified session error the last row already states', () => {
+    expect(
+      statusIndicatorDuplicatesMessageFailure({
+        indicator: { type: 'error', message: 'simulated error' },
+        failure: assistantFailure(null),
+      })
+    ).toBe(true);
+  });
+
+  it('suppresses the delivery line the last row already states', () => {
+    expect(
+      statusIndicatorDuplicatesMessageFailure({
+        indicator: { type: 'error', message: 'Message failed to deliver' },
+        failure: deliveryFailure,
+      })
+    ).toBe(true);
+  });
+
+  it('keeps a classified line the row does not carry', () => {
+    expect(
+      statusIndicatorDuplicatesMessageFailure({
+        indicator: {
+          type: 'error',
+          message: 'Assistant request failed: insufficient credits',
+        },
+        failure: assistantFailure(null),
+      })
+    ).toBe(false);
+  });
+
+  it('keeps the line when the row renders no failure footer', () => {
+    expect(
+      statusIndicatorDuplicatesMessageFailure({
+        indicator: { type: 'error', message: 'simulated error' },
+        failure: null,
+      })
+    ).toBe(false);
+  });
+
+  it('keeps a non-error indicator', () => {
+    expect(
+      statusIndicatorDuplicatesMessageFailure({
+        indicator: { type: 'progress', message: 'Setting up environment…' },
+        failure: assistantFailure(null),
+      })
+    ).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/components/agents/session-terminal-error.ts b/apps/mobile/src/components/agents/session-terminal-error.ts
index 1bf6001ba3..1a47b810ba 100644
--- a/apps/mobile/src/components/agents/session-terminal-error.ts
+++ b/apps/mobile/src/components/agents/session-terminal-error.ts
@@ -1,6 +1,10 @@
+import { type SessionStatusIndicator } from '@kilocode/cloud-agent-sdk';
+
 import { i18n } from '@/i18n';
 import { type QueryErrorVariant } from '@/components/query-error';
 
+import { type MessageFailure } from './message-failure-state';
+
 /**
  * Terminal error class for a session startup failure. The session manager's
  * fetch-fail path stores only a formatted message string on the status
@@ -246,6 +250,36 @@ export function sessionStatusErrorMessage(raw: string): string {
     : messageForClass(cls);
 }
 
+/**
+ * True when the fixed footer's error line would only restate the failure the
+ * transcript's last message row already shows. The row owns its failure and its
+ * action; a second copy of the same sentence in the footer reads as a glitch,
+ * not a designed error state. A line the row does not carry — a classified
+ * credits, service or permission failure, or the Durable Object's own safe
+ * projection — is kept: the footer is where the reader gets that reason.
+ */
+export function statusIndicatorDuplicatesMessageFailure(input: {
+  indicator: Pick<SessionStatusIndicator, 'type' | 'message'>;
+  failure: MessageFailure | null;
+}): boolean {
+  const { indicator, failure } = input;
+  if (indicator.type !== 'error' || failure === null) {
+    return false;
+  }
+  const copy = sessionStatusErrorMessage(indicator.message);
+  if (copy === failure.title) {
+    return true;
+  }
+  if (failure.detail !== null && copy === failure.detail) {
+    return true;
+  }
+  // An unclassified status error resolves to the generic assistant line, which
+  // is the same failure the row's own title states.
+  return (
+    failure.kind === 'assistant' && copy === i18n.t('agentChat.messageFailure.assistantFailed')
+  );
+}
+
 /**
  * The terminal error a session must surface, taking precedence over the
  * skeleton. Copy is always offered for a terminal error, regardless of class.
diff --git a/apps/mobile/src/components/agents/session-transcript.ts b/apps/mobile/src/components/agents/session-transcript.ts
index b1da4bc80f..d0c9f1f83b 100644
--- a/apps/mobile/src/components/agents/session-transcript.ts
+++ b/apps/mobile/src/components/agents/session-transcript.ts
@@ -92,6 +92,34 @@ export function getSessionTranscriptItemMessageId(item: SessionTranscriptItem):
   return item.messageId;
 }
 
+/**
+ * Whether `mergeSessionTranscript` emits a row for this message: it renders
+ * content, or its delivery failed and its typed footer is the row's own
+ * surface. Everything else is dropped and cannot own a failure row.
+ *
+ * An unconfirmed row with no parts at all stays invisible: unlike a confirmed
+ * user row (whose parts may still stream in, so a zero-part row stays
+ * transient), a client materialised row that never received its parts will not
+ * gain content on its own — it would otherwise leave the reported empty yellow
+ * stub above the submitted text. A synthetic row whose parts exist but render
+ * nothing is already dropped by `messageRendersContent`, so this rule only has
+ * to name the zero-part case. The row is keyed by the id the client sent (the
+ * server honors `messageId`), so the run that failed it attaches here and a
+ * failed submission keeps its one row with the typed footer. Two rows with the
+ * same prompt are two submissions and stay two rows. If the server later
+ * confirms the id, the authoritative record replaces the info and the row
+ * re-renders through the normal path.
+ */
+export function transcriptRendersMessage(
+  message: StoredMessage,
+  deliveryStates?: ReadonlyMap<string, MessageDeliveryState>
+): boolean {
+  const failed = deliveryStates?.get(message.info.id)?.status === 'failed';
+  const unconfirmedWithoutParts =
+    isUnconfirmedSubmission(message) && !failed && message.parts.length === 0;
+  return !unconfirmedWithoutParts && (messageRendersContent(message) || failed);
+}
+
 export function mergeSessionTranscript(
   messages: readonly StoredMessage[],
   preparationAttempts: readonly PreparationAttempt[],
@@ -116,22 +144,7 @@ export function mergeSessionTranscript(
   let previousCreated: number | undefined = undefined;
   for (const message of messages) {
     messageIds.add(message.info.id);
-    const failed = deliveryStates?.get(message.info.id)?.status === 'failed';
-    // An unconfirmed row with no parts at all stays invisible: unlike a
-    // confirmed user row (whose parts may still stream in, so a zero-part row
-    // stays transient), a client materialised row that never received its parts
-    // will not gain content on its own — it would otherwise leave the reported
-    // empty yellow stub above the submitted text. A synthetic row whose parts
-    // exist but render nothing is already dropped by `messageRendersContent`
-    // below, so this rule only has to name the zero-part case. The row is keyed
-    // by the id the client sent (the server honors `messageId`), so the run that
-    // failed it attaches here and a failed submission keeps its one row with the
-    // typed footer. Two rows with the same prompt are two submissions and stay
-    // two rows. If the server later confirms the id, the authoritative record
-    // replaces the info and the row re-renders through the normal path.
-    const unconfirmedWithoutParts =
-      isUnconfirmedSubmission(message) && !failed && message.parts.length === 0;
-    if (!unconfirmedWithoutParts && (messageRendersContent(message) || failed)) {
+    if (transcriptRendersMessage(message, deliveryStates)) {
       const created = message.info.time.created;
       // One validity rule, shared with the marker component: a timestamp the label
       // cannot format must never produce a marker row.