diff --git a/packages/command-registry/src/registry.ts b/packages/command-registry/src/registry.ts
index f8a8e4eda5..343659e975 100644
--- a/packages/command-registry/src/registry.ts
+++ b/packages/command-registry/src/registry.ts
@@ -1646,10 +1646,10 @@ export const RAW_COMMAND_DESCRIPTORS = [
     ...(ownerFilesEnabled ? { ownerFiles: ['src/commands/system/index.ts'] as const } : {}),
     catalog: { group: 'public', key: 'hardwareButton' },
     frameworkTier: 'extended',
-    // The first positional selects the cell (volume-up, volume-down, power), the way `orientation`
-    // selects between setOrientation and unlockOrientation; admission binds exactly that one fact.
-    // Like action-button, no post-action observation is declared: the press goes to the system,
-    // not the session app, and settling would re-capture the app the press leaves alone (#3848).
+    // The first positional selects one of the eleven named keys, the way `orientation` selects
+    // between setOrientation and unlockOrientation; admission binds exactly that one fact. Like
+    // action-button, no post-action observation is declared: the press goes to the system, not
+    // the session app, and settling would re-capture the app the press leaves alone (#3848).
     ...GENERIC_MUTATING_COMMAND_TRAITS,
     platformExecution: { kind: 'device-runtime', uses: hardwareButtonRuntimePlanUses },
   },
diff --git a/packages/contracts/src/device-rotation.ts b/packages/contracts/src/device-rotation.ts
index 629e21e13c..ae7bdc93ca 100644
--- a/packages/contracts/src/device-rotation.ts
+++ b/packages/contracts/src/device-rotation.ts
@@ -100,16 +100,40 @@ export function parseOrientationRequest(input: string | undefined): OrientationR
  * Each name is a cell of {@link SYSTEM_BUTTONS}; system-button-runtime.ts checks that at
  * compile time. The cells stay module-internal: consumers select a button by its public name.
  */
-const HARDWARE_BUTTONS = ['volumeUp', 'volumeDown', 'power'] as const;
+const HARDWARE_BUTTONS = [
+  'volumeUp',
+  'volumeDown',
+  'power',
+  'mute',
+  'sleep',
+  'wake',
+  'mediaPlayPause',
+  'mediaNext',
+  'mediaPrevious',
+  'mediaRewind',
+  'mediaFastForward',
+] as const;
 
 export type HardwareButton = (typeof HARDWARE_BUTTONS)[number];
 
 /**
- * The public positional names of the hardware keys: `volume-up`, `volume-down`, `power`.
- * The literals are the same ones SYSTEM_BUTTON_LABELS carries for these buttons; the label
- * owner's type-level check and the contracts tests refuse drift between the two lists.
+ * The public positional names of the hardware keys: the volume/power/mute keys, the explicit
+ * sleep and wake events, and the five media keys. The literals are the same ones
+ * SYSTEM_BUTTON_LABELS carries for these buttons; the label owner's type-level check and the
+ * contracts tests refuse drift between the two lists.
  */
-export type HardwareButtonName = 'volume-up' | 'volume-down' | 'power';
+export type HardwareButtonName =
+  | 'volume-up'
+  | 'volume-down'
+  | 'power'
+  | 'mute'
+  | 'sleep'
+  | 'wake'
+  | 'media-play-pause'
+  | 'media-next'
+  | 'media-previous'
+  | 'media-rewind'
+  | 'media-fast-forward';
 
 /**
  * The accepted positional values, in command order. `satisfies` turns an out-of-vocabulary
@@ -119,6 +143,14 @@ export const HARDWARE_BUTTON_NAMES = [
   'volume-up',
   'volume-down',
   'power',
+  'mute',
+  'sleep',
+  'wake',
+  'media-play-pause',
+  'media-next',
+  'media-previous',
+  'media-rewind',
+  'media-fast-forward',
 ] as const satisfies readonly HardwareButtonName[];
 
 /** The CLI synopsis tail naming the accepted positional names. */
@@ -134,6 +166,14 @@ export const HARDWARE_BUTTON_NAME_LABELS = {
   volumeUp: 'volume-up',
   volumeDown: 'volume-down',
   power: 'power',
+  mute: 'mute',
+  sleep: 'sleep',
+  wake: 'wake',
+  mediaPlayPause: 'media-play-pause',
+  mediaNext: 'media-next',
+  mediaPrevious: 'media-previous',
+  mediaRewind: 'media-rewind',
+  mediaFastForward: 'media-fast-forward',
 } as const satisfies Record<HardwareButton, HardwareButtonName>;
 
 const HARDWARE_BUTTON_NAME_MAP: ReadonlyMap<HardwareButtonName, HardwareButton> = new Map(
diff --git a/packages/contracts/src/interactor-operation-catalog-conformance.test.ts b/packages/contracts/src/interactor-operation-catalog-conformance.test.ts
index 14d38343af..ebb019c7ee 100644
--- a/packages/contracts/src/interactor-operation-catalog-conformance.test.ts
+++ b/packages/contracts/src/interactor-operation-catalog-conformance.test.ts
@@ -39,6 +39,14 @@ const EXPECTATIONS: {
   volumeUp: { method: 'volumeUp', input: {} },
   volumeDown: { method: 'volumeDown', input: {} },
   power: { method: 'power', input: {} },
+  mute: { method: 'mute', input: {} },
+  sleep: { method: 'sleep', input: {} },
+  wake: { method: 'wake', input: {} },
+  mediaPlayPause: { method: 'mediaPlayPause', input: {} },
+  mediaNext: { method: 'mediaNext', input: {} },
+  mediaPrevious: { method: 'mediaPrevious', input: {} },
+  mediaRewind: { method: 'mediaRewind', input: {} },
+  mediaFastForward: { method: 'mediaFastForward', input: {} },
   triggerAppEvent: { method: 'open', input: { eventUrl: 'myapp://x' } },
   setSetting: {
     method: 'setSetting',
diff --git a/packages/contracts/src/interactor-operation-catalog.ts b/packages/contracts/src/interactor-operation-catalog.ts
index f77a73f229..fb0adaaebb 100644
--- a/packages/contracts/src/interactor-operation-catalog.ts
+++ b/packages/contracts/src/interactor-operation-catalog.ts
@@ -114,6 +114,46 @@ export const INTERACTOR_OPERATIONS = [
     label: SYSTEM_BUTTON_LABELS.power,
     bind: (signal, resolve) => bindSystemButton('power', signal, resolve),
   },
+  {
+    operation: 'mute',
+    label: SYSTEM_BUTTON_LABELS.mute,
+    bind: (signal, resolve) => bindSystemButton('mute', signal, resolve),
+  },
+  {
+    operation: 'sleep',
+    label: SYSTEM_BUTTON_LABELS.sleep,
+    bind: (signal, resolve) => bindSystemButton('sleep', signal, resolve),
+  },
+  {
+    operation: 'wake',
+    label: SYSTEM_BUTTON_LABELS.wake,
+    bind: (signal, resolve) => bindSystemButton('wake', signal, resolve),
+  },
+  {
+    operation: 'mediaPlayPause',
+    label: SYSTEM_BUTTON_LABELS.mediaPlayPause,
+    bind: (signal, resolve) => bindSystemButton('mediaPlayPause', signal, resolve),
+  },
+  {
+    operation: 'mediaNext',
+    label: SYSTEM_BUTTON_LABELS.mediaNext,
+    bind: (signal, resolve) => bindSystemButton('mediaNext', signal, resolve),
+  },
+  {
+    operation: 'mediaPrevious',
+    label: SYSTEM_BUTTON_LABELS.mediaPrevious,
+    bind: (signal, resolve) => bindSystemButton('mediaPrevious', signal, resolve),
+  },
+  {
+    operation: 'mediaRewind',
+    label: SYSTEM_BUTTON_LABELS.mediaRewind,
+    bind: (signal, resolve) => bindSystemButton('mediaRewind', signal, resolve),
+  },
+  {
+    operation: 'mediaFastForward',
+    label: SYSTEM_BUTTON_LABELS.mediaFastForward,
+    bind: (signal, resolve) => bindSystemButton('mediaFastForward', signal, resolve),
+  },
   { operation: 'triggerAppEvent', label: 'trigger-app-event', bind: bindAppEvent },
   { operation: 'setSetting', label: 'settings', bind: bindSetSetting },
   { operation: 'readSetting', label: 'settings read', bind: bindReadSetting },
diff --git a/packages/contracts/src/interactor-types.ts b/packages/contracts/src/interactor-types.ts
index 526ee07c2d..56f63587c4 100644
--- a/packages/contracts/src/interactor-types.ts
+++ b/packages/contracts/src/interactor-types.ts
@@ -451,6 +451,34 @@ export type Interactor = {
    * it; an owner without it leaves it undefined and its fact refuses before binding.
    */
   power?(): Promise<void>;
+  /**
+   * Optional (parity with `volumeUp`): presses the media mute key once. Android-only today:
+   * Apple exposes no public mute press, so no Apple leaf carries it.
+   */
+  mute?(): Promise<void>;
+  /**
+   * Optional (parity with `volumeUp`): sends the explicit Android sleep event (KEYCODE_SLEEP),
+   * which turns the screen off without toggling the way `power` does.
+   */
+  sleep?(): Promise<void>;
+  /**
+   * Optional (parity with `volumeUp`): sends the explicit Android wake event (KEYCODE_WAKEUP),
+   * which turns the screen on without toggling the way `power` does.
+   */
+  wake?(): Promise<void>;
+  /**
+   * Optional (parity with `volumeUp`): presses the media play/pause key once. The press goes to
+   * whatever media session the OS routes it to; it does not claim playback started.
+   */
+  mediaPlayPause?(): Promise<void>;
+  /** Optional (parity with `mediaPlayPause`): presses the media next key once. */
+  mediaNext?(): Promise<void>;
+  /** Optional (parity with `mediaPlayPause`): presses the media previous key once. */
+  mediaPrevious?(): Promise<void>;
+  /** Optional (parity with `mediaPlayPause`): presses the media rewind key once. */
+  mediaRewind?(): Promise<void>;
+  /** Optional (parity with `mediaPlayPause`): presses the media fast-forward key once. */
+  mediaFastForward?(): Promise<void>;
   /** Optional: only Android implements a live status read (see {@link KeyboardStatusResult}). */
   keyboardStatus?(): Promise<KeyboardStatusResult>;
   /** Optional: platforms with no keyboard-dismiss concept leave it undefined. */
diff --git a/packages/contracts/src/navigation.ts b/packages/contracts/src/navigation.ts
index 8c2e998c51..b8a0137142 100644
--- a/packages/contracts/src/navigation.ts
+++ b/packages/contracts/src/navigation.ts
@@ -93,9 +93,9 @@ export type TvRemoteCommandResult = {
 /**
  * `hardware-button` — `{ action: 'hardware-button', button, message: 'Pressed hardware button <button>' }`.
  *
- * The button is the public name (`volume-up`, `volume-down`, `power`). The result reports that the
- * press was dispatched; it carries no volume level or screen state, because the command observes
- * neither (#3848).
+ * The button is the public name (`volume-up`, `volume-down`, `power`, `mute`, `sleep`, `wake`, or
+ * one of the five media names). The result reports that the press was dispatched; it carries no
+ * volume level, mute state, or screen state, because the command observes none of them (#3848).
  */
 export type HardwareButtonCommandResult = {
   action: 'hardware-button';
diff --git a/packages/contracts/src/platform-runtime-operations.ts b/packages/contracts/src/platform-runtime-operations.ts
index b5c6f0b06a..5e604a5e4d 100644
--- a/packages/contracts/src/platform-runtime-operations.ts
+++ b/packages/contracts/src/platform-runtime-operations.ts
@@ -128,14 +128,30 @@ export const keyboardEnterUse = defineUse({ required: ['keyboardEnter'] });
 export const appSwitcherRuntimeUse = defineUse({ required: ['appSwitcher'] });
 export const actionButtonRuntimeUse = defineUse({ required: ['actionButton'] });
 // `hardware-button`'s cells (ADR 0019 §9): the daemon admits and binds exactly the one the parsed
-// positional names, never all three (#3848).
+// positional names, never all of them (#3848).
 export const volumeUpRuntimeUse = defineUse({ required: ['volumeUp'] });
 export const volumeDownRuntimeUse = defineUse({ required: ['volumeDown'] });
 export const powerRuntimeUse = defineUse({ required: ['power'] });
+export const muteRuntimeUse = defineUse({ required: ['mute'] });
+export const sleepRuntimeUse = defineUse({ required: ['sleep'] });
+export const wakeRuntimeUse = defineUse({ required: ['wake'] });
+export const mediaPlayPauseRuntimeUse = defineUse({ required: ['mediaPlayPause'] });
+export const mediaNextRuntimeUse = defineUse({ required: ['mediaNext'] });
+export const mediaPreviousRuntimeUse = defineUse({ required: ['mediaPrevious'] });
+export const mediaRewindRuntimeUse = defineUse({ required: ['mediaRewind'] });
+export const mediaFastForwardRuntimeUse = defineUse({ required: ['mediaFastForward'] });
 export const hardwareButtonRuntimePlanUses = Object.freeze([
   volumeUpRuntimeUse,
   volumeDownRuntimeUse,
   powerRuntimeUse,
+  muteRuntimeUse,
+  sleepRuntimeUse,
+  wakeRuntimeUse,
+  mediaPlayPauseRuntimeUse,
+  mediaNextRuntimeUse,
+  mediaPreviousRuntimeUse,
+  mediaRewindRuntimeUse,
+  mediaFastForwardRuntimeUse,
 ] as const);
 export const appEventRuntimeUse = defineUse({ required: ['triggerAppEvent'] });
 export const settingsRuntimeUse = defineUse({ required: ['setSetting'] });
diff --git a/packages/contracts/src/runtime-operation-names.ts b/packages/contracts/src/runtime-operation-names.ts
index 56c04b52c8..d5048e2f73 100644
--- a/packages/contracts/src/runtime-operation-names.ts
+++ b/packages/contracts/src/runtime-operation-names.ts
@@ -50,6 +50,12 @@ export const RUNTIME_OPERATION_NAMES = [
   'listApps',
   'longPressPoint',
   'materializeAppSource',
+  'mediaFastForward',
+  'mediaNext',
+  'mediaPlayPause',
+  'mediaPrevious',
+  'mediaRewind',
+  'mute',
   'networkDump',
   'openApplication',
   'perfFrames',
@@ -83,6 +89,7 @@ export const RUNTIME_OPERATION_NAMES = [
   'setSetting',
   'setViewport',
   'shutdownTarget',
+  'sleep',
   'tapElementSelector',
   'tapPoint',
   'tapRef',
@@ -93,6 +100,7 @@ export const RUNTIME_OPERATION_NAMES = [
   'unlockOrientation',
   'volumeDown',
   'volumeUp',
+  'wake',
   'writeClipboard',
 ] as const;
 
diff --git a/packages/contracts/src/system-button-runtime.test.ts b/packages/contracts/src/system-button-runtime.test.ts
index 21e1cdac55..b18c2b0f80 100644
--- a/packages/contracts/src/system-button-runtime.test.ts
+++ b/packages/contracts/src/system-button-runtime.test.ts
@@ -5,7 +5,7 @@ import { HARDWARE_BUTTON_NAMES, parseHardwareButtonPositionals } from './device-
 import {
   SYSTEM_BUTTONS,
   SYSTEM_BUTTON_LABELS,
-  androidHardwareButtonAvailability,
+  androidHardwareButtonFacts,
   bindSystemButton,
   systemButtonRuntimeOperationFacts,
 } from './system-button-runtime.ts';
@@ -21,6 +21,8 @@ const available = { available: true } as const;
 const unsupported = { available: false, reason: 'unsupported-platform-leaf' } as const;
 
 test('an omitted button reports the family denial, a named one its own cell', () => {
+  // Every family cell must be named by an owner or take the denial: this full-object equality
+  // enumerates all of them, so a new cell that changes the family builder's shape fails here.
   expect(systemButtonRuntimeOperationFacts({ unsupported, home: available })).toEqual({
     home: available,
     appSwitcher: unsupported,
@@ -28,15 +30,18 @@ test('an omitted button reports the family denial, a named one its own cell', ()
     volumeUp: unsupported,
     volumeDown: unsupported,
     power: unsupported,
+    mute: unsupported,
+    sleep: unsupported,
+    wake: unsupported,
+    mediaPlayPause: unsupported,
+    mediaNext: unsupported,
+    mediaPrevious: unsupported,
+    mediaRewind: unsupported,
+    mediaFastForward: unsupported,
   });
-  expect(systemButtonRuntimeOperationFacts({ unsupported })).toEqual({
-    home: unsupported,
-    appSwitcher: unsupported,
-    actionButton: unsupported,
-    volumeUp: unsupported,
-    volumeDown: unsupported,
-    power: unsupported,
-  });
+  const allDenied = systemButtonRuntimeOperationFacts({ unsupported });
+  expect(Object.keys(allDenied).sort()).toEqual([...SYSTEM_BUTTONS].sort());
+  for (const button of SYSTEM_BUTTONS) expect(allDenied[button]).toEqual(unsupported);
 });
 
 test.each(SYSTEM_BUTTONS)(
@@ -91,16 +96,17 @@ test('the hardware-button vocabulary is exhaustive over the family cells and par
     ),
   ).toEqual([...HARDWARE_BUTTON_NAMES]);
   expect(
-    [...HARDWARE_BUTTON_NAMES].map((name) => parseHardwareButtonPositionals([name])).sort(),
-  ).toEqual(['power', 'volumeDown', 'volumeUp']);
+    new Set([...HARDWARE_BUTTON_NAMES].map((name) => parseHardwareButtonPositionals([name]))).size,
+  ).toBe(HARDWARE_BUTTON_NAMES.length);
+  expect(HARDWARE_BUTTON_NAMES.length).toBe(11);
   expect(parseHardwareButtonPositionals(['volume-up'])).toBe('volumeUp');
   expect(parseHardwareButtonPositionals(['Volume-Down'])).toBe('volumeDown');
-  expect(parseHardwareButtonPositionals(['power'])).toBe('power');
-  for (const name of ['', 'vol', 'mute', 'home', undefined] as const) {
+  expect(parseHardwareButtonPositionals(['media-fast-forward'])).toBe('mediaFastForward');
+  for (const name of ['', 'vol', 'media', 'media-pause', 'home', undefined] as const) {
     expect(() => parseHardwareButtonPositionals([name as string])).toThrowError(
       expect.objectContaining({
         code: 'INVALID_ARGS',
-        message: 'hardware-button button must be one of: volume-up, volume-down, power.',
+        message: `hardware-button button must be one of: ${HARDWARE_BUTTON_NAMES.join(', ')}.`,
       }),
     );
   }
@@ -114,31 +120,47 @@ test('the hardware-button positional helper enforces arity and the exact-name pa
     expect(() => parseHardwareButtonPositionals(positionals)).toThrowError(
       expect.objectContaining({
         code: 'INVALID_ARGS',
-        message: 'hardware-button requires exactly one button: volume-up, volume-down, power.',
+        message: `hardware-button requires exactly one button: ${HARDWARE_BUTTON_NAMES.join(', ')}.`,
       }),
     );
   }
-  expect(() => parseHardwareButtonPositionals(['mute'])).toThrowError(
+  expect(() => parseHardwareButtonPositionals(['media'])).toThrowError(
     expect.objectContaining({ code: 'INVALID_ARGS' }),
   );
+  // Every extended name parses to its own cell, the way the original three do.
+  for (const [name, cell] of [
+    ['mute', 'mute'],
+    ['sleep', 'sleep'],
+    ['wake', 'wake'],
+    ['media-play-pause', 'mediaPlayPause'],
+    ['media-next', 'mediaNext'],
+    ['media-previous', 'mediaPrevious'],
+    ['media-rewind', 'mediaRewind'],
+    ['media-fast-forward', 'mediaFastForward'],
+  ] as const) {
+    expect(parseHardwareButtonPositionals([name])).toBe(cell);
+  }
 });
 
 // The Android hardware-button admission rule both Android owners share: a phone or tablet
-// answers available, a TV target refuses toward tv-remote, and the synthetic simulator row has
-// no device behind it (#3848).
+// answers available for every declared cell, a TV target refuses toward tv-remote, and the
+// synthetic simulator row has no device behind it (#3848).
 test('the shared Android hardware-button rule admits phones and refuses TV and simulator', () => {
-  expect(androidHardwareButtonAvailability({ kind: 'emulator' })).toEqual({ available: true });
-  expect(androidHardwareButtonAvailability({ kind: 'mobile', target: 'phone' })).toEqual({
-    available: true,
-  });
-  expect(androidHardwareButtonAvailability({ kind: 'mobile', target: 'tv' })).toEqual(
+  const cells = HARDWARE_BUTTON_NAMES.map((name) => parseHardwareButtonPositionals([name]));
+  const phone = androidHardwareButtonFacts({ kind: 'mobile', target: 'phone' });
+  for (const cell of cells) {
+    expect(phone[cell]).toEqual({ available: true });
+  }
+  const tv = androidHardwareButtonFacts({ kind: 'mobile', target: 'tv' });
+  expect(tv.power).toEqual(
     expect.objectContaining({
       available: false,
       reason: 'unsupported-device-kind',
       hint: 'hardware-button is not supported on Android TV targets; use tv-remote.',
     }),
   );
-  expect(androidHardwareButtonAvailability({ kind: 'simulator' })).toEqual(
+  const synthetic = androidHardwareButtonFacts({ kind: 'simulator' });
+  expect(synthetic.mute).toEqual(
     expect.objectContaining({
       available: false,
       reason: 'unsupported-device-kind',
diff --git a/packages/contracts/src/system-button-runtime.ts b/packages/contracts/src/system-button-runtime.ts
index 4752300e08..957495fe35 100644
--- a/packages/contracts/src/system-button-runtime.ts
+++ b/packages/contracts/src/system-button-runtime.ts
@@ -7,9 +7,10 @@ import type { SnapshotRuntimeExecution } from './snapshot-runtime.ts';
 /**
  * The system buttons: one press each, no arguments, nothing returned. `home` and `appSwitcher`
  * reach a springboard or recents surface; `actionButton` presses iPhone/iPad hardware;
- * `volumeUp`, `volumeDown` and `power` press the phone hardware keys the `hardware-button`
- * command names. What varies between them is which owners carry the control, and that is the
- * fact table's job, not a per-button module's: a button joins this list and its owners state a cell.
+ * the rest are the phone hardware keys the `hardware-button` command names — volume, power,
+ * mute, the explicit sleep/wake events, and the media keys. What varies between them is which
+ * owners carry the control, and that is the fact table's job, not a per-button module's: a
+ * button joins this list and its owners state a cell.
  */
 export const SYSTEM_BUTTONS = [
   'home',
@@ -18,11 +19,22 @@ export const SYSTEM_BUTTONS = [
   'volumeUp',
   'volumeDown',
   'power',
+  'mute',
+  'sleep',
+  'wake',
+  'mediaPlayPause',
+  'mediaNext',
+  'mediaPrevious',
+  'mediaRewind',
+  'mediaFastForward',
 ] as const;
 
 export type SystemButton = (typeof SYSTEM_BUTTONS)[number];
 
-/** How a provider fail-closed refusal names each button to the caller. */
+/**
+ * What the family names to a caller on a fail-closed refusal. The hardware keys read as the
+ * positional names `hardware-button` takes.
+ */
 export const SYSTEM_BUTTON_LABELS = {
   home: 'home',
   appSwitcher: 'app-switcher',
@@ -30,6 +42,14 @@ export const SYSTEM_BUTTON_LABELS = {
   volumeUp: 'volume-up',
   volumeDown: 'volume-down',
   power: 'power',
+  mute: 'mute',
+  sleep: 'sleep',
+  wake: 'wake',
+  mediaPlayPause: 'media-play-pause',
+  mediaNext: 'media-next',
+  mediaPrevious: 'media-previous',
+  mediaRewind: 'media-rewind',
+  mediaFastForward: 'media-fast-forward',
 } as const satisfies Record<SystemButton, string>;
 
 // The hardware-button command vocabulary in device-rotation.ts must stay a family sub-cell with
@@ -124,7 +144,32 @@ const androidHardwareButtonKindUnavailable: RuntimeOperationUnavailability = Obj
 
 const ANDROID_AVAILABLE = Object.freeze({ available: true } as const);
 
-export function androidHardwareButtonAvailability(
+const ANDROID_HARDWARE_BUTTON_CELLS = SYSTEM_BUTTONS.filter(
+  (button) => button !== 'home' && button !== 'appSwitcher' && button !== 'actionButton',
+) satisfies readonly HardwareButton[];
+
+type HardwareCellsCoverCommandVocabulary =
+  HardwareButton extends (typeof ANDROID_HARDWARE_BUTTON_CELLS)[number]
+    ? true
+    : { missingFromCells: Exclude<HardwareButton, (typeof ANDROID_HARDWARE_BUTTON_CELLS)[number]> };
+const hardwareCellsCoverCommandVocabulary: HardwareCellsCoverCommandVocabulary = true;
+void hardwareCellsCoverCommandVocabulary;
+
+/**
+ * One device's verdict for every `hardware-button` cell. The local adb runtime and the Limrun
+ * provider spread this over their family facts, so the phone/TV/simulator rule is stated once
+ * for every key and a new key joins both owners with it.
+ */
+export function androidHardwareButtonFacts(
+  device: AndroidHardwareButtonSubject,
+): Readonly<Record<HardwareButton, RuntimeOperationFact>> {
+  const availability = androidHardwareButtonAvailability(device);
+  const facts: Partial<Record<HardwareButton, RuntimeOperationFact>> = {};
+  for (const button of ANDROID_HARDWARE_BUTTON_CELLS) facts[button] = availability;
+  return facts as Readonly<Record<HardwareButton, RuntimeOperationFact>>;
+}
+
+function androidHardwareButtonAvailability(
   device: AndroidHardwareButtonSubject,
 ): RuntimeOperationFact {
   if (device.kind === 'simulator') return androidHardwareButtonKindUnavailable;
diff --git a/packages/daemon/src/__tests__/support/runtime-binding-conformance.ts b/packages/daemon/src/__tests__/support/runtime-binding-conformance.ts
index 57c4b2fd99..31c472ab15 100644
--- a/packages/daemon/src/__tests__/support/runtime-binding-conformance.ts
+++ b/packages/daemon/src/__tests__/support/runtime-binding-conformance.ts
@@ -12,6 +12,11 @@ import {
   commandDescriptors,
   commandRuntimeUseRequirements,
 } from '@agent-device/command-registry/registry';
+import {
+  HARDWARE_BUTTON_NAMES,
+  parseHardwareButtonPositionals,
+  type HardwareButtonName,
+} from '@agent-device/contracts/device';
 import { createUnavailableRuntimeFactsForTest } from '@agent-device/test-kit';
 import { makeSession } from './session-factories.ts';
 import { makeSessionStore } from './store-factory.ts';
@@ -98,6 +103,43 @@ function systemButtonConformedBindings(): Record<SystemButtonCommand, ConformedR
   ) as Record<SystemButtonCommand, ConformedRuntimeBinding>;
 }
 
+/**
+ * Each `hardware-button` name is its own admission cell on the one `hardware-button` descriptor
+ * (#3848), so each owes its own refusal row, the way `orientation auto` does. Derived from the
+ * command vocabulary so every declared name — and any future one — proves its own refusal.
+ */
+type HardwareButtonConformedKey = `hardware-button ${HardwareButtonName}`;
+
+function hardwareButtonConformedBindings(): Record<
+  HardwareButtonConformedKey,
+  ConformedRuntimeBinding
+> {
+  const row = (name: HardwareButtonName): [HardwareButtonConformedKey, ConformedRuntimeBinding] => {
+    return [
+      `hardware-button ${name}`,
+      {
+        plan: {
+          refused: parseHardwareButtonPositionals([name]) as RuntimeOperation,
+          admitted: [],
+          command: 'hardware-button',
+        },
+        resolve: async (device, bindings) =>
+          refusable(
+            await resolveBoundSystemButtonRuntime('hardware-button', {
+              device,
+              positionals: [name],
+              ...bindings,
+            }),
+          ),
+      },
+    ];
+  };
+  return Object.fromEntries(HARDWARE_BUTTON_NAMES.map(row)) as Record<
+    HardwareButtonConformedKey,
+    ConformedRuntimeBinding
+  >;
+}
+
 /**
  * Every daemon route whose refusal on an unavailable exact-owner fact is proven through the shared
  * conformance helper, keyed by registry command name. `runtime-binding-conformance-completeness`
@@ -157,41 +199,7 @@ export const conformedRuntimeBindings = {
         }),
       ),
   },
-  // Each `hardware-button` name is its own admission cell on the one `hardware-button`
-  // descriptor (#3848), so each owes its own refusal row, the way `orientation auto` does.
-  'hardware-button': {
-    plan: { refused: 'volumeUp', admitted: [] },
-    resolve: async (device, bindings) =>
-      refusable(
-        await resolveBoundSystemButtonRuntime('hardware-button', {
-          device,
-          positionals: ['volume-up'],
-          ...bindings,
-        }),
-      ),
-  },
-  'hardware-button volume-down': {
-    plan: { refused: 'volumeDown', admitted: [], command: 'hardware-button' },
-    resolve: async (device, bindings) =>
-      refusable(
-        await resolveBoundSystemButtonRuntime('hardware-button', {
-          device,
-          positionals: ['volume-down'],
-          ...bindings,
-        }),
-      ),
-  },
-  'hardware-button power': {
-    plan: { refused: 'power', admitted: [], command: 'hardware-button' },
-    resolve: async (device, bindings) =>
-      refusable(
-        await resolveBoundSystemButtonRuntime('hardware-button', {
-          device,
-          positionals: ['power'],
-          ...bindings,
-        }),
-      ),
-  },
+  ...hardwareButtonConformedBindings(),
   'tv-remote': {
     resolve: async (device, bindings) =>
       refusable(await resolveBoundTvRemoteRuntime({ device, positionals: ['down'], ...bindings })),
diff --git a/packages/daemon/src/core/runtime-operation-effects.ts b/packages/daemon/src/core/runtime-operation-effects.ts
index a11ded7f1d..eb9c80e425 100644
--- a/packages/daemon/src/core/runtime-operation-effects.ts
+++ b/packages/daemon/src/core/runtime-operation-effects.ts
@@ -57,6 +57,12 @@ export const RUNTIME_OPERATION_EFFECTS: Readonly<
   listApps: 'repeatable',
   longPressPoint: 'mutates',
   materializeAppSource: 'repeatable',
+  mediaFastForward: 'mutates',
+  mediaNext: 'mutates',
+  mediaPlayPause: 'mutates',
+  mediaPrevious: 'mutates',
+  mediaRewind: 'mutates',
+  mute: 'mutates',
   networkDump: 'repeatable',
   openApplication: 'mutates',
   perfFrames: 'repeatable',
@@ -90,6 +96,7 @@ export const RUNTIME_OPERATION_EFFECTS: Readonly<
   setSetting: 'mutates',
   setViewport: 'mutates',
   shutdownTarget: 'mutates',
+  sleep: 'mutates',
   tapElementSelector: 'mutates',
   tapPoint: 'mutates',
   tapRef: 'mutates',
@@ -100,5 +107,6 @@ export const RUNTIME_OPERATION_EFFECTS: Readonly<
   unlockOrientation: 'mutates',
   volumeDown: 'mutates',
   volumeUp: 'mutates',
+  wake: 'mutates',
   writeClipboard: 'mutates',
 });
diff --git a/packages/daemon/src/execution/__tests__/system-button-runtime.test.ts b/packages/daemon/src/execution/__tests__/system-button-runtime.test.ts
index b6bd25e876..640e7f38b6 100644
--- a/packages/daemon/src/execution/__tests__/system-button-runtime.test.ts
+++ b/packages/daemon/src/execution/__tests__/system-button-runtime.test.ts
@@ -14,9 +14,23 @@ import {
   actionButtonRuntimeUse,
   appSwitcherRuntimeUse,
   homeRuntimeUse,
+  mediaFastForwardRuntimeUse,
+  mediaNextRuntimeUse,
+  mediaPlayPauseRuntimeUse,
+  mediaPreviousRuntimeUse,
+  mediaRewindRuntimeUse,
+  muteRuntimeUse,
+  powerRuntimeUse,
+  sleepRuntimeUse,
+  volumeDownRuntimeUse,
   volumeUpRuntimeUse,
+  wakeRuntimeUse,
   type PlatformRuntimeOperations,
 } from '@agent-device/contracts/platform-runtime-operations';
+import {
+  HARDWARE_BUTTON_NAMES,
+  parseHardwareButtonPositionals,
+} from '@agent-device/contracts/device';
 import type { SystemButton } from '@agent-device/contracts/system-button-runtime';
 import { deviceShape, type DeviceInfo } from '@agent-device/kernel/device';
 import { makeSession } from '../../__tests__/support/session-factories.ts';
@@ -61,6 +75,14 @@ const iosSimulator = {
   target: 'mobile',
   booted: true,
 } as const;
+const androidPhone = {
+  id: 'system-button-runtime-android-phone',
+  name: 'Pixel',
+  platform: 'android',
+  kind: 'emulator',
+  target: 'mobile',
+  booted: true,
+} as const;
 const available = Object.freeze({ available: true } as const);
 const unavailable = Object.freeze({
   available: false,
@@ -120,18 +142,22 @@ function executionParams(
   };
 }
 
-function runtimeHarness(button: SystemButton, fact: RuntimeOperationFact = available) {
+function runtimeHarness(
+  button: SystemButton,
+  fact: RuntimeOperationFact = available,
+  device: DeviceInfo = iosSimulator,
+) {
   const press = vi.fn(async () => undefined);
   const facts: RuntimeFacts<PlatformRuntimeOperations> = {
-    device: { ...deviceShape(iosSimulator), providerMode: 'local' },
+    device: { ...deviceShape(device), providerMode: 'local' },
     operations: systemButtonRuntimeOperationFacts({
       unsupported: unavailable,
       [button]: fact,
     }) as RuntimeFacts<PlatformRuntimeOperations>['operations'],
   };
   const binding = {
-    device: iosSimulator,
-    owner: localRuntimeOwner('apple'),
+    device,
+    owner: localRuntimeOwner(device.platform),
     facts,
     operations: { [button]: press },
     [Symbol.asyncDispose]: async () => {},
@@ -220,50 +246,72 @@ test('request router joins home admission to execution, recording, and ref inval
 });
 
 // The hardware-button route selects exactly the named cell from the positional: one inspect, one
-// bind of that cell's use, one press, and a response that echoes the public button name (#3848).
-test('hardware-button binds the named cell and reports the public button name', async () => {
-  const harness = runtimeHarness('volumeUp');
+// bind of that cell's use, one press, and a response that echoes the public button name. The use
+// is stated per name here, not read back from the row table, so a row that drifts fails (#3848).
+const HARDWARE_BUTTON_ROUTE_CASES = [
+  ['volume-up', volumeUpRuntimeUse],
+  ['volume-down', volumeDownRuntimeUse],
+  ['power', powerRuntimeUse],
+  ['mute', muteRuntimeUse],
+  ['sleep', sleepRuntimeUse],
+  ['wake', wakeRuntimeUse],
+  ['media-play-pause', mediaPlayPauseRuntimeUse],
+  ['media-next', mediaNextRuntimeUse],
+  ['media-previous', mediaPreviousRuntimeUse],
+  ['media-rewind', mediaRewindRuntimeUse],
+  ['media-fast-forward', mediaFastForwardRuntimeUse],
+] as const;
 
-  const resolved = await resolveBoundHardwareButtonRuntime({
-    platformServices: daemonPlatformServicesFixture(),
-    device: iosSimulator,
-    positionals: ['volume-up'],
-    inspectFacts: harness.inspectFacts,
-    bindDevice: harness.bindDevice,
-  });
+test('the hardware-button route cases cover the whole command vocabulary', () => {
+  expect(HARDWARE_BUTTON_ROUTE_CASES.map(([name]) => name)).toEqual([...HARDWARE_BUTTON_NAMES]);
+});
 
-  expect(resolved.ok).toBe(true);
-  if (!resolved.ok) return;
-  expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
-  expect(harness.bindDevice).toHaveBeenCalledWith(iosSimulator, volumeUpRuntimeUse);
-  const session = makeSession('system-button-runtime', { device: iosSimulator });
-  expect(
-    await resolved.execute({
-      session,
-      sessionName: session.name,
-      logPath: '/tmp/daemon.log',
-      command: 'hardware-button',
-      request: {
+test.each(HARDWARE_BUTTON_ROUTE_CASES)(
+  'hardware-button %s binds its named cell and reports the public button name',
+  async (name, use) => {
+    const harness = runtimeHarness(parseHardwareButtonPositionals([name]), available, androidPhone);
+
+    const resolved = await resolveBoundHardwareButtonRuntime({
+      platformServices: daemonPlatformServicesFixture(),
+      device: androidPhone,
+      positionals: [name],
+      inspectFacts: harness.inspectFacts,
+      bindDevice: harness.bindDevice,
+    });
+
+    expect(resolved.ok).toBe(true);
+    if (!resolved.ok) return;
+    expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
+    expect(harness.bindDevice).toHaveBeenCalledWith(androidPhone, use);
+    const session = makeSession('system-button-runtime', { device: androidPhone });
+    expect(
+      await resolved.execute({
+        session,
+        sessionName: session.name,
+        logPath: '/tmp/daemon.log',
         command: 'hardware-button',
-        positionals: ['volume-up'],
-        token: 't',
-        session: session.name,
-      },
-      positionals: ['volume-up'],
-      out: undefined,
-      dispatchContext: {},
-    }),
-  ).toEqual({
-    action: 'hardware-button',
-    button: 'volume-up',
-    message: 'Pressed hardware button volume-up',
-  });
-  expect(harness.press).toHaveBeenCalledTimes(1);
-});
+        request: {
+          command: 'hardware-button',
+          positionals: [name],
+          token: 't',
+          session: session.name,
+        },
+        positionals: [name],
+        out: undefined,
+        dispatchContext: {},
+      }),
+    ).toEqual({
+      action: 'hardware-button',
+      button: name,
+      message: `Pressed hardware button ${name}`,
+    });
+    expect(harness.press).toHaveBeenCalledTimes(1);
+  },
+);
 
 test('hardware-button refuses an unknown or missing button before inspecting any device', async () => {
   const harness = runtimeHarness('volumeUp');
-  for (const positionals of [[], ['mute'], ['volume-up', 'extra']] as const) {
+  for (const positionals of [[], ['vol'], ['volume-up', 'extra']] as const) {
     await expect(
       resolveBoundHardwareButtonRuntime({
         platformServices: daemonPlatformServicesFixture(),
diff --git a/packages/daemon/src/execution/system-button-runtime.ts b/packages/daemon/src/execution/system-button-runtime.ts
index b045b3ee58..04ea4d6202 100644
--- a/packages/daemon/src/execution/system-button-runtime.ts
+++ b/packages/daemon/src/execution/system-button-runtime.ts
@@ -2,9 +2,17 @@ import {
   actionButtonRuntimeUse,
   appSwitcherRuntimeUse,
   homeRuntimeUse,
+  mediaFastForwardRuntimeUse,
+  mediaNextRuntimeUse,
+  mediaPlayPauseRuntimeUse,
+  mediaPreviousRuntimeUse,
+  mediaRewindRuntimeUse,
+  muteRuntimeUse,
   powerRuntimeUse,
+  sleepRuntimeUse,
   volumeDownRuntimeUse,
   volumeUpRuntimeUse,
+  wakeRuntimeUse,
   type PlatformRuntimeOperations,
 } from '@agent-device/contracts/platform-runtime-operations';
 import type { BoundDeviceRuntime, RuntimeUse } from '@agent-device/contracts/platform-runtime';
@@ -87,6 +95,23 @@ const HARDWARE_BUTTON_COMMAND_ROWS = {
   volumeUp: { use: volumeUpRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.volumeUp },
   volumeDown: { use: volumeDownRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.volumeDown },
   power: { use: powerRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.power },
+  mute: { use: muteRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.mute },
+  sleep: { use: sleepRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.sleep },
+  wake: { use: wakeRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.wake },
+  mediaPlayPause: {
+    use: mediaPlayPauseRuntimeUse,
+    label: HARDWARE_BUTTON_NAME_LABELS.mediaPlayPause,
+  },
+  mediaNext: { use: mediaNextRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.mediaNext },
+  mediaPrevious: {
+    use: mediaPreviousRuntimeUse,
+    label: HARDWARE_BUTTON_NAME_LABELS.mediaPrevious,
+  },
+  mediaRewind: { use: mediaRewindRuntimeUse, label: HARDWARE_BUTTON_NAME_LABELS.mediaRewind },
+  mediaFastForward: {
+    use: mediaFastForwardRuntimeUse,
+    label: HARDWARE_BUTTON_NAME_LABELS.mediaFastForward,
+  },
 } as const satisfies Record<HardwareButton, Readonly<{ use: SystemButtonUse; label: string }>>;
 
 /** The neutral intent one press carries, projected from a resolved command context. */
@@ -157,7 +182,7 @@ export async function resolveBoundHardwareButtonRuntime(
   // refuses with INVALID_ARGS before any device dispatch.
   const button = parseHardwareButtonPositionals(params.positionals ?? []);
   const row = HARDWARE_BUTTON_COMMAND_ROWS[button];
-  // Widen to the family use so one call site serves all three rows.
+  // Widen to the family use so one call site serves every row.
   const use: SystemButtonUse = row.use;
   return await resolveBoundGenericRuntime(
     {
diff --git a/packages/platform-android/src/__tests__/input-actions.test.ts b/packages/platform-android/src/__tests__/input-actions.test.ts
index 6ba42019a0..f013bc6ea0 100644
--- a/packages/platform-android/src/__tests__/input-actions.test.ts
+++ b/packages/platform-android/src/__tests__/input-actions.test.ts
@@ -426,20 +426,31 @@ test('homeAndroid presses keyevent 3', async () => {
   );
 });
 
-test('pressAndroidHardwareButton presses the volume and power keyevents', async () => {
-  await withFakeAdb(
-    () => undefined,
-    async ({ calls, device }) => {
-      await pressAndroidHardwareButton(device, 'volumeUp');
-      await pressAndroidHardwareButton(device, 'volumeDown');
-      await pressAndroidHardwareButton(device, 'power');
-      assert.deepEqual(calls, [
-        ['shell', 'input', 'keyevent', '24'],
-        ['shell', 'input', 'keyevent', '25'],
-        ['shell', 'input', 'keyevent', '26'],
-      ]);
-    },
-  );
+test('pressAndroidHardwareButton presses each named key as its own one keyevent', async () => {
+  // The mapping this command promises: one `input keyevent` per named key, the exact Android
+  // keycode per name (#3848).
+  const keyevents = [
+    ['volumeUp', '24'],
+    ['volumeDown', '25'],
+    ['power', '26'],
+    ['mute', '164'],
+    ['sleep', '223'],
+    ['wake', '224'],
+    ['mediaPlayPause', '85'],
+    ['mediaNext', '87'],
+    ['mediaPrevious', '88'],
+    ['mediaRewind', '89'],
+    ['mediaFastForward', '90'],
+  ] as const;
+  for (const [button, keyCode] of keyevents) {
+    await withFakeAdb(
+      () => undefined,
+      async ({ calls, device }) => {
+        await pressAndroidHardwareButton(device, button);
+        assert.deepEqual(calls, [['shell', 'input', 'keyevent', keyCode]], button);
+      },
+    );
+  }
 });
 
 test('pressAndroidEnter presses the ENTER keyevent', async () => {
diff --git a/packages/platform-android/src/input-actions.ts b/packages/platform-android/src/input-actions.ts
index fc15c8727c..aac8afb644 100644
--- a/packages/platform-android/src/input-actions.ts
+++ b/packages/platform-android/src/input-actions.ts
@@ -4,6 +4,8 @@
  */
 import {
   DEVICE_ROTATION_SURFACE_INDEX,
+  HARDWARE_BUTTON_NAME_LABELS,
+  type HardwareButton,
   deviceRotationFromSurfaceIndex,
   type DeviceRotation,
 } from '@agent-device/contracts/device';
@@ -258,29 +260,19 @@ export async function appSwitcherAndroid(device: DeviceInfo): Promise<void> {
   await runAndroidShell(device, ['input', 'keyevent', '187']);
 }
 
-/**
- * The `input keyevent` codes for the phone hardware keys the `hardware-button` command names:
- * KEYCODE_VOLUME_UP/DOWN/POWER. The helper's `kind:'key'` path takes any code, so both Android
- * legs press all three the way `homeAndroid` presses 3.
- */
-const ANDROID_HARDWARE_BUTTON_KEYCODES = {
-  volumeUp: 24,
-  volumeDown: 25,
-  power: 26,
-} as const;
-
 /** Presses one phone hardware key once. TV targets are gated by the runtime facts, not here. */
 export async function pressAndroidHardwareButton(
   device: DeviceInfo,
-  button: keyof typeof ANDROID_HARDWARE_BUTTON_KEYCODES,
+  button: HardwareButton,
 ): Promise<void> {
-  const keyCode = ANDROID_HARDWARE_BUTTON_KEYCODES[button];
+  const keyevent = toAndroidTvRemoteKeyevent(HARDWARE_BUTTON_NAME_LABELS[button]);
+  const keyCode = Number(keyevent);
   const { runAndroidAutomationHelper } = await import('./automation-helper.ts');
   if (
     await runAndroidAutomationHelper(device, { action: 'input', input: { kind: 'key', keyCode } })
   )
     return;
-  await runAndroidShell(device, ['input', 'keyevent', String(keyCode)]);
+  await runAndroidShell(device, ['input', 'keyevent', keyevent]);
 }
 
 export async function longPressAndroid(
diff --git a/packages/platform-android/src/runtime.test.ts b/packages/platform-android/src/runtime.test.ts
index 95b34722c9..883ced36b7 100644
--- a/packages/platform-android/src/runtime.test.ts
+++ b/packages/platform-android/src/runtime.test.ts
@@ -1,4 +1,8 @@
 import { expect, test, vi } from 'vitest';
+import {
+  HARDWARE_BUTTON_NAMES,
+  parseHardwareButtonPositionals,
+} from '@agent-device/contracts/device';
 import type { AndroidClipboardShellSupport } from '@agent-device/contracts/android-clipboard-support';
 import { runtimeSubjectFact, type DeviceBinding } from '@agent-device/contracts/platform-runtime';
 import type {
@@ -189,6 +193,12 @@ test.each([
   },
 );
 
+// Every `hardware-button` cell the command vocabulary declares, parsed from the command's own
+// names: a key added to the vocabulary is admitted/refused here without restating the list.
+const HARDWARE_BUTTON_CELLS = HARDWARE_BUTTON_NAMES.map((name) =>
+  parseHardwareButtonPositionals([name]),
+);
+
 test('Android admits the hardware-button facts on phones and tablets and refuses a TV target', async () => {
   for (const runtimeDevice of [
     ANDROID_EMULATOR,
@@ -200,16 +210,16 @@ test('Android admits the hardware-button facts on phones and tablets and refuses
       runtimeDevice,
     );
     // One `input keyevent` each on the same adb path `home` rides, on every kind with a device.
-    for (const operation of ['volumeUp', 'volumeDown', 'power'] as const) {
+    for (const operation of HARDWARE_BUTTON_CELLS) {
       expect(binding.facts.operations[operation]).toEqual({ available: true });
       expect(binding.operations[operation]).toBeTypeOf('function');
     }
   }
 
-  // A TV target has no phone volume/power semantics; the refusal points at `tv-remote`.
+  // A TV target has no phone volume/power/media semantics; the refusal points at `tv-remote`.
   const tvDevice = { ...ANDROID_EMULATOR, kind: 'emulator' as const, target: 'tv' as const };
   const tv = await bindOrdinary(createAndroidPlatformRuntime(androidNavigationHost()), tvDevice);
-  for (const operation of ['volumeUp', 'volumeDown', 'power'] as const) {
+  for (const operation of HARDWARE_BUTTON_CELLS) {
     expect(tv.facts.operations[operation]).toEqual({
       available: false,
       reason: 'unsupported-device-kind',
@@ -224,7 +234,7 @@ test('Android admits the hardware-button facts on phones and tablets and refuses
     ...ANDROID_EMULATOR,
     kind: 'simulator' as const,
   });
-  for (const operation of ['volumeUp', 'volumeDown', 'power'] as const) {
+  for (const operation of HARDWARE_BUTTON_CELLS) {
     expect(synthetic.facts.operations[operation]).toEqual({
       available: false,
       reason: 'unsupported-device-kind',
diff --git a/packages/platform-android/src/runtime.ts b/packages/platform-android/src/runtime.ts
index bebe742bc4..cdecf763ad 100644
--- a/packages/platform-android/src/runtime.ts
+++ b/packages/platform-android/src/runtime.ts
@@ -43,7 +43,7 @@ import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtim
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
 import {
-  androidHardwareButtonAvailability,
+  androidHardwareButtonFacts,
   systemButtonRuntimeOperationFacts,
 } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
@@ -353,9 +353,7 @@ export function createAndroidPlatformRuntime(host: PlatformRuntimeHost): Platfor
           unsupported: systemButtonUnavailable,
           home: androidTouchFact(device),
           appSwitcher: androidTouchFact(device),
-          volumeUp: androidHardwareButtonAvailability(device),
-          volumeDown: androidHardwareButtonAvailability(device),
-          power: androidHardwareButtonAvailability(device),
+          ...androidHardwareButtonFacts(device),
         }),
         ...androidFoldableFacts(device),
         ...androidTelephonyFacts(device),
diff --git a/packages/platform-apple/src/runner-demand.ts b/packages/platform-apple/src/runner-demand.ts
index 20ec4f35e6..a04e798831 100644
--- a/packages/platform-apple/src/runner-demand.ts
+++ b/packages/platform-apple/src/runner-demand.ts
@@ -54,13 +54,21 @@ const APPLE_SIMULATOR_OPERATION_HOSTS: Readonly<
   readSetting: 'simulator',
   setFoldPose: 'simulator',
   // Refused on every Apple leaf at admission, so nothing waits on the runner. The volume keys are
-  // refused on the simulator leaf too (XCUIDevice exposes no volume press there), and power is
-  // refused on every kind and OS.
+  // refused on the simulator leaf too (XCUIDevice exposes no volume press there), and power and
+  // the mute/sleep/wake/media keys are refused on every kind and OS.
   sendTelephonyEvent: 'simulator',
   unlockOrientation: 'simulator',
   power: 'simulator',
   volumeDown: 'simulator',
   volumeUp: 'simulator',
+  mute: 'simulator',
+  sleep: 'simulator',
+  wake: 'simulator',
+  mediaPlayPause: 'simulator',
+  mediaNext: 'simulator',
+  mediaPrevious: 'simulator',
+  mediaRewind: 'simulator',
+  mediaFastForward: 'simulator',
   // Observation: the AX bridge presents regular and raw trees; custom actions need XCTest.
   captureSnapshot: 'simulator',
   captureSnapshotWithoutActiveApp: 'simulator',
diff --git a/packages/platform-apple/src/runtime.test.ts b/packages/platform-apple/src/runtime.test.ts
index 9afee6c09d..2122bd8a4a 100644
--- a/packages/platform-apple/src/runtime.test.ts
+++ b/packages/platform-apple/src/runtime.test.ts
@@ -354,7 +354,8 @@ test.each(Object.entries(leaves))(
 // .volumeDown)` is simulator-unavailable in the XCUITest header, so only a physical iPhone or
 // iPad admits them. Each refusal names its own axis: the iOS-family simulator hears the kind
 // refusal, tvOS/macOS/watchOS/visionOS hear the leaf refusal for having no volume key at all.
-// Power is the family denial on every leaf: XCUITest exposes no power press.
+// Power and the mute/sleep/wake/media keys are the family denial on every leaf: XCUITest exposes
+// no press route for any of them.
 test.each([
   ...Object.entries(leaves).map(([name, device]) => [name, device, false] as const),
   ['ios physical device', appleDevice({ kind: 'device' }), true] as const,
@@ -393,11 +394,25 @@ test.each([
             },
       );
     }
-    expectOperationAvailability(binding, 'power', false);
-    expect(binding.facts.operations.power).toMatchObject({
-      reason: 'unsupported-platform-leaf',
-      hint: expect.stringContaining('No Apple leaf carries this system button'),
-    });
+    // Power and the extended keys are the family denial on every Apple leaf: XCUITest exposes no
+    // press route for any of them, so the fact — not a driver call — refuses them everywhere.
+    for (const operation of [
+      'power',
+      'mute',
+      'sleep',
+      'wake',
+      'mediaPlayPause',
+      'mediaNext',
+      'mediaPrevious',
+      'mediaRewind',
+      'mediaFastForward',
+    ] as const) {
+      expectOperationAvailability(binding, operation, false);
+      expect(binding.facts.operations[operation]).toMatchObject({
+        reason: 'unsupported-platform-leaf',
+        hint: expect.stringContaining('No Apple leaf carries this system button'),
+      });
+    }
   },
 );
 
diff --git a/packages/provider-limrun/src/interaction-operations.test.ts b/packages/provider-limrun/src/interaction-operations.test.ts
index 233fb2db2d..3d8917f710 100644
--- a/packages/provider-limrun/src/interaction-operations.test.ts
+++ b/packages/provider-limrun/src/interaction-operations.test.ts
@@ -1,4 +1,8 @@
 import { runtimeSubjectFact } from '@agent-device/contracts/platform-runtime';
+import {
+  HARDWARE_BUTTON_NAMES,
+  parseHardwareButtonPositionals,
+} from '@agent-device/contracts/device';
 import type { Interactor, RunnerContext } from '@agent-device/contracts/interactor-types';
 import { bindAdmittedProviderInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import type { DeviceInfo } from '@agent-device/kernel/device';
@@ -91,22 +95,24 @@ test('home is admitted on both legs, app-switcher only on Android, the action bu
   expect(stale.actionButton).toEqual(liveSessionUnavailable);
 });
 
-// The Android leg's interactor comes from createAndroidInteractor, which carries the three
-// hardware-button presses, so a leased phone/tablet admits them with the local owner's phone
+// The Android leg's interactor comes from createAndroidInteractor, which carries every
+// hardware-button press, so a leased phone/tablet admits them all with the local owner's phone
 // and TV rule; the iOS leg has no such member and falls to the family denial (#3848).
 test('the Android leg admits the hardware-button presses and gates them on the local rule', () => {
+  const cells = HARDWARE_BUTTON_NAMES.map((name) => parseHardwareButtonPositionals([name]));
   const android = limrunSystemButtonOperationFacts(androidMobileDevice);
-  expect(android.volumeUp).toEqual({ available: true });
-  expect(android.volumeDown).toEqual({ available: true });
-  expect(android.power).toEqual({ available: true });
+  for (const cell of cells) {
+    expect(android[cell]).toEqual({ available: true });
+  }
 
   const tv = limrunSystemButtonOperationFacts(androidTvDevice);
-  expect(tv.volumeUp).toEqual({
-    available: false,
-    reason: 'unsupported-device-kind',
-    hint: 'hardware-button is not supported on Android TV targets; use tv-remote.',
-  });
-  expect(tv.power).toEqual(tv.volumeUp);
+  for (const cell of cells) {
+    expect(tv[cell]).toEqual({
+      available: false,
+      reason: 'unsupported-device-kind',
+      hint: 'hardware-button is not supported on Android TV targets; use tv-remote.',
+    });
+  }
 
   const ios = limrunSystemButtonOperationFacts(iosDevice);
   expect(ios.volumeUp).toMatchObject({
@@ -114,11 +120,12 @@ test('the Android leg admits the hardware-button presses and gates them on the l
     reason: 'unsupported-provider-mode',
     hint: 'No Limrun session exposes this system button.',
   });
+  expect(ios.mediaPlayPause).toEqual(ios.volumeUp);
 
   const stale = limrunSystemButtonOperationFacts(androidMobileDevice, liveSessionUnavailable);
-  expect(stale.volumeUp).toEqual(liveSessionUnavailable);
-  expect(stale.volumeDown).toEqual(liveSessionUnavailable);
-  expect(stale.power).toEqual(liveSessionUnavailable);
+  for (const cell of cells) {
+    expect(stale[cell]).toEqual(liveSessionUnavailable);
+  }
 });
 
 // R57: app-event delivery is the one system leaf BOTH direct-session legs serve, because each
diff --git a/packages/provider-limrun/src/interaction-operations.ts b/packages/provider-limrun/src/interaction-operations.ts
index a2c5cef6cd..77c4a5c88b 100644
--- a/packages/provider-limrun/src/interaction-operations.ts
+++ b/packages/provider-limrun/src/interaction-operations.ts
@@ -22,7 +22,7 @@ import type { AndroidSetting } from '@agent-device/platform-android/mechanics';
 import type { LimrunIosSetting } from './ios-settings.ts';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
 import {
-  androidHardwareButtonAvailability,
+  androidHardwareButtonFacts,
   systemButtonRuntimeOperationFacts,
 } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
@@ -141,7 +141,7 @@ const systemButtonUnavailable = unavailableFact(
 );
 // The hardware-button cells use the shared Android admission rule, so a Limrun-managed phone
 // and a local adb phone state the same verdict. On a leased phone or tablet the Android leg's
-// `createAndroidInteractor` carries all three presses.
+// `createAndroidInteractor` carries these presses.
 
 /**
  * The interactor-backed interaction cells a live Limrun session serves: everything here rides
@@ -296,7 +296,7 @@ export function limrunAlertOperationFacts(
 
 /**
  * The Android leg rides the local family's own interactor factory for `home`, `appSwitcher` and
- * the three hardware-button presses. The iOS direct session presses `home` through Limrun's button
+ * the hardware-button presses. The iOS direct session presses `home` through Limrun's button
  * actions and refuses `appSwitcher`. No Limrun session exposes the action button.
  */
 export function limrunSystemButtonOperationFacts(
@@ -311,9 +311,7 @@ export function limrunSystemButtonOperationFacts(
       unsupported: systemButtonUnavailable,
       home: available,
       appSwitcher: available,
-      volumeUp: androidHardwareButtonAvailability(device),
-      volumeDown: androidHardwareButtonAvailability(device),
-      power: androidHardwareButtonAvailability(device),
+      ...androidHardwareButtonFacts(device),
     });
   }
   return systemButtonRuntimeOperationFacts({
diff --git a/packages/provider-webdriver/src/capabilities.ts b/packages/provider-webdriver/src/capabilities.ts
index 511ec30628..9389ba3e8b 100644
--- a/packages/provider-webdriver/src/capabilities.ts
+++ b/packages/provider-webdriver/src/capabilities.ts
@@ -23,6 +23,14 @@ export type CloudWebDriverOperation =
   | 'volumeUp'
   | 'volumeDown'
   | 'power'
+  | 'mute'
+  | 'sleep'
+  | 'wake'
+  | 'mediaPlayPause'
+  | 'mediaNext'
+  | 'mediaPrevious'
+  | 'mediaRewind'
+  | 'mediaFastForward'
   | 'clipboard.read'
   | 'clipboard.write'
   | 'settings'
@@ -63,6 +71,10 @@ export type CloudWebDriverCapabilityOverrides = Partial<
 
 const supported: CloudWebDriverOperationCapability = { support: 'supported' };
 const unsupported: CloudWebDriverOperationCapability = { support: 'unsupported' };
+const androidHardwareButton: CloudWebDriverOperationCapability = {
+  support: 'partial',
+  note: 'Uses provider/Appium mobile pressKey support where available.',
+};
 
 const BASE_WEBDRIVER_CAPABILITIES: CloudWebDriverCapabilityMap = {
   lease: supported,
@@ -106,10 +118,6 @@ const BASE_WEBDRIVER_CAPABILITIES: CloudWebDriverCapabilityMap = {
     support: 'partial',
     note: 'Uses provider/Appium mobile pressButton support where available.',
   },
-  // hardware-button legs. The base rows state the iOS route (XCUITest `mobile: pressButton`
-  // carries the volume names and exposes no power press at all); the Android platform entry below
-  // replaces all three with the `mobile: pressKey` keycodes UiAutomator2 presses, and lifts
-  // `power` from unsupported to partial.
   volumeUp: {
     support: 'partial',
     note: 'Uses provider/Appium mobile pressButton volumeup support where available; real devices only.',
@@ -118,10 +126,15 @@ const BASE_WEBDRIVER_CAPABILITIES: CloudWebDriverCapabilityMap = {
     support: 'partial',
     note: 'Uses provider/Appium mobile pressButton volumedown support where available; real devices only.',
   },
-  power: {
-    support: 'unsupported',
-    note: 'XCUITest exposes no power press to Appium on any iOS session.',
-  },
+  power: unsupported,
+  mute: unsupported,
+  sleep: unsupported,
+  wake: unsupported,
+  mediaPlayPause: unsupported,
+  mediaNext: unsupported,
+  mediaPrevious: unsupported,
+  mediaRewind: unsupported,
+  mediaFastForward: unsupported,
   tvRemote: unsupported,
   'clipboard.read': {
     support: 'partial',
@@ -156,20 +169,17 @@ export function createCloudWebDriverCapabilities(options: {
     options.platform === 'android'
       ? {
           ...BASE_WEBDRIVER_CAPABILITIES,
-          // UiAutomator2's execute map (checked against 8.x) registers no pressButton route; it
-          // presses any keycode through mobile pressKey — the same keyevents the local Android owner sends through `input keyevent`.
-          volumeUp: {
-            support: 'partial',
-            note: 'Uses provider/Appium mobile pressKey keycode 24 where available.',
-          },
-          volumeDown: {
-            support: 'partial',
-            note: 'Uses provider/Appium mobile pressKey keycode 25 where available.',
-          },
-          power: {
-            support: 'partial',
-            note: "Uses provider/Appium mobile pressKey keycode 26 where available; the screen state after the press is the device's own.",
-          },
+          volumeUp: androidHardwareButton,
+          volumeDown: androidHardwareButton,
+          power: androidHardwareButton,
+          mute: androidHardwareButton,
+          sleep: androidHardwareButton,
+          wake: androidHardwareButton,
+          mediaPlayPause: androidHardwareButton,
+          mediaNext: androidHardwareButton,
+          mediaPrevious: androidHardwareButton,
+          mediaRewind: androidHardwareButton,
+          mediaFastForward: androidHardwareButton,
         }
       : BASE_WEBDRIVER_CAPABILITIES;
   return {
diff --git a/packages/provider-webdriver/src/platform-runtime.test.ts b/packages/provider-webdriver/src/platform-runtime.test.ts
index 906b94376c..b2cb2b86d9 100644
--- a/packages/provider-webdriver/src/platform-runtime.test.ts
+++ b/packages/provider-webdriver/src/platform-runtime.test.ts
@@ -3,6 +3,7 @@ import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runti
 import { providerRuntimeOwner } from '@agent-device/contracts/platform-runtime';
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import type { Interactor } from '@agent-device/contracts/interactor-types';
+import { HARDWARE_BUTTON_NAME_LABELS, type HardwareButton } from '@agent-device/contracts/device';
 import { createWebDriverPlatformRuntimeOwner } from './platform-runtime.ts';
 import {
   createCloudWebDriverCapabilities,
@@ -620,9 +621,6 @@ test('a reachable provider with no overrides still admits its declared operation
   }
 });
 
-// The hardware-button split lives in the platform's declared map, not in a device-kind rule:
-// the Android map carries `power` (mobile pressKey 26) and volume on the pressKey keycodes, the
-// iOS map refuses power and carries volume on mobile pressButton (#3848).
 test('hardware-button facts follow the platform capability map', async () => {
   const owner = (platform: CloudWebDriverPlatform) =>
     createWebDriverPlatformRuntimeOwner({
@@ -634,18 +632,75 @@ test('hardware-button facts follow the platform capability map', async () => {
     });
 
   const android = await owner('android').inspectFacts(device);
-  for (const key of ['volumeUp', 'volumeDown', 'power'] as const) {
-    expect(android.operations[key].available).toBe(true);
+  for (const key of [
+    'volumeUp',
+    'volumeDown',
+    'power',
+    'mute',
+    'sleep',
+    'wake',
+    'mediaPlayPause',
+    'mediaNext',
+    'mediaPrevious',
+    'mediaRewind',
+    'mediaFastForward',
+  ] as const) {
+    expect(android.operations[key].available, key).toBe(true);
   }
 
   const iosDevice: DeviceInfo = { ...device, platform: 'apple', appleOs: 'ios' };
   const ios = await owner('ios').inspectFacts(iosDevice);
   expect(ios.operations.volumeUp.available).toBe(true);
   expect(ios.operations.volumeDown.available).toBe(true);
-  expect(ios.operations.power).toMatchObject({
-    available: false,
-    reason: 'owner-capability-missing',
+  for (const key of [
+    'power',
+    'mute',
+    'sleep',
+    'wake',
+    'mediaPlayPause',
+    'mediaNext',
+    'mediaPrevious',
+    'mediaRewind',
+    'mediaFastForward',
+  ] as const) {
+    expect(ios.operations[key], key).toMatchObject({
+      available: false,
+      reason: 'owner-capability-missing',
+    });
+  }
+});
+
+test('Android TV hardware buttons are refused before a WebDriver interactor is acquired', async () => {
+  const getInteractor = vi.fn(() => {
+    throw new Error('a TV hardware button must not acquire an interactor');
+  });
+  const owner = createWebDriverPlatformRuntimeOwner({
+    host: host(async () => ({ stdout: '', stderr: '', exitCode: 0 })),
+    owner: providerRuntimeOwner('browserstack', 'android'),
+    ownsDevice: () => true,
+    capabilities: capabilities('android'),
+    getInteractor,
   });
+  const tv: DeviceInfo = { ...device, target: 'tv' };
+  const facts = await owner.inspectFacts(tv);
+  const binding = await owner.bind({
+    device: tv,
+    intent: { kind: 'ordinary' },
+    scope: {
+      signal: new AbortController().signal,
+      diagnostics: { emit: () => {} },
+      progress: { report: () => {} },
+    },
+  });
+
+  for (const button of Object.keys(HARDWARE_BUTTON_NAME_LABELS) as HardwareButton[]) {
+    expect(facts.operations[button], button).toMatchObject({
+      available: false,
+      reason: 'unsupported-provider-mode',
+    });
+    expect(binding.operations[button], button).toBeUndefined();
+  }
+  expect(getInteractor).not.toHaveBeenCalled();
 });
 
 test('an Apple WebDriver dump bounded to one entry reports unnamed traffic without its identities', async () => {
diff --git a/packages/provider-webdriver/src/platform-runtime.ts b/packages/provider-webdriver/src/platform-runtime.ts
index 4b9125a616..2c3df40124 100644
--- a/packages/provider-webdriver/src/platform-runtime.ts
+++ b/packages/provider-webdriver/src/platform-runtime.ts
@@ -218,8 +218,8 @@ const systemButtonUnavailable = unavailableFact(
 /**
  * The hardware-button legs ride `mobile: pressButton` / `mobile: pressKey`, so the cell reads the
  * seam the same way `home` does: a reachable interactor plus the provider's declaration. The
- * declaration carries the platform split — the iOS capability map marks `power` unsupported, the
- * Android map does not — so nothing here restates it as a device-kind rule.
+ * declaration carries the platform split — the iOS capability map marks `power` and the extended
+ * keys unsupported, the Android map does not — so nothing here restates it as a device-kind rule.
  */
 const hardwareButtonUnavailable = unavailableFact(
   'unsupported-provider-mode',
@@ -635,11 +635,19 @@ function webDriverFacts(
         home: declared('home', homeUnavailable),
         appSwitcher: declared('appSwitcher', appSwitcherUnavailable),
         // Volume and power ride the backend's own hardware-key route and read the same
-        // declared-capability seam `home` uses; the iOS platform map declares power unsupported, so
-        // the declaration — not a device-kind guess — is what refuses it there.
+        // declared-capability seam `home` uses; the iOS platform map declares power and the
+        // extended keys unsupported, so the declaration — not a device-kind guess — refuses them.
         volumeUp: declared('volumeUp', hardwareButtonUnavailable),
         volumeDown: declared('volumeDown', hardwareButtonUnavailable),
         power: declared('power', hardwareButtonUnavailable),
+        mute: declared('mute', hardwareButtonUnavailable),
+        sleep: declared('sleep', hardwareButtonUnavailable),
+        wake: declared('wake', hardwareButtonUnavailable),
+        mediaPlayPause: declared('mediaPlayPause', hardwareButtonUnavailable),
+        mediaNext: declared('mediaNext', hardwareButtonUnavailable),
+        mediaPrevious: declared('mediaPrevious', hardwareButtonUnavailable),
+        mediaRewind: declared('mediaRewind', hardwareButtonUnavailable),
+        mediaFastForward: declared('mediaFastForward', hardwareButtonUnavailable),
       }),
       setFoldPose: foldUnavailable,
       sendTelephonyEvent: telephonyUnavailable,
diff --git a/packages/provider-webdriver/src/webdriver-interactor-hardware-button.test.ts b/packages/provider-webdriver/src/webdriver-interactor-hardware-button.test.ts
index 5bc5966792..34ea274c5b 100644
--- a/packages/provider-webdriver/src/webdriver-interactor-hardware-button.test.ts
+++ b/packages/provider-webdriver/src/webdriver-interactor-hardware-button.test.ts
@@ -51,7 +51,7 @@ test('iOS volume presses ride mobile pressButton and power refuses before the dr
 
   const powerClient = {
     executeScript: async () => {
-      throw new Error('the iOS power refusal must reach the driver');
+      throw new Error('the iOS power refusal must not reach the driver');
     },
   } as unknown as WebDriverClient;
   const powerIos = createWebDriverInteractor({
@@ -74,3 +74,58 @@ test('Android power presses KEYCODE_POWER through mobile pressKey', async () =>
   await android.power!();
   assert.deepEqual(transcript, ['mobile: pressKey [{"keycode":26}]']);
 });
+
+// The eight extended hardware keys (#3848): Android presses each of their keycodes
+// through `mobile: pressKey`, the same keyevents the local adb owner sends; XCUITest exposes no
+// press route for any of them, so the declared capability map refuses an iOS session before the
+// driver is asked.
+test('Android presses each extended hardware key through its mobile pressKey keycode', async () => {
+  const cases = [
+    ['mute', 164],
+    ['sleep', 223],
+    ['wake', 224],
+    ['mediaPlayPause', 85],
+    ['mediaNext', 87],
+    ['mediaPrevious', 88],
+    ['mediaRewind', 89],
+    ['mediaFastForward', 90],
+  ] as const;
+  for (const [method, keycode] of cases) {
+    const transcript: string[] = [];
+    const android = createWebDriverInteractor({
+      client: recordingClient(transcript),
+      backend: 'android',
+      capabilities: createCloudWebDriverCapabilities({ provider: 'test', platform: 'android' }),
+    });
+    await android[method]!();
+    assert.deepEqual(transcript, [`mobile: pressKey [{"keycode":${keycode}}]`], method);
+  }
+});
+
+test('iOS refuses every extended hardware key before the driver is asked', async () => {
+  const ios = createWebDriverInteractor({
+    client: {
+      executeScript: async () => {
+        throw new Error('the iOS hardware-key refusal must not reach the driver');
+      },
+    } as unknown as WebDriverClient,
+    backend: 'xctest',
+    capabilities: createCloudWebDriverCapabilities({ provider: 'test', platform: 'ios' }),
+  });
+  for (const method of [
+    'mute',
+    'sleep',
+    'wake',
+    'mediaPlayPause',
+    'mediaNext',
+    'mediaPrevious',
+    'mediaRewind',
+    'mediaFastForward',
+  ] as const) {
+    await assert.rejects(
+      ios[method]!(),
+      (error: unknown) => error instanceof AppError && error.code === 'UNSUPPORTED_OPERATION',
+      method,
+    );
+  }
+});
diff --git a/packages/provider-webdriver/src/webdriver-interactor.ts b/packages/provider-webdriver/src/webdriver-interactor.ts
index afecb62811..17df097b48 100644
--- a/packages/provider-webdriver/src/webdriver-interactor.ts
+++ b/packages/provider-webdriver/src/webdriver-interactor.ts
@@ -1,4 +1,4 @@
-import type { DeviceRotation } from '@agent-device/contracts/device';
+import type { DeviceRotation, HardwareButton } from '@agent-device/contracts/device';
 import type { BackMode } from '@agent-device/contracts/back-mode';
 import type {
   CloudTextEntryReadiness,
@@ -53,12 +53,6 @@ const SNAPSHOT_VIEWPORT_PROBE_TIMEOUT_MS = 500;
 
 /** The Android `KEYCODE_ENTER` the IME's return key sends. */
 const ANDROID_KEYCODE_ENTER = 66;
-/** The Android `KEYCODE_VOLUME_UP` the `hardware-button volume-up` press sends. */
-const ANDROID_KEYCODE_VOLUME_UP = 24;
-/** The Android `KEYCODE_VOLUME_DOWN` the `hardware-button volume-down` press sends. */
-const ANDROID_KEYCODE_VOLUME_DOWN = 25;
-/** The Android `KEYCODE_POWER` the `hardware-button power` press sends. */
-const ANDROID_KEYCODE_POWER = 26;
 /** How a WebDriver dismiss lowers the iOS keyboard: Appium's hide-keyboard route. */
 const WEBDRIVER_DISMISS_MECHANISM = 'appium-hide-keyboard';
 
@@ -434,20 +428,22 @@ class WebDriverInteractor implements Interactor {
    * Android owner sends. The press lands on the system, which is what the command claims.
    */
   async volumeUp(): Promise<void> {
-    this.requireSupport('volumeUp');
-    await this.pressVolumeKey(ANDROID_KEYCODE_VOLUME_UP, 'volumeup');
+    await this.pressVolumeKey('volumeUp', 'volumeup');
   }
 
   async volumeDown(): Promise<void> {
-    this.requireSupport('volumeDown');
-    await this.pressVolumeKey(ANDROID_KEYCODE_VOLUME_DOWN, 'volumedown');
+    await this.pressVolumeKey('volumeDown', 'volumedown');
   }
 
-  private async pressVolumeKey(androidKeycode: number, xcuiButtonName: string): Promise<void> {
+  private async pressVolumeKey(
+    button: 'volumeUp' | 'volumeDown',
+    xcuiButtonName: string,
+  ): Promise<void> {
     if (this.backend === 'android') {
-      await this.client.executeScript('mobile: pressKey', [{ keycode: androidKeycode }]);
+      await this.pressAndroidHardwareKey(button);
       return;
     }
+    this.requireSupport(button);
     await this.client.executeScript('mobile: pressButton', [{ name: xcuiButtonName }]);
   }
 
@@ -457,8 +453,47 @@ class WebDriverInteractor implements Interactor {
    * capability map declares `power` unsupported, so the declaration refuses before this leg.
    */
   async power(): Promise<void> {
-    this.requireSupport('power');
-    await this.client.executeScript('mobile: pressKey', [{ keycode: ANDROID_KEYCODE_POWER }]);
+    await this.pressAndroidHardwareKey('power');
+  }
+
+  private async pressAndroidHardwareKey(button: HardwareButton): Promise<void> {
+    this.requireSupport(button);
+    const { HARDWARE_BUTTON_NAME_LABELS } = await import('@agent-device/contracts/device');
+    const { toAndroidTvRemoteKeyevent } = await import('@agent-device/contracts/tv-remote');
+    const keycode = Number(toAndroidTvRemoteKeyevent(HARDWARE_BUTTON_NAME_LABELS[button]));
+    await this.client.executeScript('mobile: pressKey', [{ keycode }]);
+  }
+
+  async mute(): Promise<void> {
+    await this.pressAndroidHardwareKey('mute');
+  }
+
+  async sleep(): Promise<void> {
+    await this.pressAndroidHardwareKey('sleep');
+  }
+
+  async wake(): Promise<void> {
+    await this.pressAndroidHardwareKey('wake');
+  }
+
+  async mediaPlayPause(): Promise<void> {
+    await this.pressAndroidHardwareKey('mediaPlayPause');
+  }
+
+  async mediaNext(): Promise<void> {
+    await this.pressAndroidHardwareKey('mediaNext');
+  }
+
+  async mediaPrevious(): Promise<void> {
+    await this.pressAndroidHardwareKey('mediaPrevious');
+  }
+
+  async mediaRewind(): Promise<void> {
+    await this.pressAndroidHardwareKey('mediaRewind');
+  }
+
+  async mediaFastForward(): Promise<void> {
+    await this.pressAndroidHardwareKey('mediaFastForward');
   }
 
   async tvRemote(_button: TvRemoteButton, _durationMs?: number): Promise<void> {
diff --git a/src/commands/system/index.test.ts b/src/commands/system/index.test.ts
index adba37a001..3f9b1e63f5 100644
--- a/src/commands/system/index.test.ts
+++ b/src/commands/system/index.test.ts
@@ -403,7 +403,14 @@ describe('system command interface', () => {
     );
     // Exact names only: no aliases, and nothing reaches the daemon for an unknown name.
     expectInvalidArgs(() => hardwareButtonCliReader(['vol'], flags()), 'button must be one of');
-    expectInvalidArgs(() => hardwareButtonCliReader(['mute'], flags()), 'button must be one of');
+    expectInvalidArgs(() => hardwareButtonCliReader(['media'], flags()), 'button must be one of');
+    // The extended names read and write through the same seam as the original three.
+    expect(hardwareButtonCliReader(['media-fast-forward'], flags())).toMatchObject({
+      button: 'media-fast-forward',
+    });
+    expect(
+      hardwareButtonDaemonWriter({ button: 'sleep' } as Record<string, unknown>).positionals,
+    ).toEqual(['sleep']);
   });
 });
 
diff --git a/src/commands/system/index.ts b/src/commands/system/index.ts
index 8734a2256e..e5588f6e4d 100644
--- a/src/commands/system/index.ts
+++ b/src/commands/system/index.ts
@@ -334,7 +334,7 @@ const tvRemoteCommandDescription =
   'Press or long-press a TV remote button on Android TV, tvOS, or Vega OS. Android TV also supports volume, power, media, channel, guide, captions, input, color keys, and android-keycode:N. tvOS and Vega OS support up, down, left, right, select, menu, home, and back. Phones and WebDriver sessions are unsupported. The aliases ok, center, and enter map to select.';
 
 const hardwareButtonCommandDescription =
-  'Press a phone hardware button once: volume-up, volume-down, or power. The press is dispatched without activating the session app and nothing is re-observed afterwards, so the OS decides what the key does — which audio stream a volume press moves, and whether the HUD shows, is device behavior this command does not claim. Power toggles the Android screen; after a press that turns it off, later commands may hit a locked screen. Android (ADB-backed and Appium) presses all three on phones and tablets; a physical iPhone or iPad presses volume only through the local runner or Appium, never power. iOS Simulators, Android TV and tvOS targets refuse: on TV targets use tv-remote.';
+  'Press a phone hardware button once: volume-up, volume-down, power, mute, sleep, wake, media-play-pause, media-next, media-previous, media-rewind, or media-fast-forward. The press is dispatched without activating the session app and nothing is re-observed afterwards, so the OS decides what the key does — which audio stream a volume press moves, which media session a media key reaches, and whether the HUD shows, is device behavior this command does not claim. Power toggles the Android screen; sleep and wake are the explicit Android events that turn it off or on without toggling, and after a press that turns it off, later commands may hit a locked screen. Android (ADB-backed and Appium) presses all eleven on phones and tablets; a physical iPhone or iPad presses volume only through the local runner or Appium, never power, mute, sleep, wake, or media. iOS Simulators, Android TV and tvOS targets refuse: on TV targets use tv-remote.';
 
 const telephonyCommandDescription =
   'Simulate an incoming phone call or SMS on an Android emulator through its console over adb: call rings from the number, accept answers, cancel ends the call, and sms delivers a text message. The call screen or notification can cover the app, so re-snapshot afterwards.';
@@ -439,7 +439,7 @@ const hardwareButtonCommandMetadata = defineFieldCommandMetadata(
     button: requiredField(
       enumField(
         HARDWARE_BUTTON_NAMES,
-        'One press each. volume-up and volume-down move the system volume stream the OS selects; power toggles the screen on Android and is refused on every Apple leaf.',
+        'One press each. volume-up and volume-down move the system volume stream the OS selects; power toggles the screen on Android; sleep and wake are the explicit Android events that turn the screen off or on without toggling; mute, media-play-pause, media-next, media-previous, media-rewind, and media-fast-forward are Android keys the OS routes to its own streams and media sessions. All of these except volume are refused on every Apple leaf.',
       ),
     ),
   },
@@ -741,7 +741,7 @@ const hardwareButtonCommandFacet = defineCommandFacet({
   text: {
     summary: 'Press a phone hardware button once',
     cliDetail:
-      'Single press; no hold. Android presses volume-up, volume-down, and power on phones and tablets. A physical iPhone or iPad presses volume only; power is never supported on Apple targets. iOS Simulators, Android TV, and tvOS refuse — use tv-remote on TV targets.',
+      'Single press; no hold. Android presses all eleven named keys on phones and tablets: volume-up, volume-down, power, mute, sleep, wake, and the five media keys. A physical iPhone or iPad presses volume only; the other keys are never supported on Apple targets. iOS Simulators, Android TV, and tvOS refuse — use tv-remote on TV targets.',
   },
   metadata: hardwareButtonCommandMetadata,
   run: (client, input) => client.command.hardwareButton(input),
diff --git a/src/core/interactors/android.ts b/src/core/interactors/android.ts
index b656f55e61..5d0a8742f2 100644
--- a/src/core/interactors/android.ts
+++ b/src/core/interactors/android.ts
@@ -130,6 +130,14 @@ export function createAndroidInteractor(
     volumeUp: () => pressAndroidHardwareButton(device, 'volumeUp'),
     volumeDown: () => pressAndroidHardwareButton(device, 'volumeDown'),
     power: () => pressAndroidHardwareButton(device, 'power'),
+    mute: () => pressAndroidHardwareButton(device, 'mute'),
+    sleep: () => pressAndroidHardwareButton(device, 'sleep'),
+    wake: () => pressAndroidHardwareButton(device, 'wake'),
+    mediaPlayPause: () => pressAndroidHardwareButton(device, 'mediaPlayPause'),
+    mediaNext: () => pressAndroidHardwareButton(device, 'mediaNext'),
+    mediaPrevious: () => pressAndroidHardwareButton(device, 'mediaPrevious'),
+    mediaRewind: () => pressAndroidHardwareButton(device, 'mediaRewind'),
+    mediaFastForward: () => pressAndroidHardwareButton(device, 'mediaFastForward'),
     tvRemote: (button, durationMs) => pressAndroidTvRemote(device, button, durationMs),
     keyboardStatus: async () => ({ kind: 'ime-probe', ...(await getAndroidKeyboardState(device)) }),
     keyboardDismiss: async () => ({ kind: 'ime-probe', ...(await dismissAndroidKeyboard(device)) }),
diff --git a/test/integration/command-coverage/declarations.ts b/test/integration/command-coverage/declarations.ts
index 2ba59e8afa..e900ef45e5 100644
--- a/test/integration/command-coverage/declarations.ts
+++ b/test/integration/command-coverage/declarations.ts
@@ -1409,12 +1409,12 @@ const COMMAND_COVERAGE_DECLARATIONS = {
   [C.hardwareButton]: {
     androidEmulator: androidEmulator.contract(
       ANDROID_HARDWARE_BUTTON_RUNTIME_CONTRACT_EVIDENCE,
-      'Android admits the hardware-button facts on phones and tablets through the keyevent path and refuses a TV target with a pointer to tv-remote',
+      'Android admits the hardware-button facts for every named key on phones and tablets through the keyevent path and refuses a TV target with a pointer to tv-remote',
     ),
     iosSimulator: iosSimulator.contract(
       APPLE_HARDWARE_BUTTON_FACT_EVIDENCE.path,
       APPLE_HARDWARE_BUTTON_FACT_EVIDENCE.test,
-      'the exact-owner runtime fact refuses hardware-button volume on the simulator leaf (XCUIDevice exposes no volume press there) and power on every leaf',
+      'the exact-owner runtime fact refuses hardware-button volume on the simulator leaf (XCUIDevice exposes no volume press there) and power and the extended keys on every leaf',
     ),
     macos: macos.contract(
       APPLE_HARDWARE_BUTTON_FACT_EVIDENCE.path,
diff --git a/website/docs/docs/client-api.md b/website/docs/docs/client-api.md
index 21379c32c9..18e62a7ec8 100644
--- a/website/docs/docs/client-api.md
+++ b/website/docs/docs/client-api.md
@@ -294,7 +294,7 @@ await client.command.fold({
 
 `fold` accepts either `pose` or `keyframes`. Keyframes use linear interpolation at roughly 60 updates per second; repeat an angle to hold it. Timestamps must start at zero and increase strictly, with 2–64 frames and a final timestamp no greater than 60,000ms. Angles must be finite and between 0° and 180°. The final timestamp bounds motion, excluding helper preparation and final hinge verification. A custom final angle is verified within 0.5°; interior angles must also settle. Cancellation stops the motion at its current angle. Re-snapshot afterwards, including after interrupted motion. Android emulators accept `pose` only.
 
-`hardwareButton` presses one phone hardware key once: `button` is `'volume-up'`, `'volume-down'`, or `'power'`. It takes no hold duration and activates no app; the result reports the dispatched press, not the OS reaction. Android presses all three on phones and tablets; a physical iPhone or iPad presses volume only; iOS Simulators, Android TV, and tvOS refuse (use `tvRemote` on TV targets).
+`hardwareButton` presses one phone hardware key once: `button` is `'volume-up'`, `'volume-down'`, `'power'`, `'mute'`, `'sleep'`, `'wake'`, `'media-play-pause'`, `'media-next'`, `'media-previous'`, `'media-rewind'`, or `'media-fast-forward'`. It takes no hold duration and activates no app; the result reports the dispatched press, not the OS reaction. Android presses all eleven on phones and tablets; a physical iPhone or iPad presses volume only; iOS Simulators, Android TV, and tvOS refuse (use `tvRemote` on TV targets). `sleep` and `wake` are the explicit Android events that turn the screen off or on; `power` toggles it.
 
 `press`, `click`, and `longpress` do not wait for a missing target to appear. When a screen is still loading, wait for its landmark before interacting:
 
diff --git a/website/docs/docs/commands.md b/website/docs/docs/commands.md
index 281ddc0840..870f7a8efc 100644
--- a/website/docs/docs/commands.md
+++ b/website/docs/docs/commands.md
@@ -123,9 +123,9 @@ Back, orientation, and hardware buttons:
 - `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.
-- `hardware-button volume-up|volume-down|power` presses one phone hardware key once, with no hold and no `--settle`, and it doesn't activate the session app. The response reports the dispatched press, not what the OS did with it: which audio stream a volume press moves and whether the HUD shows is device behavior the command does not claim.
-- Android presses all three keys on phones and tablets: the ADB-backed and helper paths send `input keyevent` 24/25/26, and an Appium-backed device presses the same keycodes through its `mobile: pressKey` route. A physical iPhone or iPad presses volume only, through the local runner or Appium's volume button press; no Apple leaf presses power. iOS Simulators refuse volume (`XCUIDevice` exposes no volume press there), and Android TV and tvOS targets refuse with a pointer to `tv-remote`.
-- A `power` press toggles the Android screen. After a press that turns it off, later commands may hit a locked screen; nothing in agent-device presses the key again to wake it.
+- `hardware-button <button>` presses one phone hardware key once, with no hold and no `--settle`, and it doesn't activate the session app. The names are `volume-up`, `volume-down`, `power`, `mute`, `sleep`, `wake`, `media-play-pause`, `media-next`, `media-previous`, `media-rewind`, and `media-fast-forward`. The response reports the dispatched press, not what the OS did with it: which audio stream a volume press moves, which media session a media key reaches, and whether the HUD shows is device behavior the command does not claim.
+- Android presses all eleven keys on phones and tablets: the ADB-backed and helper paths send `input keyevent`, and an Appium-backed device presses the same keycodes through its `mobile: pressKey` route. A physical iPhone or iPad presses volume only, through the local runner or Appium's volume button press; no Apple leaf presses the other keys. iOS Simulators refuse volume (`XCUIDevice` exposes no volume press there), and Android TV and tvOS targets refuse with a pointer to `tv-remote`.
+- A `power` press toggles the Android screen. `sleep` turns it off and `wake` turns it on without toggling, so wake the screen with `hardware-button wake` after a press that turned it off. After a press that turns the screen off, later commands may hit a locked screen.
 
 Fold a foldable device: