diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3fd138dec7..2165709044 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,12 @@
   none, and Android, HarmonyOS, Vega, Linux, web, tvOS, macOS, and visionOS each state their own refusal.
   Simulators run no Shortcuts or App Intents, so what a press triggers is verifiable only on a physical
   iPhone (#2699).
+- Changed (all): `home`, `app-switcher` and `action-button` are one system-button family in the
+  runtime contract. An owner without a button now refuses it with the family's hint (for example
+  `Android has no key event for this system button.`) rather than a per-button sentence, and a
+  Limrun or WebDriver session that is no longer active refuses `action-button` with that session's
+  own reason like every other cell; the command name still leads the `UNSUPPORTED_OPERATION`
+  message.
 - Fixed (android): `clipboard read` and `clipboard write` stop reporting success on a build whose
   clipboard service has no shell command. Android 16 (API 36) answers every `adb shell cmd clipboard …`
   with the framework default `Binder.handleShellCommand` — `No shell command implementation.` on
diff --git a/packages/contracts/package.json b/packages/contracts/package.json
index 8a86eebe60..2ce9fa24f5 100644
--- a/packages/contracts/package.json
+++ b/packages/contracts/package.json
@@ -64,10 +64,6 @@
       "types": "./src/app-state-runtime.ts",
       "default": "./src/app-state-runtime.ts"
     },
-    "./app-switcher-runtime": {
-      "types": "./src/app-switcher-runtime.ts",
-      "default": "./src/app-switcher-runtime.ts"
-    },
     "./apple-runner-request": {
       "types": "./src/apple-runner-request.ts",
       "default": "./src/apple-runner-request.ts"
@@ -220,10 +216,6 @@
       "types": "./src/gesture-runtime.ts",
       "default": "./src/gesture-runtime.ts"
     },
-    "./home-runtime": {
-      "types": "./src/home-runtime.ts",
-      "default": "./src/home-runtime.ts"
-    },
     "./host-diagnostics": {
       "types": "./src/host-diagnostics.ts",
       "default": "./src/host-diagnostics.ts"
@@ -456,6 +448,10 @@
       "types": "./src/startup-recovery-fence.ts",
       "default": "./src/startup-recovery-fence.ts"
     },
+    "./system-button-runtime": {
+      "types": "./src/system-button-runtime.ts",
+      "default": "./src/system-button-runtime.ts"
+    },
     "./tap-keyboard-occlusion": {
       "types": "./src/tap-keyboard-occlusion.ts",
       "default": "./src/tap-keyboard-occlusion.ts"
diff --git a/packages/contracts/src/app-switcher-runtime.test.ts b/packages/contracts/src/app-switcher-runtime.test.ts
deleted file mode 100644
index 8f71459ba3..0000000000
--- a/packages/contracts/src/app-switcher-runtime.test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { expect, test, vi } from 'vitest';
-import { appSwitcherRuntimeOperationFacts, bindAppSwitcher } from './app-switcher-runtime.ts';
-import type { Interactor } from './interactor-types.ts';
-import { localInteractorSource } from './interactor-operation-binding.ts';
-
-const device = {
-  platform: 'android',
-  id: 'emulator-5554',
-  name: 'Pixel',
-  kind: 'emulator',
-  booted: true,
-} as const;
-
-test('builds the exact app-switcher operation fact catalog', () => {
-  const appSwitcher = { available: true } as const;
-  expect(appSwitcherRuntimeOperationFacts({ appSwitcher })).toEqual({
-    appSwitcher,
-  });
-});
-
-test('a local binding drives the interactor with the request runner context', async () => {
-  const appSwitcher = vi.fn(async () => undefined);
-  const resolveInteractor = vi.fn(async () => ({ appSwitcher }) as unknown as Interactor);
-  const signal = new AbortController().signal;
-
-  const operations = bindAppSwitcher(signal, localInteractorSource({ device, resolveInteractor }));
-  await operations.appSwitcher({
-    options: { appBundleId: 'com.example.app' },
-    execution: { logPath: '/tmp/daemon.log', requestId: 'switcher-1' },
-  });
-
-  expect(resolveInteractor).toHaveBeenCalledWith(device, {
-    logPath: '/tmp/daemon.log',
-    requestId: 'switcher-1',
-    appBundleId: 'com.example.app',
-    signal,
-  });
-  expect(appSwitcher).toHaveBeenCalledOnce();
-});
diff --git a/packages/contracts/src/app-switcher-runtime.ts b/packages/contracts/src/app-switcher-runtime.ts
deleted file mode 100644
index 0852ab5183..0000000000
--- a/packages/contracts/src/app-switcher-runtime.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import type { Interactor, RunnerContext } from './interactor-types.ts';
-import type { RuntimeOperationFact } from './platform-runtime.ts';
-import type { SnapshotRuntimeExecution } from './snapshot-runtime.ts';
-
-/**
- * Neutral intent for one app-switcher reveal: no arguments, so only runner metadata travels —
- * the same shape `home` carries, because it is the same springboard surface.
- */
-export type AppSwitcherInput = Readonly<{
-  options?: Readonly<{ appBundleId?: string }>;
-  /** Same runner metadata a capture needs; reuses that type rather than restating it. */
-  execution?: SnapshotRuntimeExecution;
-}>;
-
-/** The reveal returns nothing; the retired leaf discarded whatever the interactor answered. */
-export type AppSwitcherRuntimeOperations = Readonly<{
-  appSwitcher(input: AppSwitcherInput): Promise<void>;
-}>;
-
-export type AppSwitcherRuntimeOperationFacts = Readonly<{
-  appSwitcher: RuntimeOperationFact;
-}>;
-
-export function appSwitcherRuntimeOperationFacts(
-  input: Readonly<{ appSwitcher: RuntimeOperationFact }>,
-): AppSwitcherRuntimeOperationFacts {
-  return Object.freeze({ appSwitcher: input.appSwitcher });
-}
-
-/**
- * Captures one selected owner's interactor authority for the lifetime of a request binding. The
- * owner is already chosen by the time a binder is called, so each entry point supplies its own
- * resolution and this holds only what both share: the runner context and the reveal itself.
- */
-export function bindAppSwitcher(
-  signal: AbortSignal,
-  resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
-): AppSwitcherRuntimeOperations {
-  return Object.freeze({
-    appSwitcher: async (input: AppSwitcherInput) => {
-      signal.throwIfAborted();
-      const interactor = await resolveInteractor({
-        ...input.execution,
-        appBundleId: input.options?.appBundleId,
-        signal,
-      });
-      await interactor.appSwitcher();
-    },
-  });
-}
diff --git a/packages/contracts/src/home-runtime.test.ts b/packages/contracts/src/home-runtime.test.ts
deleted file mode 100644
index 3ea5fbb4ce..0000000000
--- a/packages/contracts/src/home-runtime.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { expect, test, vi } from 'vitest';
-import { bindHome, homeRuntimeOperationFacts } from './home-runtime.ts';
-import type { Interactor } from './interactor-types.ts';
-import { localInteractorSource } from './interactor-operation-binding.ts';
-
-const device = {
-  platform: 'android',
-  id: 'emulator-5554',
-  name: 'Pixel',
-  kind: 'emulator',
-  booted: true,
-} as const;
-
-test('builds the exact home operation fact catalog', () => {
-  const home = { available: true } as const;
-  expect(homeRuntimeOperationFacts({ home })).toEqual({ home });
-});
-
-test('a local binding drives the interactor with no arguments', async () => {
-  const home = vi.fn(async () => undefined);
-  const resolveInteractor = vi.fn(async () => ({ home }) as unknown as Interactor);
-  const signal = new AbortController().signal;
-
-  const operations = bindHome(signal, localInteractorSource({ device, resolveInteractor }));
-  await operations.home({
-    options: { appBundleId: 'com.example.app' },
-    execution: { logPath: '/tmp/daemon.log', requestId: 'home-1' },
-  });
-
-  expect(resolveInteractor).toHaveBeenCalledWith(device, {
-    logPath: '/tmp/daemon.log',
-    requestId: 'home-1',
-    appBundleId: 'com.example.app',
-    signal,
-  });
-  expect(home).toHaveBeenCalledWith();
-});
diff --git a/packages/contracts/src/home-runtime.ts b/packages/contracts/src/home-runtime.ts
deleted file mode 100644
index 006bd2b810..0000000000
--- a/packages/contracts/src/home-runtime.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import type { Interactor, RunnerContext } from './interactor-types.ts';
-import type { RuntimeOperationFact } from './platform-runtime.ts';
-import type { SnapshotRuntimeExecution } from './snapshot-runtime.ts';
-
-/** Neutral intent for one home navigation: no arguments, so only runner metadata travels. */
-export type HomeInput = Readonly<{
-  options?: Readonly<{ appBundleId?: string }>;
-  /** Same runner metadata a capture needs; reuses that type rather than restating it. */
-  execution?: SnapshotRuntimeExecution;
-}>;
-
-/** Home returns nothing; the legacy leaf discarded whatever the interactor answered. */
-export type HomeRuntimeOperations = Readonly<{
-  home(input: HomeInput): Promise<void>;
-}>;
-
-export type HomeRuntimeOperationFacts = Readonly<{
-  home: RuntimeOperationFact;
-}>;
-
-export function homeRuntimeOperationFacts(
-  input: Readonly<{ home: RuntimeOperationFact }>,
-): HomeRuntimeOperationFacts {
-  return Object.freeze({ home: input.home });
-}
-
-/**
- * Captures one selected owner's interactor authority for the lifetime of a request binding. The
- * owner is already chosen by the time a binder is called, so each entry point supplies its own
- * resolution and this holds only what both share: the runner context and the navigation itself.
- */
-export function bindHome(
-  signal: AbortSignal,
-  resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
-): HomeRuntimeOperations {
-  return Object.freeze({
-    home: async (input: HomeInput) => {
-      signal.throwIfAborted();
-      const interactor = await resolveInteractor({
-        ...input.execution,
-        appBundleId: input.options?.appBundleId,
-        signal,
-      });
-      await interactor.home();
-    },
-  });
-}
diff --git a/packages/contracts/src/interactor-operation-binding.ts b/packages/contracts/src/interactor-operation-binding.ts
index 6d0bf5d6dd..6f17dc4409 100644
--- a/packages/contracts/src/interactor-operation-binding.ts
+++ b/packages/contracts/src/interactor-operation-binding.ts
@@ -16,6 +16,24 @@ export type LocalInteractorOperationResolver = (
 
 export type ProviderInteractorOperationResolver = (runner: RunnerContext) => Interactor | undefined;
 
+/**
+ * Optional `Interactor` members (keyboard, hover, the hardware buttons only some owners carry)
+ * are left undefined by a platform with no such concept. Facts admit an operation only for owners
+ * whose interactor implements it, so a missing method at bind time is a runtime-contract error,
+ * not a normal refusal — and never a no-op that reports success.
+ */
+export function requireInteractorMethod<Method>(
+  method: Method | undefined,
+  operation: string,
+): NonNullable<Method> {
+  if (method) return method as NonNullable<Method>;
+  throw new AppError(
+    'COMMAND_FAILED',
+    `${operation} was admitted but its bound interactor has no implementation.`,
+    { reason: 'interactor-method-missing' },
+  );
+}
+
 /** Resolves the already-selected local owner's interactor for one bound operation. */
 export function localInteractorSource(
   params: Readonly<{ device: DeviceInfo; resolveInteractor: LocalInteractorOperationResolver }>,
diff --git a/packages/contracts/src/interactor-operation-catalog.ts b/packages/contracts/src/interactor-operation-catalog.ts
index 932162f317..ccbf84ed81 100644
--- a/packages/contracts/src/interactor-operation-catalog.ts
+++ b/packages/contracts/src/interactor-operation-catalog.ts
@@ -1,10 +1,8 @@
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import { bindAlertLeg } from './alert-runtime.ts';
 import { bindAppEvent } from './app-event-runtime.ts';
-import { bindAppSwitcher } from './app-switcher-runtime.ts';
 import { bindBack } from './back-runtime.ts';
 import { bindClipboardRead, bindClipboardWrite } from './clipboard-runtime.ts';
-import { bindHome } from './home-runtime.ts';
 import { KEYBOARD_ACTION_LABELS, bindKeyboardAction } from './keyboard-runtime.ts';
 import { bindOrientation } from './orientation-runtime.ts';
 import { bindSetSetting } from './settings-runtime.ts';
@@ -16,35 +14,9 @@ import {
   type ProviderInteractorOperationResolver,
 } from './interactor-operation-binding.ts';
 import type { Interactor, RunnerContext } from './interactor-types.ts';
-import type {
-  NoArgumentInteractorOperations,
-  PlatformRuntimeOperations,
-} from './platform-runtime-operations.ts';
+import type { PlatformRuntimeOperations } from './platform-runtime-operations.ts';
 import type { RuntimeOperationFact } from './platform-runtime.ts';
-
-/**
- * Binds the zero-argument interactor group declared by `NoArgumentInteractorOperations`: one fact
- * admits each member, one interactor call performs it, and the only thing that travels is runner
- * metadata. Every other catalog row imports a binder from the module that owns that operation's
- * contract; this group has no operation-specific mechanism to own, so binding it here is what keeps
- * it one row rather than a module, an export subpath, and a facts helper.
- */
-function bindNoArgumentInteractorOperations(
-  signal: AbortSignal,
-  resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
-): NoArgumentInteractorOperations {
-  return Object.freeze({
-    actionButton: async (input) => {
-      signal.throwIfAborted();
-      const interactor = await resolveInteractor({
-        ...input.execution,
-        appBundleId: input.options?.appBundleId,
-        signal,
-      });
-      await interactor.actionButton();
-    },
-  });
-}
+import { bindSystemButton, SYSTEM_BUTTON_LABELS } from './system-button-runtime.ts';
 
 /**
  * How a facet turns one resolved interactor into its own typed operations. Every catalog member
@@ -80,7 +52,11 @@ type InteractorOperationDefinition = Readonly<{
  */
 export const INTERACTOR_OPERATIONS = [
   { operation: 'back', label: 'back', bind: bindBack },
-  { operation: 'home', label: 'home', bind: bindHome },
+  {
+    operation: 'home',
+    label: SYSTEM_BUTTON_LABELS.home,
+    bind: (signal, resolve) => bindSystemButton('home', signal, resolve),
+  },
   { operation: 'setOrientation', label: 'orientation', bind: bindOrientation },
   { operation: 'tvRemote', label: 'tv-remote', bind: bindTvRemote },
   {
@@ -100,11 +76,15 @@ export const INTERACTOR_OPERATIONS = [
   },
   { operation: 'readClipboard', label: 'clipboard read', bind: bindClipboardRead },
   { operation: 'writeClipboard', label: 'clipboard write', bind: bindClipboardWrite },
-  { operation: 'appSwitcher', label: 'app-switcher', bind: bindAppSwitcher },
+  {
+    operation: 'appSwitcher',
+    label: SYSTEM_BUTTON_LABELS.appSwitcher,
+    bind: (signal, resolve) => bindSystemButton('appSwitcher', signal, resolve),
+  },
   {
     operation: 'actionButton',
-    label: 'action-button',
-    bind: bindNoArgumentInteractorOperations,
+    label: SYSTEM_BUTTON_LABELS.actionButton,
+    bind: (signal, resolve) => bindSystemButton('actionButton', signal, resolve),
   },
   { operation: 'triggerAppEvent', label: 'trigger-app-event', bind: bindAppEvent },
   { operation: 'setSetting', label: 'settings', bind: bindSetSetting },
diff --git a/packages/contracts/src/interactor-types.ts b/packages/contracts/src/interactor-types.ts
index 8c009b65f7..5d3c315475 100644
--- a/packages/contracts/src/interactor-types.ts
+++ b/packages/contracts/src/interactor-types.ts
@@ -370,11 +370,12 @@ export type Interactor = {
   appSwitcher(): Promise<void>;
   tvRemote(button: TvRemoteButton, durationMs?: number): Promise<void>;
   /**
-   * Presses the iPhone Action Button. Required rather than optional for the same reason `tvRemote`
-   * is: an absent member would let an advertised press resolve as a no-op that reports success.
-   * Owners without the button throw `UNSUPPORTED_OPERATION`.
+   * Optional (parity with `keyboardDismiss`): presses the iPhone/iPad Action Button, hardware only
+   * the Apple owner carries. An owner without the button leaves it undefined; its fact refuses the
+   * press before binding, and the system-button binder fails closed rather than resolving an
+   * absent member as a successful no-op.
    */
-  actionButton(): Promise<void>;
+  actionButton?(): 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/keyboard-runtime.ts b/packages/contracts/src/keyboard-runtime.ts
index 5903a63974..51f82375d4 100644
--- a/packages/contracts/src/keyboard-runtime.ts
+++ b/packages/contracts/src/keyboard-runtime.ts
@@ -1,4 +1,3 @@
-import { AppError } from '@agent-device/kernel/errors';
 import type {
   Interactor,
   KeyboardDismissResult,
@@ -75,24 +74,6 @@ export function keyboardRuntimeOperationFacts(
   });
 }
 
-/**
- * `Interactor.keyboardStatus`/`keyboardDismiss`/`keyboardEnter` are optional (parity with
- * `hover`): a platform with no keyboard concept for that action leaves it undefined. Facts admit
- * an operation only for owners whose interactor implements it, so a missing method at bind time
- * is a runtime-contract error, not a normal refusal.
- */
-function requireKeyboardMethod<Method>(
-  method: Method | undefined,
-  operation: string,
-): NonNullable<Method> {
-  if (method) return method as NonNullable<Method>;
-  throw new AppError(
-    'COMMAND_FAILED',
-    `${operation} was admitted but its bound interactor has no implementation.`,
-    { reason: 'interactor-method-missing' },
-  );
-}
-
 /**
  * Captures one selected owner's interactor authority for the lifetime of a request binding. The
  * owner is already chosen by the time a binder is called, so each entry point supplies its own
@@ -129,7 +110,11 @@ export function bindKeyboardAction<Key extends keyof KeyboardRuntimeOperations>(
 ): Pick<KeyboardRuntimeOperations, Key> {
   const action = async (input: KeyboardActionInput) => {
     const interactor = await resolveKeyboardInteractor(signal, resolveInteractor, input);
-    const method = requireKeyboardMethod(interactor[key], KEYBOARD_ACTION_LABELS[key]);
+    // The guard every optional-member binder shares. Loaded on the call rather than at module
+    // evaluation because this facade's eager closure is held at its merge-base size
+    // (`eager-closure-budgets`); a static edge would grow it by one module.
+    const { requireInteractorMethod } = await import('./interactor-operation-binding.ts');
+    const method = requireInteractorMethod(interactor[key], KEYBOARD_ACTION_LABELS[key]);
     return await (method as () => Promise<unknown>).call(interactor);
   };
   return Object.freeze({ [key]: action }) as Pick<KeyboardRuntimeOperations, Key>;
diff --git a/packages/contracts/src/platform-runtime-operations.ts b/packages/contracts/src/platform-runtime-operations.ts
index 33cf5192a3..f3627735c1 100644
--- a/packages/contracts/src/platform-runtime-operations.ts
+++ b/packages/contracts/src/platform-runtime-operations.ts
@@ -10,11 +10,7 @@ import type { NetworkRuntimeHost, NetworkRuntimeOperations } from './network-run
 import type { ScreenRecordingRuntimeHost } from './screen-recording-runtime-host.ts';
 import type { ScreenRecordingRuntimeOperations } from './screen-recording-runtime.ts';
 import type { ScreenshotRuntimeOperations } from './screenshot-runtime.ts';
-import type {
-  SnapshotRuntimeExecution,
-  SnapshotRuntimeHost,
-  SnapshotRuntimeOperations,
-} from './snapshot-runtime.ts';
+import type { SnapshotRuntimeHost, SnapshotRuntimeOperations } from './snapshot-runtime.ts';
 import type { SelectorObservationRuntimeOperations } from './selector-observation-runtime.ts';
 import type { ViewportRuntimeOperations } from './viewport-runtime.ts';
 import type { FocusRuntimeOperations } from './focus-runtime.ts';
@@ -25,12 +21,11 @@ import type { ScrollRuntimeOperations } from './scroll-runtime.ts';
 import type { TypeTextRuntimeOperations } from './type-text-runtime.ts';
 import type { ElementTextRuntimeOperations } from './element-text-runtime.ts';
 import type { BackRuntimeOperations } from './back-runtime.ts';
-import type { HomeRuntimeOperations } from './home-runtime.ts';
 import type { OrientationRuntimeOperations } from './orientation-runtime.ts';
 import type { TvRemoteRuntimeOperations } from './tv-remote-runtime.ts';
 import type { KeyboardRuntimeOperations } from './keyboard-runtime.ts';
 import type { ClipboardRuntimeOperations } from './clipboard-runtime.ts';
-import type { AppSwitcherRuntimeOperations } from './app-switcher-runtime.ts';
+import type { SystemButtonRuntimeOperations } from './system-button-runtime.ts';
 import type { AppEventRuntimeOperations } from './app-event-runtime.ts';
 import type { SettingsRuntimeOperations } from './settings-runtime.ts';
 import type { AlertRuntimeOperations } from './alert-runtime.ts';
@@ -62,31 +57,6 @@ import {
 import { runtimeUse } from './platform-runtime-use.ts';
 import type { AndroidToolHost } from './platform-runtime-host.ts';
 
-/**
- * The intent one zero-argument interactor operation carries: there are no arguments, so only runner
- * metadata travels. `home` and `app-switcher` restate this shape in their own modules; the group
- * below is the version of it that needs no module of its own.
- */
-export type NoArgumentInteractorInput = Readonly<{
-  options?: Readonly<{ appBundleId?: string }>;
-  /** Same runner metadata a capture needs; reuses that type rather than restating it. */
-  execution?: SnapshotRuntimeExecution;
-}>;
-
-/**
- * The zero-argument interactor operations, bound as one group by
- * `bindNoArgumentInteractorOperations`.
- *
- * `actionButton` presses the iPhone/iPad Action Button. Its member is required rather than optional
- * even though one owner can perform it today, which is how `tvRemote` handles a control only some
- * owners have: an optional member would turn a fact that advertises the press without an interactor
- * that performs it into a successful-looking no-op. Owners without the hardware declare the refusal
- * on the interactor, and the fact is what keeps that throw off every supported path.
- */
-export type NoArgumentInteractorOperations = Readonly<{
-  actionButton(input: NoArgumentInteractorInput): Promise<void>;
-}>;
-
 export type PlatformRuntimeOperations = AppLogRuntimeOperations &
   AppInventoryRuntimeOperations &
   AppDeploymentRuntimeOperations &
@@ -103,13 +73,11 @@ export type PlatformRuntimeOperations = AppLogRuntimeOperations &
   TypeTextRuntimeOperations &
   ElementTextRuntimeOperations &
   BackRuntimeOperations &
-  HomeRuntimeOperations &
   OrientationRuntimeOperations &
   TvRemoteRuntimeOperations &
   KeyboardRuntimeOperations &
   ClipboardRuntimeOperations &
-  AppSwitcherRuntimeOperations &
-  NoArgumentInteractorOperations &
+  SystemButtonRuntimeOperations &
   AppEventRuntimeOperations &
   SettingsRuntimeOperations &
   AlertRuntimeOperations &
diff --git a/packages/contracts/src/platform-runtime-unavailable.test.ts b/packages/contracts/src/platform-runtime-unavailable.test.ts
index 7034639035..b5745a1e2d 100644
--- a/packages/contracts/src/platform-runtime-unavailable.test.ts
+++ b/packages/contracts/src/platform-runtime-unavailable.test.ts
@@ -44,13 +44,11 @@ const UNAVAILABLE_FACTS: UnavailablePlatformRuntimeFacts = {
   touch: { available: false, reason: 'unsupported-provider-mode' },
   elementText: { available: false, reason: 'unsupported-provider-mode' },
   back: { available: false, reason: 'unsupported-provider-mode' },
-  home: { available: false, reason: 'unsupported-provider-mode' },
   orientation: { available: false, reason: 'unsupported-provider-mode' },
   tvRemote: { available: false, reason: 'unsupported-provider-mode' },
   keyboard: { available: false, reason: 'unsupported-provider-mode' },
   clipboard: { available: false, reason: 'unsupported-provider-mode' },
-  appSwitcher: { available: false, reason: 'unsupported-provider-mode' },
-  actionButton: { available: false, reason: 'unsupported-provider-mode' },
+  systemButton: { available: false, reason: 'unsupported-provider-mode' },
   triggerAppEvent: { available: false, reason: 'unsupported-provider-mode' },
   setSetting: { available: false, reason: 'unsupported-provider-mode' },
   readAlert: { available: false, reason: 'unsupported-provider-mode' },
diff --git a/packages/contracts/src/platform-runtime-unavailable.ts b/packages/contracts/src/platform-runtime-unavailable.ts
index 4d2499d08c..aa57d5ded9 100644
--- a/packages/contracts/src/platform-runtime-unavailable.ts
+++ b/packages/contracts/src/platform-runtime-unavailable.ts
@@ -21,12 +21,11 @@ import { scrollRuntimeOperationFacts } from './scroll-runtime.ts';
 import { typeTextRuntimeOperationFacts } from './type-text-runtime.ts';
 import { elementTextRuntimeOperationFacts } from './element-text-runtime.ts';
 import { backRuntimeOperationFacts } from './back-runtime.ts';
-import { homeRuntimeOperationFacts } from './home-runtime.ts';
 import { orientationRuntimeOperationFacts } from './orientation-runtime.ts';
 import { tvRemoteRuntimeOperationFacts } from './tv-remote-runtime.ts';
 import { keyboardRuntimeOperationFacts } from './keyboard-runtime.ts';
 import { clipboardRuntimeOperationFacts } from './clipboard-runtime.ts';
-import { appSwitcherRuntimeOperationFacts } from './app-switcher-runtime.ts';
+import { systemButtonRuntimeOperationFacts } from './system-button-runtime.ts';
 import { appEventRuntimeOperationFacts } from './app-event-runtime.ts';
 import { settingsRuntimeOperationFacts } from './settings-runtime.ts';
 import { alertRuntimeOperationFacts } from './alert-runtime.ts';
@@ -58,13 +57,11 @@ export type UnavailablePlatformRuntimeFacts = Readonly<{
   touch: RuntimeOperationUnavailability;
   elementText: RuntimeOperationUnavailability;
   back: RuntimeOperationUnavailability;
-  home: RuntimeOperationUnavailability;
   orientation: RuntimeOperationUnavailability;
   tvRemote: RuntimeOperationUnavailability;
   keyboard: RuntimeOperationUnavailability;
   clipboard: RuntimeOperationUnavailability;
-  appSwitcher: RuntimeOperationUnavailability;
-  actionButton: RuntimeOperationUnavailability;
+  systemButton: RuntimeOperationUnavailability;
   triggerAppEvent: RuntimeOperationUnavailability;
   setSetting: RuntimeOperationUnavailability;
   readAlert: RuntimeOperationUnavailability;
@@ -114,13 +111,11 @@ const UNAVAILABLE_CELLS = {
   touch: true,
   elementText: true,
   back: true,
-  home: true,
   orientation: true,
   tvRemote: true,
   keyboard: true,
   clipboard: true,
-  appSwitcher: true,
-  actionButton: true,
+  systemButton: true,
   triggerAppEvent: true,
   setSetting: true,
   readAlert: true,
@@ -235,13 +230,11 @@ export function createUnavailablePlatformRuntimeFacts(
       }),
       ...elementTextRuntimeOperationFacts({ readTextAtPoint: frozen.elementText }),
       ...backRuntimeOperationFacts({ back: frozen.back }),
-      ...homeRuntimeOperationFacts({ home: frozen.home }),
       ...orientationRuntimeOperationFacts({ orientation: frozen.orientation }),
       ...tvRemoteRuntimeOperationFacts({ tvRemote: frozen.tvRemote }),
       ...keyboardRuntimeOperationFacts({ unsupported: frozen.keyboard }),
       ...clipboardRuntimeOperationFacts({ unsupported: frozen.clipboard }),
-      ...appSwitcherRuntimeOperationFacts({ appSwitcher: frozen.appSwitcher }),
-      actionButton: frozen.actionButton,
+      ...systemButtonRuntimeOperationFacts({ unsupported: frozen.systemButton }),
       ...appEventRuntimeOperationFacts({ triggerAppEvent: frozen.triggerAppEvent }),
       ...settingsRuntimeOperationFacts({ setSetting: frozen.setSetting }),
       ...alertRuntimeOperationFacts({
diff --git a/packages/contracts/src/system-button-runtime.test.ts b/packages/contracts/src/system-button-runtime.test.ts
new file mode 100644
index 0000000000..13468254d1
--- /dev/null
+++ b/packages/contracts/src/system-button-runtime.test.ts
@@ -0,0 +1,73 @@
+import { expect, test, vi } from 'vitest';
+import type { Interactor } from './interactor-types.ts';
+import { localInteractorSource } from './interactor-operation-binding.ts';
+import {
+  SYSTEM_BUTTONS,
+  bindSystemButton,
+  systemButtonRuntimeOperationFacts,
+} from './system-button-runtime.ts';
+
+const device = {
+  platform: 'android',
+  id: 'emulator-5554',
+  name: 'Pixel',
+  kind: 'emulator',
+  booted: true,
+} as const;
+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', () => {
+  expect(systemButtonRuntimeOperationFacts({ unsupported, home: available })).toEqual({
+    home: available,
+    appSwitcher: unsupported,
+    actionButton: unsupported,
+  });
+  expect(systemButtonRuntimeOperationFacts({ unsupported })).toEqual({
+    home: unsupported,
+    appSwitcher: unsupported,
+    actionButton: unsupported,
+  });
+});
+
+test.each(SYSTEM_BUTTONS)(
+  'a local %s binding presses the interactor once with no arguments',
+  async (button) => {
+    const press = vi.fn(async () => undefined);
+    const resolveInteractor = vi.fn(async () => ({ [button]: press }) as unknown as Interactor);
+    const signal = new AbortController().signal;
+
+    const operations = bindSystemButton(
+      button,
+      signal,
+      localInteractorSource({ device, resolveInteractor }),
+    );
+    await operations[button]({
+      options: { appBundleId: 'com.example.app' },
+      execution: { logPath: '/tmp/daemon.log', requestId: `${button}-1` },
+    });
+
+    expect(resolveInteractor).toHaveBeenCalledWith(device, {
+      logPath: '/tmp/daemon.log',
+      requestId: `${button}-1`,
+      appBundleId: 'com.example.app',
+      signal,
+    });
+    expect(press).toHaveBeenCalledExactlyOnceWith();
+  },
+);
+
+test('an admitted button whose interactor lacks the member fails closed instead of no-op success', async () => {
+  const resolveInteractor = vi.fn(async () => ({}) as unknown as Interactor);
+  const operations = bindSystemButton(
+    'actionButton',
+    new AbortController().signal,
+    localInteractorSource({ device, resolveInteractor }),
+  );
+
+  await expect(operations.actionButton({})).rejects.toMatchObject({
+    code: 'COMMAND_FAILED',
+    message: 'action-button was admitted but its bound interactor has no implementation.',
+    details: { reason: 'interactor-method-missing' },
+  });
+});
diff --git a/packages/contracts/src/system-button-runtime.ts b/packages/contracts/src/system-button-runtime.ts
new file mode 100644
index 0000000000..9b17bd4dfd
--- /dev/null
+++ b/packages/contracts/src/system-button-runtime.ts
@@ -0,0 +1,89 @@
+import { requireInteractorMethod } from './interactor-operation-binding.ts';
+import type { Interactor, RunnerContext } from './interactor-types.ts';
+import type { RuntimeOperationFact, RuntimeOperationUnavailability } from './platform-runtime.ts';
+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. 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', 'appSwitcher', 'actionButton'] as const;
+
+export type SystemButton = (typeof SYSTEM_BUTTONS)[number];
+
+/** How a provider fail-closed refusal names each button to the caller. */
+export const SYSTEM_BUTTON_LABELS = {
+  home: 'home',
+  appSwitcher: 'app-switcher',
+  actionButton: 'action-button',
+} as const satisfies Record<SystemButton, string>;
+
+/** Neutral intent for one press: no arguments, so only runner metadata travels. */
+export type SystemButtonInput = Readonly<{
+  options?: Readonly<{ appBundleId?: string }>;
+  /** Same runner metadata a capture needs; reuses that type rather than restating it. */
+  execution?: SnapshotRuntimeExecution;
+}>;
+
+/** A press returns nothing; every leaf discarded whatever the interactor answered. */
+export type SystemButtonRuntimeOperations = Readonly<{
+  [Button in SystemButton]: (input: SystemButtonInput) => Promise<void>;
+}>;
+
+export type SystemButtonRuntimeOperationFacts = Readonly<{
+  [Button in SystemButton]: RuntimeOperationFact;
+}>;
+
+/**
+ * What an owner declares about the system buttons. No button is one every owner carries, so
+ * every cell is optional and `unsupported` names the denial an omitted cell reports: an owner
+ * with no such control states that denial once instead of once per button, and a button added
+ * to {@link SYSTEM_BUTTONS} is refused by every owner that has not named it.
+ *
+ * Omission is a classified denial, never an unclassified cell and never an implied success: the
+ * type refuses a call that does not carry `unsupported`, so no owner can leave the family blank.
+ * An owner that carries one button names it — omission means "refuses", never "the same as the
+ * neighbour".
+ */
+export type SystemButtonRuntimeOperationFactsInput = Readonly<
+  { unsupported: RuntimeOperationUnavailability } & {
+    [Button in SystemButton]?: RuntimeOperationFact;
+  }
+>;
+
+export function systemButtonRuntimeOperationFacts(
+  input: SystemButtonRuntimeOperationFactsInput,
+): SystemButtonRuntimeOperationFacts {
+  const facts = {} as Record<SystemButton, RuntimeOperationFact>;
+  for (const button of SYSTEM_BUTTONS) facts[button] = input[button] ?? input.unsupported;
+  return Object.freeze(facts);
+}
+
+/**
+ * Captures one selected owner's interactor authority for the lifetime of a request binding and
+ * presses one button through it. `Interactor` members for hardware only some owners carry are
+ * optional; facts admit a button only for owners whose interactor implements it, so a missing
+ * method at press time is a runtime-contract error, not a normal refusal.
+ */
+export function bindSystemButton<Button extends SystemButton>(
+  button: Button,
+  signal: AbortSignal,
+  resolveInteractor: (runner: RunnerContext) => Promise<Interactor>,
+): Readonly<Pick<SystemButtonRuntimeOperations, Button>> {
+  const press = async (input: SystemButtonInput): Promise<void> => {
+    signal.throwIfAborted();
+    const interactor = await resolveInteractor({
+      ...input.execution,
+      appBundleId: input.options?.appBundleId,
+      signal,
+    });
+    await requireInteractorMethod(interactor[button], SYSTEM_BUTTON_LABELS[button]).call(
+      interactor,
+    );
+  };
+  return Object.freeze({ [button]: press }) as Readonly<
+    Pick<SystemButtonRuntimeOperations, Button>
+  >;
+}
diff --git a/packages/platform-android/src/runtime.test.ts b/packages/platform-android/src/runtime.test.ts
index b55647999a..138bc23cf5 100644
--- a/packages/platform-android/src/runtime.test.ts
+++ b/packages/platform-android/src/runtime.test.ts
@@ -205,11 +205,11 @@ test('Android refuses the action-button fact on every kind', async () => {
       runtimeDevice,
     );
     // No `input keyevent` reaches a Shortcut the way an iPhone Action Button press does, so this
-    // is a platform-leaf refusal on every kind rather than the shared touch gate `home` rides.
+    // is the system-button family refusal on every kind rather than the touch gate `home` rides.
     expect(binding.facts.operations.actionButton).toEqual({
       available: false,
       reason: 'unsupported-platform-leaf',
-      hint: 'action-button presses iPhone Action Button hardware; Android has no equivalent key event.',
+      hint: 'Android has no key event for this system button.',
     });
     expect(binding.operations.actionButton).toBeUndefined();
   }
diff --git a/packages/platform-android/src/runtime.ts b/packages/platform-android/src/runtime.ts
index 3eaf44b33c..e1905a5e14 100644
--- a/packages/platform-android/src/runtime.ts
+++ b/packages/platform-android/src/runtime.ts
@@ -35,11 +35,10 @@ import { typeTextRuntimeOperationFacts } from '@agent-device/contracts/type-text
 import { touchRuntimeOperationFacts } from '@agent-device/contracts/touch-runtime';
 import { viewportRuntimeOperationFacts } from '@agent-device/contracts/viewport-runtime';
 import { backRuntimeOperationFacts } from '@agent-device/contracts/back-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { bindLocalInteractorOperationSet } from '@agent-device/contracts/local-interactor-operation-set';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
@@ -88,14 +87,14 @@ const hoverUnavailable = Object.freeze({
   reason: 'unsupported-platform-leaf',
 } as const);
 /**
- * The Action Button is physical iPhone hardware with no Android key event behind it: `input
- * keyevent` has no code that reaches a Shortcut the way an Action Button press does, so there is no
- * adb path to admit here even on the kinds every other Android cell admits.
+ * `home` and `app-switcher` are the system buttons `input keyevent` can press. Any other (the
+ * iPhone Action Button today) is hardware with no Android key event behind it, so there is no adb
+ * path to admit even on the kinds every other Android cell admits.
  */
-const actionButtonUnavailable = Object.freeze({
+const systemButtonUnavailable = Object.freeze({
   available: false,
   reason: 'unsupported-platform-leaf',
-  hint: 'action-button presses iPhone Action Button hardware; Android has no equivalent key event.',
+  hint: 'Android has no key event for this system button.',
 } as const);
 const headlessUnavailable = Object.freeze({
   available: false,
@@ -357,11 +356,13 @@ export function createAndroidPlatformRuntime(host: PlatformRuntimeHost): Platfor
           readTextAtPoint: device.kind === 'simulator' ? elementTextKindUnavailable : available,
         }),
         ...backRuntimeOperationFacts({ back: androidTouchFact(device) }),
-        ...homeRuntimeOperationFacts({ home: androidTouchFact(device) }),
-        // `app-switcher` shares `home`'s cell: one `input keyevent`, admitted wherever the
-        // retired `ANDROID_ALL` bucket admitted it.
-        ...appSwitcherRuntimeOperationFacts({ appSwitcher: androidTouchFact(device) }),
-        actionButton: actionButtonUnavailable,
+        // `home` and `app-switcher` are one `input keyevent` each, admitted wherever the retired
+        // `ANDROID_ALL` bucket admitted them.
+        ...systemButtonRuntimeOperationFacts({
+          unsupported: systemButtonUnavailable,
+          home: androidTouchFact(device),
+          appSwitcher: androidTouchFact(device),
+        }),
         // The deep link opens through `am start`, admitted wherever the retired `ANDROID_ALL`
         // bucket admitted it.
         ...appEventRuntimeOperationFacts({ triggerAppEvent: androidTouchFact(device) }),
diff --git a/packages/platform-apple/src/__tests__/interactor-runner-provider.test.ts b/packages/platform-apple/src/__tests__/interactor-runner-provider.test.ts
index dfa876fc26..fa1f6dab4a 100644
--- a/packages/platform-apple/src/__tests__/interactor-runner-provider.test.ts
+++ b/packages/platform-apple/src/__tests__/interactor-runner-provider.test.ts
@@ -74,7 +74,7 @@ const RUNNER_TRANSPORT_METHODS: Record<
   home: { invoke: (i) => i.home(), runnerCommand: 'home' },
   setOrientation: { invoke: (i) => i.setOrientation('portrait'), runnerCommand: 'rotate' },
   appSwitcher: { invoke: (i) => i.appSwitcher(), runnerCommand: 'appSwitcher' },
-  actionButton: { invoke: (i) => i.actionButton(), runnerCommand: 'actionButton' },
+  actionButton: { invoke: (i) => i.actionButton!(), runnerCommand: 'actionButton' },
   tvRemote: { invoke: (i) => i.tvRemote('select'), runnerCommand: 'remotePress' },
   keyboardDismiss: { invoke: (i) => i.keyboardDismiss!(), runnerCommand: 'keyboardDismiss' },
   keyboardEnter: { invoke: (i) => i.keyboardEnter!(), runnerCommand: 'keyboardReturn' },
diff --git a/packages/platform-apple/src/navigation/runtime.ts b/packages/platform-apple/src/navigation/runtime.ts
index 349d15818d..eb0d8af2e9 100644
--- a/packages/platform-apple/src/navigation/runtime.ts
+++ b/packages/platform-apple/src/navigation/runtime.ts
@@ -1,11 +1,10 @@
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
 import { backRuntimeOperationFacts } from '@agent-device/contracts/back-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { bindAdmittedLocalInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
 import { orientationRuntimeOperationFacts } from '@agent-device/contracts/orientation-runtime';
 import type { PlatformRuntimeHost } from '@agent-device/contracts/platform-runtime-operations';
 import type { RuntimeOperationFact } from '@agent-device/contracts/platform-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { tvRemoteRuntimeOperationFacts } from '@agent-device/contracts/tv-remote-runtime';
 import {
   hasAppleActionButton,
@@ -132,6 +131,12 @@ function appleKeyboardEnterFact(device: DeviceInfo): RuntimeOperationFact {
   return appleMobileInputEligible(device) ? available : keyboardCellUnavailable;
 }
 
+/** Every system button this owner knows is named below; the family denial covers none today. */
+const systemButtonUnavailable = Object.freeze({
+  available: false,
+  reason: 'unsupported-platform-leaf',
+  hint: 'No Apple leaf carries this system button.',
+} as const);
 const actionButtonKindUnavailable = Object.freeze({
   available: false,
   reason: 'unsupported-device-kind',
@@ -161,13 +166,14 @@ function appleActionButtonFact(device: DeviceInfo): RuntimeOperationFact {
 export function appleNavigationFacts(device: DeviceInfo) {
   return Object.freeze({
     ...backRuntimeOperationFacts({ back: appleBackFact(device) }),
-    ...homeRuntimeOperationFacts({ home: appleSpringboardFact(device, homeKindUnavailable) }),
-    ...appSwitcherRuntimeOperationFacts({
+    ...systemButtonRuntimeOperationFacts({
+      unsupported: systemButtonUnavailable,
+      home: appleSpringboardFact(device, homeKindUnavailable),
       appSwitcher: appleSpringboardFact(device, appSwitcherKindUnavailable),
+      actionButton: appleActionButtonFact(device),
     }),
     ...orientationRuntimeOperationFacts({ orientation: appleOrientationFact(device) }),
     ...tvRemoteRuntimeOperationFacts({ tvRemote: appleTvRemoteFact(device) }),
-    actionButton: appleActionButtonFact(device),
     ...keyboardRuntimeOperationFacts({
       unsupported: keyboardCellUnavailable,
       status: appleKeyboardStatusFact(device),
diff --git a/packages/platform-harmonyos/src/runtime.ts b/packages/platform-harmonyos/src/runtime.ts
index ffc3e2b137..cad66c125e 100644
--- a/packages/platform-harmonyos/src/runtime.ts
+++ b/packages/platform-harmonyos/src/runtime.ts
@@ -23,12 +23,11 @@ import {
   bindLocalScrollInteractor,
   scrollRuntimeOperationFacts,
 } from '@agent-device/contracts/scroll-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { bindAdmittedLocalInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
 import { orientationRuntimeOperationFacts } from '@agent-device/contracts/orientation-runtime';
@@ -272,11 +271,13 @@ export function createHarmonyPlatformRuntime(host: PlatformRuntimeHost): Platfor
         // the legacy dispatch already did after its Apple-runner attempt failed.
         ...elementTextRuntimeOperationFacts({ readTextAtPoint: elementTextUnavailable }),
         ...backRuntimeOperationFacts({ back: harmonyFocusFact(device) }),
-        ...homeRuntimeOperationFacts({ home: harmonyFocusFact(device) }),
-        // App switcher rides the same HDC-driven key input as home, so it shares that cell.
-        ...appSwitcherRuntimeOperationFacts({ appSwitcher: harmonyFocusFact(device) }),
-        // HarmonyOS devices have no Action Button control for HDC to press.
-        actionButton: harmonyPlatformLeafUnavailable,
+        // Home and the app switcher ride the same HDC-driven key input; no other system button
+        // has a HarmonyOS control for HDC to press.
+        ...systemButtonRuntimeOperationFacts({
+          unsupported: harmonyPlatformLeafUnavailable,
+          home: harmonyFocusFact(device),
+          appSwitcher: harmonyFocusFact(device),
+        }),
         // HarmonyOS has no trigger-app-event implementation.
         ...appEventRuntimeOperationFacts({ triggerAppEvent: harmonyPlatformLeafUnavailable }),
         // The HDC-driven settings surface shares the interaction kind gate.
diff --git a/packages/platform-linux/src/runtime.ts b/packages/platform-linux/src/runtime.ts
index 8fa7bd9422..3809d120a9 100644
--- a/packages/platform-linux/src/runtime.ts
+++ b/packages/platform-linux/src/runtime.ts
@@ -19,7 +19,7 @@ import { focusRuntimeOperationFacts } from '@agent-device/contracts/focus-runtim
 import { TARGET_AUTHORED_DRAG_UNSUPPORTED_HINT } from '@agent-device/contracts/gesture-admission';
 import { gestureRuntimeOperationFacts } from '@agent-device/contracts/gesture-runtime';
 import { scrollRuntimeOperationFacts } from '@agent-device/contracts/scroll-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { bindLocalInteractorOperationSet } from '@agent-device/contracts/local-interactor-operation-set';
 import { localRuntimeOwner, sameRuntimeOwner } from '@agent-device/contracts/platform-runtime';
@@ -193,15 +193,12 @@ function linuxFacts(device: DeviceInfo): RuntimeFacts<PlatformRuntimeOperations>
     touch: focusKindUnavailable,
     elementText: elementTextKindUnavailable,
     back: backKindUnavailable,
-    home: homeKindUnavailable,
     orientation: linuxPlatformLeafUnavailable,
     tvRemote: linuxPlatformLeafUnavailable,
     clipboard: clipboardKindUnavailable,
-    // The Linux interactor's own `appSwitcher` throws unsupported, and the retired descriptor
-    // declared `linux: {}`, so no Linux cell was ever admitted.
-    appSwitcher: linuxPlatformLeafUnavailable,
-    // No Linux leaf has an Action Button; the interactor states the same refusal.
-    actionButton: linuxPlatformLeafUnavailable,
+    // `home` is the one system button with a desktop cell, declared below; the Linux interactor's
+    // own `appSwitcher` throws unsupported, and no Linux leaf has hardware buttons.
+    systemButton: linuxPlatformLeafUnavailable,
     // The retired `trigger-app-event` descriptor declared `linux: {}`.
     triggerAppEvent: linuxPlatformLeafUnavailable,
     // The retired `settings` descriptor declared `linux: {}` too.
@@ -266,7 +263,10 @@ function linuxFacts(device: DeviceInfo): RuntimeFacts<PlatformRuntimeOperations>
       // Parity with the retired `back`/`home` capability bucket (`{ device: true }`): the desktop
       // is the only Linux cell with a target to drive.
       ...backRuntimeOperationFacts({ back: linuxDesktopFact(device, backKindUnavailable) }),
-      ...homeRuntimeOperationFacts({ home: linuxDesktopFact(device, homeKindUnavailable) }),
+      ...systemButtonRuntimeOperationFacts({
+        unsupported: linuxPlatformLeafUnavailable,
+        home: linuxDesktopFact(device, homeKindUnavailable),
+      }),
       // Parity with the retired `clipboard` capability bucket (`{ device: true }`): wl-clipboard
       // / xclip / xsel drive the desktop session's selection, and no other Linux cell has one.
       ...clipboardRuntimeOperationFacts({
diff --git a/packages/platform-vega/src/__tests__/unsupported-interactor.test.ts b/packages/platform-vega/src/__tests__/unsupported-interactor.test.ts
index f83b51fd2d..02ee9ef151 100644
--- a/packages/platform-vega/src/__tests__/unsupported-interactor.test.ts
+++ b/packages/platform-vega/src/__tests__/unsupported-interactor.test.ts
@@ -20,7 +20,6 @@ const OPERATIONS = [
   'home',
   'setOrientation',
   'appSwitcher',
-  'actionButton',
   'tvRemote',
   'readClipboard',
   'writeClipboard',
diff --git a/packages/platform-vega/src/runtime.test.ts b/packages/platform-vega/src/runtime.test.ts
index 199a40375d..82b25904cc 100644
--- a/packages/platform-vega/src/runtime.test.ts
+++ b/packages/platform-vega/src/runtime.test.ts
@@ -188,12 +188,14 @@ test.each([
       });
       expect(binding.operations[operation]).toBeUndefined();
     }
-    expect(binding.facts.operations.appSwitcher).toMatchObject({
-      available: false,
-      reason: 'unsupported-platform-leaf',
-      hint: 'app-switcher is not supported on Vega OS.',
-    });
-    expect(binding.operations.appSwitcher).toBeUndefined();
+    for (const button of ['appSwitcher', 'actionButton'] as const) {
+      expect(binding.facts.operations[button]).toMatchObject({
+        available: false,
+        reason: 'unsupported-platform-leaf',
+        hint: 'System buttons other than home are not supported on Vega OS.',
+      });
+      expect(binding.operations[button]).toBeUndefined();
+    }
     expect(binding.facts.operations.triggerAppEvent).toMatchObject({
       available: false,
       reason: 'unsupported-platform-leaf',
diff --git a/packages/platform-vega/src/runtime.ts b/packages/platform-vega/src/runtime.ts
index 0c268ae241..e5ab36d2c9 100644
--- a/packages/platform-vega/src/runtime.ts
+++ b/packages/platform-vega/src/runtime.ts
@@ -13,7 +13,7 @@ import {
   availableApplicationLifecycleOperations,
 } from '@agent-device/contracts/application-lifecycle-runtime';
 import { backRuntimeOperationFacts } from '@agent-device/contracts/back-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { bindAdmittedLocalInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import { localRuntimeOwner, sameRuntimeOwner } from '@agent-device/contracts/platform-runtime';
 import { createUnavailablePlatformRuntimeFacts } from '@agent-device/contracts/platform-runtime-unavailable';
@@ -143,13 +143,9 @@ const appEventUnavailable = vegaUnavailable(
   'unsupported-platform-leaf',
   'trigger-app-event is not supported on Vega OS.',
 );
-const appSwitcherUnavailable = vegaUnavailable(
+const systemButtonUnavailable = vegaUnavailable(
   'unsupported-platform-leaf',
-  'app-switcher is not supported on Vega OS.',
-);
-const actionButtonUnavailable = vegaUnavailable(
-  'unsupported-platform-leaf',
-  'action-button is not supported on Vega OS.',
+  'System buttons other than home are not supported on Vega OS.',
 );
 const clipboardUnavailable = vegaUnavailable(
   'unsupported-platform-leaf',
@@ -192,12 +188,10 @@ function vegaFacts(device: DeviceInfo): RuntimeFacts<PlatformRuntimeOperations>
     touch: unsupportedPlatformLeaf,
     elementText: unsupportedPlatformLeaf,
     back: backUnavailable,
-    home: homeUnavailable,
     orientation: orientationUnavailable,
     tvRemote: tvRemoteUnavailable,
     clipboard: clipboardUnavailable,
-    appSwitcher: appSwitcherUnavailable,
-    actionButton: actionButtonUnavailable,
+    systemButton: systemButtonUnavailable,
     triggerAppEvent: appEventUnavailable,
     setSetting: settingsUnavailable,
     readAlert: alertUnavailable,
@@ -228,7 +222,10 @@ function vegaFacts(device: DeviceInfo): RuntimeFacts<PlatformRuntimeOperations>
       // Remote navigation is the Vega runtime's first available interaction surface: the
       // VVD-only gate the retired `vegaPlugin` closure applied to all three.
       ...backRuntimeOperationFacts({ back: supported ? lifecycleAvailable : backUnavailable }),
-      ...homeRuntimeOperationFacts({ home: supported ? lifecycleAvailable : homeUnavailable }),
+      ...systemButtonRuntimeOperationFacts({
+        unsupported: systemButtonUnavailable,
+        home: supported ? lifecycleAvailable : homeUnavailable,
+      }),
       ...tvRemoteRuntimeOperationFacts({
         tvRemote: supported ? lifecycleAvailable : tvRemoteUnavailable,
       }),
diff --git a/packages/platform-vega/src/unsupported-interactor.ts b/packages/platform-vega/src/unsupported-interactor.ts
index c36846044c..f96e878cc3 100644
--- a/packages/platform-vega/src/unsupported-interactor.ts
+++ b/packages/platform-vega/src/unsupported-interactor.ts
@@ -27,7 +27,6 @@ export function createUnsupportedInteractor(platformLabel: string): Interactor {
     home: () => unsupported('home'),
     setOrientation: () => unsupported('setOrientation'),
     appSwitcher: () => unsupported('appSwitcher'),
-    actionButton: () => unsupported('actionButton'),
     tvRemote: () => unsupported('tvRemote'),
     readClipboard: () => unsupported('readClipboard'),
     writeClipboard: () => unsupported('writeClipboard'),
diff --git a/packages/platform-web/src/runtime.ts b/packages/platform-web/src/runtime.ts
index 8ddd17f8ab..83853f75b9 100644
--- a/packages/platform-web/src/runtime.ts
+++ b/packages/platform-web/src/runtime.ts
@@ -45,13 +45,12 @@ import {
 } from '@agent-device/contracts/touch-runtime';
 import { viewportRuntimeOperationFacts } from '@agent-device/contracts/viewport-runtime';
 import { backRuntimeOperationFacts } from '@agent-device/contracts/back-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { orientationRuntimeOperationFacts } from '@agent-device/contracts/orientation-runtime';
 import { tvRemoteRuntimeOperationFacts } from '@agent-device/contracts/tv-remote-runtime';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
 import {
@@ -407,7 +406,6 @@ function webRuntimeFacts(
       // which is what the legacy dispatch already did once its Apple-runner attempt failed.
       ...elementTextRuntimeOperationFacts({ readTextAtPoint: elementTextUnavailable }),
       ...backRuntimeOperationFacts({ back: navigationUnavailable }),
-      ...homeRuntimeOperationFacts({ home: navigationUnavailable }),
       ...orientationRuntimeOperationFacts({ orientation: navigationUnavailable }),
       ...tvRemoteRuntimeOperationFacts({ tvRemote: navigationUnavailable }),
       ...keyboardRuntimeOperationFacts({ unsupported: navigationUnavailable }),
@@ -424,8 +422,7 @@ function webRuntimeFacts(
         nativeCapture: navigationUnavailable,
         profileReport: navigationUnavailable,
       }),
-      ...appSwitcherRuntimeOperationFacts({ appSwitcher: navigationUnavailable }),
-      actionButton: navigationUnavailable,
+      ...systemButtonRuntimeOperationFacts({ unsupported: navigationUnavailable }),
       ...appEventRuntimeOperationFacts({ triggerAppEvent: navigationUnavailable }),
       ...settingsRuntimeOperationFacts({ setSetting: navigationUnavailable }),
       ...alertRuntimeOperationFacts({
diff --git a/packages/provider-limrun/src/app-log-runtime.ts b/packages/provider-limrun/src/app-log-runtime.ts
index 80b7842753..defb1b8a34 100644
--- a/packages/provider-limrun/src/app-log-runtime.ts
+++ b/packages/provider-limrun/src/app-log-runtime.ts
@@ -1,10 +1,7 @@
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import type { AppsFilter, ProviderPortReverseOptions } from '@agent-device/contracts/device';
 import type { Interactor, RunnerContext } from '@agent-device/contracts/interactor-types';
-import {
-  LIMRUN_ACTION_BUTTON_UNAVAILABLE,
-  bindLimrunInteractionOperations,
-} from './interaction-operations.ts';
+import { bindLimrunInteractionOperations } from './interaction-operations.ts';
 import { bindAdmittedProviderInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import { AppError } from '@agent-device/kernel/errors';
 import { isSupportedLimrunAppLogDevice, parseLimrunDeviceId } from './device.ts';
@@ -113,13 +110,11 @@ export function createLimrunPlatformRuntimeOwner(
             touch: liveSessionUnavailable,
             elementText: liveSessionUnavailable,
             back: liveSessionUnavailable,
-            home: liveSessionUnavailable,
             orientation: liveSessionUnavailable,
             tvRemote: liveSessionUnavailable,
             keyboard: liveSessionUnavailable,
             clipboard: liveSessionUnavailable,
-            appSwitcher: liveSessionUnavailable,
-            actionButton: LIMRUN_ACTION_BUTTON_UNAVAILABLE,
+            systemButton: liveSessionUnavailable,
             triggerAppEvent: liveSessionUnavailable,
             setSetting: liveSessionUnavailable,
             readAlert: liveSessionUnavailable,
diff --git a/packages/provider-limrun/src/facts-runtime.ts b/packages/provider-limrun/src/facts-runtime.ts
index 5682c74233..ac4bc6a281 100644
--- a/packages/provider-limrun/src/facts-runtime.ts
+++ b/packages/provider-limrun/src/facts-runtime.ts
@@ -21,8 +21,7 @@ import {
   limrunAppEventOperationFacts,
   limrunSettingsOperationFacts,
   limrunAlertOperationFacts,
-  limrunActionButtonOperationFacts,
-  limrunAppSwitcherOperationFacts,
+  limrunSystemButtonOperationFacts,
   limrunClipboardOperationFacts,
   limrunNavigationOperationFacts,
 } from './interaction-operations.ts';
@@ -194,8 +193,7 @@ export function limrunAppLogFacts(
       ...limrunNavigationOperationFacts(device),
       ...limrunKeyboardOperationFacts(device),
       ...limrunClipboardOperationFacts(device),
-      ...limrunAppSwitcherOperationFacts(device),
-      ...limrunActionButtonOperationFacts(),
+      ...limrunSystemButtonOperationFacts(device),
       ...limrunAppEventOperationFacts(device),
       ...limrunSettingsOperationFacts(device),
       ...limrunAlertOperationFacts(device),
@@ -257,8 +255,7 @@ export function limrunAppLogRecoveryFacts(
       ...limrunNavigationOperationFacts(device, liveSessionUnavailable),
       ...limrunKeyboardOperationFacts(device, liveSessionUnavailable),
       ...limrunClipboardOperationFacts(device, liveSessionUnavailable),
-      ...limrunAppSwitcherOperationFacts(device, liveSessionUnavailable),
-      ...limrunActionButtonOperationFacts(),
+      ...limrunSystemButtonOperationFacts(device, liveSessionUnavailable),
       ...limrunAppEventOperationFacts(device, liveSessionUnavailable),
       ...limrunSettingsOperationFacts(device, liveSessionUnavailable),
       ...limrunAlertOperationFacts(device, liveSessionUnavailable),
diff --git a/packages/provider-limrun/src/interaction-operations.test.ts b/packages/provider-limrun/src/interaction-operations.test.ts
index 6877f61ec4..d24aa47bf8 100644
--- a/packages/provider-limrun/src/interaction-operations.test.ts
+++ b/packages/provider-limrun/src/interaction-operations.test.ts
@@ -6,7 +6,7 @@ import {
   limrunAppEventOperationFacts,
   limrunAlertOperationFacts,
   limrunSettingsOperationFacts,
-  limrunAppSwitcherOperationFacts,
+  limrunSystemButtonOperationFacts,
   limrunClipboardOperationFacts,
   limrunInteractionOperationFacts,
   limrunNavigationOperationFacts,
@@ -41,10 +41,9 @@ const liveSessionUnavailable = Object.freeze({
   hint: 'The Limrun provider session is no longer active for this device.',
 } as const);
 
-test('the Android leg admits back/home/orientation and gates tv-remote on a real TV target', () => {
+test('the Android leg admits back/orientation and gates tv-remote on a real TV target', () => {
   const mobile = limrunNavigationOperationFacts(androidMobileDevice);
   expect(mobile.back).toEqual({ available: true });
-  expect(mobile.home).toEqual({ available: true });
   expect(mobile.setOrientation).toEqual({ available: true });
   expect(mobile.tvRemote).toEqual({
     available: false,
@@ -78,19 +77,34 @@ test('clipboard follows the same Android-reuse / iOS-refusal split its siblings
   expect(stale.writeClipboard).toEqual(liveSessionUnavailable);
 });
 
-// R56: same Android-reuse / iOS-refusal split.
-test('app-switcher rides the Android interactor and is refused on the iOS leg', () => {
-  expect(limrunAppSwitcherOperationFacts(androidMobileDevice).appSwitcher).toEqual({
-    available: true,
+// R56: the springboard buttons follow the same Android-reuse / iOS-refusal split; a hardware
+// button is refused on both legs, and a dead session closes the whole family.
+test('home and app-switcher ride the Android interactor and are refused on the iOS leg', () => {
+  const android = limrunSystemButtonOperationFacts(androidMobileDevice);
+  expect(android.home).toEqual({ available: true });
+  expect(android.appSwitcher).toEqual({ available: true });
+  expect(android.actionButton).toMatchObject({
+    available: false,
+    reason: 'unsupported-provider-mode',
   });
-  expect(limrunAppSwitcherOperationFacts(iosDevice).appSwitcher).toEqual({
+
+  const ios = limrunSystemButtonOperationFacts(iosDevice);
+  expect(ios.home).toEqual({
+    available: false,
+    reason: 'unsupported-provider-mode',
+    hint: 'Limrun iOS direct sessions do not expose home yet.',
+  });
+  expect(ios.appSwitcher).toEqual({
     available: false,
     reason: 'unsupported-provider-mode',
     hint: 'Limrun iOS direct sessions do not expose app switcher yet.',
   });
-  expect(
-    limrunAppSwitcherOperationFacts(androidMobileDevice, liveSessionUnavailable).appSwitcher,
-  ).toEqual(liveSessionUnavailable);
+  expect(ios.actionButton).toMatchObject({ available: false, reason: 'unsupported-provider-mode' });
+
+  const stale = limrunSystemButtonOperationFacts(androidMobileDevice, liveSessionUnavailable);
+  expect(stale.home).toEqual(liveSessionUnavailable);
+  expect(stale.appSwitcher).toEqual(liveSessionUnavailable);
+  expect(stale.actionButton).toEqual(liveSessionUnavailable);
 });
 
 // R57: app-event delivery is the one system leaf BOTH direct-session legs serve, because each
@@ -135,15 +149,10 @@ test('alert legs ride the Android interactor and are refused on the iOS leg', ()
   }
 });
 
-test('the iOS leg admits back/orientation but explicitly refuses home and tv-remote', () => {
+test('the iOS leg admits back/orientation but explicitly refuses tv-remote', () => {
   const facts = limrunNavigationOperationFacts(iosDevice);
   expect(facts.back).toEqual({ available: true });
   expect(facts.setOrientation).toEqual({ available: true });
-  expect(facts.home).toEqual({
-    available: false,
-    reason: 'unsupported-provider-mode',
-    hint: 'Limrun iOS direct sessions do not expose home yet.',
-  });
   expect(facts.tvRemote).toEqual({
     available: false,
     reason: 'unsupported-provider-mode',
@@ -151,10 +160,9 @@ test('the iOS leg admits back/orientation but explicitly refuses home and tv-rem
   });
 });
 
-test('a dead session closes all four navigation cells with the same reason regardless of platform', () => {
+test('a dead session closes all three navigation cells with the same reason regardless of platform', () => {
   const facts = limrunNavigationOperationFacts(androidTvDevice, liveSessionUnavailable);
   expect(facts.back).toEqual(liveSessionUnavailable);
-  expect(facts.home).toEqual(liveSessionUnavailable);
   expect(facts.setOrientation).toEqual(liveSessionUnavailable);
   expect(facts.tvRemote).toEqual(liveSessionUnavailable);
 });
@@ -177,7 +185,10 @@ test('binds only the operations the facts admitted, driving the resolved interac
     },
   } as unknown as Interactor;
   const getInteractor = (_device: DeviceInfo, _runner?: RunnerContext) => interactor;
-  const facts = limrunNavigationOperationFacts(androidTvDevice);
+  const facts = {
+    ...limrunNavigationOperationFacts(androidTvDevice),
+    ...limrunSystemButtonOperationFacts(androidTvDevice),
+  };
 
   const operations = bindAdmittedProviderInteractorOperations({
     device: androidTvDevice,
@@ -200,7 +211,10 @@ test('binds only the operations the facts admitted, driving the resolved interac
 });
 
 test('binding omits every operation an unavailable fact refused', () => {
-  const facts = limrunNavigationOperationFacts(iosDevice);
+  const facts = {
+    ...limrunNavigationOperationFacts(iosDevice),
+    ...limrunSystemButtonOperationFacts(iosDevice),
+  };
   const operations = bindAdmittedProviderInteractorOperations({
     device: iosDevice,
     signal: new AbortController().signal,
diff --git a/packages/provider-limrun/src/interaction-operations.ts b/packages/provider-limrun/src/interaction-operations.ts
index 2ba70fe3ab..411d2eb232 100644
--- a/packages/provider-limrun/src/interaction-operations.ts
+++ b/packages/provider-limrun/src/interaction-operations.ts
@@ -16,11 +16,10 @@ import {
   bindProviderScrollInteractor,
   scrollRuntimeOperationFacts,
 } from '@agent-device/contracts/scroll-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
 import { orientationRuntimeOperationFacts } from '@agent-device/contracts/orientation-runtime';
@@ -142,16 +141,11 @@ const appSwitcherUnavailableIos = Object.freeze({
   reason: 'unsupported-provider-mode',
   hint: 'Limrun iOS direct sessions do not expose app switcher yet.',
 } as const);
-/**
- * Refused on both legs, so — unlike `limrunAppSwitcherOperationFacts`, whose Android leg rides the
- * local Android interactor — this needs no device-parameterized helper: the iOS session has no
- * Action Button transport, and the Android leg's own interactor refuses for the same reason the
- * local Android fact does.
- */
-export const LIMRUN_ACTION_BUTTON_UNAVAILABLE = Object.freeze({
+/** No Limrun session exposes a hardware button; only the springboard buttons split by leg. */
+const systemButtonUnavailable = Object.freeze({
   available: false,
   reason: 'unsupported-provider-mode',
-  hint: 'action-button presses iPhone Action Button hardware, which no Limrun session exposes.',
+  hint: 'No Limrun session exposes this system button.',
 } as const);
 
 /**
@@ -231,11 +225,11 @@ export function bindLimrunInteractionOperations(
 }
 
 /**
- * `back`/`home`/`orientation`/`tvRemote` differ by direct-session platform, unlike focus/type:
+ * `back`/`orientation`/`tvRemote` differ by direct-session platform, unlike focus/type:
  * the Android leg rides `session.dependencies.android.createInteractor` (`android.ts`) — the
  * SAME factory the local Android family binds, so it carries the identical cell table (parity
  * with the local owner, including the `device.target === 'tv'` gate for `tvRemote`). The iOS leg
- * (`ios.ts`) implements `back`/`setOrientation` but explicitly refuses `home`/`tvRemote`.
+ * (`ios.ts`) implements `back`/`setOrientation` but explicitly refuses `tvRemote`.
  */
 export function limrunNavigationOperationFacts(
   device: DeviceInfo,
@@ -244,7 +238,6 @@ export function limrunNavigationOperationFacts(
   if (liveSessionUnavailable) {
     return Object.freeze({
       ...backRuntimeOperationFacts({ back: liveSessionUnavailable }),
-      ...homeRuntimeOperationFacts({ home: liveSessionUnavailable }),
       ...orientationRuntimeOperationFacts({ orientation: liveSessionUnavailable }),
       ...tvRemoteRuntimeOperationFacts({ tvRemote: liveSessionUnavailable }),
     });
@@ -252,7 +245,6 @@ export function limrunNavigationOperationFacts(
   if (device.platform === 'android') {
     return Object.freeze({
       ...backRuntimeOperationFacts({ back: available }),
-      ...homeRuntimeOperationFacts({ home: available }),
       ...orientationRuntimeOperationFacts({ orientation: available }),
       ...tvRemoteRuntimeOperationFacts({
         tvRemote: device.target === 'tv' ? available : tvRemoteUnavailableAndroid,
@@ -261,7 +253,6 @@ export function limrunNavigationOperationFacts(
   }
   return Object.freeze({
     ...backRuntimeOperationFacts({ back: available }),
-    ...homeRuntimeOperationFacts({ home: homeUnavailableIos }),
     ...orientationRuntimeOperationFacts({ orientation: available }),
     ...tvRemoteRuntimeOperationFacts({ tvRemote: tvRemoteUnavailableIos }),
   });
@@ -325,24 +316,28 @@ export function limrunAlertOperationFacts(
 }
 
 /**
- * `app-switcher` splits the same way its siblings do: the Android leg rides
- * `session.dependencies.android.createInteractor` -- the SAME factory the local Android family
- * binds -- while the iOS leg's own `appSwitcher` throws.
+ * The system buttons split the way the navigation leaves do: the Android leg rides the local
+ * family's own interactor factory for `home` and `appSwitcher`, the iOS direct session refuses
+ * both, and no Limrun session exposes a hardware button on either leg.
  */
-export function limrunAppSwitcherOperationFacts(
+export function limrunSystemButtonOperationFacts(
   device: DeviceInfo,
   liveSessionUnavailable?: RuntimeOperationUnavailability,
 ) {
-  const cell =
-    liveSessionUnavailable ??
-    (device.platform === 'android' ? available : appSwitcherUnavailableIos);
-  return Object.freeze({ ...appSwitcherRuntimeOperationFacts({ appSwitcher: cell }) });
-}
-
-/** The Action Button refusal both Limrun legs share. */
-export function limrunActionButtonOperationFacts() {
-  return Object.freeze({
-    actionButton: LIMRUN_ACTION_BUTTON_UNAVAILABLE,
+  if (liveSessionUnavailable) {
+    return systemButtonRuntimeOperationFacts({ unsupported: liveSessionUnavailable });
+  }
+  if (device.platform === 'android') {
+    return systemButtonRuntimeOperationFacts({
+      unsupported: systemButtonUnavailable,
+      home: available,
+      appSwitcher: available,
+    });
+  }
+  return systemButtonRuntimeOperationFacts({
+    unsupported: systemButtonUnavailable,
+    home: homeUnavailableIos,
+    appSwitcher: appSwitcherUnavailableIos,
   });
 }
 
diff --git a/packages/provider-limrun/src/ios.ts b/packages/provider-limrun/src/ios.ts
index e513e0f3e0..ac0dd01719 100644
--- a/packages/provider-limrun/src/ios.ts
+++ b/packages/provider-limrun/src/ios.ts
@@ -347,13 +347,6 @@ class LimrunIosInteractor implements Interactor {
     throw unsupported('app-switcher', 'Limrun iOS direct sessions do not expose app switcher yet.');
   }
 
-  async actionButton(): Promise<never> {
-    throw unsupported(
-      'action-button',
-      'Limrun iOS direct sessions do not expose the Action Button.',
-    );
-  }
-
   async tvRemote(): Promise<never> {
     throw unsupported('tv-remote', 'Limrun iOS direct sessions do not expose tv remote control.');
   }
diff --git a/packages/provider-webdriver/src/platform-runtime.ts b/packages/provider-webdriver/src/platform-runtime.ts
index f90441fd51..74020d5f01 100644
--- a/packages/provider-webdriver/src/platform-runtime.ts
+++ b/packages/provider-webdriver/src/platform-runtime.ts
@@ -22,12 +22,11 @@ import {
   bindProviderScrollInteractor,
   scrollRuntimeOperationFacts,
 } from '@agent-device/contracts/scroll-runtime';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
 import { bindAdmittedProviderInteractorOperations } from '@agent-device/contracts/interactor-operation-catalog';
 import { appEventRuntimeOperationFacts } from '@agent-device/contracts/app-event-runtime';
 import { alertRuntimeOperationFacts } from '@agent-device/contracts/alert-runtime';
 import { settingsRuntimeOperationFacts } from '@agent-device/contracts/settings-runtime';
-import { appSwitcherRuntimeOperationFacts } from '@agent-device/contracts/app-switcher-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { orientationRuntimeOperationFacts } from '@agent-device/contracts/orientation-runtime';
 import { tvRemoteRuntimeOperationFacts } from '@agent-device/contracts/tv-remote-runtime';
@@ -231,15 +230,15 @@ const appSwitcherUnavailable = Object.freeze({
 } as const);
 
 /**
- * Unlike its `appSwitcher` neighbour this is never a per-session capability question: no WebDriver
- * `mobile:` script presses an iPhone Action Button, so the interactor refuses unconditionally and
- * the fact refuses unconditionally to match. There is deliberately no capability key declared for
- * it, which would advertise a button this provider can never press.
+ * Unlike `home` and `appSwitcher` this is never a per-session capability question: no WebDriver
+ * `mobile:` script presses hardware such as the iPhone Action Button, so the fact refuses
+ * unconditionally. There is deliberately no capability key for it, which would advertise a button
+ * this provider can never press.
  */
-const actionButtonUnavailable = Object.freeze({
+const systemButtonUnavailable = Object.freeze({
   available: false,
   reason: 'unsupported-provider-mode',
-  hint: 'action-button presses iPhone Action Button hardware, which no WebDriver backend exposes.',
+  hint: 'No WebDriver backend presses this system button.',
 } as const);
 
 /**
@@ -527,13 +526,11 @@ function webDriverFacts(
       touch: inactiveSession,
       elementText: inactiveSession,
       back: inactiveSession,
-      home: inactiveSession,
       orientation: inactiveSession,
       tvRemote: inactiveSession,
       keyboard: inactiveSession,
       clipboard: inactiveSession,
-      appSwitcher: inactiveSession,
-      actionButton: actionButtonUnavailable,
+      systemButton: inactiveSession,
       triggerAppEvent: inactiveSession,
       setSetting: inactiveSession,
       readAlert: inactiveSession,
@@ -571,13 +568,11 @@ function webDriverFacts(
     touch: typeUnavailable,
     elementText: elementTextUnavailable,
     back: backUnavailable,
-    home: homeUnavailable,
     orientation: orientationUnavailable,
     tvRemote: tvRemoteUnavailable,
     keyboard: keyboardUnavailable,
     clipboard: clipboardUnavailable,
-    appSwitcher: appSwitcherUnavailable,
-    actionButton: actionButtonUnavailable,
+    systemButton: systemButtonUnavailable,
     triggerAppEvent: appEventUnavailable,
     setSetting: settingsUnavailable,
     readAlert: alertUnavailable,
@@ -651,7 +646,6 @@ function webDriverFacts(
       // `back`/`home`/`orientation` ride the same reachable interactor; `tvRemote` always throws
       // unsupported in this interactor regardless of reachability (no capability declares it).
       ...backRuntimeOperationFacts({ back: declared('back', backUnavailable) }),
-      ...homeRuntimeOperationFacts({ home: declared('home', homeUnavailable) }),
       ...orientationRuntimeOperationFacts({
         orientation: declared('orientation', orientationUnavailable),
       }),
@@ -669,10 +663,11 @@ function webDriverFacts(
         read: declared('clipboard.read', clipboardUnavailable),
         write: declared('clipboard.write', clipboardUnavailable),
       }),
-      ...appSwitcherRuntimeOperationFacts({
+      ...systemButtonRuntimeOperationFacts({
+        unsupported: systemButtonUnavailable,
+        home: declared('home', homeUnavailable),
         appSwitcher: declared('appSwitcher', appSwitcherUnavailable),
       }),
-      actionButton: actionButtonUnavailable,
       // The deep link opens through the same reachable interactor `open` every lifecycle command
       // drives on this provider.
       ...appEventRuntimeOperationFacts({
diff --git a/packages/provider-webdriver/src/webdriver-interactor.ts b/packages/provider-webdriver/src/webdriver-interactor.ts
index 00cb488164..239839c3be 100644
--- a/packages/provider-webdriver/src/webdriver-interactor.ts
+++ b/packages/provider-webdriver/src/webdriver-interactor.ts
@@ -361,24 +361,6 @@ class WebDriverInteractor implements Interactor {
     this.unsupported('tvRemote');
   }
 
-  /**
-   * No WebDriver `mobile:` script presses an iPhone Action Button, so this refuses unconditionally
-   * and directly: it goes through no `requireSupport`/`unsupported` capability helper because a
-   * capability key here would advertise a button no WebDriver backend can ever report supporting.
-   */
-  async actionButton(): Promise<never> {
-    throw new AppError(
-      'UNSUPPORTED_OPERATION',
-      'action-button presses iPhone Action Button hardware, which no WebDriver backend exposes',
-      {
-        provider: this.capabilities.provider,
-        platform: this.capabilities.platform,
-        operation: 'actionButton',
-        reason: 'unsupported-provider-mode',
-      },
-    );
-  }
-
   async readClipboard(): Promise<string> {
     this.requireSupport('clipboard.read');
     const value = await this.client.executeScript('mobile: getClipboard', [{}]);
diff --git a/scripts/integration-progress-model.test.ts b/scripts/integration-progress-model.test.ts
index 600b393184..dc90be093a 100644
--- a/scripts/integration-progress-model.test.ts
+++ b/scripts/integration-progress-model.test.ts
@@ -32,3 +32,34 @@ test('integration progress counts explicit generic Apple host-tool usage only',
     await rm(root, { recursive: true, force: true });
   }
 });
+
+test('integration progress maps a parameterless facet to its client method', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'agent-device-progress-'));
+  try {
+    const commandsDir = path.join(root, 'src/commands/system');
+    const scenarioDir = path.join(root, 'test/integration/provider-scenarios');
+    await mkdir(commandsDir, { recursive: true });
+    await mkdir(scenarioDir, { recursive: true });
+    await writeFile(
+      path.join(commandsDir, 'index.ts'),
+      [
+        "const HOME_COMMAND_NAME = 'home';",
+        'const homeCommandFacet = defineParameterlessCommandFacet({',
+        '  name: HOME_COMMAND_NAME,',
+        '  run: (client, input) => client.command.home(input),',
+        '});',
+      ].join('\n'),
+    );
+    await writeFile(
+      path.join(scenarioDir, 'system.test.ts'),
+      'const home = await client.command.home(selection);\n',
+    );
+
+    const progress = buildIntegrationProgressModel({ root });
+    const home = progress.publicCommandRows.find((row) => row.command === 'home');
+
+    assert.equal(home?.references, 1);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
diff --git a/scripts/integration-progress-model.ts b/scripts/integration-progress-model.ts
index 9b679adba9..4e262b174c 100644
--- a/scripts/integration-progress-model.ts
+++ b/scripts/integration-progress-model.ts
@@ -583,7 +583,9 @@ function readCommandContractBlocks(text) {
   const nameOf = (token) => token.match(/^['"]([^'"]+)['"]$/)?.[1] ?? constants.get(token);
 
   const starts = [
-    ...text.matchAll(/defineCommandFacet\(\s*\{[\s\S]*?\bname:\s*([A-Za-z0-9_]+|['"][^'"]+['"])/g),
+    ...text.matchAll(
+      /define(?:Parameterless)?CommandFacet\(\s*\{[\s\S]*?\bname:\s*([A-Za-z0-9_]+|['"][^'"]+['"])/g,
+    ),
     ...text.matchAll(/defineFieldCommand\(\s*(['"][^'"]+['"])/g),
     ...text.matchAll(/defineCommand\(\s*\{[\s\S]*?\bname:\s*(['"][^'"]+['"])/g),
   ]
diff --git a/scripts/layering/contracts-exports.snapshot.json b/scripts/layering/contracts-exports.snapshot.json
index 755ded971b..915a85dfc6 100644
--- a/scripts/layering/contracts-exports.snapshot.json
+++ b/scripts/layering/contracts-exports.snapshot.json
@@ -13,7 +13,6 @@
   "@agent-device/contracts/app-inventory-runtime",
   "@agent-device/contracts/app-log-runtime",
   "@agent-device/contracts/app-state-runtime",
-  "@agent-device/contracts/app-switcher-runtime",
   "@agent-device/contracts/apple-runner-request",
   "@agent-device/contracts/apple-session-observation",
   "@agent-device/contracts/application-lifecycle-interaction",
@@ -52,7 +51,6 @@
   "@agent-device/contracts/gesture-plan",
   "@agent-device/contracts/gesture-plan-types",
   "@agent-device/contracts/gesture-runtime",
-  "@agent-device/contracts/home-runtime",
   "@agent-device/contracts/host-diagnostics",
   "@agent-device/contracts/interaction",
   "@agent-device/contracts/interaction-guarantees",
@@ -111,6 +109,7 @@
   "@agent-device/contracts/snapshot-runtime",
   "@agent-device/contracts/snapshot-scope",
   "@agent-device/contracts/startup-recovery-fence",
+  "@agent-device/contracts/system-button-runtime",
   "@agent-device/contracts/tap-keyboard-occlusion",
   "@agent-device/contracts/touch-runtime",
   "@agent-device/contracts/tv-remote",
diff --git a/src/__tests__/test-utils/runtime-operation-facts.ts b/src/__tests__/test-utils/runtime-operation-facts.ts
index 097ed48582..763a6ac1cb 100644
--- a/src/__tests__/test-utils/runtime-operation-facts.ts
+++ b/src/__tests__/test-utils/runtime-operation-facts.ts
@@ -16,6 +16,7 @@ import type { DeviceInfo } from '@agent-device/kernel/device';
 import { screenshotRuntimeOperationFacts } from '@agent-device/contracts/screenshot-runtime';
 import { scrollRuntimeOperationFacts } from '@agent-device/contracts/scroll-runtime';
 import { snapshotRuntimeOperationFacts } from '@agent-device/contracts/snapshot-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import { touchRuntimeOperationFacts } from '@agent-device/contracts/touch-runtime';
 import { perfRuntimeOperationFacts } from '@agent-device/contracts/perf-runtime';
 
@@ -60,13 +61,11 @@ export const unavailableDeploymentSnapshotAndShutdownOperationFacts = Object.fre
   ...scrollRuntimeOperationFacts({ scroll: unavailable }),
   ...elementTextRuntimeOperationFacts({ readTextAtPoint: unavailable }),
   back: unavailable,
-  home: unavailable,
   setOrientation: unavailable,
   tvRemote: unavailable,
   ...keyboardRuntimeOperationFacts({ unsupported: unavailable }),
   ...clipboardRuntimeOperationFacts({ unsupported: unavailable }),
-  appSwitcher: unavailable,
-  actionButton: unavailable,
+  ...systemButtonRuntimeOperationFacts({ unsupported: unavailable }),
   triggerAppEvent: unavailable,
   setSetting: unavailable,
   readAlert: unavailable,
diff --git a/src/commands/family/types.ts b/src/commands/family/types.ts
index 7946e1f331..da2666c133 100644
--- a/src/commands/family/types.ts
+++ b/src/commands/family/types.ts
@@ -10,6 +10,9 @@ import {
   resolveFacetText,
   type FacetCommandText,
 } from '@agent-device/command-registry/command-text';
+import { commonInputFromFlags, direct } from '../cli-grammar/common.ts';
+import type { InferCommandInput } from '../command-input.ts';
+import { defineFieldCommandMetadata } from '../field-command-contract.ts';
 
 export type AnyCommandMetadata<Name extends string = string> = CommandMetadata<Name, unknown>;
 
@@ -109,6 +112,37 @@ export function defineCommandFacet<
   };
 }
 
+/**
+ * A command whose only input is device selection: no fields, no positionals, no flags of its own.
+ * Its metadata, CLI schema, reader and daemon writer are fully determined by the name, so they
+ * are derived here once rather than restated by every such command.
+ */
+export function defineParameterlessCommandFacet<
+  const TCommandName extends string,
+  Result,
+  Formatter extends CliOutputFormatter | undefined = undefined,
+>(command: {
+  name: TCommandName;
+  description: string;
+  text: FacetCommandText;
+  run: (
+    client: AgentDeviceClient,
+    input: InferCommandInput<Record<never, never>>,
+  ) => Promise<Result>;
+  cliOutputFormatter?: Formatter;
+}): CommandFacet<TCommandName, Result, Formatter> {
+  return defineCommandFacet({
+    name: command.name,
+    text: command.text,
+    metadata: defineFieldCommandMetadata(command.name, command.description, {}),
+    run: command.run,
+    cliSchema: {},
+    cliReader: (_positionals, flags) => commonInputFromFlags(flags),
+    daemonWriter: direct(command.name),
+    cliOutputFormatter: command.cliOutputFormatter,
+  });
+}
+
 export function defineCommandFamilyFromFacets<
   const TFamilyName extends string,
   const TCommands extends readonly CommandFacet[],
diff --git a/src/commands/system/index.test.ts b/src/commands/system/index.test.ts
index 3f4c69c5dd..574db5a094 100644
--- a/src/commands/system/index.test.ts
+++ b/src/commands/system/index.test.ts
@@ -12,24 +12,17 @@ import type { CommandResult } from '@agent-device/command-registry/command-resul
 import { readInputFromCli } from '../cli-grammar/registry.ts';
 import type { CliFlags } from '@agent-device/contracts/command';
 import {
-  actionButtonCliReader,
-  actionButtonDaemonWriter,
-  appStateCliReader,
-  appStateDaemonWriter,
-  appSwitcherCliReader,
-  appSwitcherDaemonWriter,
   backCliReader,
   backDaemonWriter,
   clipboardCliReader,
   clipboardDaemonWriter,
-  homeCliReader,
-  homeDaemonWriter,
   keyboardCliReader,
   keyboardDaemonWriter,
   orientationCliReader,
   orientationDaemonWriter,
   tvRemoteCliReader,
   tvRemoteDaemonWriter,
+  systemCommandFamily,
 } from './index.ts';
 import { systemCliOutputFormatters } from './output.ts';
 
@@ -68,30 +61,23 @@ describe('system command interface', () => {
     >();
   });
 
+  const parameterless = ['appstate', 'home', 'app-switcher', 'action-button'] as const;
+
   test('parameterless readers project common selection flags through', () => {
-    for (const reader of [
-      appStateCliReader,
-      homeCliReader,
-      appSwitcherCliReader,
-      actionButtonCliReader,
-    ]) {
-      expect(reader([], flags({ platform: 'ios' }))).toEqual({
+    for (const command of parameterless) {
+      expect(systemCommandFamily.cliReaders[command]([], flags({ platform: 'ios' }))).toEqual({
         platform: 'ios',
       });
     }
   });
 
   test('parameterless daemon writers emit command names with no positionals', () => {
-    expect(appStateDaemonWriter({})).toMatchObject({ command: 'appstate', positionals: [] });
-    expect(homeDaemonWriter({})).toMatchObject({ command: 'home', positionals: [] });
-    expect(appSwitcherDaemonWriter({})).toMatchObject({
-      command: 'app-switcher',
-      positionals: [],
-    });
-    expect(actionButtonDaemonWriter({})).toMatchObject({
-      command: 'action-button',
-      positionals: [],
-    });
+    for (const command of parameterless) {
+      expect(systemCommandFamily.daemonWriters?.[command]?.({})).toMatchObject({
+        command,
+        positionals: [],
+      });
+    }
   });
 
   test('back reader and writer normalize back mode', () => {
diff --git a/src/commands/system/index.ts b/src/commands/system/index.ts
index 77d3d599a2..45cecd3895 100644
--- a/src/commands/system/index.ts
+++ b/src/commands/system/index.ts
@@ -19,7 +19,11 @@ import {
 import type { CliReader, DaemonWriter } from '../cli-grammar/types.ts';
 import { enumField, integerField, requiredField, stringField } from '../command-input.ts';
 import { compactRecord } from '../input-readers.ts';
-import { defineCommandFacet, defineCommandFamilyFromFacets } from '../family/types.ts';
+import {
+  defineCommandFacet,
+  defineCommandFamilyFromFacets,
+  defineParameterlessCommandFacet,
+} from '../family/types.ts';
 import { defineFieldCommandMetadata } from '../field-command-contract.ts';
 import {
   postActionObservationCliFlags,
@@ -59,23 +63,11 @@ const actionButtonCommandDescription =
 const tvRemoteCommandDescription =
   'Press or long-press a TV remote or D-pad button on Android TV, tvOS, or Vega OS. Choose the button and optional hold duration through the input fields. The aliases ok, center, and enter all map to select.';
 
-const appStateCommandMetadata = defineFieldCommandMetadata(
-  APPSTATE_COMMAND_NAME,
-  appStateCommandDescription,
-  {},
-);
-
 const backCommandMetadata = defineFieldCommandMetadata(BACK_COMMAND_NAME, backCommandDescription, {
   mode: enumField(BACK_MODES),
   ...postActionObservationFields(BACK_COMMAND_NAME),
 });
 
-const homeCommandMetadata = defineFieldCommandMetadata(
-  HOME_COMMAND_NAME,
-  homeCommandDescription,
-  {},
-);
-
 const orientationCommandMetadata = defineFieldCommandMetadata(
   ORIENTATION_COMMAND_NAME,
   orientationCommandDescription,
@@ -84,18 +76,6 @@ const orientationCommandMetadata = defineFieldCommandMetadata(
   },
 );
 
-const appSwitcherCommandMetadata = defineFieldCommandMetadata(
-  APP_SWITCHER_COMMAND_NAME,
-  appSwitcherCommandDescription,
-  {},
-);
-
-const actionButtonCommandMetadata = defineFieldCommandMetadata(
-  ACTION_BUTTON_COMMAND_NAME,
-  actionButtonCommandDescription,
-  {},
-);
-
 const keyboardCommandMetadata = defineFieldCommandMetadata(
   KEYBOARD_COMMAND_NAME,
   keyboardCommandDescription,
@@ -129,20 +109,12 @@ const tvRemoteCommandMetadata = defineFieldCommandMetadata(
   },
 );
 
-const appStateCliSchema = {} as const satisfies CommandSchemaOverride;
-
 const backCliSchema = {
   usageOverride: 'back [--in-app|--system] [--settle]',
   usageFlags: [],
   allowedFlags: ['backMode', ...postActionObservationCliFlags(BACK_COMMAND_NAME)],
 } as const satisfies CommandSchemaOverride;
 
-const homeCliSchema = {} as const satisfies CommandSchemaOverride;
-
-const appSwitcherCliSchema = {} as const satisfies CommandSchemaOverride;
-
-const actionButtonCliSchema = {} as const satisfies CommandSchemaOverride;
-
 const orientationCliSchema = {
   usageOverride: 'orientation <portrait|portrait-upside-down|landscape-left|landscape-right>',
   positionalArgs: ['orientation'],
@@ -167,12 +139,6 @@ const tvRemoteCliSchema = {
   allowedFlags: ['durationMs'],
 } as const satisfies CommandSchemaOverride;
 
-export const appStateCliReader: CliReader = (_positionals, flags) => commonInputFromFlags(flags);
-export const homeCliReader: CliReader = (_positionals, flags) => commonInputFromFlags(flags);
-export const appSwitcherCliReader: CliReader = (_positionals, flags) => commonInputFromFlags(flags);
-export const actionButtonCliReader: CliReader = (_positionals, flags) =>
-  commonInputFromFlags(flags);
-
 export const backCliReader: CliReader = (_positionals, flags) => ({
   ...commonInputFromFlags(flags),
   mode: flags.backMode,
@@ -198,24 +164,16 @@ export const tvRemoteCliReader: CliReader = (positionals, flags) => ({
   ...readTvRemoteInput(positionals, flags.durationMs),
 });
 
-export const appStateDaemonWriter: DaemonWriter = direct(APPSTATE_COMMAND_NAME);
-
 export const backDaemonWriter: DaemonWriter = (input) =>
   request(BACK_COMMAND_NAME, [], {
     ...input,
     backMode: readBackMode(input.mode),
   });
 
-export const homeDaemonWriter: DaemonWriter = direct(HOME_COMMAND_NAME);
-
 export const orientationDaemonWriter: DaemonWriter = direct(ORIENTATION_COMMAND_NAME, (input) => [
   requiredDaemonString(input.orientation, 'orientation requires orientation'),
 ]);
 
-export const appSwitcherDaemonWriter: DaemonWriter = direct(APP_SWITCHER_COMMAND_NAME);
-
-export const actionButtonDaemonWriter: DaemonWriter = direct(ACTION_BUTTON_COMMAND_NAME);
-
 export const keyboardDaemonWriter: DaemonWriter = direct(KEYBOARD_COMMAND_NAME, (input) =>
   optionalString(input.action),
 );
@@ -228,16 +186,13 @@ export const tvRemoteDaemonWriter: DaemonWriter = direct(TV_REMOTE_COMMAND_NAME,
   requiredDaemonString(input.button, 'tv-remote requires button'),
 ]);
 
-const appStateCommandFacet = defineCommandFacet({
+const appStateCommandFacet = defineParameterlessCommandFacet({
   name: APPSTATE_COMMAND_NAME,
+  description: appStateCommandDescription,
   text: {
     summary: 'Show the foreground app and activity',
   },
-  metadata: appStateCommandMetadata,
   run: (client, input) => client.command.appState(input),
-  cliSchema: appStateCliSchema,
-  cliReader: appStateCliReader,
-  daemonWriter: appStateDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters.appstate,
 });
 
@@ -254,16 +209,13 @@ const backCommandFacet = defineCommandFacet({
   cliOutputFormatter: systemCliOutputFormatters.back,
 });
 
-const homeCommandFacet = defineCommandFacet({
+const homeCommandFacet = defineParameterlessCommandFacet({
   name: HOME_COMMAND_NAME,
+  description: homeCommandDescription,
   text: {
     summary: 'Go to the device home screen',
   },
-  metadata: homeCommandMetadata,
   run: (client, input) => client.command.home(input),
-  cliSchema: homeCliSchema,
-  cliReader: homeCliReader,
-  daemonWriter: homeDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters.home,
 });
 
@@ -280,16 +232,13 @@ const orientationCommandFacet = defineCommandFacet({
   cliOutputFormatter: systemCliOutputFormatters.orientation,
 });
 
-const appSwitcherCommandFacet = defineCommandFacet({
+const appSwitcherCommandFacet = defineParameterlessCommandFacet({
   name: APP_SWITCHER_COMMAND_NAME,
+  description: appSwitcherCommandDescription,
   text: {
     summary: 'Open the device app switcher',
   },
-  metadata: appSwitcherCommandMetadata,
   run: (client, input) => client.command.appSwitcher(input),
-  cliSchema: appSwitcherCliSchema,
-  cliReader: appSwitcherCliReader,
-  daemonWriter: appSwitcherDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters['app-switcher'],
 });
 
@@ -319,18 +268,15 @@ const clipboardCommandFacet = defineCommandFacet({
   cliOutputFormatter: systemCliOutputFormatters.clipboard,
 });
 
-const actionButtonCommandFacet = defineCommandFacet({
+const actionButtonCommandFacet = defineParameterlessCommandFacet({
   name: ACTION_BUTTON_COMMAND_NAME,
+  description: actionButtonCommandDescription,
   text: {
     summary: 'Press the iPhone or iPad Action Button',
     cliDetail:
       'iPhone and iPad only. The runner asks the device for the button and reports unsupported when that model has none.',
   },
-  metadata: actionButtonCommandMetadata,
   run: (client, input) => client.command.actionButton(input),
-  cliSchema: actionButtonCliSchema,
-  cliReader: actionButtonCliReader,
-  daemonWriter: actionButtonDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters['action-button'],
 });
 
diff --git a/src/core/interactors/android.ts b/src/core/interactors/android.ts
index 220252179d..a641b0db0c 100644
--- a/src/core/interactors/android.ts
+++ b/src/core/interactors/android.ts
@@ -32,7 +32,6 @@ import {
 } from '@agent-device/platform-android/mechanics';
 import { withDiagnosticTimer } from '@agent-device/host-kit/diagnostics';
 import { withMethodScope } from '@agent-device/kernel/scoped-provider';
-import { AppError } from '@agent-device/kernel/errors';
 import type { DeviceInfo } from '@agent-device/kernel/device';
 import type { Interactor, RunnerContext } from '@agent-device/contracts/interactor-types';
 import { buildSnapshotState } from '@agent-device/capture-kit/snapshot-state';
@@ -114,12 +113,6 @@ export function createAndroidInteractor(
     home: () => homeAndroid(device),
     setOrientation: (orientation) => setAndroidOrientation(device, orientation),
     appSwitcher: () => appSwitcherAndroid(device),
-    actionButton: () => {
-      throw new AppError(
-        'UNSUPPORTED_OPERATION',
-        'action-button presses iPhone Action Button hardware, which Android has no equivalent for',
-      );
-    },
     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/src/core/interactors/harmonyos.ts b/src/core/interactors/harmonyos.ts
index 0285669c02..2dc993086d 100644
--- a/src/core/interactors/harmonyos.ts
+++ b/src/core/interactors/harmonyos.ts
@@ -53,7 +53,6 @@ export function createHarmonyInteractor(device: DeviceInfo, _runner?: RunnerCont
     home: () => homeHarmony(device),
     setOrientation: (orientation) => setHarmonyOrientation(device, orientation),
     appSwitcher: () => appSwitcherHarmony(device),
-    actionButton: unsupported('action-button'),
     tvRemote: unsupported('tv-remote'),
     keyboardDismiss: async () => {
       await pressHarmonyKeyboardKey(device, 'Back');
diff --git a/src/core/interactors/linux.ts b/src/core/interactors/linux.ts
index 408349f266..8ed8850286 100644
--- a/src/core/interactors/linux.ts
+++ b/src/core/interactors/linux.ts
@@ -75,9 +75,6 @@ export function createLinuxInteractor(): Interactor {
     appSwitcher: () => {
       throw new AppError('UNSUPPORTED_OPERATION', 'appSwitcher not yet supported on Linux');
     },
-    actionButton: () => {
-      throw new AppError('UNSUPPORTED_OPERATION', 'action-button not supported on Linux');
-    },
     tvRemote: () => {
       throw new AppError('UNSUPPORTED_OPERATION', 'tv-remote not supported on Linux');
     },
diff --git a/src/core/interactors/unsupported-interactor.ts b/src/core/interactors/unsupported-interactor.ts
index 56b6006e49..ab1c89ef7b 100644
--- a/src/core/interactors/unsupported-interactor.ts
+++ b/src/core/interactors/unsupported-interactor.ts
@@ -26,7 +26,6 @@ export function createUnsupportedInteractor(platformLabel: string): Interactor {
     home: () => unsupported('home'),
     setOrientation: () => unsupported('setOrientation'),
     appSwitcher: () => unsupported('appSwitcher'),
-    actionButton: () => unsupported('actionButton'),
     tvRemote: () => unsupported('tvRemote'),
     readClipboard: () => unsupported('readClipboard'),
     writeClipboard: () => unsupported('writeClipboard'),
diff --git a/src/daemon/__tests__/app-switcher-runtime.test.ts b/src/daemon/__tests__/app-switcher-runtime.test.ts
deleted file mode 100644
index 8777c7fb86..0000000000
--- a/src/daemon/__tests__/app-switcher-runtime.test.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { test } from 'vitest';
-import { expectRefusesUnavailableExactOwnerFact } from './runtime-binding-conformance.ts';
-
-const appleDevice = {
-  id: 'app-switcher-runtime-ios-simulator',
-  name: 'iPhone',
-  platform: 'apple',
-  appleOs: 'ios',
-  kind: 'simulator',
-  target: 'mobile',
-  booted: true,
-} as const;
-const unavailable = Object.freeze({
-  available: false,
-  reason: 'unsupported-device-kind' as const,
-  hint: 'app-switcher is supported on Apple simulators and physical devices.',
-});
-
-test('rejects an unavailable exact-owner fact before binding', async () => {
-  await expectRefusesUnavailableExactOwnerFact({
-    command: 'app-switcher',
-    device: appleDevice,
-    unavailable,
-  });
-});
diff --git a/src/daemon/__tests__/home-runtime.test.ts b/src/daemon/__tests__/home-runtime.test.ts
deleted file mode 100644
index a852e01dee..0000000000
--- a/src/daemon/__tests__/home-runtime.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { expect, test, vi } from 'vitest';
-import { homeRuntimeOperationFacts } from '@agent-device/contracts/home-runtime';
-import {
-  localRuntimeOwner,
-  narrowDeviceBinding,
-  type DeviceBinding,
-  type DeviceRuntimeGateway,
-  type RuntimeFacts,
-  type RuntimeOperationFact,
-} from '@agent-device/contracts/platform-runtime';
-import {
-  homeRuntimeUse,
-  type PlatformRuntimeOperations,
-} from '@agent-device/contracts/platform-runtime-operations';
-import { deviceShape } from '@agent-device/kernel/device';
-import { makeSession } from '../../__tests__/test-utils/session-factories.ts';
-import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
-import { createTestDeviceInventoryGateways } from '../../__tests__/test-utils/device-inventory-gateways.ts';
-import { LeaseRegistry } from '../lease-registry.ts';
-import { activateCompleteRefFrame, refFrameState } from '../ref-frame.ts';
-import type { BindDeviceRuntime, InspectDeviceRuntimeFacts } from '../request-runtime-binding.ts';
-import type { GenericPlatformExecutionParams } from '../request-generic-dispatch.ts';
-import { resolveBoundHomeRuntime } from '../home-runtime.ts';
-import { expectRefusesUnavailableExactOwnerFact } from './runtime-binding-conformance.ts';
-import { createRequestHandler } from './test-device-runtime-gateway.ts';
-
-const macOsDevice = {
-  id: 'macos-host',
-  name: 'Mac',
-  platform: 'apple',
-  appleOs: 'macos',
-  kind: 'device',
-  target: 'desktop',
-  booted: true,
-} as const;
-const available = Object.freeze({ available: true } as const);
-const unavailable = Object.freeze({
-  available: false,
-  reason: 'unsupported-platform-leaf' as const,
-});
-
-function homeExecutionParams(
-  dispatchContext: GenericPlatformExecutionParams['dispatchContext'] = {},
-): GenericPlatformExecutionParams {
-  const session = makeSession('home-runtime', { device: macOsDevice });
-  return {
-    session,
-    sessionName: session.name,
-    logPath: '/tmp/daemon.log',
-    command: 'home',
-    request: { command: 'home', positionals: [], token: 't', session: session.name },
-    positionals: [],
-    out: undefined,
-    dispatchContext,
-  };
-}
-
-function runtimeHarness(fact: RuntimeOperationFact = available) {
-  const home = vi.fn(async () => undefined);
-  const facts: RuntimeFacts<PlatformRuntimeOperations> = {
-    device: { ...deviceShape(macOsDevice), providerMode: 'local' },
-    operations: { home: fact } as RuntimeFacts<PlatformRuntimeOperations>['operations'],
-  };
-  const binding = {
-    device: macOsDevice,
-    owner: localRuntimeOwner('apple'),
-    facts,
-    operations: { home },
-    [Symbol.asyncDispose]: async () => {},
-  } satisfies DeviceBinding<PlatformRuntimeOperations>;
-  const inspectFacts: InspectDeviceRuntimeFacts = vi.fn(async () => facts);
-  const bindDevice = vi.fn(async (_device, use) =>
-    narrowDeviceBinding(binding, use),
-  ) as unknown as BindDeviceRuntime;
-  const bind = vi.fn(async () => binding);
-  const gateway: DeviceRuntimeGateway<PlatformRuntimeOperations> = {
-    inspectFacts,
-    bind,
-    shutdown: async () => {},
-  };
-  return { home, inspectFacts, bindDevice, bind, gateway };
-}
-
-test('resolves one admitted binding and drives one home navigation', async () => {
-  const harness = runtimeHarness(homeRuntimeOperationFacts({ home: available }).home);
-
-  const resolved = await resolveBoundHomeRuntime({
-    device: macOsDevice,
-    inspectFacts: harness.inspectFacts,
-    bindDevice: harness.bindDevice,
-  });
-
-  expect(resolved.ok).toBe(true);
-  if (!resolved.ok) return;
-  expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
-  expect(harness.bindDevice).toHaveBeenCalledWith(macOsDevice, homeRuntimeUse);
-  expect(await resolved.execute(homeExecutionParams())).toEqual({
-    action: 'home',
-    message: 'Home',
-  });
-  expect(harness.home).toHaveBeenCalledTimes(1);
-});
-
-test('rejects an unavailable exact-owner fact before binding (macOS has no springboard home)', async () => {
-  await expectRefusesUnavailableExactOwnerFact({
-    command: 'home',
-    device: macOsDevice,
-    unavailable,
-  });
-});
-
-test('request router joins home admission to execution, recording, and ref invalidation', async () => {
-  const harness = runtimeHarness();
-  const sessionStore = makeSessionStore('agent-device-home-generic-');
-  const session = makeSession('home-runtime', { device: macOsDevice });
-  activateCompleteRefFrame(session);
-  sessionStore.set(session.name, session);
-  const handler = createRequestHandler({
-    logPath: '/tmp/daemon.log',
-    token: 't',
-    sessionStore,
-    leaseRegistry: new LeaseRegistry(),
-    deviceInventoryGateways: createTestDeviceInventoryGateways(),
-    deviceRuntimeGateway: harness.gateway,
-    trackDownloadableArtifact: () => 'artifact',
-  });
-
-  const response = await handler({
-    command: 'home',
-    positionals: [],
-    token: 't',
-    session: session.name,
-    flags: {},
-    meta: { requestId: 'home-router-join' },
-  });
-
-  expect(response).toMatchObject({ ok: true, data: { action: 'home', message: 'Home' } });
-  expect(refFrameState(session)).toBe('expired');
-  expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
-  expect(harness.bind).toHaveBeenCalledTimes(1);
-  expect(harness.home).toHaveBeenCalledTimes(1);
-});
diff --git a/src/daemon/__tests__/runtime-binding-conformance.ts b/src/daemon/__tests__/runtime-binding-conformance.ts
index a2422cdcc5..cbb5a1b506 100644
--- a/src/daemon/__tests__/runtime-binding-conformance.ts
+++ b/src/daemon/__tests__/runtime-binding-conformance.ts
@@ -7,16 +7,16 @@ import {
 } from '@agent-device/contracts/platform-runtime';
 import type { PlatformRuntimeOperations } from '@agent-device/contracts/platform-runtime-operations';
 import type { DeviceInfo } from '@agent-device/kernel/device';
-import { commandRuntimeUseRequirements } from '@agent-device/command-registry/registry';
+import {
+  commandDescriptors,
+  commandRuntimeUseRequirements,
+} from '@agent-device/command-registry/registry';
 import { createUnavailableRuntimeFactsForTest } from '../../__tests__/test-utils/runtime-operation-facts.ts';
 import { makeSession } from '../../__tests__/test-utils/session-factories.ts';
 import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
-import { resolveBoundActionButtonRuntime } from '../action-button-runtime.ts';
-import { resolveBoundAppSwitcherRuntime } from '../app-switcher-runtime.ts';
 import { resolveBoundBackRuntime } from '../back-runtime.ts';
 import { resolveBoundFocusRuntime } from '../focus-runtime.ts';
 import { resolveBoundGestureRuntime } from '../gesture-runtime.ts';
-import { resolveBoundHomeRuntime } from '../home-runtime.ts';
 import { resolveBoundOrientationRuntime } from '../orientation-runtime.ts';
 import type { ResolvedGenericExecution } from '../request-generic-dispatch.ts';
 import type {
@@ -25,6 +25,11 @@ import type {
   RuntimeAdmissionBindings,
 } from '../request-runtime-binding.ts';
 import { dispatchSnapshotDiffViaRuntime } from '../snapshot-diff-runtime.ts';
+import {
+  isSystemButtonCommand,
+  resolveBoundSystemButtonRuntime,
+  type SystemButtonCommand,
+} from '../system-button-runtime.ts';
 import { resolveBoundTvRemoteRuntime } from '../tv-remote-runtime.ts';
 import { resolveBoundTypeTextRuntime } from '../type-text-runtime.ts';
 import { resolveBoundViewportRuntime } from '../viewport-runtime.ts';
@@ -67,28 +72,34 @@ function refusable(resolved: ResolvedGenericExecution): RefusableResolution {
   return { ok: false, response: resolved.response };
 }
 
+/** The registry's system-button commands, each resolved through the one shared press route. */
+export const systemButtonCommands: readonly SystemButtonCommand[] = commandDescriptors
+  .map((descriptor) => descriptor.name)
+  .filter(isSystemButtonCommand);
+
+function systemButtonConformedBindings(): Record<SystemButtonCommand, ConformedRuntimeBinding> {
+  return Object.fromEntries(
+    systemButtonCommands.map((command) => [
+      command,
+      {
+        resolve: async (device, bindings) =>
+          refusable(await resolveBoundSystemButtonRuntime(command, { device, ...bindings })),
+      } satisfies ConformedRuntimeBinding,
+    ]),
+  ) as Record<SystemButtonCommand, 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`
  * checks this table against the registry's runtime-use declarations in both directions.
  */
 export const conformedRuntimeBindings = {
+  ...systemButtonConformedBindings(),
   back: {
     resolve: async (device, bindings) =>
       refusable(await resolveBoundBackRuntime({ device, ...bindings })),
   },
-  home: {
-    resolve: async (device, bindings) =>
-      refusable(await resolveBoundHomeRuntime({ device, ...bindings })),
-  },
-  'action-button': {
-    resolve: async (device, bindings) =>
-      refusable(await resolveBoundActionButtonRuntime({ device, ...bindings })),
-  },
-  'app-switcher': {
-    resolve: async (device, bindings) =>
-      refusable(await resolveBoundAppSwitcherRuntime({ device, ...bindings })),
-  },
   focus: {
     resolve: async (device, bindings) =>
       refusable(await resolveBoundFocusRuntime({ device, positionals: ['40', '90'], ...bindings })),
diff --git a/src/daemon/__tests__/system-button-runtime.test.ts b/src/daemon/__tests__/system-button-runtime.test.ts
new file mode 100644
index 0000000000..f6e1b49a12
--- /dev/null
+++ b/src/daemon/__tests__/system-button-runtime.test.ts
@@ -0,0 +1,198 @@
+import { expect, test, vi } from 'vitest';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
+import {
+  localRuntimeOwner,
+  narrowDeviceBinding,
+  type DeviceBinding,
+  type DeviceRuntimeGateway,
+  type RuntimeFacts,
+  type RuntimeOperationFact,
+} from '@agent-device/contracts/platform-runtime';
+import {
+  actionButtonRuntimeUse,
+  appSwitcherRuntimeUse,
+  homeRuntimeUse,
+  type PlatformRuntimeOperations,
+} from '@agent-device/contracts/platform-runtime-operations';
+import type { SystemButton } from '@agent-device/contracts/system-button-runtime';
+import { deviceShape, type DeviceInfo } from '@agent-device/kernel/device';
+import { makeSession } from '../../__tests__/test-utils/session-factories.ts';
+import { makeSessionStore } from '../../__tests__/test-utils/store-factory.ts';
+import { createTestDeviceInventoryGateways } from '../../__tests__/test-utils/device-inventory-gateways.ts';
+import { LeaseRegistry } from '../lease-registry.ts';
+import { activateCompleteRefFrame, refFrameState } from '../ref-frame.ts';
+import type { BindDeviceRuntime, InspectDeviceRuntimeFacts } from '../request-runtime-binding.ts';
+import type { GenericPlatformExecutionParams } from '../request-generic-dispatch.ts';
+import {
+  resolveBoundSystemButtonRuntime,
+  type SystemButtonCommand,
+} from '../system-button-runtime.ts';
+import {
+  expectRefusesUnavailableExactOwnerFact,
+  systemButtonCommands,
+} from './runtime-binding-conformance.ts';
+import { createRequestHandler } from './test-device-runtime-gateway.ts';
+
+const macOsDevice = {
+  id: 'macos-host',
+  name: 'Mac',
+  platform: 'apple',
+  appleOs: 'macos',
+  kind: 'device',
+  target: 'desktop',
+  booted: true,
+} as const;
+const iosSimulator = {
+  id: 'system-button-runtime-ios-simulator',
+  name: 'iPhone',
+  platform: 'apple',
+  appleOs: 'ios',
+  kind: 'simulator',
+  target: 'mobile',
+  booted: true,
+} as const;
+const available = Object.freeze({ available: true } as const);
+const unavailable = Object.freeze({
+  available: false,
+  reason: 'unsupported-platform-leaf' as const,
+});
+
+/**
+ * What each command must bind and report, stated here rather than read back from the production
+ * table, so a row that drifts (wrong use, wrong text) fails instead of proving itself.
+ */
+const EXPECTED: Record<
+  SystemButtonCommand,
+  { button: SystemButton; use: unknown; message: string; refusedOn: DeviceInfo }
+> = {
+  home: { button: 'home', use: homeRuntimeUse, message: 'Home', refusedOn: macOsDevice },
+  'app-switcher': {
+    button: 'appSwitcher',
+    use: appSwitcherRuntimeUse,
+    message: 'Opened app switcher',
+    refusedOn: iosSimulator,
+  },
+  'action-button': {
+    button: 'actionButton',
+    use: actionButtonRuntimeUse,
+    message: 'Pressed Action Button',
+    refusedOn: iosSimulator,
+  },
+};
+
+test('the registry names exactly the commands the press route serves', () => {
+  expect([...systemButtonCommands].sort()).toEqual(Object.keys(EXPECTED).sort());
+});
+
+function executionParams(
+  command: SystemButtonCommand,
+  dispatchContext: GenericPlatformExecutionParams['dispatchContext'] = {},
+): GenericPlatformExecutionParams {
+  const session = makeSession('system-button-runtime', { device: iosSimulator });
+  return {
+    session,
+    sessionName: session.name,
+    logPath: '/tmp/daemon.log',
+    command,
+    request: { command, positionals: [], token: 't', session: session.name },
+    positionals: [],
+    out: undefined,
+    dispatchContext,
+  };
+}
+
+function runtimeHarness(button: SystemButton, fact: RuntimeOperationFact = available) {
+  const press = vi.fn(async () => undefined);
+  const facts: RuntimeFacts<PlatformRuntimeOperations> = {
+    device: { ...deviceShape(iosSimulator), providerMode: 'local' },
+    operations: systemButtonRuntimeOperationFacts({
+      unsupported: unavailable,
+      [button]: fact,
+    }) as RuntimeFacts<PlatformRuntimeOperations>['operations'],
+  };
+  const binding = {
+    device: iosSimulator,
+    owner: localRuntimeOwner('apple'),
+    facts,
+    operations: { [button]: press },
+    [Symbol.asyncDispose]: async () => {},
+  } satisfies DeviceBinding<PlatformRuntimeOperations>;
+  const inspectFacts: InspectDeviceRuntimeFacts = vi.fn(async () => facts);
+  const bindDevice = vi.fn(async (_device, use) =>
+    narrowDeviceBinding(binding, use),
+  ) as unknown as BindDeviceRuntime;
+  const bind = vi.fn(async () => binding);
+  const gateway: DeviceRuntimeGateway<PlatformRuntimeOperations> = {
+    inspectFacts,
+    bind,
+    shutdown: async () => {},
+  };
+  return { press, inspectFacts, bindDevice, bind, gateway };
+}
+
+test.each(Object.keys(EXPECTED) as SystemButtonCommand[])(
+  '%s resolves one admitted binding and presses its button once',
+  async (command) => {
+    const expected = EXPECTED[command];
+    const harness = runtimeHarness(expected.button);
+
+    const resolved = await resolveBoundSystemButtonRuntime(command, {
+      device: iosSimulator,
+      inspectFacts: harness.inspectFacts,
+      bindDevice: harness.bindDevice,
+    });
+
+    expect(resolved.ok).toBe(true);
+    if (!resolved.ok) return;
+    expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
+    expect(harness.bindDevice).toHaveBeenCalledWith(iosSimulator, expected.use);
+    expect(await resolved.execute(executionParams(command))).toEqual({
+      action: command,
+      message: expected.message,
+    });
+    expect(harness.press).toHaveBeenCalledTimes(1);
+  },
+);
+
+test.each(Object.keys(EXPECTED) as SystemButtonCommand[])(
+  '%s rejects an unavailable exact-owner fact before binding',
+  async (command) => {
+    await expectRefusesUnavailableExactOwnerFact({
+      command,
+      device: EXPECTED[command].refusedOn,
+      unavailable,
+    });
+  },
+);
+
+test('request router joins home admission to execution, recording, and ref invalidation', async () => {
+  const harness = runtimeHarness('home');
+  const sessionStore = makeSessionStore('agent-device-home-generic-');
+  const session = makeSession('system-button-runtime', { device: iosSimulator });
+  activateCompleteRefFrame(session);
+  sessionStore.set(session.name, session);
+  const handler = createRequestHandler({
+    logPath: '/tmp/daemon.log',
+    token: 't',
+    sessionStore,
+    leaseRegistry: new LeaseRegistry(),
+    deviceInventoryGateways: createTestDeviceInventoryGateways(),
+    deviceRuntimeGateway: harness.gateway,
+    trackDownloadableArtifact: () => 'artifact',
+  });
+
+  const response = await handler({
+    command: 'home',
+    positionals: [],
+    token: 't',
+    session: session.name,
+    flags: {},
+    meta: { requestId: 'home-router-join' },
+  });
+
+  expect(response).toMatchObject({ ok: true, data: { action: 'home', message: 'Home' } });
+  expect(refFrameState(session)).toBe('expired');
+  expect(harness.inspectFacts).toHaveBeenCalledTimes(1);
+  expect(harness.bind).toHaveBeenCalledTimes(1);
+  expect(harness.press).toHaveBeenCalledTimes(1);
+});
diff --git a/src/daemon/action-button-runtime.ts b/src/daemon/action-button-runtime.ts
deleted file mode 100644
index 94056ca147..0000000000
--- a/src/daemon/action-button-runtime.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import {
-  actionButtonRuntimeUse,
-  type NoArgumentInteractorInput,
-} from '@agent-device/contracts/platform-runtime-operations';
-import type { BoundDeviceRuntime } from '@agent-device/contracts/platform-runtime';
-import type { DeviceInfo } from '@agent-device/kernel/device';
-import { successText } from '@agent-device/kernel/success-text';
-import type { DaemonCommandContext } from './context.ts';
-import type { ResolvedGenericExecution } from './request-generic-dispatch.ts';
-import { resolveBoundGenericRuntime, type RuntimeAdmissionBindings } from './runtime-admission.ts';
-import { runtimeExecutionFromContext } from './snapshot-runtime-capture-input.ts';
-
-/** The neutral intent one Action Button press carries, projected from a resolved command context. */
-function actionButtonInput(context: DaemonCommandContext): NoArgumentInteractorInput {
-  return {
-    ...(context.appBundleId === undefined ? {} : { options: { appBundleId: context.appBundleId } }),
-    execution: runtimeExecutionFromContext(context),
-  };
-}
-
-/**
- * The one place `action-button` reaches a device (ADR 0019). Admission inspects the exact owner's
- * `actionButton` fact and binds once, before the dispatcher runs, so an owner with no Action Button
- * is refused rather than discovered mid-execution.
- */
-export async function resolveBoundActionButtonRuntime(
-  params: {
-    device: DeviceInfo;
-  } & RuntimeAdmissionBindings,
-): Promise<ResolvedGenericExecution> {
-  return await resolveBoundGenericRuntime(
-    {
-      command: 'action-button',
-      device: params.device,
-      use: actionButtonRuntimeUse,
-      inspectFacts: params.inspectFacts,
-      bindDevice: params.bindDevice,
-    },
-    executeActionButton,
-  );
-}
-
-/**
- * The ONE place a bound `actionButton` executes. Typed off `typeof actionButtonRuntimeUse` rather
- * than a hand-restated operations shape, so a change to what the press binds can't drift here.
- *
- * The response carries no settle or observation payload by design: the press is expected to deliver
- * to whatever the system routes it to, including a backgrounded or terminated app (#2699).
- */
-async function executeActionButton(
-  runtime: BoundDeviceRuntime<typeof actionButtonRuntimeUse>,
-  context: DaemonCommandContext,
-): Promise<Record<string, unknown>> {
-  await runtime.operations.actionButton(actionButtonInput(context));
-  return { action: 'action-button', ...successText('Pressed Action Button') };
-}
diff --git a/src/daemon/app-switcher-runtime.ts b/src/daemon/app-switcher-runtime.ts
deleted file mode 100644
index 127bb882b8..0000000000
--- a/src/daemon/app-switcher-runtime.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { AppSwitcherInput } from '@agent-device/contracts/app-switcher-runtime';
-import { appSwitcherRuntimeUse } from '@agent-device/contracts/platform-runtime-operations';
-import type { BoundDeviceRuntime } from '@agent-device/contracts/platform-runtime';
-import type { DeviceInfo } from '@agent-device/kernel/device';
-import { successText } from '@agent-device/kernel/success-text';
-import type { DaemonCommandContext } from './context.ts';
-import type { ResolvedGenericExecution } from './request-generic-dispatch.ts';
-import { resolveBoundGenericRuntime, type RuntimeAdmissionBindings } from './runtime-admission.ts';
-import { runtimeExecutionFromContext } from './snapshot-runtime-capture-input.ts';
-
-/** The neutral intent one `app-switcher` carries, projected from a resolved command context. */
-function appSwitcherInput(context: DaemonCommandContext): AppSwitcherInput {
-  return {
-    ...(context.appBundleId === undefined ? {} : { options: { appBundleId: context.appBundleId } }),
-    execution: runtimeExecutionFromContext(context),
-  };
-}
-
-/**
- * The one place `app-switcher` reaches a device (ADR 0019). Admission inspects the exact owner's
- * `appSwitcher` fact and binds once, before the dispatcher runs, so an owner with no springboard
- * to reveal is refused rather than discovered mid-execution.
- */
-export async function resolveBoundAppSwitcherRuntime(
-  params: {
-    device: DeviceInfo;
-  } & RuntimeAdmissionBindings,
-): Promise<ResolvedGenericExecution> {
-  return await resolveBoundGenericRuntime(
-    {
-      command: 'app-switcher',
-      device: params.device,
-      use: appSwitcherRuntimeUse,
-      inspectFacts: params.inspectFacts,
-      bindDevice: params.bindDevice,
-    },
-    executeAppSwitcher,
-  );
-}
-
-/**
- * The ONE place a bound `app-switcher` executes (R56). Typed off `typeof appSwitcherRuntimeUse`
- * rather than a hand-restated operations shape, so a change to what it binds can't drift here.
- */
-async function executeAppSwitcher(
-  runtime: BoundDeviceRuntime<typeof appSwitcherRuntimeUse>,
-  context: DaemonCommandContext,
-): Promise<Record<string, unknown>> {
-  await runtime.operations.appSwitcher(appSwitcherInput(context));
-  return { action: 'app-switcher', ...successText('Opened app switcher') };
-}
diff --git a/src/daemon/generic-runtime-execution.ts b/src/daemon/generic-runtime-execution.ts
index 0458c0bb69..9be9a3929e 100644
--- a/src/daemon/generic-runtime-execution.ts
+++ b/src/daemon/generic-runtime-execution.ts
@@ -8,9 +8,7 @@ import type { DaemonRequest } from './daemon-request.ts';
 import type { SessionState } from './session-state.ts';
 import { resolveBoundViewportRuntime } from './viewport-runtime.ts';
 import { resolveBoundBackRuntime } from './back-runtime.ts';
-import { resolveBoundHomeRuntime } from './home-runtime.ts';
-import { resolveBoundActionButtonRuntime } from './action-button-runtime.ts';
-import { resolveBoundAppSwitcherRuntime } from './app-switcher-runtime.ts';
+import { isSystemButtonCommand, resolveBoundSystemButtonRuntime } from './system-button-runtime.ts';
 import { resolveBoundOrientationRuntime } from './orientation-runtime.ts';
 import { resolveBoundTvRemoteRuntime } from './tv-remote-runtime.ts';
 import { errorResponse } from '@agent-device/kernel/contracts';
@@ -34,6 +32,13 @@ export async function resolveGenericRuntimeExecution(
   }> &
     ScreenshotRuntimeBindings,
 ): Promise<ResolvedGenericExecution> {
+  if (isSystemButtonCommand(params.req.command)) {
+    return await resolveBoundSystemButtonRuntime(params.req.command, {
+      device: params.session.device,
+      inspectFacts: params.inspectFacts,
+      bindDevice: params.bindDevice,
+    });
+  }
   switch (params.req.command) {
     case 'screenshot':
       return await resolveScreenshotGenericExecution(params);
@@ -65,24 +70,6 @@ export async function resolveGenericRuntimeExecution(
         inspectFacts: params.inspectFacts,
         bindDevice: params.bindDevice,
       });
-    case 'home':
-      return await resolveBoundHomeRuntime({
-        device: params.session.device,
-        inspectFacts: params.inspectFacts,
-        bindDevice: params.bindDevice,
-      });
-    case 'app-switcher':
-      return await resolveBoundAppSwitcherRuntime({
-        device: params.session.device,
-        inspectFacts: params.inspectFacts,
-        bindDevice: params.bindDevice,
-      });
-    case 'action-button':
-      return await resolveBoundActionButtonRuntime({
-        device: params.session.device,
-        inspectFacts: params.inspectFacts,
-        bindDevice: params.bindDevice,
-      });
     case 'orientation':
       return await resolveBoundOrientationRuntime({
         device: params.session.device,
diff --git a/src/daemon/handlers/__tests__/install-source.test.ts b/src/daemon/handlers/__tests__/install-source.test.ts
index c37732c59e..0e065b121f 100644
--- a/src/daemon/handlers/__tests__/install-source.test.ts
+++ b/src/daemon/handlers/__tests__/install-source.test.ts
@@ -17,6 +17,7 @@ import { perfRuntimeOperationFacts } from '@agent-device/contracts/perf-runtime'
 import { clipboardRuntimeOperationFacts } from '@agent-device/contracts/clipboard-runtime';
 import { gestureRuntimeOperationFacts } from '@agent-device/contracts/gesture-runtime';
 import { keyboardRuntimeOperationFacts } from '@agent-device/contracts/keyboard-runtime';
+import { systemButtonRuntimeOperationFacts } from '@agent-device/contracts/system-button-runtime';
 import type { PlatformRuntimeOperations } from '@agent-device/contracts/platform-runtime-operations';
 import { screenshotRuntimeOperationFacts } from '@agent-device/contracts/screenshot-runtime';
 import { scrollRuntimeOperationFacts } from '@agent-device/contracts/scroll-runtime';
@@ -374,13 +375,11 @@ function sourceRuntimeFacts(
       ...scrollRuntimeOperationFacts({ scroll: unavailable }),
       readTextAtPoint: unavailable,
       back: unavailable,
-      home: unavailable,
       setOrientation: unavailable,
       tvRemote: unavailable,
       ...keyboardRuntimeOperationFacts({ unsupported: unavailable }),
       ...clipboardRuntimeOperationFacts({ unsupported: unavailable }),
-      appSwitcher: unavailable,
-      actionButton: unavailable,
+      ...systemButtonRuntimeOperationFacts({ unsupported: unavailable }),
       triggerAppEvent: unavailable,
       setSetting: unavailable,
       readAlert: unavailable,
diff --git a/src/daemon/handlers/__tests__/session-state.test.ts b/src/daemon/handlers/__tests__/session-state.test.ts
index b1e80c02ed..f823ecb06a 100644
--- a/src/daemon/handlers/__tests__/session-state.test.ts
+++ b/src/daemon/handlers/__tests__/session-state.test.ts
@@ -55,13 +55,11 @@ test('boot rejects --headless outside Android directly', async () => {
             touch: { available: false, reason: 'owner-capability-missing' },
             elementText: { available: false, reason: 'owner-capability-missing' },
             back: { available: false, reason: 'owner-capability-missing' },
-            home: { available: false, reason: 'owner-capability-missing' },
             orientation: { available: false, reason: 'owner-capability-missing' },
             tvRemote: { available: false, reason: 'owner-capability-missing' },
             keyboard: { available: false, reason: 'owner-capability-missing' },
             clipboard: { available: false, reason: 'owner-capability-missing' },
-            appSwitcher: { available: false, reason: 'owner-capability-missing' },
-            actionButton: { available: false, reason: 'owner-capability-missing' },
+            systemButton: { available: false, reason: 'owner-capability-missing' },
             triggerAppEvent: { available: false, reason: 'owner-capability-missing' },
             setSetting: { available: false, reason: 'owner-capability-missing' },
             readAlert: { available: false, reason: 'owner-capability-missing' },
@@ -162,13 +160,11 @@ test('appstate rejects web before Android app-state backend dispatch', async ()
             touch: { available: false, reason: 'unsupported-platform-leaf' },
             elementText: { available: false, reason: 'unsupported-platform-leaf' },
             back: { available: false, reason: 'unsupported-platform-leaf' },
-            home: { available: false, reason: 'unsupported-platform-leaf' },
             orientation: { available: false, reason: 'unsupported-platform-leaf' },
             tvRemote: { available: false, reason: 'unsupported-platform-leaf' },
             keyboard: { available: false, reason: 'unsupported-platform-leaf' },
             clipboard: { available: false, reason: 'unsupported-platform-leaf' },
-            appSwitcher: { available: false, reason: 'unsupported-platform-leaf' },
-            actionButton: { available: false, reason: 'unsupported-platform-leaf' },
+            systemButton: { available: false, reason: 'unsupported-platform-leaf' },
             triggerAppEvent: { available: false, reason: 'unsupported-platform-leaf' },
             setSetting: { available: false, reason: 'unsupported-platform-leaf' },
             readAlert: { available: false, reason: 'unsupported-platform-leaf' },
diff --git a/src/daemon/home-runtime.ts b/src/daemon/home-runtime.ts
deleted file mode 100644
index b20b2fe9e0..0000000000
--- a/src/daemon/home-runtime.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { HomeInput } from '@agent-device/contracts/home-runtime';
-import { homeRuntimeUse } from '@agent-device/contracts/platform-runtime-operations';
-import type { BoundDeviceRuntime } from '@agent-device/contracts/platform-runtime';
-import type { DeviceInfo } from '@agent-device/kernel/device';
-import { successText } from '@agent-device/kernel/success-text';
-import type { DaemonCommandContext } from './context.ts';
-import type { ResolvedGenericExecution } from './request-generic-dispatch.ts';
-import { resolveBoundGenericRuntime, type RuntimeAdmissionBindings } from './runtime-admission.ts';
-import { runtimeExecutionFromContext } from './snapshot-runtime-capture-input.ts';
-
-/** The neutral intent one `home` carries, projected from a resolved command context. */
-function homeInput(context: DaemonCommandContext): HomeInput {
-  return {
-    ...(context.appBundleId === undefined ? {} : { options: { appBundleId: context.appBundleId } }),
-    execution: runtimeExecutionFromContext(context),
-  };
-}
-
-/**
- * The one place `home` reaches a device (ADR 0019). Admission inspects the exact owner's `home`
- * fact and binds once, before the dispatcher runs, so an owner that cannot navigate home is
- * refused rather than discovered mid-execution.
- */
-export async function resolveBoundHomeRuntime(
-  params: {
-    device: DeviceInfo;
-  } & RuntimeAdmissionBindings,
-): Promise<ResolvedGenericExecution> {
-  return await resolveBoundGenericRuntime(
-    {
-      command: 'home',
-      device: params.device,
-      use: homeRuntimeUse,
-      inspectFacts: params.inspectFacts,
-      bindDevice: params.bindDevice,
-    },
-    executeHome,
-  );
-}
-
-/**
- * The ONE place a bound `home` executes (R43). Typed off `typeof homeRuntimeUse` rather than a
- * hand-restated operations shape, so a change to what `home` binds can't silently drift here.
- */
-async function executeHome(
-  runtime: BoundDeviceRuntime<typeof homeRuntimeUse>,
-  context: DaemonCommandContext,
-): Promise<Record<string, unknown>> {
-  await runtime.operations.home(homeInput(context));
-  return { action: 'home', ...successText('Home') };
-}
diff --git a/src/daemon/system-button-runtime.ts b/src/daemon/system-button-runtime.ts
new file mode 100644
index 0000000000..17fbf4e78e
--- /dev/null
+++ b/src/daemon/system-button-runtime.ts
@@ -0,0 +1,83 @@
+import {
+  actionButtonRuntimeUse,
+  appSwitcherRuntimeUse,
+  homeRuntimeUse,
+  type PlatformRuntimeOperations,
+} from '@agent-device/contracts/platform-runtime-operations';
+import type { BoundDeviceRuntime, RuntimeUse } from '@agent-device/contracts/platform-runtime';
+import type {
+  SystemButton,
+  SystemButtonInput,
+} from '@agent-device/contracts/system-button-runtime';
+import type { DeviceInfo } from '@agent-device/kernel/device';
+import { successText } from '@agent-device/kernel/success-text';
+import type { DaemonCommandContext } from './context.ts';
+import type { ResolvedGenericExecution } from './request-generic-dispatch.ts';
+import { resolveBoundGenericRuntime, type RuntimeAdmissionBindings } from './runtime-admission.ts';
+import { runtimeExecutionFromContext } from './snapshot-runtime-capture-input.ts';
+
+type SystemButtonUse = RuntimeUse<
+  PlatformRuntimeOperations,
+  readonly [SystemButton],
+  readonly [],
+  readonly []
+>;
+
+type SystemButtonCommandRow = Readonly<{
+  /** The registry's declared use for the command: exactly one system-button cell. */
+  use: SystemButtonUse;
+  /** The success text the press reports; the response carries nothing else by design. */
+  message: string;
+}>;
+
+/**
+ * The generic-route commands that are one system-button press each (ADR 0019). A press has no
+ * arguments, no settle and no observation payload: it is delivered to whatever the system routes
+ * it to, and the response is the button's success text. One row per command is what keeps a new
+ * button from growing a module, a dispatcher arm and a conformance entry of its own.
+ */
+const SYSTEM_BUTTON_COMMANDS = {
+  home: { use: homeRuntimeUse, message: 'Home' },
+  'app-switcher': { use: appSwitcherRuntimeUse, message: 'Opened app switcher' },
+  'action-button': { use: actionButtonRuntimeUse, message: 'Pressed Action Button' },
+} as const satisfies Record<string, SystemButtonCommandRow>;
+
+export type SystemButtonCommand = keyof typeof SYSTEM_BUTTON_COMMANDS;
+
+export function isSystemButtonCommand(command: string): command is SystemButtonCommand {
+  return Object.hasOwn(SYSTEM_BUTTON_COMMANDS, command);
+}
+
+/** The neutral intent one press carries, projected from a resolved command context. */
+function systemButtonInput(context: DaemonCommandContext): SystemButtonInput {
+  return {
+    ...(context.appBundleId === undefined ? {} : { options: { appBundleId: context.appBundleId } }),
+    execution: runtimeExecutionFromContext(context),
+  };
+}
+
+/**
+ * The one place a system-button command reaches a device. Admission inspects the exact owner's
+ * cell for the button and binds once, before the dispatcher runs, so an owner without the control
+ * is refused rather than discovered mid-execution.
+ */
+export async function resolveBoundSystemButtonRuntime(
+  command: SystemButtonCommand,
+  params: { device: DeviceInfo } & RuntimeAdmissionBindings,
+): Promise<ResolvedGenericExecution> {
+  const row: SystemButtonCommandRow = SYSTEM_BUTTON_COMMANDS[command];
+  return await resolveBoundGenericRuntime(
+    {
+      command,
+      device: params.device,
+      use: row.use,
+      inspectFacts: params.inspectFacts,
+      bindDevice: params.bindDevice,
+    },
+    async (runtime: BoundDeviceRuntime<SystemButtonUse>, context) => {
+      const [button] = row.use.required;
+      await runtime.operations[button](systemButtonInput(context));
+      return { action: command, ...successText(row.message) };
+    },
+  );
+}
diff --git a/src/platform-runtime-gateway.test.ts b/src/platform-runtime-gateway.test.ts
index 5c915fe9f8..d2a644f626 100644
--- a/src/platform-runtime-gateway.test.ts
+++ b/src/platform-runtime-gateway.test.ts
@@ -63,13 +63,11 @@ describe('composed platform runtime gateway', () => {
       scroll: unavailable,
       typeText: unavailable,
       back: unavailable,
-      home: unavailable,
       orientation: unavailable,
       tvRemote: unavailable,
       keyboard: unavailable,
       clipboard: unavailable,
-      appSwitcher: unavailable,
-      actionButton: unavailable,
+      systemButton: unavailable,
       triggerAppEvent: unavailable,
       setSetting: unavailable,
       readAlert: unavailable,
@@ -162,13 +160,11 @@ describe('composed platform runtime gateway', () => {
       touch: unavailable,
       elementText: unavailable,
       back: unavailable,
-      home: unavailable,
       orientation: unavailable,
       tvRemote: unavailable,
       keyboard: unavailable,
       clipboard: unavailable,
-      appSwitcher: unavailable,
-      actionButton: unavailable,
+      systemButton: unavailable,
       triggerAppEvent: unavailable,
       setSetting: unavailable,
       readAlert: unavailable,
diff --git a/test/integration/command-coverage/declarations.ts b/test/integration/command-coverage/declarations.ts
index 8ac09b2768..ffd0945c3a 100644
--- a/test/integration/command-coverage/declarations.ts
+++ b/test/integration/command-coverage/declarations.ts
@@ -19,12 +19,15 @@ import {
   ANDROID_HOVER_RUNTIME_CONTRACT_EVIDENCE,
   ANDROID_TV_REMOTE_RUNTIME_CONTRACT_EVIDENCE,
   ANDROID_VIEWPORT_RUNTIME_CONTRACT_EVIDENCE,
+  APPLE_ACTION_BUTTON_FACT_EVIDENCE,
   APPLE_HOVER_DENIAL_EVIDENCE,
+  APPLE_NAVIGATION_FACTS_EVIDENCE,
   LINUX_HOVER_DENIAL_EVIDENCE,
   LINUX_PROVIDER_EVIDENCE,
   LINUX_RUNTIME_EVIDENCE,
   TVOS_AUDIO_EVIDENCE,
   TVOS_REMOTE_EVIDENCE,
+  WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE,
 } from './evidence.ts';
 
 const C = PUBLIC_COMMANDS;
@@ -406,8 +409,8 @@ const COMMAND_COVERAGE_DECLARATIONS = {
     ),
     tvos: tvos.gap('No tvOS-specific clipboard command evidence exists yet'),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact rejects native clipboard operations on the web target',
     ),
     linux: linux.contract(
@@ -426,13 +429,13 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'real keyboard dismissal reports dismissed=true and visible=false',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects keyboard actions on the macOS AppKit desktop leaf',
     ),
     tvos: tvos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects keyboard input on the tvOS focus-only leaf',
     ),
     web: web.contract(
@@ -541,8 +544,8 @@ const COMMAND_COVERAGE_DECLARATIONS = {
     ),
     tvos: tvos.gap('No tvOS-specific app-event command evidence exists yet'),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact rejects native app-event delivery on the web target',
     ),
     linux: linux.contract(
@@ -715,8 +718,8 @@ const COMMAND_COVERAGE_DECLARATIONS = {
     ),
     tvos: tvos.gap('No tvOS-specific alert command evidence exists yet'),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact rejects native alert handling on the web target',
     ),
     linux: linux.contract(
@@ -740,8 +743,8 @@ const COMMAND_COVERAGE_DECLARATIONS = {
     ),
     tvos: tvos.gap('No tvOS-specific settings command evidence exists yet'),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact rejects native device settings on the web target',
     ),
     linux: linux.contract(
@@ -1080,8 +1083,8 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'fixture AppState becomes non-active and system pixels replace foreground pixels',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects mobile Home navigation on the macOS leaf, which drives an already-running app with no springboard',
     ),
     tvos: tvos.contract(
@@ -1106,18 +1109,18 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'Android tv-remote admission is owned by its exact-owner runtime fact: available only for a real Android TV target, not the mobile emulator',
     ),
     iosSimulator: iosSimulator.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'tv-remote admission is owned by its exact-owner runtime fact: available only for the tvOS leaf, not the iOS mobile simulator',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact admits TV remote input only for the tvOS leaf, not macOS',
     ),
     tvos: tvos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact admits tv-remote for the tvOS leaf, which drives navigation through XCUIRemote presses',
     ),
     web: web.contract(
@@ -1141,13 +1144,13 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'native runner reads back exact landscape-left and portrait device states',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects device orientation changes on the macOS leaf',
     ),
     tvos: tvos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects device orientation changes on the tvOS leaf',
     ),
     web: web.contract(
@@ -1279,14 +1282,14 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'app switcher covers fixture controls and differs from Home before restoration',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+      APPLE_NAVIGATION_FACTS_EVIDENCE.path,
+      APPLE_NAVIGATION_FACTS_EVIDENCE.test,
       'the exact-owner runtime fact rejects app-switcher navigation on the macOS host leaf',
     ),
     tvos: tvos.gap('No tvOS-specific app-switcher command evidence exists yet'),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact rejects native app-switcher navigation on the web target',
     ),
     linux: linux.contract(
@@ -1301,23 +1304,23 @@ const COMMAND_COVERAGE_DECLARATIONS = {
       'the Android runtime fact refuses an iPhone Action Button press on every kind',
     ),
     iosSimulator: iosSimulator.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies the action-button fact for the %s leaf',
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.path,
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.test,
       'the iOS simulator leaf advertises the Action Button press and binds it',
     ),
     macos: macos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies the action-button fact for the %s leaf',
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.path,
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.test,
       'the exact-owner runtime fact refuses action-button on the macOS host leaf',
     ),
     tvos: tvos.contract(
-      'packages/platform-apple/src/runtime.test.ts',
-      'classifies the action-button fact for the %s leaf',
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.path,
+      APPLE_ACTION_BUTTON_FACT_EVIDENCE.test,
       'the exact-owner runtime fact refuses action-button on the tvOS leaf, whose remote has no such control',
     ),
     web: web.contract(
-      'packages/platform-web/src/runtime.test.ts',
-      'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.path,
+      WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE.test,
       'the exact-owner runtime fact refuses an Action Button press on the web target',
     ),
     linux: linux.contract(
diff --git a/test/integration/command-coverage/evidence.ts b/test/integration/command-coverage/evidence.ts
index baf223db2e..742c64d30d 100644
--- a/test/integration/command-coverage/evidence.ts
+++ b/test/integration/command-coverage/evidence.ts
@@ -61,11 +61,26 @@ export const TVOS_AUDIO_EVIDENCE: RepositoryEvidence = {
   path: 'packages/platform-apple/src/runtime.test.ts',
   test: 'tvOS audio capture availability follows the exact host-owned runtime fact',
 };
+/** The Apple owner's one navigation-fact classification, cited by every leaf it refuses. */
+export const APPLE_NAVIGATION_FACTS_EVIDENCE: RepositoryEvidence = {
+  path: 'packages/platform-apple/src/runtime.test.ts',
+  test: 'classifies back/home/app-switcher/orientation/tv-remote/keyboard facts for the %s leaf',
+};
+export const APPLE_ACTION_BUTTON_FACT_EVIDENCE: RepositoryEvidence = {
+  path: 'packages/platform-apple/src/runtime.test.ts',
+  test: 'classifies the action-button fact for the %s leaf',
+};
 export const APPLE_HOVER_DENIAL_EVIDENCE: RepositoryEvidence = {
   path: 'packages/platform-apple/src/runtime.test.ts',
   test: 'hover has no Apple interactor route on macOS, iOS, or tvOS; the touch family reports its typed denial',
 };
 
+/** The web owner's one denial of the system-surface leaves, cited by every command it refuses. */
+export const WEB_SYSTEM_SURFACE_DENIAL_EVIDENCE: RepositoryEvidence = {
+  path: 'packages/platform-web/src/runtime.test.ts',
+  test: 'clipboard, the app switcher, app events, settings and alerts carry no web bucket',
+};
+
 export const WEB_SMOKE_TEST_NAME = 'live web platform e2e smoke';
 export const WEB_SMOKE_EVIDENCE: RepositoryEvidence = {
   path: 'test/integration/smoke-web-platform.test.ts',