fix(mobile): scope child session error to the child sheet

apps/mobile/src/components/agents/child-session-sheet-state.test.ts

@@ -34,13 +34,64 @@ describe('getChildSessionSheetState', () => {
     ).toBe('empty');
   });
 
+  it('shows an empty state when the session error is null', () => {
+    expect(
+      getChildSessionSheetState(
+        {
+          status: 'ready',
+          cursor: null,
+          hasOlder: false,
+          isLoadingOlder: false,
+          olderError: null,
+          omittedItemCount: 0,
+        },
+        0,
+        null
+      )
+    ).toBe('empty');
+  });
+
   it('shows an error after failed hydration with no messages', () => {
     expect(getChildSessionSheetState({ status: 'error', message: 'Failed' }, 0)).toBe('error');
   });
 
   it('keeps rendering messages if a refresh fails', () => {
     expect(getChildSessionSheetState({ status: 'error', message: 'Failed' }, 1)).toBe('content');
   });
+
+  it('shows an error for a runtime error with no messages and hydration ready', () => {
+    expect(
+      getChildSessionSheetState(
+        {
+          status: 'ready',
+          cursor: null,
+          hasOlder: false,
+          isLoadingOlder: false,
+          olderError: null,
+          omittedItemCount: 0,
+        },
+        0,
+        'Requests ending with a model turn are not supported.'
+      )
+    ).toBe('error');
+  });
+
+  it('keeps rendering messages when a runtime error exists', () => {
+    expect(
+      getChildSessionSheetState(
+        {
+          status: 'ready',
+          cursor: null,
+          hasOlder: false,
+          isLoadingOlder: false,
+          olderError: null,
+          omittedItemCount: 0,
+        },
+        1,
+        'Requests ending with a model turn are not supported.'
+      )
+    ).toBe('content');
+  });
 });
 
 describe('openChildSessionSheet / closeChildSessionSheet', () => {

apps/mobile/src/components/agents/child-session-sheet-state.ts

@@ -19,17 +19,21 @@ export type ChildSessionSheetMountState = {
 
 export function getChildSessionSheetState(
   hydrationState: ChildSessionHydrationState,
-  messageCount: number
+  messageCount: number,
+  sessionError?: string | null
 ): ChildSessionSheetState {
   if (messageCount > 0) {
     return 'content';
   }
-  if (hydrationState.status === 'ready') {
-    return 'empty';
-  }
   if (hydrationState.status === 'error') {
     return 'error';
   }
+  if (sessionError) {
+    return 'error';
+  }
+  if (hydrationState.status === 'ready') {
+    return 'empty';
+  }
   return 'loading';
 }
 

apps/mobile/src/components/agents/child-session-sheet.mounted.test.tsx

@@ -131,6 +131,7 @@ function buildProps({
     title: 'Subagent',
     getChildMessages,
     hydrationState,
+    sessionError: null,
     isStreaming: false,
     hasOlderMessages: false,
     isLoadingOlderMessages: false,

apps/mobile/src/components/agents/child-session-sheet.tsx

@@ -24,6 +24,7 @@ import { MessageErrorBoundary } from './message-error-boundary';
 import { PartDetailSheetHost } from './part-detail-sheet-host';
 import { getChildSessionSheetState } from './child-session-sheet-state';
 import { SessionMessageList } from './session-message-list';
+import { SessionStatusIndicator } from './session-status-indicator';
 import { WorkingIndicator } from './working-indicator';
 
 type ChildSessionSheetProps = {
@@ -32,6 +33,7 @@ type ChildSessionSheetProps = {
   title: string;
   getChildMessages: (sessionId: string) => StoredMessage[];
   hydrationState: ChildSessionHydrationState;
+  sessionError: string | null;
   isStreaming: boolean;
   hasOlderMessages: boolean;
   isLoadingOlderMessages: boolean;
@@ -53,6 +55,7 @@ export function ChildSessionSheet({
   title,
   getChildMessages,
   hydrationState,
+  sessionError,
   isStreaming,
   hasOlderMessages,
   isLoadingOlderMessages,
@@ -67,7 +70,7 @@ export function ChildSessionSheet({
   modelOptions,
 }: Readonly<ChildSessionSheetProps>) {
   const messages = getChildMessages(sessionId);
-  const state = getChildSessionSheetState(hydrationState, messages.length);
+  const state = getChildSessionSheetState(hydrationState, messages.length, sessionError);
   const modelLabel = getChildSessionModelLabel(messages, modelOptions ?? []);
   // 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
@@ -107,13 +110,16 @@ export function ChildSessionSheet({
       />
     );
   } else if (state === 'error') {
-    content = (
-      <QueryError
-        title="Could not load subagent session"
-        message={hydrationState.status === 'error' ? hydrationState.message : undefined}
-        onRetry={onRetry}
-      />
-    );
+    content =
+      hydrationState.status === 'error' ? (
+        <QueryError
+          title="Could not load subagent session"
+          message={hydrationState.message}
+          onRetry={onRetry}
+        />
+      ) : (
+        <QueryError title="Subagent session failed" message={sessionError ?? undefined} />
+      );
   } else if (state === 'empty') {
     content = (
       <EmptyState
@@ -134,6 +140,17 @@ export function ChildSessionSheet({
     );
   }
 
+  if (state === 'content' && sessionError) {
+    content = (
+      <View className="flex-1">
+        <SessionStatusIndicator
+          indicator={{ type: 'error', message: sessionError, timestamp: 0 }}
+        />
+        {content}
+      </View>
+    );
+  }
+
   return (
     <Modal
       visible={visible}

apps/mobile/src/components/agents/session-detail-content.tsx

@@ -201,6 +201,7 @@ export function SessionDetailContent({
   );
   const getChildMessages = useAtomValue(manager.atoms.childMessages);
   const getChildSessionHydrationState = useAtomValue(manager.atoms.childSessionHydrationState);
+  const getChildSessionError = useAtomValue(manager.atoms.childSessionError);
   const pendingMessages = useAtomValue(manager.atoms.pendingMessages);
   const activeSessionType = useAtomValue(manager.atoms.activeSessionType);
   const remoteModelState = useAtomValue(manager.atoms.remoteModelState);
@@ -1159,6 +1160,7 @@ export function SessionDetailContent({
             title={childSessionSheet.sheet.title}
             getChildMessages={getChildMessages}
             hydrationState={getChildSessionHydrationState(childSessionSheet.sheet.sessionId)}
+            sessionError={getChildSessionError(childSessionSheet.sheet.sessionId)}
             isStreaming={getChildSessionStreaming(messages, childSessionSheet.sheet.sessionId)}
             hasOlderMessages={childHasOlderMessages}
             isLoadingOlderMessages={childIsLoadingOlderMessages}

packages/cloud-agent-sdk/src/service-state.test.ts

@@ -284,6 +284,73 @@ describe('createServiceState', () => {
       expect(state.getStatus()).toEqual({ type: 'error', message: 'Something went wrong' });
     });
 
+    it('scopes child errors to onChildSessionError without touching root state', () => {
+      const onError = jest.fn();
+      const onChildSessionError = jest.fn();
+      const state = createServiceState(makeConfig({ onError, onChildSessionError }));
+
+      state.process({
+        type: 'session.error',
+        error: 'Requests ending with a model turn are not supported.',
+        sessionId: 'child-1',
+      });
+
+      expect(onError).not.toHaveBeenCalled();
+      expect(state.getStatus()).toEqual({ type: 'idle' });
+      expect(onChildSessionError).toHaveBeenCalledWith(
+        'child-1',
+        'Requests ending with a model turn are not supported.'
+      );
+    });
+
+    it('keeps root session errors on onError and root status', () => {
+      const onError = jest.fn();
+      const onChildSessionError = jest.fn();
+      const state = createServiceState(makeConfig({ onError, onChildSessionError }));
+
+      state.process({
+        type: 'session.error',
+        error: 'Requests ending with a model turn are not supported.',
+        sessionId: 'root-1',
+      });
+
+      expect(onError).toHaveBeenCalledWith('Requests ending with a model turn are not supported.');
+      expect(onChildSessionError).not.toHaveBeenCalled();
+      expect(state.getStatus()).toEqual({
+        type: 'error',
+        message: 'Requests ending with a model turn are not supported.',
+      });
+    });
+
+    it('adopts the server-reported root session ID for errors', () => {
+      const onError = jest.fn();
+      const onChildSessionError = jest.fn();
+      const state = createServiceState(makeConfig({ onError, onChildSessionError }));
+
+      state.process({ type: 'session.created', info: makeSession('server-root') });
+      state.process({
+        type: 'session.error',
+        error: 'Root session failed.',
+        sessionId: 'server-root',
+      });
+
+      expect(onError).toHaveBeenCalledWith('Root session failed.');
+      expect(onChildSessionError).not.toHaveBeenCalled();
+      expect(state.getStatus()).toEqual({ type: 'error', message: 'Root session failed.' });
+    });
+
+    it('keeps events without a sessionId on the legacy root path', () => {
+      const onError = jest.fn();
+      const onChildSessionError = jest.fn();
+      const state = createServiceState(makeConfig({ onError, onChildSessionError }));
+
+      state.process({ type: 'session.error', error: 'Something went wrong' });
+
+      expect(onError).toHaveBeenCalledWith('Something went wrong');
+      expect(onChildSessionError).not.toHaveBeenCalled();
+      expect(state.getStatus()).toEqual({ type: 'error', message: 'Something went wrong' });
+    });
+
     it('is suppressed after stopped(error) — aftershock absorption', () => {
       const onError = jest.fn();
       const state = createServiceState(makeConfig({ onError }));

packages/cloud-agent-sdk/src/service-state.ts

@@ -26,6 +26,7 @@ type ServiceStateConfig = {
   /** The root session ID we're tracking (to detect child sessions). */
   rootSessionId: string;
   onError?: ((message: string) => void) | undefined;
+  onChildSessionError?: ((sessionId: string, message: string) => void) | undefined;
   onQuestionAsked?: ((requestId: string, questions?: QuestionInfo[]) => void) | undefined;
   onQuestionResolved?: ((requestId: string) => void) | undefined;
   onPermissionAsked?:
@@ -108,6 +109,7 @@ function upsertByRequestId<T extends { requestId: string }>(
 }
 
 function createServiceState(config: ServiceStateConfig): ServiceState {
+  let rootSessionId = config.rootSessionId;
   let activity: SessionActivity = INITIAL_ACTIVITY;
   let status: AgentStatus = IDLE_STATUS;
   let cloudStatus: CloudStatus | null = null;
@@ -134,7 +136,7 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
   }
 
   function isRootSession(sessionId: string): boolean {
-    return sessionId === config.rootSessionId;
+    return sessionId === rootSessionId;
   }
 
   function processSessionStatus(event: Extract<ServiceEvent, { type: 'session.status' }>): void {
@@ -230,13 +232,24 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
   function processSessionError(event: Extract<ServiceEvent, { type: 'session.error' }>): void {
     if (terminated) return;
 
+    // Child session errors are scoped to the child. They must not touch the
+    // shared root status or onError, which drive the parent status indicator.
+    // Events without a sessionId keep the legacy root behavior.
+    if (event.sessionId !== undefined && !isRootSession(event.sessionId)) {
+      config.onChildSessionError?.(event.sessionId, event.error);
+      return;
+    }
+
     config.onError?.(event.error);
     status = { type: 'error', message: event.error };
 
     notify();
   }
 
   function processSessionCreated(event: Extract<ServiceEvent, { type: 'session.created' }>): void {
+    if (event.info.parentID == null) {
+      rootSessionId = event.info.id;
+    }
     // Only track root session info
     if (isRootSession(event.info.id)) {
       sessionInfo = event.info;