@@ -62,7 +62,7 @@ import {
   hoverRuntimeUses,
   keyboardRuntimePlanUses,
   longPressRuntimeUses,
-  orientationRuntimeUse,
+  orientationRuntimePlanUses,
   perfRuntimePlanUses,
   pressRuntimeUses,
   resolveSelectorCaptureRuntimePlan,
@@ -1500,9 +1500,9 @@ export const RAW_COMMAND_DESCRIPTORS = [
     catalog: { group: 'public' },
     frameworkTier: 'extended',
     // R44 retires this command's capability bucket and its `dispatch` leaf together: admission is
-    // the owner's `setOrientation` fact, and the only execution is the bound operation.
+    // the owner's `setOrientation` fact (`unlockOrientation` for `auto`); only that operation runs.
     ...GENERIC_MUTATING_COMMAND_TRAITS,
-    platformExecution: { kind: 'device-runtime', uses: [orientationRuntimeUse] },
+    platformExecution: { kind: 'device-runtime', uses: orientationRuntimePlanUses },
   },
   {
     name: 'fold',
 
@@ -5,7 +5,7 @@ import type { BackMode } from './back-mode.ts';
 import type { SelectorSnapshotCommandOptions } from './client-capture.ts';
 import type { DeviceCommandBaseOptions } from './client-connection.ts';
 import type { SettleCommandOptions } from './client-gesture.ts';
-import type { DeviceRotation, SetFoldPoseInput } from './device-rotation.ts';
+import type { OrientationRequest, SetFoldPoseInput } from './device-rotation.ts';
 import type { TelephonyEventInput } from './telephony-input.ts';
 import type { TvRemoteButton } from './tv-remote.ts';
 
@@ -88,7 +88,8 @@ export type BackCommandOptions = DeviceCommandBaseOptions & {
 export type HomeCommandOptions = DeviceCommandBaseOptions;
 
 export type OrientationCommandOptions = DeviceCommandBaseOptions & {
-  orientation: DeviceRotation;
+  /** A fixed rotation, or `auto` to hand rotation back to the sensor (ADB-backed Android only). */
+  orientation: OrientationRequest;
 };
 
 export type FoldCommandOptions = DeviceCommandBaseOptions & SetFoldPoseInput;
 
@@ -3,29 +3,29 @@ import {
   DEVICE_ROTATIONS,
   deviceRotationFromSurfaceIndex,
   isDeviceRotation,
-  parseDeviceRotation,
+  parseOrientationRequest,
 } from './device-rotation.ts';
 
-describe('parseDeviceRotation', () => {
+describe('parseOrientationRequest', () => {
   test('accepts the canonical orientation names', () => {
-    expect(parseDeviceRotation('portrait')).toBe('portrait');
-    expect(parseDeviceRotation('portrait-upside-down')).toBe('portrait-upside-down');
-    expect(parseDeviceRotation('landscape-left')).toBe('landscape-left');
-    expect(parseDeviceRotation('landscape-right')).toBe('landscape-right');
+    expect(parseOrientationRequest('portrait')).toBe('portrait');
+    expect(parseOrientationRequest('portrait-upside-down')).toBe('portrait-upside-down');
+    expect(parseOrientationRequest('landscape-left')).toBe('landscape-left');
+    expect(parseOrientationRequest('landscape-right')).toBe('landscape-right');
   });
 
   test('accepts the documented short aliases', () => {
-    expect(parseDeviceRotation('upside-down')).toBe('portrait-upside-down');
-    expect(parseDeviceRotation('left')).toBe('landscape-left');
-    expect(parseDeviceRotation('right')).toBe('landscape-right');
+    expect(parseOrientationRequest('upside-down')).toBe('portrait-upside-down');
+    expect(parseOrientationRequest('left')).toBe('landscape-left');
+    expect(parseOrientationRequest('right')).toBe('landscape-right');
   });
 
   test('is case-insensitive and trims surrounding whitespace', () => {
-    expect(parseDeviceRotation('  Landscape-LEFT ')).toBe('landscape-left');
+    expect(parseOrientationRequest('  Landscape-LEFT ')).toBe('landscape-left');
   });
 
   test('throws a helpful error when the orientation is missing', () => {
-    expect(() => parseDeviceRotation(undefined)).toThrow(
+    expect(() => parseOrientationRequest(undefined)).toThrow(
       expect.objectContaining({
         code: 'INVALID_ARGS',
         message: expect.stringContaining('orientation requires an orientation argument'),
@@ -34,13 +34,19 @@ describe('parseDeviceRotation', () => {
   });
 
   test('throws on an unrecognized orientation and echoes the bad input', () => {
-    expect(() => parseDeviceRotation('sideways')).toThrow(
+    expect(() => parseOrientationRequest('sideways')).toThrow(
       expect.objectContaining({
         code: 'INVALID_ARGS',
         message: expect.stringContaining('Invalid rotation: sideways'),
       }),
     );
   });
+
+  test('adds auto to the rotations and keeps it out of DeviceRotation', () => {
+    expect(parseOrientationRequest(' AUTO ')).toBe('auto');
+    expect(DEVICE_ROTATIONS).not.toContain('auto');
+    expect(isDeviceRotation('auto')).toBe(false);
+  });
 });
 
 describe('deviceRotationFromSurfaceIndex', () => {
 
@@ -45,7 +45,8 @@ export function deviceRotationOrientation(rotation: DeviceRotation): 'PORTRAIT'
   return DEVICE_ROTATION_SURFACE_INDEX[rotation] % 2 === 0 ? 'PORTRAIT' : 'LANDSCAPE';
 }
 
-export function parseDeviceRotation(input: string | undefined): DeviceRotation {
+/** The public entry for parsing one is `parseOrientationRequest`; this stays module-private. */
+function parseDeviceRotation(input: string | undefined): DeviceRotation {
   if (input === undefined) {
     throw new AppError(
       'INVALID_ARGS',
@@ -73,6 +74,14 @@ export function parseDeviceRotation(input: string | undefined): DeviceRotation {
   }
 }
 
+/** A rotation to lock the device in, or `auto` to hand rotation back to the sensor. */
+export const ORIENTATION_REQUESTS = [...DEVICE_ROTATIONS, 'auto'] as const;
+export type OrientationRequest = (typeof ORIENTATION_REQUESTS)[number];
+
+export function parseOrientationRequest(input: string | undefined): OrientationRequest {
+  return input?.trim().toLowerCase() === 'auto' ? 'auto' : parseDeviceRotation(input);
+}
+
 // ---- Hinge pose ------------------------------------------------------------------------------
 // Lives beside the rotation vocabulary because every entry that reads one device pose already
 // evaluates this module; a module of its own would join the eager closure of entries that can
 
@@ -43,7 +43,8 @@ export {
   deviceRotationSurfaceDegrees,
   foldPoseForHingeAngle,
   isDeviceRotation,
-  parseDeviceRotation,
+  ORIENTATION_REQUESTS,
+  parseOrientationRequest,
   parseFoldPose,
 } from '../device-rotation.ts';
 export {
@@ -56,6 +57,7 @@ export {
 } from '../telephony-input.ts';
 export type {
   DeviceRotation,
+  OrientationRequest,
   FoldPose,
   FoldKeyframe,
   FoldScreenCoordinateSpace,
 
@@ -27,6 +27,7 @@ const EXPECTATIONS: {
   back: { method: 'back', input: {} },
   home: { method: 'home', input: {} },
   setOrientation: { method: 'setOrientation', input: { rotation: 'portrait' } },
+  unlockOrientation: { method: 'unlockOrientation', input: {} },
   tvRemote: { method: 'tvRemote', input: { button: 'select' } },
   keyboardStatus: { method: 'keyboardStatus', input: {} },
   keyboardDismiss: { method: 'keyboardDismiss', input: {} },
 
@@ -8,7 +8,7 @@ import {
   bindClipboardWrite,
 } from './clipboard-runtime.ts';
 import { KEYBOARD_ACTION_LABELS, bindKeyboardAction } from './keyboard-runtime.ts';
-import { bindOrientation } from './orientation-runtime.ts';
+import { bindOrientation, bindOrientationUnlock } from './orientation-runtime.ts';
 import { bindReadSetting, bindSetSetting } from './settings-runtime.ts';
 import { TV_REMOTE_LABEL, bindTvRemote } from './tv-remote-runtime.ts';
 import {
@@ -62,6 +62,7 @@ export const INTERACTOR_OPERATIONS = [
     bind: (signal, resolve) => bindSystemButton('home', signal, resolve),
   },
   { operation: 'setOrientation', label: 'orientation', bind: bindOrientation },
+  { operation: 'unlockOrientation', label: 'orientation auto', bind: bindOrientationUnlock },
   { operation: 'tvRemote', label: TV_REMOTE_LABEL, bind: bindTvRemote },
   {
     operation: 'keyboardStatus',
 
@@ -404,6 +404,8 @@ export type Interactor = {
    */
   home?(): Promise<void>;
   setOrientation(orientation: DeviceRotation): Promise<{ orientation?: DeviceRotation } | void>;
+  /** Hands rotation back to the sensor; only an owner whose `setOrientation` locks it carries this. */
+  unlockOrientation?(): Promise<void>;
   performGesture?(plan: GesturePlan): Promise<Record<string, unknown> | void>;
   /**
    * Optional (parity with `home`): opens the recents surface, a control not every owner carries.
 
@@ -15,6 +15,15 @@ test('builds the exact orientation operation fact catalog', () => {
   const orientation = { available: true } as const;
   expect(orientationRuntimeOperationFacts({ orientation })).toEqual({
     setOrientation: orientation,
+    unlockOrientation: {
+      available: false,
+      reason: 'unsupported-platform-leaf',
+      hint: 'orientation auto is only supported on ADB-backed Android.',
+    },
+  });
+  expect(orientationRuntimeOperationFacts({ orientation, unlock: orientation })).toEqual({
+    setOrientation: orientation,
+    unlockOrientation: orientation,
   });
 });
 
 
@@ -5,7 +5,7 @@ import type { SnapshotRuntimeExecution } from './snapshot-runtime.ts';
 
 /**
  * Neutral intent for one orientation change. `rotation` is already parsed by the caller
- * (`parseDeviceRotation`); the operation names no command, request, session, or CLI flag.
+ * (`parseOrientationRequest`); the operation names no command, request, session, or CLI flag.
  */
 export type SetOrientationInput = Readonly<{
   rotation: DeviceRotation;
@@ -22,16 +22,28 @@ export type SetOrientationResult = Readonly<{ orientation?: DeviceRotation }>;
 
 export type OrientationRuntimeOperations = Readonly<{
   setOrientation(input: SetOrientationInput): Promise<SetOrientationResult | void>;
+  unlockOrientation(input: Omit<SetOrientationInput, 'rotation'>): Promise<void>;
 }>;
 
 export type OrientationRuntimeOperationFacts = Readonly<{
   setOrientation: RuntimeOperationFact;
+  unlockOrientation: RuntimeOperationFact;
 }>;
 
+const unlockUnavailable = Object.freeze({
+  available: false,
+  reason: 'unsupported-platform-leaf',
+  hint: 'orientation auto is only supported on ADB-backed Android.',
+} as const);
+
+/** An owner that leaves `unlock` undeclared refuses `orientation auto`. */
 export function orientationRuntimeOperationFacts(
-  input: Readonly<{ orientation: RuntimeOperationFact }>,
+  input: Readonly<{ orientation: RuntimeOperationFact; unlock?: RuntimeOperationFact }>,
 ): OrientationRuntimeOperationFacts {
-  return Object.freeze({ setOrientation: input.orientation });
+  return Object.freeze({
+    setOrientation: input.orientation,
+    unlockOrientation: input.unlock ?? unlockUnavailable,
+  });
 }
 
 /**
@@ -42,7 +54,7 @@ export function orientationRuntimeOperationFacts(
 export function bindOrientation(
   signal: AbortSignal,
   resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
-): OrientationRuntimeOperations {
+): Pick<OrientationRuntimeOperations, 'setOrientation'> {
   return Object.freeze({
     setOrientation: async (input: SetOrientationInput) => {
       signal.throwIfAborted();
@@ -55,3 +67,23 @@ export function bindOrientation(
     },
   });
 }
+
+export function bindOrientationUnlock(
+  signal: AbortSignal,
+  resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
+): Pick<OrientationRuntimeOperations, 'unlockOrientation'> {
+  return Object.freeze({
+    unlockOrientation: async (input: Omit<SetOrientationInput, 'rotation'>) => {
+      signal.throwIfAborted();
+      const interactor = await resolveInteractor({
+        ...input.execution,
+        appBundleId: input.options?.appBundleId,
+        signal,
+      });
+      const { requireInteractorMethod } = await import('./interactor-operation-binding.ts');
+      await requireInteractorMethod(interactor.unlockOrientation, 'orientation auto').call(
+        interactor,
+      );
+    },
+  });
+}