diff --git a/apps/mobile/src/components/modal-sheet.tsx b/apps/mobile/src/components/modal-sheet.tsx
index 5b75aa2..2e94636 100644
--- a/apps/mobile/src/components/modal-sheet.tsx
+++ b/apps/mobile/src/components/modal-sheet.tsx
@@ -37,9 +37,13 @@ export function ModalSheet({
   size = "page",
   returnFocusRef,
   closeLabel = "Done",
+  onRequestClose,
 }: {
   children: ReactNode;
   onClose: () => void;
+  // Android back and the iOS dismiss gesture. Defaults to onClose; a sheet with an inner page
+  // passes its own so back returns to the list instead of closing the sheet.
+  onRequestClose?: (() => void) | undefined;
   scrollable?: boolean;
   subtitle?: string;
   title: string;
@@ -58,7 +62,7 @@ export function ModalSheet({
   return (
     <Modal
       animationType={reducedMotion ? "none" : "slide"}
-      onRequestClose={onClose}
+      onRequestClose={onRequestClose ?? onClose}
       onDismiss={() => focusAccessibility(returnFocusRef?.current)}
       onShow={() => focusAccessibility(headingRef.current)}
       presentationStyle={presentationStyle}
@@ -102,7 +106,7 @@ export function ModalSheet({
   );
 }
 
-function focusAccessibility(target: Text | View | null | undefined) {
+export function focusAccessibility(target: Text | View | null | undefined) {
   const handle = target ? findNodeHandle(target) : null;
   if (handle) AccessibilityInfo.setAccessibilityFocus(handle);
 }
diff --git a/apps/mobile/src/components/subagent-status.tsx b/apps/mobile/src/components/subagent-status.tsx
index 1026998..85d8817 100644
--- a/apps/mobile/src/components/subagent-status.tsx
+++ b/apps/mobile/src/components/subagent-status.tsx
@@ -1,6 +1,6 @@
 import Feather from "@expo/vector-icons/Feather";
-import { useEffect, useState } from "react";
-import { StyleSheet, Text, View } from "react-native";
+import { useEffect, useRef, useState } from "react";
+import { type StyleProp, StyleSheet, Text, type TextStyle, View } from "react-native";
 
 import {
   isSubagentInFlight,
@@ -33,6 +33,26 @@ export function subagentStateLabel(state: SubagentState, waitingFor?: SubagentAt
   }
 }
 
+// What a transition is announced as: "Background subagent Review needs you". Running states
+// are not announced; a child that stopped without reporting how is never called a success.
+export function subagentOutcomeLabel(state: SubagentState) {
+  switch (state) {
+    case "running":
+    case "streaming":
+      return undefined;
+    case "waiting":
+      return "needs you";
+    case "error":
+      return "failed";
+    case "interrupted":
+      return "was interrupted";
+    case "finished":
+      return "finished, outcome unknown";
+    case "completed":
+      return "completed";
+  }
+}
+
 // Working is blue, attention and stops amber, failure red, a finished run dim: the hue only
 // reinforces the label beside it.
 export function subagentStateColor(state: SubagentState) {
@@ -61,7 +81,11 @@ export function SubagentStatusGlyph({
   if (state === "running" || state === "streaming") {
     return (
       <View style={styles.glyph} testID="subagent-glyph-working">
-        <WorkingIndicator color={state === "streaming" ? palette.dim : palette.info} />
+        {/* Still: the Working line and the chip carry the motion; the blue label says it runs. */}
+        <WorkingIndicator
+          animated={false}
+          color={state === "streaming" ? palette.dim : palette.info}
+        />
       </View>
     );
   }
@@ -90,17 +114,27 @@ export function SubagentStatusGlyph({
 }
 
 // Ticks once a second while the subagent runs and freezes at its finish. Screen readers skip
-// it, so they are not told every new second.
+// it, so they are not told every new second. Render it as a sibling of any live-region text,
+// never nested inside one: Android flattens nested Text into one node, which would make the
+// live region change, and be read out, every second.
 export function SubagentElapsed({
   finishedAt,
+  frozen = false,
   startedAt,
   state,
+  style,
 }: {
   finishedAt?: number | undefined;
+  // Last-known state from a stale connection: show the time at the last update, without ticking.
+  frozen?: boolean;
   startedAt?: number | undefined;
   state: SubagentState;
+  style?: StyleProp<TextStyle>;
 }) {
-  const live = isSubagentInFlight(state);
+  const live = isSubagentInFlight(state) && !frozen;
+  // Opened while already frozen, it never saw a live tick, so any time shown would be a guess.
+  const sawLive = useRef(!frozen);
+  if (!frozen) sawLive.current = true;
   const [now, setNow] = useState(Date.now);
   useEffect(() => {
     if (!live || startedAt === undefined) return;
@@ -109,10 +143,11 @@ export function SubagentElapsed({
     return () => clearInterval(timer);
   }, [live, startedAt]);
   if (startedAt === undefined) return null;
-  const end = live ? now : finishedAt;
+  if (frozen && isSubagentInFlight(state) && !sawLive.current) return null;
+  const end = live || (frozen && isSubagentInFlight(state)) ? now : finishedAt;
   if (end === undefined) return null;
   return (
-    <Text accessibilityElementsHidden importantForAccessibility="no-hide-descendants">
+    <Text accessibilityElementsHidden importantForAccessibility="no-hide-descendants" style={style}>
       {` · ${formatElapsed(end - startedAt, true)}`}
     </Text>
   );
@@ -124,6 +159,7 @@ export function SubagentMetaLine({
   agent,
   background,
   finishedAt,
+  live = true,
   numberOfLines,
   startedAt,
   state,
@@ -133,34 +169,47 @@ export function SubagentMetaLine({
   agent?: string | undefined;
   background: boolean;
   finishedAt?: number | undefined;
+  // Whether state changes are read out here (Android live region). Off where another view owns
+  // the announcement, so one change is never read twice.
+  live?: boolean;
   numberOfLines?: number | undefined;
   startedAt?: number | undefined;
   state: SubagentState;
   suffix?: string | undefined;
   waitingFor?: SubagentAttention | undefined;
 }) {
+  // The live region holds only the state words; the ticking time is a hidden sibling.
   return (
-    <Text
-      accessibilityLiveRegion="polite"
-      dynamicTypeRamp="footnote"
-      numberOfLines={numberOfLines}
-      style={subagentStatusStyles.meta}
-    >
-      {agent ? `${agent} · ` : ""}
-      {background ? "Background · " : ""}
-      <Text style={{ color: subagentStateColor(state) }}>
-        {subagentStateLabel(state, waitingFor)}
+    <View style={subagentStatusStyles.metaRow}>
+      <Text
+        accessibilityLiveRegion={live ? "polite" : "none"}
+        dynamicTypeRamp="footnote"
+        numberOfLines={numberOfLines}
+        style={[subagentStatusStyles.meta, styles.metaShrink]}
+      >
+        {agent ? `${agent} · ` : ""}
+        {background ? "Background · " : ""}
+        <Text style={{ color: subagentStateColor(state) }}>
+          {subagentStateLabel(state, waitingFor)}
+        </Text>
+        {suffix ?? ""}
       </Text>
-      <SubagentElapsed finishedAt={finishedAt} startedAt={startedAt} state={state} />
-      {suffix ?? ""}
-    </Text>
+      <SubagentElapsed
+        finishedAt={finishedAt}
+        startedAt={startedAt}
+        state={state}
+        style={subagentStatusStyles.meta}
+      />
+    </View>
   );
 }
 
 export const subagentStatusStyles = StyleSheet.create({
   meta: { ...typography.footnote, color: palette.dim },
+  metaRow: { alignItems: "baseline", flexDirection: "row", flexWrap: "wrap" },
 });
 
 const styles = StyleSheet.create({
   glyph: { alignItems: "center", height: 20, justifyContent: "center", width: 16 },
+  metaShrink: { flexShrink: 1 },
 });
diff --git a/apps/mobile/src/components/working-indicator.tsx b/apps/mobile/src/components/working-indicator.tsx
index 68bc086..3eb6ebb 100644
--- a/apps/mobile/src/components/working-indicator.tsx
+++ b/apps/mobile/src/components/working-indicator.tsx
@@ -17,8 +17,16 @@ const dots = [0, 1, 2, 3, 4, 5].map((bit) => ({
 }));
 
 // The one working animation, shared by the session list and the session screen. The inbox
-// passes its blue working color so the spinner matches the row's status text.
-export function WorkingIndicator({ color = palette.activity }: { color?: string } = {}) {
+// passes its blue working color so the spinner matches the row's status text. Only the Working
+// line and the background-work chip animate; other running glyphs pass animated={false} and keep
+// the still first frame, so one screen never has a field of spinners ticking out of step.
+export function WorkingIndicator({
+  animated = true,
+  color = palette.activity,
+}: {
+  animated?: boolean;
+  color?: string;
+} = {}) {
   const [reducedMotion, setReducedMotion] = useState(true);
   const [foreground, setForeground] = useState(AppState.currentState === "active");
 
@@ -51,13 +59,14 @@ export function WorkingIndicator({ color = palette.activity }: { color?: string
               top: (bit % 3) * 4.5,
               opacity: (0x0b & (1 << bit)) !== 0 ? 1 : 0,
             },
-            !reducedMotion && {
-              animationName: animation,
-              animationDuration: 800,
-              animationIterationCount: "infinite",
-              animationTimingFunction: steps(1, "end"),
-              animationPlayState: foreground ? "running" : "paused",
-            },
+            animated &&
+              !reducedMotion && {
+                animationName: animation,
+                animationDuration: 800,
+                animationIterationCount: "infinite",
+                animationTimingFunction: steps(1, "end"),
+                animationPlayState: foreground ? "running" : "paused",
+              },
           ]}
         />
       ))}
diff --git a/apps/mobile/src/screens/session-background-shell-detail.tsx b/apps/mobile/src/screens/session-background-shell-detail.tsx
new file mode 100644
index 0000000..35048e8
--- /dev/null
+++ b/apps/mobile/src/screens/session-background-shell-detail.tsx
@@ -0,0 +1,356 @@
+import { useEffect, useRef, useState } from "react";
+import {
+  Alert,
+  type NativeScrollEvent,
+  type NativeSyntheticEvent,
+  ScrollView,
+  StyleSheet,
+  Text,
+  useWindowDimensions,
+  View,
+} from "react-native";
+
+import { Button } from "../components/button";
+import { focusAccessibility } from "../components/modal-sheet";
+import { SelectableTranscriptText } from "../components/selectable-transcript-text";
+import { SubagentElapsed } from "../components/subagent-status";
+import { useAnnouncement } from "../components/use-announcement";
+import { minTouchTarget, palette, radius, space, typeRamp, typography } from "../theme";
+import {
+  type ShellCandidate,
+  shellOutputTail,
+  shellPageStatus,
+  shortShellCommand,
+} from "./session-background-shells-model";
+import { ShellObservation } from "./session-shell-output";
+import type { ShellSnapshot } from "./session-shell-output-model";
+
+// Within this distance of the end, new output keeps the box scrolled to the end.
+const followThreshold = 24;
+// About four lines of command at the default size; grows with text size up to twice that.
+const commandMaxHeight = 96;
+
+// One background shell inside the monitor sheet: its command, run time, the last lines of live
+// output, and Stop. Once it ends, Stop gives way to how it ended. It stays on screen after the
+// shell leaves the running list, until Back or the sheet closes.
+export function BackgroundShellDetail({
+  onBack,
+  onStop,
+  shell,
+  stale,
+}: {
+  onBack: () => void;
+  onStop?: ((shellID: string) => Promise<void>) | undefined;
+  shell: ShellCandidate;
+  stale: boolean;
+}) {
+  const headingRef = useRef<Text>(null);
+  // Opening replaces the row that held focus, so focus moves to this page's heading.
+  useEffect(() => {
+    const frame = requestAnimationFrame(() => focusAccessibility(headingRef.current));
+    return () => cancelAnimationFrame(frame);
+  }, []);
+  const { fontScale } = useWindowDimensions();
+  // Back stays pinned; the page below it scrolls, so Back never scrolls away at large text.
+  return (
+    <View onAccessibilityEscape={onBack} style={styles.container}>
+      <Button
+        accessibilityLabel="Back to background work"
+        align="start"
+        icon="chevron-left"
+        label="Back"
+        onPress={onBack}
+        size="compact"
+        variant="text"
+      />
+      <ScrollView
+        contentContainerStyle={styles.page}
+        keyboardShouldPersistTaps="handled"
+        style={styles.pageScroll}
+      >
+        <Text
+          ref={headingRef}
+          accessibilityRole="header"
+          dynamicTypeRamp={typeRamp.headline}
+          style={styles.heading}
+        >
+          Shell
+        </Text>
+        <ScrollView
+          nestedScrollEnabled
+          style={[styles.commandScroll, { maxHeight: commandMaxHeight * Math.min(fontScale, 2) }]}
+        >
+          <SelectableTranscriptText dynamicTypeRamp={typeRamp.body} style={styles.command}>
+            {shell.command}
+          </SelectableTranscriptText>
+        </ScrollView>
+        <ShellObservation shellID={shell.shellID}>
+          {(observation) => (
+            <ShellState
+              error={Boolean(observation?.error)}
+              onRetry={observation?.retry}
+              onStop={onStop && !stale ? () => onStop(shell.shellID) : undefined}
+              shell={shell}
+              snapshot={observation?.snapshot}
+              stale={stale}
+            />
+          )}
+        </ShellObservation>
+      </ScrollView>
+    </View>
+  );
+}
+
+function ShellState({
+  error,
+  onRetry,
+  onStop,
+  shell,
+  snapshot,
+  stale,
+}: {
+  error: boolean;
+  onRetry: (() => void) | undefined;
+  onStop: (() => Promise<void>) | undefined;
+  shell: ShellCandidate;
+  snapshot: ShellSnapshot | undefined;
+  stale: boolean;
+}) {
+  // A failed refresh is as uncertain as a stale connection: last known, frozen, no Stop.
+  const degraded = stale || error;
+  const status = shellPageStatus(snapshot, degraded);
+  const endedAt = useEndedAt(status.ended);
+  const stop = useShellStop(shell.command, degraded ? undefined : onStop);
+  const statusRef = useRef<Text>(null);
+  // The Stop button that held focus is replaced by how the shell ended, so focus follows.
+  useEffect(() => {
+    if (status.ended && stop.requested) focusAccessibility(statusRef.current);
+  }, [status.ended, stop.requested]);
+  // Live regions are Android-only; iOS hears the end and a failed stop once each. After a Stop
+  // here, focus moves to the end state, which reads it; announcing too would read it twice.
+  useAnnouncement(status.ended && !stop.requested && `Shell ${status.ended.toLocaleLowerCase()}`);
+  useAnnouncement(stop.failed && stopFailedMessage);
+  const info = snapshot?.info;
+  return (
+    <View style={styles.state}>
+      <View style={styles.statusRow}>
+        <View style={styles.status}>
+          <Text
+            ref={statusRef}
+            accessibilityLiveRegion={stop.requested ? "none" : "polite"}
+            dynamicTypeRamp={typeRamp.footnote}
+            style={[styles.statusLabel, toneStyles[status.tone]]}
+          >
+            {status.label}
+          </Text>
+          <SubagentElapsed
+            finishedAt={info?.time.completed ?? endedAt}
+            frozen={degraded && !status.ended}
+            startedAt={info?.time.started ?? shell.startedAt}
+            state={status.ended ? "completed" : "running"}
+            style={styles.statusLabel}
+          />
+        </View>
+        {!status.ended && stop.available ? (
+          <Button
+            accessibilityLabel={`Stop ${shortShellCommand(shell.command)}`}
+            busy={stop.stopping}
+            label={stop.stopping ? "Stopping" : "Stop"}
+            onPress={stop.confirm}
+            size="compact"
+            variant="danger"
+          />
+        ) : null}
+      </View>
+      <ShellAlerts
+        onRetry={onRetry}
+        refreshFailed={error}
+        stopFailed={stop.failed && !status.ended}
+      />
+      <ShellTail
+        ended={Boolean(status.ended)}
+        error={error}
+        loaded={Boolean(snapshot)}
+        output={snapshot?.output ?? ""}
+        stale={stale}
+        truncated={Boolean(snapshot?.truncated)}
+      />
+    </View>
+  );
+}
+
+// A removed shell reports no completion time; the run time freezes when the page saw it end.
+function useEndedAt(ended: string | undefined) {
+  const [endedAt, setEndedAt] = useState<number>();
+  useEffect(() => {
+    if (ended && endedAt === undefined) setEndedAt(Date.now());
+  }, [ended, endedAt]);
+  return endedAt;
+}
+
+function ShellAlerts({
+  onRetry,
+  refreshFailed,
+  stopFailed,
+}: {
+  onRetry: (() => void) | undefined;
+  refreshFailed: boolean;
+  stopFailed: boolean;
+}) {
+  return (
+    <>
+      {stopFailed ? (
+        <Text accessibilityRole="alert" dynamicTypeRamp={typeRamp.footnote} style={styles.error}>
+          {stopFailedMessage}
+        </Text>
+      ) : null}
+      {refreshFailed ? (
+        <View style={styles.errorRow}>
+          <Text accessibilityRole="alert" dynamicTypeRamp={typeRamp.footnote} style={styles.error}>
+            Shell output could not be refreshed.
+          </Text>
+          {onRetry ? (
+            <Button label="Retry" onPress={onRetry} size="compact" variant="text" />
+          ) : null}
+        </View>
+      ) : null}
+    </>
+  );
+}
+
+const stopFailedMessage = "The shell could not be stopped. Try again.";
+
+// Once a stop is sent, the button stays "Stopping" until the refreshed status says how the
+// shell ended and replaces it. A failure re-enables it.
+function useShellStop(command: string, onStop: (() => Promise<void>) | undefined) {
+  const [stopping, setStopping] = useState(false);
+  const [failed, setFailed] = useState(false);
+  const [requested, setRequested] = useState(false);
+  function confirm() {
+    if (!onStop) return;
+    Alert.alert(`Stop ${shortShellCommand(command)}?`, "This ends the command on the server.", [
+      { style: "cancel", text: "Keep running" },
+      {
+        onPress: () => {
+          setStopping(true);
+          setFailed(false);
+          setRequested(true);
+          onStop().catch(() => {
+            setFailed(true);
+            setStopping(false);
+            setRequested(false);
+          });
+        },
+        style: "destructive",
+        text: "Stop shell",
+      },
+    ]);
+  }
+  return { available: Boolean(onStop), confirm, failed, requested, stopping };
+}
+
+function ShellTail({
+  ended,
+  error,
+  loaded,
+  output,
+  stale,
+  truncated,
+}: {
+  ended: boolean;
+  error: boolean;
+  loaded: boolean;
+  output: string;
+  stale: boolean;
+  truncated: boolean;
+}) {
+  const scrollRef = useRef<ScrollView>(null);
+  // Follows new output only while the reader is at the end; scrolling up to read stays put.
+  const following = useRef(true);
+  const tail = shellOutputTail(output);
+  const empty = !loaded
+    ? error || stale
+      ? "Output unavailable"
+      : "Loading output…"
+    : ended
+      ? "No output"
+      : "No output yet";
+  return (
+    <View style={styles.tail}>
+      {tail.text && (tail.clipped || truncated) ? (
+        <Text dynamicTypeRamp={typeRamp.footnote} style={styles.caption}>
+          Showing recent output.
+        </Text>
+      ) : null}
+      <ScrollView
+        ref={scrollRef}
+        accessibilityLabel="Shell output"
+        nestedScrollEnabled
+        onContentSizeChange={() => {
+          if (following.current) scrollRef.current?.scrollToEnd({ animated: false });
+        }}
+        onScroll={({
+          nativeEvent: { contentOffset, contentSize, layoutMeasurement },
+        }: NativeSyntheticEvent<NativeScrollEvent>) => {
+          following.current =
+            contentSize.height - layoutMeasurement.height - contentOffset.y <= followThreshold;
+        }}
+        scrollEventThrottle={100}
+        style={styles.output}
+      >
+        {tail.text ? (
+          <SelectableTranscriptText dynamicTypeRamp={typeRamp.body} style={styles.outputText}>
+            {tail.text}
+          </SelectableTranscriptText>
+        ) : (
+          <Text dynamicTypeRamp={typeRamp.footnote} style={styles.empty}>
+            {empty}
+          </Text>
+        )}
+      </ScrollView>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  caption: { ...typography.footnote, color: palette.dim },
+  command: { ...typography.code, color: palette.ink },
+  commandScroll: { flexGrow: 0 },
+  container: { flex: 1, gap: space.sm },
+  empty: { ...typography.footnote, color: palette.dim, padding: 12 },
+  error: { ...typography.footnote, color: palette.danger, flexShrink: 1 },
+  errorRow: { alignItems: "center", flexDirection: "row", flexWrap: "wrap", gap: space.sm },
+  failed: { color: palette.danger },
+  heading: { ...typography.headline, color: palette.ink },
+  output: {
+    backgroundColor: palette.raised,
+    borderColor: palette.border,
+    borderRadius: radius.sm,
+    borderWidth: StyleSheet.hairlineWidth,
+    maxHeight: 360,
+  },
+  outputText: { ...typography.code, color: palette.dim, padding: 12 },
+  page: { gap: space.sm },
+  pageScroll: { flex: 1 },
+  running: { color: palette.info },
+  state: { gap: space.sm },
+  status: { alignItems: "baseline", flexDirection: "row", flexShrink: 1, flexWrap: "wrap" },
+  statusLabel: { ...typography.footnote, color: palette.dim },
+  statusRow: {
+    alignItems: "center",
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: space.sm,
+    justifyContent: "space-between",
+    minHeight: minTouchTarget,
+  },
+  stopped: { color: palette.warm },
+  tail: { gap: space.xs },
+});
+
+const toneStyles = StyleSheet.create({
+  dim: {},
+  failed: { color: palette.danger },
+  running: { color: palette.info },
+  stopped: { color: palette.warm },
+});
diff --git a/apps/mobile/src/screens/session-background-shells-model.test.ts b/apps/mobile/src/screens/session-background-shells-model.test.ts
new file mode 100644
index 0000000..1dc6ac7
--- /dev/null
+++ b/apps/mobile/src/screens/session-background-shells-model.test.ts
@@ -0,0 +1,153 @@
+import { expect, test } from "@jest/globals";
+import type { SessionMessageInfo } from "@opencode2-mobile/opencode-adapter";
+
+import {
+  backgroundWorkSummary,
+  shellCandidates,
+  shellEndLabel,
+  shellOutputTail,
+  shellPageStatus,
+  shortShellCommand,
+} from "./session-background-shells-model";
+
+function shellCall(id: string, state: Record<string, unknown>, name = "shell"): SessionMessageInfo {
+  return {
+    id: `msg_${id}`,
+    type: "assistant",
+    agent: "build",
+    model: { id: "model", providerID: "provider" },
+    time: { created: 1, completed: 2 },
+    content: [{ id: `tool_${id}`, name, type: "tool", time: { created: 5, ran: 7 }, state }],
+  } as SessionMessageInfo;
+}
+
+const info = {
+  command: "pnpm dev",
+  cwd: "/workspace",
+  file: "/output",
+  id: "sh_dev",
+  metadata: {},
+  shell: "sh",
+  status: "running" as const,
+  time: { started: 1 },
+};
+
+test("candidates are background shell calls with a shellID, in launch order, once each", () => {
+  const messages = [
+    // Newest first, as the transcript pages arrive.
+    shellCall("c", {
+      status: "completed",
+      input: { cmd: "pnpm test --watch" },
+      metadata: { background: true, shellID: "sh_watch" },
+    }),
+    shellCall("b", {
+      status: "completed",
+      input: { command: "pnpm dev", background: true },
+      metadata: { shellID: "sh_dev", status: "running" },
+    }),
+    shellCall("a", {
+      status: "completed",
+      input: { command: "pnpm dev (older call)", background: true },
+      metadata: { shellID: "sh_dev" },
+    }),
+  ];
+  expect(shellCandidates(messages)).toEqual([
+    { command: "pnpm dev", key: "sh_dev", shellID: "sh_dev", startedAt: 7 },
+    { command: "pnpm test --watch", key: "sh_watch", shellID: "sh_watch", startedAt: 7 },
+  ]);
+});
+
+test("a call moved to the background counts once it no longer blocks its turn", () => {
+  const moved = { input: { command: "build" }, metadata: { shellID: "sh_build" } };
+  expect(shellCandidates([shellCall("a", { status: "running", ...moved })])).toEqual([]);
+  expect(shellCandidates([shellCall("a", { status: "completed", ...moved })])).toEqual([
+    { command: "build", key: "sh_build", shellID: "sh_build", startedAt: 7 },
+  ]);
+});
+
+test.each([
+  [
+    "a final result",
+    {
+      status: "completed",
+      input: { command: "x", background: true },
+      metadata: { shellID: "sh", status: "exited" },
+    },
+  ],
+  ["no shellID", { status: "completed", input: { command: "x", background: true }, metadata: {} }],
+  ["a streaming call", { status: "streaming", input: '{"command":"x"}' }],
+])("skips %s", (_name, state) => {
+  expect(shellCandidates([shellCall("a", state)])).toEqual([]);
+});
+
+test("other tools are not shells, and commands are sanitized", () => {
+  const state = {
+    status: "completed",
+    input: { command: "\u001b[31mrm\u001b[0m -rf build", background: true },
+    metadata: { shellID: "sh_a" },
+  };
+  expect(shellCandidates([shellCall("a", state, "read")])).toEqual([]);
+  expect(shellCandidates([shellCall("a", state, "bash")])[0]?.command).toBe("rm -rf build");
+});
+
+test("the summary follows desktop wording", () => {
+  expect(backgroundWorkSummary(0, 1)).toBe("1 shell");
+  expect(backgroundWorkSummary(0, 2)).toBe("2 shells");
+  expect(backgroundWorkSummary(1, 1)).toBe("1 subagent · 1 shell");
+  expect(backgroundWorkSummary(2, 0)).toBe("2 subagents");
+});
+
+test("end labels say how a shell ended, and nothing while it runs", () => {
+  expect(shellEndLabel(undefined, false)).toBeUndefined();
+  expect(shellEndLabel(info, false)).toBeUndefined();
+  expect(shellEndLabel({ ...info, status: "exited" }, false)).toBe("Exited");
+  expect(shellEndLabel({ ...info, exit: 0, status: "exited" }, false)).toBe("Exited");
+  expect(shellEndLabel({ ...info, exit: 1, status: "exited" }, false)).toBe("Exited with code 1");
+  expect(shellEndLabel({ ...info, status: "timeout" }, false)).toBe("Timed out");
+  expect(shellEndLabel({ ...info, status: "killed" }, false)).toBe("Stopped");
+  expect(shellEndLabel(undefined, true)).toBe("Stopped");
+});
+
+test("the tail keeps the last lines without escape codes and says when it clipped", () => {
+  const output = Array.from({ length: 50 }, (_, index) => `\u001b[2mline ${index}\u001b[0m`).join(
+    "\r\n",
+  );
+  const tail = shellOutputTail(`${output}\r\n`);
+  expect(tail.clipped).toBe(true);
+  expect(tail.text.split("\n")).toHaveLength(40);
+  expect(tail.text.startsWith("line 10\n")).toBe(true);
+  expect(tail.text.endsWith("line 49")).toBe(true);
+  expect(shellOutputTail("50%\r75%\r")).toEqual({ clipped: false, text: "50%\n75%" });
+  expect(shellOutputTail("")).toEqual({ clipped: false, text: "" });
+});
+
+test("short commands read aloud as one bounded line", () => {
+  expect(shortShellCommand("  pnpm   dev  ")).toBe("pnpm dev");
+  expect(shortShellCommand("\ncd app &&\n  pnpm build")).toBe("cd app &&");
+  const long = shortShellCommand(`echo ${"x".repeat(300)}`);
+  expect(long).toHaveLength(120);
+  expect(long.endsWith("…")).toBe(true);
+});
+
+test("the page status says how a shell ended, or that it runs, last known when degraded", () => {
+  expect(shellPageStatus(undefined, false)).toEqual({ label: "Running", tone: "running" });
+  expect(shellPageStatus({ info, missing: false }, true)).toEqual({
+    label: "Last known: Running",
+    tone: "dim",
+  });
+  expect(
+    shellPageStatus({ info: { ...info, exit: 2, status: "exited" }, missing: false }, false),
+  ).toEqual({ ended: "Exited with code 2", label: "Exited with code 2", tone: "failed" });
+  expect(
+    shellPageStatus({ info: { ...info, status: "timeout" }, missing: false }, false).tone,
+  ).toBe("failed");
+  expect(
+    shellPageStatus({ info: { ...info, exit: 0, status: "exited" }, missing: false }, false),
+  ).toEqual({ ended: "Exited", label: "Exited", tone: "dim" });
+  // A removed shell keeps its last running info but reads as stopped, never as failed.
+  expect(shellPageStatus({ info, missing: true }, true)).toEqual({
+    ended: "Stopped",
+    label: "Stopped",
+    tone: "stopped",
+  });
+});
diff --git a/apps/mobile/src/screens/session-background-shells-model.ts b/apps/mobile/src/screens/session-background-shells-model.ts
new file mode 100644
index 0000000..2bcc739
--- /dev/null
+++ b/apps/mobile/src/screens/session-background-shells-model.ts
@@ -0,0 +1,156 @@
+import type { SessionMessageInfo, ShellGetOutput } from "@opencode2-mobile/opencode-adapter";
+
+import { sanitizeTranscriptText } from "./session-transcript-model";
+
+type AssistantMessage = Extract<SessionMessageInfo, { type: "assistant" }>;
+type AssistantTool = Extract<AssistantMessage["content"][number], { type: "tool" }>;
+type ShellInfo = ShellGetOutput["data"];
+
+export const shellToolNames = new Set(["bash", "command", "exec", "shell", "terminal"]);
+
+export function isShellTool(tool: Pick<AssistantTool, "name">) {
+  return shellToolNames.has(tool.name.trim().toLocaleLowerCase());
+}
+
+// A shell the transcript says may still run in the background. Whether it does is the
+// server's answer, not the transcript's.
+export type ShellCandidate = {
+  command: string;
+  key: string;
+  // Its last status refresh failed, so "Running" is only the last known state.
+  lastKnown?: boolean;
+  shellID: string;
+  startedAt?: number;
+};
+
+const maxCommandCharacters = 4_096;
+
+// Shell calls that recorded a shellID and were started in, or moved to, the background, in launch
+// order. A call that is still running blocks its turn, so it is foreground work and stays in the
+// transcript, as in OpenCode desktop and iOS. Terminal metadata means the call already holds the
+// shell's final result.
+export function shellCandidates(messages: SessionMessageInfo[]): ShellCandidate[] {
+  const seen = new Set<string>();
+  const newestFirst: ShellCandidate[] = [];
+  for (const message of messages) {
+    if (message.type !== "assistant") continue;
+    for (let index = message.content.length - 1; index >= 0; index -= 1) {
+      const part = message.content[index];
+      if (part?.type !== "tool" || !isShellTool(part)) continue;
+      const candidate = shellCandidate(part);
+      if (!candidate || seen.has(candidate.shellID)) continue;
+      seen.add(candidate.shellID);
+      newestFirst.push(candidate);
+    }
+  }
+  return newestFirst.reverse();
+}
+
+function shellCandidate(tool: AssistantTool): ShellCandidate | undefined {
+  if (tool.state.status === "streaming") return undefined;
+  const metadata: Record<string, unknown> = isRecord(tool.state.metadata)
+    ? tool.state.metadata
+    : {};
+  const input: Record<string, unknown> = isRecord(tool.state.input) ? tool.state.input : {};
+  const shellID = metadata.shellID;
+  if (typeof shellID !== "string" || !shellID) return undefined;
+  const background = input.background === true || metadata.background === true;
+  if (!background && tool.state.status === "running") return undefined;
+  if (
+    metadata.status === "exited" ||
+    metadata.status === "timeout" ||
+    metadata.status === "killed"
+  ) {
+    return undefined;
+  }
+  const command = [input.command, input.cmd].find(
+    (value): value is string => typeof value === "string" && value.trim().length > 0,
+  );
+  return {
+    command: command ? sanitizeTranscriptText(command.trim(), maxCommandCharacters) : "Shell",
+    key: shellID,
+    shellID,
+    startedAt: tool.time.ran ?? tool.time.created,
+  };
+}
+
+// "1 subagent · 2 shells", the way OpenCode desktop summarizes background work.
+export function backgroundWorkSummary(subagents: number, shells: number) {
+  const parts: string[] = [];
+  if (subagents > 0) parts.push(`${subagents} ${subagents === 1 ? "subagent" : "subagents"}`);
+  if (shells > 0) parts.push(`${shells} ${shells === 1 ? "shell" : "shells"}`);
+  return parts.join(" · ");
+}
+
+// How a shell ended, or undefined while it runs or before its status is known. A removed
+// shell answers not found, and removing is how a shell is stopped.
+export function shellEndLabel(info: ShellInfo | undefined, missing: boolean) {
+  if (missing) return "Stopped";
+  switch (info?.status) {
+    case undefined:
+    case "running":
+      return undefined;
+    case "timeout":
+      return "Timed out";
+    case "killed":
+      return "Stopped";
+    case "exited":
+      return info.exit === undefined || info.exit === 0
+        ? "Exited"
+        : `Exited with code ${info.exit}`;
+  }
+}
+
+export type ShellPageStatus = {
+  ended?: string;
+  label: string;
+  tone: "dim" | "failed" | "running" | "stopped";
+};
+
+// What the shell page says about a shell: how it ended, or that it runs. A stale connection or
+// a failed refresh is degraded, so a running shell is only "Last known: Running".
+export function shellPageStatus(
+  snapshot: { info?: ShellInfo | undefined; missing: boolean } | undefined,
+  degraded: boolean,
+): ShellPageStatus {
+  const info = snapshot?.info;
+  const ended = snapshot ? shellEndLabel(info, snapshot.missing) : undefined;
+  if (!ended) {
+    return degraded
+      ? { label: "Last known: Running", tone: "dim" }
+      : { label: "Running", tone: "running" };
+  }
+  const failed =
+    !snapshot?.missing &&
+    (info?.status === "timeout" ||
+      (info?.status === "exited" && info.exit !== undefined && info.exit !== 0));
+  return {
+    ended,
+    label: ended,
+    tone: failed ? "failed" : ended === "Stopped" ? "stopped" : "dim",
+  };
+}
+
+export const shellTailLines = 40;
+
+// The last lines of output with escape codes stripped and carriage returns as line breaks.
+// clipped says older lines were left out, so the page can say it shows recent output.
+export function shellOutputTail(output: string, lines = shellTailLines) {
+  const all = sanitizeTranscriptText(output).trimEnd().split("\n");
+  return { clipped: all.length > lines, text: all.slice(-lines).join("\n") };
+}
+
+const maxSpokenCommandCharacters = 120;
+
+// A command short enough to read aloud or title an alert: its first line, whitespace collapsed.
+export function shortShellCommand(command: string) {
+  const firstLine = command.split("\n").find((line) => line.trim()) ?? command;
+  const collapsed = firstLine.replace(/\s+/g, " ").trim();
+  return collapsed.length > maxSpokenCommandCharacters
+    ? `${collapsed.slice(0, maxSpokenCommandCharacters - 1).trimEnd()}…`
+    : collapsed;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
diff --git a/apps/mobile/src/screens/session-background-tasks.test.tsx b/apps/mobile/src/screens/session-background-tasks.test.tsx
index f05091c..72cb439 100644
--- a/apps/mobile/src/screens/session-background-tasks.test.tsx
+++ b/apps/mobile/src/screens/session-background-tasks.test.tsx
@@ -1,10 +1,108 @@
-import { expect, jest, test } from "@jest/globals";
-import type { SessionMessageInfo } from "@opencode2-mobile/opencode-adapter";
-import { act, fireEvent, render, screen } from "@testing-library/react-native";
-import { Alert, type AlertButton } from "react-native";
+import { afterEach, beforeEach, expect, jest, test } from "@jest/globals";
+import {
+  getOpenCodeShell,
+  getOpenCodeShellOutput,
+  type OpenCodeClient,
+  removeOpenCodeShell,
+  type SessionMessageInfo,
+  type ShellGetOutput,
+} from "@opencode2-mobile/opencode-adapter";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+  act,
+  fireEvent,
+  render as renderWithoutQueries,
+  screen,
+  waitFor,
+} from "@testing-library/react-native";
+import type { ReactElement, ReactNode } from "react";
+import { AccessibilityInfo, Alert, type AlertButton, Modal, Platform } from "react-native";
 
 import { palette } from "../theme";
 import { SessionBackgroundTasks } from "./session-background-tasks";
+import { SessionShellScope } from "./session-shell-output";
+
+jest.mock("@opencode2-mobile/opencode-adapter", () => ({
+  getOpenCodeShell: jest.fn(),
+  getOpenCodeShellOutput: jest.fn(),
+  isShellNotFoundError: (error: unknown) =>
+    (error as { _tag?: string })?._tag === "ShellNotFoundError",
+  maxShellOutputBytes: 65536,
+  removeOpenCodeShell: jest.fn(),
+}));
+
+const getShell = jest.mocked(getOpenCodeShell);
+const getOutput = jest.mocked(getOpenCodeShellOutput);
+const removeShell = jest.mocked(removeOpenCodeShell);
+const location = { directory: "/workspace" };
+const notFound = Object.assign(new Error("Shell not found"), { _tag: "ShellNotFoundError" });
+// Shell IDs the fake server has removed; later reads answer not found, as on the server.
+let removed = new Set<string>();
+let shellStates: Record<string, Partial<ShellGetOutput["data"]>> = {};
+let shellOutput: Record<string, string> = {};
+// Cleared after each test, so no cache timer outlives it.
+const queryClients: QueryClient[] = [];
+
+function testQueryClient() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  queryClients.push(queryClient);
+  return queryClient;
+}
+
+afterEach(() => {
+  for (const queryClient of queryClients.splice(0)) queryClient.clear();
+});
+
+beforeEach(() => {
+  removed = new Set();
+  shellStates = {};
+  shellOutput = {};
+  getShell.mockReset().mockImplementation(async (_client, _location, id) => {
+    const state = shellStates[id];
+    if (!state || removed.has(id)) throw notFound;
+    return {
+      location,
+      data: {
+        command: "pnpm dev",
+        cwd: "/workspace",
+        file: "/output",
+        id,
+        metadata: {},
+        shell: "sh",
+        status: "running",
+        time: { started: 1_000 },
+        ...state,
+      },
+    };
+  });
+  getOutput.mockReset().mockImplementation(async (_client, _location, id, options) => {
+    if (removed.has(id)) throw notFound;
+    const bytes = shellOutput[id] ?? "";
+    const cursor = options?.cursor ?? 0;
+    return {
+      location,
+      data: {
+        cursor: bytes.length,
+        output: bytes.slice(cursor),
+        size: bytes.length,
+        truncated: false,
+      },
+    };
+  });
+  removeShell.mockReset().mockImplementation(async (_client, _location, id) => {
+    removed.add(id);
+  });
+});
+
+// No shell scope, so shell status stays unknown and only subagents are counted.
+function render(element: ReactElement) {
+  const queryClient = testQueryClient();
+  return renderWithoutQueries(element, {
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    ),
+  });
+}
 
 function taskMessage(state: "running" | "completed" | "error"): SessionMessageInfo {
   return {
@@ -54,8 +152,9 @@ test("the chip opens the monitor, whose rows open the child without repeating it
   expect(chip).toHaveStyle({ minHeight: 36 });
   expect(chip.props.hitSlop).toBe(6);
   fireEvent.press(chip);
+  expect(screen.getByRole("header", { name: "Background work" })).toBeOnTheScreen();
   expect(screen.getByRole("header", { name: "Subagents" })).toBeOnTheScreen();
-  expect(screen.getByRole("header", { name: "Working" })).toBeOnTheScreen();
+  expect(screen.queryByRole("header", { name: "Shells" })).toBeNull();
   fireEvent.press(screen.getByRole("button", { name: "Delegated task, Running" }));
   expect(onOpenChild).toHaveBeenCalledWith("ses_child");
 });
@@ -137,7 +236,7 @@ test("a child blocked on a request is counted, flagged, and listed first", () =>
     />,
   );
   const chip = screen.getByRole("button", {
-    name: "2 subagents · 1 needs you, running in this session",
+    name: "2 subagents, 1 needs you, running in this session",
   });
   expect(chip).toHaveStyle({ borderColor: palette.warm });
   expect(screen.getByTestId("subagent-monitor-waiting")).toBeOnTheScreen();
@@ -255,3 +354,506 @@ test("a failed stop explains itself and offers Stop again", async () => {
     alert.mockRestore();
   }
 });
+
+function shellLaunch(
+  shellID: string,
+  command: string,
+  options: { background?: "input" | "metadata" | "moved"; status?: string } = {},
+): SessionMessageInfo {
+  const background = options.background ?? "input";
+  return {
+    id: `msg_${shellID}`,
+    type: "assistant",
+    agent: "build",
+    model: { id: "model", providerID: "provider" },
+    time: { created: 1, completed: 2 },
+    content: [
+      {
+        id: `tool_${shellID}`,
+        name: "shell",
+        type: "tool",
+        time: { created: 1, ran: 1 },
+        state: {
+          status: "completed",
+          input: { command, ...(background === "input" ? { background: true } : {}) },
+          metadata: {
+            shellID,
+            status: options.status ?? "running",
+            ...(background === "metadata" ? { background: true } : {}),
+          },
+          content: [{ type: "text", text: "Command started in the background." }],
+        },
+      },
+    ],
+  };
+}
+
+// The chip appears once shell status loads; let its indicator settle inside act.
+async function findChip(name: string) {
+  const chip = await screen.findByRole("button", { name });
+  await act(async () => undefined);
+  return chip;
+}
+
+function renderWithShells(element: ReactElement, enabled = true) {
+  const queryClient = testQueryClient();
+  return renderWithoutQueries(element, {
+    wrapper: ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>
+        <SessionShellScope.Provider
+          value={{ client: {} as OpenCodeClient, connectionId: "connection-1", enabled, location }}
+        >
+          {children}
+        </SessionShellScope.Provider>
+      </QueryClientProvider>
+    ),
+  });
+}
+
+test("running background shells join the chip and get their own section", async () => {
+  shellStates = { sh_dev: {}, sh_watch: {}, sh_done: { exit: 0, status: "exited" } };
+  renderWithShells(
+    <SessionBackgroundTasks
+      messages={[
+        shellLaunch("sh_done", "pnpm build"),
+        shellLaunch("sh_watch", "pnpm test --watch", { background: "metadata" }),
+        shellLaunch("sh_dev", "pnpm dev", { background: "moved" }),
+        taskMessage("running"),
+      ]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  const chip = await findChip("1 subagent, 2 shells, running in this session");
+  fireEvent.press(chip);
+  expect(screen.getByRole("header", { name: "Subagents" })).toBeOnTheScreen();
+  expect(screen.getByRole("header", { name: "Shells" })).toBeOnTheScreen();
+  expect(screen.getByRole("button", { name: "pnpm dev, Running" })).toBeOnTheScreen();
+  expect(screen.getByRole("button", { name: "pnpm test --watch, Running" })).toBeOnTheScreen();
+  // The server says this one exited, so it is not listed as running.
+  expect(screen.queryByText("pnpm build")).toBeNull();
+});
+
+test("shell-only work names shells, and nothing running shows no chip", async () => {
+  shellStates = { sh_dev: {} };
+  const view = renderWithShells(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev")]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  expect(await findChip("1 shell, running in this session")).toBeOnTheScreen();
+  view.rerender(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev", { status: "exited" })]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  expect(screen.queryByTestId("subagent-monitor-chip")).toBeNull();
+});
+
+test("a foreground shell that still blocks its turn is not background work", async () => {
+  shellStates = { sh_blocking: {} };
+  const message = shellLaunch("sh_blocking", "pnpm test", { background: "moved" });
+  if (message.type !== "assistant" || message.content[0]?.type !== "tool") throw new Error("shape");
+  const tool = message.content[0];
+  const running = {
+    ...message,
+    time: { created: 1 },
+    content: [
+      {
+        ...tool,
+        state: { status: "running", input: tool.state.input, metadata: { shellID: "sh_blocking" } },
+      },
+    ],
+  } as SessionMessageInfo;
+  renderWithShells(<SessionBackgroundTasks messages={[running]} onOpenChild={jest.fn()} />);
+  await act(async () => undefined);
+  expect(getShell).not.toHaveBeenCalled();
+  expect(screen.queryByTestId("subagent-monitor-chip")).toBeNull();
+});
+
+test("a shell row opens its command, elapsed time and output tail, and Back returns", async () => {
+  shellStates = { sh_dev: {} };
+  shellOutput = { sh_dev: "\u001b[32mready\u001b[0m on :3000\r\n" };
+  renderWithShells(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev")]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  fireEvent.press(screen.getByRole("button", { name: "pnpm dev, Running" }));
+  expect(screen.getByRole("header", { name: "Shell" })).toBeOnTheScreen();
+  expect(screen.getByText("pnpm dev")).toBeOnTheScreen();
+  expect(await screen.findByText("ready on :3000")).toBeOnTheScreen();
+  expect(screen.getByText(/^Running/)).toBeOnTheScreen();
+  expect(screen.getByRole("button", { name: "Stop pnpm dev" })).toBeOnTheScreen();
+  fireEvent.press(screen.getByRole("button", { name: "Back to background work" }));
+  expect(screen.getByRole("header", { name: "Shells" })).toBeOnTheScreen();
+});
+
+test("an empty running shell says it has no output yet", async () => {
+  shellStates = { sh_dev: {} };
+  renderWithShells(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev")]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  fireEvent.press(screen.getByRole("button", { name: "pnpm dev, Running" }));
+  expect(await screen.findByText("No output yet")).toBeOnTheScreen();
+});
+
+test("Stop asks first, removes the shell, and then shows that it stopped", async () => {
+  shellStates = { sh_dev: {} };
+  const alert = jest
+    .spyOn(Alert, "alert")
+    .mockImplementation((_title, _message, buttons?: AlertButton[]) =>
+      buttons?.find((button) => button.text === "Stop shell")?.onPress?.(),
+    );
+  try {
+    renderWithShells(
+      <SessionBackgroundTasks
+        messages={[shellLaunch("sh_dev", "pnpm dev")]}
+        onOpenChild={jest.fn()}
+      />,
+    );
+    fireEvent.press(await findChip("1 shell, running in this session"));
+    fireEvent.press(screen.getByRole("button", { name: "pnpm dev, Running" }));
+    await act(async () => {
+      fireEvent.press(await screen.findByRole("button", { name: "Stop pnpm dev" }));
+    });
+    expect(alert).toHaveBeenCalledWith(
+      "Stop pnpm dev?",
+      "This ends the command on the server.",
+      expect.any(Array),
+    );
+    expect(removeShell).toHaveBeenCalledWith(expect.anything(), location, "sh_dev");
+    // The page stays open after the shell leaves the running list.
+    expect(await screen.findByText("Stopped")).toBeOnTheScreen();
+    expect(screen.queryByRole("button", { name: "Stop pnpm dev" })).toBeNull();
+    expect(screen.getByRole("header", { name: "Shell" })).toBeOnTheScreen();
+  } finally {
+    alert.mockRestore();
+  }
+});
+
+test.each([
+  [{ exit: 0, status: "exited" as const }, "Exited"],
+  [{ exit: 2, status: "exited" as const }, "Exited with code 2"],
+  [{ status: "timeout" as const }, "Timed out"],
+  [{ status: "killed" as const }, "Stopped"],
+])("a shell that ends while open shows how it ended (%o)", async (end, label) => {
+  shellStates = { sh_dev: {} };
+  const queryClient = testQueryClient();
+  renderWithoutQueries(
+    <QueryClientProvider client={queryClient}>
+      <SessionShellScope.Provider
+        value={{
+          client: {} as OpenCodeClient,
+          connectionId: "connection-1",
+          enabled: true,
+          location,
+        }}
+      >
+        <SessionBackgroundTasks
+          messages={[shellLaunch("sh_dev", "pnpm dev")]}
+          onOpenChild={jest.fn()}
+        />
+      </SessionShellScope.Provider>
+    </QueryClientProvider>,
+  );
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  fireEvent.press(screen.getByRole("button", { name: "pnpm dev, Running" }));
+  expect(await screen.findByRole("button", { name: "Stop pnpm dev" })).toBeOnTheScreen();
+  shellStates = { sh_dev: { ...end, time: { completed: 61_000, started: 1_000 } } };
+  await act(async () => {
+    await queryClient.invalidateQueries();
+  });
+  expect(await screen.findByText(label)).toBeOnTheScreen();
+  // The run time freezes at the server's completion time, beside the state, not inside it.
+  expect(screen.getByText(" · 1m", { includeHiddenElements: true })).toBeOnTheScreen();
+  expect(screen.queryByRole("button", { name: "Stop pnpm dev" })).toBeNull();
+  expect(screen.getByRole("header", { name: "Shell" })).toBeOnTheScreen();
+  // The chip reads its own status query, which settles on its own refresh.
+  await waitFor(() => expect(screen.queryByTestId("subagent-monitor-chip")).toBeNull());
+});
+
+test("a stale monitor keeps the shell page without Stop", async () => {
+  shellStates = { sh_dev: {} };
+  const messages = [shellLaunch("sh_dev", "pnpm dev")];
+  const view = renderWithShells(
+    <SessionBackgroundTasks messages={messages} onOpenChild={jest.fn()} />,
+  );
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  fireEvent.press(screen.getByRole("button", { name: "pnpm dev, Running" }));
+  expect(await screen.findByRole("button", { name: "Stop pnpm dev" })).toBeOnTheScreen();
+  view.rerender(<SessionBackgroundTasks messages={messages} onOpenChild={jest.fn()} stale />);
+  expect(screen.getByText("Status unavailable · showing last known")).toBeOnTheScreen();
+  expect(screen.queryByRole("button", { name: "Stop pnpm dev" })).toBeNull();
+});
+
+async function openShellPage(command = "pnpm dev") {
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  fireEvent.press(screen.getByRole("button", { name: `${command}, Running` }));
+  expect(await screen.findByRole("button", { name: `Stop ${command}` })).toBeOnTheScreen();
+}
+
+test("Android back on the shell page returns to the list instead of closing the sheet", async () => {
+  const platform = jest.replaceProperty(Platform, "OS", "android");
+  try {
+    shellStates = { sh_dev: {} };
+    renderWithShells(
+      <SessionBackgroundTasks
+        messages={[shellLaunch("sh_dev", "pnpm dev")]}
+        onOpenChild={jest.fn()}
+      />,
+    );
+    await openShellPage();
+    act(() => screen.UNSAFE_getByType(Modal).props.onRequestClose());
+    expect(screen.getByRole("header", { name: "Shells" })).toBeOnTheScreen();
+    act(() => screen.UNSAFE_getByType(Modal).props.onRequestClose());
+    expect(screen.UNSAFE_getByType(Modal).props.visible).toBe(false);
+  } finally {
+    platform.restore();
+  }
+});
+
+test("an iOS swipe on the shell page closes the sheet, so the chip can open it again", async () => {
+  shellStates = { sh_dev: {} };
+  renderWithShells(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev")]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  await openShellPage();
+  act(() => screen.UNSAFE_getByType(Modal).props.onRequestClose());
+  expect(screen.UNSAFE_getByType(Modal).props.visible).toBe(false);
+  fireEvent.press(screen.getByRole("button", { name: "1 shell, running in this session" }));
+  expect(screen.UNSAFE_getByType(Modal).props.visible).toBe(true);
+  expect(screen.getByRole("header", { name: "Shells" })).toBeOnTheScreen();
+});
+
+test("a failed output refresh shows the last known state without Stop", async () => {
+  shellStates = { sh_dev: {} };
+  const queryClient = testQueryClient();
+  renderWithoutQueries(
+    <QueryClientProvider client={queryClient}>
+      <SessionShellScope.Provider
+        value={{
+          client: {} as OpenCodeClient,
+          connectionId: "connection-1",
+          enabled: true,
+          location,
+        }}
+      >
+        <SessionBackgroundTasks
+          messages={[shellLaunch("sh_dev", "pnpm dev")]}
+          onOpenChild={jest.fn()}
+        />
+      </SessionShellScope.Provider>
+    </QueryClientProvider>,
+  );
+  await openShellPage();
+  getShell.mockRejectedValue(new Error("UNREACHABLE"));
+  await act(async () => {
+    await queryClient.refetchQueries({ type: "active" });
+  });
+  expect(await screen.findByText("Shell output could not be refreshed.")).toBeOnTheScreen();
+  expect(screen.getByText("Last known: Running")).toBeOnTheScreen();
+  expect(screen.queryByRole("button", { name: "Stop pnpm dev" })).toBeNull();
+});
+
+test("Back after the only shell ended returns to the list, which still says what runs", async () => {
+  shellStates = { sh_dev: {} };
+  const queryClient = testQueryClient();
+  renderWithoutQueries(
+    <QueryClientProvider client={queryClient}>
+      <SessionShellScope.Provider
+        value={{
+          client: {} as OpenCodeClient,
+          connectionId: "connection-1",
+          enabled: true,
+          location,
+        }}
+      >
+        <SessionBackgroundTasks
+          messages={[shellLaunch("sh_dev", "pnpm dev")]}
+          onOpenChild={jest.fn()}
+        />
+      </SessionShellScope.Provider>
+    </QueryClientProvider>,
+  );
+  await openShellPage();
+  shellStates = { sh_dev: { exit: 0, status: "exited" } };
+  await act(async () => {
+    await queryClient.invalidateQueries();
+  });
+  expect(await screen.findByText("Exited")).toBeOnTheScreen();
+  fireEvent.press(screen.getByRole("button", { name: "Back to background work" }));
+  // The empty state is the focus target once the row and the Shells header are gone.
+  expect(screen.getByText("Nothing is running in this session.")).toBeOnTheScreen();
+  expect(screen.queryByRole("header", { name: "Shells" })).toBeNull();
+});
+
+test("background subagent changes are announced from the chip", () => {
+  const announce = jest.spyOn(AccessibilityInfo, "announceForAccessibility");
+  announce.mockClear();
+  try {
+    const view = render(
+      <SessionBackgroundTasks
+        activeSessions={{ ses_tests: {} }}
+        messages={[launch("ses_tests", "Run tests")]}
+        onOpenChild={jest.fn()}
+        sessionID="ses_parent"
+      />,
+    );
+    expect(announce).not.toHaveBeenCalled();
+    view.rerender(
+      <SessionBackgroundTasks
+        activeSessions={{ ses_tests: {} }}
+        attention={new Map([["ses_tests", "permission" as const]])}
+        messages={[launch("ses_tests", "Run tests")]}
+        onOpenChild={jest.fn()}
+        sessionID="ses_parent"
+      />,
+    );
+    expect(announce).toHaveBeenCalledWith("Background subagent Run tests needs you");
+    announce.mockClear();
+    // Two changes in one update are read as one announcement, so neither cuts the other off.
+    view.rerender(
+      <SessionBackgroundTasks
+        activeSessions={{ ses_tests: {}, ses_lint: {} }}
+        messages={[launch("ses_tests", "Run tests"), launch("ses_lint", "Lint")]}
+        onOpenChild={jest.fn()}
+        sessionID="ses_parent"
+      />,
+    );
+    announce.mockClear();
+    view.rerender(
+      <SessionBackgroundTasks
+        activeSessions={{ ses_tests: {}, ses_lint: {} }}
+        attention={
+          new Map([
+            ["ses_tests", "permission" as const],
+            ["ses_lint", "input" as const],
+          ])
+        }
+        messages={[launch("ses_tests", "Run tests"), launch("ses_lint", "Lint")]}
+        onOpenChild={jest.fn()}
+        sessionID="ses_parent"
+      />,
+    );
+    expect(announce).toHaveBeenCalledTimes(1);
+    expect(announce).toHaveBeenCalledWith(
+      "Background subagent Lint needs you. Background subagent Run tests needs you",
+    );
+  } finally {
+    announce.mockRestore();
+  }
+});
+
+test("the live region holds the state words only, never the ticking time", async () => {
+  shellStates = { sh_dev: {} };
+  renderWithShells(
+    <SessionBackgroundTasks
+      messages={[shellLaunch("sh_dev", "pnpm dev")]}
+      onOpenChild={jest.fn()}
+    />,
+  );
+  await openShellPage();
+  const status = screen.getByText("Running");
+  expect(status.props.accessibilityLiveRegion).toBe("polite");
+  expect(status).toHaveTextContent("Running", { exact: true });
+});
+
+test("stopping a shell that already ended shows how it ended, not a failure", async () => {
+  shellStates = { sh_dev: {} };
+  removeShell.mockImplementation(async () => {
+    removed.add("sh_dev");
+    throw notFound;
+  });
+  const alert = jest
+    .spyOn(Alert, "alert")
+    .mockImplementation((_title, _message, buttons?: AlertButton[]) =>
+      buttons?.find((button) => button.text === "Stop shell")?.onPress?.(),
+    );
+  try {
+    renderWithShells(
+      <SessionBackgroundTasks
+        messages={[shellLaunch("sh_dev", "pnpm dev")]}
+        onOpenChild={jest.fn()}
+      />,
+    );
+    await openShellPage();
+    await act(async () => {
+      fireEvent.press(screen.getByRole("button", { name: "Stop pnpm dev" }));
+    });
+    expect(await screen.findByText("Stopped")).toBeOnTheScreen();
+    expect(screen.queryByText("The shell could not be stopped. Try again.")).toBeNull();
+  } finally {
+    alert.mockRestore();
+  }
+});
+
+test("a stale page keeps the last output and says the state is last known", async () => {
+  shellStates = { sh_dev: {} };
+  shellOutput = { sh_dev: "ready on :3000\n" };
+  const messages = [shellLaunch("sh_dev", "pnpm dev")];
+  const view = renderWithShells(
+    <SessionBackgroundTasks messages={messages} onOpenChild={jest.fn()} />,
+  );
+  await openShellPage();
+  expect(await screen.findByText("ready on :3000")).toBeOnTheScreen();
+  view.rerender(<SessionBackgroundTasks messages={messages} onOpenChild={jest.fn()} stale />);
+  expect(screen.getByText("Last known: Running")).toBeOnTheScreen();
+  expect(screen.getByText("ready on :3000")).toBeOnTheScreen();
+});
+
+test("long commands are read aloud as one short line", async () => {
+  const command = `pnpm exec node --eval "${"x".repeat(200)}"\necho done`;
+  shellStates = { sh_long: {} };
+  renderWithShells(
+    <SessionBackgroundTasks messages={[shellLaunch("sh_long", command)]} onOpenChild={jest.fn()} />,
+  );
+  fireEvent.press(await findChip("1 shell, running in this session"));
+  const row = screen.getByRole("button", { name: /, Running$/ });
+  expect(row.props.accessibilityLabel.length).toBeLessThan(140);
+  expect(row.props.accessibilityLabel).not.toContain("echo done");
+});
+
+test("a failed status refresh makes the chip say its status is unavailable, without motion", async () => {
+  shellStates = { sh_dev: {} };
+  const queryClient = testQueryClient();
+  renderWithoutQueries(
+    <QueryClientProvider client={queryClient}>
+      <SessionShellScope.Provider
+        value={{
+          client: {} as OpenCodeClient,
+          connectionId: "connection-1",
+          enabled: true,
+          location,
+        }}
+      >
+        <SessionBackgroundTasks
+          messages={[shellLaunch("sh_dev", "pnpm dev")]}
+          onOpenChild={jest.fn()}
+        />
+      </SessionShellScope.Provider>
+    </QueryClientProvider>,
+  );
+  await findChip("1 shell, running in this session");
+  getShell.mockRejectedValue(new Error("UNREACHABLE"));
+  await act(async () => {
+    await queryClient.refetchQueries({ type: "active" });
+  });
+  expect(
+    await screen.findByRole("button", { name: "1 shell, status unavailable" }),
+  ).toBeOnTheScreen();
+  // Sighted users see the uncertainty too: the count is dimmed.
+  expect(screen.getByText("1 shell")).toHaveStyle({ color: palette.dim });
+  fireEvent.press(screen.getByRole("button", { name: "1 shell, status unavailable" }));
+  expect(screen.getByRole("button", { name: "pnpm dev, Last known: Running" })).toBeOnTheScreen();
+});
diff --git a/apps/mobile/src/screens/session-background-tasks.tsx b/apps/mobile/src/screens/session-background-tasks.tsx
index 66befc3..2aefd3c 100644
--- a/apps/mobile/src/screens/session-background-tasks.tsx
+++ b/apps/mobile/src/screens/session-background-tasks.tsx
@@ -1,14 +1,26 @@
 import Feather from "@expo/vector-icons/Feather";
 import type { SessionMessageInfo } from "@opencode2-mobile/opencode-adapter";
-import { type RefObject, useRef, useState } from "react";
-import { Alert, Platform, Pressable, StyleSheet, Text, View } from "react-native";
+import { type RefObject, useEffect, useRef, useState } from "react";
+import {
+  AccessibilityInfo,
+  Alert,
+  Platform,
+  Pressable,
+  StyleSheet,
+  Text,
+  useWindowDimensions,
+  View,
+} from "react-native";
 
 import { Button } from "../components/button";
-import { ModalSheet } from "../components/modal-sheet";
+import { focusAccessibility, ModalSheet } from "../components/modal-sheet";
 import {
+  SubagentElapsed,
   SubagentMetaLine,
   SubagentStatusGlyph,
+  subagentOutcomeLabel,
   subagentStateLabel,
+  subagentStatusStyles,
 } from "../components/subagent-status";
 import { WorkingIndicator } from "../components/working-indicator";
 import {
@@ -21,7 +33,15 @@ import {
   space,
   typeRamp,
   typography,
+  usesLargeTextLayout,
 } from "../theme";
+import { BackgroundShellDetail } from "./session-background-shell-detail";
+import {
+  backgroundWorkSummary,
+  type ShellCandidate,
+  shortShellCommand,
+} from "./session-background-shells-model";
+import { useRunningShells, useStopShell } from "./session-shell-output";
 import {
   isSubagentInFlight,
   type SessionSubagent,
@@ -32,9 +52,9 @@ import {
 
 const chipHeight = 36;
 
-// The session's subagent monitor: a chip above the composer while any child is live, and a
-// sheet that lists every child this session launched, waiting first, then working, then
-// finished. Rows open the child; running rows can be stopped after a confirmation.
+// The session's background work: a chip above the composer while any child or shell is live, and a sheet that lists every child this session launched (waiting first, then
+// working, then finished) and its running shells. Child rows open the child; running children
+// can be stopped after a confirmation. Shell rows open the shell's output and Stop in place.
 export function SessionBackgroundTasks({
   activeSessions,
   attention,
@@ -58,18 +78,27 @@ export function SessionBackgroundTasks({
   const subagents = sessionSubagents(messages, activeSessions, sessionID, attention);
   const live = subagents.filter((subagent) => isSubagentInFlight(subagent.state));
   const waiting = live.filter((subagent) => subagent.state === "waiting").length;
-  if ((live.length === 0 || stale) && !visible) return null;
-  const count = `${live.length} ${live.length === 1 ? "subagent" : "subagents"}`;
+  const shells = useRunningShells(messages);
+  const stopShell = useStopShell();
+  useBackgroundSubagentAnnouncements(subagents, stale);
+  const running = live.length + shells.length;
+  // Shells whose status refresh failed are only last known: the chip says so and stays still
+  // when nothing it counts is confirmed live.
+  const uncertain = shells.some((shell) => shell.lastKnown);
+  const confirmedLive = live.length + shells.filter((shell) => !shell.lastKnown).length > 0;
+  if ((running === 0 || stale) && !visible) return null;
+  const count = backgroundWorkSummary(live.length, shells.length);
   const label =
     waiting > 0 ? `${count} · ${waiting} ${waiting === 1 ? "needs" : "need"} you` : count;
+  const chipVisible = running > 0 && !stale;
   return (
-    <View style={styles.container}>
-      {live.length > 0 && !stale ? (
+    <View style={chipVisible && styles.container}>
+      {chipVisible ? (
         <Pressable
           ref={triggerRef}
           accessibilityRole="button"
-          accessibilityLabel={`${label}, running in this session`}
-          accessibilityHint="Shows this session's subagents"
+          accessibilityLabel={`${label.replaceAll(" · ", ", ")}, ${uncertain ? "status unavailable" : "running in this session"}`}
+          accessibilityHint="Shows this session's background work"
           accessibilityState={{ expanded: visible }}
           hitSlop={(minTouchTarget - chipHeight) / 2}
           onPress={() => setVisible(true)}
@@ -83,9 +112,12 @@ export function SessionBackgroundTasks({
           {waiting > 0 ? (
             <View style={styles.waitingDot} testID="subagent-monitor-waiting" />
           ) : (
-            <WorkingIndicator />
+            <WorkingIndicator animated={confirmedLive} />
           )}
-          <Text dynamicTypeRamp={typeRamp.control} style={styles.label}>
+          <Text
+            dynamicTypeRamp={typeRamp.control}
+            style={[styles.label, uncertain && styles.labelUncertain]}
+          >
             {label}
           </Text>
         </Pressable>
@@ -97,7 +129,9 @@ export function SessionBackgroundTasks({
           onOpenChild(childSessionID);
         }}
         onStopChild={onStopChild}
+        onStopShell={stale ? undefined : stopShell}
         returnFocusRef={triggerRef}
+        shells={shells}
         stale={stale}
         subagents={subagents}
         visible={visible}
@@ -106,11 +140,37 @@ export function SessionBackgroundTasks({
   );
 }
 
+// Background launches fold into "Used N tools", so their cards are not mounted to announce a
+// change. The chip's component always runs, so it tells screen readers on both platforms when a
+// background subagent needs you, fails, or completes. Running states and stale data stay quiet.
+function useBackgroundSubagentAnnouncements(subagents: SessionSubagent[], stale: boolean) {
+  const previous = useRef<Map<string, SessionSubagent["state"]>>(undefined);
+  useEffect(() => {
+    const background = subagents.filter((subagent) => subagent.background);
+    const before = previous.current;
+    previous.current = new Map(background.map((subagent) => [subagent.key, subagent.state]));
+    if (!before || stale) return;
+    const messages: string[] = [];
+    for (const subagent of background) {
+      const was = before.get(subagent.key);
+      const outcome = subagentOutcomeLabel(subagent.state);
+      if (was === undefined || was === subagent.state || !outcome) continue;
+      messages.push(
+        `Background subagent ${sanitizeTranscriptText(subagent.title, 256)} ${outcome}`,
+      );
+    }
+    // One announcement per update: on iOS a second call cuts the first one off.
+    if (messages.length > 0) AccessibilityInfo.announceForAccessibility(messages.join(". "));
+  });
+}
+
 function SubagentMonitorSheet({
   onClose,
   onOpenChild,
   onStopChild,
+  onStopShell,
   returnFocusRef,
+  shells,
   stale,
   subagents,
   visible,
@@ -118,84 +178,215 @@ function SubagentMonitorSheet({
   onClose: () => void;
   onOpenChild: (sessionID: string) => void;
   onStopChild?: ((sessionID: string) => Promise<void>) | undefined;
+  onStopShell?: ((shellID: string) => Promise<void>) | undefined;
   returnFocusRef: RefObject<View | null>;
+  shells: ShellCandidate[];
   stale: boolean;
   subagents: SessionSubagent[];
   visible: boolean;
 }) {
   const [showFinished, setShowFinished] = useState(false);
+  // The open shell is kept here, not looked up in the running list, so a shell that ends while
+  // its page is open stays visible until Back or the sheet closes.
+  const [openShell, setOpenShell] = useState<ShellCandidate>();
+  // Back returns focus to the row that opened the page, or to the Shells header once it is gone.
+  const shellRows = useRef(new Map<string, View>());
+  const shellsHeader = useRef<Text>(null);
+  // The list's first heading, or its empty state: present whatever is left to show.
+  const listStart = useRef<Text | null>(null);
+  const back = () => {
+    const shellID = openShell?.shellID;
+    setOpenShell(undefined);
+    requestAnimationFrame(() =>
+      focusAccessibility(
+        (shellID ? shellRows.current.get(shellID) : undefined) ??
+          shellsHeader.current ??
+          listStart.current,
+      ),
+    );
+  };
   const sections = [
     { title: "Needs you", rows: subagents.filter((subagent) => subagent.state === "waiting") },
     {
-      title: "Working",
+      title: "Subagents",
       rows: subagents.filter(
         (subagent) => subagent.state === "running" || subagent.state === "streaming",
       ),
     },
   ];
   const finished = subagents.filter((subagent) => !isSubagentInFlight(subagent.state));
+  const firstSection = sections.find((section) => section.rows.length > 0);
+  const close = () => {
+    setOpenShell(undefined);
+    onClose();
+  };
   return (
     <ModalSheet
-      onClose={onClose}
+      onClose={close}
+      // Android back steps from the shell page to the list. An iOS swipe always dismisses the
+      // native sheet, so it must close, or the sheet state would stay open behind it.
+      onRequestClose={Platform.OS === "android" && openShell ? back : close}
+      scrollable={!openShell}
       returnFocusRef={returnFocusRef}
       subtitle={stale ? "Status unavailable · showing last known" : "In this session"}
-      title="Subagents"
+      title="Background work"
       visible={visible}
     >
-      {sections.map((section) =>
-        section.rows.length > 0 ? (
-          <View key={section.title} style={styles.section}>
-            <Text
-              accessibilityRole="header"
-              dynamicTypeRamp={typeRamp.sectionLabel}
-              style={styles.sectionTitle}
-            >
-              {section.title}
+      {openShell ? (
+        <BackgroundShellDetail onBack={back} onStop={onStopShell} shell={openShell} stale={stale} />
+      ) : (
+        <>
+          {sections.map((section) =>
+            section.rows.length > 0 ? (
+              <View key={section.title} style={styles.section}>
+                <Text
+                  ref={section === firstSection ? listStart : undefined}
+                  accessibilityRole="header"
+                  dynamicTypeRamp={typeRamp.sectionLabel}
+                  style={styles.sectionTitle}
+                >
+                  {section.title}
+                </Text>
+                <View style={styles.group}>
+                  {section.rows.map((subagent, index) => (
+                    <SubagentMonitorRow
+                      key={subagent.key}
+                      last={index === section.rows.length - 1}
+                      onOpen={onOpenChild}
+                      onStop={onStopChild}
+                      subagent={subagent}
+                    />
+                  ))}
+                </View>
+              </View>
+            ) : null,
+          )}
+          {shells.length > 0 ? (
+            <View style={styles.section}>
+              <Text
+                ref={shellsHeader}
+                accessibilityRole="header"
+                dynamicTypeRamp={typeRamp.sectionLabel}
+                style={styles.sectionTitle}
+              >
+                Shells
+              </Text>
+              <View style={styles.group}>
+                {shells.map((shell, index) => (
+                  <ShellMonitorRow
+                    key={shell.key}
+                    last={index === shells.length - 1}
+                    onOpen={setOpenShell}
+                    rowRef={(row) => {
+                      if (row) shellRows.current.set(shell.shellID, row);
+                      else shellRows.current.delete(shell.shellID);
+                    }}
+                    shell={shell}
+                    stale={stale || Boolean(shell.lastKnown)}
+                  />
+                ))}
+              </View>
+            </View>
+          ) : null}
+          {sections.every((section) => section.rows.length === 0) && shells.length === 0 ? (
+            <Text ref={listStart} dynamicTypeRamp={typeRamp.subheadline} style={styles.empty}>
+              Nothing is running in this session.
             </Text>
-            <View style={styles.group}>
-              {section.rows.map((subagent, index) => (
-                <SubagentMonitorRow
-                  key={subagent.key}
-                  last={index === section.rows.length - 1}
-                  onOpen={onOpenChild}
-                  onStop={onStopChild}
-                  subagent={subagent}
-                />
-              ))}
+          ) : null}
+          {finished.length > 0 ? (
+            <View style={styles.section}>
+              <Button
+                accessibilityLabel={`${showFinished ? "Hide" : "Show"} finished subagents`}
+                icon={showFinished ? "chevron-up" : "chevron-down"}
+                label={`${showFinished ? "Hide" : "Show"} finished subagents (${finished.length})`}
+                onPress={() => setShowFinished((current) => !current)}
+                size="compact"
+                variant="text"
+              />
+              {showFinished ? (
+                <View style={styles.group}>
+                  {finished.map((subagent, index) => (
+                    <SubagentMonitorRow
+                      key={subagent.key}
+                      last={index === finished.length - 1}
+                      onOpen={onOpenChild}
+                      subagent={subagent}
+                    />
+                  ))}
+                </View>
+              ) : null}
             </View>
-          </View>
-        ) : null,
+          ) : null}
+        </>
       )}
-      {sections.every((section) => section.rows.length === 0) ? (
-        <Text dynamicTypeRamp={typeRamp.subheadline} style={styles.empty}>
-          Nothing is running in this session.
-        </Text>
-      ) : null}
-      {finished.length > 0 ? (
-        <View style={styles.section}>
-          <Button
-            accessibilityLabel={`${showFinished ? "Hide" : "Show"} finished subagents`}
-            icon={showFinished ? "chevron-up" : "chevron-down"}
-            label={`${showFinished ? "Hide" : "Show"} finished (${finished.length})`}
-            onPress={() => setShowFinished((current) => !current)}
-            size="compact"
-            variant="text"
+    </ModalSheet>
+  );
+}
+
+function ShellMonitorRow({
+  last,
+  onOpen,
+  rowRef,
+  shell,
+  stale,
+}: {
+  last: boolean;
+  onOpen: (shell: ShellCandidate) => void;
+  rowRef: (row: View | null) => void;
+  shell: ShellCandidate;
+  stale: boolean;
+}) {
+  const largeText = usesLargeTextLayout(useWindowDimensions().fontScale);
+  const state = stale ? "Last known: Running" : "Running";
+  return (
+    <View style={[styles.row, !last && styles.separator]}>
+      <Pressable
+        ref={rowRef}
+        accessibilityHint="Shows the shell's output"
+        accessibilityLabel={`${shortShellCommand(shell.command)}, ${state}`}
+        accessibilityRole="button"
+        android_ripple={rippleFeedback.row}
+        onPress={() => onOpen(shell)}
+        style={({ pressed }) => [
+          styles.rowMain,
+          pressed && Platform.OS === "ios" && styles.pressed,
+        ]}
+      >
+        <View style={styles.shellGlyph}>
+          <Feather
+            accessible={false}
+            color={stale ? palette.dim : palette.info}
+            name="terminal"
+            size={16}
           />
-          {showFinished ? (
-            <View style={styles.group}>
-              {finished.map((subagent, index) => (
-                <SubagentMonitorRow
-                  key={subagent.key}
-                  last={index === finished.length - 1}
-                  onOpen={onOpenChild}
-                  subagent={subagent}
-                />
-              ))}
-            </View>
-          ) : null}
         </View>
-      ) : null}
-    </ModalSheet>
+        <View style={styles.copy}>
+          <Text
+            dynamicTypeRamp={typeRamp.body}
+            numberOfLines={largeText ? 4 : 2}
+            style={styles.command}
+          >
+            {shell.command}
+          </Text>
+          {/* The ticking time is a sibling of the state, never inside it. */}
+          <View style={subagentStatusStyles.metaRow}>
+            <Text
+              dynamicTypeRamp={typeRamp.footnote}
+              style={[styles.meta, !stale && styles.running]}
+            >
+              {state}
+            </Text>
+            <SubagentElapsed
+              frozen={stale}
+              startedAt={shell.startedAt}
+              state="running"
+              style={styles.meta}
+            />
+          </View>
+        </View>
+        <Feather accessible={false} color={palette.dim} name="chevron-right" size={18} />
+      </Pressable>
+    </View>
   );
 }
 
@@ -245,6 +436,8 @@ function SubagentMonitorRow({
           <SubagentMetaLine
             agent={agent}
             background={subagent.background}
+            // The monitor announces background changes once; its rows stay quiet.
+            live={!subagent.background}
             finishedAt={subagent.finishedAt}
             numberOfLines={2}
             startedAt={subagent.startedAt}
@@ -326,6 +519,7 @@ const styles = StyleSheet.create({
     paddingHorizontal: 14,
   },
   chipWaiting: { borderColor: palette.warm },
+  command: { ...typography.code, color: palette.ink },
   copy: { flex: 1, gap: 2, minWidth: 0 },
   empty: { ...typography.subheadline, color: palette.dim },
   error: { ...typography.footnote, color: palette.danger },
@@ -337,9 +531,13 @@ const styles = StyleSheet.create({
     overflow: "hidden",
   },
   label: { ...typography.control, color: palette.ink, flexShrink: 1 },
+  labelUncertain: { color: palette.dim },
+  meta: { ...typography.footnote, color: palette.dim },
   pressed: { opacity: pressedOpacity },
   row: { alignItems: "center", flexDirection: "row", paddingRight: space.sm },
   rowAction: { flexShrink: 0 },
+  // Running matches the subagent rows beside it.
+  running: { color: palette.info },
   rowMain: {
     alignItems: "flex-start",
     flex: 1,
@@ -351,6 +549,7 @@ const styles = StyleSheet.create({
   },
   section: { gap: space.xs },
   sectionTitle: { ...typography.sectionLabel, color: palette.dim, paddingHorizontal: space.md },
+  shellGlyph: { alignItems: "center", height: 20, justifyContent: "center", width: 16 },
   separator: { borderBottomColor: palette.border, borderBottomWidth: StyleSheet.hairlineWidth },
   title: { ...typography.body, color: palette.ink },
   waitingDot: {
diff --git a/apps/mobile/src/screens/session-shell-output-model.test.ts b/apps/mobile/src/screens/session-shell-output-model.test.ts
index 972f928..f9252d0 100644
--- a/apps/mobile/src/screens/session-shell-output-model.test.ts
+++ b/apps/mobile/src/screens/session-shell-output-model.test.ts
@@ -48,9 +48,11 @@ test("keeps output within the byte limit without splitting a character", () => {
   expect(boundShellOutput("øøøøa", false)).toEqual({ output: "øøøa", truncated: true });
 });
 
-test("a removed shell keeps observed output, or starts empty", () => {
+test("a removed shell keeps observed output and info, or starts empty", () => {
+  // The last info stays, so a stopped shell still shows how long it ran.
   expect(missingShellSnapshot(snapshot({ truncated: true }))).toEqual({
     cursor: 3,
+    info,
     output: "one",
     truncated: true,
     missing: true,
diff --git a/apps/mobile/src/screens/session-shell-output-model.ts b/apps/mobile/src/screens/session-shell-output-model.ts
index ef2e26a..e917b43 100644
--- a/apps/mobile/src/screens/session-shell-output-model.ts
+++ b/apps/mobile/src/screens/session-shell-output-model.ts
@@ -25,12 +25,14 @@ export function boundShellOutput(output: string, truncated: boolean) {
   return { output: new TextDecoder().decode(bytes.slice(start)), truncated: true };
 }
 
+// Keeps the last known info, so a stopped shell still shows how long it ran.
 export function missingShellSnapshot(previous: ShellSnapshot | undefined): ShellSnapshot {
   return {
     cursor: previous?.cursor ?? 0,
     output: previous?.output ?? "",
     truncated: previous?.truncated ?? false,
     missing: true,
+    ...(previous?.info ? { info: previous.info } : {}),
   };
 }
 
diff --git a/apps/mobile/src/screens/session-shell-output.tsx b/apps/mobile/src/screens/session-shell-output.tsx
index 7fd14ac..609b1ae 100644
--- a/apps/mobile/src/screens/session-shell-output.tsx
+++ b/apps/mobile/src/screens/session-shell-output.tsx
@@ -5,11 +5,15 @@ import {
   type LocationRef,
   maxShellOutputBytes,
   type OpenCodeClient,
+  removeOpenCodeShell,
+  type SessionMessageInfo,
+  type ShellGetOutput,
 } from "@opencode2-mobile/opencode-adapter";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { createContext, type ReactNode, useContext } from "react";
+import { useQueries, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createContext, type ReactNode, useCallback, useContext, useMemo } from "react";
 
 import { openCodeQueryKeys } from "../state/open-code-query-keys";
+import { type ShellCandidate, shellCandidates } from "./session-background-shells-model";
 import {
   boundShellOutput,
   missingShellSnapshot,
@@ -18,7 +22,7 @@ import {
   shellRefetchInterval,
 } from "./session-shell-output-model";
 
-type ShellScope = {
+export type ShellScope = {
   client: OpenCodeClient | undefined;
   connectionId: string;
   enabled: boolean;
@@ -85,7 +89,9 @@ function ObservedShell({
       return fetchShellSnapshot(scope.client, scope.location, shellID, previous, signal);
     },
   });
-  const snapshot = scope.enabled ? query.data : undefined;
+  // Keys carry the connection and location, so last-known output never crosses servers; it stays
+  // on screen while the connection is stale instead of falling back to "Loading".
+  const snapshot = query.data;
   return children({
     snapshot,
     error: query.isError,
@@ -138,3 +144,95 @@ async function readShellOutput(
   }
   return { cursor: page.cursor, output, truncated };
 }
+
+export type ShellStatus = { info?: ShellGetOutput["data"]; missing: boolean };
+// The last loaded status, and whether the newest refresh of it failed.
+type ShellStatusResult = ShellStatus & { refreshFailed: boolean };
+
+function isSettledShellStatus(status: ShellStatus | undefined) {
+  return Boolean(status && (status.missing || status.info?.status !== "running"));
+}
+
+// Events invalidate shell queries when a shell exits; the slow poll only covers missed events.
+const shellStatusPollMs = 10_000;
+
+// Server status for each shell the transcript says may run in the background, keyed by ID.
+// Unknown until loaded, so a shell that already ended never flashes as running.
+export function useShellStatuses(shellIDs: readonly string[]) {
+  const scope = useContext(SessionShellScope);
+  const results = useQueries({
+    queries: shellIDs.map((shellID) => ({
+      queryKey: scope
+        ? openCodeQueryKeys.shellStatus(scope.connectionId, scope.location, shellID)
+        : ["shell-status-unscoped", shellID],
+      enabled: Boolean(scope?.enabled && scope.client),
+      gcTime: 60_000,
+      retry: 1,
+      // An ended or removed shell never runs again, so shell events and focus do not refetch it.
+      staleTime: (query: { state: { data?: ShellStatus | undefined } }) =>
+        isSettledShellStatus(query.state.data) ? Number.POSITIVE_INFINITY : 0,
+      refetchInterval: (query: { state: { data?: ShellStatus | undefined } }) =>
+        isSettledShellStatus(query.state.data) ? false : shellStatusPollMs,
+      queryFn: async ({ signal }: { signal: AbortSignal }): Promise<ShellStatus> => {
+        if (!scope?.client || !scope.enabled) throw new Error("CONNECTION_NOT_READY");
+        try {
+          const { data } = await getOpenCodeShell(scope.client, scope.location, shellID, {
+            signal,
+          });
+          return { info: data, missing: false };
+        } catch (error) {
+          if (isShellNotFoundError(error)) return { missing: true };
+          throw error;
+        }
+      },
+    })),
+  });
+  // Keys carry the connection and location, so last-known data never crosses servers.
+  const statuses = new Map<string, ShellStatusResult>();
+  shellIDs.forEach((shellID, index) => {
+    const result = results[index];
+    if (result?.data) statuses.set(shellID, { ...result.data, refreshFailed: result.isError });
+  });
+  return statuses;
+}
+
+// Removing a shell stops it. Its queries then refetch, so every view reads how it ended.
+export function useStopShell() {
+  const scope = useContext(SessionShellScope);
+  const queryClient = useQueryClient();
+  const available = Boolean(scope?.enabled && scope.client);
+  const stop = useCallback(
+    async (shellID: string) => {
+      if (!scope?.client || !scope.enabled) throw new Error("CONNECTION_NOT_READY");
+      try {
+        await removeOpenCodeShell(scope.client, scope.location, shellID);
+      } catch (error) {
+        // It ended between the last poll and the stop; refreshing shows how.
+        if (!isShellNotFoundError(error)) throw error;
+      }
+      await queryClient.invalidateQueries({
+        queryKey: openCodeQueryKeys.shell(scope.connectionId, scope.location, shellID),
+      });
+    },
+    [queryClient, scope],
+  );
+  return available ? stop : undefined;
+}
+
+// Background shells the server still reports as running, with the server's start time.
+export function useRunningShells(messages: SessionMessageInfo[]) {
+  const candidates = useMemo(() => shellCandidates(messages), [messages]);
+  const statuses = useShellStatuses(candidates.map((candidate) => candidate.shellID));
+  return candidates.flatMap((candidate): ShellCandidate[] => {
+    const status = statuses.get(candidate.shellID);
+    const info = status?.info;
+    if (info?.status !== "running") return [];
+    return [
+      {
+        ...candidate,
+        ...(status?.refreshFailed ? { lastKnown: true } : {}),
+        startedAt: info.time.started,
+      },
+    ];
+  });
+}
diff --git a/apps/mobile/src/screens/session-transcript.test.tsx b/apps/mobile/src/screens/session-transcript.test.tsx
index a60c42a..64ed176 100644
--- a/apps/mobile/src/screens/session-transcript.test.tsx
+++ b/apps/mobile/src/screens/session-transcript.test.tsx
@@ -1,6 +1,6 @@
 import { afterEach, expect, jest, test } from "@jest/globals";
 import type { SessionMessageInfo } from "@opencode2-mobile/opencode-adapter";
-import { act, fireEvent, render, screen, waitFor } from "@testing-library/react-native";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react-native";
 import * as Clipboard from "expo-clipboard";
 import { AccessibilityInfo, Alert, Linking, Platform, StyleSheet, View } from "react-native";
 
@@ -21,8 +21,7 @@ import { subagentStates } from "./session-transcript-model";
 
 afterEach(resetTranscriptPerformanceMetrics);
 
-test("tool progress holds Running through brief completion gaps", () => {
-  jest.useFakeTimers();
+test("the tool group reads Used N tools, with no status or chevron", () => {
   const item = {
     type: "activity-group" as const,
     id: "activity:test",
@@ -37,21 +36,15 @@ test("tool progress holds Running through brief completion gaps", () => {
     onOpenSubagent: jest.fn(),
   };
   const view = render(<TranscriptActivityGroup {...props} item={item} />);
-  try {
-    expect(screen.getByText("Running")).toBeOnTheScreen();
-    view.rerender(<TranscriptActivityGroup {...props} item={{ ...item, running: false }} />);
-    act(() => jest.advanceTimersByTime(500));
-    expect(screen.queryByText("Finished")).toBeNull();
-    view.rerender(<TranscriptActivityGroup {...props} item={item} />);
-    act(() => jest.advanceTimersByTime(1000));
-    expect(screen.queryByText("Finished")).toBeNull();
-    view.rerender(<TranscriptActivityGroup {...props} item={{ ...item, running: false }} />);
-    act(() => jest.advanceTimersByTime(1000));
-    expect(screen.getByText("Finished")).toBeOnTheScreen();
-  } finally {
-    view.unmount();
-    jest.useRealTimers();
-  }
+  // The Working line says the turn runs; the group itself stays quiet, as in OpenCode iOS.
+  expect(screen.getByRole("button", { name: "Used 1 tool" })).toBeOnTheScreen();
+  expect(screen.getByText("Used 1 tool")).toHaveStyle({ color: palette.dim });
+  expect(screen.queryByText("Running")).toBeNull();
+  view.rerender(
+    <TranscriptActivityGroup {...props} item={{ ...item, count: 3, running: false }} />,
+  );
+  expect(screen.getByRole("button", { name: "Used 3 tools" })).toBeOnTheScreen();
+  expect(screen.queryByText("Finished")).toBeNull();
 });
 
 test("empty assistant snapshots do not flash placeholder rows between tool updates", () => {
@@ -214,7 +207,7 @@ test("nested activity reveals individual calls before their output", () => {
     />,
   );
   expect(screen.queryByText(output)).toBeNull();
-  fireEvent.press(screen.getByRole("button", { name: "1 tool calls" }));
+  fireEvent.press(screen.getByRole("button", { name: "Used 1 tool" }));
   expect(screen.queryByText(output)).toBeNull();
   fireEvent.press(screen.getByRole("button", { name: /Shell.*Show/ }));
   expect(screen.getByText(output)).toBeOnTheScreen();
@@ -285,8 +278,11 @@ test("collapsed failures distinguish interruptions without exposing server error
     />,
   );
   expect(screen.getByText("1 failed · 1 interrupted. Expand for details.")).toBeOnTheScreen();
-  expect(screen.getByText("2 Shell · 2 failed")).toHaveStyle(typography.chatActivity);
-  expect(screen.getByText("Failed")).toBeOnTheScreen();
+  // The failures are part of the button's name, not only its hint.
+  expect(
+    screen.getByRole("button", { name: "Used 2 tools, 1 failed, 1 interrupted" }),
+  ).toBeOnTheScreen();
+  expect(screen.getByText("Used 2 tools")).toHaveStyle(typography.chatActivity);
   expect(screen.queryByText(/private\/path|secret failure detail/)).toBeNull();
 });
 
@@ -1404,10 +1400,13 @@ test("background subagent launches stay running until the child reports a result
   expect(screen.getByText("Running")).toBeOnTheScreen();
 
   const announce = jest.spyOn(AccessibilityInfo, "announceForAccessibility");
+  announce.mockClear();
   view.rerender(row([notification, launch]));
   expect(screen.getByText("Completed")).toBeOnTheScreen();
   expect(screen.getByTestId("subagent-card")).toHaveStyle({ borderColor: palette.border });
-  expect(announce).toHaveBeenCalledWith("Background subagent Restyle Sessions list completed");
+  // The background-work chip owns this announcement; the card stays quiet so it is read once.
+  expect(announce).not.toHaveBeenCalled();
+  expect(screen.getByText(/@general · Background/).props.accessibilityLiveRegion).toBe("none");
   announce.mockRestore();
 
   // Leaving the active list with no reported outcome is announced neutrally, never as success.
@@ -1417,14 +1416,8 @@ test("background subagent launches stay running until the child reports a result
     </SessionSubagentStates.Provider>
   );
   view.rerender(inferred({ ses_child: {} }));
-  const neutral = jest.spyOn(AccessibilityInfo, "announceForAccessibility");
   view.rerender(inferred({}));
   expect(screen.getByText("Finished")).toBeOnTheScreen();
-  expect(neutral).toHaveBeenCalledWith(
-    "Background subagent Restyle Sessions list finished, outcome unknown",
-  );
-  expect(neutral).not.toHaveBeenCalledWith(expect.stringMatching(/completed$/));
-  neutral.mockRestore();
 });
 
 test("projects injected background results into subagent cards", () => {
@@ -1960,3 +1953,36 @@ test.each(["ios", "android"] as const)("subagent cards give press feedback on %s
     platform.restore();
   }
 });
+
+test("background subagent launches fold into the tool group; blocking ones keep a card", () => {
+  const launch = (background: boolean): SessionMessageInfo =>
+    ({
+      id: `msg_${background ? "background" : "blocking"}`,
+      type: "assistant",
+      agent: "build",
+      model: { id: "model", providerID: "provider" },
+      time: { created: 1, completed: 2 },
+      content: [
+        {
+          id: `tool_${background}`,
+          name: "subagent",
+          type: "tool",
+          time: { created: 1 },
+          state: {
+            status: background ? "completed" : "running",
+            input: { background, description: "Review", subagent_type: "review" },
+            metadata: { sessionID: "ses_child" },
+            ...(background
+              ? { content: [{ type: "text", text: "Working in the background." }] }
+              : {}),
+          },
+        },
+      ],
+    }) as SessionMessageInfo;
+  expect(groupTranscriptMessages([launch(true)], false, true)).toEqual([
+    expect.objectContaining({ type: "activity-group", count: 1 }),
+  ]);
+  expect(groupTranscriptMessages([launch(false)], false, true)).toEqual([
+    expect.objectContaining({ id: "msg_blocking", type: "assistant" }),
+  ]);
+});
diff --git a/apps/mobile/src/screens/session-transcript.tsx b/apps/mobile/src/screens/session-transcript.tsx
index 34684fa..f0e9b99 100644
--- a/apps/mobile/src/screens/session-transcript.tsx
+++ b/apps/mobile/src/screens/session-transcript.tsx
@@ -22,10 +22,10 @@ import { SelectableTranscriptText } from "../components/selectable-transcript-te
 import {
   SubagentMetaLine,
   SubagentStatusGlyph,
+  subagentOutcomeLabel,
   subagentStateLabel,
 } from "../components/subagent-status";
 import { announceOnIOS, useAnnouncement } from "../components/use-announcement";
-import { useDelayedVisibility } from "../components/use-delayed-visibility";
 import { recordTranscriptRowCommit } from "../state/transcript-performance";
 import {
   markdownPalette,
@@ -39,6 +39,7 @@ import {
   typography,
 } from "../theme";
 import type { PendingPromptPreview } from "./prompt-admission-model";
+import { shellToolNames, shortShellCommand } from "./session-background-shells-model";
 import { ShellObservation } from "./session-shell-output";
 import {
   getSubagentPresentation,
@@ -210,15 +211,21 @@ function splitAssistantProse(message: SessionMessageInfo): SessionMessageInfo[]
   }));
 }
 
+// Background subagent launches fold into the tool group like any call, as in the OpenCode iOS
+// app: the composer chip and its sheet carry their live state. A subagent that blocks the turn
+// keeps its own card.
 function isActivityMessage(message: SessionMessageInfo): message is AssistantMessage {
   return (
     message.type === "assistant" &&
     !message.error &&
     !message.retry &&
     message.content.length > 0 &&
-    message.content.every((part) =>
-      part.type === "reasoning" ? true : part.type === "tool" && !getSubagentPresentation(part),
-    )
+    message.content.every((part) => {
+      if (part.type === "reasoning") return true;
+      if (part.type !== "tool") return false;
+      const subagent = getSubagentPresentation(part);
+      return !subagent || subagent.background;
+    })
   );
 }
 
@@ -337,6 +344,19 @@ export function activitySummary(messages: SessionMessageInfo[]) {
   return `Used ${total} ${[...counts.keys()].join(", ")}${failures ? ` · ${failures} failed` : ""}`;
 }
 
+// "3 Shell, Read": what the group used, without the failure count the label already carries.
+function activityToolNames(messages: SessionMessageInfo[]) {
+  const counts = new Map<string, number>();
+  for (const message of messages) {
+    if (message.type !== "assistant") continue;
+    for (const part of message.content) {
+      if (part.type === "tool")
+        counts.set(capitalize(part.name), (counts.get(capitalize(part.name)) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].map(([name, count]) => `${count} ${name}`).join(", ");
+}
+
 export function activityFailureSummary(messages: SessionMessageInfo[]) {
   let failed = 0;
   let interrupted = 0;
@@ -374,65 +394,41 @@ export function TranscriptActivityGroup({
 }) {
   const [expanded, setExpanded] = useState(false);
   const failureSummary = activityFailureSummary(item.messages);
-  const hasRun = useRef(item.running);
-  if (item.running) hasRun.current = true;
-  const settled = useDelayedVisibility(hasRun.current && !item.running, item.id);
-  const running = item.running || (hasRun.current && !settled && !failureSummary);
-  const progressLabel = waitingFor
-    ? `Waiting for ${waitingFor}`
-    : item.running
-      ? "Running"
-      : failureSummary
-        ? /failed/.test(failureSummary)
-          ? "Failed"
-          : "Interrupted"
-        : running
-          ? "Running"
-          : "Finished";
+  // A quiet "Used 3 tools", as in the OpenCode iOS app. The Working line already says the turn
+  // runs; failures keep their caption, inside the button so it is part of what to tap.
+  const summary = `Used ${item.count} ${item.count === 1 ? "tool" : "tools"}`;
+  const running = item.running ? (waitingFor ? `Waiting for ${waitingFor}. ` : "Running. ") : "";
   return (
     <View style={styles.activityGroup}>
       <Pressable
         accessibilityRole="button"
-        accessibilityLabel={`${item.count} tool calls`}
-        accessibilityHint={`${item.running ? (waitingFor ? `Waiting for ${waitingFor}. ` : "Running. ") : ""}${activitySummary(item.messages)}. ${failureSummary ? `${failureSummary}. ` : ""}Expand or collapse execution details.`}
+        accessibilityLabel={
+          failureSummary ? `${summary}, ${failureSummary.replaceAll(" · ", ", ")}` : summary
+        }
+        accessibilityHint={`${running}${activityToolNames(item.messages)}. ${expanded ? "Hides" : "Shows"} tool details.`}
         accessibilityState={{ expanded }}
         android_ripple={rippleFeedback.row}
         onPress={() => setExpanded((value) => !value)}
         style={({ pressed }) => [
           styles.activityGroupHeader,
-          largeText && styles.activityGroupHeaderLargeText,
           pressed && Platform.OS === "ios" && styles.pressed,
         ]}
       >
-        <Text
-          dynamicTypeRamp={typeRamp.body}
-          style={[styles.activitySummary, largeText && styles.activitySummaryLargeText]}
-        >
-          Used <Text style={styles.activityLabel}>{activitySummary(item.messages).slice(5)}</Text>
-        </Text>
-        <Text
-          dynamicTypeRamp={typeRamp.body}
-          style={[
-            styles.toolProgress,
-            failureSummary &&
-              (progressLabel === "Failed" ? styles.toolProgressFailed : styles.toolProgressStopped),
-          ]}
-        >
-          {progressLabel}
+        <Text dynamicTypeRamp={typeRamp.body} style={styles.activitySummary}>
+          {summary}
         </Text>
-        <DisclosureChevron expanded={expanded} />
+        {failureSummary && !expanded ? (
+          <Text
+            dynamicTypeRamp={typeRamp.caption}
+            style={[
+              styles.activityFailureSummary,
+              !/failed/.test(failureSummary) && styles.activityStoppedSummary,
+            ]}
+          >
+            {failureSummary}. Expand for details.
+          </Text>
+        ) : null}
       </Pressable>
-      {failureSummary && !expanded ? (
-        <Text
-          dynamicTypeRamp={typeRamp.caption}
-          style={[
-            styles.activityFailureSummary,
-            progressLabel !== "Failed" && styles.activityStoppedSummary,
-          ]}
-        >
-          {failureSummary}. Expand for details.
-        </Text>
-      ) : null}
       <TranscriptImages images={messageToolImages(item.messages)} />
       {expanded
         ? item.messages.map((message) => (
@@ -1008,6 +1004,8 @@ function ToolCallDisclosure({
     toolCallPresentation(tool, nested);
   const visibleContent = content.slice(0, maxToolOutputs);
   const showOutcome = !nested || expanded;
+  const shellCommandPreview =
+    category === "shell" && !expanded && !(nested && error) ? presentation.command : undefined;
   return (
     <View
       style={[
@@ -1018,7 +1016,16 @@ function ToolCallDisclosure({
     >
       <ActivityHeader
         canExpand={canExpand}
-        detail={expanded ? toolStatusLabel(tool) : nested && error ? error : presentation.detail}
+        command={shellCommandPreview}
+        detail={
+          expanded
+            ? toolStatusLabel(tool)
+            : nested && error
+              ? error
+              : shellCommandPreview
+                ? toolStatusLabel(tool)
+                : presentation.detail
+        }
         error={Boolean(error)}
         expanded={expanded}
         label={label}
@@ -1174,7 +1181,9 @@ function ToolShellObservation({
           ) : null}
           <ShellOutput
             command={firstInputString(input, ["command", "cmd"], maxSanitizedInput)}
-            follow={observation?.snapshot?.info?.status === "running"}
+            follow={
+              observation?.snapshot?.info?.status === "running" && !observation.snapshot.missing
+            }
             text={
               observation
                 ? (observation.snapshot?.output ?? "")
@@ -1251,6 +1260,7 @@ function DiffAction({ onPress }: { onPress: () => void }) {
 
 function ActivityHeader({
   canExpand,
+  command,
   error = false,
   detail,
   expanded,
@@ -1259,6 +1269,9 @@ function ActivityHeader({
   onPress,
 }: {
   canExpand: boolean;
+  // A shell command, set on one line in monospace like the OpenCode iOS app; detail follows it
+  // in the regular face.
+  command?: string | undefined;
   error?: boolean;
   detail?: string | undefined;
   expanded: boolean;
@@ -1269,7 +1282,7 @@ function ActivityHeader({
   return (
     <Pressable
       accessibilityRole={canExpand ? "button" : undefined}
-      accessibilityLabel={`${label}${detail ? ` ${detail}` : ""}${canExpand ? (expanded ? " Hide" : " Show") : ""}`}
+      accessibilityLabel={`${label}${command ? ` ${shortShellCommand(sanitizeTranscriptText(command, 512))}` : ""}${detail ? `${command ? "," : ""} ${detail}` : ""}${canExpand ? (expanded ? " Hide" : " Show") : ""}`}
       accessibilityState={canExpand ? { expanded } : undefined}
       disabled={!canExpand}
       onPress={onPress}
@@ -1283,13 +1296,18 @@ function ActivityHeader({
         <Text dynamicTypeRamp={typeRamp.body} style={styles.activityLabel}>
           {sanitizeTranscriptText(label, 128)}
         </Text>
-        {detail ? (
+        {command || detail ? (
           <Text
             dynamicTypeRamp={typeRamp.body}
             numberOfLines={largeText ? undefined : 1}
             style={[styles.activityDetail, error && { color: palette.danger }]}
           >
-            {sanitizeTranscriptText(detail, 512)}
+            {command ? (
+              <Text style={styles.activityDetailCode}>
+                {sanitizeTranscriptText(command, 512).replace(/\s+/g, " ").trim()}
+              </Text>
+            ) : null}
+            {detail ? `${command ? " · " : ""}${sanitizeTranscriptText(detail, 512)}` : null}
           </Text>
         ) : null}
       </View>
@@ -1459,7 +1477,9 @@ function SubagentCard({
   const kind = presentation.background ? "Background subagent" : "Subagent";
   const title = sanitizeTranscriptText(presentation.title, 256);
   const agent = presentation.agent ? `@${sanitizeTranscriptText(presentation.agent, 128)}` : "";
-  useSubagentTransitionAnnouncement(kind, state, title);
+  // The background-work chip owns announcements for background children, so an expanded card
+  // never repeats one; a blocking child's card announces its own.
+  useSubagentTransitionAnnouncement(kind, state, title, !presentation.background);
   return (
     <View
       style={[styles.subagent, state === "waiting" && styles.subagentWaiting]}
@@ -1488,6 +1508,7 @@ function SubagentCard({
             {title}
           </Text>
           <SubagentMetaLine
+            live={!presentation.background}
             agent={agent}
             background={presentation.background}
             finishedAt={presentation.finishedAt}
@@ -1538,26 +1559,17 @@ function useSubagentTransitionAnnouncement(
   kind: string,
   state: SubagentPresentation["state"],
   title: string,
+  enabled: boolean,
 ) {
   const previousState = useRef(state);
   useEffect(() => {
     const previous = previousState.current;
     previousState.current = state;
     // Announce the transition only; finished cards in the history stay quiet.
-    if (previous === state || state === "running" || state === "streaming") return;
-    const outcome =
-      state === "waiting"
-        ? "needs you"
-        : state === "error"
-          ? "failed"
-          : state === "interrupted"
-            ? "was interrupted"
-            : state === "finished"
-              ? // The child stopped without reporting how, so never claim success.
-                "finished, outcome unknown"
-              : "completed";
+    const outcome = subagentOutcomeLabel(state);
+    if (!enabled || previous === state || !outcome) return;
     announceOnIOS(`${kind} ${title} ${outcome}`);
-  }, [kind, state, title]);
+  }, [enabled, kind, state, title]);
 }
 
 // One disclosure marker for every expandable transcript row.
@@ -1869,7 +1881,6 @@ const patchToolNames = new Set([
   "patch",
   "write",
 ]);
-const shellToolNames = new Set(["bash", "command", "exec", "shell", "terminal"]);
 const skillToolNames = new Set(["skill", "use_skill"]);
 
 function toolCategory(tool: AssistantTool): ToolCategory {
@@ -2108,16 +2119,11 @@ function keyDisclosureText(entries: string[]) {
 }
 
 const styles = StyleSheet.create({
-  toolProgress: { ...typography.chatActivity, color: palette.dim, flexShrink: 0 },
   // Failed is an error; Interrupted is a stop the user may have asked for.
-  toolProgressFailed: { color: palette.danger },
-  toolProgressStopped: { color: palette.warm },
   activityStoppedSummary: { color: palette.warm },
   activityFailureSummary: {
     ...typography.caption,
     color: palette.danger,
-    paddingHorizontal: space.sm,
-    paddingBottom: space.sm,
   },
   shellOutputBox: {
     backgroundColor: palette.raised,
@@ -2159,17 +2165,14 @@ const styles = StyleSheet.create({
     padding: 12,
   },
   activityGroupHeader: {
-    alignItems: "center",
-    flexDirection: "row",
-    flexWrap: "nowrap",
-    gap: space.sm,
-    justifyContent: "flex-start",
+    alignItems: "flex-start",
+    flexDirection: "column",
+    gap: 2,
+    justifyContent: "center",
     minHeight: minTouchTarget,
     paddingHorizontal: 0,
     paddingVertical: space.sm,
   },
-  activityGroupHeaderLargeText: { flexWrap: "wrap" },
-  activitySummaryLargeText: { flexBasis: "100%" },
   activity: {
     paddingHorizontal: 0,
   },
@@ -2198,6 +2201,11 @@ const styles = StyleSheet.create({
   },
   activityCopyLargeText: { alignItems: "flex-start", flexDirection: "column", gap: 2 },
   activityDetail: { ...typography.chatActivity, color: palette.dim, flexShrink: 1 },
+  activityDetailCode: {
+    fontFamily: typography.code.fontFamily,
+    fontSize: typography.subheadline.fontSize,
+    lineHeight: typography.chatActivity.lineHeight,
+  },
   activityFile: {
     ...typography.code,
     borderTopColor: palette.border,
diff --git a/apps/mobile/src/screens/workspace-screen.integration.test.tsx b/apps/mobile/src/screens/workspace-screen.integration.test.tsx
index 3a4b822..872066e 100644
--- a/apps/mobile/src/screens/workspace-screen.integration.test.tsx
+++ b/apps/mobile/src/screens/workspace-screen.integration.test.tsx
@@ -1896,11 +1896,11 @@ test("compact mode groups consecutive tool calls across assistant messages", asy
       />
     </QueryClientProvider>,
   );
-  const group = await screen.findByRole("button", { name: "3 tool calls" });
+  const group = await screen.findByRole("button", { name: "Used 3 tools" });
   expect(screen.queryByText("Result 0")).toBeNull();
   expect(screen.getByLabelText("Session transcript").props.data).toHaveLength(1);
   fireEvent.press(group);
-  expect(screen.getByRole("button", { name: "3 tool calls" }).props.accessibilityState).toEqual({
+  expect(screen.getByRole("button", { name: "Used 3 tools" }).props.accessibilityState).toEqual({
     expanded: true,
   });
   view.unmount();
@@ -2007,7 +2007,7 @@ test.each([180, 900])(
       </QueryClientProvider>,
     );
     try {
-      await screen.findByRole("button", { name: "40 tool calls" });
+      await screen.findByRole("button", { name: "Used 40 tools" });
       fireEvent(screen.getByLabelText("Session transcript"), "layout", {
         nativeEvent: { layout: { width: 360, height: 700, x: 0, y: 0 } },
       });
@@ -2319,7 +2319,7 @@ test("waits for and adopts a moved session's authoritative location", async () =
       ),
     ).toBeDefined();
 
-    fireEvent.press(await screen.findByRole("button", { name: "1 tool calls" }));
+    fireEvent.press(await screen.findByRole("button", { name: "Used 1 tool" }));
     fireEvent.press(screen.getByRole("button", { name: /Patch.*Show/ }));
     fireEvent.press(await screen.findByRole("button", { name: "Review current changes" }));
     expect(push).toHaveBeenCalledWith("Diff", {
@@ -2387,7 +2387,11 @@ test("expanded background shell follows command output after the session is idle
     </QueryClientProvider>,
   );
   try {
-    fireEvent.press(await screen.findByRole("button", { name: "1 tool calls" }));
+    // The shell outlived its call, so the composer chip counts it as background work.
+    expect(
+      await screen.findByRole("button", { name: "1 shell, running in this session" }),
+    ).toBeOnTheScreen();
+    fireEvent.press(await screen.findByRole("button", { name: "Used 1 tool" }));
     fireEvent.press(screen.getByRole("button", { name: /Shell.*Show/ }));
     expect(await screen.findByText("Build progress 50%")).toBeOnTheScreen();
     expect(screen.queryByText(/Command moved to the background/)).toBeNull();
@@ -2491,6 +2495,8 @@ test("shows running background subagents and opens their child sessions", async
     </QueryClientProvider>,
   );
 
+  // A background launch folds into the tool group; the composer chip carries its live state.
+  fireEvent.press(await screen.findByRole("button", { name: "Used 1 tool" }));
   expect(await screen.findByText("Inspect event handling")).toBeOnTheScreen();
   fireEvent.press(
     screen.getByRole("button", { name: /^Background subagent, Inspect event handling/ }),
diff --git a/apps/mobile/src/screens/workspace-screen.tsx b/apps/mobile/src/screens/workspace-screen.tsx
index 4717a70..b2f04fe 100644
--- a/apps/mobile/src/screens/workspace-screen.tsx
+++ b/apps/mobile/src/screens/workspace-screen.tsx
@@ -93,7 +93,7 @@ import { SessionActionSheet } from "./session-action-sheet";
 import { SessionBackgroundTasks } from "./session-background-tasks";
 import { SessionComposer } from "./session-composer";
 import { SessionExecutionPanel, SessionWorkingStatus } from "./session-execution-panel";
-import { SessionShellScope } from "./session-shell-output";
+import { SessionShellScope, type ShellScope } from "./session-shell-output";
 import {
   buildTranscriptPresentation,
   PendingPromptRow,
@@ -967,6 +967,16 @@ export function SessionScreen({ navigation, route }: SessionProps) {
     client && connectionId === routeConnectionId && sessionLocationReady,
   );
   const vcsQuery = useSessionVcsQuery(client, connectionId, sessionLocation, resourcesReady);
+  // The background-work chip reads shell status whichever tab is selected.
+  const dockShellScope = useMemo(
+    () => ({
+      client: client ?? undefined,
+      connectionId: routeConnectionId,
+      enabled: resourcesReady && screenFocused,
+      location: sessionLocation,
+    }),
+    [client, resourcesReady, routeConnectionId, screenFocused, sessionLocation],
+  );
   const messagesQuery = useSessionMessagesQuery({
     client,
     connectionId,
@@ -1130,6 +1140,7 @@ export function SessionScreen({ navigation, route }: SessionProps) {
         sessionForms={sessionForms}
         sessionID={sessionID}
         sessionLocation={sessionLocation}
+        shellScope={dockShellScope}
         tablet={isTabletShell(width)}
       />
       <SessionDockComposer
@@ -1731,6 +1742,7 @@ function SessionDockPanel({
   sessionForms,
   sessionID,
   sessionLocation,
+  shellScope,
   subagentAttention,
   tablet,
 }: {
@@ -1751,21 +1763,24 @@ function SessionDockPanel({
   sessionForms: WorkspaceSelection["forms"];
   sessionID: string;
   sessionLocation: LocationRef;
+  shellScope: ShellScope;
   subagentAttention: SubagentAttentionMap;
   tablet: boolean;
 }) {
   return (
     <>
-      <SessionBackgroundTasks
-        key={routeSessionScope}
-        activeSessions={activeSessions}
-        attention={subagentAttention}
-        sessionID={sessionID}
-        messages={messages}
-        onOpenChild={onOpenChild}
-        onStopChild={monitorStale ? undefined : onStopChild}
-        stale={monitorStale}
-      />
+      <SessionShellScope.Provider value={shellScope}>
+        <SessionBackgroundTasks
+          key={routeSessionScope}
+          activeSessions={activeSessions}
+          attention={subagentAttention}
+          sessionID={sessionID}
+          messages={messages}
+          onOpenChild={onOpenChild}
+          onStopChild={monitorStale ? undefined : onStopChild}
+          stale={monitorStale}
+        />
+      </SessionShellScope.Provider>
       <SessionExecutionPanel
         hideInterrupt
         hideStatus
diff --git a/apps/mobile/src/state/open-code-query-keys.ts b/apps/mobile/src/state/open-code-query-keys.ts
index 94fad0f..fbc60cc 100644
--- a/apps/mobile/src/state/open-code-query-keys.ts
+++ b/apps/mobile/src/state/open-code-query-keys.ts
@@ -195,6 +195,10 @@ export const openCodeQueryKeys = {
   shell(connectionId: string, location: LocationRef, id: string) {
     return [...locationKey(connectionId, location), "shell", id] as const;
   },
+  // Status only, for the background-work chip; shell events invalidate it with the output.
+  shellStatus(connectionId: string, location: LocationRef, id: string) {
+    return [...locationKey(connectionId, location), "shell", id, "status"] as const;
+  },
 };
 
 function connectionKey(connectionId: string) {
diff --git a/docs/COMPATIBILITY.md b/docs/COMPATIBILITY.md
index 7177300..fdd9205 100644
--- a/docs/COMPATIBILITY.md
+++ b/docs/COMPATIBILITY.md
@@ -12,6 +12,35 @@ the fail-closed database backup-exclusion startup guard. Statements marked
 pending in older dated entries describe the status at the time of that probe;
 later entries supersede them.
 
+## 2026-11-14: background shells in the composer chip, pending device verification
+
+The chip above the composer now counts running background shells next to
+subagents, as on desktop ("1 shell", "1 subagent · 2 shells"). Shells come from
+transcript shell calls that started in, or moved to, the background. The
+server's shell status decides whether each one still runs. Foreground shells
+stay in the transcript. The sheet lists Needs you, Subagents and Shells. A shell
+opens a page in the sheet with its command, run time, the last 40 lines of
+output and a confirmed Stop. Stop removes the shell on the server. After the
+shell ends, the page says how it ended. Android back returns from the page to
+the list. An iOS swipe closes the sheet.
+
+To match the OpenCode iOS app, a collapsed tool group now reads "Used N tools",
+with no status label and no chevron. Background subagent launches fold into that
+group, and the chip announces their changes. Only the Working line and the chip
+animate; other running glyphs stay still. Expanded shell rows set the command in
+monospace.
+
+The full lint, typecheck, test, and build sequence passed, including 1566 mobile
+tests and both Hermes exports. Expo Doctor passed 18 of 18 checks. Every changed
+file is JavaScript; none is a native fingerprint source under the preview EAS
+environment. Earlier revisions were published to preview through local EAS
+Update. On an iPhone, the chip showed a running background shell and "Used N
+tools" groups. Still unverified on devices: VoiceOver and TalkBack focus on
+opening a shell, Back and Stop; TalkBack speaking dock announcements on Android
+16; the final revision's appearance; Android; and large text. Running shells
+launched before the loaded transcript pages are not found until those pages
+load.
+
 ## 2026-11-14: Working docked above the bottom menu
 
 An iPhone screenshot showed the Working section below a long Recent list, out of
diff --git a/packages/opencode-adapter/src/index.test.ts b/packages/opencode-adapter/src/index.test.ts
index b4b0974..6da17f3 100644
--- a/packages/opencode-adapter/src/index.test.ts
+++ b/packages/opencode-adapter/src/index.test.ts
@@ -55,6 +55,7 @@ import {
   ptyWebSocketUrl,
   queueOpenCodeSessionInboxItem,
   removeOpenCodeSession,
+  removeOpenCodeShell,
   renameOpenCodeSession,
   replyOpenCodeForm,
   replyOpenCodePermissionRequest,
@@ -192,6 +193,21 @@ describe("background shell output", () => {
     );
     expect(isShellNotFoundError(error)).toBe(true);
   });
+  it("stops a shell at its exact location, after which it is not found", async () => {
+    const fixture = createFakeOpenCodeApi({ shells: { sh_test: { info, output: "" } } });
+    const client = createOpenCodeClient({ baseUrl: "http://fake.invalid", fetch: fixture.fetch });
+    const location = { directory: "/workspace/child" };
+    await removeOpenCodeShell(client, location, "sh_test");
+    expect(fixture.requests.at(-1)).toMatchObject({
+      method: "DELETE",
+      path: "/api/shell/sh_test",
+      query: { "location[directory]": ["/workspace/child"] },
+    });
+    const error = await getOpenCodeShell(client, location, "sh_test").catch(
+      (error: unknown) => error,
+    );
+    expect(isShellNotFoundError(error)).toBe(true);
+  });
 });
 
 describe("GitHub pull requests", () => {
diff --git a/packages/opencode-adapter/src/index.ts b/packages/opencode-adapter/src/index.ts
index 45e3227..b52319f 100644
--- a/packages/opencode-adapter/src/index.ts
+++ b/packages/opencode-adapter/src/index.ts
@@ -297,6 +297,16 @@ export async function getOpenCodeShell(
   return response;
 }
 
+// Stops a running shell and drops its record; a later GET answers ShellNotFoundError.
+export function removeOpenCodeShell(
+  client: OpenCodeClient,
+  location: LocationRef,
+  id: string,
+  options?: OpenCodeRequestOptions,
+) {
+  return client.shell.remove({ id, location: locationInput(location) }, options);
+}
+
 export async function getOpenCodeShellOutput(
   client: OpenCodeClient,
   location: LocationRef,
diff --git a/packages/test-fixtures/src/index.ts b/packages/test-fixtures/src/index.ts
index 25fd30e..e39a8d5 100644
--- a/packages/test-fixtures/src/index.ts
+++ b/packages/test-fixtures/src/index.ts
@@ -81,6 +81,7 @@ export function createFakeOpenCodeApi(options: FakeOpenCodeApiOptions = {}) {
     string,
     { info: Record<string, unknown>; output: string; pollsBeforeExit: number; final: string }
   >();
+  const removedShells = new Set<string>();
 
   const fetch: typeof globalThis.fetch = async (input, init) => {
     const url = new URL(
@@ -191,13 +192,19 @@ export function createFakeOpenCodeApi(options: FakeOpenCodeApiOptions = {}) {
     const shellMatch = url.pathname.match(/^\/api\/shell\/([^/]+)(\/output)?$/);
     if (shellMatch && method === "DELETE") {
       const id = decodeURIComponent(shellMatch[1] ?? "");
-      if (!createdShells.delete(id)) {
+      const configured = Boolean(options.shells?.[id]) && !removedShells.has(id);
+      if (!createdShells.delete(id) && !configured) {
         return json({ _tag: "ShellNotFoundError", id, message: "Shell not found" }, 404);
       }
+      // Removing a shell stops it and drops its record, as on the server.
+      removedShells.add(id);
       return new Response(null, { status: 204 });
     }
     if (shellMatch && method === "GET") {
       const id = decodeURIComponent(shellMatch[1] ?? "");
+      if (removedShells.has(id)) {
+        return json({ _tag: "ShellNotFoundError", id, message: "Shell not found" }, 404);
+      }
       const created = createdShells.get(id);
       if (created && !shellMatch[2]) {
         const running = created.pollsBeforeExit > 0;