diff --git a/apps/mobile/src/app/(app)/agent-chat/[session-id].mounted.test.tsx b/apps/mobile/src/app/(app)/agent-chat/[session-id].mounted.test.tsx
index ca9fb663ca..a87d4886b2 100644
--- a/apps/mobile/src/app/(app)/agent-chat/[session-id].mounted.test.tsx
+++ b/apps/mobile/src/app/(app)/agent-chat/[session-id].mounted.test.tsx
@@ -1,14 +1,59 @@
 /* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom). */
-import { createElement } from 'react';
+/* eslint-disable max-lines -- keep the real SDK lifecycle probes with the route's shared mounted fixture. */
+import { createElement, type ReactElement, useEffect } from 'react';
+import { useAtomValue } from 'jotai';
+import { useTranslation } from 'react-i18next';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type * as ReactQuery from '@tanstack/react-query';
 import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest';
+import {
+  createSessionManager,
+  type KiloSessionId,
+  type SessionManager,
+  type SessionManagerConfig,
+  type SessionSnapshotPageOutcome,
+} from '@kilocode/cloud-agent-sdk';
+import { kiloId, stubTextPart, stubUserMessage } from '@kilocode/cloud-agent-sdk/test-helpers';
 
+import '@/i18n';
+import { useSessionManager } from '@/components/agents/session-provider';
+import { UserWebConnectionProvider } from '@/components/agents/user-web-connection-provider';
+import { useSessionDetailRename } from '@/components/agents/use-session-detail-rename';
+import { QueryError } from '@/components/query-error';
+import { ScreenHeader } from '@/components/screen-header';
+import { Button } from '@/components/ui/button';
+import { clearActiveToken, setActiveToken, setSignOutTeardownActive } from '@/lib/auth/token-owner';
+import { bumpAuthEpoch, currentAuthEpoch } from '@/lib/auth/auth-epoch';
+import { setSignOutActive } from '@/lib/auth/sign-out-state';
+import {
+  beginAuthenticatedOwner,
+  confirmAuthenticatedOwner,
+  getAuthenticatedOwner,
+} from '@/lib/context-scope';
 import SessionDetailScreen from './[session-id]';
 
 const useLocalSearchParamsMock = vi.hoisted(() => vi.fn());
 const useRouterMock = vi.hoisted(() => vi.fn());
 const useQueryMock = vi.hoisted(() => vi.fn());
 const queryOptionsMock = vi.hoisted(() => vi.fn());
+const createMobileManagerMock = vi.hoisted(() => vi.fn());
+const authState = vi.hoisted(() => ({
+  token: 'account-a-token' as string | undefined,
+  authEpoch: 1,
+  isLoading: false,
+  isSigningOut: false,
+  sessionEnded: false,
+}));
+
+const CHILD_ID = kiloId('ses_child_scope_probe');
+const childPageMock = vi.fn<NonNullable<SessionManagerConfig['fetchSnapshotPage']>>();
+type ManagerProbe = { manager: SessionManager; store: SessionManagerConfig['store'] };
+const managers: ManagerProbe[] = [];
+// Request credentials can change independently of the React token (request-time refresh).
+let requestAccount: 'A' | 'B' = 'A';
+const rootRequests: { account: 'A' | 'B'; sessionId: KiloSessionId }[] = [];
+let rootMetadataReady: Promise<undefined> | null = null;
 
 const queryState = vi.hoisted(() => ({
   isPending: false,
@@ -19,8 +64,38 @@ const queryState = vi.hoisted(() => ({
   refetch: vi.fn(),
 }));
 
+const confirmationRequests = vi.hoisted(() => ({
+  getMe: vi.fn<() => Promise<{ id: string }>>(),
+  ticket: vi.fn<() => Promise<{ token: string }>>(),
+}));
+
+const navigationRoutes = ['session-detail'];
 vi.mock('react-native', () => ({
   View: 'View',
+  Pressable: 'Pressable',
+  ActivityIndicator: 'ActivityIndicator',
+  I18nManager: { isRTL: false },
+  Platform: { OS: 'android' },
+}));
+vi.mock('react-native-safe-area-context', () => ({
+  useSafeAreaInsets: () => ({ top: 0, bottom: 0 }),
+}));
+vi.mock('@/components/ui/directional-icons', () => ({ DirectionalChevronLeft: 'ChevronLeft' }));
+vi.mock('@/components/ui/eyebrow', () => ({ Eyebrow: 'Eyebrow' }));
+vi.mock('expo-secure-store', () => ({ getItemAsync: vi.fn() }));
+vi.mock('@/lib/config', () => ({ SESSION_INGEST_WS_URL: 'wss://ingest.example.com' }));
+vi.mock('@/lib/user-web-connection-lifecycle', () => ({
+  createNativeUserWebConnectionLifecycleHooks: () => ({}),
+}));
+vi.mock('@/lib/a11y/announce', () => ({ announceForA11y: vi.fn() }));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({ useThemeColors: () => ({}) }));
+vi.mock('@/components/ui/icons', () => ({
+  AlertCircle: 'AlertCircle',
+  ChevronDown: 'ChevronDown',
+  Lock: 'Lock',
+  SearchX: 'SearchX',
+  ServerCrash: 'ServerCrash',
+  WifiOff: 'WifiOff',
 }));
 
 vi.mock('expo-router', () => ({
@@ -28,30 +103,81 @@ vi.mock('expo-router', () => ({
   useRouter: useRouterMock,
 }));
 
-vi.mock('@tanstack/react-query', () => ({
+vi.mock('@tanstack/react-query', async importOriginal => ({
+  ...(await importOriginal<typeof ReactQuery>()),
   useQuery: useQueryMock,
 }));
 
-// This suite covers route-param parsing only; the foreground refresh hook
-// needs a real QueryClient, which the react-query mock above does not provide.
+// Foreground query refresh is separate from route parsing and provider lifetime.
 vi.mock('@/lib/hooks/use-route-foreground-refresh', () => ({
   useRouteForegroundRefresh: vi.fn(),
 }));
 
+vi.mock('@/lib/auth/auth-context', () => ({
+  useAuth: () => authState,
+}));
+
 vi.mock('@/lib/trpc', () => ({
   useTRPC: () => ({
     cliSessionsV2: {
-      get: { queryOptions: queryOptionsMock },
+      get: {
+        queryOptions: queryOptionsMock,
+        queryKey: () => [['cliSessionsV2', 'get']],
+      },
     },
   }),
+  trpcClient: {
+    user: { getMe: { query: confirmationRequests.getMe } },
+    activeSessions: { createWebTicket: { mutate: confirmationRequests.ticket } },
+  },
 }));
 
 vi.mock('@/components/invalid-route-state', () => ({
   InvalidRouteState: 'InvalidRouteState',
 }));
 
+vi.mock('@/lib/hooks/use-session-mutations', () => ({
+  useSessionMutations: () => ({ renameSessionAsync: vi.fn() }),
+}));
+
 vi.mock('@/components/agents/session-detail-content', () => ({
-  SessionDetailContent: 'SessionDetailContent',
+  SessionDetailContent: function SessionDetailContent(
+    props: Readonly<{ sessionId: KiloSessionId; cachedTitle?: string }>
+  ) {
+    const manager = useSessionManager();
+    const { t } = useTranslation();
+    const { sessionId, cachedTitle } = props;
+    // Match the real detail lifecycle for the original manager and every successor.
+    useEffect(() => {
+      void manager.switchSession(sessionId);
+    }, [sessionId, manager]);
+    const rootMessages = useAtomValue(manager.atoms.messagesList);
+    const childMessages = useAtomValue(manager.atoms.childMessages)(CHILD_ID);
+    const fetchedData = useAtomValue(manager.atoms.fetchedSessionData);
+    const isSessionLoaded = fetchedData?.kiloSessionId === sessionId;
+    // Use the real title hook with metadata from the real manager, not a fixed mock title.
+    const rename = useSessionDetailRename({
+      sessionId,
+      isLoaded: isSessionLoaded,
+      serverTitle: isSessionLoaded ? (fetchedData.title ?? undefined) : undefined,
+      fallbackTitle: cachedTitle ?? t('agentChat.session.title'),
+    });
+    return createElement(
+      'SessionDetailContent',
+      props,
+      createElement(ScreenHeader, { title: rename.title }),
+      rootMessages.flatMap(message =>
+        message.parts.flatMap(part =>
+          part.type === 'text' ? [createElement('RootText', { key: part.id }, part.text)] : []
+        )
+      ),
+      childMessages.flatMap(message =>
+        message.parts.flatMap(part =>
+          part.type === 'text' ? [createElement('Text', { key: part.id }, part.text)] : []
+        )
+      )
+    );
+  },
 }));
 
 vi.mock('@/components/agents/session-detail-skeleton', () => ({
@@ -67,8 +193,8 @@ vi.mock('@/components/agents/session-context-metrics', () => ({
   SessionContextMetrics: 'SessionContextMetrics',
 }));
 
-vi.mock('@/components/agents/session-provider', () => ({
-  AgentSessionProvider: 'AgentSessionProvider',
+vi.mock('@/components/agents/mobile-session-manager', () => ({
+  createMobileAgentSessionManager: createMobileManagerMock,
 }));
 
 vi.mock('@/components/agents/session-terminal-error', () => ({
@@ -79,21 +205,10 @@ vi.mock('@/components/agents/use-message-copy', () => ({
   performCopy: vi.fn(),
 }));
 
-vi.mock('@/components/query-error', () => ({
-  QueryError: 'QueryError',
-}));
-
-vi.mock('@/components/screen-header', () => ({
-  ScreenHeader: 'ScreenHeader',
-}));
-
-vi.mock('@/components/ui/button', () => ({
-  Button: 'Button',
-}));
-
-vi.mock('@/components/ui/text', () => ({
-  Text: 'Text',
-}));
+vi.mock('@/components/ui/text', async () => {
+  const { createContext } = await import('react');
+  return { Text: 'Text', TextClassContext: createContext<string | undefined>(undefined) };
+});
 
 vi.mock('@/lib/spawned-not-found-retry', () => ({
   shouldRetryNotFoundOnSpawnedRoute: () => false,
@@ -103,6 +218,15 @@ function findByType(
   root: TestRenderer.ReactTestInstance,
   type: string
 ): TestRenderer.ReactTestInstance[] {
+  if (type === 'QueryError') {
+    return root.findAllByType(QueryError);
+  }
+  if (type === 'Button') {
+    return root.findAllByType(Button);
+  }
+  if (type === 'ScreenHeader') {
+    return root.findAllByType(ScreenHeader);
+  }
   return root.findAll(node => typeof node.type === 'string' && (node.type as string) === type);
 }
 
@@ -115,15 +239,33 @@ function propOf(instance: TestRenderer.ReactTestInstance | undefined, key: strin
   /* eslint-enable typescript-eslint/no-unsafe-member-access */
 }
 
-function mountRoute(): TestRenderer.ReactTestRenderer {
+async function mountRoute(
+  element: ReactElement = createElement(SessionDetailScreen)
+): Promise<TestRenderer.ReactTestRenderer> {
   const ref: { current: TestRenderer.ReactTestRenderer | undefined } = { current: undefined };
-  act(() => {
-    ref.current = TestRenderer.create(createElement(SessionDetailScreen));
+  await act(async () => {
+    ref.current = TestRenderer.create(createElement(UserWebConnectionProvider, null, element));
+    await Promise.resolve();
   });
   if (!ref.current) {
     throw new Error('route did not render');
   }
-  return ref.current;
+  const renderer = ref.current;
+  onTestFinished(() => {
+    act(() => {
+      renderer.unmount();
+    });
+  });
+  return renderer;
+}
+
+async function updateRoute(renderer: TestRenderer.ReactTestRenderer) {
+  await act(async () => {
+    renderer.update(
+      createElement(UserWebConnectionProvider, null, createElement(SessionDetailScreen))
+    );
+    await Promise.resolve();
+  });
 }
 
 function queryEnabled(): boolean | undefined {
@@ -135,10 +277,118 @@ function queryInput(): { session_id?: string } | undefined {
   return queryOptionsMock.mock.calls[0]?.[0] as { session_id?: string } | undefined;
 }
 
+function beginReplacement() {
+  setSignOutActive(true);
+  setSignOutTeardownActive(true);
+  authState.isSigningOut = true;
+  authState.token = undefined;
+  bumpAuthEpoch();
+  authState.authEpoch = currentAuthEpoch();
+  beginAuthenticatedOwner();
+  clearActiveToken();
+}
+
+function commitCredentials(account: 'A' | 'B') {
+  requestAccount = account;
+  authState.token = account === 'A' ? 'account-a-token' : 'account-b-token';
+  setActiveToken(authState.token, null);
+  authState.isSigningOut = false;
+  setSignOutTeardownActive(false);
+  setSignOutActive(false);
+}
+
+function commitAccount(account: 'A' | 'B') {
+  commitCredentials(account);
+  confirmAuthenticatedOwner(getAuthenticatedOwner(), `user-${account}`);
+}
+
 beforeEach(() => {
+  beginReplacement();
+  commitAccount('A');
+  confirmationRequests.getMe
+    .mockReset()
+    .mockReturnValue(Promise.withResolvers<{ id: string }>().promise);
+  // Keep sockets deterministic; connection integration has its own real-SDK socket suite.
+  confirmationRequests.ticket
+    .mockReset()
+    .mockReturnValue(Promise.withResolvers<{ token: string }>().promise);
+  managers.length = 0;
+  requestAccount = 'A';
+  rootRequests.length = 0;
+  rootMetadataReady = null;
+  childPageMock.mockReset();
+  createMobileManagerMock.mockReset();
+  createMobileManagerMock.mockImplementation(
+    ({ store, userWebConnection }: Pick<SessionManagerConfig, 'store' | 'userWebConnection'>) => {
+      const manager = createSessionManager({
+        store,
+        userWebConnection,
+        resolveSession: async id => {
+          await Promise.resolve();
+          return { type: 'read-only', kiloSessionId: id };
+        },
+        getTicket: vi.fn(),
+        fetchSnapshot: vi.fn().mockResolvedValue({ info: { id: 'sess-1' }, messages: [] }),
+        fetchSnapshotPage: async (id, options) => {
+          if (id === CHILD_ID) {
+            const page = await childPageMock(id, options);
+            return page;
+          }
+          return transcriptPage(
+            id,
+            `msg-root-${requestAccount}`,
+            `Account ${requestAccount} root row`
+          );
+        },
+        api: {
+          send: vi.fn(),
+          interrupt: vi.fn(),
+          answer: vi.fn(),
+          reject: vi.fn(),
+          respondToPermission: vi.fn(),
+        },
+        prepare: vi.fn(),
+        initiate: vi.fn(),
+        fetchSession: async id => {
+          const account = requestAccount;
+          rootRequests.push({ account, sessionId: id });
+          await rootMetadataReady;
+          return {
+            kiloSessionId: id,
+            cloudAgentSessionId: null,
+            title: `Account ${account} current title`,
+            organizationId: null,
+            gitUrl: null,
+            gitBranch: null,
+            mode: null,
+            model: null,
+            variant: null,
+            repository: null,
+            isInitiated: true,
+            needsLegacyPrepare: false,
+            isPreparingAsync: false,
+            prompt: null,
+            initialMessageId: null,
+            associatedPr: null,
+          };
+        },
+      });
+      managers.push({ manager, store });
+      return manager;
+    }
+  );
   useLocalSearchParamsMock.mockReset();
   useRouterMock.mockReset();
-  useRouterMock.mockReturnValue({ replace: vi.fn() });
+  navigationRoutes.splice(0, navigationRoutes.length, 'session-detail');
+  useRouterMock.mockReturnValue({
+    canGoBack: () => navigationRoutes.length > 1,
+    back: () => {
+      navigationRoutes.pop();
+    },
+    replace: (href: string) => {
+      navigationRoutes.splice(-1, 1, href);
+    },
+  });
   useQueryMock.mockReset();
   useQueryMock.mockImplementation((options: { enabled?: boolean } | undefined) => {
     // A disabled TanStack query stays pending forever (`isPending: true` when
@@ -161,41 +411,33 @@ beforeEach(() => {
 });
 
 describe('SessionDetailScreen invalid session-id', () => {
-  it('renders InvalidRouteState with the app backTo when session-id is undefined', () => {
+  it('renders InvalidRouteState with the app backTo when session-id is undefined', async () => {
     useLocalSearchParamsMock.mockReturnValue({ 'session-id': undefined });
-    const renderer = mountRoute();
+    const renderer = await mountRoute();
 
     const invalid = findByType(renderer.root, 'InvalidRouteState');
     expect(invalid).toHaveLength(1);
     expect(propOf(invalid[0], 'backTo')).toBe('/(app)');
     expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
     expect(queryEnabled()).toBe(false);
-
-    act(() => {
-      renderer.unmount();
-    });
   });
 
-  it('renders InvalidRouteState with the app backTo when session-id is an array', () => {
+  it('renders InvalidRouteState with the app backTo when session-id is an array', async () => {
     useLocalSearchParamsMock.mockReturnValue({ 'session-id': ['sess-1', 'sess-2'] });
-    const renderer = mountRoute();
+    const renderer = await mountRoute();
 
     const invalid = findByType(renderer.root, 'InvalidRouteState');
     expect(invalid).toHaveLength(1);
     expect(propOf(invalid[0], 'backTo')).toBe('/(app)');
     expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
     expect(queryEnabled()).toBe(false);
-
-    act(() => {
-      renderer.unmount();
-    });
   });
 });
 
 describe('SessionDetailScreen valid session-id', () => {
-  it('renders the session content with the parsed session-id and enables the query', () => {
+  it('renders the session content with the parsed session-id and enables the query', async () => {
     useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
-    const renderer = mountRoute();
+    const renderer = await mountRoute();
 
     const content = findByType(renderer.root, 'SessionDetailContent');
     expect(content).toHaveLength(1);
@@ -203,9 +445,705 @@ describe('SessionDetailScreen valid session-id', () => {
     expect(findByType(renderer.root, 'InvalidRouteState')).toHaveLength(0);
     expect(queryEnabled()).toBe(true);
     expect(queryInput()).toEqual({ session_id: 'sess-1' });
+  });
+});
+
+function transcriptPage(sessionId: KiloSessionId, messageId: string, text: string) {
+  return {
+    kind: 'success',
+    info: { id: sessionId, ...(sessionId === CHILD_ID ? { parentID: 'sess-1' } : {}) },
+    messages: [
+      {
+        info: stubUserMessage({ id: messageId, sessionID: sessionId }),
+        parts: [
+          stubTextPart({
+            id: `part-${messageId}`,
+            sessionID: sessionId,
+            messageID: messageId,
+            text,
+          }),
+        ],
+      },
+    ],
+    nextCursor: null,
+    omittedItemCount: 0,
+  } satisfies SessionSnapshotPageOutcome;
+}
+
+function childPage(messageId: string, text: string, nextCursor: string | null = null) {
+  return { ...transcriptPage(CHILD_ID, messageId, text), nextCursor };
+}
+
+function transcriptText(renderer: TestRenderer.ReactTestRenderer, type = 'Text'): string {
+  if (renderer.toJSON() === null) {
+    return '';
+  }
+  const headerText = new Set(
+    renderer.root.findAllByType(ScreenHeader).flatMap(header => findByType(header, type))
+  );
+  return findByType(renderer.root, type)
+    .filter(node => !headerText.has(node))
+    .flatMap(node => node.children.filter(child => typeof child === 'string'))
+    .join('\n');
+}
+
+function childIds({ store, manager }: ManagerProbe): string[] {
+  return store
+    .get(manager.atoms.childMessages)(CHILD_ID)
+    .map(message => message.info.id);
+}
+
+async function startChildPage(pageKind: 'first' | 'older') {
+  useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1', organizationId: 'org-a' });
+  const renderer = await mountRoute();
+  const current = managers.at(-1);
+  if (!current) {
+    throw new Error('route did not create a manager');
+  }
+  // The rendered detail effect, not this helper, must initialize the manager.
+  expect(transcriptText(renderer, 'RootText')).toBe('Account A root row');
+
+  if (pageKind === 'older') {
+    childPageMock.mockResolvedValueOnce(
+      childPage('msg-account-a-cached', 'Account A cached row', 'older-cursor')
+    );
+    await act(async () => {
+      await current.manager.hydrateChildSession(CHILD_ID);
+    });
+    expect(transcriptText(renderer)).toContain('Account A cached row');
+  }
+
+  const deferred = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+  childPageMock.mockReturnValueOnce(deferred.promise);
+  const pending: { request?: Promise<void> } = {};
+  act(() => {
+    pending.request =
+      pageKind === 'first'
+        ? current.manager.hydrateChildSession(CHILD_ID)
+        : current.manager.loadOlderChildMessages(CHILD_ID);
+  });
+  if (!pending.request) {
+    throw new Error('child request did not start');
+  }
+  expect(childPageMock).toHaveBeenLastCalledWith(
+    CHILD_ID,
+    pageKind === 'first' ? {} : { cursor: 'older-cursor' }
+  );
+  return { renderer, current, request: pending.request, resolvePage: deferred.resolve };
+}
+
+// Exercise the real provider, manager, child replay, and Jotai storage with
+// controlled auth snapshots, network results, and a native transcript renderer stub.
+describe.each(['first', 'older'] as const)('SessionDetailScreen %s child-page scope', pageKind => {
+  it.each([
+    {
+      transition: 'root replacement',
+      change: () => {
+        useLocalSearchParamsMock.mockReturnValue({
+          'session-id': 'sess-2',
+          organizationId: 'org-a',
+        });
+      },
+    },
+    {
+      transition: 'context replacement',
+      change: () => {
+        useLocalSearchParamsMock.mockReturnValue({
+          'session-id': 'sess-1',
+          organizationId: 'org-b',
+        });
+      },
+    },
+    {
+      transition: 'account replacement before credential publication',
+      change: () => {
+        beginReplacement();
+      },
+    },
+    {
+      transition: 'account replacement after credential publication',
+      change: () => {
+        beginReplacement();
+        commitAccount('B');
+      },
+    },
+    {
+      transition: 'logout before credential cleanup',
+      change: () => {
+        authState.isSigningOut = true;
+        setSignOutActive(true);
+        beginAuthenticatedOwner();
+      },
+    },
+  ])('rejects deferred rows after $transition', async ({ change }) => {
+    const { renderer, current, request, resolvePage } = await startChildPage(pageKind);
+    act(change);
+    await updateRoute(renderer);
+    await act(async () => {
+      resolvePage(childPage('msg-account-a-late', 'Account A late row'));
+      await request;
+    });
+
+    // Keep both observations even when one fails: hidden content is not retired storage.
+    expect.soft(childIds(current)).not.toContain('msg-account-a-late');
+    expect.soft(transcriptText(renderer)).not.toContain('Account A');
+  });
+
+  it('keeps valid rows and accepts deferred rows during ordinary token refresh', async () => {
+    const { renderer, current, request, resolvePage } = await startChildPage(pageKind);
+    authState.token = 'account-a-refreshed-token';
+    await updateRoute(renderer);
+    await act(async () => {
+      resolvePage(childPage('msg-account-a-late', 'Account A late row'));
+      await request;
+    });
+
+    expect(transcriptText(renderer)).toContain('Account A late row');
+    expect(childIds(current)).toContain('msg-account-a-late');
+    if (pageKind === 'older') {
+      expect(transcriptText(renderer)).toContain('Account A cached row');
+    }
+  });
+});
+
+describe.each(['first', 'older'] as const)(
+  'SessionDetailScreen %s replacement sequence',
+  pageKind => {
+    it('retires the manager synchronously before React can unmount its route', async () => {
+      const { renderer, current, request, resolvePage } = await startChildPage(pageKind);
+      await act(async () => {
+        beginReplacement();
+        // Root rows exist in both cases, so this fails if retirement waits for React cleanup.
+        expect(current.store.get(current.manager.atoms.messagesList)).toEqual([]);
+        expect(childIds(current)).toEqual([]);
+        resolvePage(childPage('msg-account-a-late', 'Account A late row'));
+        await request;
+      });
+
+      expect(childIds(current)).toEqual([]);
+      expect(transcriptText(renderer)).toBe('');
+    });
+
+    it('retires the old owner while pending and initializes the committed successor', async () => {
+      const { renderer, current, request, resolvePage } = await startChildPage(pageKind);
+      const startedRequests = rootRequests.length;
+
+      // Pending ownership publishes while credential persistence still holds account A.
+      act(beginReplacement);
+      await updateRoute(renderer);
+      expect.soft(transcriptText(renderer, 'RootText')).not.toContain('Account A');
+      expect.soft(transcriptText(renderer)).not.toContain('Account A');
+      expect.soft(rootRequests.slice(startedRequests)).toEqual([]);
+
+      await act(async () => {
+        resolvePage(childPage('msg-account-a-late', 'Account A late row'));
+        await request;
+      });
+      expect.soft(childIds(current)).toEqual([]);
+      expect.soft(transcriptText(renderer)).not.toContain('Account A');
+
+      // A current getMe response confirms the committed credentials.
+      act(() => {
+        commitAccount('B');
+      });
+      await updateRoute(renderer);
+      expect.soft(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+
+      const successor = managers.at(-1);
+      if (successor && renderer.toJSON() !== null) {
+        childPageMock.mockResolvedValueOnce(
+          childPage('msg-account-b-current', 'Account B current row')
+        );
+        await act(async () => {
+          await successor.manager.hydrateChildSession(CHILD_ID);
+        });
+      }
+      expect.soft(childIds(current)).toEqual([]);
+      expect.soft(transcriptText(renderer)).toBe('Account B current row');
+
+      authState.token = 'account-b-refreshed-token';
+      await updateRoute(renderer);
+      expect.soft(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+      expect.soft(transcriptText(renderer)).toBe('Account B current row');
+    });
+  }
+);
+
+describe('SessionDetailScreen owner-scoped metadata and recovery', () => {
+  it('does not initialize a successor from the previous account metadata cache', async () => {
+    const actual = await vi.importActual<typeof ReactQuery>('@tanstack/react-query');
+    useQueryMock.mockImplementation(actual.useQuery);
+    const metadata = Promise.withResolvers<{ organization_id: string }>();
+    queryOptionsMock.mockImplementation(() => ({
+      queryKey: [['cliSessionsV2', 'get']],
+      queryFn: async () => {
+        const account = requestAccount;
+        await Promise.resolve();
+        return account === 'A' ? { organization_id: 'org-a' } : metadata.promise;
+      },
+    }));
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false, gcTime: Infinity } },
+    });
+    vi.useFakeTimers();
+    onTestFinished(() => {
+      client.clear();
+      vi.useRealTimers();
+    });
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
+    const tree = createElement(QueryClientProvider, { client }, createElement(SessionDetailScreen));
+    const renderer = await mountRoute(tree);
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(transcriptText(renderer, 'RootText')).toBe('Account A root row');
+    const requestsBeforeReplacement = rootRequests.length;
+
+    await act(async () => {
+      beginReplacement();
+      commitAccount('B');
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(transcriptText(renderer, 'RootText')).toBe('');
+    expect(rootRequests.slice(requestsBeforeReplacement)).toEqual([]);
+
+    await act(async () => {
+      metadata.resolve({ organization_id: 'org-b' });
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+  });
+
+  it('waits for current identity after credentials commit on a fresh mount', async () => {
+    beginReplacement();
+    requestAccount = 'B';
+    authState.token = 'account-b-token';
+    authState.isSigningOut = false;
+    setSignOutActive(false);
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1', organizationId: 'org-a' });
+    const renderer = await mountRoute();
+    expect(rootRequests).toEqual([]);
+    expect(transcriptText(renderer, 'RootText')).toBe('');
 
+    act(() => {
+      commitAccount('B');
+    });
+    await updateRoute(renderer);
+    expect(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+  });
+
+  it('keeps the existing retry action usable for a temporary metadata failure', async () => {
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
+    queryState.isError = true;
+    queryState.error = { data: { code: 'INTERNAL_SERVER_ERROR' } };
+    queryState.refetch.mockImplementation(async () => {
+      queryState.isError = false;
+      queryState.error = null;
+      await Promise.resolve();
+    });
+    const renderer = await mountRoute();
+    const error = findByType(renderer.root, 'QueryError')[0];
+    expect(propOf(error, 'variant')).toBe('server');
+    const retry = propOf(error, 'onRetry') as (() => void) | undefined;
+    if (!retry) {
+      throw new Error('temporary error lost its retry action');
+    }
+
+    act(retry);
+    await updateRoute(renderer);
+
+    expect(findByType(renderer.root, 'QueryError')).toHaveLength(0);
+    expect(transcriptText(renderer, 'RootText')).toBe('Account A root row');
+  });
+
+  it.each([
+    { code: 'NOT_FOUND', variant: 'not-found' },
+    { code: 'UNAUTHORIZED', variant: 'permission' },
+  ])('keeps $code terminal with no retry action', async ({ code, variant }) => {
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
+    queryState.isError = true;
+    queryState.error = { data: { code } };
+    const renderer = await mountRoute();
+    const error = findByType(renderer.root, 'QueryError')[0];
+
+    expect(propOf(error, 'variant')).toBe(variant);
+    expect(propOf(error, 'onRetry')).toBeUndefined();
+    expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
+    expect(findByType(renderer.root, 'Button')).toHaveLength(2);
+  });
+});
+
+describe('SessionDetailScreen fresh authentication scope', () => {
+  // Fresh mounts now consume the producer's pending/confirmed association, not token history.
+  it('starts no old-account work when first mounted during pending replacement', async () => {
+    beginReplacement();
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1', organizationId: 'org-a' });
+    const renderer = await mountRoute();
+
+    expect.soft(rootRequests).toEqual([]);
+    expect.soft(transcriptText(renderer, 'RootText')).toBe('');
+    expect.soft(transcriptText(renderer)).toBe('');
+
+    act(() => {
+      commitAccount('B');
+    });
+    await updateRoute(renderer);
+    expect.soft(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+  });
+
+  it('initializes current-account rows on a fresh mount and route re-entry', async () => {
+    beginReplacement();
+    commitAccount('A');
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1', organizationId: 'org-a' });
+    const renderer = await mountRoute();
+    expect(transcriptText(renderer, 'RootText')).toBe('Account A root row');
+    const previous = managers.at(-1);
+    if (!previous) {
+      throw new Error('route did not create a manager');
+    }
     act(() => {
       renderer.unmount();
     });
+    expect(previous.store.get(previous.manager.atoms.messagesList)).toEqual([]);
+
+    const reentered = await mountRoute();
+    expect(transcriptText(reentered, 'RootText')).toBe('Account A root row');
   });
 });
+
+function retryControl(renderer: TestRenderer.ReactTestRenderer) {
+  const retry = findByType(renderer.root, 'Pressable').find(
+    node => propOf(node, 'accessibilityLabel') === 'Retry'
+  );
+  if (!retry) {
+    throw new Error('confirmation Retry is missing');
+  }
+  return retry;
+}
+
+function pressControl(control: TestRenderer.ReactTestInstance | undefined) {
+  const onPress = propOf(control, 'onPress') as (() => void) | undefined;
+  if (!onPress) {
+    throw new Error('route control is not operable');
+  }
+  onPress();
+}
+
+describe.each([true, false])('SessionDetailScreen header return with history=%s', hasHistory => {
+  it.each([
+    { state: 'pending identity', source: 'identity', code: undefined },
+    { state: 'retryable identity failure', source: 'identity', code: 'INTERNAL_SERVER_ERROR' },
+    { state: 'pending metadata', source: 'metadata', code: undefined },
+    { state: 'retryable metadata failure', source: 'metadata', code: 'INTERNAL_SERVER_ERROR' },
+    { state: 'terminal missing session', source: 'metadata', code: 'NOT_FOUND' },
+    { state: 'terminal access denial', source: 'metadata', code: 'UNAUTHORIZED' },
+  ] as const)('leaves $state without admitting session data', async ({ source, code }) => {
+    if (hasHistory) {
+      navigationRoutes.unshift('previous-screen');
+    }
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
+    if (source === 'identity') {
+      beginReplacement();
+      commitCredentials('B');
+      if (code) {
+        confirmationRequests.getMe.mockRejectedValueOnce(new Error('offline'));
+      }
+    } else {
+      queryState.isPending = code === undefined;
+      queryState.isError = code !== undefined;
+      queryState.error = code ? { data: { code } } : null;
+    }
+    const renderer = await mountRoute();
+    expect(findByType(renderer.root, code ? 'QueryError' : 'SessionSkeletonMessages')).toHaveLength(
+      1
+    );
+    const back = findByType(renderer.root.findByType(ScreenHeader), 'Pressable').find(
+      node => propOf(node, 'accessibilityLabel') === 'Go back'
+    );
+    act(() => {
+      pressControl(back);
+    });
+
+    expect(navigationRoutes).toEqual(
+      hasHistory ? ['previous-screen'] : ['/(app)/(tabs)/(2_agents)']
+    );
+    expect(rootRequests).toEqual([]);
+  });
+});
+
+describe('SessionDetailScreen identity confirmation feedback', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    onTestFinished(() => {
+      vi.useRealTimers();
+    });
+    beginReplacement();
+    commitCredentials('B');
+    useLocalSearchParamsMock.mockReturnValue({ 'session-id': 'sess-1' });
+  });
+
+  it.each([undefined, 'org-a'])(
+    'shows the header and existing skeletons while identity is pending with organization %s',
+    async organizationId => {
+      useLocalSearchParamsMock.mockReturnValue({
+        'session-id': 'sess-1',
+        organizationId,
+        title: 'Account A private title',
+      });
+      const renderer = await mountRoute(
+        createElement(
+          'RouteAndSibling',
+          null,
+          createElement(SessionDetailScreen),
+          createElement('UnrelatedScreen')
+        )
+      );
+
+      const header = findByType(renderer.root, 'ScreenHeader')[0];
+      expect(propOf(header, 'title')).toBeTruthy();
+      expect(propOf(header, 'title')).not.toBe('Account A private title');
+      expect(findByType(renderer.root, 'SessionSkeletonMessages')).toHaveLength(1);
+      expect(findByType(renderer.root, 'SessionComposerSkeleton')).toHaveLength(1);
+      expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
+      expect(findByType(renderer.root, 'QueryError')).toHaveLength(0);
+      expect(
+        findByType(renderer.root, 'Pressable').filter(
+          node => propOf(node, 'accessibilityLabel') === 'Retry'
+        )
+      ).toHaveLength(0);
+      expect(findByType(renderer.root, 'UnrelatedScreen')).toHaveLength(1);
+      expect(transcriptText(renderer, 'RootText')).toBe('');
+      expect(rootRequests).toEqual([]);
+      expect(queryEnabled()).toBe(false);
+    }
+  );
+
+  it('keeps repeated failures recoverable and opens current root and child rows after user Retry', async () => {
+    const repeatedFailure = Promise.withResolvers<{ id: string }>();
+    const success = Promise.withResolvers<{ id: string }>();
+    confirmationRequests.getMe
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockReturnValueOnce(repeatedFailure.promise)
+      .mockReturnValueOnce(success.promise);
+    const renderer = await mountRoute();
+
+    expect(transcriptText(renderer)).toContain('Could not load your account');
+    expect(transcriptText(renderer)).toContain('Check your connection and try again.');
+    expect(propOf(retryControl(renderer), 'accessibilityState')).toMatchObject({
+      disabled: false,
+      busy: false,
+    });
+    act(() => {
+      pressControl(retryControl(renderer));
+    });
+    expect(findByType(renderer.root, 'QueryError')).toHaveLength(1);
+    expect(propOf(retryControl(renderer), 'disabled')).toBe(true);
+    expect(propOf(retryControl(renderer), 'accessibilityState')).toMatchObject({
+      disabled: true,
+      busy: true,
+    });
+    expect(findByType(renderer.root, 'ActivityIndicator')).toHaveLength(1);
+    expect(rootRequests).toEqual([]);
+
+    await act(async () => {
+      repeatedFailure.reject(new Error('still offline'));
+      await Promise.resolve();
+    });
+    expect(transcriptText(renderer)).toContain('Could not load your account');
+    expect(transcriptText(renderer)).toContain('Back to sessions');
+    expect(propOf(retryControl(renderer), 'accessibilityState')).toMatchObject({
+      disabled: false,
+      busy: false,
+    });
+    expect(transcriptText(renderer, 'RootText')).toBe('');
+    act(() => {
+      pressControl(retryControl(renderer));
+    });
+    expect(propOf(retryControl(renderer), 'accessibilityState')).toMatchObject({
+      disabled: true,
+      busy: true,
+    });
+    await act(async () => {
+      success.resolve({ id: 'user-B' });
+      await success.promise;
+    });
+
+    expect(getAuthenticatedOwner().userId).toBe('user-B');
+    expect(findByType(renderer.root, 'QueryError')).toHaveLength(0);
+    expect(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+    const current = managers.at(-1);
+    if (!current) {
+      throw new Error('confirmed route did not initialize its manager');
+    }
+    childPageMock.mockResolvedValueOnce(childPage('msg-current-child', 'Account B child row'));
+    await act(async () => {
+      await current.manager.hydrateChildSession(CHILD_ID);
+    });
+    expect(transcriptText(renderer)).toBe('Account B child row');
+  });
+
+  it('leaves failed confirmation through Back to sessions', async () => {
+    confirmationRequests.getMe.mockRejectedValueOnce(new Error('offline'));
+    const renderer = await mountRoute();
+    const back = findByType(renderer.root, 'Button').find(button =>
+      findByType(button, 'Text').some(text => text.children.includes('Back to sessions'))
+    );
+    act(() => {
+      pressControl(back);
+    });
+
+    expect(navigationRoutes).toEqual(['/(app)/(tabs)/(2_agents)']);
+    expect(rootRequests).toEqual([]);
+  });
+
+  it.each(['success', 'failure'] as const)(
+    'keeps successor feedback and ownership unchanged after retired identity %s',
+    async outcome => {
+      beginReplacement();
+      commitCredentials('A');
+      const retired = Promise.withResolvers<{ id: string }>();
+      const current = Promise.withResolvers<{ id: string }>();
+      confirmationRequests.getMe
+        .mockReturnValueOnce(retired.promise)
+        .mockReturnValueOnce(current.promise);
+      const renderer = await mountRoute();
+      act(beginReplacement);
+      commitCredentials('B');
+      await updateRoute(renderer);
+      const owner = getAuthenticatedOwner();
+      await act(async () => {
+        if (outcome === 'success') {
+          retired.resolve({ id: 'user-A' });
+        } else {
+          retired.reject(new Error('retired account failure'));
+        }
+        await Promise.resolve();
+      });
+
+      expect(getAuthenticatedOwner()).toBe(owner);
+      expect(owner.userId).toBeNull();
+      expect(findByType(renderer.root, 'ScreenHeader')).toHaveLength(1);
+      expect(findByType(renderer.root, 'SessionSkeletonMessages')).toHaveLength(1);
+      expect(findByType(renderer.root, 'QueryError')).toHaveLength(0);
+      expect(transcriptText(renderer, 'RootText')).toBe('');
+      expect(rootRequests).toEqual([]);
+      await act(async () => {
+        current.resolve({ id: 'user-B' });
+        await current.promise;
+      });
+      expect(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+      expect(findByType(renderer.root, 'QueryError')).toHaveLength(0);
+    }
+  );
+});
+
+describe.each([
+  { route: 'personal', organizationId: undefined },
+  { route: 'explicit organization', organizationId: 'org-a' },
+])('SessionDetailScreen title isolation on $route routes', ({ organizationId }) => {
+  it.each(['retained replacement', 'fresh pending mount'] as const)(
+    'does not restore an inherited title after %s confirms with delayed metadata',
+    async mountKind => {
+      const actual = await vi.importActual<typeof ReactQuery>('@tanstack/react-query');
+      useQueryMock.mockImplementation(actual.useQuery);
+      const routeMetadata = Promise.withResolvers<{ organization_id: string }>();
+      const sessionMetadata = Promise.withResolvers<undefined>();
+      const identity = Promise.withResolvers<{ id: string }>();
+      confirmationRequests.getMe.mockReturnValueOnce(identity.promise);
+      queryOptionsMock.mockImplementation(() => ({
+        queryKey: [['cliSessionsV2', 'get']],
+        queryFn: async () => {
+          const account = requestAccount;
+          await Promise.resolve();
+          return account === 'A' ? { organization_id: 'org-a' } : routeMetadata.promise;
+        },
+      }));
+      const client = new QueryClient({
+        defaultOptions: { queries: { retry: false, gcTime: Infinity } },
+      });
+      vi.useFakeTimers();
+      onTestFinished(() => {
+        client.clear();
+        vi.useRealTimers();
+      });
+      useLocalSearchParamsMock.mockReturnValue({
+        'session-id': 'sess-1',
+        organizationId,
+        title:
+          mountKind === 'fresh pending mount'
+            ? ['Account A private title']
+            : 'Account A private title',
+      });
+      const tree = createElement(
+        QueryClientProvider,
+        { client },
+        createElement(SessionDetailScreen)
+      );
+      if (mountKind === 'fresh pending mount') {
+        beginReplacement();
+        commitCredentials('B');
+        rootMetadataReady = sessionMetadata.promise;
+      }
+      const renderer = await mountRoute(tree);
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0);
+      });
+
+      if (mountKind === 'retained replacement') {
+        expect(propOf(findByType(renderer.root, 'ScreenHeader')[0], 'title')).toBe(
+          'Account A current title'
+        );
+        expect(transcriptText(renderer, 'RootText')).toBe('Account A root row');
+        await act(async () => {
+          rootMetadataReady = sessionMetadata.promise;
+          beginReplacement();
+          commitCredentials('B');
+          renderer.update(createElement(UserWebConnectionProvider, null, tree));
+          await vi.advanceTimersByTimeAsync(0);
+        });
+      }
+
+      expect(propOf(findByType(renderer.root, 'ScreenHeader')[0], 'title')).toBe('Session');
+      expect(findByType(renderer.root, 'SessionSkeletonMessages')).toHaveLength(1);
+      expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
+      expect(transcriptText(renderer, 'RootText')).toBe('');
+      await act(async () => {
+        identity.resolve({ id: 'user-B' });
+        await vi.advanceTimersByTimeAsync(0);
+      });
+
+      expect(getAuthenticatedOwner().userId).toBe('user-B');
+      expect.soft(propOf(findByType(renderer.root, 'ScreenHeader')[0], 'title')).toBe('Session');
+      if (organizationId === undefined) {
+        expect(findByType(renderer.root, 'SessionSkeletonMessages')).toHaveLength(1);
+        expect(findByType(renderer.root, 'SessionDetailContent')).toHaveLength(0);
+        await act(async () => {
+          routeMetadata.resolve({ organization_id: 'org-b' });
+          await vi.advanceTimersByTimeAsync(0);
+        });
+      }
+
+      // Explicit organization routes reach content without resolving the route metadata query.
+      const content = findByType(renderer.root, 'SessionDetailContent');
+      expect(content).toHaveLength(1);
+      expect.soft(propOf(content[0], 'cachedTitle')).toBeUndefined();
+      expect.soft(propOf(findByType(renderer.root, 'ScreenHeader')[0], 'title')).toBe('Session');
+      expect(transcriptText(renderer, 'RootText')).toBe('');
+      await act(async () => {
+        sessionMetadata.resolve(undefined);
+        await vi.advanceTimersByTimeAsync(0);
+      });
+
+      expect(propOf(findByType(renderer.root, 'ScreenHeader')[0], 'title')).toBe(
+        'Account B current title'
+      );
+      expect(transcriptText(renderer, 'RootText')).toBe('Account B root row');
+      act(() => {
+        authState.isSigningOut = true;
+        setSignOutActive(true);
+        beginAuthenticatedOwner();
+      });
+      expect(renderer.toJSON()).toBeNull();
+    }
+  );
+});
diff --git a/apps/mobile/src/app/(app)/agent-chat/[session-id].tsx b/apps/mobile/src/app/(app)/agent-chat/[session-id].tsx
index 1f05f083ed..bed3b37be3 100644
--- a/apps/mobile/src/app/(app)/agent-chat/[session-id].tsx
+++ b/apps/mobile/src/app/(app)/agent-chat/[session-id].tsx
@@ -1,8 +1,15 @@
 import { type KiloSessionId } from '@kilocode/cloud-agent-sdk';
 import { type Href, useLocalSearchParams, useRouter } from 'expo-router';
-import { useQuery } from '@tanstack/react-query';
+import { hashKey, useQuery } from '@tanstack/react-query';
 import { View } from 'react-native';
 import { useTranslation } from 'react-i18next';
+import { useSyncExternalStore } from 'react';
+
+import {
+  getAuthenticatedOwner,
+  isAuthenticatedOwner,
+  subscribeAuthenticatedOwner,
+} from '@/lib/context-scope';
 
 import { SessionDetailContent } from '@/components/agents/session-detail-content';
 import {
@@ -12,6 +19,7 @@ import {
 import { SessionConnectionIndicator } from '@/components/agents/session-connection-indicator';
 import { SessionContextMetrics } from '@/components/agents/session-context-metrics';
 import { AgentSessionProvider } from '@/components/agents/session-provider';
+import { useIdentityConfirmation } from '@/components/agents/user-web-connection-provider';
 import { buildTerminalErrorCopyText } from '@/components/agents/session-terminal-error';
 import { performCopy } from '@/components/agents/use-message-copy';
 import { InvalidRouteState } from '@/components/invalid-route-state';
@@ -25,6 +33,10 @@ import { shouldRetryNotFoundOnSpawnedRoute } from '@/lib/spawned-not-found-retry
 import { useTRPC } from '@/lib/trpc';
 
 export default function SessionDetailScreen() {
+  const owner = useSyncExternalStore(subscribeAuthenticatedOwner, getAuthenticatedOwner);
+  const confirmation = useIdentityConfirmation();
+  const identityPending = !isAuthenticatedOwner(owner);
+  const identityFailed = identityPending && confirmation.isError;
   const {
     'session-id': rawSessionId,
     organizationId: routeOrganizationId,
@@ -33,7 +45,6 @@ export default function SessionDetailScreen() {
     shareId: shareIdParam,
     autoSend: autoSendRaw,
     mode: modeParam,
-    title: titleParam,
   } = useLocalSearchParams<{
     'session-id': string;
     organizationId?: string;
@@ -53,7 +64,7 @@ export default function SessionDetailScreen() {
     autoSend?: string;
     /** Agent mode the spawn was started with; seeds the composer before the CLI reports one. */
     mode?: string;
-    /** Title the list row already showed; paints the header on the first frame. */
+    /** Legacy title hints remain accepted but carry no account ownership, so ignore them. */
     title?: string;
   }>();
   // `session-id` is required: a malformed deep link can hand us `undefined`
@@ -64,10 +75,6 @@ export default function SessionDetailScreen() {
   const shareId = Array.isArray(shareIdParam) ? shareIdParam[0] : shareIdParam;
   const autoSendParam = Array.isArray(autoSendRaw) ? autoSendRaw[0] : autoSendRaw;
   const spawnedMode = Array.isArray(modeParam) ? modeParam[0] : modeParam;
-  // The row the user tapped already showed this title, so the header opens
-  // with it instead of a generic label that swaps a beat later. Deep links
-  // and push opens carry no title and keep the fallback.
-  const cachedTitle = Array.isArray(titleParam) ? titleParam[0] : titleParam;
   const trpc = useTRPC();
   const router = useRouter();
   const { t } = useTranslation();
@@ -103,20 +110,31 @@ export default function SessionDetailScreen() {
         retryDelay: 1000,
       }
     ),
-    enabled: routeOrganizationId === undefined && sessionId !== null,
+    // Isolate account metadata while preserving the typed tRPC key and prefix invalidation.
+    queryHash: hashKey([
+      ...trpc.cliSessionsV2.get.queryKey({ session_id: sessionId ?? '' }),
+      owner.authEpoch,
+      owner.generation,
+      owner.userId,
+    ]),
+    enabled: isAuthenticatedOwner(owner) && routeOrganizationId === undefined && sessionId !== null,
   });
 
   if (sessionId === null) {
     return <InvalidRouteState backTo={'/(app)' as Href} />;
   }
 
-  if (routeOrganizationId === undefined && sessionQuery.isPending) {
+  if (
+    !identityFailed &&
+    (identityPending || (routeOrganizationId === undefined && sessionQuery.isPending))
+  ) {
     // The composer placeholder holds its own height: nothing may shift when
-    // the query resolves.
+    // the query resolves. Route title hints are not bound to an account.
     return (
       <View className="flex-1 bg-background">
         <ScreenHeader
-          title={cachedTitle ?? t('agentChat.session.title')}
+          title={t('agentChat.session.title')}
+          backFallback="/(app)/(tabs)/(2_agents)"
           headerRight={
             <SessionContextMetrics
               info={undefined}
@@ -133,17 +151,25 @@ export default function SessionDetailScreen() {
     );
   }
 
-  if (routeOrganizationId === undefined && sessionQuery.isError) {
+  if (identityFailed || (routeOrganizationId === undefined && sessionQuery.isError)) {
     // A NOT_FOUND (e.g. the stored session was deleted) or UNAUTHORIZED
     // (org-access denial) can't be recovered by retrying — show a permanent
     // state with no Retry. Other errors stay transient and retriable. All
     // get Back and Copy.
-    const errorCode = sessionQuery.error.data?.code;
+    const errorCode = identityFailed ? undefined : sessionQuery.error?.data?.code;
     const notFound = errorCode === 'NOT_FOUND';
     const unauthorized = errorCode === 'UNAUTHORIZED';
-    let title = t('agentChat.session.couldNotLoad');
-    let message = t('agentChat.session.failedToLoadDetails');
-    let variant: 'not-found' | 'permission' | 'server' = 'server';
+    let title = t(
+      identityFailed ? 'bootstrap.couldNotLoadAccount' : 'agentChat.session.couldNotLoad'
+    );
+    let message = t(
+      identityFailed
+        ? 'bootstrap.couldNotLoadAccountDescription'
+        : 'agentChat.session.failedToLoadDetails'
+    );
+    let variant: 'neutral' | 'not-found' | 'permission' | 'server' = identityFailed
+      ? 'neutral'
+      : 'server';
     if (notFound) {
       title = t('agentChat.session.notFound');
       message = t('agentChat.session.notFoundDescription');
@@ -153,10 +179,14 @@ export default function SessionDetailScreen() {
       message = t('agentChat.session.accessDeniedDescription');
       variant = 'permission';
     }
+    const retry = identityFailed ? confirmation.retry : () => void sessionQuery.refetch();
     const copyText = buildTerminalErrorCopyText({ sessionId, title, message });
     return (
       <View className="flex-1 bg-background">
-        <ScreenHeader title={t('agentChat.session.title')} />
+        <ScreenHeader
+          title={t('agentChat.session.title')}
+          backFallback="/(app)/(tabs)/(2_agents)"
+        />
         <SessionConnectionIndicator />
         <View className="flex-1 items-center justify-center gap-3 px-6">
           <QueryError
@@ -165,8 +195,8 @@ export default function SessionDetailScreen() {
             className="px-0 pt-0"
             title={title}
             message={message}
-            onRetry={notFound || unauthorized ? undefined : () => void sessionQuery.refetch()}
-            isRetrying={sessionQuery.isFetching}
+            onRetry={notFound || unauthorized ? undefined : retry}
+            isRetrying={identityFailed ? confirmation.isPending : sessionQuery.isFetching}
           />
           <View className="flex-row gap-3">
             <Button
@@ -196,12 +226,11 @@ export default function SessionDetailScreen() {
 
   return (
     <AgentSessionProvider
-      key={`${sessionId}:${organizationId ?? 'personal'}`}
+      key={`${owner.generation}:${owner.userId}:${sessionId}:${organizationId ?? 'personal'}`}
       organizationId={organizationId}
     >
       <SessionDetailContent
         sessionId={sessionId as KiloSessionId}
-        cachedTitle={cachedTitle}
         openedVia={via === 'push' ? 'push' : 'app'}
         shareId={shareId}
         autoSend={autoSendParam === '1'}
diff --git a/apps/mobile/src/components/agents/child-session-card-state.test.ts b/apps/mobile/src/components/agents/child-session-card-state.test.ts
index f0b28a1043..dc81528f1c 100644
--- a/apps/mobile/src/components/agents/child-session-card-state.test.ts
+++ b/apps/mobile/src/components/agents/child-session-card-state.test.ts
@@ -105,6 +105,29 @@ function makeAssistantMessage(parts: Part[], id = 'msg-1'): StoredMessage {
 }
 
 describe('getChildSessionCardState', () => {
+  it.each([
+    ['pending', 'Waiting for activity'],
+    ['running', 'Waiting for activity'],
+    ['completed', ''],
+    ['error', ''],
+  ] as const)(
+    'keeps a %s task useful without child transcript enrichment',
+    (status, latestActivity) => {
+      const part = makeTaskPart(status, {
+        subagent_type: 'Researcher',
+        description: 'Review access rules',
+        prompt: 'Read the access configuration before proposing changes.',
+      });
+      for (const messages of [[], [makeAssistantMessage([])]]) {
+        expect(getChildSessionCardState(part, messages)).toEqual({
+          agentName: 'Researcher',
+          taskName: 'Review access rules',
+          latestActivity,
+        });
+      }
+    }
+  );
+
   it('falls back to Subagent / Task / Waiting for activity for a pending task with empty input', () => {
     const part = makeTaskPart('pending');
     expect(getChildSessionCardState(part, [])).toEqual({
@@ -129,26 +152,33 @@ describe('getChildSessionCardState', () => {
     expect(state.taskName).toBe(`${'a'.repeat(60)}\u2026`);
   });
 
-  it('reads a completed read tool from child messages and derives its filename context', () => {
-    const part = makeTaskPart('running', {
-      subagent_type: 'Researcher',
-      description: 'Check spec',
-    });
-    const readPart = makeToolPart('read', {
-      status: 'completed',
-      input: { filePath: '/project/docs/spec.md' },
-      output: 'content',
-      title: 'read',
-      metadata: {},
-      time: { start: 1, end: 2 },
-    });
-    const messages = [makeAssistantMessage([readPart])];
-    expect(getChildSessionCardState(part, messages)).toEqual({
-      agentName: 'Researcher',
-      taskName: 'Check spec',
-      latestActivity: { tool: 'read', context: 'spec.md' },
-    });
-  });
+  it.each(['running', 'completed', 'error'] as const)(
+    'uses the %s task status to control loaded read activity and its label',
+    status => {
+      const part = makeTaskPart(status, {
+        subagent_type: 'Researcher',
+        description: 'Check spec',
+      });
+      const readPart = makeToolPart('read', {
+        status: 'completed',
+        input: { filePath: '/project/docs/spec.md' },
+        output: 'content',
+        title: 'read',
+        metadata: {},
+        time: { start: 1, end: 2 },
+      });
+      const messages = [makeAssistantMessage([readPart])];
+      const state = getChildSessionCardState(part, messages);
+      expect(state).toEqual({
+        agentName: 'Researcher',
+        taskName: 'Check spec',
+        latestActivity: status === 'running' ? { tool: 'read', context: 'spec.md' } : '',
+      });
+      expect(getChildSessionActivityLabel(state.latestActivity)).toBe(
+        status === 'running' ? 'read spec.md' : ''
+      );
+    }
+  );
 
   it('keeps the latest completed or errored tool when it supersedes an older running tool', () => {
     const part = makeTaskPart('running', { subagent_type: 'Builder', description: 'Fix bug' });
@@ -271,15 +301,18 @@ describe('getChildSessionCardState', () => {
     });
   });
 
-  it('shows live text activity when the latest assistant part is a text part', () => {
-    const part = makeTaskPart('running', { subagent_type: 'Writer', description: 'Draft reply' });
-    const messages = [makeAssistantMessage([makeTextPart('Here is the answer.')])];
-    expect(getChildSessionCardState(part, messages)).toEqual({
-      agentName: 'Writer',
-      taskName: 'Draft reply',
-      latestActivity: 'Writing response',
-    });
-  });
+  it.each(['running', 'completed', 'error'] as const)(
+    'uses the %s task status to control loaded text activity',
+    status => {
+      const part = makeTaskPart(status, { subagent_type: 'Writer', description: 'Draft reply' });
+      const messages = [makeAssistantMessage([makeTextPart('Here is the answer.')])];
+      expect(getChildSessionCardState(part, messages)).toEqual({
+        agentName: 'Writer',
+        taskName: 'Draft reply',
+        latestActivity: status === 'running' ? 'Writing response' : '',
+      });
+    }
+  );
 
   it('shows live reasoning activity when the latest assistant part is a reasoning part', () => {
     const part = makeTaskPart('running', { subagent_type: 'Thinker', description: 'Reason' });
diff --git a/apps/mobile/src/components/agents/child-session-sheet-recovery.mounted.test.tsx b/apps/mobile/src/components/agents/child-session-sheet-recovery.mounted.test.tsx
new file mode 100644
index 0000000000..9de5cff685
--- /dev/null
+++ b/apps/mobile/src/components/agents/child-session-sheet-recovery.mounted.test.tsx
@@ -0,0 +1,293 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer mounts the native tree without a DOM. */
+import { createElement, Fragment } from 'react';
+import { act } from 'react-test-renderer';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  buildProps,
+  createRecoverySource,
+  historyPage,
+  host,
+  makeAssistantMessage,
+  modal,
+  readyState,
+  renderSheet,
+  retryButton,
+  type SheetProps,
+  textValues,
+  updateSheet,
+  viewport,
+} from './child-session-sheet-test-helpers';
+import {
+  type KiloSessionId,
+  type SessionManagerConfig,
+  type SessionSnapshotPageOutcome,
+  type StoredMessage,
+} from '@kilocode/cloud-agent-sdk';
+import { type FlashListProps } from '@shopify/flash-list';
+import { type NativeScrollEvent, type NativeSyntheticEvent } from 'react-native';
+import { QueryError } from '@/components/query-error';
+import { i18n } from '@/i18n';
+
+async function mountRecovery(messages = [makeAssistantMessage()]) {
+  const fetchPage = vi
+    .fn<NonNullable<SessionManagerConfig['fetchSnapshotPage']>>()
+    .mockRejectedValue(new Error('Connection failed. Please retry in a moment.'));
+  const { manager, store, storage } = await createRecoverySource(fetchPage);
+  function receive(message: StoredMessage) {
+    storage.upsertMessage(message.info);
+    for (const part of message.parts) {
+      storage.upsertPart(message.info.id, part);
+    }
+  }
+  for (const message of messages) {
+    receive(message);
+  }
+  const childId = 'child-1' as KiloSessionId;
+  let pending = manager.hydrateChildSession(childId);
+  await pending;
+  const props = {
+    ...buildProps({
+      getChildMessages: store.get(manager.atoms.childMessages),
+      hydrationState: store.get(manager.atoms.childSessionHydrationState)(childId),
+    }),
+    onRetry: () => {
+      pending = manager.hydrateChildSession(props.sessionId as KiloSessionId);
+    },
+    onLoadOlderMessages: () => {
+      pending = manager.loadOlderChildMessages(props.sessionId as KiloSessionId);
+    },
+    onClose: () => {
+      props.visible = false;
+    },
+    onDismiss: () => {
+      renderer.update(createElement(Fragment));
+    },
+  };
+  const renderer = await renderSheet(props);
+  async function sync(next: Partial<SheetProps> = {}) {
+    Object.assign(props, next);
+    props.getChildMessages = store.get(manager.atoms.childMessages);
+    const state = store.get(manager.atoms.childSessionHydrationState)(props.sessionId);
+    props.hydrationState = state;
+    props.hasOlderMessages = state.status === 'ready' && state.hasOlder;
+    props.isLoadingOlderMessages = state.status === 'ready' && state.isLoadingOlder;
+    props.olderMessagesError = state.status === 'ready' ? state.olderError : null;
+    await updateSheet(renderer, props);
+  }
+  async function retry(count = 1) {
+    const press = retryButton(renderer.root).props.onPress as () => void;
+    await act(async () => {
+      for (let index = 0; index < count; index += 1) {
+        press();
+      }
+      await Promise.resolve();
+    });
+    await sync();
+  }
+  async function settle() {
+    await pending;
+    await sync();
+  }
+  async function wait() {
+    await pending;
+  }
+  return { renderer, manager, fetchPage, receive, sync, retry, settle, wait };
+}
+
+describe('ChildSessionSheet recovery', () => {
+  it('keeps rows, Retry, and the viewport through pending duplicates, another failure, and a deduplicated success', async () => {
+    const sheet = await mountRecovery();
+    const { renderer, fetchPage } = sheet;
+    const list = host(renderer.root, 'FlashList');
+    const button = retryButton(renderer.root);
+    const listProps = list.props as FlashListProps<StoredMessage>;
+    const scrollEvent = {
+      nativeEvent: {
+        contentOffset: { y: 320 },
+        contentSize: { height: 2000 },
+        layoutMeasurement: { height: 400 },
+      },
+    };
+    await act(async () => {
+      const event = scrollEvent as NativeSyntheticEvent<NativeScrollEvent>;
+      listProps.onScrollBeginDrag?.(event);
+      viewport.offset = 320;
+      listProps.onScrollEndDrag?.(event);
+      await vi.advanceTimersByTimeAsync(1000);
+    });
+    const failure = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    fetchPage.mockReturnValueOnce(failure.promise);
+    // Both presses arrive before React commits the disabled state.
+    await sheet.retry(2);
+    expect(retryButton(renderer.root)).toBe(button);
+    expect(button.props.disabled).toBe(true);
+    expect(button.props.accessibilityState).toEqual({ disabled: true, busy: true });
+    expect(textValues(renderer.root)).toContain('Connection failed. Please retry in a moment.');
+    sheet.receive(makeAssistantMessage('m2', 'Live arrival'));
+    await sheet.sync();
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1000);
+    });
+    expect(button.props.accessibilityState).toEqual({ disabled: true, busy: true });
+    expect(textValues(list)).toEqual(['child text', 'Live arrival']);
+    expect(host(renderer.root, 'FlashList')).toBe(list);
+    expect(viewport.offset).toBe(320);
+    failure.reject(new Error('fetch failed'));
+    await sheet.settle();
+    expect(textValues(renderer.root)).toContain('Connection lost. Please retry in a moment.');
+    expect(button.props.accessibilityState).toEqual({ disabled: false, busy: false });
+    expect(host(renderer.root, 'FlashList')).toBe(list);
+    expect(viewport.offset).toBe(320);
+
+    const success = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    fetchPage.mockReturnValueOnce(success.promise);
+    await sheet.retry();
+    expect(retryButton(renderer.root)).toBe(button);
+    expect(button.props.accessibilityState).toEqual({ disabled: true, busy: true });
+    expect(textValues(renderer.root)).toContain('Connection lost. Please retry in a moment.');
+    success.resolve(
+      historyPage([
+        makeAssistantMessage('m0', 'Older history'),
+        makeAssistantMessage('m1', 'Complete child text'),
+      ])
+    );
+    await sheet.settle();
+    expect(textValues(list)).toEqual(['Older history', 'Complete child text', 'Live arrival']);
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    expect(host(renderer.root, 'FlashList')).toBe(list);
+    expect(viewport.offset).toBe(320);
+  });
+
+  it('allows dismissal during Retry without reopening on a late success', async () => {
+    const sheet = await mountRecovery();
+    const { renderer } = sheet;
+    const pending = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    sheet.fetchPage.mockReturnValueOnce(pending.promise);
+    await sheet.retry();
+    const list = host(renderer.root, 'FlashList');
+    await act(async () => {
+      (host(renderer.root, 'SheetHeader').props.onDone as () => void)();
+      await Promise.resolve();
+    });
+    await sheet.sync();
+    expect(modal(renderer.root).props.visible).toBe(false);
+    expect(host(renderer.root, 'FlashList')).toBe(list);
+    expect(textValues(list)).toEqual(['child text']);
+    await act(async () => {
+      (modal(renderer.root).props.onDismiss as () => void)();
+      await Promise.resolve();
+    });
+    pending.resolve(historyPage([makeAssistantMessage('m0', 'Recovered while closed')]));
+    await sheet.wait();
+    expect(renderer.toJSON()).toBeNull();
+    await sheet.sync({ visible: true });
+    expect(textValues(host(renderer.root, 'FlashList'))).toEqual([
+      'Recovered while closed',
+      'child text',
+    ]);
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(0);
+  });
+
+  it('does not carry the previous child error into a selected child with pending history', async () => {
+    const sheet = await mountRecovery();
+    const first = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    sheet.fetchPage.mockReturnValueOnce(first.promise);
+    await sheet.retry();
+    sheet.receive(makeAssistantMessage('m3', 'Selected child text', 'child-2'));
+    const second = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    sheet.fetchPage.mockReturnValueOnce(second.promise);
+    const secondHydration = sheet.manager.hydrateChildSession('child-2' as KiloSessionId);
+    await sheet.sync({ sessionId: 'child-2', title: 'Selected child' });
+    expect(sheet.renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    first.reject(new Error('Previous child failed again'));
+    await sheet.settle();
+    expect(textValues(host(sheet.renderer.root, 'FlashList'))).toEqual(['Selected child text']);
+    expect(sheet.renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    expect(host(sheet.renderer.root, 'SheetHeader').props.title).toBe('Selected child');
+    second.resolve(historyPage([], null, 'child-2'));
+    await secondHydration;
+    await sheet.sync();
+    expect(textValues(host(sheet.renderer.root, 'FlashList'))).toEqual(['Selected child text']);
+  });
+
+  it('recovers first-page and older-page errors independently without clearing the runtime error', async () => {
+    const sheet = await mountRecovery();
+    const { renderer } = sheet;
+    const list = host(renderer.root, 'FlashList');
+    await sheet.sync({ sessionError: 'Runtime failure' });
+    expect(textValues(renderer.root)).toEqual(
+      expect.arrayContaining(['Connection failed. Please retry in a moment.', 'Runtime failure'])
+    );
+    sheet.fetchPage.mockResolvedValueOnce(historyPage([], 'older-cursor'));
+    await sheet.retry();
+    await sheet.settle();
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    await sheet.manager.loadOlderChildMessages('child-1' as KiloSessionId);
+    await sheet.sync();
+    expect(textValues(renderer.root)).toContain(i18n.t('agentChat.olderMessages.couldNotLoad'));
+    const older = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    sheet.fetchPage.mockReturnValueOnce(older.promise);
+    await sheet.retry();
+    expect(textValues(renderer.root)).toContain('Runtime failure');
+    expect(textValues(renderer.root)).toContain(i18n.t('agentChat.olderMessages.couldNotLoad'));
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    older.resolve(historyPage([makeAssistantMessage('m0', 'Older recovered row')]));
+    await sheet.settle();
+    expect(textValues(list)).toEqual(['Older recovered row', 'child text']);
+    expect(textValues(renderer.root)).toContain('Runtime failure');
+    expect(textValues(renderer.root)).not.toContain('Retry');
+    expect(host(renderer.root, 'FlashList')).toBe(list);
+  });
+
+  it.each([
+    ['invalid_data', 'agentChat.olderMessages.unavailable'],
+    ['too_large', 'agentChat.olderMessages.tooLarge'],
+  ] as const)('keeps %s older-page errors non-retryable beside cached rows', async (kind, key) => {
+    const sheet = await mountRecovery();
+    sheet.fetchPage.mockResolvedValueOnce(historyPage([], 'older-cursor'));
+    await sheet.retry();
+    await sheet.settle();
+    sheet.fetchPage.mockResolvedValueOnce({ kind });
+    await sheet.manager.loadOlderChildMessages('child-1' as KiloSessionId);
+    await sheet.sync();
+    expect(textValues(sheet.renderer.root)).toContain(i18n.t(key));
+    expect(textValues(sheet.renderer.root)).toContain('child text');
+    expect(textValues(sheet.renderer.root)).not.toContain('Retry');
+    expect(sheet.renderer.root.findAllByType(QueryError)).toHaveLength(0);
+  });
+
+  it('preserves uncached Retry, loading, confirmed empty history, and later live content', async () => {
+    const sheet = await mountRecovery([]);
+    expect(textValues(sheet.renderer.root)).toContain(
+      'Connection failed. Please retry in a moment.'
+    );
+    expect(retryButton(sheet.renderer.root).props.disabled).toBe(false);
+    const pending = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+    sheet.fetchPage.mockReturnValueOnce(pending.promise);
+    await sheet.retry();
+    expect(textValues(sheet.renderer.root)).toContain(
+      i18n.t('agentChat.childSessionSheet.loading')
+    );
+    expect(sheet.renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    pending.resolve(historyPage());
+    await sheet.settle();
+    expect(textValues(sheet.renderer.root)).toContain(
+      i18n.t('agentChat.childSessionSheet.noMessages')
+    );
+    sheet.receive(makeAssistantMessage('m1', 'First live row'));
+    await sheet.sync();
+    expect(textValues(host(sheet.renderer.root, 'FlashList'))).toEqual(['First live row']);
+    expect(textValues(sheet.renderer.root)).not.toContain(
+      i18n.t('agentChat.childSessionSheet.noMessages')
+    );
+  });
+
+  it('does not give an uncached runtime error a hydration Retry', async () => {
+    const renderer = await renderSheet({
+      ...buildProps({ getChildMessages: () => [], hydrationState: readyState }),
+      sessionError: 'Runtime failure',
+    });
+    expect(textValues(renderer.root)).toContain('Runtime failure');
+    expect(textValues(renderer.root)).not.toContain('Retry');
+  });
+});
diff --git a/apps/mobile/src/components/agents/child-session-sheet-state.test.ts b/apps/mobile/src/components/agents/child-session-sheet-state.test.ts
index 33845fe6f7..cd6690c289 100644
--- a/apps/mobile/src/components/agents/child-session-sheet-state.test.ts
+++ b/apps/mobile/src/components/agents/child-session-sheet-state.test.ts
@@ -55,10 +55,14 @@ describe('getChildSessionSheetState', () => {
     expect(getChildSessionSheetState({ status: 'error', message: 'Failed' }, 0)).toBe('error');
   });
 
-  it('keeps rendering messages if a refresh fails', () => {
+  it('keeps live messages visible after first-page hydration fails', () => {
     expect(getChildSessionSheetState({ status: 'error', message: 'Failed' }, 1)).toBe('content');
   });
 
+  it('keeps live messages visible while first-page hydration retries', () => {
+    expect(getChildSessionSheetState({ status: 'loading' }, 2)).toBe('content');
+  });
+
   it('shows an error for a runtime error with no messages and hydration ready', () => {
     expect(
       getChildSessionSheetState(
diff --git a/apps/mobile/src/components/agents/child-session-sheet-test-helpers.tsx b/apps/mobile/src/components/agents/child-session-sheet-test-helpers.tsx
new file mode 100644
index 0000000000..5b8ea67c00
--- /dev/null
+++ b/apps/mobile/src/components/agents/child-session-sheet-test-helpers.tsx
@@ -0,0 +1,327 @@
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest. */
+import { type ComponentProps, createElement, type ReactNode } from 'react';
+import { type FlashListProps } from '@shopify/flash-list';
+import TestRenderer, { act } from 'react-test-renderer';
+import { afterEach, beforeEach, vi } from 'vitest';
+
+import {
+  type ChildSessionHydrationState,
+  createSessionManager,
+  createUserWebConnection,
+  type KiloSessionId,
+  type SessionManager,
+  type SessionManagerConfig,
+  type SessionSnapshotPageOutcome,
+  type StoredMessage,
+} from '@kilocode/cloud-agent-sdk';
+import { createJotaiStorage } from '@kilocode/cloud-agent-sdk/storage/jotai';
+import { createStore } from 'jotai';
+import { type SessionModelOption } from '@/lib/hooks/use-session-model-options';
+
+import { ChildSessionSheet } from './child-session-sheet';
+
+const reactNativeMock = vi.hoisted(() => ({
+  Keyboard: { addListener: vi.fn(() => ({ remove: vi.fn() })) },
+  Platform: { OS: 'ios' as string },
+  useWindowDimensions: vi.fn(() => ({ width: 390, height: 844 })),
+}));
+const safeAreaMock = vi.hoisted(() => ({
+  useSafeAreaInsets: vi.fn(() => ({ top: 0, bottom: 0, left: 0, right: 0 })),
+}));
+export { reactNativeMock, safeAreaMock };
+
+vi.mock('react-native', () => ({
+  Modal: 'Modal',
+  View: 'View',
+  Pressable: 'Pressable',
+  ActivityIndicator: 'ActivityIndicator',
+  AccessibilityInfo: { announceForAccessibility: vi.fn() },
+  ...reactNativeMock,
+}));
+vi.mock('react-native-reanimated', () => ({
+  default: { View: 'AnimatedView' },
+  LinearTransition: { duration: () => ({}) },
+  FadeIn: { duration: () => ({}) },
+  FadeOut: { duration: () => ({}) },
+  useReducedMotion: () => false,
+}));
+vi.mock('react-native-safe-area-context', () => ({
+  useSafeAreaInsets: safeAreaMock.useSafeAreaInsets,
+}));
+// The real text component loads slot's untransformed JSX. Keep its context
+// so the real Button and its accessibility state still render here.
+vi.mock('@/components/ui/text', async () => {
+  const React = await import('react');
+  return {
+    Text: 'Text',
+    TextClassContext: React.createContext<string | undefined>(undefined),
+  };
+});
+vi.mock('@/components/ui/icons', () => ({
+  Bot: 'Bot',
+  ChevronRight: 'ChevronRight',
+  ChevronDown: 'ChevronDown',
+  Loader2: 'Loader2',
+  AlertCircle: 'AlertCircle',
+  Check: 'Check',
+  Lock: 'Lock',
+  SearchX: 'SearchX',
+  ServerCrash: 'ServerCrash',
+  WifiOff: 'WifiOff',
+}));
+vi.mock('@/components/ui/spinning-icon', () => ({
+  SpinningIcon: 'SpinningIcon',
+}));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({
+  useThemeColors: () => ({}),
+}));
+vi.mock('@shopify/flash-list', async () => {
+  const React = await import('react');
+  return {
+    FlashList: (props: FlashListProps<StoredMessage>) =>
+      React.createElement(
+        'FlashList',
+        props,
+        props.ListHeaderComponent as ReactNode,
+        props.data?.map((item, index) =>
+          React.createElement(
+            React.Fragment,
+            { key: props.keyExtractor?.(item, index) },
+            props.renderItem?.({ item, index, target: 'Cell' })
+          )
+        ),
+        props.ListFooterComponent as ReactNode
+      ),
+  };
+});
+vi.mock('./part-detail-sheet-host', () => ({
+  PartDetailSheetHost: ({ children }: { children?: unknown }) => children,
+}));
+vi.mock('./working-indicator', () => ({
+  WorkingIndicator: () => null,
+}));
+vi.mock('./message-error-boundary', () => ({
+  MessageErrorBoundary: ({ children }: { children?: unknown }) => children,
+}));
+vi.mock('@/components/sheet-header', () => ({
+  SheetHeader: 'SheetHeader',
+}));
+
+const modelOption: SessionModelOption = {
+  id: 'kilo/model',
+  name: 'Test Model',
+  displayId: 'model',
+  variants: [],
+  isPreferred: false,
+  showGatewayMetadata: false,
+  provider: { id: 'kilo', name: 'Kilo' },
+  modelRef: { providerID: 'kilo', modelID: 'model' },
+};
+
+export function makeAssistantMessage(
+  id = 'm1',
+  text = 'child text',
+  sessionID = 'child-1'
+): StoredMessage {
+  return {
+    info: {
+      id,
+      sessionID,
+      role: 'assistant',
+      time: { created: 1 },
+      parentID: 'm0',
+      modelID: 'model',
+      providerID: 'kilo',
+      mode: 'code',
+      agent: 'build',
+      path: { cwd: '/', root: '/' },
+      cost: 0,
+      tokens: { total: 0, input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    },
+    parts: [{ id: `text-${id}`, sessionID, messageID: id, type: 'text', text }],
+  };
+}
+
+export const readyState: ChildSessionHydrationState = {
+  status: 'ready',
+  cursor: null,
+  hasOlder: false,
+  isLoadingOlder: false,
+  olderError: null,
+  omittedItemCount: 0,
+};
+export const errorState: ChildSessionHydrationState = { status: 'error', message: 'Failed' };
+
+export type SheetProps = ComponentProps<typeof ChildSessionSheet>;
+
+export function buildProps({
+  getChildMessages,
+  hydrationState,
+}: Pick<SheetProps, 'getChildMessages' | 'hydrationState'>): SheetProps {
+  return {
+    visible: true,
+    sessionId: 'child-1',
+    title: 'Subagent',
+    getChildMessages,
+    hydrationState,
+    sessionError: null,
+    isStreaming: false,
+    hasOlderMessages: false,
+    isLoadingOlderMessages: false,
+    olderMessagesError: null,
+    olderMessagesOmittedItemCount: 0,
+    onLoadOlderMessages: vi.fn<() => void>(),
+    renderPart: ({ part }) =>
+      part.type === 'text' ? createElement('Text', null, part.text) : null,
+    onOpenChildSession: vi.fn<(sessionId: string, title: string) => void>(),
+    onRetry: vi.fn<() => void>(),
+    onClose: vi.fn<() => void>(),
+    modelOptions: [modelOption],
+  };
+}
+
+// Observe the manager's real storage without replacing its replay or deduplication.
+vi.mock('@kilocode/cloud-agent-sdk/storage/jotai', { spy: true });
+const managers: SessionManager[] = [];
+
+export function historyPage(
+  messages: StoredMessage[] = [],
+  nextCursor: string | null = null,
+  sessionId = 'child-1'
+): SessionSnapshotPageOutcome {
+  return { kind: 'success', info: { id: sessionId }, messages, nextCursor, omittedItemCount: 0 };
+}
+
+export async function createRecoverySource(
+  fetchPage: NonNullable<SessionManagerConfig['fetchSnapshotPage']>
+) {
+  const store = createStore();
+  const rootId = 'root' as KiloSessionId;
+  const userWebConnection = createUserWebConnection({ websocketUrl: '', getAuthToken: () => '' });
+  // The read-only root uses only the upgrade watcher's subscription methods.
+  vi.spyOn(userWebConnection, 'subscribeToCliSession').mockReturnValue(vi.fn<() => void>());
+  vi.spyOn(userWebConnection, 'onSystemEvent').mockReturnValue(vi.fn<() => void>());
+  const api = {};
+  const manager = createSessionManager({
+    store,
+    resolveSession: vi.fn<SessionManagerConfig['resolveSession']>().mockResolvedValue({
+      type: 'read-only',
+      kiloSessionId: rootId,
+    }),
+    fetchSession: vi.fn<SessionManagerConfig['fetchSession']>().mockResolvedValue({
+      kiloSessionId: rootId,
+      cloudAgentSessionId: null,
+      title: 'Root',
+      organizationId: null,
+      gitUrl: null,
+      gitBranch: null,
+      mode: null,
+      model: null,
+      variant: null,
+      repository: null,
+      isInitiated: true,
+      needsLegacyPrepare: false,
+      isPreparingAsync: false,
+      prompt: null,
+      initialMessageId: null,
+      associatedPr: null,
+    }),
+    fetchSnapshot: vi.fn<SessionManagerConfig['fetchSnapshot']>(),
+    fetchSnapshotPage: async (id, options) => {
+      const page = id === rootId ? historyPage([], null, id) : await fetchPage(id, options);
+      return page;
+    },
+    getTicket: vi.fn<SessionManagerConfig['getTicket']>(),
+    prepare: vi.fn<SessionManagerConfig['prepare']>(),
+    initiate: vi.fn<SessionManagerConfig['initiate']>(),
+    userWebConnection,
+    api: api as SessionManagerConfig['api'],
+  });
+  managers.push(manager);
+  await manager.switchSession(rootId);
+  const result = vi.mocked(createJotaiStorage).mock.results.at(-1);
+  if (result?.type !== 'return') {
+    throw new Error('manager storage was not created');
+  }
+  return { manager, store, storage: result.value };
+}
+
+const mountedSheets: TestRenderer.ReactTestRenderer[] = [];
+export const viewport = { offset: 0 };
+
+export async function renderSheet(props: SheetProps) {
+  const rendererRef: { current: TestRenderer.ReactTestRenderer | undefined } = {
+    current: undefined,
+  };
+  await act(async () => {
+    await Promise.resolve();
+    rendererRef.current = TestRenderer.create(createElement(ChildSessionSheet, props), {
+      createNodeMock: element => {
+        if (element.type !== 'FlashList') {
+          return null;
+        }
+        viewport.offset = 0;
+        return {
+          scrollToEnd: () => {
+            viewport.offset = 2000;
+          },
+        };
+      },
+    });
+  });
+  const renderer = rendererRef.current;
+  if (!renderer) {
+    throw new Error('renderer was not created');
+  }
+  mountedSheets.push(renderer);
+  return renderer;
+}
+
+export async function updateSheet(renderer: TestRenderer.ReactTestRenderer, props: SheetProps) {
+  await act(async () => {
+    await Promise.resolve();
+    renderer.update(createElement(ChildSessionSheet, props));
+  });
+}
+
+export function host(root: TestRenderer.ReactTestInstance, type: string) {
+  return root.find(node => (node.type as string) === type);
+}
+
+export function textValues(root: TestRenderer.ReactTestInstance) {
+  return root.findAll(node => (node.type as string) === 'Text').map(node => node.props.children);
+}
+
+export function retryButton(root: TestRenderer.ReactTestInstance) {
+  return root.find(
+    node => (node.type as string) === 'Pressable' && node.props.accessibilityLabel === 'Retry'
+  );
+}
+
+export function findByTestID(root: TestRenderer.ReactTestInstance, testID: string) {
+  return root.findAll(node => node.props.testID === testID);
+}
+
+export function modal(root: TestRenderer.ReactTestInstance) {
+  return host(root, 'Modal');
+}
+
+beforeEach(() => {
+  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+  reactNativeMock.Platform.OS = 'ios';
+  reactNativeMock.useWindowDimensions.mockReturnValue({ width: 390, height: 844 });
+  safeAreaMock.useSafeAreaInsets.mockReturnValue({ top: 0, bottom: 0, left: 0, right: 0 });
+});
+
+afterEach(async () => {
+  await act(async () => {
+    await Promise.resolve();
+    for (const renderer of mountedSheets.splice(0)) {
+      renderer.unmount();
+    }
+    for (const manager of managers.splice(0)) {
+      manager.destroy();
+    }
+  });
+  vi.useRealTimers();
+});
diff --git a/apps/mobile/src/components/agents/child-session-sheet.mounted.test.tsx b/apps/mobile/src/components/agents/child-session-sheet.mounted.test.tsx
index 7f035ff521..71c6512867 100644
--- a/apps/mobile/src/components/agents/child-session-sheet.mounted.test.tsx
+++ b/apps/mobile/src/components/agents/child-session-sheet.mounted.test.tsx
@@ -1,199 +1,131 @@
 /* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as src/components/ui/selectable-text.mounted.test.tsx) */
-import { type ComponentProps, createElement } from 'react';
-import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { act } from 'react-test-renderer';
+import { describe, expect, it, vi } from 'vitest';
 
 import {
-  type ChildSessionHydrationState,
-  type OlderMessagesError,
-  type StoredMessage,
-  type TextPart,
-} from '@kilocode/cloud-agent-sdk';
-
-import { type SessionModelOption } from '@/lib/hooks/use-session-model-options';
-
-import { ChildSessionSheet } from './child-session-sheet';
+  buildProps,
+  errorState,
+  findByTestID,
+  host,
+  makeAssistantMessage,
+  modal,
+  reactNativeMock,
+  readyState,
+  renderSheet,
+  retryButton,
+  safeAreaMock,
+  textValues,
+  updateSheet,
+} from './child-session-sheet-test-helpers';
+import { QueryError } from '@/components/query-error';
+import { i18n } from '@/i18n';
 import { ChildSessionModelLabel } from './child-session-model-label';
 
-const reactNativeMock = vi.hoisted(() => ({
-  Platform: { OS: 'ios' as string },
-  useWindowDimensions: vi.fn(() => ({ width: 390, height: 844 })),
-}));
-const safeAreaMock = vi.hoisted(() => ({
-  useSafeAreaInsets: vi.fn(() => ({ top: 0, bottom: 0, left: 0, right: 0 })),
-}));
-
-vi.mock('react-native', () => ({
-  Modal: 'Modal',
-  View: 'View',
-  Pressable: 'Pressable',
-  Platform: reactNativeMock.Platform,
-  useWindowDimensions: reactNativeMock.useWindowDimensions,
-}));
-vi.mock('react-native-reanimated', () => ({
-  default: { View: 'AnimatedView' },
-  LinearTransition: { duration: () => ({}) },
-}));
-vi.mock('react-native-safe-area-context', () => ({
-  useSafeAreaInsets: safeAreaMock.useSafeAreaInsets,
-}));
-// The real `@/components/ui/text` loads `@rn-primitives/slot`, whose node_modules
-// `.mjs` contains JSX that this pipeline cannot transform. Provide a real context
-// so any `useContext(TextClassContext)` consumer still resolves.
-vi.mock('@/components/ui/text', async () => {
-  const React = await import('react');
-  return {
-    Text: 'Text',
-    TextClassContext: React.createContext<string | undefined>(undefined),
-  };
-});
-vi.mock('@/components/ui/icons', () => ({
-  Bot: 'Bot',
-  ChevronRight: 'ChevronRight',
-  Loader2: 'Loader2',
-}));
-vi.mock('@/components/ui/spinning-icon', () => ({
-  SpinningIcon: 'SpinningIcon',
-}));
-vi.mock('@/lib/hooks/use-theme-colors', () => ({
-  useThemeColors: () => ({}),
-}));
-vi.mock('./session-message-list', () => ({
-  SessionMessageList: () => null,
-}));
-vi.mock('./part-detail-sheet-host', () => ({
-  PartDetailSheetHost: ({ children }: { children?: unknown }) => children,
-}));
-vi.mock('./working-indicator', () => ({
-  WorkingIndicator: () => null,
-}));
-vi.mock('./message-error-boundary', () => ({
-  MessageErrorBoundary: ({ children }: { children?: unknown }) => children,
-}));
-vi.mock('@/components/empty-state', () => ({
-  EmptyState: 'EmptyState',
-}));
-vi.mock('@/components/query-error', () => ({
-  QueryError: 'QueryError',
-}));
-vi.mock('@/components/sheet-header', () => ({
-  SheetHeader: 'SheetHeader',
-}));
-
-const modelOption: SessionModelOption = {
-  id: 'kilo/model',
-  name: 'Test Model',
-  displayId: 'model',
-  variants: [],
-  isPreferred: false,
-  showGatewayMetadata: false,
-  provider: { id: 'kilo', name: 'Kilo' },
-  modelRef: { providerID: 'kilo', modelID: 'model' },
-};
-
-function makeTextPart(text: string): TextPart {
-  return { id: 't1', sessionID: 's1', messageID: 'm1', type: 'text', text };
-}
-
-function makeAssistantMessage(): StoredMessage {
-  return {
-    info: {
-      id: 'm1',
-      sessionID: 's1',
-      role: 'assistant',
-      time: { created: 1 },
-      parentID: 'm0',
-      modelID: 'model',
-      providerID: 'kilo',
-      mode: 'code',
-      agent: 'build',
-      path: { cwd: '/', root: '/' },
-      cost: 0,
-      tokens: { total: 0, input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+describe('ChildSessionSheet title layout', () => {
+  it.each([
+    {
+      state: 'loading',
+      hydrationState: { status: 'loading' } as const,
+      messages: [],
+      sessionError: null,
+      expectedText: i18n.t('agentChat.childSessionSheet.loading'),
+      retryCount: 0,
+    },
+    {
+      state: 'ready',
+      hydrationState: readyState,
+      messages: [makeAssistantMessage()],
+      sessionError: null,
+      expectedText: 'child text',
+      retryCount: 0,
     },
-    parts: [makeTextPart('child text')],
-  };
-}
+    {
+      state: 'empty',
+      hydrationState: readyState,
+      messages: [],
+      sessionError: null,
+      expectedText: i18n.t('agentChat.childSessionSheet.noMessages'),
+      retryCount: 0,
+    },
+    {
+      state: 'retryable error',
+      hydrationState: errorState,
+      messages: [],
+      sessionError: null,
+      expectedText: 'Failed',
+      retryCount: 1,
+    },
+    {
+      state: 'terminal error',
+      hydrationState: readyState,
+      messages: [],
+      sessionError: 'Runtime failure',
+      expectedText: 'Runtime failure',
+      retryCount: 0,
+    },
+  ])('keeps the selected title wrapped during $state', async state => {
+    const props = {
+      ...buildProps({
+        getChildMessages: () => state.messages,
+        hydrationState: state.hydrationState,
+      }),
+      title: 'Inspect performance child 01',
+      sessionError: state.sessionError,
+    };
+    const renderer = await renderSheet(props);
+    const header = host(renderer.root, 'SheetHeader');
+
+    expect(header.props).toMatchObject({ title: 'Inspect performance child 01', wrapTitle: true });
+    expect(header.props.onDone).toBe(props.onClose);
+    expect(textValues(renderer.root)).toContain(state.expectedText);
+    expect(
+      renderer.root.findAll(
+        node => (node.type as string) === 'Pressable' && node.props.accessibilityLabel === 'Retry'
+      )
+    ).toHaveLength(state.retryCount);
+  });
+});
 
-const readyState: ChildSessionHydrationState = {
-  status: 'ready',
-  cursor: null,
-  hasOlder: false,
-  isLoadingOlder: false,
-  olderError: null,
-  omittedItemCount: 0,
-};
+describe('ChildSessionSheet mounted', () => {
+  it('keeps the wrapped title, live rows, and Retry through hydration recovery', async () => {
+    const messages = [makeAssistantMessage()];
+    const props = buildProps({
+      getChildMessages: () => messages,
+      hydrationState: { status: 'loading' },
+    });
+    const renderer = await renderSheet(props);
+    const list = host(renderer.root, 'FlashList');
+    const header = host(renderer.root, 'SheetHeader');
+
+    await updateSheet(renderer, { ...props, hydrationState: errorState });
+
+    expect(textValues(renderer.root)).toContain('child text');
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(1);
+    expect(textValues(renderer.root)).toContain('Failed');
+    expect(retryButton(renderer.root).props.accessibilityState).toEqual({
+      disabled: false,
+      busy: false,
+    });
+    expect(host(renderer.root, 'FlashList')).toBe(list);
 
-const errorState: ChildSessionHydrationState = { status: 'error', message: 'Failed' };
+    await updateSheet(renderer, props);
 
-type SheetPropsFixture = {
-  getChildMessages: (sessionId: string) => StoredMessage[];
-  hydrationState: ChildSessionHydrationState;
-};
+    expect(host(renderer.root, 'SheetHeader')).toBe(header);
+    expect(header.props).toMatchObject({ title: props.title, wrapTitle: true });
+    expect(textValues(renderer.root)).toEqual(expect.arrayContaining(['child text', 'Failed']));
+    expect(retryButton(renderer.root).props.accessibilityState).toEqual({
+      disabled: true,
+      busy: true,
+    });
+    expect(host(renderer.root, 'FlashList')).toBe(list);
 
-function buildProps({
-  getChildMessages,
-  hydrationState,
-}: SheetPropsFixture): ComponentProps<typeof ChildSessionSheet> {
-  return {
-    visible: true,
-    sessionId: 'child-1',
-    title: 'Subagent',
-    getChildMessages,
-    hydrationState,
-    sessionError: null,
-    isStreaming: false,
-    hasOlderMessages: false,
-    isLoadingOlderMessages: false,
-    olderMessagesError: null as OlderMessagesError | null,
-    olderMessagesOmittedItemCount: 0,
-    onLoadOlderMessages: vi.fn<() => void>(),
-    renderPart: () => null,
-    onOpenChildSession: vi.fn<(sessionId: string, title: string) => void>(),
-    onRetry: vi.fn<() => void>(),
-    onClose: vi.fn<() => void>(),
-    modelOptions: [modelOption],
-  };
-}
+    await updateSheet(renderer, { ...props, hydrationState: readyState });
 
-async function renderSheet(props: ComponentProps<typeof ChildSessionSheet>) {
-  const rendererRef: { current: TestRenderer.ReactTestRenderer | undefined } = {
-    current: undefined,
-  };
-  await act(async () => {
-    await Promise.resolve();
-    rendererRef.current = TestRenderer.create(createElement(ChildSessionSheet, props));
+    expect(host(renderer.root, 'SheetHeader')).toBe(header);
+    expect(header.props).toMatchObject({ title: props.title, wrapTitle: true });
+    expect(renderer.root.findAllByType(QueryError)).toHaveLength(0);
+    expect(host(renderer.root, 'FlashList')).toBe(list);
   });
-  const renderer = rendererRef.current;
-  if (!renderer) {
-    throw new Error('renderer was not created');
-  }
-  return renderer;
-}
-
-function findByTestID(
-  root: TestRenderer.ReactTestInstance,
-  testID: string
-): TestRenderer.ReactTestInstance[] {
-  return root.findAll(node => node.props.testID === testID);
-}
-
-function modal(root: TestRenderer.ReactTestInstance): TestRenderer.ReactTestInstance {
-  const found = root.findAll(node => (node.type as string) === 'Modal');
-  const node = found[0];
-  if (!node) {
-    throw new Error('Modal not found');
-  }
-  return node;
-}
-
-beforeEach(() => {
-  reactNativeMock.Platform.OS = 'ios';
-  reactNativeMock.useWindowDimensions.mockReturnValue({ width: 390, height: 844 });
-  safeAreaMock.useSafeAreaInsets.mockReturnValue({ top: 0, bottom: 0, left: 0, right: 0 });
-});
-
-describe('ChildSessionSheet mounted', () => {
   it('renders the model row when child messages carry model data', async () => {
     const messages = [makeAssistantMessage()];
     const renderer = await renderSheet(
@@ -233,7 +165,7 @@ describe('ChildSessionSheet mounted', () => {
     );
 
     expect(renderer.root.findAllByType(ChildSessionModelLabel)).toHaveLength(0);
-    const errors = renderer.root.findAll(node => (node.type as string) === 'QueryError');
+    const errors = renderer.root.findAllByType(QueryError);
     expect(errors).toHaveLength(1);
   });
 });
@@ -291,21 +223,24 @@ describe('ChildSessionSheet sheet surface', () => {
     expect(onClose).toHaveBeenCalledTimes(1);
   });
 
-  it('closes when Done is pressed', async () => {
-    const onClose = vi.fn<() => void>();
-    const renderer = await renderSheet({
-      ...buildProps({ getChildMessages: () => [], hydrationState: readyState }),
-      onClose,
-    });
+  it('closes the loading child once when Done is pressed', async () => {
+    const props = {
+      ...buildProps({ getChildMessages: () => [], hydrationState: { status: 'loading' } }),
+    };
+    let closeCount = 0;
+    props.onClose = () => {
+      closeCount += 1;
+      props.visible = false;
+    };
+    const renderer = await renderSheet(props);
 
-    const header = renderer.root.findAll(node => (node.type as string) === 'SheetHeader')[0];
-    if (!header) {
-      throw new Error('SheetHeader not found');
-    }
     await act(async () => {
+      (host(renderer.root, 'SheetHeader').props.onDone as () => void)();
       await Promise.resolve();
-      (header.props.onDone as () => void)();
     });
-    expect(onClose).toHaveBeenCalledTimes(1);
+    await updateSheet(renderer, props);
+
+    expect(modal(renderer.root).props.visible).toBe(false);
+    expect(closeCount).toBe(1);
   });
 });
diff --git a/apps/mobile/src/components/agents/child-session-sheet.tsx b/apps/mobile/src/components/agents/child-session-sheet.tsx
index 010fbeb9c5..915626dd81 100644
--- a/apps/mobile/src/components/agents/child-session-sheet.tsx
+++ b/apps/mobile/src/components/agents/child-session-sheet.tsx
@@ -1,4 +1,4 @@
-import { type ReactNode } from 'react';
+import { type ReactNode, useState } from 'react';
 import { View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { useTranslation } from 'react-i18next';
@@ -75,6 +75,21 @@ export function ChildSessionSheet({
   const state = getChildSessionSheetState(hydrationState, messages.length, sessionError);
   const modelLabel = getChildSessionModelLabel(messages, modelOptions ?? []);
   const { t } = useTranslation();
+  // Hydration drops its error while retrying. Retain this child's copy so
+  // the recovery controls stay mounted until the request settles.
+  const [lastHydrationError, setLastHydrationError] = useState<{
+    sessionId: string;
+    message: string | null;
+  }>({ sessionId, message: null });
+  let hydrationError: string | null = null;
+  if (hydrationState.status === 'error') {
+    hydrationError = hydrationState.message;
+  } else if (hydrationState.status === 'loading' && lastHydrationError.sessionId === sessionId) {
+    hydrationError = lastHydrationError.message;
+  }
+  if (lastHydrationError.sessionId !== sessionId || lastHydrationError.message !== hydrationError) {
+    setLastHydrationError({ sessionId, message: hydrationError });
+  }
   // Safe-area context can return 0 inside a RN `Modal` (pageSheet doesn't
   // always propagate the home-indicator inset), so we floor the value with
   // a comfortable constant to keep the last row / working indicator clear
@@ -85,32 +100,48 @@ export function ChildSessionSheet({
 
   if (state === 'content') {
     content = (
-      <SessionMessageList
-        sessionId={sessionId}
-        items={messages}
-        keyExtractor={message => message.info.id}
-        hasOlderMessages={hasOlderMessages}
-        isLoadingOlderMessages={isLoadingOlderMessages}
-        olderMessagesError={olderMessagesError}
-        olderMessagesOmittedItemCount={olderMessagesOmittedItemCount}
-        onLoadOlderMessages={onLoadOlderMessages}
-        renderItem={({ item }) => (
-          <MessageErrorBoundary>
-            <View className="px-4 py-1">
-              <ChildSessionMessage
-                message={item}
-                depth={0}
-                getChildMessages={getChildMessages}
-                renderPart={renderPart}
-                onOpenChildSession={onOpenChildSession}
-                modelOptions={modelOptions}
-              />
-            </View>
-          </MessageErrorBoundary>
-        )}
-        ListFooterComponent={<WorkingIndicator messages={messages} isStreaming={isStreaming} />}
-        contentBottomInset={sheetBottomInset}
-      />
+      <View className="flex-1">
+        {sessionError ? (
+          <SessionStatusIndicator
+            indicator={{ type: 'error', message: sessionError, timestamp: 0 }}
+          />
+        ) : null}
+        {hydrationError !== null ? (
+          <QueryError
+            title={t('agentChat.childSessionSheet.couldNotLoad')}
+            message={hydrationError}
+            onRetry={onRetry}
+            isRetrying={hydrationState.status === 'loading'}
+            className="flex-none gap-3 border-b border-border py-3"
+          />
+        ) : null}
+        <SessionMessageList
+          sessionId={sessionId}
+          items={messages}
+          keyExtractor={message => message.info.id}
+          hasOlderMessages={hasOlderMessages}
+          isLoadingOlderMessages={isLoadingOlderMessages}
+          olderMessagesError={olderMessagesError}
+          olderMessagesOmittedItemCount={olderMessagesOmittedItemCount}
+          onLoadOlderMessages={onLoadOlderMessages}
+          renderItem={({ item }) => (
+            <MessageErrorBoundary>
+              <View className="px-4 py-1">
+                <ChildSessionMessage
+                  message={item}
+                  depth={0}
+                  getChildMessages={getChildMessages}
+                  renderPart={renderPart}
+                  onOpenChildSession={onOpenChildSession}
+                  modelOptions={modelOptions}
+                />
+              </View>
+            </MessageErrorBoundary>
+          )}
+          ListFooterComponent={<WorkingIndicator messages={messages} isStreaming={isStreaming} />}
+          contentBottomInset={sheetBottomInset}
+        />
+      </View>
     );
   } else if (state === 'error') {
     content =
@@ -146,20 +177,9 @@ export function ChildSessionSheet({
     );
   }
 
-  if (state === 'content' && sessionError) {
-    content = (
-      <View className="flex-1">
-        <SessionStatusIndicator
-          indicator={{ type: 'error', message: sessionError, timestamp: 0 }}
-        />
-        {content}
-      </View>
-    );
-  }
-
   return (
     <SessionPageSheet visible={visible} onClose={onClose} onDismiss={onDismiss}>
-      <SheetHeader title={title} onDone={onClose} />
+      <SheetHeader title={title} wrapTitle onDone={onClose} />
       {modelLabel ? (
         <View className="border-b border-border px-4 py-2">
           <ChildSessionModelLabel modelLabel={modelLabel} />
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 a7df0a2537..3e73f000b2 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
@@ -1,92 +1,13 @@
 import { describe, expect, it, vi } from 'vitest';
 
+import { type MessageDeliveryState, type StoredMessage } from '@kilocode/cloud-agent-sdk';
 import {
-  type KiloSessionId,
-  type MessageDeliveryState,
-  type StoredMessage,
-  type ToolPart,
-} from '@kilocode/cloud-agent-sdk';
-import {
-  collectEmptyChildSessionIds,
   countInFlightMessages,
-  hydrateEmptyChildSessions,
   resolveRetryPrompt,
   retryMessageAndClear,
 } from './session-detail-content-helpers';
 import { assistantMessage, userMessage } from './message-bubble-test-utils';
 
-const subagentSessionId = 'ses-child' as KiloSessionId;
-const otherSubagentSessionId = 'ses-child-2' as KiloSessionId;
-
-const noChildMessages = (): StoredMessage[] => [];
-
-function makeToolPart(tool: string, state: ToolPart['state']): ToolPart {
-  return {
-    id: 'p1',
-    sessionID: 'ses-1',
-    messageID: 'msg-1',
-    type: 'tool',
-    tool,
-    callID: 'call-1',
-    state,
-  };
-}
-
-function makeTaskPart(
-  status: 'pending' | 'running' | 'completed' | 'error',
-  sessionId: KiloSessionId = subagentSessionId,
-  input: Record<string, unknown> = {}
-): ToolPart {
-  if (status === 'pending') {
-    return makeToolPart('task', { status: 'pending', input, raw: '' });
-  }
-  if (status === 'running') {
-    return makeToolPart('task', {
-      status: 'running',
-      input,
-      time: { start: 1 },
-      metadata: { sessionId },
-    });
-  }
-  if (status === 'completed') {
-    return makeToolPart('task', {
-      status: 'completed',
-      input,
-      output: 'done',
-      title: 'Task',
-      metadata: { sessionId },
-      time: { start: 1, end: 2 },
-    });
-  }
-  return makeToolPart('task', {
-    status: 'error',
-    input,
-    error: 'failed',
-    metadata: { sessionId },
-    time: { start: 1, end: 2 },
-  });
-}
-
-function makeAssistantMessage(parts: ToolPart[], id = 'msg-1'): StoredMessage {
-  return {
-    info: {
-      id,
-      sessionID: 'ses-1',
-      role: 'assistant',
-      time: { created: 1 },
-      parentID: 'msg-0',
-      modelID: 'claude',
-      providerID: 'anthropic',
-      mode: 'code',
-      agent: 'build',
-      path: { cwd: '/', root: '/' },
-      cost: 0,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    },
-    parts,
-  };
-}
-
 describe('countInFlightMessages', () => {
   it('excludes a failed pending row from the in-flight count', () => {
     const pending = new Map<string, MessageDeliveryState>([
@@ -201,102 +122,3 @@ describe('resolveRetryPrompt', () => {
     expect(resolveRetryPrompt(assistant, [assistant])).toBeNull();
   });
 });
-
-describe('collectEmptyChildSessionIds', () => {
-  it('returns [] for no messages', () => {
-    expect(collectEmptyChildSessionIds([], noChildMessages)).toEqual([]);
-  });
-
-  it('returns [] for a non-task tool part', () => {
-    const readPart = makeToolPart('read', {
-      status: 'completed',
-      input: { filePath: 'x' },
-      output: 'y',
-      title: 'read',
-      metadata: {},
-      time: { start: 1, end: 2 },
-    });
-    const messages = [makeAssistantMessage([readPart])];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([]);
-  });
-
-  it('returns [] for a pending task with no metadata sessionId', () => {
-    const messages = [makeAssistantMessage([makeTaskPart('pending')])];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([]);
-  });
-
-  it('returns the id for a completed task with empty child messages', () => {
-    const messages = [makeAssistantMessage([makeTaskPart('completed')])];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([subagentSessionId]);
-  });
-
-  it('returns [] for a completed task with existing child messages', () => {
-    const messages = [makeAssistantMessage([makeTaskPart('completed')])];
-    const getChildMessages = (id: KiloSessionId): StoredMessage[] =>
-      id === subagentSessionId ? [makeAssistantMessage([], 'child-msg')] : [];
-    expect(collectEmptyChildSessionIds(messages, getChildMessages)).toEqual([]);
-  });
-
-  it('includes running and error task states when empty', () => {
-    const messages = [
-      makeAssistantMessage([makeTaskPart('running', subagentSessionId)], 'msg-run'),
-      makeAssistantMessage([makeTaskPart('error', otherSubagentSessionId)], 'msg-err'),
-    ];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([
-      subagentSessionId,
-      otherSubagentSessionId,
-    ]);
-  });
-
-  it('returns a duplicate task id once', () => {
-    const messages = [
-      makeAssistantMessage([makeTaskPart('completed', subagentSessionId)], 'msg-1'),
-      makeAssistantMessage([makeTaskPart('completed', subagentSessionId)], 'msg-2'),
-    ];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([subagentSessionId]);
-  });
-
-  it('returns two different empty child ids in first-seen order', () => {
-    const messages = [
-      makeAssistantMessage([makeTaskPart('completed', subagentSessionId)], 'msg-1'),
-      makeAssistantMessage([makeTaskPart('completed', otherSubagentSessionId)], 'msg-2'),
-    ];
-    expect(collectEmptyChildSessionIds(messages, noChildMessages)).toEqual([
-      subagentSessionId,
-      otherSubagentSessionId,
-    ]);
-  });
-});
-
-describe('hydrateEmptyChildSessions', () => {
-  it('does not retry when ready after the first hydrate', async () => {
-    let status = 'loading';
-    const hydrate = vi.fn(async () => {
-      status = 'ready';
-      await Promise.resolve();
-    });
-    const readHydrationStatus = vi.fn(() => status);
-    await hydrateEmptyChildSessions([subagentSessionId], hydrate, readHydrationStatus);
-    expect(hydrate).toHaveBeenCalledTimes(1);
-  });
-
-  it('retries once when the first hydrate errors and the second readies', async () => {
-    let status = 'loading';
-    const hydrate = vi.fn(async () => {
-      status = status === 'loading' ? 'error' : 'ready';
-      await Promise.resolve();
-    });
-    const readHydrationStatus = vi.fn(() => status);
-    await hydrateEmptyChildSessions([subagentSessionId], hydrate, readHydrationStatus);
-    expect(hydrate).toHaveBeenCalledTimes(2);
-  });
-
-  it('stops at two hydrates when the retry also errors', async () => {
-    const hydrate = vi.fn(async () => {
-      await Promise.resolve();
-    });
-    const readHydrationStatus = vi.fn(() => 'error');
-    await hydrateEmptyChildSessions([subagentSessionId], hydrate, readHydrationStatus);
-    expect(hydrate).toHaveBeenCalledTimes(2);
-  });
-});
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 e9f518af28..544eb28825 100644
--- a/apps/mobile/src/components/agents/session-detail-content-helpers.ts
+++ b/apps/mobile/src/components/agents/session-detail-content-helpers.ts
@@ -1,11 +1,6 @@
-import {
-  type KiloSessionId,
-  type MessageDeliveryState,
-  type StoredMessage,
-} from '@kilocode/cloud-agent-sdk';
+import { type MessageDeliveryState, type StoredMessage } from '@kilocode/cloud-agent-sdk';
 
-import { getTaskToolSessionId } from './child-session-card-state';
-import { firstHumanText, isToolPart } from './part-types';
+import { firstHumanText } from './part-types';
 
 /**
  * Counts pending messages that are still in flight. A terminal delivery
@@ -66,49 +61,3 @@ export function resolveRetryPrompt(
   }
   return null;
 }
-
-/**
- * Collects child session ids that appear in task tool parts but have no
- * hydrated messages yet. Ids are deduplicated and returned in first-seen
- * order; a child that already has messages is skipped.
- */
-export function collectEmptyChildSessionIds(
-  messages: readonly StoredMessage[],
-  getChildMessages: (childSessionId: KiloSessionId) => readonly StoredMessage[]
-): KiloSessionId[] {
-  const seen = new Set<KiloSessionId>();
-  const emptyIds: KiloSessionId[] = [];
-  for (const message of messages) {
-    for (const part of message.parts) {
-      const childSessionId = isToolPart(part) ? getTaskToolSessionId(part) : undefined;
-      if (childSessionId !== undefined && !seen.has(childSessionId)) {
-        seen.add(childSessionId);
-        if (getChildMessages(childSessionId).length === 0) {
-          emptyIds.push(childSessionId);
-        }
-      }
-    }
-  }
-  return emptyIds;
-}
-
-/**
- * Hydrates each empty child session once, retrying an id exactly once when
- * its first hydration reports an error status. `hydrate` never rejects on a
- * fetch failure (it writes an error status), so the retry reads the status
- * rather than catching a rejection.
- */
-export async function hydrateEmptyChildSessions(
-  ids: readonly KiloSessionId[],
-  hydrate: (id: KiloSessionId) => Promise<void>,
-  readHydrationStatus: (id: KiloSessionId) => string
-): Promise<void> {
-  await Promise.all(
-    ids.map(async id => {
-      await hydrate(id);
-      if (readHydrationStatus(id) === 'error') {
-        await hydrate(id);
-      }
-    })
-  );
-}
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 ca8de2b991..5255e30934 100644
--- a/apps/mobile/src/components/agents/session-detail-content.test.ts
+++ b/apps/mobile/src/components/agents/session-detail-content.test.ts
@@ -1,388 +1,131 @@
-/* eslint-disable max-lines -- the session test renders the full SessionDetailContent and mocks its RN/expo/SDK surface, so the wiring is long. */
-/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom); see src/app/(app)/agent-chat/[session-id].mounted.test.tsx. */
-/* eslint-disable require-await, @typescript-eslint/require-await -- mock factories settle without await because they resolve immediately */
-import { createElement, type ElementType, type ReactElement } from 'react';
-import { Modal, Pressable } from 'react-native';
-import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { type KiloSessionId, type StoredMessage } from '@kilocode/cloud-agent-sdk';
-import type * as ReactI18next from 'react-i18next';
-
-import { type SessionTranscriptItem } from '@/components/agents/session-transcript';
-import { SessionMessageList } from '@/components/agents/session-message-list';
-import { MessageDetailsSheet } from '@/components/agents/message-details-sheet';
-import { AccessibleStatus } from '@/components/ui/accessible-status';
-import { Text } from '@/components/ui/text';
-import { assistantMessage } from './message-bubble-test-utils';
+/* eslint-disable max-lines -- Keep the detail trigger and real SDK request regressions with their shared screen fixture. */
+/* eslint-disable typescript-eslint/no-deprecated -- The repository uses react-test-renderer for DOM-free native component tests. */
+import { type ComponentProps, createElement, Fragment } from 'react';
+import { createStore, Provider } from 'jotai';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { act, type ReactTestInstance, type ReactTestRenderer } from 'react-test-renderer';
+import { type Pressable } from 'react-native';
+import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest';
+import {
+  createSessionManager,
+  createUserWebConnection,
+  type KiloSessionId,
+  type SessionManager,
+  type SessionSnapshotPageOutcome,
+  type StoredMessage,
+  type ToolPart,
+} from '@kilocode/cloud-agent-sdk';
+import { kiloId, stubTextPart } from '@kilocode/cloud-agent-sdk/test-helpers';
+
+import { ChildSessionSection } from '@/components/agents/child-session-section';
+import { ChildSessionModelLabel } from '@/components/agents/child-session-model-label';
+import { ChildSessionSheet } from '@/components/agents/child-session-sheet';
+import { getTaskToolSessionId } from '@/components/agents/child-session-card-state';
+import { assistantMessage } from '@/components/agents/message-bubble-test-utils';
+import { SessionDetailContent } from '@/components/agents/session-detail-content';
+import { SessionSkeletonMessages } from '@/components/agents/session-detail-skeleton';
+import { type SessionMessageList } from '@/components/agents/session-message-list';
 import {
   resolveSendAttachmentKind,
   shouldRefuseSilentAttachmentDrop,
 } from '@/components/agents/session-detail-send-attachment';
+import { EmptyState } from '@/components/empty-state';
+import { QueryError } from '@/components/query-error';
+import { i18n } from '@/i18n';
+import { renderWithProviders } from '@/test/render-with-providers';
 
-// The screen mounts the real details sheet and AccessibleStatus.
-// Composer and manager fakes expose current state for cancellation tests.
-const hoisted = vi.hoisted(() => {
-  const draft = { text: '', files: [] as unknown[] };
-  return {
-    managerRef: { current: null as unknown },
-    announce: vi.fn(),
-    chatComposer: {
-      draft,
-      control: {
-        hasContent: vi.fn(() => draft.text !== '' || draft.files.length > 0),
-        setText: vi.fn((text: string) => {
-          draft.text = text;
-        }),
-        restoreAttachments: vi.fn((files: unknown[]) => {
-          draft.files = [...files];
-        }),
-      },
-      lastProps: null as null | {
-        onSend?: (text: string, options?: Record<string, unknown>) => Promise<void> | void;
-      },
-    },
-  };
-});
-
-// Mock every RN / Expo / SDK side-effect import that `mobile-session-manager.ts`
-// and `session-detail-content.tsx` pull in transitively before loading either
-// module.
-vi.mock('expo-secure-store', () => ({
-  getItemAsync: vi.fn(),
-}));
-vi.mock('sonner-native', () => ({
-  toast: { error: vi.fn(), success: vi.fn(), warning: vi.fn() },
-}));
-vi.mock('@kilocode/cloud-agent-sdk', () => ({
-  createSessionManager: vi.fn(),
-}));
-vi.mock('@kilocode/cloud-agent-sdk/preparation-attempts', () => ({
-  isNoOpCompletedPreparationAttempt: () => false,
-}));
-vi.mock('@/lib/auth/token-owner', () => ({
-  getAuthTokenForRequest: vi.fn(() => 'test-token'),
-}));
-vi.mock('@/components/agents/mobile-session-transport-payload', () => ({
-  normalizeTransportPayload: vi.fn((x: unknown) => x),
-}));
-vi.mock('@/components/agents/mobile-session-diagnostics', () => ({
-  formatSafeCloudAgentFailureDiagnostic: vi.fn(),
-  withCloudAgentDiagnostics: vi.fn((_op: string, _org: unknown, fn: () => unknown) => fn()),
-}));
-vi.mock('@/components/agents/mobile-session-page-adapter', () => ({
-  fetchMobileSessionSnapshotPage: vi.fn(),
-}));
-vi.mock('@/lib/config', () => ({
-  API_BASE_URL: 'https://api.test',
-  CLOUD_AGENT_WS_URL: 'wss://ws.test',
-  WEB_BASE_URL: 'https://web.test',
-}));
-vi.mock('@/lib/user-web-connection-lifecycle', () => ({
-  createNativeUserWebConnectionLifecycleHooks: vi.fn(() => ({})),
-}));
-vi.mock('@/components/agents/tool-card-image-cache', () => ({
-  cacheToolAttachment: vi.fn(),
-  cacheToolCardImage: vi.fn(),
-}));
-vi.mock('@/components/agents/file-part-cache', () => ({
-  cacheFilePart: vi.fn(),
-}));
-vi.mock('@/lib/trpc', () => ({
-  useTRPC: () => ({
-    moderation: { reportContent: { mutationOptions: (options: unknown) => options } },
-  }),
-  trpcClient: {
-    cloudAgentNext: {
-      getAttachmentDownloadUrl: { mutate: vi.fn() },
-      prepareSession: { mutate: vi.fn() },
-      sendMessage: { mutate: vi.fn() },
-      cancelQueuedMessage: { mutate: vi.fn() },
-    },
-    organizations: {
-      cloudAgentNext: {
-        prepareSession: { mutate: vi.fn() },
-        sendMessage: { mutate: vi.fn() },
-        cancelQueuedMessage: { mutate: vi.fn() },
-      },
-    },
-    cliSessionsV2: {
-      getWithRuntimeState: { query: vi.fn() },
-    },
+const managerSlot = vi.hoisted(() => ({ current: null as SessionManager | null }));
+vi.mock('@/components/agents/session-provider', () => ({
+  useSessionManager: () => {
+    if (!managerSlot.current) {
+      throw new Error('Missing test session manager');
+    }
+    return managerSlot.current;
   },
 }));
 
-// ── react-native / native bridges ──────────────────────────────────────────
+// Keep the actual detail/card/sheet/header callbacks and SDK. Replace native
+// rendering and unrelated composer, account, model-picker, and router dependencies.
+const navigationRoutes = vi.hoisted(() => ['session-detail']);
 vi.mock('react-native', () => ({
-  ActivityIndicator: 'ActivityIndicator',
-  Alert: { alert: vi.fn() },
+  View: 'View',
+  Pressable: 'Pressable',
   KeyboardAvoidingView: 'KeyboardAvoidingView',
-  Modal: 'Modal',
+  I18nManager: { isRTL: false },
   Platform: { OS: 'ios' },
-  Pressable: 'Pressable',
-  ScrollView: 'ScrollView',
-  View: 'View',
-}));
-vi.mock('@tanstack/react-query', () => ({ useMutation: () => ({ mutate: vi.fn() }) }));
-vi.mock('@/lib/hooks/use-theme-colors', () => ({
-  useThemeColors: () => ({ background: '#000', mutedForeground: '#999' }),
-}));
-vi.mock('@/lib/a11y/announcing-toast', () => ({
-  announcingToast: { success: vi.fn(), error: vi.fn() },
-}));
-vi.mock('@/components/sheet-header', () => ({ SheetHeader: 'SheetHeader' }));
-vi.mock('@/components/agents/message-text-select-sheet', () => ({
-  MessageTextSelectSheet: 'MessageTextSelectSheet',
-}));
-vi.mock('expo-router', () => ({
-  useFocusEffect: vi.fn(),
-  useIsFocused: () => true,
-  useRouter: () => ({ replace: vi.fn() }),
-}));
-vi.mock('expo-keep-awake', () => ({
-  useKeepAwake: vi.fn(),
-}));
-vi.mock('expo-haptics', () => ({
-  impactAsync: vi.fn(async () => undefined),
-  notificationAsync: vi.fn(async () => undefined),
-  NotificationFeedbackType: { Error: 'error', Success: 'success' },
 }));
 vi.mock('react-native-reanimated', () => ({
-  default: { View: 'Animated.View' },
+  default: { View: 'AnimatedView' },
   FadeIn: { duration: () => ({}) },
   FadeOut: { duration: () => ({}) },
   LinearTransition: { duration: () => ({}) },
 }));
 vi.mock('react-native-safe-area-context', () => ({
-  useSafeAreaInsets: () => ({ bottom: 0, left: 0, right: 0, top: 0 }),
-}));
-vi.mock('react-i18next', async importOriginal => {
-  const actual = await importOriginal<typeof ReactI18next>();
-  return {
-    ...actual,
-    useTranslation: () => ({ t: (key: string) => key }),
-  };
-});
-
-// ── jotai + session provider ───────────────────────────────────────────────
-// Hooks and store.get read the same current atom values, including updates before React renders.
-// Writes and subscriptions remain inert because each test controls manager updates.
-vi.mock('jotai', () => ({
-  useAtomValue: (atom: { value: unknown }) => atom.value,
-  useSetAtom: () => vi.fn(),
-  useStore: () => ({ get: (atom: { value: unknown }) => atom.value, sub: vi.fn(() => vi.fn()) }),
-}));
-vi.mock('@/components/agents/session-provider', () => ({
-  useSessionManager: () => hoisted.managerRef.current,
-}));
-
-// ── hooks and libs ─────────────────────────────────────────────────────────
-vi.mock('@/lib/utils', () => ({
-  cn: (...classes: (string | false | null | undefined)[]) => classes.filter(Boolean).join(' '),
-}));
-vi.mock('@/lib/intl-cache', () => ({
-  dateTimeFormat: vi.fn(() => ({ format: () => '' })),
-  relativeTimeFormat: vi.fn(() => ({ format: () => '' })),
-}));
-vi.mock('@/lib/analytics/posthog', () => ({
-  captureEvent: vi.fn(),
-  MESSAGE_SENT_EVENT: 'message_sent',
-  SESSION_VIEWED_EVENT: 'session_viewed',
+  useSafeAreaInsets: () => ({ top: 0, bottom: 16 }),
 }));
-vi.mock('@/lib/a11y/announce', () => ({
-  moveA11yFocus: () => false,
-  announceForA11y: hoisted.announce,
-}));
-vi.mock('@/lib/persist/drafts', () => ({
-  agentComposerDraftKey: (id: string) => `agent-composer:${id}`,
-}));
-vi.mock('@/lib/persist/use-draft-load', () => ({
-  useFencedDraftLoad: () => ({ settled: true, value: null }),
-}));
-vi.mock('@/lib/hooks/use-current-user-id', () => ({
-  useCurrentUserId: () => ({ isLoading: false, userId: undefined }),
-}));
-vi.mock('@/lib/hooks/use-available-models', () => ({
-  useAvailableModels: () => ({ isLoading: false, models: [] }),
-}));
-vi.mock('@/lib/hooks/use-model-preferences', () => ({
-  useModelPreferences: () => ({ setLastSelected: vi.fn() }),
-}));
-vi.mock('@/lib/hooks/use-persisted-agent-model', () => ({
-  usePersistedAgentModel: () => ({ saveModel: vi.fn() }),
-}));
-vi.mock('@/lib/hooks/use-keep-screen-on-preference', () => ({
-  useKeepScreenOnPreference: () => ({ hasLoaded: true, keepScreenOn: false }),
-}));
-vi.mock('@/lib/hooks/use-reasoning-preference', () => ({
-  useReasoningPreference: () => ({ defaultExpanded: false }),
-}));
-vi.mock('@/lib/hooks/use-session-model-options', () => ({
-  createRemoteModelOverride: vi.fn(),
-  revalidateLegacyGatewayOverride: vi.fn(),
-  useSessionModelOptions: () => ({ options: [], selectedValue: null, selectedVariant: null }),
-}));
-vi.mock('@/lib/use-github-repos-refresh', () => ({
-  useGitHubReposRefresh: () => ({ openGitHubIntegration: vi.fn() }),
-}));
-vi.mock('@/lib/session-context-info', () => ({
-  resolveSessionContextInfo: () => null,
-}));
-vi.mock('@/lib/picker-bridge', () => ({
-  areModelPickerSelectionScopesEqual: () => true,
-}));
-
-// ── agent hooks ────────────────────────────────────────────────────────────
-vi.mock('@/components/agents/use-continue-session', () => ({
-  useContinueSession: () => ({
-    clearGuidance: vi.fn(),
-    continueSession: vi.fn(),
-    guidance: null,
-    isContinuing: false,
-  }),
-}));
-vi.mock('@/components/agents/use-interaction-handlers', () => ({
-  useInteractionHandlers: () => ({
-    handleAnswerQuestion: vi.fn(),
-    handleRejectQuestion: vi.fn(),
-    handleRespondToPermission: vi.fn(),
-    isAnswering: false,
-    isRespondingToPermission: false,
-    permissionSubmissionError: null,
-    questionSubmissionError: null,
-  }),
-}));
-vi.mock('@/components/agents/use-session-config-sync', () => ({
-  useSessionConfigSync: () => ({
-    currentMode: 'code',
-    currentModel: undefined,
-    currentVariant: '',
-    setCurrentMode: vi.fn(),
-    setCurrentModel: vi.fn(),
-    setCurrentVariant: vi.fn(),
-  }),
-}));
-vi.mock('@/components/agents/use-session-detail-rename', () => ({
-  useSessionDetailRename: () => ({
-    closeModal: vi.fn(),
-    isModalOpen: false,
-    isTitleInteractive: false,
-    modalInitialValue: '',
-    openModal: vi.fn(),
-    submit: vi.fn(),
-    title: 'Test session',
+vi.mock('expo-router', () => ({
+  useFocusEffect: vi.fn(),
+  useIsFocused: () => true,
+  useRouter: () => ({
+    canGoBack: () => navigationRoutes.length > 1,
+    back: () => {
+      navigationRoutes.pop();
+    },
+    replace: (href: string) => {
+      navigationRoutes.splice(-1, 1, href);
+    },
+    push: (href: string) => {
+      navigationRoutes.push(href);
+    },
   }),
 }));
-vi.mock('@/components/kilo-chat/hooks/use-cli-session-presence', () => ({
-  resolveLoadedCliSessionPresenceId: () => null,
-  useCliSessionPresence: vi.fn(),
-}));
-
-// ── pure helpers the component still calls ────────────────────────────────
-vi.mock('@/components/agents/agent-interaction-policy', () => ({
-  getBlockingInteraction: () => 'none',
-}));
-vi.mock('@/components/agents/mode-normalize', () => ({
-  customModeOptionsFromRuntimeAgents: () => [],
-  dedupeCustomModeOptions: (options: unknown) => options,
-  ensureSelectedCustomOption: (options: unknown) => options,
-  lockedModelOption: () => ({}),
-  resolvePinnedAgentModel: () => ({}),
-}));
-vi.mock('@/components/agents/queued-badge-hold', () => ({
-  nextHeldQueuedIds: (held: unknown) => held,
-}));
-vi.mock('@/components/agents/session-keyboard-container-state', () => ({
-  getSessionKeyboardContainerKind: () => 'app-aware-padding',
-}));
-vi.mock('@/components/agents/context-usage-display', () => ({
-  getContextSheetMountState: () => ({ mounted: false, visible: false }),
-}));
-vi.mock('@/components/agents/session-composer-disabled', () => ({
-  resolveSessionComposerDisabled: () => false,
-}));
-vi.mock('@/components/agents/session-list-helpers', () => ({
-  selectSessionCostInputs: () => ({ breakdownCostUsd: null, totalMicrodollars: null }),
-}));
-vi.mock('@/components/agents/mobile-session-manager-helpers', () => ({
-  buildRemoteAttachmentParts: vi.fn(),
-}));
-vi.mock('@/components/agents/session-working-state', () => ({
-  shouldShowAgentWorkingIndicator: () => false,
-  shouldShowFooterWorkingIndicator: () => false,
-  shouldShowSessionFooterRow: () => false,
-}));
-vi.mock('@/components/agents/session-keep-awake', () => ({
-  shouldKeepSessionAwake: () => false,
-}));
-vi.mock('@/components/agents/session-focus-refetch', () => ({
-  shouldRefetchOnFocus: () => false,
-}));
-vi.mock('@/components/agents/session-terminal-error', () => ({
-  buildTerminalErrorCopyText: () => '',
-  resolveSessionTerminalError: () => null,
-}));
-vi.mock('@/components/agents/child-session-card-state', () => ({
-  getChildSessionStreaming: () => false,
-}));
-vi.mock('@/components/agents/child-session-sheet-state', () => ({
-  closeChildSessionSheet: vi.fn(),
-  openChildSessionSheet: vi.fn(),
-  releaseChildSessionSheet: vi.fn(),
-}));
-vi.mock('@/components/agents/use-message-copy', () => ({
-  performCopy: vi.fn(),
-}));
-vi.mock('@/components/agents/session-detail-content-helpers', () => ({
-  collectEmptyChildSessionIds: () => [],
-  countInFlightMessages: () => 0,
-  hydrateEmptyChildSessions: vi.fn(),
-  resolveRetryPrompt: () => null,
-  retryMessageAndClear: vi.fn(),
-  runConnectRepository: vi.fn(),
+vi.mock('expo-keep-awake', () => ({ useKeepAwake: vi.fn() }));
+vi.mock('expo-haptics', () => ({
+  notificationAsync: vi.fn(),
+  NotificationFeedbackType: { Error: 'error', Success: 'success' },
 }));
-vi.mock('@/components/agents/create-and-navigate-agent-session', () => ({
-  createAndNavigateAgentSession: vi.fn(),
+vi.mock('@/components/agents/mobile-session-manager', () => ({
+  isCancelQueuedUpgradeRequired: vi.fn(),
 }));
-vi.mock('@/components/agents/exit-remote-session-with-feedback', () => ({
-  exitRemoteSessionWithFeedback: vi.fn(),
+vi.mock('sonner-native', () => ({ toast: { error: vi.fn() } }));
+vi.mock('@/components/ui/icons', () => ({
+  Bot: 'Bot',
+  ChevronDown: 'ChevronDown',
+  Clock: 'Clock',
+  Loader2: 'Loader2',
+  MessageSquare: 'MessageSquare',
 }));
-vi.mock('@/components/agents/restart-agent-session', () => ({
-  restartAgentSession: vi.fn(),
+vi.mock('@/components/ui/directional-icons', () => ({
+  DirectionalChevronLeft: 'ChevronLeft',
+  DirectionalChevronRight: 'ChevronRight',
+}));
+vi.mock('@/components/ui/spinning-icon', () => ({ SpinningIcon: 'SpinningIcon' }));
+vi.mock('@/components/ui/text', () => ({ Text: 'Text' }));
+vi.mock('@/components/ui/eyebrow', () => ({ Eyebrow: 'Eyebrow' }));
+vi.mock('@/components/ui/button', () => ({ Button: 'Button' }));
+vi.mock('@/components/ui/bubble', () => ({ Bubble: 'Bubble' }));
+vi.mock('@/components/ui/blur-bar', () => ({ BlurBar: 'BlurBar' }));
+vi.mock('@/components/empty-state', () => ({ EmptyState: 'EmptyState' }));
+vi.mock('@/components/query-error', () => ({ QueryError: 'QueryError' }));
+vi.mock('@/components/rename-modal', () => ({ RenameModal: 'RenameModal' }));
+vi.mock('@/components/sheet-header', () => ({ SheetHeader: 'SheetHeader' }));
+vi.mock('@/components/agents/session-page-sheet', () => ({ SessionPageSheet: 'SessionPageSheet' }));
+vi.mock('@/components/agents/part-detail-sheet-host', () => ({
+  PartDetailSheetHost: 'PartDetailSheetHost',
 }));
-
-// ── sub-components ─────────────────────────────────────────────────────────
-// ChatComposer is the only non-string mock: it binds the composer control
-// handle and captures its props so the suite can drive `onSend`.
-vi.mock('@/components/agents/chat-composer', async () => {
-  const React = await import('react');
-  return {
-    ChatComposer: (props: {
-      controlRef?: React.Ref<unknown>;
-      onSend?: (text: string, options?: Record<string, unknown>) => Promise<void> | void;
-    }) => {
-      hoisted.chatComposer.lastProps = props;
-      React.useImperativeHandle(props.controlRef, () => hoisted.chatComposer.control);
-      return React.createElement('ChatComposer', null);
-    },
-  };
-});
-vi.mock('@/components/agents/message-bubble', () => ({
-  MessageBubble: 'MessageBubble',
+vi.mock('@/components/agents/message-error-boundary', () => ({
+  MessageErrorBoundary: 'MessageErrorBoundary',
 }));
-vi.mock('@/components/agents/session-message-list', () => ({
-  SessionMessageList: 'SessionMessageList',
+vi.mock('@/components/agents/message-details-sheet', () => ({
+  MessageDetailsSheet: 'MessageDetailsSheet',
 }));
-
+vi.mock('@/components/agents/chat-composer', () => ({ ChatComposer: 'ChatComposer' }));
 vi.mock('@/components/agents/model-selector', () => ({
   ModelPickerSelectionScopeProvider: 'ModelPickerSelectionScopeProvider',
 }));
-vi.mock('@/components/agents/permission-card', () => ({
-  PermissionCard: 'PermissionCard',
-}));
-vi.mock('@/components/agents/question-card', () => ({
-  QuestionCard: 'QuestionCard',
-}));
+vi.mock('@/components/agents/permission-card', () => ({ PermissionCard: 'PermissionCard' }));
+vi.mock('@/components/agents/question-card', () => ({ QuestionCard: 'QuestionCard' }));
+vi.mock('@/components/agents/preparation-group', () => ({ PreparationGroup: 'PreparationGroup' }));
 vi.mock('@/components/agents/session-connection-indicator', () => ({
   SessionConnectionIndicator: 'SessionConnectionIndicator',
 }));
@@ -392,270 +135,405 @@ vi.mock('@/components/agents/session-context-metrics', () => ({
 vi.mock('@/components/agents/session-context-sheet', () => ({
   SessionContextSheet: 'SessionContextSheet',
 }));
-vi.mock('@/components/agents/session-pr-badge', () => ({
-  SessionPrBadge: 'SessionPrBadge',
-}));
+vi.mock('@/components/agents/session-pr-badge', () => ({ SessionPrBadge: 'SessionPrBadge' }));
 vi.mock('@/components/agents/session-status-indicator', () => ({
   SessionStatusIndicator: 'SessionStatusIndicator',
 }));
-vi.mock('@/components/agents/preparation-group', () => ({
-  PreparationGroup: 'PreparationGroup',
-}));
 vi.mock('@/components/agents/session-detail-skeleton', () => ({
   SessionSkeletonMessages: 'SessionSkeletonMessages',
 }));
 vi.mock('@/components/agents/transcript-time-marker', () => ({
   TranscriptTimeMarker: 'TranscriptTimeMarker',
 }));
-vi.mock('@/components/agents/working-indicator', () => ({
-  WorkingIndicator: 'WorkingIndicator',
+vi.mock('@/components/agents/working-indicator', () => ({ WorkingIndicator: 'WorkingIndicator' }));
+vi.mock('@/components/agents/compaction-separator', () => ({
+  CompactionSeparator: 'CompactionSeparator',
 }));
-vi.mock('@/components/agents/child-session-sheet', () => ({
-  ChildSessionSheet: 'ChildSessionSheet',
+vi.mock('@/components/agents/file-part-renderer', () => ({ FilePartRenderer: 'FilePartRenderer' }));
+vi.mock('@/components/agents/reasoning-part-renderer', () => ({
+  ReasoningPartRenderer: 'ReasoningPartRenderer',
 }));
-vi.mock('@/components/agents/part-detail-sheet-host', () => ({
-  PartDetailSheetHost: 'PartDetailSheetHost',
+vi.mock('@/components/agents/text-part-renderer', () => ({
+  TextPartRenderer: ({ text }: { text: string }) => createElement('Text', null, text),
 }));
-vi.mock('@/components/agents/part-renderer', () => ({
-  PartRenderer: 'PartRenderer',
+vi.mock('@/components/agents/chat-markdown-text', () => ({
+  ChatMarkdownText: ({ value }: { value: string }) => createElement('Text', null, value),
 }));
-vi.mock('@/components/empty-state', () => ({
-  EmptyState: 'EmptyState',
+vi.mock('@/components/agents/tool-cards', () => ({ TaskToolCard: 'TaskToolCard' }));
+vi.mock('@/components/agents/suggest-tool-card', () => ({ SuggestToolCard: 'SuggestToolCard' }));
+vi.mock('@/components/agents/session-message-list', () => ({
+  SessionMessageList: function MessageList<T>(props: ComponentProps<typeof SessionMessageList<T>>) {
+    return createElement(
+      'MessageList',
+      null,
+      props.items.map((item, index) =>
+        createElement(
+          Fragment,
+          { key: props.keyExtractor(item) },
+          props.renderItem({ item, index, target: 'Cell' })
+        )
+      )
+    );
+  },
 }));
 vi.mock('@/components/kilo-chat/app-aware-keyboard-padding', () => ({
   AppAwareKeyboardPaddingView: 'AppAwareKeyboardPaddingView',
 }));
-vi.mock('@/components/query-error', () => ({
-  QueryError: 'QueryError',
+vi.mock('@/components/kilo-chat/hooks/use-cli-session-presence', () => ({
+  resolveLoadedCliSessionPresenceId: vi.fn(),
+  useCliSessionPresence: vi.fn(),
 }));
-vi.mock('@/components/rename-modal', () => ({
-  RenameModal: 'RenameModal',
+vi.mock('@/components/agents/create-and-navigate-agent-session', () => ({
+  createAndNavigateAgentSession: vi.fn(),
 }));
-vi.mock('@/components/screen-header', () => ({
-  ScreenHeader: 'ScreenHeader',
+vi.mock('@/components/agents/exit-remote-session-with-feedback', () => ({
+  exitRemoteSessionWithFeedback: vi.fn(),
 }));
-
-vi.mock('@/components/ui/blur-bar', () => ({
-  BlurBar: 'BlurBar',
+vi.mock('@/components/agents/restart-agent-session', () => ({ restartAgentSession: vi.fn() }));
+vi.mock('@/components/agents/mobile-session-manager-helpers', () => ({
+  buildRemoteAttachmentParts: vi.fn(),
 }));
-vi.mock('@/components/ui/button', () => ({
-  Button: 'Button',
+vi.mock('@/components/agents/use-message-copy', () => ({
+  useMessageCopy: () => ({ copyMessage: vi.fn() }),
+  performCopy: vi.fn(),
 }));
-vi.mock('@/components/ui/text', () => ({
-  Text: 'Text',
+vi.mock('@/components/agents/use-interaction-handlers', () => ({
+  useInteractionHandlers: () => ({}),
 }));
-vi.mock('@/components/ui/icons', () => ({
-  MessageSquare: 'MessageSquare',
+vi.mock('@/components/agents/use-session-config-sync', () => ({
+  useSessionConfigSync: () => ({ currentMode: 'code', currentModel: '', currentVariant: '' }),
 }));
+vi.mock('@/components/agents/use-session-detail-rename', () => ({
+  useSessionDetailRename: ({ serverTitle }: { serverTitle?: string }) => ({
+    title: serverTitle,
+    isTitleInteractive: false,
+  }),
+}));
+vi.mock('@/lib/analytics/posthog', () => ({
+  captureEvent: vi.fn(),
+  MESSAGE_SENT_EVENT: 'sent',
+  SESSION_VIEWED_EVENT: 'viewed',
+}));
+vi.mock('@/lib/a11y/announce', () => ({ moveA11yFocus: () => false }));
+vi.mock('@/lib/hooks/use-current-user-id', () => ({
+  useCurrentUserId: () => ({ userId: 'test-user', isLoading: false }),
+}));
+vi.mock('@/lib/hooks/use-available-models', () => ({
+  useAvailableModels: () => ({ models: [], isLoading: false }),
+}));
+vi.mock('@/lib/hooks/use-model-preferences', () => ({
+  useModelPreferences: () => ({ setLastSelected: vi.fn() }),
+}));
+vi.mock('@/lib/hooks/use-persisted-agent-model', () => ({
+  usePersistedAgentModel: () => ({ saveModel: vi.fn() }),
+}));
+vi.mock('@/lib/hooks/use-reasoning-preference', () => ({
+  useReasoningPreference: () => ({ defaultExpanded: false }),
+}));
+vi.mock('@/lib/hooks/use-keep-screen-on-preference', () => ({
+  useKeepScreenOnPreference: () => ({ keepScreenOn: false, hasLoaded: true }),
+}));
+vi.mock('@/lib/hooks/use-session-model-options', () => ({
+  useSessionModelOptions: () => ({ options: [], selectedValue: '', selectedVariant: '' }),
+}));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({ useThemeColors: () => ({}) }));
+vi.mock('@/lib/persist/drafts', () => ({ agentComposerDraftKey: (id: string) => id }));
+vi.mock('@/lib/persist/use-draft-load', () => ({
+  useFencedDraftLoad: () => ({ settled: true, value: null }),
+}));
+vi.mock('@/lib/trpc', () => ({ trpcClient: {} }));
 
-const { SessionDetailContent } = await import('@/components/agents/session-detail-content');
-
-const SESSION_ID = 'sess-1' as KiloSessionId;
+const ROOT_ID = kiloId('ses-root');
+const NEXT_ROOT_ID = kiloId('ses-next-root');
+const SELECTED_ID = kiloId('ses-selected');
+const NESTED_ID = kiloId('ses-nested');
+const CHILD_IDS = [
+  SELECTED_ID,
+  ...Array.from({ length: 23 }, (_, index) => kiloId(`ses-sibling-${index}`)),
+];
 
-function makeManager() {
+function taskMessage(parentId: KiloSessionId, childIds: KiloSessionId[]): StoredMessage {
+  const message = assistantMessage(`msg-${parentId}`);
   return {
-    atoms: {
-      messagesList: { value: [] as StoredMessage[] },
-      isLoading: { value: false },
-      error: { value: null },
-      fetchedSessionData: {
-        value: {
-          associatedPr: null,
-          cloudAgentSessionId: undefined,
-          gitUrl: undefined,
-          kiloSessionId: SESSION_ID,
-          mode: undefined,
-          organizationId: undefined,
-          title: 'Test session',
-          totalCostMicrodollars: null,
-        },
-      },
-      sessionConfig: { value: null },
-      isStreaming: { value: false },
-      statusIndicator: { value: null },
-      agentStatus: { value: { type: 'connected' } },
-      cloudStatus: { value: null },
-      preparationAttempts: { value: [] },
-      canSend: { value: true },
-      isReadOnly: { value: false },
-      supportsAttachments: { value: true },
-      activeQuestion: { value: null },
-      activePermission: { value: null },
-      activeSuggestion: { value: null },
-      pendingQuestions: { value: [] },
-      pendingPermissions: { value: [] },
-      totalCost: { value: null },
-      childMessages: { value: () => new Map() },
-      childSessionHydrationState: { value: () => ({ status: 'idle' }) },
-      childSessionError: { value: () => null },
-      pendingMessages: { value: new Map<string, { status: string }>() },
-      activeSessionType: { value: null },
-      remoteModelState: {
-        value: { catalog: null, ownerConnectionId: null as string | null, protocol: 'v1' },
-      },
-      observedModel: { value: null },
-      remoteModelOverride: { value: null },
-      cloudAgentModelOverride: { value: null },
-      availableCommands: { value: [] },
-      remoteCommandState: { value: null },
-      contextUsage: { value: null },
-      hasOlderMessages: { value: false },
-      isLoadingOlderMessages: { value: false },
-      olderMessagesError: { value: null },
-      olderMessagesOmittedItemCount: { value: 0 },
-    },
-    switchSession: vi.fn(),
-    send: vi.fn(),
-    cancelQueuedMessage: vi.fn(),
-    acceptSuggestion: vi.fn(),
-    dismissSuggestion: vi.fn(),
-    interrupt: vi.fn(),
-    setCloudAgentModelOverride: vi.fn(),
-    setRemoteModelOverride: vi.fn(),
-    updateFetchedAssociatedPr: vi.fn(),
-    hydrateChildSession: vi.fn(),
-    loadOlderMessages: vi.fn(),
-    trimRetainedHistory: vi.fn(),
-    loadOlderChildMessages: vi.fn(),
-    clearFailedMessage: vi.fn(),
-    createRemoteSession: vi.fn(),
-    exitRemoteSession: vi.fn(),
-    destroy: vi.fn(),
+    info: { ...message.info, sessionID: parentId },
+    parts: childIds.map((childId, index): ToolPart => {
+      const input = { description: `Task ${childId}`, subagent_type: 'Researcher' };
+      const metadata = { sessionId: childId };
+      let state: ToolPart['state'] = {
+        status: 'completed',
+        input,
+        metadata,
+        output: 'Done',
+        title: 'Task',
+        time: { start: 1, end: 2 },
+      };
+      if (index % 3 === 1) {
+        state = { status: 'running', input, metadata, time: { start: 1 } };
+      } else if (index % 3 === 2) {
+        state = {
+          status: 'error',
+          input,
+          metadata,
+          error: 'Task failed',
+          time: { start: 1, end: 2 },
+        };
+      }
+      return {
+        id: `part-${childId}`,
+        sessionID: parentId,
+        messageID: message.info.id,
+        type: 'tool',
+        tool: 'task',
+        callID: `call-${childId}`,
+        state,
+      };
+    }),
   };
 }
 
-type TestManager = ReturnType<typeof makeManager>;
-
-let currentManager: TestManager = makeManager();
-
-const TEXT_PART = { type: 'text', text: 'Queued prompt' } as const;
-const FILE_PART = {
-  type: 'file',
-  filename: 'a.pdf',
-  mime: 'application/pdf',
-  url: 'file:///tmp/attachments/sess-1/user-1/msg-1/a.pdf',
-} as const;
-
-function queuedMessage(parts: readonly unknown[] = [TEXT_PART]): StoredMessage {
+function childMessage(sessionId: KiloSessionId, text: string): StoredMessage {
+  const message = assistantMessage(`msg-${sessionId}`);
   return {
-    info: { id: 'msg-queued-1', role: 'user', time: { created: undefined } },
-    parts,
-  } as unknown as StoredMessage;
+    info: { ...message.info, sessionID: sessionId },
+    parts: [
+      stubTextPart({
+        id: `text-${sessionId}`,
+        sessionID: sessionId,
+        messageID: message.info.id,
+        text,
+      }),
+    ],
+  };
 }
 
-function mount(): TestRenderer.ReactTestRenderer {
-  const ref: { current: TestRenderer.ReactTestRenderer | undefined } = { current: undefined };
-  act(() => {
-    ref.current = TestRenderer.create(
-      createElement(SessionDetailContent, { sessionId: SESSION_ID })
-    );
-  });
-  if (!ref.current) {
-    throw new Error('SessionDetailContent did not render');
-  }
-  return ref.current;
+function page(sessionId: KiloSessionId, messages: StoredMessage[]): SessionSnapshotPageOutcome {
+  return {
+    kind: 'success',
+    info: { id: sessionId },
+    messages,
+    nextCursor: null,
+    omittedItemCount: 0,
+  };
 }
 
-function findByType(
-  renderer: TestRenderer.ReactTestRenderer,
-  type: ElementType
-): TestRenderer.ReactTestInstance[] {
-  return renderer.root.findAllByType(type);
-}
+beforeEach(() => {
+  navigationRoutes.splice(0, navigationRoutes.length, 'session-detail');
+});
 
-/** Reads the MessageBubble element the current transcript renders for `messageId`. */
-function readBubble(
-  renderer: TestRenderer.ReactTestRenderer,
-  messageId: string
-): ReactElement | undefined {
-  const lists = findByType(renderer, SessionMessageList);
-  const listProps = lists[0]?.props as
-    | {
-        items?: SessionTranscriptItem[];
-        renderItem?: (args: { item: SessionTranscriptItem }) => ReactElement;
+async function mountDetails(
+  rootMessages = [taskMessage(ROOT_ID, CHILD_IDS)],
+  metadataReady?: Promise<undefined>
+) {
+  const store = createStore();
+  const rootPages = new Map([[ROOT_ID, rootMessages]]);
+  const requests: {
+    id: KiloSessionId;
+    response: ReturnType<typeof Promise.withResolvers<SessionSnapshotPageOutcome | null>>;
+  }[] = [];
+  const connection = createUserWebConnection({
+    websocketUrl: 'wss://example.test',
+    getAuthToken: vi.fn(),
+  });
+  const manager = createSessionManager({
+    store,
+    userWebConnection: connection,
+    resolveSession: async id => {
+      await Promise.resolve();
+      return { type: 'read-only', kiloSessionId: id };
+    },
+    getTicket: vi.fn(),
+    fetchSnapshot: vi.fn(),
+    fetchSnapshotPage: async id => {
+      const response = Promise.withResolvers<SessionSnapshotPageOutcome | null>();
+      requests.push({ id, response });
+      const messages = rootPages.get(id);
+      if (messages) {
+        response.resolve(page(id, messages));
       }
-    | undefined;
-  const item = listProps?.items?.find(
-    candidate => candidate.type === 'message' && candidate.message.info.id === messageId
-  );
-  if (!item || !listProps?.renderItem) {
-    return undefined;
-  }
-  return listProps.renderItem({ item });
+      const outcome = await response.promise;
+      return outcome;
+    },
+    api: {
+      send: vi.fn(),
+      interrupt: vi.fn(),
+      answer: vi.fn(),
+      reject: vi.fn(),
+      respondToPermission: vi.fn(),
+    },
+    prepare: vi.fn(),
+    initiate: vi.fn(),
+    fetchSession: async id => {
+      await metadataReady;
+      return {
+        kiloSessionId: id,
+        cloudAgentSessionId: null,
+        title: `Root ${id}`,
+        organizationId: null,
+        gitUrl: null,
+        gitBranch: null,
+        mode: null,
+        model: null,
+        variant: null,
+        repository: null,
+        isInitiated: true,
+        needsLegacyPrepare: false,
+        isPreparingAsync: false,
+        prompt: null,
+        initialMessageId: null,
+        associatedPr: null,
+      };
+    },
+  });
+  managerSlot.current = manager;
+  onTestFinished(() => {
+    manager.destroy();
+    connection.destroy();
+  });
+  const element = (id: KiloSessionId) =>
+    createElement(
+      Provider,
+      { store },
+      createElement(SessionDetailContent, { key: id, sessionId: id })
+    );
+  const view = await renderWithProviders(element(ROOT_ID));
+  onTestFinished(view.unmount);
+  const requestFor = (id: KiloSessionId) => {
+    const request = requests.findLast(candidate => candidate.id === id);
+    if (!request) {
+      throw new Error(`No page request for ${id}`);
+    }
+    return request.response;
+  };
+  return {
+    ...view,
+    manager,
+    store,
+    rootPages,
+    requestedIds: () => requests.map(request => request.id),
+    respond: async (id: KiloSessionId, messages: StoredMessage[]) => {
+      await act(async () => {
+        requestFor(id).resolve(page(id, messages));
+        await Promise.resolve();
+      });
+    },
+    fail: async (id: KiloSessionId, error: unknown) => {
+      await act(async () => {
+        requestFor(id).reject(error);
+        await Promise.resolve();
+      });
+    },
+    switchRoot: async (id: KiloSessionId) => {
+      await act(async () => {
+        view.renderer.update(
+          createElement(QueryClientProvider, { client: view.queryClient }, element(id))
+        );
+        await Promise.resolve();
+      });
+    },
+  };
 }
 
-function bubbleProps(
-  renderer: TestRenderer.ReactTestRenderer,
-  messageId: string
-): Record<string, unknown> {
-  return (readBubble(renderer, messageId)?.props ?? {}) as Record<string, unknown>;
+function cardFor(renderer: ReactTestRenderer, sessionId: KiloSessionId): ReactTestInstance {
+  const card = renderer.root.findAllByType(ChildSessionSection).find(node => {
+    const props = node.props as ComponentProps<typeof ChildSessionSection>;
+    return getTaskToolSessionId(props.part) === sessionId;
+  });
+  if (!card) {
+    throw new Error(`No card for ${sessionId}`);
+  }
+  return card;
 }
 
-function detailsProps(renderer: TestRenderer.ReactTestRenderer) {
-  return renderer.root.findByType(MessageDetailsSheet).props as Parameters<
-    typeof MessageDetailsSheet
-  >[0];
+function pressCard(renderer: ReactTestRenderer, sessionId: KiloSessionId) {
+  const { onPress } = cardFor(renderer, sessionId).findByProps({ accessibilityRole: 'button' })
+    .props as { onPress: () => void };
+  act(() => {
+    onPress();
+  });
 }
 
-function cancellationRow(renderer: TestRenderer.ReactTestRenderer) {
-  return findByType(renderer, Pressable).find(
-    node => node.props.testID === 'message-details-cancel-queued'
-  );
+function sheetProps(renderer: ReactTestRenderer) {
+  return renderer.root.findByType(ChildSessionSheet).props as ComponentProps<
+    typeof ChildSessionSheet
+  >;
 }
 
-function cancellationPress(renderer: TestRenderer.ReactTestRenderer): () => void {
-  const row = cancellationRow(renderer);
-  if (!row) {
-    throw new Error('Cancellation row is missing');
-  }
-  return row.props.onPress as () => void;
+function renderedText(node: ReactTestInstance) {
+  return node
+    .findAll(child => typeof child.type === 'string' && (child.type as string) === 'Text')
+    .flatMap(child => child.children.filter(value => typeof value === 'string'))
+    .join('\n');
 }
 
-function openDetails(renderer: TestRenderer.ReactTestRenderer, message: StoredMessage): void {
-  const open = bubbleProps(renderer, message.info.id).onLongPressDetails as (
-    message: StoredMessage
-  ) => void;
-  act(() => {
-    open(message);
-  });
+function pressHeaderBack(renderer: ReactTestRenderer) {
+  const { onPress } = renderer.root.findByProps({ accessibilityLabel: 'Go back' }).props as {
+    onPress: () => void;
+  };
+  act(onPress);
 }
 
-function closeDetails(renderer: TestRenderer.ReactTestRenderer): void {
-  const close = findByType(renderer, Modal)[0]?.props.onRequestClose as () => void;
-  act(() => {
-    close();
+describe.each([true, false])('session detail return with history=%s', hasHistory => {
+  beforeEach(() => {
+    if (hasHistory) {
+      navigationRoutes.unshift('previous-screen');
+    }
   });
-}
 
-function updateScreen(renderer: TestRenderer.ReactTestRenderer): void {
-  act(() => {
-    renderer.update(createElement(SessionDetailContent, { sessionId: SESSION_ID }));
-  });
-}
+  it.each(['loaded after child dismissal', 'empty'] as const)('leaves %s content', async state => {
+    const view = await mountDetails(state === 'empty' ? [] : undefined);
+    if (state === 'empty') {
+      expect(view.renderer.root.findByType(EmptyState).props).toMatchObject({
+        title: i18n.t('agentChat.session.emptyTitle'),
+      });
+    } else {
+      pressCard(view.renderer, SELECTED_ID);
+      await view.respond(SELECTED_ID, [childMessage(SELECTED_ID, 'Selected child row')]);
+      expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).toContain(
+        'Selected child row'
+      );
+      act(() => {
+        sheetProps(view.renderer).onClose();
+      });
+      act(() => {
+        sheetProps(view.renderer).onDismiss?.();
+      });
+      expect(view.renderer.root.findAllByType(ChildSessionSheet)).toHaveLength(0);
+      expect(renderedText(cardFor(view.renderer, SELECTED_ID))).toContain('Task ses-selected');
+    }
 
-function unmountScreen(renderer: TestRenderer.ReactTestRenderer): void {
-  act(() => {
-    renderer.unmount();
+    pressHeaderBack(view.renderer);
+    expect(navigationRoutes).toEqual(
+      hasHistory ? ['previous-screen'] : ['/(app)/(tabs)/(2_agents)']
+    );
   });
-}
 
-function statusMessages(renderer: TestRenderer.ReactTestRenderer): string[] {
-  return renderer.root
-    .findAllByType(AccessibleStatus)
-    .map(node => node.props.message as string | null)
-    .filter(message => message !== null);
-}
+  it.each([
+    { state: 'pending metadata', code: undefined },
+    { state: 'retryable metadata failure', code: 'INTERNAL_SERVER_ERROR' },
+    { state: 'terminal access denial', code: 'UNAUTHORIZED' },
+  ] as const)('leaves $state without changing its feedback', async ({ code }) => {
+    const metadata = Promise.withResolvers<undefined>();
+    const view = await mountDetails([], metadata.promise);
+    expect(view.renderer.root.findAllByType(SessionSkeletonMessages)).toHaveLength(1);
+    if (code) {
+      await act(async () => {
+        metadata.reject({ data: { code } });
+        await Promise.resolve();
+      });
+      const error = view.renderer.root.findByType(QueryError).props as ComponentProps<
+        typeof QueryError
+      >;
+      expect(error.variant).toBe(code === 'UNAUTHORIZED' ? 'permission' : 'server');
+      expect(Boolean(error.onRetry)).toBe(code !== 'UNAUTHORIZED');
+      expect(renderedText(view.renderer.root)).toContain('Back to sessions');
+      expect(renderedText(view.renderer.root)).toContain('Copy');
+    }
 
-beforeEach(() => {
-  currentManager = makeManager();
-  hoisted.managerRef.current = currentManager;
-  hoisted.chatComposer.lastProps = null;
-  hoisted.chatComposer.draft.text = '';
-  hoisted.chatComposer.draft.files = [];
-  hoisted.chatComposer.control.hasContent.mockClear();
-  hoisted.chatComposer.control.setText.mockClear();
-  hoisted.chatComposer.control.restoreAttachments.mockClear();
-  hoisted.announce.mockClear();
+    pressHeaderBack(view.renderer);
+    expect(navigationRoutes).toEqual(
+      hasHistory ? ['previous-screen'] : ['/(app)/(tabs)/(2_agents)']
+    );
+  });
 });
 
 describe('resolveSendAttachmentKind', () => {
@@ -693,835 +571,247 @@ describe('shouldRefuseSilentAttachmentDrop', () => {
   );
 });
 
-describe('SessionDetailContent cancel/restore', () => {
-  function seedQueuedMessage(message: StoredMessage = queuedMessage()): void {
-    currentManager.atoms.messagesList.value = [message];
-    currentManager.atoms.pendingMessages.value = new Map([[message.info.id, { status: 'queued' }]]);
-  }
-
-  const failed = 'agentChat.session.cancelQueuedFailed';
-  const restored = 'agentChat.session.cancelQueuedRestored';
-  const restoreAvailable = 'agentChat.session.cancelQueuedRestoreAvailable';
-
-  it('exposes no cancellation without a selected message', () => {
-    seedQueuedMessage();
-    const renderer = mount();
-    expect(detailsProps(renderer).visible).toBe(false);
-    expect(detailsProps(renderer).message).toBeNull();
-    expect(cancellationRow(renderer)).toBeUndefined();
-    unmountScreen(renderer);
-  });
-
+// These tests run in the existing detail suite with the DOM-free renderer.
+// Request order and rendered state are deterministic; native paint timing is not.
+describe('child transcript requests', () => {
   it.each([
-    'accepted',
-    'running',
-    'canceled',
-    'failed',
-    'missing',
-    'assistant',
-    'untracked',
-    'future',
-  ])('rejects stale activation and updates the open sheet for %s', async state => {
-    const message = queuedMessage();
-    seedQueuedMessage(message);
-    const renderer = mount();
-    openDetails(renderer, message);
-    const stalePress = cancellationPress(renderer);
-    expect(detailsProps(renderer).canCancelQueued).toBe(true);
-    if (state === 'missing') {
-      currentManager.atoms.messagesList.value = [];
-    } else if (state === 'assistant') {
-      currentManager.atoms.messagesList.value = [assistantMessage(message.info.id)];
-    } else if (state === 'untracked') {
-      currentManager.atoms.pendingMessages.value = new Map();
-    } else {
-      currentManager.atoms.pendingMessages.value = new Map([[message.info.id, { status: state }]]);
+    {
+      sessionId: SELECTED_ID,
+      status: 'completed',
+      text: 'Researcher\nTask ses-selected\ncompleted',
+      textRows: 3,
+      waiting: false,
+    },
+    {
+      sessionId: kiloId('ses-sibling-0'),
+      status: 'running',
+      text: 'Researcher\nTask ses-sibling-0\nWaiting for activity\nrunning',
+      textRows: 4,
+      waiting: true,
+    },
+    {
+      sessionId: kiloId('ses-sibling-1'),
+      status: 'error',
+      text: 'Researcher\nTask ses-sibling-1\nerror',
+      textRows: 3,
+      waiting: false,
+    },
+  ] as const)(
+    'renders the $status card without fetching a child transcript for labels',
+    async ({ sessionId, status, text, textRows, waiting }) => {
+      const view = await mountDetails();
+      const card = cardFor(view.renderer, sessionId);
+      const button = card.findByProps({ accessibilityRole: 'button' }).props as ComponentProps<
+        typeof Pressable
+      >;
+
+      expect(view.renderer.root.findAllByType(ChildSessionSection)).toHaveLength(24);
+      expect(renderedText(card)).toBe(text);
+      expect(card.findAll(node => (node.type as string) === 'Text')).toHaveLength(textRows);
+      expect(button).toMatchObject({
+        disabled: false,
+        accessibilityState: { disabled: false },
+        accessibilityHint: i18n.t('agentChat.childSession.openHint'),
+      });
+      expect(button.accessibilityLabel).toContain('Researcher');
+      expect(button.accessibilityLabel).toContain(`Task ${sessionId}`);
+      expect(button.accessibilityLabel).toContain(status);
+      expect(button.accessibilityLabel?.includes('Waiting for activity')).toBe(waiting);
+      expect(view.renderer.root.findAllByType(ChildSessionModelLabel)).toHaveLength(0);
+      expect(view.requestedIds()).toEqual([ROOT_ID]);
     }
-    // Deliberately invoke the old row before React receives the manager update.
-    await act(async () => {
-      stalePress();
-      await Promise.resolve();
-    });
-    updateScreen(renderer);
-    expect(detailsProps(renderer).canCancelQueued).toBe(false);
-    expect(cancellationRow(renderer)).toBeUndefined();
-    expect(detailsProps(renderer).message).toBe(currentManager.atoms.messagesList.value[0] ?? null);
-    expect(currentManager.cancelQueuedMessage).not.toHaveBeenCalled();
-    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-    expect(statusMessages(renderer)).toEqual([]);
-    seedQueuedMessage(message);
-    updateScreen(renderer);
-    expect(detailsProps(renderer).canCancelQueued).toBe(true);
-    expect(cancellationRow(renderer)).toBeDefined();
-    unmountScreen(renderer);
-  });
-
-  it('uses current message parts rather than the selected snapshot at invocation', async () => {
-    const selected = queuedMessage();
-    seedQueuedMessage(selected);
-    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
-    const renderer = mount();
-    openDetails(renderer, selected);
-    const press = cancellationPress(renderer);
-    const current = queuedMessage([{ ...TEXT_PART, text: 'Current prompt' }, FILE_PART]);
-    currentManager.atoms.messagesList.value = [current];
-    await act(async () => {
-      press();
-      await Promise.resolve();
-    });
-    expect(hoisted.chatComposer.draft).toEqual({ text: 'Current prompt', files: [FILE_PART] });
-    expect(readBubble(renderer, selected.info.id)).toBeUndefined();
-    expect(statusMessages(renderer)).toEqual([restored]);
-    unmountScreen(renderer);
-  });
+  );
 
-  describe.each([false, true])('composer occupied=%s', occupied => {
-    it.each([
-      { name: 'text', parts: [TEXT_PART], text: 'Queued prompt', files: [] },
-      {
-        name: 'text and files',
-        parts: [TEXT_PART, FILE_PART],
-        text: 'Queued prompt',
-        files: [FILE_PART],
-      },
-      { name: 'file-only', parts: [FILE_PART], text: '', files: [FILE_PART] },
-    ])('cancels $name once and preserves its restoration path', async ({ parts, text, files }) => {
-      const message = queuedMessage(parts);
-      seedQueuedMessage(message);
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-      const original = {
-        text: occupied ? 'Existing draft' : '',
-        files: occupied ? [{ filename: 'draft.txt' }] : [],
-      };
-      Object.assign(hoisted.chatComposer.draft, original);
-      const renderer = mount();
-      openDetails(renderer, message);
-      const press = cancellationPress(renderer);
-      act(() => {
-        press();
-        press();
-      });
-      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
-      expect(detailsProps(renderer).canCancelQueued).toBe(false);
-      expect(detailsProps(renderer).isCancelingQueued).toBe(true);
-      expect(cancellationRow(renderer)?.props.accessibilityState).toEqual({
-        disabled: true,
-        busy: true,
-      });
-      expect(hoisted.chatComposer.draft).toEqual(original);
-      await act(async () => {
-        request.resolve({ dropped: true });
-        await request.promise;
-        // The completed identifier must remain guarded before React commits restoration.
-        press();
+  it.each([
+    [SELECTED_ID, NESTED_ID, 'completed'],
+    [kiloId('ses-sibling-0'), kiloId('ses-nested-sibling'), 'running'],
+    [kiloId('ses-sibling-1'), kiloId('ses-nested-failed'), 'error'],
+  ] as const)(
+    'opens %s and its nested sheet immediately without requesting siblings',
+    async (selectedId, nestedId, status) => {
+      const isRunning = status === 'running';
+      const view = await mountDetails();
+      pressCard(view.renderer, selectedId);
+      pressCard(view.renderer, selectedId);
+
+      expect(sheetProps(view.renderer)).toMatchObject({
+        visible: true,
+        sessionId: selectedId,
+        title: `Task ${selectedId}`,
+        hydrationState: { status: 'loading' },
       });
-      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
-      expect(detailsProps(renderer).visible).toBe(false);
-      expect(statusMessages(renderer)).toEqual([occupied ? restoreAvailable : restored]);
-      expect(hoisted.announce.mock.calls).toEqual([[occupied ? restoreAvailable : restored]]);
-      if (occupied) {
-        expect(hoisted.chatComposer.draft).toEqual(original);
-        expect(hoisted.chatComposer.control.setText).not.toHaveBeenCalled();
-        expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
-        expect(bubbleProps(renderer, message.info.id).deliveryState).toBeUndefined();
-        expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeInstanceOf(Function);
-        openDetails(renderer, message);
-        expect(detailsProps(renderer).canCancelQueued).toBe(false);
-        expect(cancellationRow(renderer)).toBeUndefined();
-        closeDetails(renderer);
-        currentManager.atoms.messagesList.value = [];
-        currentManager.atoms.pendingMessages.value = new Map();
-        updateScreen(renderer);
-        const restore = bubbleProps(renderer, message.info.id).onRestoreQueued as (
-          message: StoredMessage
-        ) => void;
-        expect(restore).toBeInstanceOf(Function);
-        act(() => {
-          restore(message);
-        });
-        expect(statusMessages(renderer)).toEqual([restored]);
-        expect(hoisted.announce.mock.calls).toEqual([[restoreAvailable], [restored]]);
-      }
-      expect(hoisted.chatComposer.draft).toEqual({ text: text || original.text, files });
-      expect(hoisted.chatComposer.control.setText).toHaveBeenCalledTimes(text ? 1 : 0);
-      expect(hoisted.chatComposer.control.restoreAttachments).toHaveBeenCalledTimes(1);
-      expect(readBubble(renderer, message.info.id)).toBeUndefined();
-      unmountScreen(renderer);
-    });
-
-    it.each(['false', 'rejection'])(
-      'preserves the message and composer after retryable %s with matching sheet feedback',
-      async outcome => {
-        const message = queuedMessage([TEXT_PART, FILE_PART]);
-        seedQueuedMessage(message);
-        const original = {
-          text: occupied ? 'Keep my draft' : '',
-          files: occupied ? [{ filename: 'draft.txt' }] : [],
-        };
-        Object.assign(hoisted.chatComposer.draft, original);
-        if (outcome === 'false') {
-          currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: false });
-        } else {
-          currentManager.cancelQueuedMessage.mockRejectedValue(
-            Object.assign(new Error(outcome), { code: 'SERVICE_UNAVAILABLE' })
-          );
-        }
-        const renderer = mount();
-        openDetails(renderer, message);
-        await act(async () => {
-          cancellationPress(renderer)();
-          await Promise.resolve();
-        });
-        expect(hoisted.chatComposer.draft).toEqual(original);
-        expect(currentManager.atoms.messagesList.value).toEqual([message]);
-        expect(readBubble(renderer, message.info.id)).toBeDefined();
-        expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeUndefined();
-        expect(detailsProps(renderer).canCancelQueued).toBe(true);
-        expect(detailsProps(renderer).isCancelingQueued).toBe(false);
-        expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
-        expect(statusMessages(renderer)).toEqual([failed]);
-        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(failed);
-        expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-        expect(currentManager.interrupt).not.toHaveBeenCalled();
-        expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
-        unmountScreen(renderer);
-      }
-    );
+      expect(view.requestedIds()).toEqual([ROOT_ID, selectedId]);
 
-    it('retains upgrade guidance and blocks unsupported cancellation across message selections', async () => {
-      const message = queuedMessage([TEXT_PART, FILE_PART]);
-      const second = { ...message, info: { ...message.info, id: 'msg-queued-2' } };
-      currentManager.atoms.messagesList.value = [message, second];
-      currentManager.atoms.pendingMessages.value = new Map(
-        [message, second].map(item => [item.info.id, { status: 'queued' }])
+      const selected = taskMessage(selectedId, [
+        NESTED_ID,
+        kiloId('ses-nested-sibling'),
+        kiloId('ses-nested-failed'),
+      ]);
+      selected.parts.push(...childMessage(selectedId, 'Selected child row').parts);
+      await view.respond(selectedId, [selected]);
+      expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).toContain(
+        'Selected child row'
       );
-      const original = {
-        text: occupied ? 'Keep my draft' : '',
-        files: occupied ? [{ filename: 'draft.txt' }] : [],
-      };
-      Object.assign(hoisted.chatComposer.draft, original);
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage
-        .mockReturnValueOnce(request.promise)
-        .mockResolvedValue({ dropped: true });
-      const renderer = mount();
-      openDetails(renderer, second);
-      const staleSecondPress = cancellationPress(renderer);
-      openDetails(renderer, message);
-      const stalePress = cancellationPress(renderer);
-      act(() => {
-        stalePress();
-      });
-      await act(async () => {
-        request.reject(
-          Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
-        );
-        await Promise.resolve();
-        stalePress();
-        staleSecondPress();
-      });
-      const upgrade = 'agentChat.session.cancelQueuedUpgradeRequired';
-      expect(detailsProps(renderer).visible).toBe(true);
-      expect(detailsProps(renderer).canCancelQueued).toBe(false);
-      expect(detailsProps(renderer).isCancelingQueued).toBe(false);
-      expect(cancellationRow(renderer)).toBeUndefined();
-      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(upgrade);
-      expect(statusMessages(renderer)).toEqual([upgrade]);
-      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
-      closeDetails(renderer);
-      openDetails(renderer, message);
-      expect(cancellationRow(renderer)).toBeUndefined();
-      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
-      expect(statusMessages(renderer)).toEqual([]);
-      openDetails(renderer, second);
-      expect(cancellationRow(renderer)).toBeUndefined();
-      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
-      expect(statusMessages(renderer)).toEqual([]);
-      expect(hoisted.chatComposer.draft).toEqual(original);
-      expect(currentManager.atoms.messagesList.value).toEqual([message, second]);
-      expect(readBubble(renderer, message.info.id)).toBeDefined();
-      expect(readBubble(renderer, second.info.id)).toBeDefined();
-      expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeUndefined();
-      expect(bubbleProps(renderer, second.info.id).onRestoreQueued).toBeUndefined();
-      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
-      expect(currentManager.interrupt).not.toHaveBeenCalled();
-      expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
-      expect(hoisted.announce.mock.calls).toEqual([[upgrade]]);
-      unmountScreen(renderer);
-    });
-  });
-
-  it.each([false, true])(
-    'restores cancellation only for a replacement CLI connection, sheet closed=%s',
-    async closed => {
-      const message = queuedMessage([TEXT_PART, FILE_PART]);
-      seedQueuedMessage(message);
-      currentManager.atoms.remoteModelState.value.ownerConnectionId = 'cli-1';
-      currentManager.cancelQueuedMessage.mockRejectedValueOnce(
-        Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+      const selectedCard = cardFor(view.renderer, selectedId);
+      expect(renderedText(selectedCard)).toContain(`Task ${selectedId}`);
+      expect(renderedText(selectedCard).includes('Writing response')).toBe(isRunning);
+      const selectedButton = selectedCard.findByProps({ accessibilityRole: 'button' })
+        .props as ComponentProps<typeof Pressable>;
+      expect(selectedButton.accessibilityLabel?.includes('Writing response')).toBe(isRunning);
+      expect(selectedCard.findAllByType(ChildSessionModelLabel)).toHaveLength(1);
+      const nestedCard = cardFor(view.renderer, nestedId);
+      expect(renderedText(nestedCard)).toBe(
+        `Researcher\nTask ${nestedId}${isRunning ? '\nWaiting for activity' : ''}\n${status}`
       );
-      const renderer = mount();
-      openDetails(renderer, message);
-      const stalePress = cancellationPress(renderer);
-      await act(async () => {
-        stalePress();
-        await Promise.resolve();
-      });
-      const upgrade = 'agentChat.session.cancelQueuedUpgradeRequired';
-      expect(cancellationRow(renderer)).toBeUndefined();
-      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-      if (closed) {
-        closeDetails(renderer);
-        openDetails(renderer, message);
-        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
-        expect(statusMessages(renderer)).toEqual([]);
-      }
-
-      for (const ownerConnectionId of ['cli-1', null, 'cli-1']) {
-        currentManager.atoms.remoteModelState.value = {
-          ...currentManager.atoms.remoteModelState.value,
-          ownerConnectionId,
-        };
-        currentManager.atoms.agentStatus.value = {
-          type: ownerConnectionId === null ? 'disconnected' : 'connected',
-        };
-        currentManager.atoms.supportsAttachments.value = ownerConnectionId !== null;
-        updateScreen(renderer);
-        act(() => {
-          stalePress();
-        });
-        expect(cancellationRow(renderer)).toBeUndefined();
-        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
-        expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
-        expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-      }
-      if (closed) {
-        closeDetails(renderer);
-      }
-      currentManager.atoms.remoteModelState.value = {
-        ...currentManager.atoms.remoteModelState.value,
-        ownerConnectionId: 'cli-2',
-      };
-      updateScreen(renderer);
-      if (closed) {
-        openDetails(renderer, message);
-      }
-      expect(detailsProps(renderer).message).toBe(message);
-      expect(cancellationRow(renderer)).toBeDefined();
-      expect(detailsProps(renderer).canCancelQueued).toBe(true);
-      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-      expect(findByType(renderer, Text).map(node => node.props.children)).not.toContain(upgrade);
-      expect(hoisted.announce.mock.calls).toEqual([[upgrade]]);
-      currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
-      await act(async () => {
-        cancellationPress(renderer)();
-        await Promise.resolve();
-      });
-      expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [FILE_PART] });
-      expect(readBubble(renderer, message.info.id)).toBeUndefined();
-      expect(detailsProps(renderer).visible).toBe(false);
-      expect(statusMessages(renderer)).toEqual([restored]);
-      expect(hoisted.announce.mock.calls).toEqual([[upgrade], [restored]]);
-      unmountScreen(renderer);
-    }
-  );
-
-  it.each([false, true])(
-    'reports a late upgrade failure once without disabling the replacement, sheet dismissed=%s',
-    async dismissed => {
-      const message = queuedMessage();
-      seedQueuedMessage(message);
-      currentManager.atoms.remoteModelState.value.ownerConnectionId = 'cli-1';
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage.mockReturnValueOnce(request.promise);
-      const renderer = mount();
-      openDetails(renderer, message);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      if (dismissed) {
-        closeDetails(renderer);
-      }
-      currentManager.atoms.remoteModelState.value = {
-        ...currentManager.atoms.remoteModelState.value,
-        ownerConnectionId: 'cli-2',
-      };
-      updateScreen(renderer);
-      await act(async () => {
-        request.reject(
-          Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
-        );
-        await Promise.resolve();
-      });
-      expect(detailsProps(renderer).visible).toBe(!dismissed);
-      expect(detailsProps(renderer).isCancelingQueued).toBe(false);
-      expect(detailsProps(renderer).cancelQueuedFeedback?.message ?? null).toBe(
-        dismissed ? null : failed
+      expect(nestedCard.findAll(node => (node.type as string) === 'Text')).toHaveLength(
+        isRunning ? 4 : 3
       );
-      expect(detailsProps(renderer).cancelQueuedGuidance).toBeNull();
-      expect(statusMessages(renderer)).toEqual([failed]);
-      const visibleText = findByType(renderer, Text).map(node => node.props.children);
-      expect(visibleText.filter(text => text === failed)).toHaveLength(1);
-      expect(visibleText).not.toContain('agentChat.session.cancelQueuedUpgradeRequired');
-      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-      expect(readBubble(renderer, message.info.id)).toBeDefined();
-      if (dismissed) {
-        openDetails(renderer, message);
-      }
-      expect(detailsProps(renderer).canCancelQueued).toBe(true);
-      expect(cancellationRow(renderer)?.props.accessibilityState).toEqual({
+      const nestedButton = nestedCard.findByProps({ accessibilityRole: 'button' })
+        .props as ComponentProps<typeof Pressable>;
+      expect(nestedButton).toMatchObject({
         disabled: false,
-        busy: false,
+        accessibilityState: { disabled: false },
+        accessibilityHint: i18n.t('agentChat.childSession.openHint'),
       });
-      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-      currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
-      await act(async () => {
-        cancellationPress(renderer)();
-        await Promise.resolve();
+      expect(nestedButton.accessibilityLabel).toContain(`Task ${nestedId}`);
+      expect(nestedButton.accessibilityLabel).toContain(status);
+      expect(nestedButton.accessibilityLabel?.includes('Waiting for activity')).toBe(isRunning);
+      expect(view.requestedIds()).toEqual([ROOT_ID, selectedId]);
+
+      pressCard(view.renderer, nestedId);
+      expect(sheetProps(view.renderer)).toMatchObject({
+        visible: true,
+        sessionId: nestedId,
+        title: `Task ${nestedId}`,
+        hydrationState: { status: 'loading' },
       });
-      expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [] });
-      expect(readBubble(renderer, message.info.id)).toBeUndefined();
-      expect(detailsProps(renderer).visible).toBe(false);
-      expect(statusMessages(renderer)).toEqual([restored]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed], [restored]]);
-      unmountScreen(renderer);
+      expect(view.requestedIds()).toEqual([ROOT_ID, selectedId, nestedId]);
+      await view.respond(nestedId, [childMessage(nestedId, 'Nested child row')]);
+      expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).toContain(
+        'Nested child row'
+      );
+      expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).not.toContain(
+        'Selected child row'
+      );
+
+      pressCard(view.renderer, selectedId);
+      expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).toContain(
+        'Selected child row'
+      );
+      const hydratedNestedCard = cardFor(view.renderer, nestedId);
+      expect(renderedText(hydratedNestedCard)).toContain(`Task ${nestedId}`);
+      expect(renderedText(hydratedNestedCard).includes('Writing response')).toBe(isRunning);
+      expect(hydratedNestedCard.findAllByType(ChildSessionModelLabel)).toHaveLength(1);
+      const hydratedNestedButton = hydratedNestedCard.findByProps({ accessibilityRole: 'button' })
+        .props as ComponentProps<typeof Pressable>;
+      expect(hydratedNestedButton.accessibilityLabel?.includes('Writing response')).toBe(isRunning);
+      expect(view.requestedIds()).toEqual([ROOT_ID, selectedId, nestedId]);
     }
   );
 
-  it('keeps the occupied Restore path usable before late delivery events', async () => {
-    const message = queuedMessage([TEXT_PART, FILE_PART]);
-    seedQueuedMessage(message);
-    const request = Promise.withResolvers<{ dropped: boolean }>();
-    currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-    const renderer = mount();
-    openDetails(renderer, message);
-    act(() => {
-      cancellationPress(renderer)();
-    });
-    const typedDraft = { text: 'Typed while waiting', files: [{ filename: 'draft.txt' }] };
-    Object.assign(hoisted.chatComposer.draft, typedDraft);
-    await act(async () => {
-      request.resolve({ dropped: true });
-      await request.promise;
-    });
-    expect(hoisted.chatComposer.draft).toEqual(typedDraft);
-    expect(bubbleProps(renderer, message.info.id).deliveryState).toBeUndefined();
-    const restore = bubbleProps(renderer, message.info.id).onRestoreQueued as (
-      message: StoredMessage
-    ) => void;
-    act(() => {
-      restore(message);
-    });
-    updateScreen(renderer);
-    expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [FILE_PART] });
-    expect(readBubble(renderer, message.info.id)).toBeUndefined();
-    expect(currentManager.atoms.messagesList.value).toEqual([message]);
-    expect(hoisted.announce.mock.calls).toEqual([[restoreAvailable], [restored]]);
-    unmountScreen(renderer);
-  });
+  it('keeps metadata after a retryable failure and retries only on explicit Retry', async () => {
+    const view = await mountDetails();
+    pressCard(view.renderer, SELECTED_ID);
+    await view.fail(SELECTED_ID, new Error('fetch failed'));
 
-  it.each(['success', 'upgrade'])(
-    'ignores an old %s outcome in a different session',
-    async outcome => {
-      const message = queuedMessage();
-      seedQueuedMessage(message);
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-      const renderer = mount();
-      openDetails(renderer, message);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      const nextSessionId = 'sess-2' as KiloSessionId;
-      const nextMessage = queuedMessage([{ ...TEXT_PART, text: 'Next session prompt' }]);
-      seedQueuedMessage(nextMessage);
-      currentManager.atoms.fetchedSessionData.value.kiloSessionId = nextSessionId;
-      act(() => {
-        renderer.update(createElement(SessionDetailContent, { sessionId: nextSessionId }));
-      });
-      await act(async () => {
-        if (outcome === 'upgrade') {
-          request.reject(
-            Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
-          );
-        } else {
-          request.resolve({ dropped: true });
-        }
-        await Promise.resolve();
-      });
-      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-      expect(detailsProps(renderer).visible).toBe(false);
-      expect(statusMessages(renderer)).toEqual([]);
-      expect(hoisted.announce).not.toHaveBeenCalled();
-      openDetails(renderer, nextMessage);
-      expect(detailsProps(renderer).canCancelQueued).toBe(true);
-      expect(cancellationRow(renderer)).toBeDefined();
-      unmountScreen(renderer);
-    }
-  );
+    const errorProps = view.renderer.root.findByType(QueryError).props as ComponentProps<
+      typeof QueryError
+    >;
+    expect(errorProps.message).toBe('Connection lost. Please retry in a moment.');
+    expect(renderedText(cardFor(view.renderer, SELECTED_ID))).toContain('Task ses-selected');
+    expect(view.requestedIds()).toEqual([ROOT_ID, SELECTED_ID]);
 
-  it('does not carry known unsupported cancellation into a different session', async () => {
-    const message = queuedMessage();
-    seedQueuedMessage(message);
-    currentManager.cancelQueuedMessage.mockRejectedValueOnce(
-      Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
-    );
-    const renderer = mount();
-    openDetails(renderer, message);
-    await act(async () => {
-      cancellationPress(renderer)();
-      await Promise.resolve();
-    });
-    expect(cancellationRow(renderer)).toBeUndefined();
-    const nextSessionId = 'sess-2' as KiloSessionId;
-    const nextMessage = queuedMessage([{ ...TEXT_PART, text: 'Next session prompt' }]);
-    seedQueuedMessage(nextMessage);
-    currentManager.atoms.fetchedSessionData.value.kiloSessionId = nextSessionId;
     act(() => {
-      renderer.update(createElement(SessionDetailContent, { sessionId: nextSessionId }));
+      errorProps.onRetry?.();
+      errorProps.onRetry?.();
     });
-    openDetails(renderer, nextMessage);
-    expect(statusMessages(renderer)).toEqual([]);
-    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
-    await act(async () => {
-      cancellationPress(renderer)();
-      await Promise.resolve();
-    });
-    expect(hoisted.chatComposer.draft).toEqual({ text: 'Next session prompt', files: [] });
-    expect(readBubble(renderer, nextMessage.info.id)).toBeUndefined();
-    expect(statusMessages(renderer)).toEqual([restored]);
-    unmountScreen(renderer);
+    expect(sheetProps(view.renderer).hydrationState.status).toBe('loading');
+    expect(view.requestedIds()).toEqual([ROOT_ID, SELECTED_ID, SELECTED_ID]);
+    await view.respond(SELECTED_ID, [childMessage(SELECTED_ID, 'Recovered child row')]);
+    expect(renderedText(view.renderer.root.findByType(ChildSessionSheet))).toContain(
+      'Recovered child row'
+    );
+    expect(view.renderer.root.findAllByType(QueryError)).toHaveLength(0);
   });
 
-  it('removes a busy row when the live queue becomes running', async () => {
-    const message = queuedMessage();
-    seedQueuedMessage(message);
-    const request = Promise.withResolvers<{ dropped: boolean }>();
-    currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-    const renderer = mount();
-    openDetails(renderer, message);
-    const press = cancellationPress(renderer);
+  it('preserves access-error copy and dismissal without automatic retry', async () => {
+    const view = await mountDetails();
+    pressCard(view.renderer, SELECTED_ID);
+    await view.fail(SELECTED_ID, { data: { code: 'FORBIDDEN' } });
+
+    const errorProps = view.renderer.root.findByType(QueryError).props as ComponentProps<
+      typeof QueryError
+    >;
+    expect(errorProps.message).toBe('You are not authorized to use the Cloud Agent.');
+    expect(view.requestedIds()).toEqual([ROOT_ID, SELECTED_ID]);
     act(() => {
-      press();
+      sheetProps(view.renderer).onClose();
     });
-    currentManager.atoms.pendingMessages.value = new Map([
-      [message.info.id, { status: 'running' }],
-    ]);
-    updateScreen(renderer);
-    expect(cancellationRow(renderer)).toBeUndefined();
-    expect(detailsProps(renderer).isCancelingQueued).toBe(false);
-    await act(async () => {
-      press();
-      request.resolve({ dropped: false });
-      await request.promise;
+    expect(sheetProps(view.renderer).visible).toBe(false);
+    act(() => {
+      sheetProps(view.renderer).onDismiss?.();
     });
-    expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
-    expect(cancellationRow(renderer)).toBeUndefined();
-    expect(readBubble(renderer, message.info.id)).toBeDefined();
-    expect(statusMessages(renderer)).toEqual([failed]);
-    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-    unmountScreen(renderer);
+    expect(view.renderer.root.findAllByType(ChildSessionSheet)).toHaveLength(0);
+    expect(renderedText(cardFor(view.renderer, SELECTED_ID))).toContain('Task ses-selected');
+    expect(view.renderer.root.findAllByType(ChildSessionSection)).toHaveLength(24);
   });
 
-  it.each([false, true])(
-    'clears both announcement inputs on retry without replay on dismissal, first dismissed=%s',
-    async dismissed => {
-      const message = queuedMessage();
-      seedQueuedMessage(message);
-      const first = Promise.withResolvers<{ dropped: boolean }>();
-      const retry = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage
-        .mockReturnValueOnce(first.promise)
-        .mockReturnValueOnce(retry.promise);
-      const renderer = mount();
-      openDetails(renderer, message);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      if (dismissed) {
-        closeDetails(renderer);
-      }
-      await act(async () => {
-        first.reject(new Error('offline'));
-        await Promise.resolve();
-      });
-      expect(statusMessages(renderer)).toEqual([failed]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-      if (dismissed) {
-        openDetails(renderer, message);
-      }
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      expect(statusMessages(renderer)).toEqual([]);
-      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-      expect(findByType(renderer, Text).map(node => node.props.children)).not.toContain(failed);
-      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-      await act(async () => {
-        retry.reject(new Error('offline'));
-        await Promise.resolve();
-      });
-      expect(statusMessages(renderer)).toEqual([failed]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
-      closeDetails(renderer);
-      expect(statusMessages(renderer)).toEqual([]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
-      openDetails(renderer, message);
-      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-      expect(hoisted.announce).toHaveBeenCalledTimes(2);
-      unmountScreen(renderer);
+  it.each(['failure', 'success'] as const)(
+    'does not publish or retry old child work after a root change and late %s',
+    async outcome => {
+      const view = await mountDetails();
+      pressCard(view.renderer, SELECTED_ID);
+      view.rootPages.set(NEXT_ROOT_ID, [taskMessage(NEXT_ROOT_ID, [kiloId('ses-next-child')])]);
+      await view.switchRoot(NEXT_ROOT_ID);
+      await (outcome === 'failure'
+        ? view.fail(SELECTED_ID, new Error('fetch failed'))
+        : view.respond(SELECTED_ID, [childMessage(SELECTED_ID, 'Old scope row')]));
+
+      expect(view.requestedIds()).toEqual([ROOT_ID, SELECTED_ID, NEXT_ROOT_ID]);
+      expect(view.store.get(view.manager.atoms.childMessages)(SELECTED_ID)).toEqual([]);
+      expect(view.renderer.root.findAllByType(ChildSessionSheet)).toHaveLength(0);
+      expect(renderedText(view.renderer.root)).toContain('Task ses-next-child');
+      expect(renderedText(view.renderer.root)).not.toContain('Old scope row');
+      expect(renderedText(view.renderer.root)).not.toContain('Task ses-selected');
     }
   );
 
-  it('announces identical immediate failures once per attempt despite React batching', async () => {
-    const message = queuedMessage();
-    seedQueuedMessage(message);
-    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: false });
-    const renderer = mount();
-    openDetails(renderer, message);
-    await act(async () => {
-      cancellationPress(renderer)();
-      await Promise.resolve();
+  it('shows confirmed empty history without fetching it again for labels or reopening', async () => {
+    const view = await mountDetails();
+    pressCard(view.renderer, SELECTED_ID);
+    expect(view.renderer.root.findByType(EmptyState).props).toMatchObject({
+      title: i18n.t('agentChat.childSessionSheet.loading'),
     });
-    await act(async () => {
-      cancellationPress(renderer)();
-      await Promise.resolve();
+    await view.respond(SELECTED_ID, []);
+    expect(view.renderer.root.findByType(EmptyState).props).toMatchObject({
+      title: i18n.t('agentChat.childSessionSheet.noMessages'),
     });
-    expect(statusMessages(renderer)).toEqual([failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
-    unmountScreen(renderer);
-  });
-
-  it.each(['success', 'false', 'rejection'])(
-    'announces one outer %s outcome when dismissed while pending',
-    async outcome => {
-      const message = queuedMessage();
-      seedQueuedMessage(message);
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-      const renderer = mount();
-      openDetails(renderer, message);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      closeDetails(renderer);
-      expect(statusMessages(renderer)).toEqual([]);
-      await act(async () => {
-        if (outcome === 'rejection') {
-          request.reject(new Error('offline'));
-        } else {
-          request.resolve({ dropped: outcome === 'success' });
-        }
-        await Promise.resolve();
-      });
-      expect(detailsProps(renderer).visible).toBe(false);
-      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-      expect(statusMessages(renderer)).toEqual([outcome === 'success' ? restored : failed]);
-      expect(hoisted.announce.mock.calls).toEqual([[outcome === 'success' ? restored : failed]]);
-      expect(hoisted.chatComposer.draft.text).toBe(outcome === 'success' ? 'Queued prompt' : '');
-      closeDetails(renderer);
-      expect(hoisted.announce).toHaveBeenCalledTimes(1);
-      unmountScreen(renderer);
-    }
-  );
-
-  it.each([
-    { outcome: 'success', firstFeedback: restored },
-    { outcome: 'false', firstFeedback: failed },
-    { outcome: 'rejection', firstFeedback: failed },
-    { outcome: 'upgrade', firstFeedback: 'agentChat.session.cancelQueuedUpgradeRequired' },
-  ])(
-    'keeps the selected failure when A completes later with $outcome',
-    async ({ outcome, firstFeedback }) => {
-      const first = queuedMessage([TEXT_PART, FILE_PART]);
-      const second = {
-        ...queuedMessage([{ ...TEXT_PART, text: 'Second prompt' }]),
-        info: { ...first.info, id: 'msg-queued-2' },
-      };
-      currentManager.atoms.messagesList.value = [first, second];
-      currentManager.atoms.pendingMessages.value = new Map(
-        [first, second].map(message => [message.info.id, { status: 'queued' }])
-      );
-      const firstRequest = Promise.withResolvers<{ dropped: boolean }>();
-      const secondRequest = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage
-        .mockReturnValueOnce(firstRequest.promise)
-        .mockReturnValueOnce(secondRequest.promise);
-      const renderer = mount();
-      openDetails(renderer, first);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      closeDetails(renderer);
-      openDetails(renderer, second);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      await act(async () => {
-        secondRequest.resolve({ dropped: false });
-        await secondRequest.promise;
-      });
-      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
-      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-      await act(async () => {
-        if (outcome === 'rejection' || outcome === 'upgrade') {
-          firstRequest.reject(
-            Object.assign(new Error(outcome), {
-              code: outcome === 'upgrade' ? 'CLI_UPGRADE_REQUIRED' : 'SERVICE_UNAVAILABLE',
-            })
-          );
-        } else {
-          firstRequest.resolve({ dropped: outcome === 'success' });
-        }
-        await Promise.resolve();
-      });
-      expect(detailsProps(renderer).visible).toBe(true);
-      expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
-      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
-      expect(
-        renderer.root
-          .findByType(MessageDetailsSheet)
-          .findAll(node => node.type === Text && node.props.children === failed)
-      ).toHaveLength(1);
-      expect(detailsProps(renderer).canCancelQueued).toBe(outcome !== 'upgrade');
-      expect(statusMessages(renderer)).toEqual([firstFeedback, failed]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed], [firstFeedback]]);
-      expect(hoisted.chatComposer.draft).toEqual(
-        outcome === 'success'
-          ? { text: 'Queued prompt', files: [FILE_PART] }
-          : { text: '', files: [] }
-      );
-      expect(readBubble(renderer, second.info.id)).toBeDefined();
-      expect(bubbleProps(renderer, second.info.id).onRestoreQueued).toBeUndefined();
-      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([
-        [first.info.id],
-        [second.info.id],
-      ]);
-      closeDetails(renderer);
-      expect(statusMessages(renderer)).toEqual([firstFeedback]);
-      expect(hoisted.announce.mock.calls).toEqual([[failed], [firstFeedback]]);
-      unmountScreen(renderer);
-    }
-  );
 
-  it('keeps another message’s sheet failure on request start and clears only the matching retry', async () => {
-    const first = queuedMessage();
-    const second = { ...first, info: { ...first.info, id: 'msg-queued-2' } };
-    currentManager.atoms.messagesList.value = [first, second];
-    currentManager.atoms.pendingMessages.value = new Map(
-      [first, second].map(message => [message.info.id, { status: 'queued' }])
-    );
-    const firstRequest = Promise.withResolvers<{ dropped: boolean }>();
-    const secondRequest = Promise.withResolvers<{ dropped: boolean }>();
-    const secondRetry = Promise.withResolvers<{ dropped: boolean }>();
-    currentManager.cancelQueuedMessage
-      .mockReturnValueOnce(secondRequest.promise)
-      .mockReturnValueOnce(firstRequest.promise)
-      .mockReturnValueOnce(secondRetry.promise);
-    const renderer = mount();
-    openDetails(renderer, first);
-    const staleFirstPress = cancellationPress(renderer);
-    openDetails(renderer, second);
     act(() => {
-      cancellationPress(renderer)();
-    });
-    await act(async () => {
-      secondRequest.resolve({ dropped: false });
-      await secondRequest.promise;
+      sheetProps(view.renderer).onClose();
     });
-    expect(statusMessages(renderer)).toEqual([failed]);
     act(() => {
-      staleFirstPress();
+      sheetProps(view.renderer).onDismiss?.();
     });
-    expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
-    expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
-    expect(statusMessages(renderer)).toEqual([failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed]]);
-    await act(async () => {
-      firstRequest.resolve({ dropped: false });
-      await firstRequest.promise;
+    pressCard(view.renderer, SELECTED_ID);
+    expect(sheetProps(view.renderer)).toMatchObject({
+      visible: true,
+      hydrationState: { status: 'ready' },
     });
-    expect(statusMessages(renderer)).toEqual([failed, failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
-    act(() => {
-      cancellationPress(renderer)();
-    });
-    expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-    expect(statusMessages(renderer)).toEqual([failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
-    await act(async () => {
-      secondRetry.resolve({ dropped: false });
-      await secondRetry.promise;
+    expect(view.renderer.root.findByType(EmptyState).props).toMatchObject({
+      title: i18n.t('agentChat.childSessionSheet.noMessages'),
     });
-    expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
-    expect(statusMessages(renderer)).toEqual([failed, failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed], [failed]]);
-    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
-    expect(readBubble(renderer, first.info.id)).toBeDefined();
-    expect(readBubble(renderer, second.info.id)).toBeDefined();
-    closeDetails(renderer);
-    expect(statusMessages(renderer)).toEqual([failed]);
-    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed], [failed]]);
-    unmountScreen(renderer);
+    expect(view.requestedIds()).toEqual([ROOT_ID, SELECTED_ID]);
+    expect(cardFor(view.renderer, SELECTED_ID).findAllByType(ChildSessionModelLabel)).toHaveLength(
+      0
+    );
   });
 
-  it.each([true, false])(
-    'binds an old request outcome to its message, dropped=%s',
-    async dropped => {
-      const first = queuedMessage();
-      const second = {
-        ...queuedMessage([{ ...TEXT_PART, text: 'Second prompt' }]),
-        info: { ...first.info, id: 'msg-queued-2' },
-      };
-      currentManager.atoms.messagesList.value = [first, second];
-      currentManager.atoms.pendingMessages.value = new Map(
-        [first, second].map(message => [message.info.id, { status: 'queued' }])
-      );
-      const request = Promise.withResolvers<{ dropped: boolean }>();
-      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
-      const renderer = mount();
-      openDetails(renderer, first);
-      act(() => {
-        cancellationPress(renderer)();
-      });
-      openDetails(renderer, second);
-      await act(async () => {
-        request.resolve({ dropped });
-        await request.promise;
-      });
-      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[first.info.id]]);
-      expect(detailsProps(renderer).visible).toBe(true);
-      expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
-      expect(detailsProps(renderer).canCancelQueued).toBe(true);
-      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
-      expect(statusMessages(renderer)).toEqual([dropped ? restored : failed]);
-      expect(hoisted.announce.mock.calls).toEqual([[dropped ? restored : failed]]);
-      expect(hoisted.chatComposer.draft.text).toBe(dropped ? 'Queued prompt' : '');
-      unmountScreen(renderer);
-    }
-  );
-});
-
-describe('SessionDetailContent send failure', () => {
-  it('throws without putting the prompt back itself (the composer owns the restore)', async () => {
-    currentManager.send.mockResolvedValue(false);
-
-    const renderer = mount();
-    const onSend = hoisted.chatComposer.lastProps?.onSend;
-    expect(onSend).toBeInstanceOf(Function);
-
-    await act(async () => {
-      await expect(onSend?.('prompt text', {})).rejects.toThrow('Failed to send message');
-    });
-
-    // The session layer must not restore the prompt itself — that would
-    // duplicate the composer's own empty-composer restore.
-    expect(hoisted.chatComposer.control.setText).not.toHaveBeenCalled();
-
-    act(() => {
-      renderer.unmount();
-    });
+  it('renders no child card or sheet when the root has no children', async () => {
+    const view = await mountDetails([childMessage(ROOT_ID, 'Root-only row')]);
+    expect(renderedText(view.renderer.root)).toContain('Root-only row');
+    expect(view.renderer.root.findAllByType(ChildSessionSection)).toHaveLength(0);
+    expect(view.renderer.root.findAllByType(ChildSessionSheet)).toHaveLength(0);
+    expect(view.requestedIds()).toEqual([ROOT_ID]);
   });
 });
diff --git a/apps/mobile/src/components/agents/session-detail-content.tsx b/apps/mobile/src/components/agents/session-detail-content.tsx
index c94c2712ed..a8571e7233 100644
--- a/apps/mobile/src/components/agents/session-detail-content.tsx
+++ b/apps/mobile/src/components/agents/session-detail-content.tsx
@@ -67,9 +67,7 @@ import {
   shouldShowSessionFooterRow,
 } from '@/components/agents/session-working-state';
 import {
-  collectEmptyChildSessionIds,
   countInFlightMessages,
-  hydrateEmptyChildSessions,
   resolveRetryPrompt,
   retryMessageAndClear,
 } from '@/components/agents/session-detail-content-helpers';
@@ -188,7 +186,6 @@ export function SessionDetailContent({
   });
   const childSheetReleaseTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const composerControlRef = useRef<ChatComposerControl | null>(null);
-  const childHydrateAttemptedRef = useRef<Set<string>>(new Set());
 
   const clearChildSheetReleaseTimeout = useCallback(() => {
     if (childSheetReleaseTimeoutRef.current !== null) {
@@ -476,42 +473,6 @@ export function SessionDetailContent({
 
   const store = useStore();
 
-  useEffect(() => {
-    childHydrateAttemptedRef.current = new Set();
-  }, [sessionId]);
-
-  // Hydrate child transcripts for task cards that have no messages yet, so a
-  // reopened parent shows each completed child's model on the card without
-  // opening the child sheet. An attempted id is never hydrated again for the
-  // same parent session; a hydrate error retries once.
-  useEffect(() => {
-    if (isLoading) {
-      return;
-    }
-    if (fetchedData?.kiloSessionId !== sessionId) {
-      return;
-    }
-    const liveGetChildMessages = store.get(manager.atoms.childMessages);
-    const readHydrationStatus = (id: KiloSessionId) =>
-      store.get(manager.atoms.childSessionHydrationState)(id).status;
-    const emptyIds = collectEmptyChildSessionIds(messages, liveGetChildMessages).filter(
-      id => !childHydrateAttemptedRef.current.has(id)
-    );
-    if (emptyIds.length === 0) {
-      return;
-    }
-    for (const id of emptyIds) {
-      childHydrateAttemptedRef.current.add(id);
-    }
-    void hydrateEmptyChildSessions(
-      emptyIds,
-      async id => {
-        await manager.hydrateChildSession(id);
-      },
-      readHydrationStatus
-    );
-  }, [isLoading, fetchedData?.kiloSessionId, sessionId, messages, manager, store]);
-
   // Refetch the linked PR on every focus so a link, unlink, or mid-session
   // decision change surfaces without reopening the session. A pending review
   // decision gets one 4s follow-up refetch — no polling loop.
@@ -1432,6 +1393,7 @@ export function SessionDetailContent({
       <View className="flex-1 bg-background">
         <ScreenHeader
           title={rename.title}
+          backFallback="/(app)/(tabs)/(2_agents)"
           headerRight={headerRight}
           {...(rename.isTitleInteractive
             ? {
diff --git a/apps/mobile/src/components/agents/session-detail-queue.test.ts b/apps/mobile/src/components/agents/session-detail-queue.test.ts
new file mode 100644
index 0000000000..927ddcc4ed
--- /dev/null
+++ b/apps/mobile/src/components/agents/session-detail-queue.test.ts
@@ -0,0 +1,1477 @@
+/* eslint-disable max-lines -- the session test renders the full SessionDetailContent and mocks its RN/expo/SDK surface, so the wiring is long. */
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (node env, no jsdom); see src/app/(app)/agent-chat/[session-id].mounted.test.tsx. */
+/* eslint-disable require-await, @typescript-eslint/require-await -- mock factories settle without await because they resolve immediately */
+import { createElement, type ElementType, type ReactElement } from 'react';
+import { Modal, Pressable } from 'react-native';
+import TestRenderer, { act } from 'react-test-renderer';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { type KiloSessionId, type StoredMessage } from '@kilocode/cloud-agent-sdk';
+import type * as ReactI18next from 'react-i18next';
+
+import { type SessionTranscriptItem } from '@/components/agents/session-transcript';
+import { SessionMessageList } from '@/components/agents/session-message-list';
+import { MessageDetailsSheet } from '@/components/agents/message-details-sheet';
+import { AccessibleStatus } from '@/components/ui/accessible-status';
+import { Text } from '@/components/ui/text';
+import { assistantMessage } from './message-bubble-test-utils';
+
+const hoisted = vi.hoisted(() => {
+  const draft = { text: '', files: [] as unknown[] };
+  return {
+    managerRef: { current: null as unknown },
+    announce: vi.fn(),
+    chatComposer: {
+      draft,
+      control: {
+        hasContent: vi.fn(() => draft.text !== '' || draft.files.length > 0),
+        setText: vi.fn((text: string) => {
+          draft.text = text;
+        }),
+        restoreAttachments: vi.fn((files: unknown[]) => {
+          draft.files = [...files];
+        }),
+      },
+      lastProps: null as null | {
+        onSend?: (text: string, options?: Record<string, unknown>) => Promise<void> | void;
+      },
+    },
+  };
+});
+
+// Mock every RN / Expo / SDK side-effect import that `mobile-session-manager.ts`
+// and `session-detail-content.tsx` pull in transitively before loading either
+// module.
+vi.mock('expo-secure-store', () => ({
+  getItemAsync: vi.fn(),
+}));
+vi.mock('sonner-native', () => ({
+  toast: { error: vi.fn(), success: vi.fn(), warning: vi.fn() },
+}));
+vi.mock('@kilocode/cloud-agent-sdk', () => ({
+  createSessionManager: vi.fn(),
+}));
+vi.mock('@kilocode/cloud-agent-sdk/preparation-attempts', () => ({
+  isNoOpCompletedPreparationAttempt: () => false,
+}));
+vi.mock('@/lib/auth/token-owner', () => ({
+  getAuthTokenForRequest: vi.fn(() => 'test-token'),
+}));
+vi.mock('@/components/agents/mobile-session-transport-payload', () => ({
+  normalizeTransportPayload: vi.fn((x: unknown) => x),
+}));
+vi.mock('@/components/agents/mobile-session-diagnostics', () => ({
+  formatSafeCloudAgentFailureDiagnostic: vi.fn(),
+  withCloudAgentDiagnostics: vi.fn((_op: string, _org: unknown, fn: () => unknown) => fn()),
+}));
+vi.mock('@/components/agents/mobile-session-page-adapter', () => ({
+  fetchMobileSessionSnapshotPage: vi.fn(),
+}));
+vi.mock('@/lib/config', () => ({
+  API_BASE_URL: 'https://api.test',
+  CLOUD_AGENT_WS_URL: 'wss://ws.test',
+  WEB_BASE_URL: 'https://web.test',
+}));
+vi.mock('@/lib/user-web-connection-lifecycle', () => ({
+  createNativeUserWebConnectionLifecycleHooks: vi.fn(() => ({})),
+}));
+vi.mock('@/components/agents/tool-card-image-cache', () => ({
+  cacheToolAttachment: vi.fn(),
+  cacheToolCardImage: vi.fn(),
+}));
+vi.mock('@/components/agents/file-part-cache', () => ({
+  cacheFilePart: vi.fn(),
+}));
+vi.mock('@/lib/trpc', () => ({
+  useTRPC: () => ({
+    moderation: { reportContent: { mutationOptions: (options: unknown) => options } },
+  }),
+  trpcClient: {
+    cloudAgentNext: {
+      getAttachmentDownloadUrl: { mutate: vi.fn() },
+      prepareSession: { mutate: vi.fn() },
+      sendMessage: { mutate: vi.fn() },
+      cancelQueuedMessage: { mutate: vi.fn() },
+    },
+    organizations: {
+      cloudAgentNext: {
+        prepareSession: { mutate: vi.fn() },
+        sendMessage: { mutate: vi.fn() },
+        cancelQueuedMessage: { mutate: vi.fn() },
+      },
+    },
+    cliSessionsV2: {
+      getWithRuntimeState: { query: vi.fn() },
+    },
+  },
+}));
+
+// ── react-native / native bridges ──────────────────────────────────────────
+vi.mock('react-native', () => ({
+  ActivityIndicator: 'ActivityIndicator',
+  Alert: { alert: vi.fn() },
+  KeyboardAvoidingView: 'KeyboardAvoidingView',
+  Modal: 'Modal',
+  Platform: { OS: 'ios' },
+  Pressable: 'Pressable',
+  ScrollView: 'ScrollView',
+  View: 'View',
+}));
+vi.mock('@tanstack/react-query', () => ({ useMutation: () => ({ mutate: vi.fn() }) }));
+vi.mock('@/lib/hooks/use-theme-colors', () => ({
+  useThemeColors: () => ({ background: '#000', mutedForeground: '#999' }),
+}));
+vi.mock('@/lib/a11y/announcing-toast', () => ({
+  announcingToast: { success: vi.fn(), error: vi.fn() },
+}));
+vi.mock('@/components/sheet-header', () => ({ SheetHeader: 'SheetHeader' }));
+vi.mock('@/components/agents/message-text-select-sheet', () => ({
+  MessageTextSelectSheet: 'MessageTextSelectSheet',
+}));
+vi.mock('expo-router', () => ({
+  useFocusEffect: vi.fn(),
+  useIsFocused: () => true,
+  useRouter: () => ({ replace: vi.fn() }),
+}));
+vi.mock('expo-keep-awake', () => ({
+  useKeepAwake: vi.fn(),
+}));
+vi.mock('expo-haptics', () => ({
+  impactAsync: vi.fn(async () => undefined),
+  notificationAsync: vi.fn(async () => undefined),
+  NotificationFeedbackType: { Error: 'error', Success: 'success' },
+}));
+vi.mock('react-native-reanimated', () => ({
+  default: { View: 'Animated.View' },
+  FadeIn: { duration: () => ({}) },
+  FadeOut: { duration: () => ({}) },
+  LinearTransition: { duration: () => ({}) },
+}));
+vi.mock('react-native-safe-area-context', () => ({
+  useSafeAreaInsets: () => ({ bottom: 0, left: 0, right: 0, top: 0 }),
+}));
+vi.mock('react-i18next', async importOriginal => {
+  const actual = await importOriginal<typeof ReactI18next>();
+  return {
+    ...actual,
+    useTranslation: () => ({ t: (key: string) => key }),
+  };
+});
+
+// ── jotai + session provider ───────────────────────────────────────────────
+vi.mock('jotai', () => ({
+  useAtomValue: (atom: { value: unknown }) => atom.value,
+  useSetAtom: () => vi.fn(),
+  useStore: () => ({ get: (atom: { value: unknown }) => atom.value, sub: vi.fn(() => vi.fn()) }),
+}));
+vi.mock('@/components/agents/session-provider', () => ({
+  useSessionManager: () => hoisted.managerRef.current,
+}));
+
+// ── hooks and libs ─────────────────────────────────────────────────────────
+vi.mock('@/lib/utils', () => ({
+  cn: (...classes: (string | false | null | undefined)[]) => classes.filter(Boolean).join(' '),
+}));
+vi.mock('@/lib/intl-cache', () => ({
+  dateTimeFormat: vi.fn(() => ({ format: () => '' })),
+  relativeTimeFormat: vi.fn(() => ({ format: () => '' })),
+}));
+vi.mock('@/lib/analytics/posthog', () => ({
+  captureEvent: vi.fn(),
+  MESSAGE_SENT_EVENT: 'message_sent',
+  SESSION_VIEWED_EVENT: 'session_viewed',
+}));
+vi.mock('@/lib/a11y/announce', () => ({
+  moveA11yFocus: () => false,
+  announceForA11y: hoisted.announce,
+}));
+vi.mock('@/lib/persist/drafts', () => ({
+  agentComposerDraftKey: (id: string) => `agent-composer:${id}`,
+}));
+vi.mock('@/lib/persist/use-draft-load', () => ({
+  useFencedDraftLoad: () => ({ settled: true, value: null }),
+}));
+vi.mock('@/lib/hooks/use-current-user-id', () => ({
+  useCurrentUserId: () => ({ isLoading: false, userId: undefined }),
+}));
+vi.mock('@/lib/hooks/use-available-models', () => ({
+  useAvailableModels: () => ({ isLoading: false, models: [] }),
+}));
+vi.mock('@/lib/hooks/use-model-preferences', () => ({
+  useModelPreferences: () => ({ setLastSelected: vi.fn() }),
+}));
+vi.mock('@/lib/hooks/use-persisted-agent-model', () => ({
+  usePersistedAgentModel: () => ({ saveModel: vi.fn() }),
+}));
+vi.mock('@/lib/hooks/use-keep-screen-on-preference', () => ({
+  useKeepScreenOnPreference: () => ({ hasLoaded: true, keepScreenOn: false }),
+}));
+vi.mock('@/lib/hooks/use-reasoning-preference', () => ({
+  useReasoningPreference: () => ({ defaultExpanded: false }),
+}));
+vi.mock('@/lib/hooks/use-session-model-options', () => ({
+  createRemoteModelOverride: vi.fn(),
+  revalidateLegacyGatewayOverride: vi.fn(),
+  useSessionModelOptions: () => ({ options: [], selectedValue: null, selectedVariant: null }),
+}));
+vi.mock('@/lib/use-github-repos-refresh', () => ({
+  useGitHubReposRefresh: () => ({ openGitHubIntegration: vi.fn() }),
+}));
+vi.mock('@/lib/session-context-info', () => ({
+  resolveSessionContextInfo: () => null,
+}));
+vi.mock('@/lib/picker-bridge', () => ({
+  areModelPickerSelectionScopesEqual: () => true,
+}));
+
+// ── agent hooks ────────────────────────────────────────────────────────────
+vi.mock('@/components/agents/use-continue-session', () => ({
+  useContinueSession: () => ({
+    clearGuidance: vi.fn(),
+    continueSession: vi.fn(),
+    guidance: null,
+    isContinuing: false,
+  }),
+}));
+vi.mock('@/components/agents/use-interaction-handlers', () => ({
+  useInteractionHandlers: () => ({
+    handleAnswerQuestion: vi.fn(),
+    handleRejectQuestion: vi.fn(),
+    handleRespondToPermission: vi.fn(),
+    isAnswering: false,
+    isRespondingToPermission: false,
+    permissionSubmissionError: null,
+    questionSubmissionError: null,
+  }),
+}));
+vi.mock('@/components/agents/use-session-config-sync', () => ({
+  useSessionConfigSync: () => ({
+    currentMode: 'code',
+    currentModel: undefined,
+    currentVariant: '',
+    setCurrentMode: vi.fn(),
+    setCurrentModel: vi.fn(),
+    setCurrentVariant: vi.fn(),
+  }),
+}));
+vi.mock('@/components/agents/use-session-detail-rename', () => ({
+  useSessionDetailRename: () => ({
+    closeModal: vi.fn(),
+    isModalOpen: false,
+    isTitleInteractive: false,
+    modalInitialValue: '',
+    openModal: vi.fn(),
+    submit: vi.fn(),
+    title: 'Test session',
+  }),
+}));
+vi.mock('@/components/kilo-chat/hooks/use-cli-session-presence', () => ({
+  resolveLoadedCliSessionPresenceId: () => null,
+  useCliSessionPresence: vi.fn(),
+}));
+
+// ── pure helpers the component still calls ────────────────────────────────
+vi.mock('@/components/agents/agent-interaction-policy', () => ({
+  getBlockingInteraction: () => 'none',
+}));
+vi.mock('@/components/agents/mode-normalize', () => ({
+  customModeOptionsFromRuntimeAgents: () => [],
+  dedupeCustomModeOptions: (options: unknown) => options,
+  ensureSelectedCustomOption: (options: unknown) => options,
+  lockedModelOption: () => ({}),
+  resolvePinnedAgentModel: () => ({}),
+}));
+vi.mock('@/components/agents/queued-badge-hold', () => ({
+  nextHeldQueuedIds: (held: unknown) => held,
+}));
+vi.mock('@/components/agents/session-keyboard-container-state', () => ({
+  getSessionKeyboardContainerKind: () => 'app-aware-padding',
+}));
+vi.mock('@/components/agents/context-usage-display', () => ({
+  getContextSheetMountState: () => ({ mounted: false, visible: false }),
+}));
+vi.mock('@/components/agents/session-composer-disabled', () => ({
+  resolveSessionComposerDisabled: () => false,
+}));
+vi.mock('@/components/agents/session-list-helpers', () => ({
+  selectSessionCostInputs: () => ({ breakdownCostUsd: null, totalMicrodollars: null }),
+}));
+vi.mock('@/components/agents/mobile-session-manager-helpers', () => ({
+  buildRemoteAttachmentParts: vi.fn(),
+}));
+vi.mock('@/components/agents/session-working-state', () => ({
+  shouldShowAgentWorkingIndicator: () => false,
+  shouldShowFooterWorkingIndicator: () => false,
+  shouldShowSessionFooterRow: () => false,
+}));
+vi.mock('@/components/agents/session-keep-awake', () => ({
+  shouldKeepSessionAwake: () => false,
+}));
+vi.mock('@/components/agents/session-focus-refetch', () => ({
+  shouldRefetchOnFocus: () => false,
+}));
+vi.mock('@/components/agents/session-terminal-error', () => ({
+  buildTerminalErrorCopyText: () => '',
+  resolveSessionTerminalError: () => null,
+}));
+vi.mock('@/components/agents/child-session-card-state', () => ({
+  getChildSessionStreaming: () => false,
+}));
+vi.mock('@/components/agents/child-session-sheet-state', () => ({
+  closeChildSessionSheet: vi.fn(),
+  openChildSessionSheet: vi.fn(),
+  releaseChildSessionSheet: vi.fn(),
+}));
+vi.mock('@/components/agents/use-message-copy', () => ({
+  performCopy: vi.fn(),
+}));
+vi.mock('@/components/agents/session-detail-content-helpers', () => ({
+  countInFlightMessages: () => 0,
+  resolveRetryPrompt: () => null,
+  retryMessageAndClear: vi.fn(),
+}));
+vi.mock('@/components/agents/create-and-navigate-agent-session', () => ({
+  createAndNavigateAgentSession: vi.fn(),
+}));
+vi.mock('@/components/agents/exit-remote-session-with-feedback', () => ({
+  exitRemoteSessionWithFeedback: vi.fn(),
+}));
+vi.mock('@/components/agents/restart-agent-session', () => ({
+  restartAgentSession: vi.fn(),
+}));
+
+// ── sub-components ─────────────────────────────────────────────────────────
+// ChatComposer is the only non-string mock: it binds the composer control
+// handle and captures its props so the suite can drive `onSend`.
+vi.mock('@/components/agents/chat-composer', async () => {
+  const React = await import('react');
+  return {
+    ChatComposer: (props: {
+      controlRef?: React.Ref<unknown>;
+      onSend?: (text: string, options?: Record<string, unknown>) => Promise<void> | void;
+    }) => {
+      hoisted.chatComposer.lastProps = props;
+      React.useImperativeHandle(props.controlRef, () => hoisted.chatComposer.control);
+      return React.createElement('ChatComposer', null);
+    },
+  };
+});
+vi.mock('@/components/agents/message-bubble', () => ({
+  MessageBubble: 'MessageBubble',
+}));
+vi.mock('@/components/agents/session-message-list', () => ({
+  SessionMessageList: 'SessionMessageList',
+}));
+vi.mock('@/components/agents/model-selector', () => ({
+  ModelPickerSelectionScopeProvider: 'ModelPickerSelectionScopeProvider',
+}));
+vi.mock('@/components/agents/permission-card', () => ({
+  PermissionCard: 'PermissionCard',
+}));
+vi.mock('@/components/agents/question-card', () => ({
+  QuestionCard: 'QuestionCard',
+}));
+vi.mock('@/components/agents/session-connection-indicator', () => ({
+  SessionConnectionIndicator: 'SessionConnectionIndicator',
+}));
+vi.mock('@/components/agents/session-context-metrics', () => ({
+  SessionContextMetrics: 'SessionContextMetrics',
+}));
+vi.mock('@/components/agents/session-context-sheet', () => ({
+  SessionContextSheet: 'SessionContextSheet',
+}));
+vi.mock('@/components/agents/session-pr-badge', () => ({
+  SessionPrBadge: 'SessionPrBadge',
+}));
+vi.mock('@/components/agents/session-status-indicator', () => ({
+  SessionStatusIndicator: 'SessionStatusIndicator',
+}));
+vi.mock('@/components/agents/preparation-group', () => ({
+  PreparationGroup: 'PreparationGroup',
+}));
+vi.mock('@/components/agents/session-detail-skeleton', () => ({
+  SessionSkeletonMessages: 'SessionSkeletonMessages',
+}));
+vi.mock('@/components/agents/transcript-time-marker', () => ({
+  TranscriptTimeMarker: 'TranscriptTimeMarker',
+}));
+vi.mock('@/components/agents/working-indicator', () => ({
+  WorkingIndicator: 'WorkingIndicator',
+}));
+vi.mock('@/components/agents/child-session-sheet', () => ({
+  ChildSessionSheet: 'ChildSessionSheet',
+}));
+vi.mock('@/components/agents/part-detail-sheet-host', () => ({
+  PartDetailSheetHost: 'PartDetailSheetHost',
+}));
+vi.mock('@/components/agents/part-renderer', () => ({
+  PartRenderer: 'PartRenderer',
+}));
+vi.mock('@/components/empty-state', () => ({
+  EmptyState: 'EmptyState',
+}));
+vi.mock('@/components/kilo-chat/app-aware-keyboard-padding', () => ({
+  AppAwareKeyboardPaddingView: 'AppAwareKeyboardPaddingView',
+}));
+vi.mock('@/components/query-error', () => ({
+  QueryError: 'QueryError',
+}));
+vi.mock('@/components/rename-modal', () => ({
+  RenameModal: 'RenameModal',
+}));
+vi.mock('@/components/screen-header', () => ({
+  ScreenHeader: 'ScreenHeader',
+}));
+vi.mock('@/components/ui/blur-bar', () => ({
+  BlurBar: 'BlurBar',
+}));
+vi.mock('@/components/ui/button', () => ({
+  Button: 'Button',
+}));
+vi.mock('@/components/ui/text', () => ({
+  Text: 'Text',
+}));
+vi.mock('@/components/ui/icons', () => ({
+  MessageSquare: 'MessageSquare',
+}));
+
+const { SessionDetailContent } = await import('@/components/agents/session-detail-content');
+
+const SESSION_ID = 'sess-1' as KiloSessionId;
+
+function makeManager() {
+  return {
+    atoms: {
+      messagesList: { value: [] as StoredMessage[] },
+      isLoading: { value: false },
+      error: { value: null },
+      fetchedSessionData: {
+        value: {
+          associatedPr: null,
+          cloudAgentSessionId: undefined,
+          gitUrl: undefined,
+          kiloSessionId: SESSION_ID,
+          mode: undefined,
+          organizationId: undefined,
+          title: 'Test session',
+          totalCostMicrodollars: null,
+        },
+      },
+      sessionConfig: { value: null },
+      isStreaming: { value: false },
+      statusIndicator: { value: null },
+      agentStatus: { value: { type: 'connected' } },
+      cloudStatus: { value: null },
+      preparationAttempts: { value: [] },
+      canSend: { value: true },
+      isReadOnly: { value: false },
+      supportsAttachments: { value: true },
+      activeQuestion: { value: null },
+      activePermission: { value: null },
+      activeSuggestion: { value: null },
+      pendingQuestions: { value: [] },
+      pendingPermissions: { value: [] },
+      totalCost: { value: null },
+      childMessages: { value: () => new Map() },
+      childSessionHydrationState: { value: () => ({ status: 'idle' }) },
+      childSessionError: { value: () => null },
+      pendingMessages: { value: new Map<string, { status: string }>() },
+      activeSessionType: { value: null },
+      remoteModelState: {
+        value: { catalog: null, ownerConnectionId: null as string | null, protocol: 'v1' },
+      },
+      observedModel: { value: null },
+      remoteModelOverride: { value: null },
+      cloudAgentModelOverride: { value: null },
+      availableCommands: { value: [] },
+      remoteCommandState: { value: null },
+      contextUsage: { value: null },
+      hasOlderMessages: { value: false },
+      isLoadingOlderMessages: { value: false },
+      olderMessagesError: { value: null },
+      olderMessagesOmittedItemCount: { value: 0 },
+    },
+    switchSession: vi.fn(),
+    send: vi.fn(),
+    cancelQueuedMessage: vi.fn(),
+    acceptSuggestion: vi.fn(),
+    dismissSuggestion: vi.fn(),
+    interrupt: vi.fn(),
+    setCloudAgentModelOverride: vi.fn(),
+    setRemoteModelOverride: vi.fn(),
+    updateFetchedAssociatedPr: vi.fn(),
+    hydrateChildSession: vi.fn(),
+    loadOlderMessages: vi.fn(),
+    trimRetainedHistory: vi.fn(),
+    loadOlderChildMessages: vi.fn(),
+    clearFailedMessage: vi.fn(),
+    createRemoteSession: vi.fn(),
+    exitRemoteSession: vi.fn(),
+    destroy: vi.fn(),
+  };
+}
+
+type TestManager = ReturnType<typeof makeManager>;
+
+let currentManager: TestManager = makeManager();
+
+const TEXT_PART = { type: 'text', text: 'Queued prompt' } as const;
+const FILE_PART = {
+  type: 'file',
+  filename: 'a.pdf',
+  mime: 'application/pdf',
+  url: 'file:///tmp/attachments/sess-1/user-1/msg-1/a.pdf',
+} as const;
+
+function queuedMessage(parts: readonly unknown[] = [TEXT_PART]): StoredMessage {
+  return {
+    info: { id: 'msg-queued-1', role: 'user', time: { created: undefined } },
+    parts,
+  } as unknown as StoredMessage;
+}
+
+function mount(): TestRenderer.ReactTestRenderer {
+  const ref: { current: TestRenderer.ReactTestRenderer | undefined } = { current: undefined };
+  act(() => {
+    ref.current = TestRenderer.create(
+      createElement(SessionDetailContent, { sessionId: SESSION_ID })
+    );
+  });
+  if (!ref.current) {
+    throw new Error('SessionDetailContent did not render');
+  }
+  return ref.current;
+}
+
+function findByType(
+  renderer: TestRenderer.ReactTestRenderer,
+  type: ElementType
+): TestRenderer.ReactTestInstance[] {
+  return renderer.root.findAllByType(type);
+}
+
+/** Reads the MessageBubble element the current transcript renders for `messageId`. */
+function readBubble(
+  renderer: TestRenderer.ReactTestRenderer,
+  messageId: string
+): ReactElement | undefined {
+  const lists = findByType(renderer, SessionMessageList);
+  const listProps = lists[0]?.props as
+    | {
+        items?: SessionTranscriptItem[];
+        renderItem?: (args: { item: SessionTranscriptItem }) => ReactElement;
+      }
+    | undefined;
+  const item = listProps?.items?.find(
+    candidate => candidate.type === 'message' && candidate.message.info.id === messageId
+  );
+  if (!item || !listProps?.renderItem) {
+    return undefined;
+  }
+  return listProps.renderItem({ item });
+}
+
+function bubbleProps(
+  renderer: TestRenderer.ReactTestRenderer,
+  messageId: string
+): Record<string, unknown> {
+  return (readBubble(renderer, messageId)?.props ?? {}) as Record<string, unknown>;
+}
+
+function detailsProps(renderer: TestRenderer.ReactTestRenderer) {
+  return renderer.root.findByType(MessageDetailsSheet).props as Parameters<
+    typeof MessageDetailsSheet
+  >[0];
+}
+
+function cancellationRow(renderer: TestRenderer.ReactTestRenderer) {
+  return findByType(renderer, Pressable).find(
+    node => node.props.testID === 'message-details-cancel-queued'
+  );
+}
+
+function cancellationPress(renderer: TestRenderer.ReactTestRenderer): () => void {
+  const row = cancellationRow(renderer);
+  if (!row) {
+    throw new Error('Cancellation row is missing');
+  }
+  return row.props.onPress as () => void;
+}
+
+function openDetails(renderer: TestRenderer.ReactTestRenderer, message: StoredMessage): void {
+  const open = bubbleProps(renderer, message.info.id).onLongPressDetails as (
+    message: StoredMessage
+  ) => void;
+  act(() => {
+    open(message);
+  });
+}
+
+function closeDetails(renderer: TestRenderer.ReactTestRenderer): void {
+  const close = findByType(renderer, Modal)[0]?.props.onRequestClose as () => void;
+  act(() => {
+    close();
+  });
+}
+
+function updateScreen(renderer: TestRenderer.ReactTestRenderer): void {
+  act(() => {
+    renderer.update(createElement(SessionDetailContent, { sessionId: SESSION_ID }));
+  });
+}
+
+function unmountScreen(renderer: TestRenderer.ReactTestRenderer): void {
+  act(() => {
+    renderer.unmount();
+  });
+}
+
+function statusMessages(renderer: TestRenderer.ReactTestRenderer): string[] {
+  return renderer.root
+    .findAllByType(AccessibleStatus)
+    .map(node => node.props.message as string | null)
+    .filter(message => message !== null);
+}
+
+beforeEach(() => {
+  currentManager = makeManager();
+  hoisted.managerRef.current = currentManager;
+  hoisted.chatComposer.lastProps = null;
+  hoisted.chatComposer.draft.text = '';
+  hoisted.chatComposer.draft.files = [];
+  hoisted.chatComposer.control.hasContent.mockClear();
+  hoisted.chatComposer.control.setText.mockClear();
+  hoisted.chatComposer.control.restoreAttachments.mockClear();
+  hoisted.announce.mockClear();
+});
+
+describe('SessionDetailContent cancel/restore', () => {
+  function seedQueuedMessage(message: StoredMessage = queuedMessage()): void {
+    currentManager.atoms.messagesList.value = [message];
+    currentManager.atoms.pendingMessages.value = new Map([[message.info.id, { status: 'queued' }]]);
+  }
+
+  const failed = 'agentChat.session.cancelQueuedFailed';
+  const restored = 'agentChat.session.cancelQueuedRestored';
+  const restoreAvailable = 'agentChat.session.cancelQueuedRestoreAvailable';
+
+  it('exposes no cancellation without a selected message', () => {
+    seedQueuedMessage();
+    const renderer = mount();
+    expect(detailsProps(renderer).visible).toBe(false);
+    expect(detailsProps(renderer).message).toBeNull();
+    expect(cancellationRow(renderer)).toBeUndefined();
+    unmountScreen(renderer);
+  });
+
+  it.each([
+    'accepted',
+    'running',
+    'canceled',
+    'failed',
+    'missing',
+    'assistant',
+    'untracked',
+    'future',
+  ])('rejects stale activation and updates the open sheet for %s', async state => {
+    const message = queuedMessage();
+    seedQueuedMessage(message);
+    const renderer = mount();
+    openDetails(renderer, message);
+    const stalePress = cancellationPress(renderer);
+    expect(detailsProps(renderer).canCancelQueued).toBe(true);
+    if (state === 'missing') {
+      currentManager.atoms.messagesList.value = [];
+    } else if (state === 'assistant') {
+      currentManager.atoms.messagesList.value = [assistantMessage(message.info.id)];
+    } else if (state === 'untracked') {
+      currentManager.atoms.pendingMessages.value = new Map();
+    } else {
+      currentManager.atoms.pendingMessages.value = new Map([[message.info.id, { status: state }]]);
+    }
+    await act(async () => {
+      stalePress();
+      await Promise.resolve();
+    });
+    updateScreen(renderer);
+    expect(detailsProps(renderer).canCancelQueued).toBe(false);
+    expect(cancellationRow(renderer)).toBeUndefined();
+    expect(detailsProps(renderer).message).toBe(currentManager.atoms.messagesList.value[0] ?? null);
+    expect(currentManager.cancelQueuedMessage).not.toHaveBeenCalled();
+    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+    expect(statusMessages(renderer)).toEqual([]);
+    seedQueuedMessage(message);
+    updateScreen(renderer);
+    expect(detailsProps(renderer).canCancelQueued).toBe(true);
+    expect(cancellationRow(renderer)).toBeDefined();
+    unmountScreen(renderer);
+  });
+
+  it('uses current message parts rather than the selected snapshot at invocation', async () => {
+    const selected = queuedMessage();
+    seedQueuedMessage(selected);
+    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
+    const renderer = mount();
+    openDetails(renderer, selected);
+    const press = cancellationPress(renderer);
+    const current = queuedMessage([{ ...TEXT_PART, text: 'Current prompt' }, FILE_PART]);
+    currentManager.atoms.messagesList.value = [current];
+    await act(async () => {
+      press();
+      await Promise.resolve();
+    });
+    expect(hoisted.chatComposer.draft).toEqual({ text: 'Current prompt', files: [FILE_PART] });
+    expect(readBubble(renderer, selected.info.id)).toBeUndefined();
+    expect(statusMessages(renderer)).toEqual([restored]);
+    unmountScreen(renderer);
+  });
+
+  describe.each([false, true])('composer occupied=%s', occupied => {
+    it.each([
+      { name: 'text', parts: [TEXT_PART], text: 'Queued prompt', files: [] },
+      {
+        name: 'text and files',
+        parts: [TEXT_PART, FILE_PART],
+        text: 'Queued prompt',
+        files: [FILE_PART],
+      },
+      { name: 'file-only', parts: [FILE_PART], text: '', files: [FILE_PART] },
+    ])('cancels $name once and preserves its restoration path', async ({ parts, text, files }) => {
+      const message = queuedMessage(parts);
+      seedQueuedMessage(message);
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+      const original = {
+        text: occupied ? 'Existing draft' : '',
+        files: occupied ? [{ filename: 'draft.txt' }] : [],
+      };
+      Object.assign(hoisted.chatComposer.draft, original);
+      const renderer = mount();
+      openDetails(renderer, message);
+      const press = cancellationPress(renderer);
+      act(() => {
+        press();
+        press();
+      });
+      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
+      expect(detailsProps(renderer).canCancelQueued).toBe(false);
+      expect(detailsProps(renderer).isCancelingQueued).toBe(true);
+      expect(cancellationRow(renderer)?.props.accessibilityState).toEqual({
+        disabled: true,
+        busy: true,
+      });
+      expect(hoisted.chatComposer.draft).toEqual(original);
+      await act(async () => {
+        request.resolve({ dropped: true });
+        await request.promise;
+        press();
+      });
+      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
+      expect(detailsProps(renderer).visible).toBe(false);
+      expect(statusMessages(renderer)).toEqual([occupied ? restoreAvailable : restored]);
+      expect(hoisted.announce.mock.calls).toEqual([[occupied ? restoreAvailable : restored]]);
+      if (occupied) {
+        expect(hoisted.chatComposer.draft).toEqual(original);
+        expect(hoisted.chatComposer.control.setText).not.toHaveBeenCalled();
+        expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
+        expect(bubbleProps(renderer, message.info.id).deliveryState).toBeUndefined();
+        expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeInstanceOf(Function);
+        openDetails(renderer, message);
+        expect(detailsProps(renderer).canCancelQueued).toBe(false);
+        expect(cancellationRow(renderer)).toBeUndefined();
+        closeDetails(renderer);
+        currentManager.atoms.messagesList.value = [];
+        currentManager.atoms.pendingMessages.value = new Map();
+        updateScreen(renderer);
+        const restore = bubbleProps(renderer, message.info.id).onRestoreQueued as (
+          message: StoredMessage
+        ) => void;
+        expect(restore).toBeInstanceOf(Function);
+        act(() => {
+          restore(message);
+        });
+        expect(statusMessages(renderer)).toEqual([restored]);
+        expect(hoisted.announce.mock.calls).toEqual([[restoreAvailable], [restored]]);
+      }
+      expect(hoisted.chatComposer.draft).toEqual({ text: text || original.text, files });
+      expect(hoisted.chatComposer.control.setText).toHaveBeenCalledTimes(text ? 1 : 0);
+      expect(hoisted.chatComposer.control.restoreAttachments).toHaveBeenCalledTimes(1);
+      expect(readBubble(renderer, message.info.id)).toBeUndefined();
+      unmountScreen(renderer);
+    });
+
+    it.each(['false', 'rejection'])(
+      'preserves the message and composer after retryable %s with matching sheet feedback',
+      async outcome => {
+        const message = queuedMessage([TEXT_PART, FILE_PART]);
+        seedQueuedMessage(message);
+        const original = {
+          text: occupied ? 'Keep my draft' : '',
+          files: occupied ? [{ filename: 'draft.txt' }] : [],
+        };
+        Object.assign(hoisted.chatComposer.draft, original);
+        if (outcome === 'false') {
+          currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: false });
+        } else {
+          currentManager.cancelQueuedMessage.mockRejectedValue(
+            Object.assign(new Error(outcome), { code: 'SERVICE_UNAVAILABLE' })
+          );
+        }
+        const renderer = mount();
+        openDetails(renderer, message);
+        await act(async () => {
+          cancellationPress(renderer)();
+          await Promise.resolve();
+        });
+        expect(hoisted.chatComposer.draft).toEqual(original);
+        expect(currentManager.atoms.messagesList.value).toEqual([message]);
+        expect(readBubble(renderer, message.info.id)).toBeDefined();
+        expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeUndefined();
+        expect(detailsProps(renderer).canCancelQueued).toBe(true);
+        expect(detailsProps(renderer).isCancelingQueued).toBe(false);
+        expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
+        expect(statusMessages(renderer)).toEqual([failed]);
+        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(failed);
+        expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+        expect(currentManager.interrupt).not.toHaveBeenCalled();
+        expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
+        unmountScreen(renderer);
+      }
+    );
+
+    it('retains upgrade guidance and blocks unsupported cancellation across message selections', async () => {
+      const message = queuedMessage([TEXT_PART, FILE_PART]);
+      const second = { ...message, info: { ...message.info, id: 'msg-queued-2' } };
+      currentManager.atoms.messagesList.value = [message, second];
+      currentManager.atoms.pendingMessages.value = new Map(
+        [message, second].map(item => [item.info.id, { status: 'queued' }])
+      );
+      const original = {
+        text: occupied ? 'Keep my draft' : '',
+        files: occupied ? [{ filename: 'draft.txt' }] : [],
+      };
+      Object.assign(hoisted.chatComposer.draft, original);
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage
+        .mockReturnValueOnce(request.promise)
+        .mockResolvedValue({ dropped: true });
+      const renderer = mount();
+      openDetails(renderer, second);
+      const staleSecondPress = cancellationPress(renderer);
+      openDetails(renderer, message);
+      const stalePress = cancellationPress(renderer);
+      act(() => {
+        stalePress();
+      });
+      await act(async () => {
+        request.reject(
+          Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+        );
+        await Promise.resolve();
+        stalePress();
+        staleSecondPress();
+      });
+      const upgrade = 'agentChat.session.cancelQueuedUpgradeRequired';
+      expect(detailsProps(renderer).visible).toBe(true);
+      expect(detailsProps(renderer).canCancelQueued).toBe(false);
+      expect(detailsProps(renderer).isCancelingQueued).toBe(false);
+      expect(cancellationRow(renderer)).toBeUndefined();
+      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(upgrade);
+      expect(statusMessages(renderer)).toEqual([upgrade]);
+      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
+      closeDetails(renderer);
+      openDetails(renderer, message);
+      expect(cancellationRow(renderer)).toBeUndefined();
+      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
+      expect(statusMessages(renderer)).toEqual([]);
+      openDetails(renderer, second);
+      expect(cancellationRow(renderer)).toBeUndefined();
+      expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
+      expect(statusMessages(renderer)).toEqual([]);
+      expect(hoisted.chatComposer.draft).toEqual(original);
+      expect(currentManager.atoms.messagesList.value).toEqual([message, second]);
+      expect(readBubble(renderer, message.info.id)).toBeDefined();
+      expect(readBubble(renderer, second.info.id)).toBeDefined();
+      expect(bubbleProps(renderer, message.info.id).onRestoreQueued).toBeUndefined();
+      expect(bubbleProps(renderer, second.info.id).onRestoreQueued).toBeUndefined();
+      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
+      expect(currentManager.interrupt).not.toHaveBeenCalled();
+      expect(hoisted.chatComposer.control.restoreAttachments).not.toHaveBeenCalled();
+      expect(hoisted.announce.mock.calls).toEqual([[upgrade]]);
+      unmountScreen(renderer);
+    });
+  });
+
+  it.each([false, true])(
+    'restores cancellation only for a replacement CLI connection, sheet closed=%s',
+    async closed => {
+      const message = queuedMessage([TEXT_PART, FILE_PART]);
+      seedQueuedMessage(message);
+      currentManager.atoms.remoteModelState.value.ownerConnectionId = 'cli-1';
+      currentManager.cancelQueuedMessage.mockRejectedValueOnce(
+        Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+      );
+      const renderer = mount();
+      openDetails(renderer, message);
+      const stalePress = cancellationPress(renderer);
+      await act(async () => {
+        stalePress();
+        await Promise.resolve();
+      });
+      const upgrade = 'agentChat.session.cancelQueuedUpgradeRequired';
+      expect(cancellationRow(renderer)).toBeUndefined();
+      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+      if (closed) {
+        closeDetails(renderer);
+        openDetails(renderer, message);
+        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
+        expect(statusMessages(renderer)).toEqual([]);
+      }
+
+      for (const ownerConnectionId of ['cli-1', null, 'cli-1']) {
+        currentManager.atoms.remoteModelState.value = {
+          ...currentManager.atoms.remoteModelState.value,
+          ownerConnectionId,
+        };
+        currentManager.atoms.agentStatus.value = {
+          type: ownerConnectionId === null ? 'disconnected' : 'connected',
+        };
+        currentManager.atoms.supportsAttachments.value = ownerConnectionId !== null;
+        updateScreen(renderer);
+        act(() => {
+          stalePress();
+        });
+        expect(cancellationRow(renderer)).toBeUndefined();
+        expect(findByType(renderer, Text).map(node => node.props.children)).toContain(upgrade);
+        expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
+        expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+      }
+      if (closed) {
+        closeDetails(renderer);
+      }
+      currentManager.atoms.remoteModelState.value = {
+        ...currentManager.atoms.remoteModelState.value,
+        ownerConnectionId: 'cli-2',
+      };
+      updateScreen(renderer);
+      if (closed) {
+        openDetails(renderer, message);
+      }
+      expect(detailsProps(renderer).message).toBe(message);
+      expect(cancellationRow(renderer)).toBeDefined();
+      expect(detailsProps(renderer).canCancelQueued).toBe(true);
+      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+      expect(findByType(renderer, Text).map(node => node.props.children)).not.toContain(upgrade);
+      expect(hoisted.announce.mock.calls).toEqual([[upgrade]]);
+      currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
+      await act(async () => {
+        cancellationPress(renderer)();
+        await Promise.resolve();
+      });
+      expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [FILE_PART] });
+      expect(readBubble(renderer, message.info.id)).toBeUndefined();
+      expect(detailsProps(renderer).visible).toBe(false);
+      expect(statusMessages(renderer)).toEqual([restored]);
+      expect(hoisted.announce.mock.calls).toEqual([[upgrade], [restored]]);
+      unmountScreen(renderer);
+    }
+  );
+
+  it.each([false, true])(
+    'reports a late upgrade failure once without disabling the replacement, sheet dismissed=%s',
+    async dismissed => {
+      const message = queuedMessage();
+      seedQueuedMessage(message);
+      currentManager.atoms.remoteModelState.value.ownerConnectionId = 'cli-1';
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage.mockReturnValueOnce(request.promise);
+      const renderer = mount();
+      openDetails(renderer, message);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      if (dismissed) {
+        closeDetails(renderer);
+      }
+      currentManager.atoms.remoteModelState.value = {
+        ...currentManager.atoms.remoteModelState.value,
+        ownerConnectionId: 'cli-2',
+      };
+      updateScreen(renderer);
+      await act(async () => {
+        request.reject(
+          Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+        );
+        await Promise.resolve();
+      });
+      expect(detailsProps(renderer).visible).toBe(!dismissed);
+      expect(detailsProps(renderer).isCancelingQueued).toBe(false);
+      expect(detailsProps(renderer).cancelQueuedFeedback?.message ?? null).toBe(
+        dismissed ? null : failed
+      );
+      expect(detailsProps(renderer).cancelQueuedGuidance).toBeNull();
+      expect(statusMessages(renderer)).toEqual([failed]);
+      const visibleText = findByType(renderer, Text).map(node => node.props.children);
+      expect(visibleText.filter(text => text === failed)).toHaveLength(1);
+      expect(visibleText).not.toContain('agentChat.session.cancelQueuedUpgradeRequired');
+      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+      expect(readBubble(renderer, message.info.id)).toBeDefined();
+      if (dismissed) {
+        openDetails(renderer, message);
+      }
+      expect(detailsProps(renderer).canCancelQueued).toBe(true);
+      expect(cancellationRow(renderer)?.props.accessibilityState).toEqual({
+        disabled: false,
+        busy: false,
+      });
+      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+      currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
+      await act(async () => {
+        cancellationPress(renderer)();
+        await Promise.resolve();
+      });
+      expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [] });
+      expect(readBubble(renderer, message.info.id)).toBeUndefined();
+      expect(detailsProps(renderer).visible).toBe(false);
+      expect(statusMessages(renderer)).toEqual([restored]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed], [restored]]);
+      unmountScreen(renderer);
+    }
+  );
+
+  it('keeps the occupied Restore path usable before late delivery events', async () => {
+    const message = queuedMessage([TEXT_PART, FILE_PART]);
+    seedQueuedMessage(message);
+    const request = Promise.withResolvers<{ dropped: boolean }>();
+    currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+    const renderer = mount();
+    openDetails(renderer, message);
+    act(() => {
+      cancellationPress(renderer)();
+    });
+    const typedDraft = { text: 'Typed while waiting', files: [{ filename: 'draft.txt' }] };
+    Object.assign(hoisted.chatComposer.draft, typedDraft);
+    await act(async () => {
+      request.resolve({ dropped: true });
+      await request.promise;
+    });
+    expect(hoisted.chatComposer.draft).toEqual(typedDraft);
+    expect(bubbleProps(renderer, message.info.id).deliveryState).toBeUndefined();
+    const restore = bubbleProps(renderer, message.info.id).onRestoreQueued as (
+      message: StoredMessage
+    ) => void;
+    act(() => {
+      restore(message);
+    });
+    updateScreen(renderer);
+    expect(hoisted.chatComposer.draft).toEqual({ text: 'Queued prompt', files: [FILE_PART] });
+    expect(readBubble(renderer, message.info.id)).toBeUndefined();
+    expect(currentManager.atoms.messagesList.value).toEqual([message]);
+    expect(hoisted.announce.mock.calls).toEqual([[restoreAvailable], [restored]]);
+    unmountScreen(renderer);
+  });
+
+  it.each(['success', 'upgrade'])(
+    'ignores an old %s outcome in a different session',
+    async outcome => {
+      const message = queuedMessage();
+      seedQueuedMessage(message);
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+      const renderer = mount();
+      openDetails(renderer, message);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      const nextSessionId = 'sess-2' as KiloSessionId;
+      const nextMessage = queuedMessage([{ ...TEXT_PART, text: 'Next session prompt' }]);
+      seedQueuedMessage(nextMessage);
+      currentManager.atoms.fetchedSessionData.value.kiloSessionId = nextSessionId;
+      act(() => {
+        renderer.update(createElement(SessionDetailContent, { sessionId: nextSessionId }));
+      });
+      await act(async () => {
+        if (outcome === 'upgrade') {
+          request.reject(
+            Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+          );
+        } else {
+          request.resolve({ dropped: true });
+        }
+        await Promise.resolve();
+      });
+      expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+      expect(detailsProps(renderer).visible).toBe(false);
+      expect(statusMessages(renderer)).toEqual([]);
+      expect(hoisted.announce).not.toHaveBeenCalled();
+      openDetails(renderer, nextMessage);
+      expect(detailsProps(renderer).canCancelQueued).toBe(true);
+      expect(cancellationRow(renderer)).toBeDefined();
+      unmountScreen(renderer);
+    }
+  );
+
+  it('does not carry known unsupported cancellation into a different session', async () => {
+    const message = queuedMessage();
+    seedQueuedMessage(message);
+    currentManager.cancelQueuedMessage.mockRejectedValueOnce(
+      Object.assign(new Error('Upgrade required'), { code: 'CLI_UPGRADE_REQUIRED' })
+    );
+    const renderer = mount();
+    openDetails(renderer, message);
+    await act(async () => {
+      cancellationPress(renderer)();
+      await Promise.resolve();
+    });
+    expect(cancellationRow(renderer)).toBeUndefined();
+    const nextSessionId = 'sess-2' as KiloSessionId;
+    const nextMessage = queuedMessage([{ ...TEXT_PART, text: 'Next session prompt' }]);
+    seedQueuedMessage(nextMessage);
+    currentManager.atoms.fetchedSessionData.value.kiloSessionId = nextSessionId;
+    act(() => {
+      renderer.update(createElement(SessionDetailContent, { sessionId: nextSessionId }));
+    });
+    openDetails(renderer, nextMessage);
+    expect(statusMessages(renderer)).toEqual([]);
+    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: true });
+    await act(async () => {
+      cancellationPress(renderer)();
+      await Promise.resolve();
+    });
+    expect(hoisted.chatComposer.draft).toEqual({ text: 'Next session prompt', files: [] });
+    expect(readBubble(renderer, nextMessage.info.id)).toBeUndefined();
+    expect(statusMessages(renderer)).toEqual([restored]);
+    unmountScreen(renderer);
+  });
+
+  it('removes a busy row when the live queue becomes running', async () => {
+    const message = queuedMessage();
+    seedQueuedMessage(message);
+    const request = Promise.withResolvers<{ dropped: boolean }>();
+    currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+    const renderer = mount();
+    openDetails(renderer, message);
+    const press = cancellationPress(renderer);
+    act(() => {
+      press();
+    });
+    currentManager.atoms.pendingMessages.value = new Map([
+      [message.info.id, { status: 'running' }],
+    ]);
+    updateScreen(renderer);
+    expect(cancellationRow(renderer)).toBeUndefined();
+    expect(detailsProps(renderer).isCancelingQueued).toBe(false);
+    await act(async () => {
+      press();
+      request.resolve({ dropped: false });
+      await request.promise;
+    });
+    expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[message.info.id]]);
+    expect(cancellationRow(renderer)).toBeUndefined();
+    expect(readBubble(renderer, message.info.id)).toBeDefined();
+    expect(statusMessages(renderer)).toEqual([failed]);
+    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+    unmountScreen(renderer);
+  });
+
+  it.each([false, true])(
+    'clears both announcement inputs on retry without replay on dismissal, first dismissed=%s',
+    async dismissed => {
+      const message = queuedMessage();
+      seedQueuedMessage(message);
+      const first = Promise.withResolvers<{ dropped: boolean }>();
+      const retry = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage
+        .mockReturnValueOnce(first.promise)
+        .mockReturnValueOnce(retry.promise);
+      const renderer = mount();
+      openDetails(renderer, message);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      if (dismissed) {
+        closeDetails(renderer);
+      }
+      await act(async () => {
+        first.reject(new Error('offline'));
+        await Promise.resolve();
+      });
+      expect(statusMessages(renderer)).toEqual([failed]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+      if (dismissed) {
+        openDetails(renderer, message);
+      }
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      expect(statusMessages(renderer)).toEqual([]);
+      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+      expect(findByType(renderer, Text).map(node => node.props.children)).not.toContain(failed);
+      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+      await act(async () => {
+        retry.reject(new Error('offline'));
+        await Promise.resolve();
+      });
+      expect(statusMessages(renderer)).toEqual([failed]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
+      closeDetails(renderer);
+      expect(statusMessages(renderer)).toEqual([]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
+      openDetails(renderer, message);
+      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+      expect(hoisted.announce).toHaveBeenCalledTimes(2);
+      unmountScreen(renderer);
+    }
+  );
+
+  it('announces identical immediate failures once per attempt despite React batching', async () => {
+    const message = queuedMessage();
+    seedQueuedMessage(message);
+    currentManager.cancelQueuedMessage.mockResolvedValue({ dropped: false });
+    const renderer = mount();
+    openDetails(renderer, message);
+    await act(async () => {
+      cancellationPress(renderer)();
+      await Promise.resolve();
+    });
+    await act(async () => {
+      cancellationPress(renderer)();
+      await Promise.resolve();
+    });
+    expect(statusMessages(renderer)).toEqual([failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
+    unmountScreen(renderer);
+  });
+
+  it.each(['success', 'false', 'rejection'])(
+    'announces one outer %s outcome when dismissed while pending',
+    async outcome => {
+      const message = queuedMessage();
+      seedQueuedMessage(message);
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+      const renderer = mount();
+      openDetails(renderer, message);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      closeDetails(renderer);
+      expect(statusMessages(renderer)).toEqual([]);
+      await act(async () => {
+        if (outcome === 'rejection') {
+          request.reject(new Error('offline'));
+        } else {
+          request.resolve({ dropped: outcome === 'success' });
+        }
+        await Promise.resolve();
+      });
+      expect(detailsProps(renderer).visible).toBe(false);
+      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+      expect(statusMessages(renderer)).toEqual([outcome === 'success' ? restored : failed]);
+      expect(hoisted.announce.mock.calls).toEqual([[outcome === 'success' ? restored : failed]]);
+      expect(hoisted.chatComposer.draft.text).toBe(outcome === 'success' ? 'Queued prompt' : '');
+      closeDetails(renderer);
+      expect(hoisted.announce).toHaveBeenCalledTimes(1);
+      unmountScreen(renderer);
+    }
+  );
+
+  it.each([
+    { outcome: 'success', firstFeedback: restored },
+    { outcome: 'false', firstFeedback: failed },
+    { outcome: 'rejection', firstFeedback: failed },
+    { outcome: 'upgrade', firstFeedback: 'agentChat.session.cancelQueuedUpgradeRequired' },
+  ])(
+    'keeps the selected failure when A completes later with $outcome',
+    async ({ outcome, firstFeedback }) => {
+      const first = queuedMessage([TEXT_PART, FILE_PART]);
+      const second = {
+        ...queuedMessage([{ ...TEXT_PART, text: 'Second prompt' }]),
+        info: { ...first.info, id: 'msg-queued-2' },
+      };
+      currentManager.atoms.messagesList.value = [first, second];
+      currentManager.atoms.pendingMessages.value = new Map(
+        [first, second].map(message => [message.info.id, { status: 'queued' }])
+      );
+      const firstRequest = Promise.withResolvers<{ dropped: boolean }>();
+      const secondRequest = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage
+        .mockReturnValueOnce(firstRequest.promise)
+        .mockReturnValueOnce(secondRequest.promise);
+      const renderer = mount();
+      openDetails(renderer, first);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      closeDetails(renderer);
+      openDetails(renderer, second);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      await act(async () => {
+        secondRequest.resolve({ dropped: false });
+        await secondRequest.promise;
+      });
+      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
+      expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+      await act(async () => {
+        if (outcome === 'rejection' || outcome === 'upgrade') {
+          firstRequest.reject(
+            Object.assign(new Error(outcome), {
+              code: outcome === 'upgrade' ? 'CLI_UPGRADE_REQUIRED' : 'SERVICE_UNAVAILABLE',
+            })
+          );
+        } else {
+          firstRequest.resolve({ dropped: outcome === 'success' });
+        }
+        await Promise.resolve();
+      });
+      expect(detailsProps(renderer).visible).toBe(true);
+      expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
+      expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
+      expect(
+        renderer.root
+          .findByType(MessageDetailsSheet)
+          .findAll(node => node.type === Text && node.props.children === failed)
+      ).toHaveLength(1);
+      expect(detailsProps(renderer).canCancelQueued).toBe(outcome !== 'upgrade');
+      expect(statusMessages(renderer)).toEqual([firstFeedback, failed]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed], [firstFeedback]]);
+      expect(hoisted.chatComposer.draft).toEqual(
+        outcome === 'success'
+          ? { text: 'Queued prompt', files: [FILE_PART] }
+          : { text: '', files: [] }
+      );
+      expect(readBubble(renderer, second.info.id)).toBeDefined();
+      expect(bubbleProps(renderer, second.info.id).onRestoreQueued).toBeUndefined();
+      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([
+        [first.info.id],
+        [second.info.id],
+      ]);
+      closeDetails(renderer);
+      expect(statusMessages(renderer)).toEqual([firstFeedback]);
+      expect(hoisted.announce.mock.calls).toEqual([[failed], [firstFeedback]]);
+      unmountScreen(renderer);
+    }
+  );
+
+  it('keeps another message’s sheet failure on request start and clears only the matching retry', async () => {
+    const first = queuedMessage();
+    const second = { ...first, info: { ...first.info, id: 'msg-queued-2' } };
+    currentManager.atoms.messagesList.value = [first, second];
+    currentManager.atoms.pendingMessages.value = new Map(
+      [first, second].map(message => [message.info.id, { status: 'queued' }])
+    );
+    const firstRequest = Promise.withResolvers<{ dropped: boolean }>();
+    const secondRequest = Promise.withResolvers<{ dropped: boolean }>();
+    const secondRetry = Promise.withResolvers<{ dropped: boolean }>();
+    currentManager.cancelQueuedMessage
+      .mockReturnValueOnce(secondRequest.promise)
+      .mockReturnValueOnce(firstRequest.promise)
+      .mockReturnValueOnce(secondRetry.promise);
+    const renderer = mount();
+    openDetails(renderer, first);
+    const staleFirstPress = cancellationPress(renderer);
+    openDetails(renderer, second);
+    act(() => {
+      cancellationPress(renderer)();
+    });
+    await act(async () => {
+      secondRequest.resolve({ dropped: false });
+      await secondRequest.promise;
+    });
+    expect(statusMessages(renderer)).toEqual([failed]);
+    act(() => {
+      staleFirstPress();
+    });
+    expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
+    expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
+    expect(statusMessages(renderer)).toEqual([failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed]]);
+    await act(async () => {
+      firstRequest.resolve({ dropped: false });
+      await firstRequest.promise;
+    });
+    expect(statusMessages(renderer)).toEqual([failed, failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
+    act(() => {
+      cancellationPress(renderer)();
+    });
+    expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+    expect(statusMessages(renderer)).toEqual([failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed]]);
+    await act(async () => {
+      secondRetry.resolve({ dropped: false });
+      await secondRetry.promise;
+    });
+    expect(detailsProps(renderer).cancelQueuedFeedback?.message).toBe(failed);
+    expect(statusMessages(renderer)).toEqual([failed, failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed], [failed]]);
+    expect(hoisted.chatComposer.draft).toEqual({ text: '', files: [] });
+    expect(readBubble(renderer, first.info.id)).toBeDefined();
+    expect(readBubble(renderer, second.info.id)).toBeDefined();
+    closeDetails(renderer);
+    expect(statusMessages(renderer)).toEqual([failed]);
+    expect(hoisted.announce.mock.calls).toEqual([[failed], [failed], [failed]]);
+    unmountScreen(renderer);
+  });
+
+  it.each([true, false])(
+    'binds an old request outcome to its message, dropped=%s',
+    async dropped => {
+      const first = queuedMessage();
+      const second = {
+        ...queuedMessage([{ ...TEXT_PART, text: 'Second prompt' }]),
+        info: { ...first.info, id: 'msg-queued-2' },
+      };
+      currentManager.atoms.messagesList.value = [first, second];
+      currentManager.atoms.pendingMessages.value = new Map(
+        [first, second].map(message => [message.info.id, { status: 'queued' }])
+      );
+      const request = Promise.withResolvers<{ dropped: boolean }>();
+      currentManager.cancelQueuedMessage.mockReturnValue(request.promise);
+      const renderer = mount();
+      openDetails(renderer, first);
+      act(() => {
+        cancellationPress(renderer)();
+      });
+      openDetails(renderer, second);
+      await act(async () => {
+        request.resolve({ dropped });
+        await request.promise;
+      });
+      expect(currentManager.cancelQueuedMessage.mock.calls).toEqual([[first.info.id]]);
+      expect(detailsProps(renderer).visible).toBe(true);
+      expect(detailsProps(renderer).message?.info.id).toBe(second.info.id);
+      expect(detailsProps(renderer).canCancelQueued).toBe(true);
+      expect(detailsProps(renderer).cancelQueuedFeedback).toBeNull();
+      expect(statusMessages(renderer)).toEqual([dropped ? restored : failed]);
+      expect(hoisted.announce.mock.calls).toEqual([[dropped ? restored : failed]]);
+      expect(hoisted.chatComposer.draft.text).toBe(dropped ? 'Queued prompt' : '');
+      unmountScreen(renderer);
+    }
+  );
+});
+
+describe('SessionDetailContent send failure', () => {
+  it('throws without putting the prompt back itself (the composer owns the restore)', async () => {
+    currentManager.send.mockResolvedValue(false);
+
+    const renderer = mount();
+    const onSend = hoisted.chatComposer.lastProps?.onSend;
+    expect(onSend).toBeInstanceOf(Function);
+
+    await act(async () => {
+      await expect(onSend?.('prompt text', {})).rejects.toThrow('Failed to send message');
+    });
+
+    // The session layer must not restore the prompt itself — that would
+    // duplicate the composer's own empty-composer restore.
+    expect(hoisted.chatComposer.control.setText).not.toHaveBeenCalled();
+
+    act(() => {
+      renderer.unmount();
+    });
+  });
+});
diff --git a/apps/mobile/src/components/agents/session-provider.tsx b/apps/mobile/src/components/agents/session-provider.tsx
index 8cae40abae..74af09858c 100644
--- a/apps/mobile/src/components/agents/session-provider.tsx
+++ b/apps/mobile/src/components/agents/session-provider.tsx
@@ -3,6 +3,11 @@ import { createStore, Provider as JotaiProvider } from 'jotai';
 import { type SessionManager } from '@kilocode/cloud-agent-sdk';
 import { createMobileAgentSessionManager } from '@/components/agents/mobile-session-manager';
 import { useUserWebConnection } from '@/components/agents/user-web-connection-provider';
+import {
+  getAuthenticatedOwner,
+  isAuthenticatedOwner,
+  subscribeAuthenticatedOwner,
+} from '@/lib/context-scope';
 
 const ManagerContext = createContext<SessionManager | null>(null);
 
@@ -24,12 +29,21 @@ export function AgentSessionProvider({
     organizationId,
   });
 
+  const owner = useRef(getAuthenticatedOwner()).current;
   useEffect(() => {
     const manager = managerRef.current;
+    const retire = () => {
+      if (!isAuthenticatedOwner(owner)) {
+        manager?.destroy();
+      }
+    };
+    const unsubscribe = subscribeAuthenticatedOwner(retire);
+    retire();
     return () => {
+      unsubscribe();
       manager?.destroy();
     };
-  }, []);
+  }, [owner]);
 
   return (
     <JotaiProvider store={storeRef.current}>
diff --git a/apps/mobile/src/components/agents/user-web-connection-provider.mounted.test.tsx b/apps/mobile/src/components/agents/user-web-connection-provider.mounted.test.tsx
index 8702427664..fec0fa580c 100644
--- a/apps/mobile/src/components/agents/user-web-connection-provider.mounted.test.tsx
+++ b/apps/mobile/src/components/agents/user-web-connection-provider.mounted.test.tsx
@@ -1,93 +1,445 @@
-/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as src/test/render-with-providers.tsx) */
-import { createElement } from 'react';
+/* eslint-disable typescript-eslint/no-deprecated -- react-test-renderer mounts the native provider without a device. */
+/* eslint-disable max-lines -- real connection lifetime cases share the socket and credential fixture. */
+import { createElement, StrictMode } from 'react';
 import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { type UserWebConnection } from '@kilocode/cloud-agent-sdk/user-web-connection';
 
-import { UserWebConnectionProvider } from './user-web-connection-provider';
-
-type AuthConfig = { getAuthToken: () => Promise<string> };
+import { bumpAuthEpoch } from '@/lib/auth/auth-epoch';
+import { setSignOutActive } from '@/lib/auth/sign-out-state';
+import {
+  clearActiveToken,
+  getActiveToken,
+  setActiveToken,
+  setSignOutTeardownActive,
+} from '@/lib/auth/token-owner';
+import {
+  beginAuthenticatedOwner,
+  getAuthenticatedOwner,
+  isAuthenticatedOwner,
+} from '@/lib/context-scope';
+import {
+  useIdentityConfirmation,
+  UserWebConnectionProvider,
+  useUserWebConnection,
+} from './user-web-connection-provider';
 
 const mocks = vi.hoisted(() => ({
-  mutate: vi.fn(() => ({ token: 'ticket-1', expiresAt: 1_700_000_060 })),
+  getMe: vi.fn<() => Promise<{ id: string }>>(),
+  mutate: vi.fn<() => Promise<{ token: string }>>(),
   query: vi.fn(),
-  createUserWebConnection: vi.fn(),
-  capturedConfig: null as AuthConfig | null,
-}));
-
-vi.mock('@kilocode/cloud-agent-sdk/user-web-connection', () => ({
-  createUserWebConnection: (config: AuthConfig) => {
-    mocks.capturedConfig = config;
-    mocks.createUserWebConnection(config);
-    return {
-      retain: vi.fn(() => vi.fn()),
-      connect: vi.fn(),
-      disconnect: vi.fn(),
-      destroy: vi.fn(),
-      isConnected: vi.fn(() => false),
-      onConnectionChange: vi.fn(() => vi.fn()),
-      isReconnectExhausted: vi.fn(() => false),
-      onReconnectExhaustionChange: vi.fn(() => vi.fn()),
-      retryConnection: vi.fn(),
-      subscribeToCliSession: vi.fn(() => vi.fn()),
-      sendCommand: vi.fn(),
-      sendCommandToConnection: vi.fn(),
-      onCliEvent: vi.fn(() => vi.fn()),
-      onSystemEvent: vi.fn(() => vi.fn()),
-      onReconnect: vi.fn(() => vi.fn()),
-      onSessionEvent: vi.fn(() => vi.fn()),
-    };
+  auth: {
+    token: 'account-a-token' as string | undefined,
+    isLoading: false,
+    isSigningOut: false,
+    sessionEnded: false,
   },
 }));
 
-vi.mock('@/lib/config', () => ({
-  SESSION_INGEST_WS_URL: 'wss://ingest.example.com',
-}));
-
+vi.mock('expo-secure-store', () => ({ getItemAsync: vi.fn() }));
+vi.mock('@/lib/auth/auth-context', () => ({ useAuth: () => mocks.auth }));
+vi.mock('@/lib/config', () => ({ SESSION_INGEST_WS_URL: 'wss://ingest.example.com' }));
 vi.mock('@/lib/user-web-connection-lifecycle', () => ({
   createNativeUserWebConnectionLifecycleHooks: () => ({}),
 }));
-
 vi.mock('@/lib/trpc', () => ({
   trpcClient: {
+    user: { getMe: { query: mocks.getMe } },
     activeSessions: {
-      createWebTicket: {
-        mutate: mocks.mutate,
-      },
-      getToken: {
-        query: mocks.query,
-      },
+      createWebTicket: { mutate: mocks.mutate },
+      getToken: { query: mocks.query },
     },
   },
 }));
 
-describe('UserWebConnectionProvider', () => {
-  beforeEach(() => {
-    mocks.capturedConfig = null;
-    mocks.mutate.mockClear();
-    mocks.query.mockClear();
-    mocks.createUserWebConnection.mockClear();
+const sockets: TestSocket[] = [];
+class TestSocket {
+  static readonly OPEN = 1;
+  readyState = 0;
+  onopen: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onclose: ((event: { code: number }) => void) | null = null;
+  onerror: (() => void) | null = null;
+  readonly frames: string[] = [];
+
+  readonly url: string;
+
+  constructor(url: string) {
+    this.url = url;
+    sockets.push(this);
+  }
+
+  send(frame: string) {
+    this.frames.push(frame);
+  }
+
+  close() {
+    this.readyState = 3;
+  }
+
+  open() {
+    this.readyState = 1;
+    this.onopen?.();
+    this.receive({ type: 'system', event: 'sessions.list', data: { sessions: [] } });
+  }
+
+  receive(message: unknown) {
+    this.onmessage?.({ data: JSON.stringify(message) });
+  }
+}
+
+const renderers: TestRenderer.ReactTestRenderer[] = [];
+const connections: UserWebConnection[] = [];
+const identityCredentials: (string | undefined)[] = [];
+const ticketCredentials: (string | undefined)[] = [];
+
+function Consumer() {
+  connections.push(useUserWebConnection());
+  return createElement('ConnectionConsumer', useIdentityConfirmation());
+}
+
+function confirmationFeedback(renderer: TestRenderer.ReactTestRenderer) {
+  return renderer.root.findByType('ConnectionConsumer' as TestRenderer.ReactTestInstance['type'])
+    .props as ReturnType<typeof useIdentityConfirmation>;
+}
+
+function connectionTree() {
+  return createElement(UserWebConnectionProvider, null, createElement(Consumer));
+}
+
+async function mountConnection(strict = false) {
+  const holder: { renderer?: TestRenderer.ReactTestRenderer } = {};
+  await act(async () => {
+    holder.renderer = TestRenderer.create(
+      strict ? createElement(StrictMode, null, connectionTree()) : connectionTree()
+    );
+    await Promise.resolve();
   });
+  if (!holder.renderer) {
+    throw new Error('connection provider did not mount');
+  }
+  renderers.push(holder.renderer);
+  return holder.renderer;
+}
 
-  it('mints the ingest ticket via the createWebTicket mutation', async () => {
-    const holder: { renderer?: TestRenderer.ReactTestRenderer } = {};
-    await act(() => {
-      holder.renderer = TestRenderer.create(createElement(UserWebConnectionProvider, null));
-    });
+async function updateConnection(renderer: TestRenderer.ReactTestRenderer) {
+  await act(async () => {
+    renderer.update(connectionTree());
+    await Promise.resolve();
+  });
+}
+
+function currentConnection() {
+  const connection = connections.at(-1);
+  if (!connection) {
+    throw new Error('connection consumer did not mount');
+  }
+  return connection;
+}
+
+function currentSocket() {
+  const socket = sockets.at(-1);
+  if (!socket) {
+    throw new Error('connection did not open a socket');
+  }
+  return socket;
+}
+
+function beginReplacement() {
+  mocks.auth.token = undefined;
+  mocks.auth.isSigningOut = true;
+  setSignOutTeardownActive(true);
+  setSignOutActive(true);
+  bumpAuthEpoch();
+  beginAuthenticatedOwner();
+  clearActiveToken();
+}
 
-    expect(mocks.createUserWebConnection).toHaveBeenCalledTimes(1);
-    const config = mocks.capturedConfig;
-    if (!config) {
-      throw new Error('user web connection config not captured');
+function commitCredentials() {
+  setActiveToken('account-b-token', null);
+  setSignOutTeardownActive(false);
+  setSignOutActive(false);
+  mocks.auth.token = 'account-b-token';
+  mocks.auth.isSigningOut = false;
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.spyOn(Math, 'random').mockReturnValue(0.5);
+  vi.stubGlobal('WebSocket', TestSocket);
+  sockets.length = 0;
+  connections.length = 0;
+  identityCredentials.length = 0;
+  ticketCredentials.length = 0;
+  mocks.query.mockClear();
+  mocks.auth.token = 'account-a-token';
+  mocks.auth.isSigningOut = false;
+  setSignOutActive(false);
+  setSignOutTeardownActive(false);
+  bumpAuthEpoch();
+  beginAuthenticatedOwner();
+  setActiveToken('account-a-token', null);
+  mocks.getMe.mockReset().mockImplementation(async () => {
+    const token = getActiveToken()?.token;
+    identityCredentials.push(token);
+    await Promise.resolve();
+    return { id: token === 'account-b-token' ? 'user-b' : 'user-a' };
+  });
+  mocks.mutate.mockReset().mockImplementation(async () => {
+    const token = getActiveToken()?.token;
+    ticketCredentials.push(token);
+    await Promise.resolve();
+    return { token: token === 'account-b-token' ? 'ticket-b' : 'ticket-a' };
+  });
+});
+
+afterEach(() => {
+  act(() => {
+    for (const renderer of renderers.splice(0)) {
+      renderer.unmount();
     }
+  });
+  for (const connection of connections) {
+    connection.destroy();
+  }
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
 
-    const token = await config.getAuthToken();
+describe('UserWebConnectionProvider ownership', () => {
+  it('mints the ingest ticket via the createWebTicket mutation under confirmed credentials', async () => {
+    await mountConnection();
+    currentSocket().open();
 
-    expect(token).toBe('ticket-1');
-    expect(mocks.mutate).toHaveBeenCalledTimes(1);
+    expect(new URL(currentSocket().url).searchParams.get('ticket')).toBe('ticket-a');
+    expect(identityCredentials).toEqual(['account-a-token']);
+    expect(ticketCredentials).toEqual(['account-a-token']);
+    expect(getAuthenticatedOwner().userId).toBe('user-a');
+    expect(currentConnection().isConnected()).toBe(true);
     expect(mocks.query).not.toHaveBeenCalled();
+  });
+
+  it('starts no old-account work on a fresh pending mount and opens a committed successor', async () => {
+    beginReplacement();
+    const renderer = await mountConnection();
+    expect(renderer.toJSON()).toBeNull();
+    expect(identityCredentials).toEqual([]);
+    expect(ticketCredentials).toEqual([]);
+    expect(sockets).toHaveLength(0);
+
+    commitCredentials();
+    await updateConnection(renderer);
+    currentSocket().open();
+    expect(getAuthenticatedOwner().userId).toBe('user-b');
+    expect(identityCredentials).toEqual(['account-b-token']);
+    expect(ticketCredentials).toEqual(['account-b-token']);
+    expect(currentConnection().isConnected()).toBe(true);
+  });
+
+  it.each(['replacement', 'early logout'] as const)(
+    'destroys the old connection during %s even with a retained session consumer',
+    async transition => {
+      const renderer = await mountConnection();
+      const previous = currentConnection();
+      const socket = currentSocket();
+      socket.open();
+      const releaseSession = previous.subscribeToCliSession('old-root');
+      expect(socket.frames).toContain(JSON.stringify({ type: 'subscribe', sessionId: 'old-root' }));
 
-    await act(() => {
-      holder.renderer?.unmount();
+      act(() => {
+        if (transition === 'replacement') {
+          beginReplacement();
+        } else {
+          mocks.auth.isSigningOut = true;
+          setSignOutActive(true);
+          beginAuthenticatedOwner();
+        }
+        // Observe retirement before React unmounts the consumer or releases its retain.
+        expect(socket.readyState).toBe(3);
+        expect(previous.isConnected()).toBe(false);
+      });
+      await expect(previous.sendCommand('old-root', 'send_message', {})).rejects.toThrow(
+        'Connection destroyed'
+      );
+      releaseSession();
+
+      commitCredentials();
+      await updateConnection(renderer);
+      currentSocket().open();
+      expect(currentConnection()).not.toBe(previous);
+      expect(currentConnection().isConnected()).toBe(true);
+      expect(new URL(currentSocket().url).searchParams.get('ticket')).toBe('ticket-b');
+    }
+  );
+
+  it('rejects a late getMe response after replacement and keeps the successor identity', async () => {
+    const identity = Promise.withResolvers<{ id: string }>();
+    mocks.getMe.mockReturnValueOnce(identity.promise);
+    const renderer = await mountConnection();
+    expect(getAuthenticatedOwner().userId).toBeNull();
+    expect(sockets).toHaveLength(0);
+
+    act(beginReplacement);
+    commitCredentials();
+    await updateConnection(renderer);
+    await act(async () => {
+      identity.resolve({ id: 'user-a' });
+      await identity.promise;
+    });
+
+    expect(getAuthenticatedOwner().userId).toBe('user-b');
+    expect(ticketCredentials).toEqual(['account-b-token']);
+    expect(sockets).toHaveLength(1);
+    expect(new URL(currentSocket().url).searchParams.get('ticket')).toBe('ticket-b');
+  });
+
+  it('rejects a pending old ticket after replacement while the successor connects', async () => {
+    const ticket = Promise.withResolvers<{ token: string }>();
+    mocks.mutate.mockReturnValueOnce(ticket.promise);
+    const renderer = await mountConnection();
+    const previous = currentConnection();
+    const releaseSession = previous.subscribeToCliSession('old-root');
+    expect(isAuthenticatedOwner(getAuthenticatedOwner())).toBe(true);
+    expect(sockets).toHaveLength(0);
+
+    act(beginReplacement);
+    commitCredentials();
+    await updateConnection(renderer);
+    await act(async () => {
+      ticket.resolve({ token: 'late-ticket-a' });
+      await ticket.promise;
+    });
+
+    expect(sockets).toHaveLength(1);
+    expect(new URL(currentSocket().url).searchParams.get('ticket')).toBe('ticket-b');
+    expect(previous.isConnected()).toBe(false);
+    releaseSession();
+  });
+
+  it('preserves the live connection, subscription, and owner during ordinary refresh', async () => {
+    const renderer = await mountConnection();
+    const connection = currentConnection();
+    const socket = currentSocket();
+    const owner = getAuthenticatedOwner();
+    socket.open();
+    const releaseSession = connection.subscribeToCliSession('current-root');
+    const events: string[] = [];
+    const unsubscribe = connection.onSystemEvent(event => {
+      events.push(event.event);
+    });
+
+    setActiveToken('account-a-refreshed-token', null);
+    mocks.auth.token = 'account-a-refreshed-token';
+    await updateConnection(renderer);
+    socket.receive({ type: 'system', event: 'sessions.list', data: { sessions: [] } });
+
+    expect(getAuthenticatedOwner()).toBe(owner);
+    expect(currentConnection()).toBe(connection);
+    expect(connection.isConnected()).toBe(true);
+    expect(sockets).toHaveLength(1);
+    expect(socket.frames).toEqual([
+      JSON.stringify({ type: 'subscribe', sessionId: 'current-root' }),
+    ]);
+    expect(events).toEqual(['sessions.list']);
+    expect(identityCredentials).toEqual(['account-a-token']);
+    expect(ticketCredentials).toEqual(['account-a-token']);
+    unsubscribe();
+    releaseSession();
+  });
+
+  it('recovers identity confirmation through the existing connection retry after a transient failure', async () => {
+    mocks.getMe.mockRejectedValueOnce(new Error('offline'));
+    await mountConnection();
+    expect(getAuthenticatedOwner().userId).toBeNull();
+    expect(sockets).toHaveLength(0);
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1000);
     });
+
+    expect(getAuthenticatedOwner().userId).toBe('user-a');
+    currentSocket().open();
+    expect(currentConnection().isConnected()).toBe(true);
+  });
+
+  it('retries current confirmation without replacing the connection or duplicating pending requests', async () => {
+    mocks.getMe.mockRejectedValueOnce(new Error('offline'));
+    const renderer = await mountConnection();
+    const connection = currentConnection();
+    const releaseConsumer = connection.retain();
+    expect(confirmationFeedback(renderer)).toMatchObject({ isError: true, isPending: false });
+    expect(getAuthenticatedOwner().userId).toBeNull();
+
+    const identity = Promise.withResolvers<{ id: string }>();
+    mocks.getMe.mockReturnValueOnce(identity.promise);
+    const retry = confirmationFeedback(renderer).retry;
+    act(() => {
+      retry();
+      retry();
+    });
+    expect(confirmationFeedback(renderer)).toMatchObject({ isError: true, isPending: true });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1000);
+    });
+    expect(mocks.getMe).toHaveBeenCalledTimes(2);
+    expect(sockets).toHaveLength(0);
+
+    await act(async () => {
+      identity.resolve({ id: 'user-a' });
+      await identity.promise;
+    });
+    currentSocket().open();
+    expect(confirmationFeedback(renderer)).toMatchObject({ isError: false, isPending: false });
+    expect(getAuthenticatedOwner().userId).toBe('user-a');
+    expect(currentConnection()).toBe(connection);
+    expect(connection.isConnected()).toBe(true);
+    expect(sockets).toHaveLength(1);
+    releaseConsumer();
+  });
+
+  it.each(['success', 'failure'] as const)(
+    'ignores stale confirmation %s and Retry after replacement',
+    async outcome => {
+      const identity = Promise.withResolvers<{ id: string }>();
+      mocks.getMe.mockReturnValueOnce(identity.promise);
+      const renderer = await mountConnection();
+      const retiredRetry = confirmationFeedback(renderer).retry;
+      expect(confirmationFeedback(renderer)).toMatchObject({ isError: false, isPending: true });
+
+      act(beginReplacement);
+      commitCredentials();
+      await updateConnection(renderer);
+      currentSocket().open();
+      const owner = getAuthenticatedOwner();
+      const connection = currentConnection();
+      await act(async () => {
+        if (outcome === 'success') {
+          identity.resolve({ id: 'user-a' });
+        } else {
+          identity.reject(new Error('retired account failure'));
+        }
+        await Promise.resolve();
+        retiredRetry();
+        await vi.advanceTimersByTimeAsync(1000);
+      });
+
+      expect(getAuthenticatedOwner()).toBe(owner);
+      expect(owner.userId).toBe('user-b');
+      expect(confirmationFeedback(renderer)).toMatchObject({ isError: false, isPending: false });
+      expect(currentConnection()).toBe(connection);
+      expect(connection.isConnected()).toBe(true);
+      expect(ticketCredentials).toEqual(['account-b-token']);
+      expect(sockets).toHaveLength(1);
+    }
+  );
+
+  it('keeps a current connection usable after StrictMode effect replay', async () => {
+    await mountConnection(true);
+    currentSocket().open();
+
+    expect(sockets).toHaveLength(1);
+    expect(getAuthenticatedOwner().userId).toBe('user-a');
+    expect(currentConnection().isConnected()).toBe(true);
   });
 });
diff --git a/apps/mobile/src/components/agents/user-web-connection-provider.test.ts b/apps/mobile/src/components/agents/user-web-connection-provider.test.ts
index 4beaf0b4da..1dd3107c9b 100644
--- a/apps/mobile/src/components/agents/user-web-connection-provider.test.ts
+++ b/apps/mobile/src/components/agents/user-web-connection-provider.test.ts
@@ -1,85 +1,111 @@
-/* eslint-disable typescript-eslint/no-deprecated, react/no-children-prop -- react-test-renderer is the DOM-free renderer used to mount React/RN trees under vitest (same pattern as user-web-connection-provider.mounted.test.tsx); `children` must be passed as a prop because this is a .ts file with no JSX */
+/* eslint-disable typescript-eslint/no-deprecated, react/no-children-prop -- the .ts fixture uses react-test-renderer without JSX. */
 import { createElement } from 'react';
 import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest';
 
+import { bumpAuthEpoch } from '@/lib/auth/auth-epoch';
+import { setSignOutActive } from '@/lib/auth/sign-out-state';
+import { setActiveToken } from '@/lib/auth/token-owner';
+import {
+  beginAuthenticatedOwner,
+  confirmAuthenticatedOwner,
+  getAuthenticatedOwner,
+} from '@/lib/context-scope';
 import { UserWebConnectionProvider } from './user-web-connection-provider';
 
 type AuthConfig = { getAuthToken: () => Promise<string> };
-
 const mocks = vi.hoisted(() => ({
-  mutate: vi.fn(async () => {
-    await Promise.resolve();
-    return { token: 'ticket-1', expiresAt: 1_700_000_060 };
-  }),
+  mutate: vi.fn<() => Promise<{ token: string; expiresAt: number }>>(),
   query: vi.fn(),
   capturedConfig: null as AuthConfig | null,
 }));
 
+vi.mock('expo-secure-store', () => ({ getItemAsync: vi.fn() }));
+vi.mock('@/lib/auth/auth-context', () => ({
+  useAuth: () => ({
+    token: 'account-a-token',
+    isLoading: false,
+    isSigningOut: false,
+    sessionEnded: false,
+  }),
+}));
 vi.mock('@kilocode/cloud-agent-sdk/user-web-connection', () => ({
   createUserWebConnection: (config: AuthConfig) => {
     mocks.capturedConfig = config;
-    return { retain: () => vi.fn() };
+    return { retain: () => vi.fn(), destroy: vi.fn() };
   },
 }));
-
-vi.mock('@/lib/config', () => ({
-  SESSION_INGEST_WS_URL: 'wss://ingest.example.com',
-}));
-
+vi.mock('@/lib/config', () => ({ SESSION_INGEST_WS_URL: 'wss://ingest.example.com' }));
 vi.mock('@/lib/user-web-connection-lifecycle', () => ({
   createNativeUserWebConnectionLifecycleHooks: () => ({}),
 }));
-
 vi.mock('@/lib/trpc', () => ({
   trpcClient: {
+    user: { getMe: { query: vi.fn().mockResolvedValue({ id: 'user-a' }) } },
     activeSessions: {
-      createWebTicket: {
-        mutate: mocks.mutate,
-      },
-      getToken: {
-        query: mocks.query,
-      },
+      createWebTicket: { mutate: mocks.mutate },
+      getToken: { query: mocks.query },
     },
   },
 }));
 
-describe('UserWebConnectionProvider', () => {
+async function mountTicketProducer() {
+  const holder: { renderer?: TestRenderer.ReactTestRenderer } = {};
+  await act(async () => {
+    holder.renderer = TestRenderer.create(
+      createElement(UserWebConnectionProvider, { children: null })
+    );
+    await Promise.resolve();
+  });
+  onTestFinished(() => {
+    act(() => holder.renderer?.unmount());
+  });
+  if (!mocks.capturedConfig) {
+    throw new Error('createUserWebConnection was not called');
+  }
+  return mocks.capturedConfig;
+}
+
+describe('UserWebConnectionProvider ticket fencing', () => {
   beforeEach(() => {
+    setSignOutActive(false);
+    bumpAuthEpoch();
+    beginAuthenticatedOwner();
+    setActiveToken('account-a-token', null);
     mocks.capturedConfig = null;
-    mocks.mutate.mockClear();
+    mocks.mutate.mockReset().mockResolvedValue({ token: 'ticket-1', expiresAt: 1_700_000_060 });
     mocks.query.mockClear();
   });
 
   it('mints the ingest ticket via the createWebTicket mutation (not the getToken query)', async () => {
-    const rendererRef: { current: TestRenderer.ReactTestRenderer | undefined } = {
-      current: undefined,
-    };
-    await act(async () => {
-      await Promise.resolve();
-      rendererRef.current = TestRenderer.create(
-        createElement(UserWebConnectionProvider, { children: null })
-      );
-    });
-
-    const config = mocks.capturedConfig;
-    if (!config) {
-      throw new Error('createUserWebConnection was not called');
-    }
-
+    const config = await mountTicketProducer();
     const token = await config.getAuthToken();
 
     expect(token).toBe('ticket-1');
     expect(mocks.mutate).toHaveBeenCalledTimes(1);
     expect(mocks.query).not.toHaveBeenCalled();
+  });
 
-    const renderer = rendererRef.current;
-    if (!renderer) {
-      throw new Error('renderer was not created');
-    }
+  it('rejects rather than returns a ticket completed under a retired generation', async () => {
+    const ticket = Promise.withResolvers<{ token: string; expiresAt: number }>();
+    mocks.mutate.mockReturnValueOnce(ticket.promise);
+    const config = await mountTicketProducer();
+    const result = config.getAuthToken();
+    const rejection = expect(result).rejects.toThrow('Authenticated owner changed');
     await act(async () => {
       await Promise.resolve();
-      renderer.unmount();
     });
+    act(() => {
+      setSignOutActive(true);
+      bumpAuthEpoch();
+      beginAuthenticatedOwner();
+      setActiveToken('account-b-token', null);
+      setSignOutActive(false);
+      confirmAuthenticatedOwner(getAuthenticatedOwner(), 'user-b');
+    });
+    ticket.resolve({ token: 'retired-ticket', expiresAt: 1_700_000_060 });
+
+    await rejection;
+    await expect(config.getAuthToken()).rejects.toThrow('Authenticated owner changed');
   });
 });
diff --git a/apps/mobile/src/components/agents/user-web-connection-provider.tsx b/apps/mobile/src/components/agents/user-web-connection-provider.tsx
index e164dfc39d..b009b9a049 100644
--- a/apps/mobile/src/components/agents/user-web-connection-provider.tsx
+++ b/apps/mobile/src/components/agents/user-web-connection-provider.tsx
@@ -1,49 +1,165 @@
-import { createContext, type ReactNode, useContext, useEffect, useRef } from 'react';
+import {
+  createContext,
+  type ReactNode,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore,
+} from 'react';
 import { type UserWebConnection } from '@kilocode/cloud-agent-sdk';
-// kilocode_change - K1/C2: `createUserWebConnection` must come from its
-// narrow subpath, not the `cloud-agent-sdk` barrel. The barrel's index.ts
-// also re-exports web-only transport code that imports a web-app `@/...`
-// alias unresolved under the mobile app's own `@` alias — this previously
-// went unnoticed because nothing under `apps/mobile` had a test that
-// actually imported this provider (and thus the barrel) at runtime until
-// the `kilo remote` spawn hook test did. See the matching
-// vitest.config.ts aliases for the full explanation.
+// Use the narrow subpath: the barrel also loads web-only transport imports.
 import { createUserWebConnection } from '@kilocode/cloud-agent-sdk/user-web-connection';
 
+import { useAuth } from '@/lib/auth/auth-context';
+import { getActiveToken } from '@/lib/auth/token-owner';
 import { SESSION_INGEST_WS_URL } from '@/lib/config';
+import {
+  type AuthenticatedOwner,
+  confirmAuthenticatedOwner,
+  getAuthenticatedOwner,
+  isCurrentOwner,
+  subscribeAuthenticatedOwner,
+} from '@/lib/context-scope';
 import { createNativeUserWebConnectionLifecycleHooks } from '@/lib/user-web-connection-lifecycle';
 import { trpcClient } from '@/lib/trpc';
 
 const UserWebConnectionContext = createContext<UserWebConnection | null>(null);
 
+type IdentityConfirmation = {
+  isPending: boolean;
+  isError: boolean;
+  retry: () => void;
+};
+
+const IdentityConfirmationContext = createContext<IdentityConfirmation | null>(null);
+
 type UserWebConnectionProviderProps = {
   children: ReactNode;
 };
 
 export function UserWebConnectionProvider({ children }: Readonly<UserWebConnectionProviderProps>) {
+  const { token, isLoading, isSigningOut, sessionEnded } = useAuth();
+  const owner = useSyncExternalStore(subscribeAuthenticatedOwner, getAuthenticatedOwner);
+  if (!token || isLoading || isSigningOut || sessionEnded || !isCurrentOwner(owner)) {
+    return null;
+  }
+  return (
+    <OwnedUserWebConnectionProvider key={`${owner.authEpoch}:${owner.generation}`} owner={owner}>
+      {children}
+    </OwnedUserWebConnectionProvider>
+  );
+}
+
+type OwnedUserWebConnectionProviderProps = UserWebConnectionProviderProps & {
+  owner: AuthenticatedOwner;
+};
+
+function OwnedUserWebConnectionProvider({
+  children,
+  owner,
+}: Readonly<OwnedUserWebConnectionProviderProps>) {
+  const captured = useRef(owner).current;
+  const [confirmation, setConfirmation] = useState({
+    isPending: captured.userId === null,
+    isError: false,
+  });
+  const retryRef = useRef<(() => void) | null>(null);
+  const nativeLifecycle = useMemo(() => createNativeUserWebConnectionLifecycleHooks(), []);
   const connectionRef = useRef<UserWebConnection | null>(null);
   connectionRef.current ??= createUserWebConnection({
     websocketUrl: `${SESSION_INGEST_WS_URL}/api/user/web`,
     getAuthToken: async () => {
+      if (!isCurrentOwner(captured) || !getActiveToken()) {
+        throw new Error('Authenticated owner changed');
+      }
+      if (getAuthenticatedOwner().userId === null) {
+        setConfirmation(state => ({ ...state, isPending: true }));
+        try {
+          // Never confirm from a cached getMe result or a decoded bearer token.
+          const user = await trpcClient.user.getMe.query();
+          if (!confirmAuthenticatedOwner(captured, user.id)) {
+            throw new Error('Authenticated owner changed');
+          }
+          setConfirmation({ isPending: false, isError: false });
+        } catch (error) {
+          if (isCurrentOwner(captured) && getAuthenticatedOwner().userId === null) {
+            setConfirmation({ isPending: false, isError: true });
+          }
+          throw error;
+        }
+      }
+      if (!isCurrentOwner(captured)) {
+        throw new Error('Authenticated owner changed');
+      }
       const result = await trpcClient.activeSessions.createWebTicket.mutate();
+      if (!isCurrentOwner(captured)) {
+        throw new Error('Authenticated owner changed');
+      }
       return result.token;
     },
-    lifecycleHooks: createNativeUserWebConnectionLifecycleHooks(),
+    lifecycleHooks: {
+      ...nativeLifecycle,
+      onOnline: retry => {
+        // Reuse SDK recovery before a socket exists, including its backoff and single-flight guard.
+        retryRef.current = retry;
+        const unsubscribe = nativeLifecycle.onOnline?.(retry);
+        return () => {
+          retryRef.current = null;
+          unsubscribe?.();
+        };
+      },
+    },
   });
+  const connection = connectionRef.current;
+  const identityConfirmation = useMemo(
+    () => ({
+      ...confirmation,
+      retry: () => {
+        if (isCurrentOwner(captured) && getAuthenticatedOwner().userId === null) {
+          retryRef.current?.();
+        }
+      },
+    }),
+    [captured, confirmation]
+  );
 
-  // Retain the connection for the provider lifetime. The retain return value
-  // IS the release, so the effect cleanup releases it; zero retains stops the
-  // socket reversibly. An effect replay (StrictMode development double-mount)
-  // re-retains and reconnects instead of destroying the connection.
-  useEffect(() => connectionRef.current?.retain(), []);
+  useEffect(() => {
+    // Ownership revocation must win even while a session holds another retain.
+    const retire = () => {
+      if (!isCurrentOwner(captured)) {
+        connection.destroy();
+      }
+    };
+    const unsubscribe = subscribeAuthenticatedOwner(retire);
+    retire();
+    const release = connection.retain();
+    return () => {
+      unsubscribe();
+      release();
+      // Effect replay keeps a current connection reusable; account changes do not.
+      retire();
+    };
+  }, [captured, connection]);
 
   return (
-    <UserWebConnectionContext.Provider value={connectionRef.current}>
-      {children}
+    <UserWebConnectionContext.Provider value={connection}>
+      <IdentityConfirmationContext.Provider value={identityConfirmation}>
+        {children}
+      </IdentityConfirmationContext.Provider>
     </UserWebConnectionContext.Provider>
   );
 }
 
+export function useIdentityConfirmation(): IdentityConfirmation {
+  const confirmation = useContext(IdentityConfirmationContext);
+  if (!confirmation) {
+    throw new Error('useIdentityConfirmation must be used within UserWebConnectionProvider');
+  }
+  return confirmation;
+}
+
 export function useUserWebConnection(): UserWebConnection {
   const connection = useContext(UserWebConnectionContext);
   if (!connection) {
diff --git a/apps/mobile/src/components/screen-header.mounted.test.tsx b/apps/mobile/src/components/screen-header.mounted.test.tsx
index 2a1cd72e74..a6cdc2f3b5 100644
--- a/apps/mobile/src/components/screen-header.mounted.test.tsx
+++ b/apps/mobile/src/components/screen-header.mounted.test.tsx
@@ -6,13 +6,15 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ScreenHeader } from './screen-header';
 
 const routerState = vi.hoisted(() => ({
+  routes: ['previous-screen', 'session-detail'],
   back: vi.fn(),
+  replace: vi.fn<(href: string) => void>(),
   canGoBack: vi.fn(() => true),
 }));
 const i18nManager = vi.hoisted(() => ({ isRTL: false }));
 
 vi.mock('expo-router', () => ({
-  useRouter: () => ({ back: routerState.back, canGoBack: routerState.canGoBack }),
+  useRouter: () => routerState,
 }));
 vi.mock('react-native', () => ({
   I18nManager: i18nManager,
@@ -107,9 +109,14 @@ function renderHeader(props: ScreenHeaderProps): TestRenderer.ReactTestRenderer
 
 describe('ScreenHeader mounted', () => {
   beforeEach(() => {
-    routerState.back.mockClear();
-    routerState.canGoBack.mockClear();
-    routerState.canGoBack.mockReturnValue(true);
+    routerState.routes = ['previous-screen', 'session-detail'];
+    routerState.back.mockReset().mockImplementation(() => {
+      routerState.routes.pop();
+    });
+    routerState.replace.mockReset().mockImplementation(href => {
+      routerState.routes.splice(-1, 1, href);
+    });
+    routerState.canGoBack.mockReset().mockImplementation(() => routerState.routes.length > 1);
     i18nManager.isRTL = false;
   });
 
@@ -182,42 +189,66 @@ describe('ScreenHeader mounted', () => {
     }
   });
 
-  it('calls router.back() by default and onBack when provided', () => {
+  it('returns to the previous screen by default', () => {
     const renderer = renderHeader({ title: 'Sessions' });
-    const back = findBackPressable(renderer.root);
-    act(() => {
-      (back.props.onPress as () => void)();
-    });
-    expect(routerState.back).toHaveBeenCalledTimes(1);
-
-    const onBack = vi.fn(() => undefined);
-    const customRenderer = renderHeader({ title: 'Sessions', onBack });
-    const customBack = findBackPressable(customRenderer.root);
     act(() => {
-      (customBack.props.onPress as () => void)();
+      (findBackPressable(renderer.root).props.onPress as () => void)();
     });
-    expect(onBack).toHaveBeenCalledTimes(1);
-    expect(routerState.back).toHaveBeenCalledTimes(1);
+    expect(routerState.routes).toEqual(['previous-screen']);
   });
 
-  it('runs only the pressed control action', () => {
-    const onTitlePress = vi.fn(() => undefined);
-    const renderer = renderHeader({ title: 'Sessions', onTitlePress });
-
-    const back = findBackPressable(renderer.root);
-    act(() => {
-      (back.props.onPress as () => void)();
-    });
-    expect(onTitlePress).not.toHaveBeenCalled();
-    expect(routerState.back).toHaveBeenCalledTimes(1);
+  it.each([
+    { history: ['previous-screen', 'session-detail'], destination: 'previous-screen' },
+    { history: ['session-detail'], destination: '/(app)/(tabs)/(2_agents)' },
+  ])(
+    'returns from $history without retaining the session or opening its title',
+    ({ history, destination }) => {
+      routerState.routes = [...history];
+      let titleOpened = false;
+      const renderer = renderHeader({
+        title: 'Session',
+        backFallback: '/(app)/(tabs)/(2_agents)',
+        onTitlePress: () => {
+          titleOpened = true;
+        },
+      });
+      act(() => {
+        (findBackPressable(renderer.root).props.onPress as () => void)();
+      });
+      expect(routerState.routes).toEqual([destination]);
+      expect(titleOpened).toBe(false);
+      act(() => {
+        (findTitlePressable(renderer.root).props.onPress as () => void)();
+      });
+      expect(titleOpened).toBe(true);
+      expect(routerState.routes).toEqual([destination]);
+    }
+  );
 
-    const title = findTitlePressable(renderer.root);
-    act(() => {
-      (title.props.onPress as () => void)();
-    });
-    expect(onTitlePress).toHaveBeenCalledTimes(1);
-    expect(routerState.back).toHaveBeenCalledTimes(1);
-  });
+  it.each([
+    { history: true, backFallback: undefined },
+    { history: true, backFallback: '/(app)/(tabs)/(2_agents)' },
+    { history: false, backFallback: '/(app)/(tabs)/(2_agents)' },
+  ] as const)(
+    'preserves custom onBack precedence for history=$history, fallback=$backFallback',
+    ({ history, backFallback }) => {
+      routerState.routes = history ? ['previous-screen', 'session-detail'] : ['session-detail'];
+      const initialRoutes = [...routerState.routes];
+      let dismissed = false;
+      const renderer = renderHeader({
+        title: 'Session',
+        backFallback,
+        onBack: () => {
+          dismissed = true;
+        },
+      });
+      act(() => {
+        (findBackPressable(renderer.root).props.onPress as () => void)();
+      });
+      expect(dismissed).toBe(true);
+      expect(routerState.routes).toEqual(initialRoutes);
+    }
+  );
 
   it('labels the title with the override or the default open-menu label', () => {
     const renderer = renderHeader({ title: 'Sessions', onTitlePress: () => undefined });
@@ -263,7 +294,11 @@ describe('ScreenHeader mounted', () => {
     const forced = renderHeader({ title: 'Sessions', showBackButton: true });
     expect(backPressableCount(forced.root)).toBe(1);
 
-    const explicitlyHidden = renderHeader({ title: 'Sessions', showBackButton: false });
+    const explicitlyHidden = renderHeader({
+      title: 'Sessions',
+      showBackButton: false,
+      backFallback: '/(app)/(tabs)/(2_agents)',
+    });
     expect(backPressableCount(explicitlyHidden.root)).toBe(0);
   });
 
diff --git a/apps/mobile/src/components/screen-header.tsx b/apps/mobile/src/components/screen-header.tsx
index e65f9244ec..f9a8df6632 100644
--- a/apps/mobile/src/components/screen-header.tsx
+++ b/apps/mobile/src/components/screen-header.tsx
@@ -1,4 +1,4 @@
-import { useRouter } from 'expo-router';
+import { type Href, useRouter } from 'expo-router';
 import { ChevronDown } from '@/components/ui/icons';
 import { DirectionalChevronLeft } from '@/components/ui/directional-icons';
 import { I18nManager, Platform, Pressable, View } from 'react-native';
@@ -21,6 +21,8 @@ type ScreenHeaderProps = {
   modal?: boolean;
   showBackButton?: boolean;
   onBack?: () => void;
+  /** Keep Back available without history, replacing the current route with this destination. */
+  backFallback?: Href;
   onTitlePress?: () => void;
   /**
    * Accessibility label for the pressable title. Defaults to a generic
@@ -42,6 +44,7 @@ export function ScreenHeader({
   modal,
   showBackButton,
   onBack,
+  backFallback,
   onTitlePress,
   onTitlePressAccessibilityLabel,
   backIcon,
@@ -51,7 +54,7 @@ export function ScreenHeader({
   const router = useRouter();
   const colors = useThemeColors();
   const { t } = useTranslation();
-  const canGoBack = showBackButton ?? router.canGoBack();
+  const canGoBack = showBackButton ?? (router.canGoBack() || backFallback !== undefined);
 
   // iOS modals are presented as cards already inset from the status bar
   const paddingTop = modal && Platform.OS === 'ios' ? 32 : insets.top + 8;
@@ -102,6 +105,8 @@ export function ScreenHeader({
               onPress={() => {
                 if (onBack) {
                   onBack();
+                } else if (backFallback !== undefined && !router.canGoBack()) {
+                  router.replace(backFallback);
                 } else {
                   router.back();
                 }
diff --git a/apps/mobile/src/components/sheet-header.mounted.test.tsx b/apps/mobile/src/components/sheet-header.mounted.test.tsx
index f7ee30f32c..79fcbfae42 100644
--- a/apps/mobile/src/components/sheet-header.mounted.test.tsx
+++ b/apps/mobile/src/components/sheet-header.mounted.test.tsx
@@ -46,6 +46,62 @@ function pressablesByLabel(
   );
 }
 
+describe('SheetHeader title layout', () => {
+  it.each([undefined, false])(
+    'keeps the single-line layout when wrapTitle is %s',
+    async wrapTitle => {
+      const renderer = await mount({
+        title: 'Inspect performance child 01',
+        onDone: () => undefined,
+        wrapTitle,
+      });
+      const heading = renderer.root.findByProps({ accessibilityRole: 'header' });
+
+      expect(heading.props.children).toBe('Inspect performance child 01');
+      expect(heading.props.numberOfLines).toBe(1);
+      expect(heading.parent?.parent?.props.className).toMatch(/(?:^|\s)h-11(?:\s|$)/u);
+
+      await act(async () => {
+        renderer.unmount();
+        await Promise.resolve();
+      });
+    }
+  );
+
+  it('wraps the full title in a growing row with space reserved for Done', async () => {
+    const onDone = vi.fn<() => void>();
+    const renderer = await mount({
+      title: 'Inspect performance child 01',
+      onDone,
+      wrapTitle: true,
+    });
+    const heading = renderer.root.findByProps({ accessibilityRole: 'header' });
+    const titleRegion = heading.parent;
+    const row = titleRegion?.parent;
+    const dones = pressablesByLabel(renderer.root, 'Done');
+
+    expect(heading.props.children).toBe('Inspect performance child 01');
+    expect.soft(heading.props.numberOfLines).toBeUndefined();
+    expect.soft(row?.props.className).toContain('min-h-11');
+    expect.soft(row?.props.className).not.toMatch(/(?:^|\s)(?:h-|max-h-|overflow-hidden)/u);
+    expect(titleRegion?.props.className).toContain('flex-1');
+    expect(titleRegion?.props.className).toContain('px-24');
+    expect(heading.props.className).toContain('text-lg');
+    expect(heading.props.adjustsFontSizeToFit).not.toBe(true);
+    expect(row?.parent?.props.collapsable).toBe(false);
+    expect(dones).toHaveLength(1);
+    expect(dones[0]?.parent).toBe(row);
+    expect(dones[0]?.props.className).toContain('end-0');
+    expect(dones[0]?.props.onPress).toBe(onDone);
+    expect(dones[0]?.props.disabled).toBe(false);
+
+    await act(async () => {
+      renderer.unmount();
+      await Promise.resolve();
+    });
+  });
+});
+
 describe('SheetHeader share action', () => {
   it('renders a Share pressable in the left slot when onShare is provided', async () => {
     const renderer = await mount({
diff --git a/apps/mobile/src/components/sheet-header.tsx b/apps/mobile/src/components/sheet-header.tsx
index 19e95b4ca6..2cf479c474 100644
--- a/apps/mobile/src/components/sheet-header.tsx
+++ b/apps/mobile/src/components/sheet-header.tsx
@@ -4,9 +4,11 @@ import { Pressable, View } from 'react-native';
 import { Share } from '@/components/ui/icons';
 import { Text } from '@/components/ui/text';
 import { useThemeColors } from '@/lib/hooks/use-theme-colors';
+import { cn } from '@/lib/utils';
 
 export function SheetHeader({
   title,
+  wrapTitle = false,
   onDone,
   onCancel,
   doneLabel,
@@ -16,6 +18,8 @@ export function SheetHeader({
   disabled = false,
 }: {
   title: string;
+  /** Let the title wrap and the row grow while preserving the action slots. */
+  wrapTitle?: boolean;
   onDone: () => void;
   onCancel?: () => void;
   doneLabel?: string;
@@ -44,11 +48,11 @@ export function SheetHeader({
     // view by finding the header at the screen content's subview index 0 — a
     // flattened header breaks that native pass and the list paints over it.
     <View collapsable={false} className="border-b border-border bg-background px-4 pb-3 pt-4">
-      <View className="h-11 flex-row items-center justify-center">
+      <View className={cn('flex-row items-center justify-center', wrapTitle ? 'min-h-11' : 'h-11')}>
         <View className="flex-1 px-24">
           <Text
             className="text-center text-lg font-semibold text-foreground"
-            numberOfLines={1}
+            numberOfLines={wrapTitle ? undefined : 1}
             accessibilityRole="header"
           >
             {title}
diff --git a/apps/mobile/src/lib/auth/auth-context.test.tsx b/apps/mobile/src/lib/auth/auth-context.test.tsx
index 8ff169bc14..46112effe9 100644
--- a/apps/mobile/src/lib/auth/auth-context.test.tsx
+++ b/apps/mobile/src/lib/auth/auth-context.test.tsx
@@ -1,10 +1,13 @@
+/// <reference lib="es2024.promise" />
 /* oxlint-disable typescript-eslint/no-deprecated -- react-test-renderer is the DOM-free renderer for RN trees under vitest (node env, no jsdom) */
 /* oxlint-disable @typescript-eslint/no-unsafe-call @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable max-lines -- one cohesive auth-context suite: sign-out teardown ordering and stale sign-in fencing share the provider mount and the SecureStore mock */
 import { createElement } from 'react';
 import TestRenderer, { act } from 'react-test-renderer';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest';
 import type * as AuthContextModule from './auth-context';
+import type * as ContextScopeModule from '../context-scope';
+import type * as TokenOwnerModule from './token-owner';
 
 // ---- hoisted mocks ----
 
@@ -106,6 +109,38 @@ const consentMock = vi.hoisted(() => ({
   clearPendingConsentOutcome: vi.fn(),
 }));
 
+const ownerProducer = vi.hoisted(() => ({
+  getMe: vi.fn<() => Promise<{ id: string }>>().mockResolvedValue({ id: 'user-a' }),
+  ticket: vi.fn().mockResolvedValue({ token: 'ingest-ticket' }),
+  getAuthToken: undefined as (() => Promise<string>) | undefined,
+}));
+
+vi.mock('@/lib/trpc', () => ({
+  trpcClient: {
+    user: { getMe: { query: ownerProducer.getMe } },
+    activeSessions: { createWebTicket: { mutate: ownerProducer.ticket } },
+  },
+}));
+vi.mock('@/lib/user-web-connection-lifecycle', () => ({
+  createNativeUserWebConnectionLifecycleHooks: () => ({}),
+}));
+// Capture the real provider's credential callback. The mounted connection suite uses the real SDK.
+vi.mock('@kilocode/cloud-agent-sdk/user-web-connection', () => ({
+  createUserWebConnection: (config: { getAuthToken: () => Promise<string> }) => {
+    ownerProducer.getAuthToken = config.getAuthToken;
+    return { retain: () => vi.fn(), destroy: vi.fn() };
+  },
+}));
+
+async function requestOwnerTicket() {
+  const request = ownerProducer.getAuthToken;
+  if (!request) {
+    throw new Error('committed connection producer did not mount');
+  }
+  const token = await request();
+  return token;
+}
+
 // ---- all vi.mock calls ----
 
 vi.mock('expo-secure-store', () => ({
@@ -247,6 +282,7 @@ vi.mock('@/lib/storage-keys', () => ({
 
 vi.mock('@/lib/config', () => ({
   API_BASE_URL: 'https://api.example.com',
+  SESSION_INGEST_WS_URL: 'wss://ingest.example.com',
 }));
 
 vi.mock('react-native', () => ({
@@ -1073,12 +1109,18 @@ describe('reactive auth epoch', () => {
   /** Mount the provider with a consumer that re-captures the context on every
    *  render, so the test can read the epoch after sign-in or sign-out moved it. */
   // oxlint-disable-next-line require-await -- dynamic import is awaited
-  async function mountEpochTest(): Promise<{
+  async function mountEpochTest(withConnection = false): Promise<{
     getCtx: () => AuthContextValue;
     unmount: () => void;
   }> {
     vi.resetModules();
+    ownerProducer.getAuthToken = undefined;
+    ownerProducer.getMe.mockReset().mockResolvedValue({ id: 'user-a' });
     const mod = await import('./auth-context');
+    const connectionModule = withConnection
+      ? await import('../../components/agents/user-web-connection-provider')
+      : null;
+    const ConnectionProvider = connectionModule?.UserWebConnectionProvider;
 
     let capturedCtx: AuthContextValue | undefined = undefined;
     function Consumer(): null {
@@ -1088,8 +1130,14 @@ describe('reactive auth epoch', () => {
 
     let renderer: TestRenderer.ReactTestRenderer | undefined = undefined;
     await act(async () => {
+      const consumer = createElement(Consumer);
       renderer = TestRenderer.create(
-        createElement(mod.AuthProvider, null, createElement(Consumer))
+        createElement(
+          mod.AuthProvider,
+          null,
+          consumer,
+          ConnectionProvider ? createElement(ConnectionProvider, null, null) : null
+        )
       );
       await Promise.resolve();
     });
@@ -1113,6 +1161,184 @@ describe('reactive auth epoch', () => {
     };
   }
 
+  it('publishes pending ownership before credential writes and confirms only the committed successor', async () => {
+    const { getCtx, unmount } = await mountEpochTest(true);
+    onTestFinished(() => act(unmount));
+    const scope: typeof ContextScopeModule = await import('../context-scope');
+    const tokens: typeof TokenOwnerModule = await import('./token-owner');
+    await act(async () => {
+      await getCtx().signIn('account-a-token');
+    });
+    await act(async () => {
+      await requestOwnerTicket();
+    });
+    const previous = scope.getAuthenticatedOwner();
+    expect(previous.userId).toBe('user-a');
+    // The old credentials remain readable on disk while the replacement write is held.
+    hoisted.secureStore.getItemAsync.mockResolvedValue('account-a-token');
+
+    const published: { userId: string | null; token: string | null }[] = [];
+    const unsubscribe = scope.subscribeAuthenticatedOwner(() => {
+      published.push({
+        userId: scope.getAuthenticatedOwner().userId,
+        token: tokens.getActiveToken()?.token ?? null,
+      });
+    });
+    onTestFinished(unsubscribe);
+    const write = Promise.withResolvers<undefined>();
+    onTestFinished(() => {
+      write.resolve(undefined);
+    });
+    hoisted.secureStore.setItemAsync.mockImplementationOnce(async () => {
+      await write.promise;
+    });
+    const transition: { promise?: Promise<void> } = {};
+    await act(async () => {
+      transition.promise = getCtx().signIn('account-b-token');
+      await Promise.resolve();
+    });
+
+    expect(published).toEqual([{ userId: null, token: null }]);
+    expect(scope.isAuthenticatedOwner(previous)).toBe(false);
+    expect(getCtx().token).toBeUndefined();
+    expect(getCtx().isSigningOut).toBe(true);
+    await expect(tokens.getAuthTokenForRequest()).resolves.toBeNull();
+    await expect(requestOwnerTicket()).rejects.toThrow('Authenticated owner changed');
+
+    await act(async () => {
+      write.resolve(undefined);
+      await transition.promise;
+    });
+    expect(scope.getAuthenticatedOwner().userId).toBeNull();
+    const requestedTokens: (string | undefined)[] = [];
+    ownerProducer.getMe.mockImplementationOnce(async () => {
+      requestedTokens.push(tokens.getActiveToken()?.token);
+      await Promise.resolve();
+      return { id: 'user-b' };
+    });
+    await act(async () => {
+      await requestOwnerTicket();
+    });
+
+    expect(requestedTokens).toEqual(['account-b-token']);
+    expect(scope.getAuthenticatedOwner().userId).toBe('user-b');
+    expect(scope.getAuthenticatedOwner().generation).toBeGreaterThan(previous.generation);
+    expect(getCtx().token).toBe('account-b-token');
+    expect(getCtx().isSigningOut).toBe(false);
+  });
+
+  it('confirms a restored account from getMe rather than the decoded token hint', async () => {
+    const token = makeToken({ kiloUserId: 'unconfirmed-hint' });
+    hoisted.secureStore.getItemAsync
+      .mockResolvedValueOnce(token)
+      .mockResolvedValueOnce('stored-refresh')
+      .mockResolvedValueOnce('9999999999999')
+      .mockResolvedValueOnce(token);
+    const { unmount } = await mountEpochTest(true);
+    onTestFinished(() => act(unmount));
+    const scope: typeof ContextScopeModule = await import('../context-scope');
+    expect(scope.getAuthenticatedOwner().userId).toBeNull();
+
+    await act(async () => {
+      await requestOwnerTicket();
+    });
+
+    expect(scope.getAuthenticatedOwner().userId).toBe('user-a');
+    expect(scope.isAuthenticatedOwner(scope.getAuthenticatedOwner())).toBe(true);
+  });
+
+  it('rejects a prior account getMe completion after the current account confirms', async () => {
+    const { getCtx, unmount } = await mountEpochTest(true);
+    onTestFinished(() => act(unmount));
+    await act(async () => {
+      await getCtx().signIn('account-a-token');
+    });
+    const identity = Promise.withResolvers<{ id: string }>();
+    ownerProducer.getMe.mockReturnValueOnce(identity.promise);
+    const stale = requestOwnerTicket();
+    const rejection = expect(stale).rejects.toThrow('Authenticated owner changed');
+
+    await act(async () => {
+      await getCtx().signIn('account-b-token');
+    });
+    ownerProducer.getMe.mockResolvedValueOnce({ id: 'user-b' });
+    await act(async () => {
+      await requestOwnerTicket();
+      identity.resolve({ id: 'user-a' });
+      await rejection;
+    });
+
+    const scope: typeof ContextScopeModule = await import('../context-scope');
+    expect(scope.getAuthenticatedOwner().userId).toBe('user-b');
+    expect(getCtx().token).toBe('account-b-token');
+  });
+
+  it('revokes the confirmed owner before remote logout cleanup or the epoch bump', async () => {
+    const { getCtx, unmount } = await mountEpochTest(true);
+    onTestFinished(() => act(unmount));
+    await act(async () => {
+      await getCtx().signIn('account-a-token');
+    });
+    await act(async () => {
+      await requestOwnerTicket();
+    });
+    const scope: typeof ContextScopeModule = await import('../context-scope');
+    const previous = scope.getAuthenticatedOwner();
+    const cleanup = Promise.withResolvers<undefined>();
+    onTestFinished(() => {
+      cleanup.resolve(undefined);
+    });
+    logoutCleanupMock.runLogoutCleanup.mockReturnValueOnce(cleanup.promise);
+    const transition: { promise?: Promise<void> } = {};
+    await act(async () => {
+      transition.promise = getCtx().signOut();
+      await Promise.resolve();
+    });
+
+    expect(getCtx().authEpoch).toBe(previous.authEpoch);
+    expect(getCtx().isSigningOut).toBe(true);
+    expect(scope.getAuthenticatedOwner().userId).toBeNull();
+    expect(scope.isAuthenticatedOwner(previous)).toBe(false);
+    await expect(requestOwnerTicket()).rejects.toThrow('Authenticated owner changed');
+
+    await act(async () => {
+      cleanup.resolve(undefined);
+      await transition.promise;
+    });
+    expect(getCtx().token).toBeUndefined();
+  });
+
+  it('keeps confirmed ownership stable during real request-time credential refresh', async () => {
+    const { getCtx, unmount } = await mountEpochTest(true);
+    onTestFinished(() => act(unmount));
+    await act(async () => {
+      await getCtx().signIn('account-a-token');
+    });
+    await act(async () => {
+      await requestOwnerTicket();
+    });
+    const scope: typeof ContextScopeModule = await import('../context-scope');
+    const owner = scope.getAuthenticatedOwner();
+    const { performRefresh } = await import('@/lib/auth/credentials');
+    const tokens: typeof TokenOwnerModule = await import('./token-owner');
+    hoisted.secureStore.getItemAsync.mockResolvedValueOnce('refresh-a');
+    const fetch = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValueOnce(
+        Response.json({ token: 'refreshed-token', refreshToken: 'refreshed-pair', expiresIn: 3600 })
+      );
+    onTestFinished(() => {
+      fetch.mockRestore();
+    });
+
+    const outcome = await performRefresh();
+
+    expect(outcome.ok).toBe(true);
+    expect(tokens.getActiveToken()?.token).toBe('refreshed-token');
+    expect(scope.getAuthenticatedOwner()).toBe(owner);
+    expect(scope.isAuthenticatedOwner(owner)).toBe(true);
+  });
+
   it('exposes the current auth epoch in the context value', async () => {
     const { getCtx, unmount } = await mountEpochTest();
     const { currentAuthEpoch } = await import('@/lib/auth/auth-epoch');
diff --git a/apps/mobile/src/lib/auth/auth-context.tsx b/apps/mobile/src/lib/auth/auth-context.tsx
index 4b2001848c..5de29ef27c 100644
--- a/apps/mobile/src/lib/auth/auth-context.tsx
+++ b/apps/mobile/src/lib/auth/auth-context.tsx
@@ -76,6 +76,7 @@ import { clearTelemetryDecision } from '@/lib/telemetry/controller';
 import { clearSentryUser } from '@/lib/sentry-context';
 import { purgePostHogPersistence } from '@/lib/telemetry/posthog-storage';
 import { AppState } from 'react-native';
+import { beginAuthenticatedOwner } from '@/lib/context-scope';
 
 // Pre-load tokens at module level so they're available before React mounts
 export const preloadedAuthToken = SecureStore.getItemAsync(AUTH_TOKEN_KEY);
@@ -211,8 +212,14 @@ export function AuthProvider({ children }: { readonly children: ReactNode }) {
       // full teardown, and a sign-out queued behind a sign-in signs that new
       // session out (documented, correct FIFO semantics).
       await chainSave('auth-transition', async () => {
+        // Close admission before publishing the pending generation or writing credentials.
+        setSignOutTeardownActive(true);
+        setSignOutActive(true);
         bumpAuthEpoch();
+        beginAuthenticatedOwner();
         setAuthEpoch(currentAuthEpoch());
+        setToken(undefined);
+        clearActiveToken();
         // Bind the pending deep-link slot to the new user id at the same
         // place the auth epoch advances, so a destination captured while this
         // account is signed in restores only for this account.
@@ -272,6 +279,7 @@ export function AuthProvider({ children }: { readonly children: ReactNode }) {
       // the read-cache mount unsubscribes and cannot resubscribe while the old
       // user id is still cached.
       setSignOutActive(true);
+      beginAuthenticatedOwner();
       // Drop an account-bound pending deep-link destination synchronously,
       // before the first await, so a different account signed in later in this
       // process cannot navigate to the previous account's destination. A
@@ -320,6 +328,7 @@ export function AuthProvider({ children }: { readonly children: ReactNode }) {
         // fence) and before any local deletion (no deferred save can land
         // after it).
         bumpAuthEpoch();
+        beginAuthenticatedOwner();
         setAuthEpoch(currentAuthEpoch());
         // The signed-out session owns no user id: a destination captured
         // during teardown is recorded as "captured while signed out".
diff --git a/apps/mobile/src/lib/context-scope.test.ts b/apps/mobile/src/lib/context-scope.test.ts
new file mode 100644
index 0000000000..e690d5c7e8
--- /dev/null
+++ b/apps/mobile/src/lib/context-scope.test.ts
@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { bumpAuthEpoch } from '@/lib/auth/auth-epoch';
+import { setSignOutActive } from '@/lib/auth/sign-out-state';
+import {
+  beginAuthenticatedOwner,
+  confirmAuthenticatedOwner,
+  getAuthenticatedOwner,
+  isAuthenticatedOwner,
+  subscribeAuthenticatedOwner,
+} from './context-scope';
+
+describe('authenticated ownership', () => {
+  beforeEach(() => {
+    setSignOutActive(false);
+    bumpAuthEpoch();
+    beginAuthenticatedOwner();
+  });
+
+  it('revokes the confirmed owner synchronously when replacement begins', () => {
+    confirmAuthenticatedOwner(getAuthenticatedOwner(), 'user-a');
+    const previous = getAuthenticatedOwner();
+    const visibleOwners: (string | null)[] = [];
+    const unsubscribe = subscribeAuthenticatedOwner(() => {
+      visibleOwners.push(getAuthenticatedOwner().userId);
+    });
+
+    beginAuthenticatedOwner();
+
+    expect(isAuthenticatedOwner(previous)).toBe(false);
+    expect(visibleOwners).toEqual([null]);
+    unsubscribe();
+  });
+
+  it('rejects a late confirmation even when replacement stays in the same epoch', () => {
+    const previous = getAuthenticatedOwner();
+    const current = beginAuthenticatedOwner();
+    confirmAuthenticatedOwner(current, 'user-b');
+
+    expect(confirmAuthenticatedOwner(previous, 'user-a')).toBe(false);
+    expect(getAuthenticatedOwner().userId).toBe('user-b');
+  });
+
+  it('keeps repeated current confirmation stable and rejects conflicting identity', () => {
+    const pending = getAuthenticatedOwner();
+    confirmAuthenticatedOwner(pending, 'user-a');
+    const confirmed = getAuthenticatedOwner();
+
+    expect(confirmAuthenticatedOwner(pending, 'user-a')).toBe(true);
+    expect(confirmAuthenticatedOwner(pending, 'user-b')).toBe(false);
+    expect(getAuthenticatedOwner()).toBe(confirmed);
+    expect(isAuthenticatedOwner(confirmed)).toBe(true);
+  });
+
+  it('rejects confirmation while sign-out closes admission before the epoch moves', () => {
+    const pending = getAuthenticatedOwner();
+    setSignOutActive(true);
+
+    expect(confirmAuthenticatedOwner(pending, 'user-a')).toBe(false);
+    expect(getAuthenticatedOwner().userId).toBeNull();
+  });
+
+  it('rejects a confirmation captured before the auth epoch moved', () => {
+    const pending = getAuthenticatedOwner();
+    bumpAuthEpoch();
+
+    expect(confirmAuthenticatedOwner(pending, 'user-a')).toBe(false);
+    expect(getAuthenticatedOwner().userId).toBeNull();
+  });
+});
diff --git a/apps/mobile/src/lib/context-scope.ts b/apps/mobile/src/lib/context-scope.ts
new file mode 100644
index 0000000000..e27ac82f3c
--- /dev/null
+++ b/apps/mobile/src/lib/context-scope.ts
@@ -0,0 +1,64 @@
+import { currentAuthEpoch, isCurrentAuthEpoch } from '@/lib/auth/auth-epoch';
+import { isSignOutActive } from '@/lib/auth/sign-out-state';
+
+export type AuthenticatedOwner = Readonly<{
+  authEpoch: number;
+  generation: number;
+  userId: string | null;
+}>;
+
+let owner: AuthenticatedOwner = Object.freeze({
+  authEpoch: currentAuthEpoch(),
+  generation: 0,
+  userId: null,
+});
+const listeners = new Set<() => void>();
+
+export function getAuthenticatedOwner(): AuthenticatedOwner {
+  return owner;
+}
+
+export function subscribeAuthenticatedOwner(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function publish(next: AuthenticatedOwner): AuthenticatedOwner {
+  owner = Object.freeze(next);
+  for (const listener of listeners) {
+    listener();
+  }
+  return owner;
+}
+
+/** Revoke ownership before changing credentials. Ordinary refresh does not call this. */
+export function beginAuthenticatedOwner(): AuthenticatedOwner {
+  return publish({ authEpoch: currentAuthEpoch(), generation: owner.generation + 1, userId: null });
+}
+
+export function isCurrentOwner(captured: AuthenticatedOwner): boolean {
+  return (
+    !isSignOutActive() &&
+    isCurrentAuthEpoch(captured.authEpoch) &&
+    captured.authEpoch === owner.authEpoch &&
+    captured.generation === owner.generation &&
+    (captured.userId === null || captured.userId === owner.userId)
+  );
+}
+
+/** Only a getMe response requested under committed credentials can confirm this generation. */
+export function confirmAuthenticatedOwner(captured: AuthenticatedOwner, userId: string): boolean {
+  if (!userId || !isCurrentOwner(captured) || (owner.userId !== null && owner.userId !== userId)) {
+    return false;
+  }
+  if (owner.userId === null) {
+    publish({ ...owner, userId });
+  }
+  return true;
+}
+
+export function isAuthenticatedOwner(captured: AuthenticatedOwner): boolean {
+  return captured.userId !== null && isCurrentOwner(captured);
+}
diff --git a/dev/seed/app/mobile-sheet-fixtures.ts b/dev/seed/app/mobile-sheet-fixtures.ts
index 7e76ae2795..a526ce9205 100644
--- a/dev/seed/app/mobile-sheet-fixtures.ts
+++ b/dev/seed/app/mobile-sheet-fixtures.ts
@@ -13,7 +13,9 @@ import {
 import type { SeedResult } from '../index';
 import {
   buildChildIngestItems,
+  buildChildPerformanceFixtures,
   buildEmptyIngestItems,
+  buildMobileSheetFixtureResult,
   buildRootIngestItems,
   buildUnsupportedIngestItems,
   CHILD_SESSION_ID,
@@ -21,8 +23,10 @@ import {
   EMPTY_SESSION_ID,
   EMPTY_SESSION_TITLE,
   expectedPartIdsFor,
+  fixtureCleanupSessionIds,
   fixtureSessionIds,
   parseSessionIngestServiceStatus,
+  pollForChildPerformanceFixture,
   ROOT_SESSION_ID,
   ROOT_SESSION_TITLE,
   UNSUPPORTED_SESSION_ID,
@@ -42,10 +46,15 @@ function printUsage(): void {
   console.log('Seeds deterministic mobile transcripts for sheet hit-area E2E.');
   console.log('Resets only the four fixture session IDs, then ingests history');
   console.log('through the local cloudflare-session-ingest worker.');
+  console.log('Use --child-performance to also reset and seed a separate tree');
+  console.log('with 24 direct children, paged history, and one nested child.');
   console.log('');
   console.log('Examples:');
   console.log('  pnpm dev:seed app:mobile-sheet-fixtures ada@example.com');
   console.log('  pnpm -s dev:seed app:mobile-sheet-fixtures ada@example.com --json');
+  console.log(
+    '  pnpm -s dev:seed app:mobile-sheet-fixtures ada@example.com --child-performance --json'
+  );
 }
 
 function isValidEmail(email: string): boolean {
@@ -167,7 +176,9 @@ export async function run(...args: string[]): Promise<SeedResult | void> {
     return;
   }
 
-  const email = parseArgs(args);
+  const childPerformance = args.includes('--child-performance');
+  const email = parseArgs(args.filter(arg => arg !== '--child-performance'));
+  const performanceFixtures = childPerformance ? buildChildPerformanceFixtures() : [];
 
   const secret = process.env.NEXTAUTH_SECRET;
   if (!secret) {
@@ -229,41 +240,17 @@ export async function run(...args: string[]): Promise<SeedResult | void> {
   }
   const sessionIngestUrl = `http://localhost:${serviceStatus.port}`;
 
-  // Reset only the four fixture sessions (child first, then root, then the
-  // parentless unsupported and empty sessions) so reruns are idempotent and
-  // the parent FK is never violated.
-  await db
-    .delete(cli_sessions_v2)
-    .where(
-      and(
-        eq(cli_sessions_v2.kilo_user_id, user.userId),
-        eq(cli_sessions_v2.session_id, CHILD_SESSION_ID)
-      )
-    );
-  await db
-    .delete(cli_sessions_v2)
-    .where(
-      and(
-        eq(cli_sessions_v2.kilo_user_id, user.userId),
-        eq(cli_sessions_v2.session_id, ROOT_SESSION_ID)
-      )
-    );
-  await db
-    .delete(cli_sessions_v2)
-    .where(
-      and(
-        eq(cli_sessions_v2.kilo_user_id, user.userId),
-        eq(cli_sessions_v2.session_id, UNSUPPORTED_SESSION_ID)
-      )
-    );
-  await db
-    .delete(cli_sessions_v2)
-    .where(
-      and(
-        eq(cli_sessions_v2.kilo_user_id, user.userId),
-        eq(cli_sessions_v2.session_id, EMPTY_SESSION_ID)
-      )
-    );
+  // Reset only fixture IDs, with every descendant before its parent.
+  for (const sessionId of fixtureCleanupSessionIds(childPerformance)) {
+    await db
+      .delete(cli_sessions_v2)
+      .where(
+        and(
+          eq(cli_sessions_v2.kilo_user_id, user.userId),
+          eq(cli_sessions_v2.session_id, sessionId)
+        )
+      );
+  }
 
   const remaining = await db
     .select({ sessionId: cli_sessions_v2.session_id })
@@ -271,7 +258,7 @@ export async function run(...args: string[]): Promise<SeedResult | void> {
     .where(
       and(
         eq(cli_sessions_v2.kilo_user_id, user.userId),
-        inArray(cli_sessions_v2.session_id, fixtureSessionIds())
+        inArray(cli_sessions_v2.session_id, fixtureSessionIds(childPerformance))
       )
     );
   if (remaining.length > 0) {
@@ -308,6 +295,14 @@ export async function run(...args: string[]): Promise<SeedResult | void> {
       title: EMPTY_SESSION_TITLE,
       created_on_platform: 'cli',
     },
+    ...performanceFixtures.map(fixture => ({
+      session_id: fixture.sessionId,
+      kilo_user_id: user.userId,
+      title: fixture.title,
+      parent_session_id: fixture.parentId,
+      created_on_platform: 'cli',
+      git_url: fixture.parentId === undefined ? rootGitUrl : undefined,
+    })),
   ] satisfies Array<typeof cli_sessions_v2.$inferInsert>;
 
   await db.insert(cli_sessions_v2).values(rows);
@@ -321,23 +316,31 @@ export async function run(...args: string[]): Promise<SeedResult | void> {
     buildUnsupportedIngestItems()
   );
   await ingestSession(sessionIngestUrl, EMPTY_SESSION_ID, token, buildEmptyIngestItems());
+  for (const fixture of performanceFixtures) {
+    await ingestSession(sessionIngestUrl, fixture.sessionId, token, fixture.items);
+  }
 
   await pollForParts(sessionIngestUrl, ROOT_SESSION_ID, token);
   await pollForParts(sessionIngestUrl, CHILD_SESSION_ID, token);
+  for (const fixture of performanceFixtures) {
+    await pollForChildPerformanceFixture(sessionIngestUrl, token, fixture);
+  }
 
   console.log('');
   console.log('Seeded four mobile transcripts for sheet hit-area E2E.');
+  if (childPerformance) {
+    console.log('Also seeded a performance tree with 24 direct children and one nested child.');
+  }
   console.log('All fixtures are read-only history: no cloud-agent session ID is set.');
 
-  return {
-    userId: user.userId,
-    email: user.email,
-    rootSessionId: ROOT_SESSION_ID,
-    childSessionId: CHILD_SESSION_ID,
-    unsupportedSessionId: UNSUPPORTED_SESSION_ID,
-    emptySessionId: EMPTY_SESSION_ID,
-    usedRepository,
-    sessionIngestPort: serviceStatus.port,
-    sessionIngestUrl,
-  };
+  return buildMobileSheetFixtureResult(
+    {
+      userId: user.userId,
+      email: user.email,
+      usedRepository,
+      sessionIngestPort: serviceStatus.port,
+      sessionIngestUrl,
+    },
+    childPerformance
+  );
 }
diff --git a/dev/seed/lib/mobile-sheet-fixtures.test.ts b/dev/seed/lib/mobile-sheet-fixtures.test.ts
index aad37a22c0..706df802df 100644
--- a/dev/seed/lib/mobile-sheet-fixtures.test.ts
+++ b/dev/seed/lib/mobile-sheet-fixtures.test.ts
@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { setImmediate } from 'node:timers/promises';
 
 import {
   kiloSdkMessageSchema,
@@ -9,7 +10,9 @@ import {
 
 import {
   buildChildIngestItems,
+  buildChildPerformanceFixtures,
   buildEmptyIngestItems,
+  buildMobileSheetFixtureResult,
   buildRootIngestItems,
   buildUnsupportedIngestItems,
   CHILD_ASSISTANT_MESSAGE_ID,
@@ -17,11 +20,16 @@ import {
   CHILD_SESSION_ID,
   CHILD_SESSION_TITLE,
   CHILD_USER_MESSAGE_ID,
+  EMPTY_CHILD_SESSION_ID,
   EMPTY_SESSION_ID,
   EMPTY_SESSION_TITLE,
   expectedPartIdsFor,
+  fixtureCleanupSessionIds,
   fixtureSessionIds,
+  NESTED_CHILD_SESSION_ID,
   parseSessionIngestServiceStatus,
+  PERFORMANCE_ROOT_SESSION_ID,
+  pollForChildPerformanceFixture,
   ROOT_ASSISTANT_MESSAGE_ID,
   ROOT_FILE_PART_ID,
   ROOT_READ_PART_ID,
@@ -29,9 +37,11 @@ import {
   ROOT_SESSION_TITLE,
   ROOT_TASK_PART_ID,
   ROOT_USER_MESSAGE_ID,
+  SELECTED_CHILD_SESSION_ID,
   UNSUPPORTED_SESSION_ID,
   UNSUPPORTED_SESSION_TITLE,
   UNSUPPORTED_USER_MESSAGE_ID,
+  type ChildPerformanceFixture,
   type SessionIngestItem,
 } from './mobile-sheet-fixtures';
 
@@ -313,3 +323,431 @@ void test('status JSON parsing extracts the session-ingest service', () => {
 
   assert.throws(() => parseSessionIngestServiceStatus('not json'), /did not return valid JSON/);
 });
+
+function performanceFixture(sessionId: string): ChildPerformanceFixture {
+  const fixture = buildChildPerformanceFixtures().find(value => value.sessionId === sessionId);
+  assert.ok(fixture);
+  return fixture;
+}
+
+function storedMessages(fixture: ChildPerformanceFixture) {
+  const parts = itemsOfType(fixture.items, 'part').map(item => parsePartData(item.data));
+  return itemsOfType(fixture.items, 'message').map(item => {
+    const info = parseMessageData(item.data);
+    return { info, parts: parts.filter(part => part.messageID === info.id) };
+  });
+}
+
+function historyResponse(fixture: ChildPerformanceFixture, history: unknown): Response {
+  return Response.json({ success: true, kiloSessionId: fixture.sessionId, history });
+}
+
+void test('performance fixtures keep deterministic identities, sizes, links, and ingestion order', () => {
+  const fixtures = buildChildPerformanceFixtures();
+  assert.deepEqual(buildChildPerformanceFixtures(), fixtures);
+  assert.equal(fixtures.length, 26);
+  assert.equal(
+    fixtures.filter(fixture => fixture.parentId === PERFORMANCE_ROOT_SESSION_ID).length,
+    24
+  );
+  assert.equal(performanceFixture(NESTED_CHILD_SESSION_ID).parentId, SELECTED_CHILD_SESSION_ID);
+  assert.equal(performanceFixture(EMPTY_CHILD_SESSION_ID).items.length, 1);
+
+  const ids = new Set<string>();
+  const sizes: Record<number, number> = {};
+  for (const fixture of fixtures) {
+    const messages = storedMessages(fixture);
+    sizes[messages.length] = (sizes[messages.length] ?? 0) + 1;
+    const session = parseSessionData(singleItemOfType(fixture.items, 'session').data);
+    assert.equal(session.id, fixture.sessionId);
+    assert.equal(session.parentID, fixture.parentId);
+    if (fixture.parentId) {
+      assert.ok(
+        fixtures.findIndex(parent => parent.sessionId === fixture.parentId) <
+          fixtures.indexOf(fixture)
+      );
+    }
+    assert.equal(messages.length, fixture.messageCount);
+    const messageIds = messages.map(message => message.info.id);
+    assert.deepEqual(messageIds, [...messageIds].sort());
+    for (const [index, message] of messages.entries()) {
+      assert.equal(message.info.sessionID, fixture.sessionId);
+      assert.ok(
+        message.parts.some(part => part.type === 'text' && part.text.includes('Synthetic'))
+      );
+      if (index > 0) assert.ok(message.info.time.created > messages[index - 1].info.time.created);
+      if (message.info.role === 'assistant') {
+        assert.equal(message.info.parentID, messages[index - 1].info.id);
+        assert.equal(messages[index - 1].info.role, 'user');
+      }
+    }
+
+    let stage = 0;
+    const ingestedMessages = new Set<string>();
+    for (const item of fixture.items) {
+      assert.notEqual(item.type, 'session_diff');
+      if (item.type === 'session_diff') assert.fail('unexpected session diff');
+      assert.equal(typeof item.data.id, 'string');
+      if (typeof item.data.id !== 'string') assert.fail('missing fixture identity');
+      assert.ok(!ids.has(item.data.id), `duplicate fixture identity: ${item.data.id}`);
+      ids.add(item.data.id);
+      const nextStage = item.type === 'session' ? 0 : item.type === 'message' ? 1 : 2;
+      assert.ok(nextStage >= stage, 'session, messages, and parts must arrive in order');
+      stage = nextStage;
+      if (item.type === 'message') ingestedMessages.add(item.data.id);
+      if (item.type === 'part') {
+        const part = parsePartData(item.data);
+        assert.equal(part.sessionID, fixture.sessionId);
+        assert.ok(ingestedMessages.has(part.messageID));
+      }
+    }
+  }
+  assert.deepEqual(sizes, { 0: 1, 2: 1, 12: 22, 120: 2 });
+  const selected = storedMessages(performanceFixture(SELECTED_CHILD_SESSION_ID));
+  assert.equal(selected[0].info.id, 'msg000000000007ChildPerf000010001');
+  assert.equal(selected[119].info.id, 'msg000000000007ChildPerf000010120');
+});
+
+void test('task metadata links every direct and nested child with useful mixed states', () => {
+  const fixtures = buildChildPerformanceFixtures();
+  const linked = new Set<string>();
+  const rootStates: Record<string, number> = {};
+  for (const fixture of fixtures) {
+    for (const item of itemsOfType(fixture.items, 'part')) {
+      const part = parsePartData(item.data);
+      if (part.type !== 'tool' || part.tool !== 'task') continue;
+      assert.notEqual(part.state.status, 'pending');
+      if (part.state.status === 'pending') assert.fail('pending task');
+      const childSessionId = part.state.metadata?.sessionId;
+      const child = fixtures.find(value => value.sessionId === childSessionId);
+      assert.ok(child);
+      assert.equal(child.parentId, fixture.sessionId);
+      assert.equal(part.state.input.description, child.title);
+      assert.equal(part.state.input.subagent_type, 'Explorer');
+      assert.equal(part.state.input.prompt, `Inspect synthetic fixture ${child.sessionId}.`);
+      assert.ok(!linked.has(child.sessionId));
+      linked.add(child.sessionId);
+      if (part.state.status === 'error') {
+        assert.ok(part.state.error.includes('Synthetic'));
+      } else {
+        assert.equal(part.state.title, child.title);
+      }
+      if (part.state.status === 'running') {
+        assert.ok(!('end' in part.state.time));
+        assert.ok(!('output' in part.state));
+      } else {
+        assert.ok(part.state.time.end > part.state.time.start);
+      }
+      if (fixture.sessionId === PERFORMANCE_ROOT_SESSION_ID) {
+        rootStates[part.state.status] = (rootStates[part.state.status] ?? 0) + 1;
+      }
+    }
+  }
+  assert.equal(linked.size, 25);
+  assert.ok(linked.has(NESTED_CHILD_SESSION_ID));
+  assert.ok(linked.has(EMPTY_CHILD_SESSION_ID));
+  assert.deepEqual(rootStates, { completed: 9, running: 8, error: 7 });
+});
+
+void test('cleanup owns exactly the selected fixtures and deletes descendants first', () => {
+  assert.deepEqual(fixtureCleanupSessionIds(), [
+    CHILD_SESSION_ID,
+    ROOT_SESSION_ID,
+    UNSUPPORTED_SESSION_ID,
+    EMPTY_SESSION_ID,
+  ]);
+  const fixtures = buildChildPerformanceFixtures();
+  const cleanup = fixtureCleanupSessionIds(true);
+  assert.equal(cleanup.length, 30);
+  assert.equal(new Set(cleanup).size, 30);
+  assert.deepEqual(
+    new Set(cleanup),
+    new Set([...fixtureSessionIds(), ...fixtures.map(fixture => fixture.sessionId)])
+  );
+  assert.deepEqual(new Set(fixtureSessionIds(true)), new Set(cleanup));
+  for (const fixture of fixtures) {
+    assert.ok(!fixtureSessionIds().includes(fixture.sessionId));
+    if (fixture.parentId) {
+      assert.ok(cleanup.indexOf(fixture.sessionId) < cleanup.indexOf(fixture.parentId));
+    }
+  }
+});
+
+void test('default JSON stays unchanged and opt-in JSON preserves every existing field', () => {
+  const context = {
+    userId: 'fixture-user',
+    email: 'fixture@example.com',
+    usedRepository: 'fixture-owner/fixture-repo',
+    sessionIngestPort: 12345,
+    sessionIngestUrl: 'http://localhost:12345',
+  };
+  const expected = {
+    userId: 'fixture-user',
+    email: 'fixture@example.com',
+    rootSessionId: 'ses_000000000001RootFixture001',
+    childSessionId: 'ses_000000000002ChildFixture01',
+    unsupportedSessionId: 'ses_000000000003Unsupported001',
+    emptySessionId: 'ses_000000000004EmptyFixture01',
+    usedRepository: 'fixture-owner/fixture-repo',
+    sessionIngestPort: 12345,
+    sessionIngestUrl: 'http://localhost:12345',
+  };
+  assert.equal(JSON.stringify(buildMobileSheetFixtureResult(context)), JSON.stringify(expected));
+  assert.deepEqual(buildMobileSheetFixtureResult(context, false), expected);
+  const result = buildMobileSheetFixtureResult(context, true);
+  for (const [key, value] of Object.entries(expected)) assert.equal(result[key], value);
+  assert.equal(Object.keys(result).length, 17);
+  assert.equal(typeof result.performanceChildSessionIds, 'string');
+  if (typeof result.performanceChildSessionIds !== 'string') assert.fail('missing child IDs');
+  const fixtures = buildChildPerformanceFixtures();
+  const directChildren = fixtures.filter(
+    fixture => fixture.parentId === result.performanceRootSessionId
+  );
+  assert.deepEqual(
+    result.performanceChildSessionIds.split(','),
+    directChildren.map(fixture => fixture.sessionId)
+  );
+  assert.equal(result.performanceChildCount, directChildren.length);
+  assert.equal(
+    result.pagedChildMessageCount,
+    storedMessages(performanceFixture(String(result.selectedChildSessionId))).length
+  );
+  assert.equal(
+    result.pagedChildMessageCount,
+    storedMessages(performanceFixture(String(result.nestedChildSessionId))).length
+  );
+  assert.equal(storedMessages(performanceFixture(String(result.emptyChildSessionId))).length, 0);
+  assert.equal(result.ordinaryChildMessageCount, storedMessages(directChildren[1]).length);
+  assert.deepEqual(buildMobileSheetFixtureResult(context), expected);
+});
+
+void test('materialization follows independent older cursors for both paged children', async t => {
+  const fixtures = [
+    performanceFixture(SELECTED_CHILD_SESSION_ID),
+    performanceFixture(NESTED_CHILD_SESSION_ID),
+  ];
+  let now = 0;
+  t.mock.method(Date, 'now', () => (now += 30_000));
+  t.mock.method(globalThis, 'fetch', async (input: string | URL | Request) => {
+    const url = new URL(String(input));
+    const fixture = fixtures.find(
+      value => url.pathname === `/api/session/${value.sessionId}/messages`
+    );
+    assert.ok(fixture);
+    const messages = storedMessages(fixture);
+    const cursor = url.searchParams.get('before');
+    if (url.searchParams.get('limit') !== '50')
+      return historyResponse(fixture, { kind: 'invalid_data' });
+    if (cursor === null) {
+      return historyResponse(fixture, {
+        messages: messages.slice(70),
+        nextCursor: `${fixture.sessionId}:70/+`,
+      });
+    }
+    if (cursor === `${fixture.sessionId}:70/+`) {
+      return historyResponse(fixture, {
+        messages: messages.slice(20, 70),
+        nextCursor: `${fixture.sessionId}:20/+`,
+      });
+    }
+    if (cursor === `${fixture.sessionId}:20/+`) {
+      return historyResponse(fixture, { messages: messages.slice(0, 20), nextCursor: null });
+    }
+    return historyResponse(fixture, { kind: 'invalid_data' });
+  });
+  for (const fixture of fixtures) {
+    await assert.doesNotReject(
+      pollForChildPerformanceFixture('http://fixture.invalid', 'synthetic-token', fixture)
+    );
+  }
+});
+
+for (const sessionId of [SELECTED_CHILD_SESSION_ID, NESTED_CHILD_SESSION_ID]) {
+  void test(`materialization rejects a paged child without an older cursor: ${sessionId}`, async t => {
+    const fixture = performanceFixture(sessionId);
+    let now = 0;
+    t.mock.method(Date, 'now', () => (now += 30_000));
+    t.mock.method(globalThis, 'fetch', async () =>
+      historyResponse(fixture, {
+        messages: storedMessages(fixture),
+        nextCursor: null,
+      })
+    );
+    await assert.rejects(
+      pollForChildPerformanceFixture('http://fixture.invalid', 'synthetic-token', fixture),
+      /Timed out/
+    );
+  });
+}
+
+void test('materialization waits through pending, retryable failure, and missing parts', async t => {
+  const fixture = buildChildPerformanceFixtures()[2];
+  const messages = storedMessages(fixture);
+  const histories = [
+    null,
+    { kind: 'retryable_failure', phase: 'page_parts' },
+    { messages: messages.map(message => ({ ...message, parts: [] })), nextCursor: null },
+    { messages, nextCursor: null },
+  ];
+  t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 0 });
+  t.mock.method(globalThis, 'fetch', async () => historyResponse(fixture, histories.shift()));
+  let outcome: unknown = 'pending';
+  const polling = pollForChildPerformanceFixture(
+    'http://fixture.invalid',
+    'synthetic-token',
+    fixture
+  ).then(
+    () => {
+      outcome = 'ready';
+    },
+    error => {
+      outcome = error;
+    }
+  );
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    await setImmediate();
+    assert.equal(outcome, 'pending');
+    t.mock.timers.tick(500);
+  }
+  await polling;
+  assert.equal(outcome, 'ready');
+});
+
+void test('empty child readiness requires a successful empty history, not null staging', async t => {
+  const fixture = performanceFixture(EMPTY_CHILD_SESSION_ID);
+  let materialized = false;
+  t.mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 0 });
+  t.mock.method(globalThis, 'fetch', async () =>
+    historyResponse(
+      fixture,
+      materialized ? { messages: [], nextCursor: null, omittedItemCount: 0 } : null
+    )
+  );
+  let outcome: unknown = 'pending';
+  const polling = pollForChildPerformanceFixture(
+    'http://fixture.invalid',
+    'synthetic-token',
+    fixture
+  ).then(
+    () => {
+      outcome = 'ready';
+    },
+    error => {
+      outcome = error;
+    }
+  );
+  await setImmediate();
+  assert.equal(outcome, 'pending');
+  materialized = true;
+  t.mock.timers.tick(500);
+  await polling;
+  assert.equal(outcome, 'ready');
+});
+
+void test('materialization rejects unusable responses and incomplete or corrupt histories', async t => {
+  const fixture = buildChildPerformanceFixtures()[2];
+  const messages = storedMessages(fixture);
+  const page = { messages, nextCursor: null };
+  const cases = [
+    {
+      name: 'HTTP denial',
+      response: () => new Response(null, { status: 403 }),
+      error: /failed \(403\)/,
+    },
+    {
+      name: 'wrong content type',
+      response: () => new Response('<html>not history</html>'),
+      error: /application\/json/,
+    },
+    {
+      name: 'invalid JSON',
+      response: () => new Response('{', { headers: { 'content-type': 'application/json' } }),
+      error: /JSON/,
+    },
+    {
+      name: 'wrong session',
+      response: () =>
+        Response.json({ success: true, kiloSessionId: ROOT_SESSION_ID, history: page }),
+      error: /unexpected shape/,
+    },
+    {
+      name: 'invalid history shape',
+      response: () => historyResponse(fixture, { messages: 'not messages', nextCursor: null }),
+      error: /unexpected history shape/,
+    },
+    {
+      name: 'terminal invalid data',
+      response: () => historyResponse(fixture, { kind: 'invalid_data' }),
+      error: /invalid_data/,
+    },
+    {
+      name: 'terminal oversized data',
+      response: () =>
+        historyResponse(fixture, { kind: 'too_large', maximumBytes: 1, phase: 'page_parts' }),
+      error: /too_large/,
+    },
+    {
+      name: 'omitted items',
+      response: () => historyResponse(fixture, { ...page, omittedItemCount: 1 }),
+      error: /omitted/,
+    },
+    {
+      name: 'missing messages',
+      response: () => historyResponse(fixture, { ...page, messages: messages.slice(1) }),
+      error: /Timed out/,
+    },
+    {
+      name: 'missing parts',
+      response: () =>
+        historyResponse(fixture, {
+          ...page,
+          messages: messages.map(message => ({ ...message, parts: [] })),
+        }),
+      error: /Timed out/,
+    },
+    {
+      name: 'wrong message owner',
+      response: () =>
+        historyResponse(fixture, {
+          ...page,
+          messages: messages.map(message => ({
+            ...message,
+            info: { ...message.info, sessionID: ROOT_SESSION_ID },
+          })),
+        }),
+      error: /Unexpected or duplicate message/,
+    },
+    {
+      name: 'duplicate message',
+      response: () => historyResponse(fixture, { ...page, messages: [...messages, messages[0]] }),
+      error: /duplicate message/,
+    },
+    {
+      name: 'wrong part parent',
+      response: () =>
+        historyResponse(fixture, {
+          ...page,
+          messages: messages.map(message => ({
+            ...message,
+            parts: message.parts.map(part => ({ ...part, messageID: 'msgWrongParent' })),
+          })),
+        }),
+      error: /part relationship/,
+    },
+    {
+      name: 'repeated cursor',
+      response: () => historyResponse(fixture, { messages: [], nextCursor: 'repeated' }),
+      error: /repeated history cursor/,
+    },
+  ];
+  let now = 0;
+  t.mock.method(Date, 'now', () => (now += 30_000));
+  for (const scenario of cases) {
+    t.mock.method(globalThis, 'fetch', async () => scenario.response());
+    await assert.rejects(
+      pollForChildPerformanceFixture('http://fixture.invalid', 'synthetic-token', fixture),
+      scenario.error,
+      scenario.name
+    );
+  }
+});
diff --git a/dev/seed/lib/mobile-sheet-fixtures.ts b/dev/seed/lib/mobile-sheet-fixtures.ts
index a75db21ff8..62ea7fedd0 100644
--- a/dev/seed/lib/mobile-sheet-fixtures.ts
+++ b/dev/seed/lib/mobile-sheet-fixtures.ts
@@ -1,6 +1,11 @@
-// Pure fixture builders and status parsing for the mobile sheet transcript
-// seed. This module has no database or network side effects: the node test
-// imports it without a live stack.
+// Fixture builders, status parsing, and opt-in materialization polling.
+// Importing this module has no database or network side effects.
+import {
+  DEFAULT_KILO_SDK_MESSAGE_PAGE_SIZE,
+  kiloSdkMessageHistorySchema,
+} from '@kilocode/session-ingest-contracts';
+
+import type { SeedResult } from '../index';
 
 export const ROOT_SESSION_ID = 'ses_000000000001RootFixture001';
 export const CHILD_SESSION_ID = 'ses_000000000002ChildFixture01';
@@ -99,8 +104,14 @@ const CHILD_ASSISTANT_TOKENS: FixtureTokens = {
 };
 
 /** The exact session IDs this seed resets. Nothing else is touched. */
-export function fixtureSessionIds(): string[] {
-  return [ROOT_SESSION_ID, CHILD_SESSION_ID, UNSUPPORTED_SESSION_ID, EMPTY_SESSION_ID];
+export function fixtureSessionIds(childPerformance = false): string[] {
+  return [
+    ROOT_SESSION_ID,
+    CHILD_SESSION_ID,
+    UNSUPPORTED_SESSION_ID,
+    EMPTY_SESSION_ID,
+    ...(childPerformance ? PERFORMANCE_SESSION_IDS : []),
+  ];
 }
 
 /** Part IDs that must appear in the materialized history for a fixture session. */
@@ -190,6 +201,7 @@ export function buildToolPartItem(params: {
   messageId: string;
   callId: string;
   tool: string;
+  status?: 'completed' | 'running' | 'error';
   input: Record<string, unknown>;
   output: string;
   title: string;
@@ -206,14 +218,31 @@ export function buildToolPartItem(params: {
       type: 'tool',
       callID: params.callId,
       tool: params.tool,
-      state: {
-        status: 'completed',
-        input: params.input,
-        output: params.output,
-        title: params.title,
-        metadata: params.metadata,
-        time: { start: params.start, end: params.end },
-      },
+      state:
+        params.status === 'running'
+          ? {
+              status: 'running',
+              input: params.input,
+              title: params.title,
+              metadata: params.metadata,
+              time: { start: params.start },
+            }
+          : params.status === 'error'
+            ? {
+                status: 'error',
+                input: params.input,
+                error: params.output,
+                metadata: params.metadata,
+                time: { start: params.start, end: params.end },
+              }
+            : {
+                status: 'completed',
+                input: params.input,
+                output: params.output,
+                title: params.title,
+                metadata: params.metadata,
+                time: { start: params.start, end: params.end },
+              },
     },
   };
 }
@@ -365,6 +394,299 @@ export function buildEmptyIngestItems(): SessionIngestItem[] {
   ];
 }
 
+export const PERFORMANCE_ROOT_SESSION_ID = 'ses_000000000006ChildPerfRoot1';
+export const SELECTED_CHILD_SESSION_ID = 'ses_000000000007ChildPerf00001';
+export const EMPTY_CHILD_SESSION_ID = 'ses_000000000007ChildPerf00024';
+export const NESTED_CHILD_SESSION_ID = 'ses_000000000008ChildPerfNest1';
+
+const PERFORMANCE_CHILD_IDS = Array.from(
+  { length: 24 },
+  (_, index) => `ses_000000000007ChildPerf${String(index + 1).padStart(5, '0')}`
+);
+const PERFORMANCE_SESSION_IDS = [
+  PERFORMANCE_ROOT_SESSION_ID,
+  ...PERFORMANCE_CHILD_IDS,
+  NESTED_CHILD_SESSION_ID,
+];
+
+export type ChildPerformanceFixture = {
+  sessionId: string;
+  parentId?: string;
+  title: string;
+  messageCount: number;
+  items: SessionIngestItem[];
+};
+
+/** Children precede their parents; the default reset order stays unchanged. */
+export function fixtureCleanupSessionIds(childPerformance = false): string[] {
+  return [
+    ...(childPerformance ? [...PERFORMANCE_SESSION_IDS].reverse() : []),
+    CHILD_SESSION_ID,
+    ROOT_SESSION_ID,
+    UNSUPPORTED_SESSION_ID,
+    EMPTY_SESSION_ID,
+  ];
+}
+
+export function buildMobileSheetFixtureResult(
+  context: {
+    userId: string;
+    email: string;
+    usedRepository: string;
+    sessionIngestPort: number;
+    sessionIngestUrl: string;
+  },
+  childPerformance = false
+): SeedResult {
+  return {
+    userId: context.userId,
+    email: context.email,
+    rootSessionId: ROOT_SESSION_ID,
+    childSessionId: CHILD_SESSION_ID,
+    unsupportedSessionId: UNSUPPORTED_SESSION_ID,
+    emptySessionId: EMPTY_SESSION_ID,
+    usedRepository: context.usedRepository,
+    sessionIngestPort: context.sessionIngestPort,
+    sessionIngestUrl: context.sessionIngestUrl,
+    ...(childPerformance
+      ? {
+          performanceRootSessionId: PERFORMANCE_ROOT_SESSION_ID,
+          performanceChildSessionIds: PERFORMANCE_CHILD_IDS.join(','),
+          selectedChildSessionId: SELECTED_CHILD_SESSION_ID,
+          nestedChildSessionId: NESTED_CHILD_SESSION_ID,
+          emptyChildSessionId: EMPTY_CHILD_SESSION_ID,
+          performanceChildCount: PERFORMANCE_CHILD_IDS.length,
+          ordinaryChildMessageCount: 12,
+          pagedChildMessageCount: 120,
+        }
+      : {}),
+  };
+}
+
+/** A separate tree keeps default fixtures unchanged, even after an opt-in run. */
+export function buildChildPerformanceFixtures(): ChildPerformanceFixture[] {
+  const sessions = [
+    {
+      sessionId: PERFORMANCE_ROOT_SESSION_ID,
+      parentId: undefined,
+      title: 'Child performance fixtures',
+      messageCount: 2,
+    },
+    ...PERFORMANCE_CHILD_IDS.map((sessionId, index) => ({
+      sessionId,
+      parentId: PERFORMANCE_ROOT_SESSION_ID,
+      title:
+        sessionId === EMPTY_CHILD_SESSION_ID
+          ? 'Empty child performance fixture'
+          : `Inspect performance child ${String(index + 1).padStart(2, '0')}`,
+      messageCount:
+        sessionId === EMPTY_CHILD_SESSION_ID
+          ? 0
+          : sessionId === SELECTED_CHILD_SESSION_ID
+            ? 120
+            : 12,
+    })),
+    {
+      sessionId: NESTED_CHILD_SESSION_ID,
+      parentId: SELECTED_CHILD_SESSION_ID,
+      title: 'Inspect nested performance child',
+      messageCount: 120,
+    },
+  ];
+
+  return sessions.map((session, sessionIndex) => {
+    const messageIdFor = (index: number) =>
+      `msg${session.sessionId.slice(4)}${String(index).padStart(4, '0')}`;
+    const messages: SessionIngestItem[] = [];
+    const parts: SessionIngestItem[] = [];
+    for (let index = 1; index <= session.messageCount; index += 1) {
+      const createdAt = FIXTURE_TIME_CREATED + index * 1_000;
+      const messageId = messageIdFor(index);
+      messages.push(
+        index % 2 === 1
+          ? buildUserMessageItem({ messageId, sessionId: session.sessionId, createdAt })
+          : buildAssistantMessageItem({
+              messageId,
+              sessionId: session.sessionId,
+              parentId: messageIdFor(index - 1),
+              createdAt,
+              completedAt: createdAt + 200,
+              cost: CHILD_ASSISTANT_COST,
+              tokens: CHILD_ASSISTANT_TOKENS,
+            })
+      );
+      parts.push({
+        type: 'part',
+        data: {
+          id: `prt${session.sessionId.slice(4)}${String(index).padStart(4, '0')}`,
+          sessionID: session.sessionId,
+          messageID: messageId,
+          type: 'text',
+          text: [
+            session.title,
+            '',
+            `Synthetic ${index % 2 === 1 ? 'user' : 'assistant'} message ${index} of ${session.messageCount}.`,
+            'This deterministic transcript contains no repository or user data.',
+            `Read-only fixture marker A: ${index}.`,
+            `Read-only fixture marker B: ${index}.`,
+            `Read-only fixture marker C: ${index}.`,
+          ].join('\n'),
+        },
+      });
+    }
+
+    const children = sessions.filter(child => child.parentId === session.sessionId);
+    for (const [index, child] of children.entries()) {
+      const status =
+        child.sessionId === EMPTY_CHILD_SESSION_ID || index % 3 === 0
+          ? 'completed'
+          : index % 3 === 1
+            ? 'running'
+            : 'error';
+      parts.push(
+        buildToolPartItem({
+          partId: `prtTask${child.sessionId.slice(4)}`,
+          sessionId: session.sessionId,
+          messageId: messageIdFor(session.messageCount),
+          callId: `callTask${child.sessionId.slice(4)}`,
+          tool: 'task',
+          status,
+          input: {
+            subagent_type: 'Explorer',
+            description: child.title,
+            prompt: `Inspect synthetic fixture ${child.sessionId}.`,
+          },
+          output: status === 'error' ? 'Synthetic task failure.' : 'Synthetic task completed.',
+          title: child.title,
+          metadata: { sessionId: child.sessionId },
+          start: FIXTURE_TIME_CREATED + session.messageCount * 1_000,
+          end: FIXTURE_TIME_CREATED + session.messageCount * 1_000 + 200,
+        })
+      );
+    }
+
+    return {
+      ...session,
+      items: [
+        buildSessionItem({
+          sessionId: session.sessionId,
+          parentId: session.parentId,
+          title: session.title,
+          slug: `child-performance-${sessionIndex}`,
+        }),
+        ...messages,
+        ...parts,
+      ],
+    };
+  });
+}
+
+/** Walk each real cursor; a successful empty page is distinct from pending history. */
+export async function pollForChildPerformanceFixture(
+  baseUrl: string,
+  token: string,
+  fixture: ChildPerformanceFixture
+): Promise<void> {
+  const expectedMessages = fixture.items.flatMap(item =>
+    item.type === 'message' && typeof item.data.id === 'string' ? [item.data.id] : []
+  );
+  const expectedParts = fixture.items.flatMap(item =>
+    item.type === 'part' && typeof item.data.id === 'string' ? [item.data.id] : []
+  );
+  const deadline = Date.now() + 30_000;
+
+  for (;;) {
+    const seenMessages = new Set<string>();
+    const seenParts = new Set<string>();
+    const cursors = new Set<string>();
+    let before: string | undefined;
+    let hasHistory = true;
+    let hasOlder = false;
+    do {
+      const query = new URLSearchParams({ limit: String(DEFAULT_KILO_SDK_MESSAGE_PAGE_SIZE) });
+      if (before !== undefined) query.set('before', before);
+      const response = await fetch(
+        `${baseUrl}/api/session/${fixture.sessionId}/messages?${query}`,
+        {
+          headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Messages read of ${fixture.sessionId} failed (${response.status})`);
+      }
+      if (response.headers.get('content-type')?.split(';')[0].trim() !== 'application/json') {
+        throw new Error(`Messages read of ${fixture.sessionId} did not return application/json`);
+      }
+      const payload: unknown = await response.json();
+      if (
+        !isRecord(payload) ||
+        payload.success !== true ||
+        payload.kiloSessionId !== fixture.sessionId
+      ) {
+        throw new Error(`Messages read of ${fixture.sessionId} returned an unexpected shape`);
+      }
+      if (payload.history === null) {
+        hasHistory = false;
+        break;
+      }
+      const parsed = kiloSdkMessageHistorySchema.safeParse(payload.history);
+      if (!parsed.success) {
+        throw new Error(
+          `Messages read of ${fixture.sessionId} returned an unexpected history shape`
+        );
+      }
+      const page = parsed.data;
+      if ('kind' in page) {
+        if (page.kind === 'retryable_failure') {
+          hasHistory = false;
+          break;
+        }
+        throw new Error(`session-ingest reported ${page.kind} for ${fixture.sessionId}`);
+      }
+      if (page.omittedItemCount !== 0) {
+        throw new Error(`session-ingest omitted fixture items for ${fixture.sessionId}`);
+      }
+      if (before === undefined) hasOlder = page.nextCursor !== null;
+      for (const message of page.messages) {
+        if (message.info.sessionID !== fixture.sessionId || seenMessages.has(message.info.id)) {
+          throw new Error(`Unexpected or duplicate message in ${fixture.sessionId}`);
+        }
+        seenMessages.add(message.info.id);
+        for (const part of message.parts) {
+          if (part.sessionID !== fixture.sessionId || part.messageID !== message.info.id) {
+            throw new Error(`Unexpected part relationship in ${fixture.sessionId}`);
+          }
+          seenParts.add(part.id);
+        }
+      }
+      before = page.nextCursor ?? undefined;
+      if (before !== undefined) {
+        if (!before || cursors.has(before)) {
+          throw new Error(`Invalid or repeated history cursor for ${fixture.sessionId}`);
+        }
+        cursors.add(before);
+      }
+    } while (before !== undefined);
+
+    if (
+      hasHistory &&
+      (expectedMessages.length <= DEFAULT_KILO_SDK_MESSAGE_PAGE_SIZE || hasOlder) &&
+      seenMessages.size === expectedMessages.length &&
+      expectedMessages.every(id => seenMessages.has(id)) &&
+      seenParts.size === expectedParts.length &&
+      expectedParts.every(id => seenParts.has(id))
+    ) {
+      return;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Timed out waiting for complete child performance history of ${fixture.sessionId}`
+      );
+    }
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }