diff --git a/modules/napplet-host/android/src/main/java/org/nostrocket/hypergolic/host/NappletHostModule.kt b/modules/napplet-host/android/src/main/java/org/nostrocket/hypergolic/host/NappletHostModule.kt
index e4ae6b8..25227f2 100644
--- a/modules/napplet-host/android/src/main/java/org/nostrocket/hypergolic/host/NappletHostModule.kt
+++ b/modules/napplet-host/android/src/main/java/org/nostrocket/hypergolic/host/NappletHostModule.kt
@@ -5,12 +5,31 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import com.facebook.react.common.LifecycleState
 import android.util.Base64
 import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.functions.Queues
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.withContext
 
 class NappletHostModule : Module() {
+  private var workspaceFullscreen = false
+
+  private fun updateWorkspaceBars() {
+    val window = appContext.currentActivity?.window ?: return
+    val controller = WindowCompat.getInsetsController(window, window.decorView)
+    val bars = WindowInsetsCompat.Type.systemBars()
+    if (workspaceFullscreen) {
+      controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+      controller.hide(bars)
+    } else {
+      controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_DEFAULT
+      controller.show(bars)
+    }
+  }
+
   override fun definition() = ModuleDefinition {
     Name("HypergolicNappletHost")
     Events("onRelayStream", "onRelayLifecycle", "onUploadProgress", "onRoutingLifecycle")
@@ -32,7 +51,12 @@ class NappletHostModule : Module() {
       ResourceHttpsRequestOwner.INSTANCE.setForeground(foreground)
       PublishedRelayWssRequestOwner.INSTANCE.setForeground(foreground)
     }
+    AsyncFunction("setWorkspaceFullscreen") { fullscreen: Boolean ->
+      workspaceFullscreen = fullscreen
+      updateWorkspaceBars()
+    }.runOnQueue(Queues.MAIN)
     OnActivityEntersForeground {
+      if (workspaceFullscreen) updateWorkspaceBars()
       SelectedFilePicker.foreground(true)
       UploadTransport.foreground(true)
       CvmTransport.foreground(true)
diff --git a/src/shell/Notifications.tsx b/src/shell/Notifications.tsx
index 73e1f19..927bdd2 100644
--- a/src/shell/Notifications.tsx
+++ b/src/shell/Notifications.tsx
@@ -1,6 +1,7 @@
 import {publishedAppLabel} from '../napplets/published-identity';
 import { TrustedBand } from './TrustedBand';
-import {useCallback, useEffect, useMemo, useState, useSyncExternalStore} from 'react';
+import {WorkspaceFullscreenContext} from './WorkspaceFullscreen';
+import {useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore} from 'react';
 import {AppState, FlatList, ScrollView, StyleSheet, Text, View} from 'react-native';
 import { ShellModal as Modal } from './ShellModal';
 import { ShellPressable as Pressable } from './ShellPressable';
@@ -35,6 +36,7 @@ function NotificationPermission({review, service}: {review: NotifyReview; servic
 type CentreEntry = Readonly<{kind: 'card'; card: NotificationCard}> | Readonly<{kind: 'badge'; badge: NotificationBadge}>;
 export function Notifications({service, blocked}: {service: NotifyBroker; blocked: boolean}) {
   const { styles } = useShellStyles(createStyles);
+  const fullscreen = useContext(WorkspaceFullscreenContext);
   const snapshot = useSyncExternalStore(service.subscribe, service.getSnapshot), [opened, setOpened] = useState(false), insets = useSafeAreaInsets();
   useEffect(() => {
     const timer = setInterval(() => service.refresh(), 250), listener = AppState.addEventListener('change', state => {if (state !== 'active') setOpened(false); service.refresh();});
@@ -43,7 +45,7 @@ export function Notifications({service, blocked}: {service: NotifyBroker; blocke
   const entries = useMemo<readonly CentreEntry[]>(() => [...snapshot.cards.map(card => ({kind: 'card' as const, card})), ...snapshot.attributedBadges.map(badge => ({kind: 'badge' as const, badge}))], [snapshot.cards, snapshot.attributedBadges]);
   const renderEntry = useCallback(({item}: {item: CentreEntry}) => item.kind === 'card' ? <NotificationContent card={item.card} service={service}/> : <View testID={'notify-badge-' + publishedAppLabel(item.badge.origin.appId)} style={styles.card}><Text style={styles.title}>{publishedAppLabel(item.badge.origin.appId)}</Text><Text style={styles.publisher}>{formatNpub(item.badge.origin.publisher)}</Text><Text style={styles.text}>Badge count: {item.badge.count}</Text></View>, [service, styles]);
   if (blocked) return null;
-  const toast = !opened && !snapshot.review ? snapshot.toast : undefined;
+  const toast = !fullscreen && !opened && !snapshot.review ? snapshot.toast : undefined;
   const badge = Object.values(snapshot.badges).reduce((sum, count) => sum + count, 0);
   return <>
     {toast && <View testID="notify-toast" style={styles.toast}><View style={styles.card}>
@@ -51,7 +53,7 @@ export function Notifications({service, blocked}: {service: NotifyBroker; blocke
       <Text numberOfLines={1} style={styles.title}>{toast.title}</Text>{toast.body !== '' && <Text numberOfLines={2} style={styles.text}>{toast.body}</Text>}
       <Button id="notify-toast-open" label="View notification" onPress={() => setOpened(true)}/>
     </View></View>}
-    {(snapshot.cards.length > 0 || badge > 0) && !snapshot.review && <View style={styles.launcher}><Button id="notify-centre-open" label={'Notifications (' + snapshot.cards.length + '), badges ' + badge} onPress={() => setOpened(true)}/></View>}
+    {!fullscreen && (snapshot.cards.length > 0 || badge > 0) && !snapshot.review && <View style={styles.launcher}><Button id="notify-centre-open" label={'Notifications (' + snapshot.cards.length + '), badges ' + badge} onPress={() => setOpened(true)}/></View>}
     <Modal visible={opened && !snapshot.review} transparent animationType="fade" onRequestClose={() => setOpened(false)}><View style={[styles.shade, {paddingTop: insets.top, paddingLeft: insets.left, paddingRight: insets.right}]}><FlatList
       data={entries}
       keyExtractor={item => item.kind === 'card' ? 'card-' + item.card.id : 'badge-' + item.badge.origin.generation}
diff --git a/src/shell/Shell.tsx b/src/shell/Shell.tsx
index c5a1533..a9a4a89 100644
--- a/src/shell/Shell.tsx
+++ b/src/shell/Shell.tsx
@@ -1,4 +1,5 @@
 import { isHostActivityBlocked } from './workspace-activity';
+import { WorkspaceFullscreenContext, useWorkspaceFullscreen } from './WorkspaceFullscreen';
 import { useWorkspaceDiscovery } from './useWorkspaceDiscovery';
 import { DiscoveryAccessReview } from './DiscoveryAccessReview';
 import { WorkspaceHeader } from './WorkspaceHeader';
@@ -81,6 +82,7 @@ export function Shell({ blocked = false, hostActivityBlocked = blocked, initialW
   const owner = useContext(OwnerContext);
   const [localWorkspace, setLocalWorkspace] = useState(() => initialWorkspace ?? initialTestWorkspace());
   const workspace = controlledWorkspace ?? localWorkspace;
+  const fullscreen = useWorkspaceFullscreen(workspace);
   const current = useRef(workspace);
   useLayoutEffect(() => { current.current = workspace; }, [workspace]);
   const change = useCallback((next: Workspace) => {
@@ -102,7 +104,7 @@ export function Shell({ blocked = false, hostActivityBlocked = blocked, initialW
   const focusedIndex = Math.max(0, workspace.sessions.findIndex(session => session.id === workspace.focusedId));
   const focused = workspace.sessions.find(session => session.id === workspace.focusedId);
   const { session: menuSession, visible: menuVisible, anchor: menuAnchor, dismiss: dismissMenu, open: openMenu, clear: clearMenu } =
-    useWorkspaceMenu(focused, workspace.overview, { blocked, busy: busyRef, dragging: handleDragging, closeChecks });
+    useWorkspaceMenu(focused, workspace.overview, { blocked, fullscreen, busy: busyRef, dragging: handleDragging, closeChecks });
   const navigationBlocked = blocked || busy || closeCheck !== null;
   const progress = useSharedValue(workspace.overview ? 1 : 0);
   const position = useSharedValue(focusedIndex);
@@ -141,7 +143,7 @@ export function Shell({ blocked = false, hostActivityBlocked = blocked, initialW
   }, []);
   useEffect(() => {
     if (!busyRef.current) { position.set(focusedIndex); progress.set(workspace.overview ? 1 : 0); }
-  }, [focusedIndex, position, progress, workspace.overview]);
+  }, [focusedIndex, fullscreen, position, progress, workspace.overview]);
 
   const focusSession = useCallback((id: string) => {
     if (blocked || busyRef.current || closeChecks.isPending()) return;
@@ -160,10 +162,10 @@ export function Shell({ blocked = false, hostActivityBlocked = blocked, initialW
     change(showOverview(current.current));
     runAnimation(progress, 1, () => overview.current?.focusCard(current.current.focusedId));
   }, [blocked, change, closeChecks, progress, runAnimation]);
-  useWorkspaceBack({ workspace, blocked, menuVisible, busy: busyRef, keyboard: keyboardVisible,
+  useWorkspaceBack({ workspace, blocked, fullscreen, menuVisible, busy: busyRef, keyboard: keyboardVisible,
     closeChecks, dismissMenu, openOverview, focusSession });
   const onHandleEnd = (side: HandleSide, result: 'overview' | 'switch' | 'cancel') => handleWorkspaceGestureEnd({
-    side, result, blocked, busyRef, focusedIndex, current, position, openOverview, runAnimation, change,
+    side, result, blocked, fullscreen, busyRef, focusedIndex, current, position, openOverview, runAnimation, change,
     setHandleDragging,
   });
   function closeSession(id: string) {
@@ -208,15 +210,15 @@ export function Shell({ blocked = false, hostActivityBlocked = blocked, initialW
       <ShellBackdrop mood={workspace.overview ? 'shelf' : 'running'} />
       <ReviewFocus sessionId={workspace.focusedId} overview={workspace.overview} busy={busy} dragging={handleDragging} blocked={blocked} settings={obscured} closing={closingId !== null} />
       <View accessibilityElementsHidden={obscured} importantForAccessibility={obscured ? 'no-hide-descendants' : 'auto'} style={styles.content}>
-        <WorkspaceHeader overview={workspace.overview} focused={focused} identity={identity} disabled={navigationBlocked || handleDragging}
+        <WorkspaceHeader fullscreen={fullscreen} overview={workspace.overview} focused={focused} identity={identity} disabled={navigationBlocked || handleDragging}
           menuAnchor={menuAnchor} onSettings={openSettings} onOverview={openOverview} onMenu={openMenu} />
-        <WorkspaceStage onZoomTarget={registerZoomTarget} closeCheck={closeCheck} workspace={workspace} progress={progress} position={position} scrollY={scrollY} swipeY={swipeY} swipeId={swipeId} busy={busy} blocked={navigationBlocked || obscured} hostActivityBlocked={isHostActivityBlocked(hostActivityBlocked, obscured)} interactive={!handleDragging}
+        <WorkspaceStage fullscreen={fullscreen} onZoomTarget={registerZoomTarget} closeCheck={closeCheck} workspace={workspace} progress={progress} position={position} scrollY={scrollY} swipeY={swipeY} swipeId={swipeId} busy={busy} blocked={navigationBlocked || obscured} hostActivityBlocked={isHostActivityBlocked(hostActivityBlocked, obscured)} interactive={!handleDragging}
           pending={pendingApprovals ?? noPending} ref={overview} onHostEvent={receiveHostEvent} onFocus={focusSession} onClose={requestClose} onOpen={openDiscovery}
           onDragEnd={(id, close) => { runAnimation(swipeY, 0, () => { swipeId.set(null); if (close) requestClose(id); }, 140); }}
           onHandleStart={() => { setHandleDragging(true); Keyboard.dismiss(); cancelAnimation(position); }}
           onHandleEnd={onHandleEnd} />
       </View>
-      {footer}
+      <WorkspaceFullscreenContext value={fullscreen}>{footer}</WorkspaceFullscreenContext>
       <DiscoveryAccessReview review={discovery.review} decide={discovery.decide} />
       {menuSession && <WorkspaceMenu title={menuSession.title} disabled={navigationBlocked} onNappletSettings={openNappletSettings}
         onResetZoom={() => resetZoom(menuSession)} zoomResetDisabled={!zoomResetAvailable}
@@ -245,10 +247,11 @@ interface ShellSettingsProps {
   openDiscovery: () => void;
 }
 
-function handleWorkspaceGestureEnd({ side, result, blocked, busyRef, focusedIndex, current, position, openOverview, runAnimation, change, setHandleDragging }: {
+function handleWorkspaceGestureEnd({ side, result, blocked, fullscreen, busyRef, focusedIndex, current, position, openOverview, runAnimation, change, setHandleDragging }: {
   side: HandleSide;
   result: 'overview' | 'switch' | 'cancel';
   blocked: boolean;
+  fullscreen: boolean;
   busyRef: { current: boolean };
   focusedIndex: number;
   current: { current: Workspace };
@@ -259,7 +262,9 @@ function handleWorkspaceGestureEnd({ side, result, blocked, busyRef, focusedInde
   setHandleDragging: (dragging: boolean) => void;
 }) {
   setHandleDragging(false);
-  if (blocked || busyRef.current) return;
+  if (busyRef.current) return;
+  if (fullscreen) { position.set(focusedIndex); return; }
+  if (blocked) return;
   if (result === 'overview') { position.set(focusedIndex); openOverview(); return; }
   const id = result === 'switch' ? adjacentNapplet(current.current, directionForHandle(side)) : null;
   const destination = id ? current.current.sessions.findIndex(session => session.id === id) : focusedIndex;
diff --git a/src/shell/WorkspaceFullscreen.ts b/src/shell/WorkspaceFullscreen.ts
new file mode 100644
index 0000000..3c388e5
--- /dev/null
+++ b/src/shell/WorkspaceFullscreen.ts
@@ -0,0 +1,23 @@
+import { requireNativeModule } from 'expo';
+import { createContext, useEffect } from 'react';
+import { Platform, useWindowDimensions } from 'react-native';
+import { isWorkspaceFullscreen } from './workspace-activity';
+import type { Workspace } from './workspace';
+
+export const WorkspaceFullscreenContext = createContext(false);
+
+const androidChrome = Platform.OS === 'android'
+  ? requireNativeModule<{setWorkspaceFullscreen(fullscreen: boolean): Promise<void>}>('HypergolicNappletHost')
+  : null;
+
+export function useWorkspaceFullscreen(workspace: Workspace): boolean {
+  const fullscreen = isWorkspaceFullscreen(workspace, useWindowDimensions());
+  useEffect(() => {
+    if (!fullscreen || !androidChrome) return;
+    const chrome = androidChrome;
+    const setFullscreen = (enabled: boolean) => { void chrome.setWorkspaceFullscreen(enabled).catch(() => undefined); };
+    setFullscreen(true);
+    return () => setFullscreen(false);
+  }, [fullscreen]);
+  return fullscreen;
+}
diff --git a/src/shell/WorkspaceHeader.tsx b/src/shell/WorkspaceHeader.tsx
index fffe136..dc407de 100644
--- a/src/shell/WorkspaceHeader.tsx
+++ b/src/shell/WorkspaceHeader.tsx
@@ -1,20 +1,20 @@
 import type { Ref } from 'react';
-import { StatusBar, type ViewInstance } from 'react-native';
+import { Platform, StatusBar, type ViewInstance } from 'react-native';
 import { Header, type ShellIdentity } from './Header';
 import type { NappletDescriptor } from './workspace';
 import { useShellStyles } from './theme';
 
 const noStyles = () => ({});
-export function WorkspaceHeader({ overview, focused, identity, disabled, menuAnchor, onSettings, onOverview, onMenu }: {
-  overview: boolean; focused: NappletDescriptor | undefined; identity?: ShellIdentity; disabled: boolean;
+export function WorkspaceHeader({ fullscreen, overview, focused, identity, disabled, menuAnchor, onSettings, onOverview, onMenu }: {
+  fullscreen: boolean; overview: boolean; focused: NappletDescriptor | undefined; identity?: ShellIdentity; disabled: boolean;
   menuAnchor: Ref<ViewInstance>; onSettings(): void; onOverview(): void; onMenu(): void;
 }) {
   const { isDark } = useShellStyles(noStyles);
   const compact = !overview && focused !== undefined;
   return <>
-    <StatusBar barStyle={isDark ? 'light-content' : 'dark-content'} />
-    <Header title={overview ? 'Hypergolic' : focused?.title ?? 'Hypergolic'} identity={identity} disabled={disabled}
+    <StatusBar hidden={Platform.OS === 'ios' ? fullscreen : undefined} barStyle={isDark ? 'light-content' : 'dark-content'} />
+    {!fullscreen && <Header title={overview ? 'Hypergolic' : focused?.title ?? 'Hypergolic'} identity={identity} disabled={disabled}
       compact={compact} menuAnchor={menuAnchor} onSettings={onSettings}
-      onOverview={compact ? onOverview : undefined} onMenu={compact ? onMenu : undefined} />
+      onOverview={compact ? onOverview : undefined} onMenu={compact ? onMenu : undefined} />}
   </>;
 }
diff --git a/src/shell/WorkspaceStage.tsx b/src/shell/WorkspaceStage.tsx
index a9d8bbe..761e9fa 100644
--- a/src/shell/WorkspaceStage.tsx
+++ b/src/shell/WorkspaceStage.tsx
@@ -13,6 +13,7 @@ import { runtimeStatus } from './runtime-status';
 import type {ZoomResetRegistration} from './zoom-reset';
 
 interface LiveProps {
+  gutter: number;
   session: NappletDescriptor;
   closeCheck: string;
   index: number;
@@ -29,7 +30,7 @@ interface LiveProps {
   onZoomTarget: ZoomResetRegistration;
   onHostEvent?: (event: HostEvent) => void;
 }
-const LiveSession = memo(function LiveSession({ session, closeCheck, index, size, rect, progress, position, scrollY, swipeY, swipeId, active, inputBlocked, raised, onZoomTarget, onHostEvent }: LiveProps) {
+const LiveSession = memo(function LiveSession({ gutter, session, closeCheck, index, size, rect, progress, position, scrollY, swipeY, swipeId, active, inputBlocked, raised, onZoomTarget, onHostEvent }: LiveProps) {
   const { styles } = useShellStyles(createStyles);
   // A keyed session starts when first focused and stays mounted until close or identity change.
   const [loaded, setLoaded] = useState(raised);
@@ -55,7 +56,7 @@ const LiveSession = memo(function LiveSession({ session, closeCheck, index, size
   return (
     <Animated.View collapsable={false} pointerEvents={active && !inputBlocked ? 'auto' : 'none'} importantForAccessibility={active && !inputBlocked ? 'auto' : 'no-hide-descendants'} accessibilityElementsHidden={!active || inputBlocked}
       style={[styles.live, { width, height, zIndex: raised ? 2 : 1 }, movement]}>
-      {loaded ? <NappletHost onZoomTarget={onZoomTarget} closeCheck={closeCheck} active={active} inputBlocked={inputBlocked} session={session} onHostEvent={onNativeEvent} style={styles.host} />
+      {loaded ? <NappletHost onZoomTarget={onZoomTarget} closeCheck={closeCheck} active={active} inputBlocked={inputBlocked} session={session} onHostEvent={onNativeEvent} style={[styles.host, {marginHorizontal: gutter}]} />
         : <View style={styles.unloaded}><Text style={styles.reopen}>Open to load</Text></View>}
       <Text testID={`runtime-status-${session.id}`} importantForAccessibility={active ? 'auto' : 'no-hide-descendants'} accessibilityElementsHidden={!active} accessibilityLiveRegion={active ? 'polite' : 'none'} style={[styles.runtimeStatus, loaded && status === 'Runtime connected' && styles.connected]}>{loaded ? status : 'Not loaded'}</Text>
     </Animated.View>
@@ -63,6 +64,7 @@ const LiveSession = memo(function LiveSession({ session, closeCheck, index, size
 });
 
 interface StageProps {
+  fullscreen: boolean;
   onZoomTarget: ZoomResetRegistration;
   workspace: Workspace;
   closeCheck: CloseCheckRequest | null;
@@ -85,21 +87,21 @@ interface StageProps {
   onHandleEnd: (side: HandleSide, result: 'overview' | 'switch' | 'cancel') => void;
 }
 
-export const WorkspaceStage = forwardRef<OverviewHandle, StageProps>(function WorkspaceStage({ onZoomTarget, workspace, closeCheck, progress, position, scrollY, swipeY, swipeId, busy, blocked, hostActivityBlocked = blocked, interactive, pending, onHostEvent, onFocus, onClose, onOpen, onDragEnd, onHandleStart, onHandleEnd }, ref) {
+export const WorkspaceStage = forwardRef<OverviewHandle, StageProps>(function WorkspaceStage({ fullscreen, onZoomTarget, workspace, closeCheck, progress, position, scrollY, swipeY, swipeId, busy, blocked, hostActivityBlocked = blocked, interactive, pending, onHostEvent, onFocus, onClose, onOpen, onDragEnd, onHandleStart, onHandleEnd }, ref) {
   const { styles } = useShellStyles(createStyles);
   const [size, setSize] = useState<Size>({ width: 0, height: 0 });
   const [measured, setMeasured] = useState<Record<string, CardMeasurement>>({});
   const { fontScale } = useWindowDimensions();
   const geometry = useMemo(() => overviewGeometry(size, workspace.sessions.length, fontScale), [fontScale, size, workspace.sessions.length]);
   const disabled = busy || blocked;
-  return <View style={styles.stage} testID="shell-stage" onLayout={({ nativeEvent }) => {
+  return <View style={[styles.stage, !fullscreen && styles.stageMargin]} testID="shell-stage" onLayout={({ nativeEvent }) => {
     const { width, height } = nativeEvent.layout;
     // A transient zero-sized stage (IME/rotation) must not unmount live sessions.
     if (width <= 0 || height <= 0) return;
     setSize(previous => previous.width === width && previous.height === height ? previous : { width, height });
   }}>
     {size.width > 0 && size.height > 0 && <>
-      {workspace.sessions.map((session, index) => <LiveSession key={session.id} onZoomTarget={onZoomTarget} session={session} closeCheck={closeCheck?.sessionId === session.id ? JSON.stringify({id: closeCheck.id, generation: closeCheck.generation}) : ''} index={index} size={size} rect={resolveCardRect(geometry.cards[index], measured[session.id])}
+      {workspace.sessions.map((session, index) => <LiveSession key={session.id} gutter={fullscreen ? 0 : HANDLE_GUTTER} onZoomTarget={onZoomTarget} session={session} closeCheck={closeCheck?.sessionId === session.id ? JSON.stringify({id: closeCheck.id, generation: closeCheck.generation}) : ''} index={index} size={size} rect={resolveCardRect(geometry.cards[index], measured[session.id])}
         progress={progress} position={position} scrollY={scrollY} swipeY={swipeY} swipeId={swipeId} {...workspaceSessionActivity({focused: workspace.focusedId === session.id, overview: workspace.overview, busy, interactive, blocked, checkingClose: closeCheck !== null, hostActivityBlocked})}
         raised={workspace.focusedId === session.id} onHostEvent={onHostEvent} />)}
       <Overview ref={ref} sessions={workspace.sessions} geometry={geometry} size={size} visible={workspace.overview} busy={disabled} focusedId={workspace.focusedId}
@@ -111,16 +113,17 @@ export const WorkspaceStage = forwardRef<OverviewHandle, StageProps>(function Wo
             && prior.actual.width === measurement.actual.width && prior.actual.height === measurement.actual.height
             ? previous : { ...previous, [id]: measurement };
         })} />
-      <Handles width={size.width} position={position} index={Math.max(0, workspace.sessions.findIndex(session => session.id === workspace.focusedId))} count={workspace.sessions.length} top={clamp(size.height * 0.62, 40, Math.max(40, size.height - 104))} disabled={workspace.overview || disabled}
+      <Handles width={size.width} position={position} index={Math.max(0, workspace.sessions.findIndex(session => session.id === workspace.focusedId))} count={workspace.sessions.length} top={clamp(size.height * 0.62, 40, Math.max(40, size.height - 104))} disabled={fullscreen || workspace.overview || disabled}
         canPrevious={adjacentNapplet(workspace, -1) !== null} canNext={adjacentNapplet(workspace, 1) !== null}
         onStart={onHandleStart} onEnd={onHandleEnd} />
     </>}
   </View>;
 });
 const createStyles = (colors: ShellPalette, fonts: ShellFonts) => StyleSheet.create({
-  stage: { flex: 1, marginHorizontal: 6, marginBottom: 2, borderRadius: 0, overflow: 'hidden' },
+  stage: { flex: 1, overflow: 'hidden' },
+  stageMargin: { marginHorizontal: 6, marginBottom: 2 },
   live: { position: 'absolute', left: 0, top: 0, overflow: 'hidden', backgroundColor: colors.background },
-  host: { flex: 1, marginHorizontal: HANDLE_GUTTER },
+  host: { flex: 1 },
   unloaded: { flex: 1, justifyContent: 'center', alignItems: 'center' },
   reopen: { fontFamily: fonts.body, color: colors.muted, fontSize: 22 },
   connected: { position: 'absolute', height: 0, width: 0, paddingVertical: 0, opacity: 0 },
diff --git a/src/shell/useWorkspaceBack.ts b/src/shell/useWorkspaceBack.ts
index b6d926a..15be8ee 100644
--- a/src/shell/useWorkspaceBack.ts
+++ b/src/shell/useWorkspaceBack.ts
@@ -3,24 +3,24 @@ import { BackHandler, Keyboard } from 'react-native';
 import type { Workspace } from './workspace';
 
 interface Props {
-  workspace: Workspace; blocked: boolean; menuVisible: boolean;
+  workspace: Workspace; blocked: boolean; fullscreen: boolean; menuVisible: boolean;
   busy: Readonly<{ current: boolean }>; keyboard: Readonly<{ current: boolean }>;
   closeChecks: { isPending(): boolean };
   dismissMenu(): void; openOverview(): void; focusSession(id: string): void;
 }
 
 /** Back dismisses the nearest shell surface before navigating the workspace. */
-export function useWorkspaceBack({ workspace, blocked, menuVisible, busy, keyboard, closeChecks, dismissMenu, openOverview, focusSession }: Props) {
+export function useWorkspaceBack({ workspace, blocked, fullscreen, menuVisible, busy, keyboard, closeChecks, dismissMenu, openOverview, focusSession }: Props) {
   const { overview, focusedId } = workspace;
   useEffect(() => {
     const subscription = BackHandler.addEventListener('hardwareBackPress', () => {
       if (menuVisible) { dismissMenu(); return true; }
       if (keyboard.current) { Keyboard.dismiss(); return true; }
-      if (blocked || busy.current || closeChecks.isPending()) return true;
+      if (fullscreen || blocked || busy.current || closeChecks.isPending()) return true;
       if (!overview) { openOverview(); return true; }
       if (focusedId) { focusSession(focusedId); return true; }
       return false;
     });
     return () => subscription.remove();
-  }, [blocked, busy, closeChecks, dismissMenu, focusSession, focusedId, keyboard, menuVisible, openOverview, overview]);
+  }, [blocked, busy, closeChecks, dismissMenu, focusSession, focusedId, fullscreen, keyboard, menuVisible, openOverview, overview]);
 }
diff --git a/src/shell/useWorkspaceMenu.ts b/src/shell/useWorkspaceMenu.ts
index 783082b..19f1569 100644
--- a/src/shell/useWorkspaceMenu.ts
+++ b/src/shell/useWorkspaceMenu.ts
@@ -3,7 +3,7 @@ import { AccessibilityInfo, Keyboard, type ViewInstance } from 'react-native';
 import type { NappletDescriptor } from './workspace';
 
 interface Availability {
-  blocked: boolean; dragging: boolean;
+  blocked: boolean; fullscreen: boolean; dragging: boolean;
   busy: Readonly<{ current: boolean }>;
   closeChecks: { isPending(): boolean };
 }
@@ -12,7 +12,8 @@ interface Availability {
 export function useWorkspaceMenu(focused: NappletDescriptor | undefined, overview: boolean, availability: Availability) {
   const [id, setId] = useState<string | null>(null);
   const anchor = useRef<ViewInstance>(null);
-  const session = !overview && focused?.id === id ? focused : undefined;
+  const canShow = !overview && !availability.fullscreen;
+  const session = canShow && focused?.id === id ? focused : undefined;
   const visible = session !== undefined;
   if (id !== null && !visible) setId(null);
   const dismiss = useCallback(() => {
@@ -23,7 +24,7 @@ export function useWorkspaceMenu(focused: NappletDescriptor | undefined, overvie
     });
   }, []);
   const open = () => {
-    if (availability.blocked || availability.busy.current || availability.dragging || availability.closeChecks.isPending() || !focused || overview) return;
+    if (availability.blocked || availability.busy.current || availability.dragging || availability.closeChecks.isPending() || !focused || !canShow) return;
     Keyboard.dismiss();
     setId(focused.id);
   };
diff --git a/src/shell/workspace-activity.test.ts b/src/shell/workspace-activity.test.ts
index 24bbca6..4a88f92 100644
--- a/src/shell/workspace-activity.test.ts
+++ b/src/shell/workspace-activity.test.ts
@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { workspaceSessionActivity, isHostActivityBlocked } from './workspace-activity.ts';
+import { workspaceSessionActivity, isHostActivityBlocked, isWorkspaceFullscreen } from './workspace-activity.ts';
 
 const focused = {focused: true, overview: false, busy: false, interactive: true, checkingClose: false,
   blocked: false, hostActivityBlocked: false};
@@ -28,3 +28,15 @@ test('real shell blockers obscure the host independently of review input occlusi
   assert.equal(isHostActivityBlocked(true, false), true);
   assert.equal(isHostActivityBlocked(false, true), true);
 });
+
+test('fullscreen follows the native window only while a napplet is focused outside overview', () => {
+  const portrait = {width: 390, height: 844};
+  const landscape = {width: 844, height: 390};
+  const focused = {focusedId: 'discover', overview: false};
+  assert.equal(isWorkspaceFullscreen(focused, portrait), false);
+  assert.equal(isWorkspaceFullscreen(focused, landscape), true);
+  assert.equal(isWorkspaceFullscreen({...focused, overview: true}, landscape), false);
+  assert.equal(isWorkspaceFullscreen({focusedId: null, overview: false}, landscape), false);
+  assert.equal(isWorkspaceFullscreen(focused, {width: 844, height: 0}), false);
+  assert.equal(isWorkspaceFullscreen(focused, {width: 390, height: 390}), false);
+});
diff --git a/src/shell/workspace-activity.ts b/src/shell/workspace-activity.ts
index d5f21ab..70f7fad 100644
--- a/src/shell/workspace-activity.ts
+++ b/src/shell/workspace-activity.ts
@@ -1,3 +1,10 @@
+import type { Workspace } from './workspace.ts';
+
+/** Native window bounds follow OS rotation. The stage can shrink independently for the keyboard. */
+export function isWorkspaceFullscreen(workspace: Pick<Workspace, 'focusedId' | 'overview'>, window: {width: number; height: number}): boolean {
+  return workspace.focusedId !== null && !workspace.overview && window.height > 0 && window.width > window.height;
+}
+
 /** Review input occlusion is separate from changing the committed native source. */
 export function workspaceSessionActivity(context: Readonly<{
   focused: boolean; overview: boolean; busy: boolean; interactive: boolean; checkingClose: boolean;