@@ -252,6 +252,8 @@ unverified, because the pose it ended in is not the one that was asked for.
 The attempt count, the per-read timeout, cancellation, and the open/closed end-stop
 rule are unchanged: an unsettled fold costs the same four hinge streams it always did.
 
+A toolchain with no `devicectl device motion` subcommand (devicectl 651.13.5, Xcode 27.1 RC build 27A9275) cannot read the hinge at all, and answers the first read with no sample. The HID command has already been delivered by then, so `fold` refuses with `fold-pose-dispatched-unverified`: sent, not confirmed, distinct from a pose the hinge contradicted. The error carries the lit panel as evidence; panel power cannot separate `half-open` from `open`, so it is never promoted to a verified pose.
+
 ## Pose is derived from panel power, and official control does not exist
 
 Apple ships fold state as an **app-side, read-only** API: `UIHinge.status`
 
@@ -66,6 +66,9 @@ test('refuses a stream that printed no sample, naming the toolchain gap', async
 
   await expect(readAppleHingeAngle(IOS_TEST_SIMULATOR)).rejects.toMatchObject({
     code: 'COMMAND_FAILED',
-    details: expect.objectContaining({ hint: expect.stringContaining('hinge-angle') }),
+    details: expect.objectContaining({
+      reason: 'fold-hinge-angle-unavailable',
+      hint: expect.stringContaining('hinge-angle'),
+    }),
   });
 });
@@ -12,6 +12,9 @@ import { runXcrun } from './tool-provider.ts';
  */
 const HINGE_ANGLE_SAMPLE = /Angle:\s*(-?\d+(?:[.,]\d+)?)\s*°/g;
 
+/** The stream printed no sample: the toolchain has no `device motion` subcommand or it reports nothing. */
+export const HINGE_ANGLE_UNAVAILABLE_REASON = 'fold-hinge-angle-unavailable';
+
 const HINGE_ANGLE_UNSUPPORTED_HINT =
   "This Xcode/CoreDevice toolchain does not stream 'devicectl device motion hinge-angle' for this device. Foldable poses can be verified only through that stream; update Xcode to a version that ships it.";
 
@@ -56,6 +59,7 @@ export async function readAppleHingeAngle(
       stdout: result.stdout,
       stderr: result.stderr,
       deviceId: device.id,
+      reason: HINGE_ANGLE_UNAVAILABLE_REASON,
       hint: HINGE_ANGLE_UNSUPPORTED_HINT,
     }),
   );
 
@@ -15,6 +15,7 @@ vi.mock('@agent-device/host-kit/diagnostics', async (importOriginal) => {
 });
 
 import type { DeviceInfo } from '@agent-device/kernel/device';
+import { AppError } from '@agent-device/kernel/errors';
 import {
   buildInventory,
   queryAppleDisplayInventory,
@@ -381,3 +382,70 @@ test.each([
     expect(mockHinge).toHaveBeenCalledTimes(2);
   },
 );
+
+test('reports a dispatched but unverifiable pose when the toolchain has no hinge-angle stream', async () => {
+  mockInventory
+    .mockResolvedValueOnce(duoInventory('outer'))
+    .mockResolvedValueOnce(duoInventory('inner'));
+  mockHinge.mockRejectedValue(
+    new AppError('COMMAND_FAILED', 'CoreDevice reported no hinge angle sample', {
+      reason: 'fold-hinge-angle-unavailable',
+    }),
+  );
+
+  await expect(setAppleFoldPose(duo, { pose: 'open' })).rejects.toMatchObject({
+    code: 'COMMAND_FAILED',
+    details: expect.objectContaining({
+      reason: 'fold-pose-dispatched-unverified',
+      requestedPose: 'open',
+      screen: { display: 'LCD-1', coordinateSpace: 'native-panel', widthPt: 669, heightPt: 951 },
+    }),
+  });
+  expect(mockSend).toHaveBeenCalledWith(duo, 'open', undefined);
+  expect(mockHinge).toHaveBeenCalledTimes(1);
+});
+
+test('does not rewrite other hinge read failures as dispatched-unverified', async () => {
+  mockInventory.mockResolvedValueOnce(duoInventory('inner'));
+  mockHinge.mockRejectedValue(new AppError('COMMAND_FAILED', 'devicectl wedged'));
+
+  await expect(setAppleFoldPose(duo, { pose: 'open' })).rejects.toMatchObject({
+    details: expect.not.objectContaining({ reason: 'fold-pose-dispatched-unverified' }),
+  });
+});
+
+test('keeps a mid-settle hinge read failure as the read failure, not a missing toolchain', async () => {
+  mockInventory.mockResolvedValueOnce(duoInventory('inner'));
+  mockHinge.mockResolvedValueOnce(100).mockRejectedValueOnce(
+    new AppError('COMMAND_FAILED', 'CoreDevice reported no hinge angle sample', {
+      reason: 'fold-hinge-angle-unavailable',
+    }),
+  );
+
+  await expect(setAppleFoldPose(duo, { pose: 'half-open' })).rejects.toMatchObject({
+    details: expect.objectContaining({ reason: 'fold-hinge-angle-unavailable' }),
+  });
+});
+
+test('omits the screen from the dispatched-unverified refusal when no panel is lit', async () => {
+  const noneLit = buildInventory([
+    panel({ power: 'dark' }),
+    panel({ name: 'LCD-1', displayId: 3, primary: false, power: 'dark' }),
+  ]);
+  mockInventory.mockResolvedValueOnce(duoInventory('outer')).mockResolvedValueOnce(noneLit);
+  mockHinge.mockRejectedValue(
+    new AppError('COMMAND_FAILED', 'CoreDevice reported no hinge angle sample', {
+      reason: 'fold-hinge-angle-unavailable',
+      stderr: "Unknown option '--device'",
+    }),
+  );
+
+  const failure = await setAppleFoldPose(duo, { pose: 'open' }).catch((error: unknown) => error);
+  expect(failure).toMatchObject({
+    details: {
+      reason: 'fold-pose-dispatched-unverified',
+      hingeReadFailure: { stderr: "Unknown option '--device'" },
+    },
+  });
+  expect((failure as AppError).details).not.toHaveProperty('screen');
+});
@@ -15,7 +15,7 @@ import {
   type AppleDeviceDisplay,
   type AppleDisplayInventory,
 } from '../core/display-inventory.ts';
-import { readAppleHingeAngle } from '../core/hinge-angle.ts';
+import { HINGE_ANGLE_UNAVAILABLE_REASON, readAppleHingeAngle } from '../core/hinge-angle.ts';
 import { requireSimulatorDevice } from '../core/simulator.ts';
 import { sendSimulatorFoldPose } from './simulator-hid.ts';
 
@@ -25,6 +25,9 @@ const FOLDABLE_REQUIRED_HINT =
 const INVENTORY_REQUIRED_HINT =
   "fold needs 'devicectl device info displays' to tell a foldable from a single-panel simulator; update Xcode to a version that ships the display-information feature.";
 
+const DISPATCHED_UNVERIFIED_HINT =
+  "The pose request was sent and the device may have followed it, but 'devicectl device motion hinge-angle' is unavailable here, so fold cannot confirm it. Take a screenshot or snapshot to see which panel is lit, or update Xcode to a version that ships the hinge-angle stream.";
+
 const POSE_UNSETTLED_HINT =
   'The hinge reached the requested pose and was still moving when the read budget ended. Retry the fold, then read the angle directly with xcrun devicectl device motion hinge-angle --device <udid> --session-timeout 1 --timeout 5 to see whether the simulator holds the pose.';
 
@@ -58,6 +61,40 @@ export async function setAppleFoldPose(
   };
 }
 
