@@ -5,3 +5,5 @@
 Fix foldable iPhone simulator rotation in scoped sets and confirm the lit panel in both default and scoped sets. Rotation in both sets uses the fold helper, with no CoreDevice orientation polling. An already visible target dispatches nothing. Incomplete, unknown-power and multi-lit panel tables neither confirm nor dispatch. A target the panel never shows fails with `orientation-unverified`.
 
 Use the fixed iPhone Duo picker offsets measured in both sets (outer 0 degrees, inner +90 degrees), replacing runtime calibration. Inner landscape-left sends `portrait-upside-down`, mapped to the HID wire value `pud`; it remains unsupported as a user target. Delayed reads wait without resending the same picker value to the same panel.
+
+Unresolved guest reads inside the settle loop neither confirm nor dispatch and are retried. An unresolved final read fails with `orientation-panel-table-unavailable`. Multi-panel classification admits rotation without a model-name guard; a new multi-panel model needs its own picker mapping.
@@ -372,21 +372,22 @@ Rejected alternatives:
 
 `XCUIDevice.orientation` has no effect on an iPhone Duo simulator, and the runner readback repeats the requested value.
 `devicectl device orientation set` reports success and has no effect on a simulator that `simctl boot` started.
-`orientation` therefore rotates a multi-panel iPhone Duo simulator through the guest device-state control: the HID event that Device Hub's orientation menu sends (`orientation-picker-control`, type `enum`).
+`orientation` therefore rotates a multi-panel simulator through the guest device-state control: the HID event that Device Hub's orientation menu sends (`orientation-picker-control`, type `enum`).
 The picker accepts `pud` for upside-down dispatch, which the inner panel needs to show landscape-left.
 The user target `portrait-upside-down` remains refused with `unsupported-foldable-orientation`.
 Routing uses the `fold` admission and the set-based panel-count source. A resolved panel count is a hardware fact, so the daemon probes each simulator once.
 A supplied helper is a reuse handle; only an explicit guest-source request changes the default-set source.
 Thus, classifying a single-panel default-set simulator does not prepare the fold helper.
 
-The picker mapping requires the discovered model to be iPhone Duo; other multi-panel models are refused.
+The picker offsets were measured on iPhone Duo; a new multi-panel model needs its own mapping.
 In both simulator sets, the helper reads the guest panel table and dispatches the fixed picker value for the established lit panel.
 The table maps the outer panel at zero offset and the inner panel at +90 degrees.
 Only a fresh `currentOrientation` from an established lit panel confirms the requested visible orientation.
 An incomplete table, unknown-power sibling, or multiple lit panels cannot confirm or dispatch.
 A repeated visible target dispatches nothing; delayed reads wait without resending to the same panel.
 A target that never appears is refused with `orientation-unverified` in either set.
-An unreadable guest table reports `orientation-panel-table-unavailable` and points to the inventory diagnostic.
+An unresolved guest read inside the settle loop neither confirms nor dispatches; the loop retries it.
+An unresolved final read reports `orientation-panel-table-unavailable` and points to the inventory diagnostic.
 
 Rejected alternatives:
 
 
@@ -290,7 +290,7 @@ const backCommandDescription =
 const homeCommandDescription =
   'Send the selected device to its home screen. This leaves the app session open but moves the foreground away from the app.';
 const orientationCommandDescription =