+function isHingeAngleUnavailable(error: unknown): boolean {
+  return error instanceof AppError && error.details?.reason === HINGE_ANGLE_UNAVAILABLE_REASON;
+}
+
+/**
+ * The toolchain cannot read the hinge, so the pose is neither confirmed nor refuted. The HID
+ * command was delivered, though, so the device may already be in the requested pose; the lit
+ * panel is evidence for the caller to weigh, not a verification (panel power cannot separate
+ * `half-open` from `open`).
+ */
+async function dispatchedUnverifiedPoseError(
+  device: DeviceInfo,
+  pose: FoldPose,
+  signal: AbortSignal | undefined,
+  targetAngle: number | undefined,
+  cause: unknown,
+): Promise<AppError> {
+  const litPanel = await readLitPanel(device, signal);
+  return new AppError(
+    'COMMAND_FAILED',
+    `${device.name} received the ${pose} pose request, but this toolchain cannot read the hinge angle to verify it`,
+    {
+      deviceId: device.id,
+      requestedPose: pose,
+      ...(targetAngle === undefined ? {} : { targetAngleDegrees: targetAngle }),
+      reason: 'fold-pose-dispatched-unverified',
+      ...(litPanel ? { screen: screenReport(litPanel) } : {}),
+      ...(cause instanceof AppError ? { hingeReadFailure: cause.details } : {}),
+      hint: DISPATCHED_UNVERIFIED_HINT,
+    },
+    cause,
+  );
+}
+
 function requireFoldableInventory(device: DeviceInfo, inventory: AppleDisplayInventory): void {
   if (inventory.unresolved) {
     throw new AppError(
@@ -99,7 +136,12 @@ async function awaitHingePose(
   for (let attempt = 1; attempt <= IOS_FOLD_POSE_SETTLE_ATTEMPTS; attempt += 1) {
     signal?.throwIfAborted();
     previous = observed;
-    observed = await readAppleHingeAngle(device, { signal });
+    try {
+      observed = await readAppleHingeAngle(device, { signal });
+    } catch (error) {
+      if (observed !== undefined || !isHingeAngleUnavailable(error)) throw error;
+      throw await dispatchedUnverifiedPoseError(device, pose, signal, targetAngle, error);
+    }
     if (isVerifiedHingePose(observed, previous, pose, targetAngle)) return observed;
   }
   throw hingeVerificationError(device, pose, observed, previous, targetAngle);
 
@@ -253,7 +253,7 @@ Screens are handled for you:
 
 Changing the pose:
   agent-device fold closed | half-open | open
-  fold sends a private HID hinge event inside the selected simulator and then reads the hinge angle back from CoreDevice until it agrees: closed is 0 degrees, open is 180, and half-open is any angle between them (requested at 130 degrees). An angle in that interval only proves the category, so half-open is reported once two consecutive readings both fall inside it and agree within 0.5 degrees. The response reports the verified pose, the hinge angle, and the panel the device now lights with its native panel point size, marked coordinateSpace "native-panel". That point size is the panel's own geometry, not the next snapshot's viewport, so it cannot place a tap: the active app window can differ (a 669x951 inner panel hosts a 951x669 window). A hinge whose last reading is some other pose fails with COMMAND_FAILED and reason fold-pose-unverified, naming the angle CoreDevice still reports; a hinge seen half-open but never at rest fails with reason fold-pose-unsettled, naming the observed and previous angles. A single-panel simulator fails with UNSUPPORTED_OPERATION. A simulator scoped to a non-default set with --ios-simulator-device-set is refused before any hinge is touched, with ${foldGuidance.unsupportedScope}: the HID send honors the set, but CoreDevice's display inventory and hinge-angle readback resolve a scoped simulator as not found, so the pose could not be verified. Run fold without --ios-simulator-device-set (in the default set).
+  fold sends a private HID hinge event inside the selected simulator and then reads the hinge angle back from CoreDevice until it agrees: closed is 0 degrees, open is 180, and half-open is any angle between them (requested at 130 degrees). An angle in that interval only proves the category, so half-open is reported once two consecutive readings both fall inside it and agree within 0.5 degrees. The response reports the verified pose, the hinge angle, and the panel the device now lights with its native panel point size, marked coordinateSpace "native-panel". That point size is the panel's own geometry, not the next snapshot's viewport, so it cannot place a tap: the active app window can differ (a 669x951 inner panel hosts a 951x669 window). A hinge whose last reading is some other pose fails with COMMAND_FAILED and reason fold-pose-unverified, naming the angle CoreDevice still reports; a hinge seen half-open but never at rest fails with reason fold-pose-unsettled, naming the observed and previous angles; a toolchain without the hinge-angle stream (no devicectl device motion) fails with reason fold-pose-dispatched-unverified, meaning the pose was sent but cannot be confirmed, and carries the lit panel's size as evidence, so take a screenshot or snapshot to check. A single-panel simulator fails with UNSUPPORTED_OPERATION. A simulator scoped to a non-default set with --ios-simulator-device-set is refused before any hinge is touched, with ${foldGuidance.unsupportedScope}: the HID send honors the set, but CoreDevice's display inventory and hinge-angle readback resolve a scoped simulator as not found, so the pose could not be verified. Run fold without --ios-simulator-device-set (in the default set).
   Expect a fold to take 10-16 seconds: each hinge read is a five-second devicectl stream, and half-open waits for the hinge to stop moving. Re-snapshot after every fold; refs and coordinates from before it are stale, and the command's message says so.
   Timed motion: fold --keyframes '[{"atMs":0,"angle":0},{"atMs":5000,"angle":180}]'. Use 2–64 frames starting at 0ms, increasing integer timestamps up to 60000ms, and angles from 0 to 180. The last timestamp sets motion duration, excluding setup and verification. Equal angles hold; cancellation stops motion. See the fold examples in the command and Node API documentation for trajectories.
 
 
@@ -114,7 +114,7 @@ Fold a foldable device:
 - The iOS response names the lit panel and its size, marked `coordinateSpace: "native-panel"`. That size is not the next snapshot's viewport and cannot place a tap.
 - iOS only: `--keyframes` plays a timed trajectory instead of a preset, for example `fold --keyframes '[{"atMs":0,"angle":0},{"atMs":1667,"angle":160},{"atMs":3333,"angle":100},{"atMs":5000,"angle":180}]'`. Use 2–64 keyframes starting at 0ms, strictly increasing integer timestamps up to 60,000ms, and angles from 0 to 180°.
 - iOS needs an Xcode with the iOS simulator SDK and foldable HID support (verified on Xcode 27.1); Device Hub and Accessibility permission aren't required. The first fold builds a helper cached under `~/.agent-device/fold-helper`; failures report `fold-helper-build-failed` or `fold-hid-dispatch-failed`.
-- `COMMAND_FAILED` with `reason: fold-pose-unverified` means the hinge reports another pose; `fold-pose-unsettled` means it reached `half-open` but never came to rest.
+- `COMMAND_FAILED` with `reason: fold-pose-unverified` means the hinge reports another pose; `fold-pose-unsettled` means it reached `half-open` but never came to rest; `fold-pose-dispatched-unverified` means the pose was sent but this Xcode has no hinge-angle stream to confirm it, so check the lit panel with a screenshot.
 - `UNSUPPORTED_OPERATION` covers single-panel devices (`single-panel-device` on Android) and simulators in a non-default `--ios-simulator-device-set` (`unsupported-device-scope`; use the default set). Physical devices are refused.
 - On Android, `fold` confirms the pose from the device state the emulator commits and reports `hingeAngleDegrees` as the hinge sensor reads it: the angle the AVD profile defines for the posture, such as 0°, 90°, and 180° on the Pixel folds or 15°, 90°, and 165° on the generic 7.6in Foldable. It also dismisses the lock screen that folding to the cover display can raise. For panels, poses, and timings, see `agent-device help foldable`.