-  'Set device orientation on iOS and Android. auto hands rotation back to the sensor on ADB-backed Android (local and Limrun); other backends refuse it. A foldable iPhone simulator (iPhone Duo) refuses portrait-upside-down. In both default and scoped simulator sets it rotates through the fold helper and succeeds only when the lit panel shows the requested orientation; otherwise it fails with orientation-unverified, or orientation-panel-table-unavailable when the guest panel table cannot be read.';
+  'Set device orientation on iOS and Android. auto hands rotation back to the sensor on ADB-backed Android (local and Limrun); other backends refuse it. A foldable iPhone simulator (iPhone Duo) refuses portrait-upside-down. In both default and scoped simulator sets it rotates through the fold helper and succeeds only when the lit panel shows the requested orientation; otherwise it fails with orientation-unverified, or orientation-panel-table-unavailable when the final guest panel table cannot be read.';
 const foldGuidance = {
   hingeEvent: 'simulator HID hinge event',
   permissions: 'Device Hub and host Accessibility permission are not required.',
 
@@ -17,6 +17,7 @@ import { createLocalAppleToolProvider, withAppleToolProvider } from '../core/too
 import { createAppleInteractor } from '../interactor.ts';
 import { isAppleFoldableSimulator, readFoldablePanelTable } from './orientation.ts';
 import { ensureFoldHelperBinary } from './fold-helper-cache.ts';
+import { IOS_FOLDABLE_ORIENTATION_SETTLE_ATTEMPTS } from '../core/config.ts';
 import { IOS_DEVICE, IOS_SIMULATOR } from '../__tests__/device-fixtures.ts';
 import { IPHONE_17_SINGLE_PANEL, IPHONE_DUO_CLOSED } from '../__tests__/display-fixtures.ts';
 
@@ -35,7 +36,6 @@ function simulator(overrides: Partial<DeviceInfo> = {}): DeviceInfo {
   simulatorCount += 1;
   return {
     ...IOS_SIMULATOR,
-    model: 'iPhone Duo',
     id: `${IOS_SIMULATOR.id}-${simulatorCount}`,
     ...overrides,
   };
@@ -184,6 +184,7 @@ function fakeDuo(
     picker: DeviceRotation;
     offsets?: { inner: number; outer: number };
     followsHid?: boolean;
+    unresolvedGuestReads?: readonly number[] | 'all';
     /** Rotations a panel's foreground UI cannot show; the panel keeps its last rotation. */
     cannotShow?: Partial<Record<DuoPanel, readonly DeviceRotation[]>>;
     /** The rotation a dark panel last showed, for the fold that lights it. */
@@ -208,6 +209,7 @@ function fakeDuo(
   let lagReadsLeft = 0;
   let bothLitReads = 0;
   let panelReads = 0;
+  let guestReads = 0;
   const shown: Record<DuoPanel, number> = {
     inner: PANEL_ANGLE[options.lastShown?.inner ?? 'portrait'],
     outer: PANEL_ANGLE[options.lastShown?.outer ?? 'portrait'],
@@ -264,6 +266,13 @@ function fakeDuo(
       const mode = spawn.slice(3);
       helpers.push(mode);
       if (mode[0] === 'panels') {
+        guestReads += 1;
+        if (
+          options.unresolvedGuestReads === 'all' ||
+          options.unresolvedGuestReads?.includes(guestReads)
+        ) {
+          return { stdout: '', stderr: 'transient guest panel read failure', exitCode: 1 };
+        }
         const displays = readPanels();
         return { stdout: JSON.stringify({ version: 1, displays }), stderr: '', exitCode: 0 };
       }
@@ -354,6 +363,50 @@ describe.each([undefined, '/tmp/scoped-set'])('foldable rotation, set %s', (simu
     },
   );
 
+  test.each([1, 2])('retries unresolved guest read %s before confirming', async (failedRead) => {
+    const device = simulator({ simulatorSetPath });
+    const classification = fakeDuo(device, { lit: 'outer', picker: 'portrait' });
+    await expect(rotateDuo(classification, 'portrait')).resolves.toEqual({
+      orientation: 'portrait',
+    });
+    const sim = fakeDuo(device, {
+      lit: 'outer',
+      picker: 'portrait',
+      unresolvedGuestReads: [failedRead],
+    });
+    await expect(rotateDuo(sim, 'landscape-left')).resolves.toEqual({
+      orientation: 'landscape-left',
+    });
+    expect(sim.helpers.map((mode) => mode[0])).toEqual(
+      failedRead === 1
+        ? ['panels', 'panels', 'rotate', 'panels']
+        : ['panels', 'rotate', 'panels', 'panels'],
+    );
+    expect(sim.rotations()).toEqual(['landscape-left']);
+    expect(mockRunner).not.toHaveBeenCalled();
+  });
+
+  test('always unresolved guest reads exhaust the loop without dispatch', async () => {
+    const device = simulator({ simulatorSetPath });
+    const sim = fakeDuo(device, {
+      lit: 'outer',
+      picker: 'portrait',
+      unresolvedGuestReads: 'all',
+    });
+    // Classify before injecting guest failures, including in a scoped set.
+    const classification = fakeDuo(device, { lit: 'outer', picker: 'portrait' });
+    await expect(rotateDuo(classification, 'portrait')).resolves.toEqual({
+      orientation: 'portrait',
+    });
+    await expect(rotateDuo(sim, 'landscape-left')).resolves.toMatchObject({
+      code: 'COMMAND_FAILED',
+      details: { reason: 'orientation-panel-table-unavailable' },
+    });
+    expect(sim.helpers).toHaveLength(IOS_FOLDABLE_ORIENTATION_SETTLE_ATTEMPTS + 1);
+    expect(sim.rotations()).toEqual([]);
+    expect(mockRunner).not.toHaveBeenCalled();
+  });
+
   test('a foldable rotates on the first command, confirmed by the panel table', async () => {
     const scoped = simulator({ simulatorSetPath });
     // The inner panel lights at rot90 while the picker sits at portrait (K = +90, measured).
@@ -661,20 +714,3 @@ test('a rotation is not routed by a pending panel-table retry', async () => {
   expect(sim.rotations()).toEqual(['landscape-left']);
   expect(mockRunner).not.toHaveBeenCalled();
 });
-
-test.each(['iPad Pro', 'Another Foldable', undefined])(
-  'an unverified multi-panel model %s cannot use the Duo picker mapping',
-  async (model) => {
-    const sim = fakeDuo(simulator({ model, name: 'iPhone Duo' }), {
-      lit: 'outer',
-      picker: 'portrait',
-    });
-    await expect(sim.rotate('landscape-left')).rejects.toMatchObject({
-      code: 'UNSUPPORTED_OPERATION',
-      details: { reason: 'unsupported-foldable-model' },
-    });
-    expect(ensureFoldHelperBinary).not.toHaveBeenCalled();
-    expect(sim.rotations()).toEqual([]);
-    expect(mockRunner).not.toHaveBeenCalled();
-  },
-);
 
@@ -125,13 +125,6 @@ export async function setAppleFoldableOrientation(
   options: { signal?: AbortSignal } = {},
 ): Promise<{ orientation: DeviceRotation }> {
   const { signal } = options;
-  if (device.model !== 'iPhone Duo') {
-    throw new AppError('UNSUPPORTED_OPERATION', 'Guest rotation requires an iPhone Duo model', {
-      deviceId: device.id,
-      reason: 'unsupported-foldable-model',
-      hint: 'The guest orientation picker mapping is verified only for iPhone Duo. Use a simulator whose discovered model is iPhone Duo.',
-    });
-  }
   if (rotation === 'portrait-upside-down') {
     throw new AppError('UNSUPPORTED_OPERATION', `${device.name} cannot rotate to ${rotation}`, {
       deviceId: device.id,
@@ -145,7 +138,7 @@ export async function setAppleFoldableOrientation(
   let reading: LitPanel | undefined;
   for (let attempt = 1; attempt <= IOS_FOLDABLE_ORIENTATION_SETTLE_ATTEMPTS; attempt += 1) {
     signal?.throwIfAborted();
-    reading = await readLitPanel(device, helper, signal);
+    reading = await readLitPanel(device, helper, { signal });
     if (reading?.rotation === rotation) return { orientation: rotation };
     if (reading && reading.panel.displayId !== dispatchedDisplayId) {
       const mapping = reading.panel.primary ? PANEL_PICKERS.outer : PANEL_PICKERS.inner;
@@ -168,7 +161,7 @@ export async function setAppleFoldableOrientation(
     }
     await settleRotation();
   }
-  reading = await readLitPanel(device, helper, signal);
+  reading = await readLitPanel(device, helper, { signal, requireTable: true });
   if (reading?.rotation === rotation) return { orientation: rotation };
   throw unverifiedError(device, rotation, reading);
 }
@@ -213,14 +206,14 @@ function unverifiedError(
 async function readLitPanel(
   device: DeviceInfo,
   helper: FoldHelper,
-  signal: AbortSignal | undefined,
+  options: { signal?: AbortSignal; requireTable?: boolean },
 ): Promise<LitPanel | undefined> {
   const inventory = await queryAppleDisplayInventory(device, {
-    signal,
+    signal: options.signal,
     source: 'guest',
     foldHelper: helper,
   });
-  if (inventory.unresolved) {
+  if (inventory.unresolved && options.requireTable) {
     throw new AppError('COMMAND_FAILED', 'The guest panel table could not be read', {
       deviceId: device.id,
       reason: 'orientation-panel-table-unavailable',
 
@@ -125,7 +125,7 @@ Back, orientation, and hardware buttons:
 - `back` uses app-owned back navigation: visible in-app back UI on Apple targets, and the back keyevent on Android. `--in-app` names this default explicitly.
 - On iOS, a single-screen iPhone or an iPad whose app provably fills its screen, `back` can use a top-leading tap when the app tree is unreadable. It compares the screen before and after the tap. If the screen cannot be captured, the command reports an unknown outcome; inspect the screen before you retry.
 - `back --system` sends system back input: the Android back keyevent, the iOS back gesture, or the tvOS Siri Remote Menu button. macOS has no system back, so it reports unavailable.
-- `orientation portrait|portrait-upside-down|landscape-left|landscape-right` works on iOS and Android mobile targets only. On ADB-backed Android it turns auto-rotate off, and the lock persists after the session ends until something turns it back on. In both default and scoped simulator sets, an iPhone Duo classified with more than one integrated panel refuses `portrait-upside-down` and rotates through the fold helper. It succeeds only when the lit panel shows the requested orientation; if it never does, or the simulator never reports a single lit panel, the command fails with `orientation-unverified`. An unreadable guest table reports `orientation-panel-table-unavailable`. Other multi-panel simulator models are refused. A simulator classified with one panel, or whose first classification read is unresolved, uses the standard runner rotation.
+- `orientation portrait|portrait-upside-down|landscape-left|landscape-right` works on iOS and Android mobile targets only. On ADB-backed Android it turns auto-rotate off, and the lock persists after the session ends until something turns it back on. In both default and scoped simulator sets, an iPhone Duo classified with more than one integrated panel refuses `portrait-upside-down` and rotates through the fold helper. It succeeds only when the lit panel shows the requested orientation; if it never does, or the simulator never reports a single lit panel, the command fails with `orientation-unverified`. Unresolved guest reads are retried inside the settle loop; an unresolved final read reports `orientation-panel-table-unavailable`. The picker offsets were measured on iPhone Duo; a new multi-panel model needs its own mapping. A simulator classified with one panel, or whose first classification read is unresolved, uses the standard runner rotation.
 - `orientation auto` hands rotation back to the sensor on ADB-backed Android, local or Limrun (`accelerometer_rotation=1`, `user_rotation` untouched), and reports `orientation: "auto"`. It does not wait for the display to rotate, because there is no target rotation: the sensor decides, and an emulator usually settles on portrait. Every other backend refuses `auto` with `UNSUPPORTED_OPERATION`.
 - `action-button` presses the iPhone or iPad Action Button once. It takes no arguments, no hold duration, and no `--settle`, and it doesn't activate the session app or drive Camera Control. Other platforms refuse it, and a model without the button (an iPhone SE, most iPad simulators) fails with `UNSUPPORTED_OPERATION`.
 - `action-button` reports that the press was dispatched, not what it triggered. Simulators run no Shortcuts or App Intents, so verify the outcome on a physical iPhone. Expect a press to take about five seconds on a Simulator.