diff --git a/AGENTS.md b/AGENTS.md
index 2b333997c..a3a9bbd9c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -276,9 +276,9 @@ This repo encodes invariants as self-declaring gates. The correct response to a
 - Commit messages and PR titles should use conventional prefixes such as `feat:`, `fix:`, `chore:`, `perf:`, `refactor:`, `docs:`, `test:`, `build:`, or `ci:` as appropriate.
 - Do not use bracketed automation prefixes such as `[codex]` or similar bot tags in commit messages or PR titles.
 - Open a ready-for-review PR by default. Use a draft PR only when the user explicitly asks for one or the work is intentionally incomplete.
-- PR body must be short and include:
-  - `## Summary`: lead with benefits and reviewer-relevant outcomes. Prefer a compact before/after when it makes the improvement clearer. Include the issue closed by the PR using `Closes #123` when applicable.
-  - `## Validation`: answer this prompt in concise prose: "How did you verify the change, and what passed or changed on screen?" Prefer evidence over command dumps; mention the relevant check category or scenario, and include screenshots when visual/UI behavior is relevant.
+- PR body must be short, reviewer-oriented, and include:
+  - `## Summary`: describe the user/API behavior, not the implementation file tour. Lead with what changed for operators, clients, command authors, or platform behavior. Use a compact before/after when it clarifies the workflow or bug fix. For new or changed public APIs, include 1-3 concrete CLI/Node/MCP examples that reviewers can scan. Include `Closes #123` when applicable.
+  - `## Validation`: summarize meaningful evidence in concise prose or bullets. Prefer scenario names, manual device/browser evidence, changed screenshots, CI status, and notable failures/retries with their outcome. Avoid command accounting for routine local gates; mention an exact command only when it is unusual, manually reproducible evidence, or necessary to explain a residual risk. For docs-only changes, say why runtime validation is not applicable instead of writing a command checklist.
 - Call out real tradeoffs, known gaps, or follow-ups explicitly; omit boilerplate when there are none.
 - Include touched-file count and note if scope expanded beyond initial command family.
 
diff --git a/CONTEXT.md b/CONTEXT.md
index 38add6c7b..2763f99af 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -72,8 +72,9 @@ The perfect-shape refactor is complete and merged. Its end-state:
   (`src/core/command-descriptor/registry.ts`) is the single declaration site from which the
   capability matrix, daemon command registry, batch allowlist, timeout policy, MCP exposure list, and
   capability-checked CLI command list are *derived* by parity-tested projection. The command catalog
-  still owns identity, command families still own surface metadata/CLI schema, and the Node client
-  surface remains a deferred derivation target. One
+  still owns identity, command families still own surface metadata/CLI schema, and system command
+  facets now project their simple Node client command methods; the rest of the Node client surface
+  remains a deferred derivation target. One
   `PlatformPlugin` per platform family (`src/core/platform-plugin/`) stops core/daemon from branching
   on platform, with the Apple plugin the first instance. See
   [ADR 0008](docs/adr/0008-command-descriptor-registry.md).
diff --git a/scripts/integration-progress-model.ts b/scripts/integration-progress-model.ts
index 299d78a7d..1b4c4511f 100644
--- a/scripts/integration-progress-model.ts
+++ b/scripts/integration-progress-model.ts
@@ -152,7 +152,7 @@ function summarizeProviderScenarioFlagCoverage(files) {
     ['hideTouches', 'recording without touch overlays'],
     ['intervalMs', 'repeated press interval'],
     ['delayMs', 'typing/fill delay'],
-    ['durationMs', 'scroll and gesture duration'],
+    ['durationMs', 'scroll, gesture, and TV remote duration'],
     ['holdMs', 'press hold duration'],
     ['jitterPx', 'press jitter'],
     ['pixels', 'scroll distance'],
diff --git a/src/__tests__/cli-grammar.test.ts b/src/__tests__/cli-grammar.test.ts
index 5b62e5868..a2b9e42e9 100644
--- a/src/__tests__/cli-grammar.test.ts
+++ b/src/__tests__/cli-grammar.test.ts
@@ -164,7 +164,7 @@ test('is grammar explains the predicate/selector-key collision on invalid predic
       assert.equal(err.code, 'INVALID_ARGS');
       assert.match(
         err.message,
-        /is requires predicate: visible\|hidden\|exists\|editable\|selected\|text/,
+        /is requires predicate: visible\|hidden\|exists\|editable\|selected\|focused\|text/,
       );
       assert.match(err.details?.hint ?? '', /is <selector> <predicate>/);
       assert.match(err.details?.hint ?? '', /visible=true/);
diff --git a/src/__tests__/contracts-schema-public.test.ts b/src/__tests__/contracts-schema-public.test.ts
index b22506e68..be88f7bcd 100644
--- a/src/__tests__/contracts-schema-public.test.ts
+++ b/src/__tests__/contracts-schema-public.test.ts
@@ -12,6 +12,7 @@ import type {
   BackCommandResult,
   HomeCommandResult,
   RotateCommandResult,
+  TvRemoteCommandResult,
 } from '../contracts/navigation.ts';
 import type { ViewportCommandResult } from '../contracts/viewport.ts';
 import { centerOfRect, defaultHintForCode, normalizeError } from '../sdk/contracts.ts';
@@ -166,6 +167,13 @@ test('command result contracts are assignable to command result map', () => {
   } satisfies RotateCommandResult;
   const rotateFromMap: CommandResult<'rotate'> = rotate;
 
+  const tvRemote = {
+    action: 'tv-remote',
+    button: 'select',
+    message: 'Pressed TV remote select',
+  } satisfies TvRemoteCommandResult;
+  const tvRemoteFromMap: CommandResult<'tv-remote'> = tvRemote;
+
   const clipboard = {
     action: 'write',
     textLength: 11,
@@ -187,6 +195,7 @@ test('command result contracts are assignable to command result map', () => {
   assert.equal(homeFromMap.action, 'home');
   assert.equal(appSwitcherFromMap.action, 'app-switcher');
   assert.equal(rotateFromMap.orientation, 'portrait');
+  assert.equal(tvRemoteFromMap.button, 'select');
   assert.equal(clipboardFromMap.action === 'write' ? clipboardFromMap.textLength : -1, 11);
   assert.equal(
     appstateFromMap.platform === 'android' ? appstateFromMap.package : '',
diff --git a/src/__tests__/runtime-public.test.ts b/src/__tests__/runtime-public.test.ts
index 7c8559438..6aace159d 100644
--- a/src/__tests__/runtime-public.test.ts
+++ b/src/__tests__/runtime-public.test.ts
@@ -265,6 +265,7 @@ test('internal backend, commands, and io modules are usable', () => {
   assert.equal(typeof commands.system.settings, 'function');
   assert.equal(typeof commands.system.alert, 'function');
   assert.equal(typeof commands.system.appSwitcher, 'function');
+  assert.equal(typeof commands.system.tvRemote, 'function');
   assert.equal(typeof commands.admin.devices, 'function');
   assert.equal(typeof commands.admin.install, 'function');
   assert.equal(typeof commands.recording.record, 'function');
diff --git a/src/backend.ts b/src/backend.ts
index e58e6db11..b619a2ce2 100644
--- a/src/backend.ts
+++ b/src/backend.ts
@@ -9,6 +9,7 @@ import type { ClickButton } from './core/click-button.ts';
 import type { DeviceRotation } from './core/device-rotation.ts';
 import type { ScrollDirection } from './core/scroll-gesture.ts';
 import type { SessionSurface } from './core/session-surface.ts';
+import type { TvRemoteButton } from './core/tv-remote.ts';
 import type { RecordingExportQuality } from './core/recording-export-quality.ts';
 import type { SnapshotDiagnosticsSummary } from './snapshot-diagnostics.ts';
 import type {
@@ -87,6 +88,11 @@ export type BackendBackOptions = {
   mode?: BackMode;
 };
 
+export type BackendTvRemoteOptions = {
+  button: TvRemoteButton;
+  durationMs?: number;
+};
+
 export type BackendKeyboardOptions = {
   action: 'status' | 'get' | 'dismiss' | 'enter' | 'return';
 };
@@ -491,6 +497,10 @@ export type AgentDeviceBackend = {
     options?: BackendBackOptions,
   ): Promise<BackendActionResult>;
   pressHome?(context: BackendCommandContext): Promise<BackendActionResult>;
+  pressTvRemote?(
+    context: BackendCommandContext,
+    options: BackendTvRemoteOptions,
+  ): Promise<BackendActionResult>;
   rotate?(
     context: BackendCommandContext,
     orientation: BackendDeviceOrientation,
diff --git a/src/cli/parser/__tests__/args-parse-interaction.test.ts b/src/cli/parser/__tests__/args-parse-interaction.test.ts
index 1942f09b5..dd3c0b2e9 100644
--- a/src/cli/parser/__tests__/args-parse-interaction.test.ts
+++ b/src/cli/parser/__tests__/args-parse-interaction.test.ts
@@ -26,6 +26,21 @@ test('parseArgs accepts keyboard subcommands', () => {
   assert.deepEqual(enter.positionals, ['enter']);
 });
 
+test('parseArgs accepts tv-remote', () => {
+  const remote = parseArgs(['tv-remote', 'press', 'select', '--duration-ms', '250'], {
+    strictFlags: true,
+  });
+  assert.equal(remote.command, 'tv-remote');
+  assert.deepEqual(remote.positionals, ['press', 'select']);
+  assert.equal(remote.flags.durationMs, 250);
+
+  const longpress = parseArgs(['tv-remote', 'longpress', 'select'], {
+    strictFlags: true,
+  });
+  assert.equal(longpress.command, 'tv-remote');
+  assert.deepEqual(longpress.positionals, ['longpress', 'select']);
+});
+
 test('parseArgs accepts scroll pixel distance and duration flags', () => {
   const parsed = parseArgs(['scroll', 'down', '--pixels', '240', '--duration-ms', '50'], {
     strictFlags: true,
diff --git a/src/cli/parser/__tests__/cli-help-command-usage.test.ts b/src/cli/parser/__tests__/cli-help-command-usage.test.ts
index 355a12cf8..242bafab3 100644
--- a/src/cli/parser/__tests__/cli-help-command-usage.test.ts
+++ b/src/cli/parser/__tests__/cli-help-command-usage.test.ts
@@ -35,6 +35,14 @@ test('usageForCommand resolves longpress help', async () => {
   assert.match(help ?? '', /agent-device longpress <x y\|@ref\|selector> \[durationMs\]/);
 });
 
+test('usageForCommand documents tv-remote longpress preset', async () => {
+  const help = await usageForCommand('tv-remote');
+  assert.equal(help === null, false);
+  assert.match(help ?? '', /agent-device tv-remote \[press\|longpress\]/);
+  assert.match(help ?? '', /--duration-ms <ms>/);
+  assert.match(help ?? '', /Use longpress for a 500ms held remote button/);
+});
+
 test('usageForCommand supports legacy long-press alias', async () => {
   const help = await usageForCommand('long-press');
   assert.equal(help === null, false);
diff --git a/src/cli/parser/__tests__/cli-help-topics.test.ts b/src/cli/parser/__tests__/cli-help-topics.test.ts
index d3c302a31..cef6b4cbe 100644
--- a/src/cli/parser/__tests__/cli-help-topics.test.ts
+++ b/src/cli/parser/__tests__/cli-help-topics.test.ts
@@ -155,6 +155,10 @@ test('usage includes agent workflows, config, environment, and examples footers'
     usageText,
     /agent-device help debugging\s+Use when logs, network, audio, perf memory, traces, alerts, or diagnostics matter/,
   );
+  assert.match(
+    usageText,
+    /agent-device help tv\s+Use when navigating Android TV or tvOS focus-first surfaces/,
+  );
   assert.match(
     usageText,
     /agent-device help react-devtools\s+Use when inspecting components, props\/state\/hooks, renders, or profiles/,
@@ -296,6 +300,20 @@ test('usageForCommand resolves workflow help topic', async () => {
   assert.doesNotMatch(help, /agent-device react-devtools profile/);
 });
 
+test('usageForCommand resolves tv help topic', async () => {
+  const help = await usageForCommand('tv');
+  if (help === null) throw new Error('Expected tv help text');
+  assert.match(help, /agent-device help tv/);
+  assert.match(help, /agent-device tv-remote press down/);
+  assert.match(help, /agent-device screenshot \.\/tv-focus\.png --overlay-refs/);
+  assert.match(help, /tv-remote longpress select/);
+  assert.match(help, /tv-remote press select --duration-ms 500/);
+  assert.match(help, /longpress is CLI sugar for --duration-ms 500/);
+  assert.match(help, /ok, center, and enter are input aliases for select/);
+  assert.match(help, /do not switch to raw adb keyevent/);
+  assert.match(help, /Use --platform ios --target tv/);
+});
+
 test('usageForCommand resolves web help topic', async () => {
   const help = await usageForCommand('web');
   if (help === null) throw new Error('Expected web help text');
diff --git a/src/cli/parser/cli-help.ts b/src/cli/parser/cli-help.ts
index c148300cd..4f38d4003 100644
--- a/src/cli/parser/cli-help.ts
+++ b/src/cli/parser/cli-help.ts
@@ -19,6 +19,10 @@ const AGENT_WORKFLOWS = [
     description:
       'Use when logs, network, audio, perf memory, traces, alerts, or diagnostics matter',
   },
+  {
+    label: 'agent-device help tv',
+    description: 'Use when navigating Android TV or tvOS focus-first surfaces',
+  },
   {
     label: 'agent-device help react-native',
     description: 'Use when the target app is React Native, Expo, or a dev client',
@@ -94,6 +98,7 @@ const AGENT_QUICKSTART_LINES = [
   'Direct proxy: run agent-device connect proxy --daemon-base-url <proxy-agent-device-url> before using a shared Mac proxy. Device leases are automatic on open and expire after five minutes of inactivity.',
   'Batch JSON steps use "command" and structured "input"; legacy "positionals"/"flags" steps still run in CLI but are deprecated until the next major version.',
   'Navigation: app-owned back uses back; system back uses back --system.',
+  'TV targets are focus-first: read help tv; use tv-remote press up|down|left|right|select to move D-pad/remote focus, tv-remote longpress <button> for a held remote button, and activate focused controls before assuming press/click @ref works.',
   'Web browser sessions: read help web; first slice is web setup if needed -> web doctor -> open <url> --platform web -> snapshot -i -> click/fill/get/is/find/wait/screenshot -> close.',
   'Verification commands must name the expected text/selector; bare screenshots/snapshots are not enough.',
   'Debug evidence: Session state contains request diagnostics and runner.log; use logs clear --restart/mark/path, trace, and network dump --include headers for app evidence.',
@@ -156,7 +161,7 @@ Command shape:
   Snapshot refs look like @e12. After snapshot -i, use the exact @eN ref from that output.
   If the exact ref is not known yet, first output snapshot -i, then use a concrete example shape like press @e12 in the next command; do not write @<ref>, @ref, @Label_Name, or @eN placeholders.
   Close means agent-device close. App-owned back means back; system back means back --system.
-  Taps are press or click; tap is an alias for press. Gestures use swipe, longpress, or gesture <pan|fling|swipe|pinch|rotate|transform>. Use gesture swipe left|right for reliable in-page horizontal swipes, and gesture swipe right-edge for left-edge navigation/back gestures. Android swipe, pinch, rotate, and transform use provider-native touch injection when available, then the bundled touch helper. iOS simulator transform uses private XCTest synthesis for a continuous two-finger pan/scale/rotation path; otherwise it reports UNSUPPORTED_OPERATION.
+  Taps are press or click; tap is an alias for press. On Android TV and tvOS, read help tv and use tv-remote press up|down|left|right|select to move D-pad/remote focus before activating controls; use tv-remote longpress <button> for a held remote button. Gestures use swipe, longpress, or gesture <pan|fling|swipe|pinch|rotate|transform>. Use gesture swipe left|right for reliable in-page horizontal swipes, and gesture swipe right-edge for left-edge navigation/back gestures. Android swipe, pinch, rotate, and transform use provider-native touch injection when available, then the bundled touch helper. iOS simulator transform uses private XCTest synthesis for a continuous two-finger pan/scale/rotation path; otherwise it reports UNSUPPORTED_OPERATION.
 
 Bootstrap:
   agent-device devices --platform ios
@@ -194,6 +199,7 @@ Snapshots and refs:
   Missing target in a long list: use a short manual scroll + snapshot loop with a max attempt count. If a named target is summarized as off-screen below/above, use scroll down/up, then snapshot -i; do not use scroll bottom/top because the target may appear before the absolute list edge. Use scroll bottom/top only when the task explicitly asks for the list edge. Edge scrolls verify hidden content with snapshots and stop when no matching hidden content remains.
   Truncated text/input previews: do not use get text first; expand with snapshot -s @ref (for example snapshot -s @e7), then read the scoped output.
   Rare iOS accessibility gaps: if a row ref is shown disabled/hittable:false and press @ref reports success but no UI change, or a horizontal tab/filter bar is collapsed into one composite/seekbar with no child refs, run agent-device snapshot -i --json to read rects, compute the target center, press x y, then diff snapshot -i. Coordinates are fallback-only; document why you used them.
+  TV focus gaps: read help tv. If a fresh snapshot exposes focused nodes, verify with is focused <selector>; use wait focused=true only on apps where repeated snapshots preserve focus metadata. If the app exposes only a surface view or focus metadata is transient, use screenshot/snapshot diff as visual truth and tv-remote press directions/select; do not switch to raw adb keyevent in command plans.
 
 Selectors:
   Use selectors as positional targets: id="field-email" or label="Allow".
@@ -351,12 +357,50 @@ Guarantees:
 
 Escalate:
   help debugging       logs, network, alerts, traces, flaky runtime failures
+  help tv              Android TV and tvOS focus-first remote navigation
   help react-devtools  React Native performance, profiling, props/state/hooks, slow renders, rerenders
   help react-native   React Native app automation hazards, overlays, Metro, and routing
   help remote          remote/cloud config, tenant, lease, local service tunnels
   help macos           desktop, frontmost-app, menu bar surfaces
   help dogfood         exploratory QA report workflow`,
   },
+  tv: {
+    summary: 'Android TV and tvOS focus-first remote navigation',
+    body: `agent-device help tv
+
+Use this when the target is Android TV, Apple TV, or tvOS. TV surfaces are focus-first: move focus with remote/D-pad buttons, then activate the focused control.
+
+Core loop:
+  agent-device open Settings --platform android --target tv --session tv
+  agent-device snapshot -i --platform android --target tv --session tv
+  agent-device tv-remote press down --platform android --target tv --session tv
+  agent-device is focused 'label="Profiles"' --platform android --target tv --session tv
+  agent-device tv-remote press select --platform android --target tv --session tv
+  agent-device screenshot ./tv-focus.png --overlay-refs --platform android --target tv --session tv
+
+Buttons:
+  tv-remote press up|down|left|right|select|menu|home|back
+  tv-remote longpress select
+  tv-remote press select --duration-ms 500
+  ok, center, and enter are input aliases for select; command output still reports button: "select".
+  longpress is CLI sugar for --duration-ms 500. --duration-ms overrides that preset.
+  --duration-ms holds a tvOS remote button for that duration. On Android TV, any positive duration maps to the ADB longpress form because Android input keyevent has no exact hold duration.
+
+Android TV:
+  Android TV uses ADB keyevents behind agent-device tv-remote. Keep command plans on agent-device; do not switch to raw adb keyevent.
+  Use --target tv when a host has both phone/tablet and TV emulators/devices.
+
+tvOS:
+  tvOS is driven by the Siri Remote focus engine, not coordinate taps.
+  back maps to the Menu remote button; home maps to the Home remote button.
+  Use --platform ios --target tv for Apple TV simulators and devices.
+
+Focus and visual truth:
+  If snapshot -i exposes a focused node, verify it with is focused <selector>.
+  Use wait focused=true only when repeated snapshots preserve focus metadata for the app.
+  If the app exposes only a surface view, or focus metadata is transient, use screenshot --overlay-refs, screenshot, or diff snapshot as visual truth and keep moving focus with tv-remote.
+  Do not assume press/click @ref works on Android TV or tvOS until the desired element is focused.`,
+  },
   debugging: {
     summary: 'Targeted failure evidence without dumping stale context',
     body: `agent-device help debugging
diff --git a/src/client/client-types.ts b/src/client/client-types.ts
index b154c2585..51955d2aa 100644
--- a/src/client/client-types.ts
+++ b/src/client/client-types.ts
@@ -23,6 +23,7 @@ import type { BackMode } from '../core/back-mode.ts';
 import type { ClickButton } from '../core/click-button.ts';
 import type { RecordingExportQuality } from '../core/recording-export-quality.ts';
 import type { DeviceRotation } from '../core/device-rotation.ts';
+import type { TvRemoteButton } from '../core/tv-remote.ts';
 import type {
   ScrollDirection,
   SwipePattern,
@@ -70,6 +71,7 @@ export type {
   BackCommandResult,
   HomeCommandResult,
   RotateCommandResult,
+  TvRemoteCommandResult,
 } from '../contracts/navigation.ts';
 export type { ClipboardCommandResult } from '../contracts/clipboard.ts';
 export type { AppStateCommandResult } from '../contracts/app-state.ts';
@@ -534,6 +536,11 @@ export type ClipboardCommandOptions =
       text: string;
     });
 
+export type TvRemoteCommandOptions = DeviceCommandBaseOptions & {
+  button: TvRemoteButton;
+  durationMs?: number;
+};
+
 export type ReactNativeCommandOptions = DeviceCommandBaseOptions & {
   action: 'dismiss-overlay';
 };
@@ -563,6 +570,7 @@ export type AgentDeviceCommandClient = {
   appSwitcher: (options?: AppSwitcherCommandOptions) => Promise<CommandResult<'app-switcher'>>;
   keyboard: (options?: KeyboardCommandOptions) => Promise<CommandResult<'keyboard'>>;
   clipboard: (options: ClipboardCommandOptions) => Promise<CommandResult<'clipboard'>>;
+  tvRemote: (options: TvRemoteCommandOptions) => Promise<CommandResult<'tv-remote'>>;
   reactNative: (options: ReactNativeCommandOptions) => Promise<CommandRequestResult>;
   doctor: (options?: DoctorCommandOptions) => Promise<CommandRequestResult>;
   /**
@@ -763,7 +771,7 @@ type IsTextPredicateOptions = DeviceCommandBaseOptions &
 
 type IsStatePredicateOptions = DeviceCommandBaseOptions &
   SelectorSnapshotCommandOptions & {
-    predicate: 'visible' | 'hidden' | 'exists' | 'editable' | 'selected';
+    predicate: 'visible' | 'hidden' | 'exists' | 'editable' | 'selected' | 'focused';
     selector: string;
     value?: never;
   };
diff --git a/src/client/client.ts b/src/client/client.ts
index 10f3181aa..1d929748d 100644
--- a/src/client/client.ts
+++ b/src/client/client.ts
@@ -6,6 +6,7 @@ import {
   prepareDaemonCommandRequest,
   type DaemonCommandName,
 } from '../commands/command-projection.ts';
+import { systemCommandFamily } from '../commands/system/index.ts';
 import { buildRequestFlags } from '../commands/command-flags.ts';
 import { throwDaemonError } from '../daemon-error.ts';
 import {
@@ -27,6 +28,7 @@ import {
 import { readScreenshotResultData } from '../utils/screenshot-result.ts';
 import { isRecord } from '../utils/parsing.ts';
 import type {
+  AgentDeviceCommandClient,
   AgentDeviceClient,
   AgentDeviceClientConfig,
   AgentDeviceDaemonTransport,
@@ -52,6 +54,11 @@ import { readSnapshotDiagnosticsSummary } from '../snapshot-diagnostics.ts';
 import type { CommandFlags } from '../core/dispatch-context.ts';
 import type { AgentArtifactsResult } from '../cloud-artifacts.ts';
 
+type ProjectedSystemCommandClient = Pick<
+  AgentDeviceCommandClient,
+  'appState' | 'back' | 'home' | 'rotate' | 'appSwitcher' | 'keyboard' | 'clipboard' | 'tvRemote'
+>;
+
 export function createAgentDeviceClient(
   config: AgentDeviceClientConfig = {},
   deps: { transport?: AgentDeviceDaemonTransport } = {},
@@ -106,22 +113,13 @@ export function createAgentDeviceClient(
 
   const resolveRequestSession = (options: InternalRequestOptions = {}) =>
     resolveSessionName(mergeClientOptions(config, options).session);
+  const projectedSystemCommands = buildProjectedSystemCommandClient(executeCommand);
 
   return {
     command: {
       wait: async (options) => await executeCommand('wait', options),
       alert: async (options = {}) => await executeCommand('alert', options),
-      appState: async (options = {}) =>
-        await executeCommand<CommandResult<'appstate'>>('appstate', options),
-      back: async (options = {}) => await executeCommand<CommandResult<'back'>>('back', options),
-      home: async (options = {}) => await executeCommand<CommandResult<'home'>>('home', options),
-      rotate: async (options) => await executeCommand<CommandResult<'rotate'>>('rotate', options),
-      appSwitcher: async (options = {}) =>
-        await executeCommand<CommandResult<'app-switcher'>>('app-switcher', options),
-      keyboard: async (options = {}) =>
-        await executeCommand<CommandResult<'keyboard'>>('keyboard', options),
-      clipboard: async (options) =>
-        await executeCommand<CommandResult<'clipboard'>>('clipboard', options),
+      ...projectedSystemCommands,
       reactNative: async (options) => await executeCommand('react-native', options),
       doctor: async (options = {}) => await executeCommand('doctor', options),
       prepare: async (options) => await executeCommand('prepare', options),
@@ -408,6 +406,17 @@ function optionalSnapshotResponseFields(
   };
 }
 
+function buildProjectedSystemCommandClient(
+  executeCommand: <T>(command: DaemonCommandName, options?: InternalRequestOptions) => Promise<T>,
+): ProjectedSystemCommandClient {
+  const methods: Record<string, (options?: InternalRequestOptions) => Promise<unknown>> = {};
+  for (const [method, command] of Object.entries(systemCommandFamily.clientCommandMethods ?? {})) {
+    methods[method] = async (options = {}) =>
+      await executeCommand<CommandResult<typeof command>>(command as DaemonCommandName, options);
+  }
+  return methods as unknown as ProjectedSystemCommandClient;
+}
+
 function readObject(value: unknown): Record<string, unknown> | undefined {
   return isRecord(value) ? value : undefined;
 }
diff --git a/src/cloud-webdriver/capabilities.ts b/src/cloud-webdriver/capabilities.ts
index 9fa8b9930..356790876 100644
--- a/src/cloud-webdriver/capabilities.ts
+++ b/src/cloud-webdriver/capabilities.ts
@@ -20,6 +20,7 @@ export type CloudWebDriverOperation =
   | 'home'
   | 'rotate'
   | 'appSwitcher'
+  | 'tvRemote'
   | 'clipboard.read'
   | 'clipboard.write'
   | 'settings'
@@ -99,6 +100,7 @@ const BASE_WEBDRIVER_CAPABILITIES: CloudWebDriverCapabilityMap = {
     support: 'partial',
     note: 'Uses provider/Appium mobile pressButton support where available.',
   },
+  tvRemote: unsupported,
   'clipboard.read': {
     support: 'partial',
     note: 'Uses provider/Appium clipboard extension support where available.',
diff --git a/src/cloud-webdriver/webdriver-interactor.ts b/src/cloud-webdriver/webdriver-interactor.ts
index 5e9d87cd7..428fcd8d5 100644
--- a/src/cloud-webdriver/webdriver-interactor.ts
+++ b/src/cloud-webdriver/webdriver-interactor.ts
@@ -7,6 +7,7 @@ import type {
 import type { BackMode } from '../core/back-mode.ts';
 import type { DeviceRotation } from '../core/device-rotation.ts';
 import type { ScrollDirection, TransformGestureParams } from '../core/scroll-gesture.ts';
+import type { TvRemoteButton } from '../core/tv-remote.ts';
 import type { SettingOptions } from '../platforms/permission-utils.ts';
 import { AppError } from '../kernel/errors.ts';
 import { buildScrollGesturePlan } from '../core/scroll-gesture.ts';
@@ -253,6 +254,10 @@ class WebDriverInteractor implements Interactor {
     await this.client.executeScript('mobile: pressButton', [{ name: 'appSwitch' }]);
   }
 
+  async tvRemote(_button: TvRemoteButton, _durationMs?: number): Promise<void> {
+    this.unsupported('tvRemote');
+  }
+
   async readClipboard(): Promise<string> {
     this.requireSupport('clipboard.read');
     const value = await this.client.executeScript('mobile: getClipboard', [{}]);
diff --git a/src/command-catalog.ts b/src/command-catalog.ts
index 5d051c575..3baa637a1 100644
--- a/src/command-catalog.ts
+++ b/src/command-catalog.ts
@@ -48,6 +48,7 @@ export const PUBLIC_COMMANDS = {
   trace: 'trace',
   triggerAppEvent: 'trigger-app-event',
   type: 'type',
+  tvRemote: 'tv-remote',
   viewport: 'viewport',
   wait: 'wait',
 } as const;
diff --git a/src/commands/family/types.ts b/src/commands/family/types.ts
index 1ad2a758f..6bdc81fcb 100644
--- a/src/commands/family/types.ts
+++ b/src/commands/family/types.ts
@@ -18,6 +18,7 @@ export type CommandFamilyFacet<TCommandName extends string = string> = {
   clientSurface?: boolean;
   metadata: readonly AnyCommandMetadata<TCommandName>[];
   definitions: readonly AnyCommandDefinition<TCommandName>[];
+  clientCommandMethods?: Readonly<Record<string, TCommandName>>;
   cliSchemas?: Readonly<Partial<Record<TCommandName, CommandSchemaOverride>>>;
   cliReaders: Readonly<Record<TCommandName, CliReader>>;
   daemonWriters?: Readonly<Record<string, DaemonWriter>>;
@@ -29,6 +30,7 @@ export type CommandFacet<TCommandName extends string = string> = {
   metadata: AnyCommandMetadata<TCommandName>;
   definition: AnyCommandDefinition<TCommandName>;
   cliSchema?: CommandSchemaOverride;
+  clientMethod?: string;
   cliReader: CliReader;
   daemonWriter?: DaemonWriter;
   extraDaemonWriters?: Readonly<Record<string, DaemonWriter>>;
@@ -57,6 +59,7 @@ export function defineCommandFamilyFromFacets<
   const TCommands extends readonly CommandFacet[],
 >(family: { name: TFamilyName; clientSurface?: boolean; commands: TCommands }) {
   const cliSchemas: Record<string, CommandSchemaOverride> = {};
+  const clientCommandMethods: Record<string, string> = {};
   const cliReaders: Record<string, CliReader> = {};
   const daemonWriters: Record<string, DaemonWriter> = {};
   const cliOutputFormatters: Record<string, CliOutputFormatter> = {};
@@ -65,6 +68,14 @@ export function defineCommandFamilyFromFacets<
     if (command.cliSchema) {
       addRecordEntry(cliSchemas, 'CLI schema', command.name, command.cliSchema);
     }
+    if (command.clientMethod) {
+      addRecordEntry(
+        clientCommandMethods,
+        'client command method',
+        command.clientMethod,
+        command.name,
+      );
+    }
     addRecordEntry(cliReaders, 'CLI reader', command.name, command.cliReader);
     if (command.daemonWriter) {
       addRecordEntry(daemonWriters, 'daemon writer', command.name, command.daemonWriter);
@@ -91,6 +102,7 @@ export function defineCommandFamilyFromFacets<
     definitions: family.commands.map(
       (command) => command.definition,
     ) as CommandFacetDefinitions<TCommands>,
+    clientCommandMethods: clientCommandMethods as Record<string, CommandFacetName<TCommands>>,
     cliSchemas: cliSchemas as Partial<Record<CommandFacetName<TCommands>, CommandSchemaOverride>>,
     cliReaders: cliReaders as Record<CommandFacetName<TCommands>, CliReader>,
     daemonWriters,
diff --git a/src/commands/interaction/metadata.ts b/src/commands/interaction/metadata.ts
index 757184d4c..d62c78b44 100644
--- a/src/commands/interaction/metadata.ts
+++ b/src/commands/interaction/metadata.ts
@@ -169,7 +169,7 @@ const getFields = {
 
 const isFields = {
   predicate: requiredField(
-    enumField(['visible', 'hidden', 'exists', 'editable', 'selected', 'text'] as const),
+    enumField(['visible', 'hidden', 'exists', 'editable', 'selected', 'focused', 'text'] as const),
   ),
   selector: requiredField(stringField()),
   value: stringField(),
diff --git a/src/commands/interaction/runtime/selector-capture-policy.test.ts b/src/commands/interaction/runtime/selector-capture-policy.test.ts
new file mode 100644
index 000000000..af2459ed6
--- /dev/null
+++ b/src/commands/interaction/runtime/selector-capture-policy.test.ts
@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { parseSelectorChain } from '../../../utils/selectors-parse.ts';
+import { deriveSelectorCapturePolicy } from './selector-capture-policy.ts';
+
+test('selector capture policy reads full snapshots for focused predicates', () => {
+  assert.deepEqual(deriveSelectorCapturePolicy({ predicate: 'focused' }), {
+    includeRects: false,
+    interactiveOnly: false,
+  });
+});
+
+test('selector capture policy reads full snapshots for focus selectors', () => {
+  assert.deepEqual(
+    deriveSelectorCapturePolicy({ selectorChain: parseSelectorChain('focused=true') }),
+    {
+      includeRects: false,
+      interactiveOnly: false,
+    },
+  );
+});
+
+test('selector capture policy keeps rect reads separate from focus reads', () => {
+  assert.deepEqual(deriveSelectorCapturePolicy({ predicate: 'visible' }), {
+    includeRects: true,
+    interactiveOnly: false,
+  });
+});
+
+test('selector capture policy leaves ordinary selectors non-interactive', () => {
+  assert.deepEqual(
+    deriveSelectorCapturePolicy({ selectorChain: parseSelectorChain('label="Continue"') }),
+    {
+      includeRects: false,
+      interactiveOnly: false,
+    },
+  );
+});
diff --git a/src/commands/interaction/runtime/selector-capture-policy.ts b/src/commands/interaction/runtime/selector-capture-policy.ts
new file mode 100644
index 000000000..8b9d4bd0e
--- /dev/null
+++ b/src/commands/interaction/runtime/selector-capture-policy.ts
@@ -0,0 +1,26 @@
+import type { IsPredicate } from '../../../utils/selector-is-predicates.ts';
+import type { SelectorChain } from '../../../utils/selectors-parse.ts';
+
+export type SelectorCapturePolicyInput = {
+  predicate?: IsPredicate;
+  selectorChain?: SelectorChain | null;
+};
+
+export type SelectorCapturePolicy = {
+  includeRects: boolean;
+  interactiveOnly: boolean;
+};
+
+export function deriveSelectorCapturePolicy(
+  input: SelectorCapturePolicyInput,
+): SelectorCapturePolicy {
+  const includeRects = predicateNeedsRects(input.predicate);
+  return {
+    includeRects,
+    interactiveOnly: false,
+  };
+}
+
+function predicateNeedsRects(predicate: IsPredicate | undefined): boolean {
+  return predicate === 'visible' || predicate === 'hidden';
+}
diff --git a/src/commands/interaction/runtime/selector-read.test.ts b/src/commands/interaction/runtime/selector-read.test.ts
index 6142ffd4d..d5a530ce9 100644
--- a/src/commands/interaction/runtime/selector-read.test.ts
+++ b/src/commands/interaction/runtime/selector-read.test.ts
@@ -168,6 +168,114 @@ test('runtime visibility predicates request snapshot rects', async () => {
   assert.equal(captureOptions?.includeRects, true);
 });
 
+test('runtime focused predicate requests a full snapshot', async () => {
+  const snapshot = makeSnapshotState([
+    {
+      index: 0,
+      depth: 0,
+      type: 'Cell',
+      label: 'Profiles and Accounts',
+      focused: true,
+    },
+  ]);
+  let captureOptions: BackendSnapshotOptions | undefined;
+  const device = createAgentDevice({
+    backend: {
+      platform: 'ios',
+      captureSnapshot: async (_context, options) => {
+        captureOptions = options;
+        return { snapshot };
+      },
+    } satisfies AgentDeviceBackend,
+    artifacts: createLocalArtifactAdapter(),
+    sessions: createMemorySessionStore([{ name: 'default', snapshot }]),
+    policy: localCommandPolicy(),
+  });
+
+  const result = await device.selectors.is({
+    session: 'default',
+    predicate: 'focused',
+    selector: 'role=cell label="Profiles and Accounts"',
+  });
+
+  assert.equal(result.pass, true);
+  assert.equal(captureOptions?.interactiveOnly, false);
+});
+
+test('runtime focused predicate reads focused Android TV nodes from the full tree', async () => {
+  const fullSnapshot = makeSnapshotState(
+    [
+      {
+        index: 0,
+        depth: 0,
+        type: 'TextView',
+        label: 'Featured',
+        focused: true,
+        hittable: false,
+      },
+    ],
+    { backend: 'android' },
+  );
+  const interactiveSnapshot = makeSnapshotState([], { backend: 'android' });
+  let captureOptions: BackendSnapshotOptions | undefined;
+  const device = createAgentDevice({
+    backend: {
+      platform: 'android',
+      captureSnapshot: async (_context, options) => {
+        captureOptions = options;
+        return { snapshot: options?.interactiveOnly ? interactiveSnapshot : fullSnapshot };
+      },
+    } satisfies AgentDeviceBackend,
+    artifacts: createLocalArtifactAdapter(),
+    sessions: createMemorySessionStore([{ name: 'default', snapshot: interactiveSnapshot }]),
+    policy: localCommandPolicy(),
+  });
+
+  const result = await device.selectors.is({
+    session: 'default',
+    predicate: 'focused',
+    selector: 'label=Featured',
+  });
+
+  assert.equal(result.pass, true);
+  assert.equal(captureOptions?.interactiveOnly, false);
+});
+
+test('runtime focused selector waits against a full snapshot', async () => {
+  const snapshot = makeSnapshotState([
+    {
+      index: 0,
+      depth: 0,
+      type: 'Cell',
+      label: 'Profiles and Accounts',
+      focused: true,
+    },
+  ]);
+  let captureOptions: BackendSnapshotOptions | undefined;
+  const device = createAgentDevice({
+    backend: {
+      platform: 'ios',
+      captureSnapshot: async (_context, options) => {
+        captureOptions = options;
+        return { snapshot };
+      },
+    } satisfies AgentDeviceBackend,
+    artifacts: createLocalArtifactAdapter(),
+    sessions: createMemorySessionStore([{ name: 'default', snapshot }]),
+    policy: localCommandPolicy(),
+  });
+
+  const result = await device.selectors.wait({
+    session: 'default',
+    target: { kind: 'selector', selector: 'focused=true', timeoutMs: 1000 },
+  });
+
+  assert.equal(result.kind, 'selector');
+  assert.equal(result.selector, 'focused=true');
+  assert.equal(result.waitedMs >= 0, true);
+  assert.equal(captureOptions?.interactiveOnly, false);
+});
+
 test('runtime is validates selector predicates', async () => {
   const device = createSelectorDevice(selectorReadSnapshot());
 
diff --git a/src/commands/interaction/runtime/selector-read.ts b/src/commands/interaction/runtime/selector-read.ts
index 88dc204ac..814f30970 100644
--- a/src/commands/interaction/runtime/selector-read.ts
+++ b/src/commands/interaction/runtime/selector-read.ts
@@ -24,7 +24,6 @@ import {
   evaluateIsPredicate,
   isSupportedPredicate,
   IS_PREDICATE_REQUIRED_MESSAGE,
-  type IsPredicate,
 } from '../../../utils/selector-is-predicates.ts';
 import type {
   ElementTarget,
@@ -49,6 +48,7 @@ import {
   TINY_STABLE_TREE_NODE_COUNT,
 } from './stable-capture.ts';
 import { now, sleep, toBackendContext } from '../../runtime-common.ts';
+import { deriveSelectorCapturePolicy } from './selector-capture-policy.ts';
 
 export type { SelectorSnapshotOptions } from './selector-read-shared.ts';
 export type { ElementTarget, RefTarget, ResolvedTarget, SelectorTarget };
@@ -98,7 +98,7 @@ export type GetAttrsCommandOptions = CommandContext &
 
 export type IsCommandOptions = CommandContext &
   SelectorSnapshotOptions & {
-    predicate: 'visible' | 'hidden' | 'exists' | 'editable' | 'selected' | 'text';
+    predicate: 'visible' | 'hidden' | 'exists' | 'editable' | 'selected' | 'focused' | 'text';
     selector: string;
     expectedText?: string;
   };
@@ -274,12 +274,11 @@ export const isCommand: RuntimeCommand<IsCommandOptions, IsCommandResult> = asyn
   if (options.predicate === 'text' && !options.expectedText) {
     throw new AppError('INVALID_ARGS', 'is text requires expected text value');
   }
-  const includeRects = predicateNeedsRects(options.predicate);
+  const chain = parseSelectorChain(options.selector);
   const capture = await captureSelectorSnapshot(runtime, options, {
     updateSession: true,
-    includeRects,
+    ...deriveSelectorCapturePolicy({ predicate: options.predicate, selectorChain: chain }),
   });
-  const chain = parseSelectorChain(options.selector);
 
   if (options.predicate === 'exists') {
     const matched = findSelectorChainMatch(capture.snapshot.nodes, chain, {
@@ -435,6 +434,7 @@ async function findFirstLocatorMatch(
   const capture = await captureSelectorSnapshot(runtime, options, {
     updateSession: true,
     scope: findSnapshotScope(runtime, locator, options.query, selectorChain),
+    ...deriveSelectorCapturePolicy({ selectorChain }),
   });
   if (isSparseSnapshotQualityVerdict(capture.snapshot.snapshotQuality)) {
     throw sparseSelectorSnapshotError(capture.snapshot.snapshotQuality);
@@ -471,10 +471,6 @@ function sparseSelectorSnapshotError(verdict: SnapshotQualityVerdict): AppError
   });
 }
 
-function predicateNeedsRects(predicate: IsPredicate): boolean {
-  return predicate === 'visible' || predicate === 'hidden';
-}
-
 async function waitForSelector(
   runtime: AgentDeviceRuntime,
   options: WaitCommandOptions,
@@ -484,8 +480,12 @@ async function waitForSelector(
   const timeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const start = now(runtime);
   const chain = parseSelectorChain(selectorExpression);
+  const capturePolicy = deriveSelectorCapturePolicy({ selectorChain: chain });
   while (now(runtime) - start < timeout) {
-    const capture = await captureSelectorSnapshot(runtime, options, { updateSession: true });
+    const capture = await captureSelectorSnapshot(runtime, options, {
+      updateSession: true,
+      ...capturePolicy,
+    });
     const match = findSelectorChainMatch(capture.snapshot.nodes, chain, {
       platform: runtime.backend.platform,
     });
@@ -568,14 +568,15 @@ async function resolveSelectorNode(
   sessionName: string,
   params: { selector: string; disambiguateAmbiguous: boolean },
 ): Promise<{ capture: CapturedSnapshot; node: SnapshotNode; selector: string; ref: string }> {
+  const chain = parseSelectorChain(params.selector);
   const capture = await captureSelectorSnapshot(
     runtime,
     { ...options, session: sessionName },
     {
       updateSession: true,
+      ...deriveSelectorCapturePolicy({ selectorChain: chain }),
     },
   );
-  const chain = parseSelectorChain(params.selector);
   const resolved = resolveSelectorChain(capture.snapshot.nodes, chain, {
     platform: runtime.backend.platform,
     requireRect: false,
diff --git a/src/commands/interaction/selectors.ts b/src/commands/interaction/selectors.ts
index 0b8555cd6..761190079 100644
--- a/src/commands/interaction/selectors.ts
+++ b/src/commands/interaction/selectors.ts
@@ -120,7 +120,8 @@ function readIsOptionsFromPositionals(positionals: string[], flags: CliFlags): I
     predicate !== 'hidden' &&
     predicate !== 'exists' &&
     predicate !== 'editable' &&
-    predicate !== 'selected'
+    predicate !== 'selected' &&
+    predicate !== 'focused'
   ) {
     throw new AppError('INVALID_ARGS', IS_PREDICATE_REQUIRED_MESSAGE, {
       hint: IS_PREDICATE_USAGE_HINT,
diff --git a/src/commands/system/index.test.ts b/src/commands/system/index.test.ts
index 4164363b9..8479db9e5 100644
--- a/src/commands/system/index.test.ts
+++ b/src/commands/system/index.test.ts
@@ -15,6 +15,9 @@ import {
   keyboardDaemonWriter,
   rotateCliReader,
   rotateDaemonWriter,
+  tvRemoteCliReader,
+  tvRemoteDaemonWriter,
+  systemCommandFamily,
 } from './index.ts';
 
 function flags(overrides: Partial<CliFlags> = {}): CliFlags {
@@ -31,6 +34,19 @@ function expectInvalidArgs(fn: () => unknown, messageFragment: string) {
 }
 
 describe('system command interface', () => {
+  test('system command family projects Node client command methods', () => {
+    expect(systemCommandFamily.clientCommandMethods).toEqual({
+      appState: 'appstate',
+      back: 'back',
+      home: 'home',
+      rotate: 'rotate',
+      appSwitcher: 'app-switcher',
+      keyboard: 'keyboard',
+      clipboard: 'clipboard',
+      tvRemote: 'tv-remote',
+    });
+  });
+
   test('parameterless readers project common selection flags through', () => {
     for (const reader of [appStateCliReader, homeCliReader, appSwitcherCliReader]) {
       expect(reader([], flags({ platform: 'ios' }))).toEqual({
@@ -117,4 +133,47 @@ describe('system command interface', () => {
       'copied',
     ]);
   });
+
+  test('tv-remote reader parses button and optional press subcommand', () => {
+    expect(tvRemoteCliReader(['down'], flags({ durationMs: 250 }))).toMatchObject({
+      button: 'down',
+      durationMs: 250,
+    });
+    expect(tvRemoteCliReader(['press', 'select'], flags())).toMatchObject({
+      button: 'select',
+    });
+    expect(tvRemoteCliReader(['ok'], flags())).toMatchObject({ button: 'select' });
+    expect(tvRemoteCliReader(['center'], flags())).toMatchObject({ button: 'select' });
+    expect(tvRemoteCliReader(['enter'], flags())).toMatchObject({ button: 'select' });
+  });
+
+  test('tv-remote reader maps longpress subcommand to duration preset', () => {
+    expect(tvRemoteCliReader(['longpress', 'select'], flags())).toMatchObject({
+      button: 'select',
+      durationMs: 500,
+    });
+    expect(tvRemoteCliReader(['longpress', 'back'], flags({ durationMs: 900 }))).toMatchObject({
+      button: 'back',
+      durationMs: 900,
+    });
+  });
+
+  test('tv-remote reader and writer validate button arguments', () => {
+    expect(
+      tvRemoteDaemonWriter({ button: 'right' } as Record<string, unknown>).positionals,
+    ).toEqual(['right']);
+    expectInvalidArgs(
+      () => tvRemoteCliReader([], flags()),
+      'tv-remote requires exactly one button',
+    );
+    expectInvalidArgs(
+      () => tvRemoteCliReader(['press', 'left', 'extra'], flags()),
+      'tv-remote requires exactly one button',
+    );
+    expectInvalidArgs(
+      () => tvRemoteCliReader(['longpress', 'left', 'extra'], flags()),
+      'tv-remote requires exactly one button',
+    );
+    expectInvalidArgs(() => tvRemoteCliReader(['blue'], flags()), 'button must be one of');
+  });
 });
diff --git a/src/commands/system/index.ts b/src/commands/system/index.ts
index c921b9607..f400ba87b 100644
--- a/src/commands/system/index.ts
+++ b/src/commands/system/index.ts
@@ -2,11 +2,23 @@ import type { ClipboardCommandOptions } from '../../client/client-types.ts';
 import type { BackMode } from '../../core/back-mode.ts';
 import { BACK_MODES } from '../../core/back-mode.ts';
 import { parseDeviceRotation, DEVICE_ROTATIONS } from '../../core/device-rotation.ts';
+import {
+  parseTvRemoteButton,
+  TV_REMOTE_BUTTON_USAGE,
+  TV_REMOTE_BUTTONS,
+  tvRemoteDurationMode,
+} from '../../core/tv-remote.ts';
 import { AppError } from '../../kernel/errors.ts';
 import type { CommandSchemaOverride } from '../../utils/cli-command-schema-types.ts';
 import { defineCommandFacet, defineCommandFamilyFromFacets } from '../family/types.ts';
 import { defineExecutableCommand } from '../command-contract.ts';
-import { compactRecord, enumField, requiredField, stringField } from '../command-input.ts';
+import {
+  compactRecord,
+  enumField,
+  integerField,
+  requiredField,
+  stringField,
+} from '../command-input.ts';
 import { defineFieldCommandMetadata } from '../field-command-contract.ts';
 import {
   commonInputFromFlags,
@@ -25,6 +37,8 @@ const ROTATE_COMMAND_NAME = 'rotate';
 const APP_SWITCHER_COMMAND_NAME = 'app-switcher';
 const KEYBOARD_COMMAND_NAME = 'keyboard';
 const CLIPBOARD_COMMAND_NAME = 'clipboard';
+const TV_REMOTE_COMMAND_NAME = 'tv-remote';
+const TV_REMOTE_LONGPRESS_PRESET_MS = 500;
 
 const CLIPBOARD_ACTION_VALUES = ['read', 'write'] as const;
 const KEYBOARD_METADATA_ACTION_VALUES = ['status', 'dismiss'] as const;
@@ -36,6 +50,7 @@ const rotateCommandDescription = 'Rotate device orientation.';
 const appSwitcherCommandDescription = 'Open the app switcher.';
 const keyboardCommandDescription = 'Inspect or dismiss the keyboard.';
 const clipboardCommandDescription = 'Read or write clipboard text.';
+const tvRemoteCommandDescription = 'Press a TV remote/D-pad button.';
 
 const appStateCommandMetadata = defineFieldCommandMetadata(
   APPSTATE_COMMAND_NAME,
@@ -84,6 +99,20 @@ const clipboardCommandMetadata = defineFieldCommandMetadata(
   },
 );
 
+const tvRemoteCommandMetadata = defineFieldCommandMetadata(
+  TV_REMOTE_COMMAND_NAME,
+  tvRemoteCommandDescription,
+  {
+    button: requiredField(enumField(TV_REMOTE_BUTTONS)),
+    durationMs: integerField(
+      `Press duration in milliseconds. tvOS uses the exact hold duration; Android TV maps any positive value to an ADB longpress (${tvRemoteDurationMode('android')}).`,
+      {
+        min: 0,
+      },
+    ),
+  },
+);
+
 const appStateCommandDefinition = defineExecutableCommand(
   appStateCommandMetadata,
   (client, input) => client.command.appState(input),
@@ -116,6 +145,11 @@ const clipboardCommandDefinition = defineExecutableCommand(
   (client, input) => client.command.clipboard(input as ClipboardCommandOptions),
 );
 
+const tvRemoteCommandDefinition = defineExecutableCommand(
+  tvRemoteCommandMetadata,
+  (client, input) => client.command.tvRemote(input),
+);
+
 const appStateCliSchema = {
   helpDescription: 'Show foreground app/activity',
 } as const satisfies CommandSchemaOverride;
@@ -147,6 +181,16 @@ const clipboardCliSchema = {
   allowsExtraPositionals: true,
 } as const satisfies CommandSchemaOverride;
 
+const tvRemoteCliSchema = {
+  usageOverride: `tv-remote [press|longpress] ${TV_REMOTE_BUTTON_USAGE} [--duration-ms <ms>]`,
+  listUsageOverride: 'tv-remote press|longpress <button> [--duration-ms <ms>]',
+  helpDescription:
+    'Press a TV remote/D-pad button on Android TV or tvOS. Use longpress for a 500ms held remote button; --duration-ms overrides the preset. Aliases ok, center, and enter map to select.',
+  summary: 'Press a TV remote/D-pad button',
+  positionalArgs: ['press|longpress?', 'button'],
+  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);
@@ -171,6 +215,11 @@ export const clipboardCliReader: CliReader = (positionals, flags) => ({
   ...readClipboardInput(positionals),
 });
 
+export const tvRemoteCliReader: CliReader = (positionals, flags) => ({
+  ...commonInputFromFlags(flags),
+  ...readTvRemoteInput(positionals, flags.durationMs),
+});
+
 export const appStateDaemonWriter: DaemonWriter = direct(APPSTATE_COMMAND_NAME);
 
 export const backDaemonWriter: DaemonWriter = (input) =>
@@ -192,10 +241,15 @@ export const clipboardDaemonWriter: DaemonWriter = direct(CLIPBOARD_COMMAND_NAME
   clipboardPositionals(input as ClipboardCommandOptions),
 );
 
+export const tvRemoteDaemonWriter: DaemonWriter = direct(TV_REMOTE_COMMAND_NAME, (input) => [
+  requiredDaemonString(input.button, 'tv-remote requires button'),
+]);
+
 const appStateCommandFacet = defineCommandFacet({
   name: APPSTATE_COMMAND_NAME,
   metadata: appStateCommandMetadata,
   definition: appStateCommandDefinition,
+  clientMethod: 'appState',
   cliSchema: appStateCliSchema,
   cliReader: appStateCliReader,
   daemonWriter: appStateDaemonWriter,
@@ -206,6 +260,7 @@ const backCommandFacet = defineCommandFacet({
   name: BACK_COMMAND_NAME,
   metadata: backCommandMetadata,
   definition: backCommandDefinition,
+  clientMethod: 'back',
   cliSchema: backCliSchema,
   cliReader: backCliReader,
   daemonWriter: backDaemonWriter,
@@ -216,6 +271,7 @@ const homeCommandFacet = defineCommandFacet({
   name: HOME_COMMAND_NAME,
   metadata: homeCommandMetadata,
   definition: homeCommandDefinition,
+  clientMethod: 'home',
   cliReader: homeCliReader,
   daemonWriter: homeDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters.home,
@@ -225,6 +281,7 @@ const rotateCommandFacet = defineCommandFacet({
   name: ROTATE_COMMAND_NAME,
   metadata: rotateCommandMetadata,
   definition: rotateCommandDefinition,
+  clientMethod: 'rotate',
   cliSchema: rotateCliSchema,
   cliReader: rotateCliReader,
   daemonWriter: rotateDaemonWriter,
@@ -235,6 +292,7 @@ const appSwitcherCommandFacet = defineCommandFacet({
   name: APP_SWITCHER_COMMAND_NAME,
   metadata: appSwitcherCommandMetadata,
   definition: appSwitcherCommandDefinition,
+  clientMethod: 'appSwitcher',
   cliReader: appSwitcherCliReader,
   daemonWriter: appSwitcherDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters['app-switcher'],
@@ -244,6 +302,7 @@ const keyboardCommandFacet = defineCommandFacet({
   name: KEYBOARD_COMMAND_NAME,
   metadata: keyboardCommandMetadata,
   definition: keyboardCommandDefinition,
+  clientMethod: 'keyboard',
   cliSchema: keyboardCliSchema,
   cliReader: keyboardCliReader,
   daemonWriter: keyboardDaemonWriter,
@@ -254,12 +313,24 @@ const clipboardCommandFacet = defineCommandFacet({
   name: CLIPBOARD_COMMAND_NAME,
   metadata: clipboardCommandMetadata,
   definition: clipboardCommandDefinition,
+  clientMethod: 'clipboard',
   cliSchema: clipboardCliSchema,
   cliReader: clipboardCliReader,
   daemonWriter: clipboardDaemonWriter,
   cliOutputFormatter: systemCliOutputFormatters.clipboard,
 });
 
+const tvRemoteCommandFacet = defineCommandFacet({
+  name: TV_REMOTE_COMMAND_NAME,
+  metadata: tvRemoteCommandMetadata,
+  definition: tvRemoteCommandDefinition,
+  clientMethod: 'tvRemote',
+  cliSchema: tvRemoteCliSchema,
+  cliReader: tvRemoteCliReader,
+  daemonWriter: tvRemoteDaemonWriter,
+  cliOutputFormatter: systemCliOutputFormatters['tv-remote'],
+});
+
 export const systemCommandFamily = defineCommandFamilyFromFacets({
   name: 'system',
   commands: [
@@ -270,6 +341,7 @@ export const systemCommandFamily = defineCommandFamilyFromFacets({
     appSwitcherCommandFacet,
     keyboardCommandFacet,
     clipboardCommandFacet,
+    tvRemoteCommandFacet,
   ],
 });
 
@@ -305,6 +377,27 @@ function readClipboardInput(positionals: string[]): Record<string, unknown> {
   return { action, text: positionals.slice(1).join(' ') };
 }
 
+function readTvRemoteInput(
+  positionals: string[],
+  durationMs: number | undefined,
+): Record<string, unknown> {
+  const subcommand = positionals[0]?.toLowerCase();
+  const isNamedAction = subcommand === 'press' || subcommand === 'longpress';
+  const args = isNamedAction ? positionals.slice(1) : positionals;
+  if (args.length !== 1) {
+    throw new AppError(
+      'INVALID_ARGS',
+      `tv-remote requires exactly one button: ${TV_REMOTE_BUTTONS.join(', ')}.`,
+    );
+  }
+  const effectiveDurationMs =
+    durationMs ?? (subcommand === 'longpress' ? TV_REMOTE_LONGPRESS_PRESET_MS : undefined);
+  return compactRecord({
+    button: parseTvRemoteButton(args[0]),
+    durationMs: effectiveDurationMs,
+  });
+}
+
 function readKeyboardAction(
   value: string | undefined,
 ): 'status' | 'dismiss' | 'enter' | 'return' | undefined {
diff --git a/src/commands/system/output.ts b/src/commands/system/output.ts
index f4190f01d..c4063bbc2 100644
--- a/src/commands/system/output.ts
+++ b/src/commands/system/output.ts
@@ -48,6 +48,7 @@ export const systemCliOutputFormatters = {
   'app-switcher': messageOutput,
   keyboard: resultOutput(keyboardCliOutput),
   clipboard: resultOutput(clipboardCliOutput),
+  'tv-remote': messageOutput,
 } as const satisfies Record<string, CliOutputFormatter>;
 
 function formatAppState(data: AppStateCommandResult): string | null {
diff --git a/src/commands/system/runtime/index.ts b/src/commands/system/runtime/index.ts
index f9494b50c..4eb3b3ed1 100644
--- a/src/commands/system/runtime/index.ts
+++ b/src/commands/system/runtime/index.ts
@@ -9,6 +9,7 @@ import {
   keyboardCommand,
   rotateCommand,
   settingsCommand,
+  tvRemoteCommand,
   type SystemAlertCommandOptions,
   type SystemAlertCommandResult,
   type SystemAppSwitcherCommandOptions,
@@ -25,6 +26,8 @@ import {
   type SystemRotateCommandResult,
   type SystemSettingsCommandOptions,
   type SystemSettingsCommandResult,
+  type SystemTvRemoteCommandOptions,
+  type SystemTvRemoteCommandResult,
 } from './system.ts';
 
 export type SystemCommands = {
@@ -39,6 +42,7 @@ export type SystemCommands = {
     SystemAppSwitcherCommandOptions | undefined,
     SystemAppSwitcherCommandResult
   >;
+  tvRemote: RuntimeCommand<SystemTvRemoteCommandOptions, SystemTvRemoteCommandResult>;
 };
 
 export type BoundSystemCommands = {
@@ -52,6 +56,7 @@ export type BoundSystemCommands = {
   appSwitcher: (
     options?: SystemAppSwitcherCommandOptions,
   ) => Promise<SystemAppSwitcherCommandResult>;
+  tvRemote: BoundRuntimeCommand<SystemTvRemoteCommandOptions, SystemTvRemoteCommandResult>;
 };
 
 export const systemCommands: SystemCommands = {
@@ -63,6 +68,7 @@ export const systemCommands: SystemCommands = {
   settings: settingsCommand,
   alert: alertCommand,
   appSwitcher: appSwitcherCommand,
+  tvRemote: tvRemoteCommand,
 };
 
 export function bindSystemCommands(runtime: AgentDeviceRuntime): BoundSystemCommands {
@@ -75,5 +81,6 @@ export function bindSystemCommands(runtime: AgentDeviceRuntime): BoundSystemComm
     settings: (options) => systemCommands.settings(runtime, options),
     alert: (options) => systemCommands.alert(runtime, options),
     appSwitcher: (options) => systemCommands.appSwitcher(runtime, options),
+    tvRemote: (options) => systemCommands.tvRemote(runtime, options),
   };
 }
diff --git a/src/commands/system/runtime/system.test.ts b/src/commands/system/runtime/system.test.ts
index 7fd4227bb..82c220e8f 100644
--- a/src/commands/system/runtime/system.test.ts
+++ b/src/commands/system/runtime/system.test.ts
@@ -5,6 +5,7 @@ import type {
   BackendAlertAction,
   BackendDeviceOrientation,
   BackendKeyboardOptions,
+  BackendTvRemoteOptions,
 } from '../../../backend.ts';
 import { createLocalArtifactAdapter } from '../../../io.ts';
 import { createAgentDevice, localCommandPolicy } from '../../../runtime.ts';
@@ -26,6 +27,7 @@ test('runtime system commands call typed backend primitives', async () => {
   const settings = await device.system.settings({ target: 'privacy' });
   const alert = await device.system.alert({ action: 'accept', timeoutMs: 500 });
   const appSwitcher = await device.system.appSwitcher();
+  const tvRemote = await device.system.tvRemote({ button: 'select', durationMs: 300 });
 
   assert.equal(back.kind, 'systemBack');
   assert.equal(home.kind, 'systemHome');
@@ -37,6 +39,8 @@ test('runtime system commands call typed backend primitives', async () => {
   assert.equal(settings.target, 'privacy');
   assert.equal(alert.kind, 'alertHandled');
   assert.equal(appSwitcher.kind, 'appSwitcherOpened');
+  assert.equal(tvRemote.kind, 'tvRemotePressed');
+  assert.equal(tvRemote.button, 'select');
   assert.deepEqual(calls, [
     { command: 'pressBack', mode: 'system', session: 'default' },
     { command: 'pressHome', session: 'default' },
@@ -47,6 +51,7 @@ test('runtime system commands call typed backend primitives', async () => {
     { command: 'openSettings', target: 'privacy' },
     { command: 'handleAlert', action: 'accept', timeoutMs: 500 },
     { command: 'openAppSwitcher' },
+    { command: 'pressTvRemote', options: { button: 'select', durationMs: 300 } },
   ]);
 });
 
@@ -74,6 +79,10 @@ test('runtime system commands validate options before backend calls', async () =
     () => device.system.alert({ action: 'tap' as BackendAlertAction }),
     /action must be/,
   );
+  await assert.rejects(
+    () => device.system.tvRemote({ button: 'blue' as BackendTvRemoteOptions['button'] }),
+    /button must be/,
+  );
 
   assert.deepEqual(calls, []);
 });
@@ -112,5 +121,8 @@ function createSystemBackend(calls: unknown[]): AgentDeviceBackend {
     openAppSwitcher: async () => {
       calls.push({ command: 'openAppSwitcher' });
     },
+    pressTvRemote: async (_context, options) => {
+      calls.push({ command: 'pressTvRemote', options });
+    },
   };
 }
diff --git a/src/commands/system/runtime/system.ts b/src/commands/system/runtime/system.ts
index aa8d9099a..38f9538d6 100644
--- a/src/commands/system/runtime/system.ts
+++ b/src/commands/system/runtime/system.ts
@@ -4,9 +4,11 @@ import type {
   BackendAlertResult,
   BackendDeviceOrientation,
   BackendKeyboardResult,
+  BackendTvRemoteOptions,
 } from '../../../backend.ts';
 import type { CommandContext } from '../../../runtime-contract.ts';
 import type { BackMode } from '../../../core/back-mode.ts';
+import { parseTvRemoteButton } from '../../../core/tv-remote.ts';
 import { AppError } from '../../../kernel/errors.ts';
 import { successText } from '../../../utils/success-text.ts';
 import { requireIntInRange } from '../../../utils/validation.ts';
@@ -127,6 +129,14 @@ export type SystemAppSwitcherCommandResult = {
   kind: 'appSwitcherOpened';
 } & BackendResultEnvelope;
 
+export type SystemTvRemoteCommandOptions = CommandContext & BackendTvRemoteOptions;
+
+export type SystemTvRemoteCommandResult = {
+  kind: 'tvRemotePressed';
+  button: BackendTvRemoteOptions['button'];
+  durationMs?: number;
+} & BackendResultEnvelope;
+
 export const backCommand: RuntimeCommand<
   SystemBackCommandOptions | undefined,
   SystemBackCommandResult
@@ -166,6 +176,32 @@ export const homeCommand: RuntimeCommand<
   };
 };
 
+export const tvRemoteCommand: RuntimeCommand<
+  SystemTvRemoteCommandOptions,
+  SystemTvRemoteCommandResult
+> = async (runtime, options): Promise<SystemTvRemoteCommandResult> => {
+  if (!runtime.backend.pressTvRemote) {
+    throw new AppError('UNSUPPORTED_OPERATION', 'system.tvRemote is not supported by this backend');
+  }
+  const button = parseTvRemoteButton(options.button);
+  const durationMs =
+    options.durationMs === undefined
+      ? undefined
+      : requireIntInRange(options.durationMs, 'durationMs', 0, 10_000);
+  const backendResult = await runtime.backend.pressTvRemote(toBackendContext(runtime, options), {
+    button,
+    ...(durationMs !== undefined ? { durationMs } : {}),
+  });
+  const formattedBackendResult = toBackendResult(backendResult);
+  return {
+    kind: 'tvRemotePressed',
+    button,
+    ...(durationMs !== undefined ? { durationMs } : {}),
+    ...(formattedBackendResult ? { backendResult: formattedBackendResult } : {}),
+    ...successText(`Pressed TV remote ${button}`),
+  };
+};
+
 export const rotateCommand: RuntimeCommand<
   SystemRotateCommandOptions,
   SystemRotateCommandResult
diff --git a/src/contracts/navigation.ts b/src/contracts/navigation.ts
index 1be7f7e5b..c63b6d12c 100644
--- a/src/contracts/navigation.ts
+++ b/src/contracts/navigation.ts
@@ -1,5 +1,6 @@
 import type { BackMode } from '../core/back-mode.ts';
 import type { DeviceRotation } from '../core/device-rotation.ts';
+import type { TvRemoteButton } from '../core/tv-remote.ts';
 
 /**
  * Closed results of the navigation/global action commands. Each mirrors the
@@ -36,3 +37,11 @@ export type AppSwitcherCommandResult = {
   action: 'app-switcher';
   message: string;
 };
+
+/** `tv-remote` — `{ action: 'tv-remote', button, durationMs?, message }`. */
+export type TvRemoteCommandResult = {
+  action: 'tv-remote';
+  button: TvRemoteButton;
+  durationMs?: number;
+  message: string;
+};
diff --git a/src/core/__tests__/capabilities.test.ts b/src/core/__tests__/capabilities.test.ts
index 39e8025e2..fafa78ef1 100644
--- a/src/core/__tests__/capabilities.test.ts
+++ b/src/core/__tests__/capabilities.test.ts
@@ -32,6 +32,14 @@ const androidEmulator: DeviceInfo = {
   kind: 'emulator',
 };
 
+const androidTvEmulator: DeviceInfo = {
+  platform: 'android',
+  id: 'emulator-5556',
+  name: 'Android TV',
+  kind: 'emulator',
+  target: 'tv',
+};
+
 const macOsDevice: DeviceInfo = {
   platform: 'apple',
   appleOs: 'macos',
@@ -124,6 +132,16 @@ test('device capability matrix stays consistent across shared command groups', (
         { device: androidDevice, expected: true, label: 'on Android' },
       ],
     },
+    {
+      commands: ['tv-remote'],
+      checks: [
+        { device: iosSimulator, expected: false, label: 'on iOS sim' },
+        { device: androidDevice, expected: false, label: 'on Android phone' },
+        { device: androidTvEmulator, expected: true, label: 'on Android TV' },
+        { device: macOsDevice, expected: false, label: 'on macOS' },
+        { device: tvOsSimulator, expected: true, label: 'on tvOS simulator' },
+      ],
+    },
     {
       commands: ['shutdown'],
       checks: [
@@ -312,6 +330,7 @@ test('tvOS follows iOS capability matrix by device kind', () => {
       'back',
       'home',
       'app-switcher',
+      'tv-remote',
       'record',
     ],
     [{ device: tvOsSimulator, expected: true, label: 'on tvOS' }],
diff --git a/src/core/__tests__/capability-plugin-routing-parity.test.ts b/src/core/__tests__/capability-plugin-routing-parity.test.ts
index ddc2ece0a..f8b3c7357 100644
--- a/src/core/__tests__/capability-plugin-routing-parity.test.ts
+++ b/src/core/__tests__/capability-plugin-routing-parity.test.ts
@@ -112,6 +112,9 @@ const supportsSynthesisGesture = (device: DeviceInfo): boolean =>
   device.platform === 'android' || isIosMobileSimulator(device);
 const supportsAndroidOrIosNonTv = (device: DeviceInfo): boolean =>
   device.platform === 'android' || (isIosFamily(device) && device.target !== 'tv');
+const supportsTvRemote = (device: DeviceInfo): boolean =>
+  (device.platform === 'android' && device.target === 'tv') ||
+  (isIosFamily(device) && device.target === 'tv');
 const supportsHostAudioProbe = (device: DeviceInfo): boolean =>
   device.platform === 'web' ||
   (process.platform === 'darwin' &&
@@ -146,6 +149,7 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
     device.kind === 'simulator',
   keyboard: supportsAndroidOrIosNonTv,
   rotate: supportsAndroidOrIosNonTv,
+  'tv-remote': supportsTvRemote,
   alert: (device) => device.platform === 'android' || isMacOsOrAppleSimulator(device),
   settings: (device) =>
     device.platform === 'android' || isMacOs(device) || device.kind === 'simulator',
@@ -155,6 +159,17 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
   'transform-gesture': supportsSynthesisGesture,
 };
 const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
+  'tv-remote': (device) => {
+    if (device.platform === 'android') {
+      return device.target === 'tv'
+        ? undefined
+        : 'tv-remote is supported only on Android TV targets.';
+    }
+    if (isIosFamily(device)) {
+      return device.target === 'tv' ? undefined : 'tv-remote is supported only on tvOS devices.';
+    }
+    return isMacOs(device) ? 'tv-remote is supported only on tvOS devices.' : undefined;
+  },
   pinch: synthesisGestureUnsupportedHint,
   'rotate-gesture': synthesisGestureUnsupportedHint,
   'transform-gesture': synthesisGestureUnsupportedHint,
@@ -277,8 +292,13 @@ test('(b.2) non-Apple families only carry their own non-portable support gates',
   // Most relocated closures are Apple-only. Audio is the one host-dependent command
   // that also gates Android emulator support on macOS hosts, so Android carries only
   // that command-specific predicate.
-  assert.deepEqual(Object.keys(getPlugin('android').capability.supportsByDefault ?? {}), ['audio']);
-  assert.equal(getPlugin('android').capability.unsupportedHintByDefault, undefined);
+  assert.deepEqual(Object.keys(getPlugin('android').capability.supportsByDefault ?? {}), [
+    'audio',
+    'tv-remote',
+  ]);
+  assert.deepEqual(Object.keys(getPlugin('android').capability.unsupportedHintByDefault ?? {}), [
+    'tv-remote',
+  ]);
   for (const platform of ['linux', 'web'] as const) {
     const capability = getPlugin(platform).capability;
     assert.equal(capability.supportsByDefault, undefined, `${platform} has no supportsByDefault`);
diff --git a/src/core/__tests__/dispatch-interactions.test.ts b/src/core/__tests__/dispatch-interactions.test.ts
index 02f0381e2..767660f78 100644
--- a/src/core/__tests__/dispatch-interactions.test.ts
+++ b/src/core/__tests__/dispatch-interactions.test.ts
@@ -63,6 +63,7 @@ function makeUnusedInteractor(): Interactor {
     rotateGesture: fail,
     transformGesture: fail,
     appSwitcher: fail,
+    tvRemote: fail,
     readClipboard: fail,
     writeClipboard: fail,
     setSetting: fail,
diff --git a/src/core/__tests__/dispatch-tv-remote.test.ts b/src/core/__tests__/dispatch-tv-remote.test.ts
new file mode 100644
index 000000000..1ae482c56
--- /dev/null
+++ b/src/core/__tests__/dispatch-tv-remote.test.ts
@@ -0,0 +1,75 @@
+import { beforeEach, test, vi } from 'vitest';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+
+vi.mock('../../platforms/apple/core/runner/runner-client.ts', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../../platforms/apple/core/runner/runner-client.ts')>();
+  return { ...actual, runAppleRunnerCommand: vi.fn() };
+});
+
+import { dispatchCommand } from '../dispatch.ts';
+import { AppError } from '../../kernel/errors.ts';
+import { runAppleRunnerCommand } from '../../platforms/apple/core/runner/runner-client.ts';
+import {
+  ANDROID_EMULATOR,
+  ANDROID_TV_DEVICE,
+  TVOS_SIMULATOR,
+} from '../../__tests__/test-utils/device-fixtures.ts';
+import { withMockedAdb } from '../../__tests__/test-utils/mocked-binaries.ts';
+
+const mockRunAppleRunnerCommand = vi.mocked(runAppleRunnerCommand);
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  mockRunAppleRunnerCommand.mockResolvedValue({ message: 'remotePress' });
+});
+
+test('dispatch tv-remote sends Android TV D-pad keyevents', async () => {
+  await withMockedAdb('agent-device-dispatch-tv-remote-', async (argsLogPath) => {
+    const result = await dispatchCommand(ANDROID_TV_DEVICE, 'tv-remote', ['right']);
+
+    assert.equal(result?.action, 'tv-remote');
+    assert.equal(result?.button, 'right');
+    const logged = await fs.readFile(argsLogPath, 'utf8');
+    assert.match(logged, /shell\ninput\nkeyevent\nKEYCODE_DPAD_RIGHT/);
+  });
+});
+
+test('dispatch tv-remote maps Android duration to longpress keyevent', async () => {
+  await withMockedAdb('agent-device-dispatch-tv-remote-longpress-', async (argsLogPath) => {
+    const result = await dispatchCommand(ANDROID_TV_DEVICE, 'tv-remote', ['select'], undefined, {
+      durationMs: 500,
+    });
+
+    assert.equal(result?.durationMs, 500);
+    const logged = await fs.readFile(argsLogPath, 'utf8');
+    assert.match(logged, /shell\ninput\nkeyevent\n--longpress\nKEYCODE_DPAD_CENTER/);
+  });
+});
+
+test('dispatch tv-remote sends native tvOS remotePress command', async () => {
+  const result = await dispatchCommand(TVOS_SIMULATOR, 'tv-remote', ['back'], undefined, {
+    appBundleId: 'com.example.tv',
+    durationMs: 250,
+  });
+
+  assert.equal(result?.button, 'back');
+  assert.equal(mockRunAppleRunnerCommand.mock.calls.length, 1);
+  assert.deepEqual(mockRunAppleRunnerCommand.mock.calls[0]?.[1], {
+    command: 'remotePress',
+    remoteButton: 'menu',
+    appBundleId: 'com.example.tv',
+    durationMs: 250,
+  });
+});
+
+test('dispatch tv-remote rejects non-TV targets before platform input', async () => {
+  await assert.rejects(
+    () => dispatchCommand(ANDROID_EMULATOR, 'tv-remote', ['down']),
+    (error: unknown) =>
+      error instanceof AppError &&
+      error.code === 'UNSUPPORTED_OPERATION' &&
+      /TV targets/.test(error.message),
+  );
+});
diff --git a/src/core/command-descriptor/__tests__/command-result.test.ts b/src/core/command-descriptor/__tests__/command-result.test.ts
index d8c4f4cfa..8b1c3d322 100644
--- a/src/core/command-descriptor/__tests__/command-result.test.ts
+++ b/src/core/command-descriptor/__tests__/command-result.test.ts
@@ -11,6 +11,7 @@ import type {
   BackCommandResult,
   HomeCommandResult,
   RotateCommandResult,
+  TvRemoteCommandResult,
 } from '../../../contracts/navigation.ts';
 import type { ClipboardCommandResult } from '../../../contracts/clipboard.ts';
 import type { AppStateCommandResult } from '../../../contracts/app-state.ts';
@@ -40,6 +41,7 @@ test('seeded CommandResult entries resolve to their existing contract result typ
   const clipboard: Equal<CommandResult<'clipboard'>, ClipboardCommandResult> = true;
   const appstate: Equal<CommandResult<'appstate'>, AppStateCommandResult> = true;
   const keyboard: Equal<CommandResult<'keyboard'>, KeyboardCommandResult> = true;
+  const tvRemote: Equal<CommandResult<'tv-remote'>, TvRemoteCommandResult> = true;
   expect([
     press,
     fill,
@@ -54,7 +56,8 @@ test('seeded CommandResult entries resolve to their existing contract result typ
     clipboard,
     appstate,
     keyboard,
-  ]).toEqual([true, true, true, true, true, true, true, true, true, true, true, true, true]);
+    tvRemote,
+  ]).toEqual([true, true, true, true, true, true, true, true, true, true, true, true, true, true]);
 });
 
 test('unmigrated commands fall back to the untyped Record bag, keeping the union total', () => {
@@ -80,6 +83,7 @@ test('CommandResultMap is seeded only from already-existing contract result type
     | 'clipboard'
     | 'appstate'
     | 'keyboard'
+    | 'tv-remote'
   > = true;
   expect(keys).toBe(true);
 });
diff --git a/src/core/command-descriptor/command-result.ts b/src/core/command-descriptor/command-result.ts
index 7396941df..49b4dfac3 100644
--- a/src/core/command-descriptor/command-result.ts
+++ b/src/core/command-descriptor/command-result.ts
@@ -10,6 +10,7 @@ import type {
   BackCommandResult,
   HomeCommandResult,
   RotateCommandResult,
+  TvRemoteCommandResult,
 } from '../../contracts/navigation.ts';
 import type { ClipboardCommandResult } from '../../contracts/clipboard.ts';
 import type { AppStateCommandResult } from '../../contracts/app-state.ts';
@@ -47,6 +48,7 @@ export interface CommandResultMap {
   clipboard: ClipboardCommandResult;
   appstate: AppStateCommandResult;
   keyboard: KeyboardCommandResult;
+  'tv-remote': TvRemoteCommandResult;
 }
 
 /**
diff --git a/src/core/command-descriptor/registry.ts b/src/core/command-descriptor/registry.ts
index 81a99d984..c246fff1d 100644
--- a/src/core/command-descriptor/registry.ts
+++ b/src/core/command-descriptor/registry.ts
@@ -589,6 +589,17 @@ const RAW_COMMAND_DESCRIPTORS = [
     timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
     batchable: true,
   },
+  {
+    name: PUBLIC_COMMANDS.tvRemote,
+    daemon: { route: 'generic', replayScopedAction: true, androidBlockingDialogGuard: true },
+    capability: {
+      apple: APPLE_SIM_AND_DEVICE,
+      android: ANDROID_ALL,
+      linux: LINUX_NONE,
+    },
+    timeoutPolicy: DEFAULT_TIMEOUT_POLICY,
+    batchable: true,
+  },
   {
     name: PUBLIC_COMMANDS.rotate,
     daemon: { route: 'generic', replayScopedAction: true, androidBlockingDialogGuard: true },
diff --git a/src/core/dispatch.ts b/src/core/dispatch.ts
index 643725eba..dc569d1c3 100644
--- a/src/core/dispatch.ts
+++ b/src/core/dispatch.ts
@@ -13,6 +13,7 @@ import {
 import { emitDiagnostic, withDiagnosticTimer } from '../utils/diagnostics.ts';
 import { readLocationCoordinate } from '../utils/location-coordinates.ts';
 import { successText, withSuccessText } from '../utils/success-text.ts';
+import { requireIntInRange } from '../utils/validation.ts';
 import { screenshotOptionsFromFlags } from '../contracts/screenshot.ts';
 import { isKeyboardAction, type KeyboardAction } from '../utils/keyboard-actions.ts';
 import type { DispatchContext } from './dispatch-context.ts';
@@ -34,6 +35,7 @@ import {
 } from './dispatch-interactions.ts';
 import { readNotificationPayload } from './dispatch-payload.ts';
 import { parseDeviceRotation } from './device-rotation.ts';
+import { parseTvRemoteButton } from './tv-remote.ts';
 import { readViewportDimension } from './viewport-dimension.ts';
 
 export { resolveTargetDevice } from './dispatch-resolve.ts';
@@ -120,6 +122,7 @@ type DispatchCommand =
   | 'app-switcher'
   | 'clipboard'
   | 'keyboard'
+  | 'tv-remote'
   | 'settings'
   | 'push'
   | 'snapshot'
@@ -204,6 +207,8 @@ const DISPATCH_HANDLERS: Record<DispatchCommand, DispatchHandler> = {
   clipboard: ({ interactor, positionals }) => handleClipboardCommand(interactor, positionals),
   keyboard: ({ device, positionals, context, runnerCtx }) =>
     handleKeyboardCommand(device, positionals, context, runnerCtx),
+  'tv-remote': ({ device, interactor, positionals, context }) =>
+    handleTvRemoteCommand(device, interactor, positionals, context),
   settings: ({ device, interactor, positionals, context }) =>
     handleSettingsCommand(device, interactor, positionals, context),
   push: ({ device, positionals, context }) => handlePushCommand(device, positionals, context),
@@ -390,6 +395,34 @@ async function handleClipboardCommand(
   };
 }
 
+async function handleTvRemoteCommand(
+  device: DeviceInfo,
+  interactor: Interactor,
+  positionals: string[],
+  context: DispatchContext | undefined,
+): Promise<Record<string, unknown>> {
+  if (device.target !== 'tv') {
+    throw new AppError('UNSUPPORTED_OPERATION', 'tv-remote is supported only on TV targets', {
+      hint: 'Select an Android TV or tvOS target with --target tv.',
+    });
+  }
+  if (positionals.length !== 1) {
+    throw new AppError('INVALID_ARGS', 'tv-remote requires exactly one button');
+  }
+  const button = parseTvRemoteButton(positionals[0]);
+  const durationMs =
+    context?.durationMs === undefined
+      ? undefined
+      : requireIntInRange(context.durationMs, 'durationMs', 0, 10_000);
+  await interactor.tvRemote(button, durationMs);
+  return {
+    action: 'tv-remote',
+    button,
+    ...(durationMs !== undefined ? { durationMs } : {}),
+    ...successText(`Pressed TV remote ${button}`),
+  };
+}
+
 async function handleKeyboardCommand(
   device: DeviceInfo,
   positionals: string[],
diff --git a/src/core/interactor-types.ts b/src/core/interactor-types.ts
index ecaa8f76d..640670e1e 100644
--- a/src/core/interactor-types.ts
+++ b/src/core/interactor-types.ts
@@ -1,6 +1,7 @@
 import type { BackMode } from './back-mode.ts';
 import type { DeviceRotation } from './device-rotation.ts';
 import type { ScrollDirection, TransformGestureParams } from './scroll-gesture.ts';
+import type { TvRemoteButton } from './tv-remote.ts';
 import type { SettingOptions } from '../platforms/permission-utils.ts';
 import type { SessionSurface } from './session-surface.ts';
 import type { BackendSnapshotResult } from '../backend.ts';
@@ -145,6 +146,7 @@ export type Interactor = {
   ): Promise<Record<string, unknown> | void>;
   transformGesture(options: TransformGestureParams): Promise<Record<string, unknown> | void>;
   appSwitcher(): Promise<void>;
+  tvRemote(button: TvRemoteButton, durationMs?: number): Promise<void>;
   readClipboard(): Promise<string>;
   writeClipboard(text: string): Promise<void>;
   setSetting(
diff --git a/src/core/interactors/android.ts b/src/core/interactors/android.ts
index 65d857ec2..00b7c5c6e 100644
--- a/src/core/interactors/android.ts
+++ b/src/core/interactors/android.ts
@@ -11,6 +11,7 @@ import {
   homeAndroid,
   longPressAndroid,
   pressAndroid,
+  pressAndroidTvRemote,
   rotateAndroid,
   scrollAndroid,
   typeAndroid,
@@ -92,6 +93,7 @@ export function createAndroidInteractor(device: DeviceInfo): Interactor {
       rotateGestureAndroid(device, { degrees, x, y, velocity }),
     transformGesture: (options) => transformGestureAndroid(device, options),
     appSwitcher: () => appSwitcherAndroid(device),
+    tvRemote: (button, durationMs) => pressAndroidTvRemote(device, button, durationMs),
     readClipboard: () => readAndroidClipboardText(device),
     writeClipboard: (text) => writeAndroidClipboardText(device, text),
     setSetting: (setting, state, appId, options) =>
diff --git a/src/core/interactors/linux.ts b/src/core/interactors/linux.ts
index 6cebbb94c..599b6934a 100644
--- a/src/core/interactors/linux.ts
+++ b/src/core/interactors/linux.ts
@@ -68,6 +68,9 @@ export function createLinuxInteractor(): Interactor {
     appSwitcher: () => {
       throw new AppError('UNSUPPORTED_OPERATION', 'appSwitcher not yet supported on Linux');
     },
+    tvRemote: () => {
+      throw new AppError('UNSUPPORTED_OPERATION', 'tv-remote not supported on Linux');
+    },
     readClipboard: () => readLinuxClipboard(),
     writeClipboard: (text) => writeLinuxClipboard(text),
     setSetting: () => {
diff --git a/src/core/interactors/register-builtins.ts b/src/core/interactors/register-builtins.ts
index 4a305fec5..dcd373f10 100644
--- a/src/core/interactors/register-builtins.ts
+++ b/src/core/interactors/register-builtins.ts
@@ -25,7 +25,14 @@ const androidPlugin = {
   platforms: ['android'],
   capability: {
     bucket: 'android',
-    supportsByDefault: { [PUBLIC_COMMANDS.audio]: isAudioProbeSupportedDevice },
+    supportsByDefault: {
+      [PUBLIC_COMMANDS.audio]: isAudioProbeSupportedDevice,
+      [PUBLIC_COMMANDS.tvRemote]: (device) => device.target === 'tv',
+    },
+    unsupportedHintByDefault: {
+      [PUBLIC_COMMANDS.tvRemote]: (device) =>
+        device.target === 'tv' ? undefined : 'tv-remote is supported only on Android TV targets.',
+    },
   },
   // Wraps the Android arm of `resolveLogBackend`: every Android device -> 'android'.
   appLog: { resolveBackend: () => 'android' },
diff --git a/src/core/interactors/web.ts b/src/core/interactors/web.ts
index 930c0a384..c46f12eca 100644
--- a/src/core/interactors/web.ts
+++ b/src/core/interactors/web.ts
@@ -40,6 +40,7 @@ export function createWebInteractor(): Interactor {
     rotateGesture: () => unsupportedWebOperation('rotateGesture'),
     transformGesture: () => unsupportedWebOperation('transformGesture'),
     appSwitcher: () => unsupportedWebOperation('appSwitcher'),
+    tvRemote: () => unsupportedWebOperation('tvRemote'),
     readClipboard: () => unsupportedWebOperation('readClipboard'),
     writeClipboard: () => unsupportedWebOperation('writeClipboard'),
     setSetting: () => unsupportedWebOperation('setSetting'),
diff --git a/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts b/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
index efbd49449..cdc6e6017 100644
--- a/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
+++ b/src/core/platform-plugin/__tests__/apple-os-capability-table-parity.test.ts
@@ -52,6 +52,9 @@ const supportsSynthesisGesture = (device: DeviceInfo): boolean =>
   device.platform === 'android' || isIosMobileSimulator(device);
 const supportsAndroidOrIosNonTv = (device: DeviceInfo): boolean =>
   device.platform === 'android' || (isIosFamily(device) && device.target !== 'tv');
+const supportsTvRemote = (device: DeviceInfo): boolean =>
+  (device.platform === 'android' && device.target === 'tv') ||
+  (isIosFamily(device) && device.target === 'tv');
 const synthesisGestureUnsupportedHint = (device: DeviceInfo): string | undefined => {
   if (isMacOs(device))
     return 'macOS automation has no multi-touch input — this gesture is supported on Android and the iOS simulator only.';
@@ -77,6 +80,7 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
     device.kind === 'simulator',
   keyboard: supportsAndroidOrIosNonTv,
   rotate: supportsAndroidOrIosNonTv,
+  'tv-remote': supportsTvRemote,
   alert: (device) => device.platform === 'android' || isMacOsOrAppleSimulator(device),
   settings: (device) =>
     device.platform === 'android' || isMacOs(device) || device.kind === 'simulator',
@@ -90,6 +94,17 @@ const SUPPORTS_REF: Record<string, (device: DeviceInfo) => boolean> = {
   'transform-gesture': supportsSynthesisGesture,
 };
 const HINT_REF: Record<string, (device: DeviceInfo) => string | undefined> = {
+  'tv-remote': (device) => {
+    if (device.platform === 'android') {
+      return device.target === 'tv'
+        ? undefined
+        : 'tv-remote is supported only on Android TV targets.';
+    }
+    if (isIosFamily(device)) {
+      return device.target === 'tv' ? undefined : 'tv-remote is supported only on tvOS devices.';
+    }
+    return isMacOs(device) ? 'tv-remote is supported only on tvOS devices.' : undefined;
+  },
   pinch: synthesisGestureUnsupportedHint,
   'rotate-gesture': synthesisGestureUnsupportedHint,
   'transform-gesture': synthesisGestureUnsupportedHint,
diff --git a/src/core/tv-remote.ts b/src/core/tv-remote.ts
new file mode 100644
index 000000000..36f515e24
--- /dev/null
+++ b/src/core/tv-remote.ts
@@ -0,0 +1,103 @@
+import { AppError } from '../kernel/errors.ts';
+
+type TvRemoteDurationMode = 'exact' | 'longpress';
+
+type TvRemoteButtonDefinition = {
+  aliases: readonly string[];
+  androidKeyevent: string;
+  appleRemoteButton: string;
+};
+
+const TV_REMOTE_DURATION_MODE = {
+  android: 'longpress',
+  apple: 'exact',
+} as const satisfies Record<string, TvRemoteDurationMode>;
+
+const TV_REMOTE_BUTTON_DEFINITIONS = {
+  up: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_DPAD_UP',
+    appleRemoteButton: 'up',
+  },
+  down: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_DPAD_DOWN',
+    appleRemoteButton: 'down',
+  },
+  left: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_DPAD_LEFT',
+    appleRemoteButton: 'left',
+  },
+  right: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_DPAD_RIGHT',
+    appleRemoteButton: 'right',
+  },
+  select: {
+    aliases: ['ok', 'center', 'enter'],
+    androidKeyevent: 'KEYCODE_DPAD_CENTER',
+    appleRemoteButton: 'select',
+  },
+  menu: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_MENU',
+    appleRemoteButton: 'menu',
+  },
+  home: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_HOME',
+    appleRemoteButton: 'home',
+  },
+  back: {
+    aliases: [],
+    androidKeyevent: 'KEYCODE_BACK',
+    appleRemoteButton: 'menu',
+  },
+} as const satisfies Record<string, TvRemoteButtonDefinition>;
+
+export const TV_REMOTE_BUTTONS = Object.keys(
+  TV_REMOTE_BUTTON_DEFINITIONS,
+) as (keyof typeof TV_REMOTE_BUTTON_DEFINITIONS)[];
+
+export const TV_REMOTE_BUTTON_USAGE = `<${TV_REMOTE_BUTTONS.join('|')}>`;
+
+export type TvRemoteButton = (typeof TV_REMOTE_BUTTONS)[number];
+
+export type AppleTvRemoteButton =
+  (typeof TV_REMOTE_BUTTON_DEFINITIONS)[TvRemoteButton]['appleRemoteButton'];
+
+export function parseTvRemoteButton(value: string | undefined): TvRemoteButton {
+  const normalized = value?.toLowerCase();
+  if (isTvRemoteButton(normalized)) return normalized;
+  const canonical = normalized ? TV_REMOTE_BUTTON_ALIAS_MAP.get(normalized) : undefined;
+  if (canonical) return canonical;
+  throw new AppError(
+    'INVALID_ARGS',
+    `tv-remote button must be one of: ${TV_REMOTE_BUTTONS.join(', ')}.`,
+  );
+}
+
+function isTvRemoteButton(value: unknown): value is TvRemoteButton {
+  return typeof value === 'string' && TV_REMOTE_BUTTONS.includes(value as TvRemoteButton);
+}
+
+export function toAppleTvRemoteButton(button: TvRemoteButton): AppleTvRemoteButton {
+  return TV_REMOTE_BUTTON_DEFINITIONS[button].appleRemoteButton;
+}
+
+export function toAndroidTvRemoteKeyevent(button: TvRemoteButton): string {
+  return TV_REMOTE_BUTTON_DEFINITIONS[button].androidKeyevent;
+}
+
+export function tvRemoteDurationMode(
+  platform: keyof typeof TV_REMOTE_DURATION_MODE,
+): TvRemoteDurationMode {
+  return TV_REMOTE_DURATION_MODE[platform];
+}
+
+const TV_REMOTE_BUTTON_ALIAS_MAP = new Map<string, TvRemoteButton>(
+  TV_REMOTE_BUTTONS.flatMap((button) =>
+    TV_REMOTE_BUTTON_DEFINITIONS[button].aliases.map((alias) => [alias, button] as const),
+  ),
+);
diff --git a/src/daemon/__tests__/request-handler-catalog.test.ts b/src/daemon/__tests__/request-handler-catalog.test.ts
index 5a40a75ef..62a4d1cb2 100644
--- a/src/daemon/__tests__/request-handler-catalog.test.ts
+++ b/src/daemon/__tests__/request-handler-catalog.test.ts
@@ -49,6 +49,7 @@ test('catalog commands use generic routing only when intentionally passthrough o
     PUBLIC_COMMANDS.screenshot,
     PUBLIC_COMMANDS.scroll,
     PUBLIC_COMMANDS.swipe,
+    PUBLIC_COMMANDS.tvRemote,
     PUBLIC_COMMANDS.viewport,
   ].sort();
   const genericCatalogCommands = [
diff --git a/src/daemon/__tests__/selectors.test.ts b/src/daemon/__tests__/selectors.test.ts
index 14d3b3462..868fc727b 100644
--- a/src/daemon/__tests__/selectors.test.ts
+++ b/src/daemon/__tests__/selectors.test.ts
@@ -504,6 +504,33 @@ test('role selector normalization matches Android class names by leaf type', ()
   assert.equal(resolved.node.ref, 'a1');
 });
 
+test('focused selector matches snapshot focus state', () => {
+  const tvNodes: SnapshotState['nodes'] = [
+    {
+      ref: 'tv1',
+      index: 0,
+      type: 'android.widget.TextView',
+      label: 'Search',
+      focused: false,
+    },
+    {
+      ref: 'tv2',
+      index: 1,
+      type: 'android.widget.Button',
+      label: 'Play',
+      focused: true,
+    },
+  ];
+  const chain = parseSelectorChain('focused=true');
+  const resolved = resolveSelectorChain(tvNodes, chain, {
+    platform: 'android',
+    requireUnique: true,
+  });
+
+  assert.ok(resolved);
+  assert.equal(resolved.node.ref, 'tv2');
+});
+
 // ── appName / windowTitle selectors ──────────────────────────────────────
 
 test('appName selector matches nodes with appName field', () => {
diff --git a/src/daemon/selectors-match.ts b/src/daemon/selectors-match.ts
index 3f9ec6a88..e8bf901f7 100644
--- a/src/daemon/selectors-match.ts
+++ b/src/daemon/selectors-match.ts
@@ -43,6 +43,8 @@ function matchesTerm(
       return isNodeEditable(node, platform) === Boolean(term.value);
     case 'selected':
       return Boolean(node.selected === true) === Boolean(term.value);
+    case 'focused':
+      return Boolean(node.focused === true) === Boolean(term.value);
     case 'enabled':
       return Boolean(node.enabled !== false) === Boolean(term.value);
     case 'hittable':
diff --git a/src/mcp/__tests__/command-tools.test.ts b/src/mcp/__tests__/command-tools.test.ts
index 5b302b83c..749e99509 100644
--- a/src/mcp/__tests__/command-tools.test.ts
+++ b/src/mcp/__tests__/command-tools.test.ts
@@ -259,6 +259,14 @@ test('MCP typed commands advertise an outputSchema with the contract discriminan
     (branch) => (branch.properties?.action as { const?: unknown } | undefined)?.const,
   );
   assert.deepEqual(clipboardActions, ['read', 'write']);
+
+  const tvRemote = tools.find((tool) => tool.name === 'tv-remote');
+  assert.ok(tvRemote);
+  assert.ok(tvRemote.outputSchema);
+  assert.deepEqual(
+    (tvRemote.outputSchema.properties?.button as { enum?: unknown[] } | undefined)?.enum,
+    ['up', 'down', 'left', 'right', 'select', 'menu', 'home', 'back'],
+  );
 });
 
 test('MCP untyped tools stay byte-identical: no outputSchema key', () => {
diff --git a/src/mcp/command-output-schemas.ts b/src/mcp/command-output-schemas.ts
index e77a4e3a2..1c6c53353 100644
--- a/src/mcp/command-output-schemas.ts
+++ b/src/mcp/command-output-schemas.ts
@@ -4,6 +4,7 @@ import { booleanSchema, looseObjectSchema, stringSchema } from '../commands/comm
 import { BACK_MODES } from '../core/back-mode.ts';
 import { DEVICE_ROTATIONS } from '../core/device-rotation.ts';
 import { SESSION_SURFACES } from '../core/session-surface.ts';
+import { TV_REMOTE_BUTTONS } from '../core/tv-remote.ts';
 import { DEVICE_TARGETS, PLATFORMS } from '../kernel/device.ts';
 
 /**
@@ -250,6 +251,15 @@ export const COMMAND_OUTPUT_SCHEMAS = {
     'action',
     'message',
   ]),
+  'tv-remote': objectSchema(
+    {
+      action: constSchema('tv-remote'),
+      button: enumSchema(TV_REMOTE_BUTTONS),
+      durationMs: numberSchema(),
+      message: stringSchema(),
+    },
+    ['action', 'button', 'message'],
+  ),
 
   // src/contracts/clipboard.ts — discriminated union on `action`.
   clipboard: {
diff --git a/src/platforms/android/__tests__/ui-hierarchy.test.ts b/src/platforms/android/__tests__/ui-hierarchy.test.ts
index bce9a746f..4fb891227 100644
--- a/src/platforms/android/__tests__/ui-hierarchy.test.ts
+++ b/src/platforms/android/__tests__/ui-hierarchy.test.ts
@@ -205,6 +205,20 @@ test('parseUiHierarchy excludes Android nodes that are not visible to the user',
   );
 });
 
+test('parseUiHierarchy keeps focused non-clickable Android TV nodes in interactive snapshots', () => {
+  const xml = `<hierarchy>
+  <node class="android.widget.FrameLayout" bounds="[0,0][960,540]" enabled="true" visible-to-user="true">
+    <node class="android.widget.TextView" text="Featured" bounds="[80,80][360,160]" clickable="false" focusable="true" focused="true" enabled="true" visible-to-user="true"/>
+  </node>
+</hierarchy>`;
+
+  const result = parseUiHierarchy(xml, 800, { interactiveOnly: true });
+  const focused = result.nodes.find((node) => node.label === 'Featured');
+
+  assert.equal(focused?.focused, true);
+  assert.equal(focused?.hittable, false);
+});
+
 test('parseUiHierarchy prunes Android nodes that are not visible to the user in raw snapshots', () => {
   const xml = `<hierarchy>
   <node class="android.widget.FrameLayout" bounds="[0,0][390,844]" enabled="true" visible-to-user="true">
diff --git a/src/platforms/android/input-actions.ts b/src/platforms/android/input-actions.ts
index 3b0198970..6f7edbf5a 100644
--- a/src/platforms/android/input-actions.ts
+++ b/src/platforms/android/input-actions.ts
@@ -3,6 +3,7 @@ import type { DeviceInfo } from '../../kernel/device.ts';
 import { emitDiagnostic } from '../../utils/diagnostics.ts';
 import type { DeviceRotation } from '../../core/device-rotation.ts';
 import { buildScrollGesturePlan, type ScrollDirection } from '../../core/scroll-gesture.ts';
+import { toAndroidTvRemoteKeyevent, type TvRemoteButton } from '../../core/tv-remote.ts';
 import { runAndroidAdb, sleep } from './adb.ts';
 import { resolveAndroidTextInjector, type AndroidTextInputAction } from './adb-executor.ts';
 import { getAndroidKeyboardState, type AndroidKeyboardState } from './device-input-state.ts';
@@ -19,6 +20,16 @@ export async function pressAndroid(device: DeviceInfo, x: number, y: number): Pr
   await runAndroidAdb(device, ['shell', 'input', 'tap', String(x), String(y)]);
 }
 
+export async function pressAndroidTvRemote(
+  device: DeviceInfo,
+  button: TvRemoteButton,
+  durationMs?: number,
+): Promise<void> {
+  const keyevent = toAndroidTvRemoteKeyevent(button);
+  const keyeventArgs = durationMs && durationMs > 0 ? ['keyevent', '--longpress'] : ['keyevent'];
+  await runAndroidAdb(device, ['shell', 'input', ...keyeventArgs, keyevent]);
+}
+
 export async function swipeAndroid(
   device: DeviceInfo,
   x1: number,
diff --git a/src/platforms/android/ui-hierarchy.ts b/src/platforms/android/ui-hierarchy.ts
index 79183292b..f2ed1b8ed 100644
--- a/src/platforms/android/ui-hierarchy.ts
+++ b/src/platforms/android/ui-hierarchy.ts
@@ -173,6 +173,7 @@ function appendAndroidSnapshotNode(
     bundleId: node.packageName ?? undefined,
     rect: node.rect,
     enabled: node.enabled,
+    focused: node.focused,
     visibleToUser: node.visibleToUser,
     hittable: node.hittable,
     depth,
@@ -422,6 +423,7 @@ export type AndroidUiHierarchy = {
   enabled?: boolean;
   visibleToUser?: boolean;
   drawingOrder?: number;
+  focused?: boolean;
   hittable?: boolean;
   depth: number;
   parentIndex?: number;
@@ -490,6 +492,7 @@ export function parseUiHierarchyTree(xml: string): AndroidUiHierarchy {
       packageName: attrs.packageName,
       rect: attrs.rect,
       enabled: attrs.enabled,
+      focused: attrs.focused,
       visibleToUser: attrs.visibleToUser,
       drawingOrder: attrs.drawingOrder,
       hittable: attrs.clickable ?? attrs.focusable,
@@ -735,6 +738,7 @@ function shouldIncludeInteractiveAndroidNode(
   ancestorCollection: boolean,
 ): boolean {
   if (hasNonPositiveRect(node)) return false;
+  if (node.focused) return true;
   if (node.hittable) return true;
   if (isScrollableType(info.type) && descendantHittable) return true;
   return shouldIncludeInteractiveProxyNode(
diff --git a/src/platforms/apple/interactor.ts b/src/platforms/apple/interactor.ts
index 79d429184..6b96eefda 100644
--- a/src/platforms/apple/interactor.ts
+++ b/src/platforms/apple/interactor.ts
@@ -11,6 +11,7 @@ import { iosRunnerOverrides, resolveAppleBackRunnerCommand } from './interaction
 import { appleRemotePressCommand } from './os/tvos/remote.ts';
 import { runMacOsScreenshotAction } from './os/macos/helper.ts';
 import { runAppleRunnerCommand } from './core/runner/runner-client.ts';
+import { toAppleTvRemoteButton } from '../../core/tv-remote.ts';
 import { withDiagnosticTimer } from '../../utils/diagnostics.ts';
 import { isMacOs, isTvOsDevice, type DeviceInfo } from '../../kernel/device.ts';
 import { AppError } from '../../kernel/errors.ts';
@@ -145,6 +146,17 @@ export function createAppleInteractor(
         runnerOpts,
       );
     },
+    tvRemote: async (button, durationMs) => {
+      await runAppleRunnerCommand(
+        device,
+        appleRemotePressCommand(
+          toAppleTvRemoteButton(button),
+          runnerContext.appBundleId,
+          durationMs,
+        ),
+        runnerOpts,
+      );
+    },
     readClipboard: () => readIosClipboardText(device),
     writeClipboard: (text) => writeIosClipboardText(device, text),
     setSetting: (setting, state, appId, options) =>
diff --git a/src/platforms/apple/plugin.ts b/src/platforms/apple/plugin.ts
index 7ad9d05e2..3403e3b6b 100644
--- a/src/platforms/apple/plugin.ts
+++ b/src/platforms/apple/plugin.ts
@@ -3,7 +3,7 @@ import type { PlatformPlugin } from '../../core/platform-plugin/plugin.ts';
 import { PUBLIC_COMMANDS } from '../../command-catalog.ts';
 import { isAudioProbeSupportedDevice } from '../../kernel/audio-probe-support.ts';
 import { shouldUseHostMacFastPath } from '../../core/platform-inventory.ts';
-import { isMacOs, type DeviceInfo } from '../../kernel/device.ts';
+import { isMacOs, isTvOsDevice, type DeviceInfo } from '../../kernel/device.ts';
 import type { DeviceInventoryRequest } from '../../core/platform-inventory.ts';
 import type { RunnerContext } from '../../core/interactor-types.ts';
 
@@ -62,6 +62,15 @@ const supportsSynthesisGesture = (device: DeviceInfo): boolean => {
     : device.platform === 'android';
 };
 
+// `tv-remote` is Android-TV or tvOS only. Off Apple this preserves the Android-TV
+// branch so the relocated Apple closure stays equivalent to the full original
+// supports predicate under the parity guard; the closure is only consulted for Apple
+// devices in production capability routing.
+const supportsTvRemote = (device: DeviceInfo): boolean => {
+  if (device.platform === 'android') return device.target === 'tv';
+  return isTvOsDevice(device);
+};
+
 const synthesisGestureUnsupportedHint = (device: DeviceInfo): string | undefined => {
   const caps = appleOsCapabilities(device);
   if (!caps) return undefined; // non-Apple: no multi-touch gate, no hint
@@ -91,6 +100,7 @@ const APPLE_SUPPORTS_BY_DEFAULT: Record<string, (device: DeviceInfo) => boolean>
     supportsHostOrSimulatorSurface(device),
   [PUBLIC_COMMANDS.keyboard]: supportsKeyboard,
   [PUBLIC_COMMANDS.rotate]: supportsOrientation,
+  [PUBLIC_COMMANDS.tvRemote]: supportsTvRemote,
   [PUBLIC_COMMANDS.alert]: (device) =>
     device.platform === 'android' || supportsHostOrSimulatorSurface(device),
   [PUBLIC_COMMANDS.settings]: (device) =>
@@ -105,6 +115,16 @@ const APPLE_UNSUPPORTED_HINT_BY_DEFAULT: Record<
   string,
   (device: DeviceInfo) => string | undefined
 > = {
+  [PUBLIC_COMMANDS.tvRemote]: (device) =>
+    device.platform === 'android'
+      ? device.target === 'tv'
+        ? undefined
+        : 'tv-remote is supported only on Android TV targets.'
+      : !appleOsCapabilities(device)
+        ? undefined
+        : isTvOsDevice(device)
+          ? undefined
+          : 'tv-remote is supported only on tvOS devices.',
   pinch: synthesisGestureUnsupportedHint,
   'rotate-gesture': synthesisGestureUnsupportedHint,
   'transform-gesture': synthesisGestureUnsupportedHint,
diff --git a/src/utils/__tests__/selector-is-predicates.test.ts b/src/utils/__tests__/selector-is-predicates.test.ts
index a2de17701..21ac991f1 100644
--- a/src/utils/__tests__/selector-is-predicates.test.ts
+++ b/src/utils/__tests__/selector-is-predicates.test.ts
@@ -34,6 +34,7 @@ test('normalizeIsPositionals rotates the selector-first form to predicate-first'
     'text=Foo',
     'visible=true',
   ]);
+  assert.deepEqual(normalizeIsPositionals(['label=Play', 'focused']), ['focused', 'label=Play']);
 });
 
 test('normalizeIsPositionals leaves unparseable arguments untouched', () => {
@@ -44,6 +45,26 @@ test('normalizeIsPositionals leaves unparseable arguments untouched', () => {
   assert.deepEqual(normalizeIsPositionals([]), []);
 });
 
+test('focused predicate reads snapshot focus state', () => {
+  const node: SnapshotNode = {
+    index: 0,
+    ref: 'e0',
+    type: 'android.widget.Button',
+    label: 'Play',
+    focused: true,
+  };
+
+  const result = evaluateIsPredicate({
+    predicate: 'focused',
+    node,
+    nodes: [node],
+    platform: 'android',
+  });
+
+  assert.equal(result.pass, true);
+  assert.match(result.details, /"focused":true/);
+});
+
 test('visible predicate treats zero-height hittable Android nodes as hidden', () => {
   const nodes: SnapshotNode[] = [
     {
diff --git a/src/utils/selector-is-predicates.ts b/src/utils/selector-is-predicates.ts
index 5dffe7966..c3f186b56 100644
--- a/src/utils/selector-is-predicates.ts
+++ b/src/utils/selector-is-predicates.ts
@@ -10,19 +10,26 @@ import {
   normalizeType,
 } from '../snapshot/snapshot-processing.ts';
 
-export type IsPredicate = 'visible' | 'hidden' | 'exists' | 'editable' | 'selected' | 'text';
+export type IsPredicate =
+  | 'visible'
+  | 'hidden'
+  | 'exists'
+  | 'editable'
+  | 'selected'
+  | 'focused'
+  | 'text';
 
 export function isSupportedPredicate(input: string): input is IsPredicate {
-  return ['visible', 'hidden', 'exists', 'editable', 'selected', 'text'].includes(input);
+  return ['visible', 'hidden', 'exists', 'editable', 'selected', 'focused', 'text'].includes(input);
 }
 
 export const IS_PREDICATE_REQUIRED_MESSAGE =
-  'is requires predicate: visible|hidden|exists|editable|selected|text';
+  'is requires predicate: visible|hidden|exists|editable|selected|focused|text';
 
 export const IS_PREDICATE_USAGE_HINT =
-  'Use "is <predicate> <selector>" or "is <selector> <predicate>". visible|hidden|editable|selected double as selector keys: a bare predicate token after the selector is read as the predicate, so write key=true (e.g. visible=true) inside the selector to use it as a filter instead.';
+  'Use "is <predicate> <selector>" or "is <selector> <predicate>". visible|hidden|editable|selected|focused double as selector keys: a bare predicate token after the selector is read as the predicate, so write key=true (e.g. visible=true) inside the selector to use it as a filter instead.';
 
-// visible|hidden|editable|selected double as selector boolean keys, so the selector-first
+// visible|hidden|editable|selected|focused double as selector boolean keys, so the selector-first
 // form (`is <selector> <predicate>`) cannot survive greedy selector parsing: the trailing
 // predicate token would be swallowed as a boolean selector term. Reserve the first bare
 // predicate token that terminates a valid selector prefix and rotate the positionals into
@@ -49,6 +56,7 @@ export function evaluateIsPredicate(params: {
   const actualText = extractNodeText(node);
   const editable = isNodeEditable(node, platform);
   const selected = node.selected === true;
+  const focused = node.focused === true;
   const visible =
     predicate === 'text' ? isNodeVisible(node) : isAssertionVisible(node, nodes, platform);
   let pass = false;
@@ -65,6 +73,9 @@ export function evaluateIsPredicate(params: {
     case 'selected':
       pass = selected;
       break;
+    case 'focused':
+      pass = focused;
+      break;
     case 'text':
       pass = actualText === (expectedText ?? '');
       break;
@@ -76,6 +87,7 @@ export function evaluateIsPredicate(params: {
           visible,
           editable,
           selected,
+          focused,
         })}`;
   return { pass, actualText, details };
 }
diff --git a/src/utils/selectors-parse.ts b/src/utils/selectors-parse.ts
index b3c55398b..72873e1bc 100644
--- a/src/utils/selectors-parse.ts
+++ b/src/utils/selectors-parse.ts
@@ -12,6 +12,7 @@ export type SelectorKey =
   | 'hidden'
   | 'editable'
   | 'selected'
+  | 'focused'
   | 'enabled'
   | 'hittable';
 
@@ -44,6 +45,7 @@ const BOOLEAN_KEYS = new Set<SelectorKey>([
   'hidden',
   'editable',
   'selected',
+  'focused',
   'enabled',
   'hittable',
 ]);
diff --git a/test/integration/provider-scenarios/android-tv-remote.test.ts b/test/integration/provider-scenarios/android-tv-remote.test.ts
new file mode 100644
index 000000000..f6b0f8dd6
--- /dev/null
+++ b/test/integration/provider-scenarios/android-tv-remote.test.ts
@@ -0,0 +1,81 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import type { DeviceInfo } from '../../../src/kernel/device.ts';
+import type { AndroidAdbProvider } from '../../../src/platforms/android/adb-executor.ts';
+import { assertCommandCall } from './assertions.ts';
+import { createProviderScenarioHarness, withProviderScenarioResource } from './harness.ts';
+import { runProviderScenario } from './scenario.ts';
+
+const PROVIDER_SCENARIO_ANDROID_TV: DeviceInfo = {
+  platform: 'android',
+  id: 'emulator-5556',
+  name: 'Android TV',
+  kind: 'emulator',
+  target: 'tv',
+  booted: true,
+};
+
+test('Provider-backed integration Android TV remote flow sends D-pad keyevents', async () => {
+  const adbCalls: string[][] = [];
+  const adbProvider: AndroidAdbProvider = {
+    exec: async (args) => {
+      adbCalls.push([...args]);
+      return { stdout: '', stderr: '', exitCode: 0 };
+    },
+  };
+
+  await withProviderScenarioResource(
+    async () =>
+      await createProviderScenarioHarness({
+        androidAdbProvider: () => adbProvider,
+        deviceInventoryProvider: async () => [PROVIDER_SCENARIO_ANDROID_TV],
+      }),
+    async (daemon) => {
+      daemon.setSession('default', {
+        name: 'default',
+        device: PROVIDER_SCENARIO_ANDROID_TV,
+        createdAt: Date.now(),
+        actions: [],
+      });
+
+      await runProviderScenario(daemon, [
+        {
+          name: 'move focus down',
+          command: 'tv-remote',
+          positionals: ['down'],
+          flags: { platform: 'android', target: 'tv' },
+          expectData: {
+            action: 'tv-remote',
+            button: 'down',
+            message: 'Pressed TV remote down',
+          },
+        },
+        {
+          name: 'hold select',
+          command: 'tv-remote',
+          positionals: ['select'],
+          flags: { platform: 'android', target: 'tv', durationMs: 500 },
+          expectData: {
+            action: 'tv-remote',
+            button: 'select',
+            durationMs: 500,
+            message: 'Pressed TV remote select',
+          },
+        },
+      ]);
+
+      assertCommandCall(adbCalls, ['shell', 'input', 'keyevent', 'KEYCODE_DPAD_DOWN']);
+      assertCommandCall(adbCalls, [
+        'shell',
+        'input',
+        'keyevent',
+        '--longpress',
+        'KEYCODE_DPAD_CENTER',
+      ]);
+      assert.deepEqual(
+        daemon.session('default')?.actions.map((action) => action.command),
+        ['tv-remote', 'tv-remote'],
+      );
+    },
+  );
+});
diff --git a/test/integration/provider-scenarios/apple-platform-output-guard.test.ts b/test/integration/provider-scenarios/apple-platform-output-guard.test.ts
index f8dacd3a9..1c3279ba4 100644
--- a/test/integration/provider-scenarios/apple-platform-output-guard.test.ts
+++ b/test/integration/provider-scenarios/apple-platform-output-guard.test.ts
@@ -121,6 +121,7 @@ const DRIVEN_COMMANDS: Record<string, DriveSpec> = {
   [PUBLIC_COMMANDS.rotate]: () => one(['left']),
   [PUBLIC_COMMANDS.scroll]: () => one(['down']),
   [PUBLIC_COMMANDS.swipe]: () => one(['up']),
+  [PUBLIC_COMMANDS.tvRemote]: () => one(['select']),
   [PUBLIC_COMMANDS.appSwitcher]: () => one(),
 
   // -- orchestration (drive to an error response; still scanned) --
diff --git a/test/skillgym/suites/agent-device-smoke-suite.ts b/test/skillgym/suites/agent-device-smoke-suite.ts
index c33855f8a..47e89c60b 100644
--- a/test/skillgym/suites/agent-device-smoke-suite.ts
+++ b/test/skillgym/suites/agent-device-smoke-suite.ts
@@ -1179,6 +1179,47 @@ const SKILL_GUIDANCE_CASES: Case[] = [
     strictFinalOutput: true,
     allowOnlyLocalCliHelpCommands: true,
   }),
+  makeCase({
+    id: 'android-tv-focus-uses-tv-remote',
+    contract: [
+      'Platform: Android TV emulator',
+      'Target selector is not currently focused',
+      'TV apps are focus-first: move focus with D-pad/remote buttons before selecting',
+      'Visual focus evidence is required before selecting',
+      'Raw ADB keyevent is the old workaround; use agent-device command surface instead',
+      'If you inspect CLI help, run it raw; do not pipe it through head, grep, jq, or tail',
+      'Final answer must be agent-device command lines only, with no prose or introduction',
+    ],
+    task: 'Plan commands to move focus down twice, capture overlay-ref screenshot evidence, and select the focused Android TV control.',
+    outputs: [
+      plannedCommand('tv-remote'),
+      /\bdown\b/i,
+      /screenshot\b[^\n]*--overlay-refs/i,
+      /\bselect\b/i,
+    ],
+    forbiddenOutputs: [
+      /\badb\b/i,
+      /\bkeyevent\b/i,
+      /(?:^|\n)(?:agent-device\s+)?(?:press|click)\s+@(?:e\d+|ref)\b/i,
+    ],
+    strictFinalOutput: true,
+    allowOnlyLocalCliHelpCommands: true,
+  }),
+  makeCase({
+    id: 'android-tv-remote-longpress-preset',
+    contract: [
+      'Platform: Android TV emulator',
+      'The focused control is a TV remote target',
+      'Use the agent-device TV remote command surface, not raw ADB keyevents',
+      'For a held TV remote button, use the tv-remote longpress preset',
+      'Final answer must be agent-device command lines only, with no prose or introduction',
+    ],
+    task: 'Plan the command to hold the focused Android TV select button with the default TV remote longpress preset.',
+    outputs: [plannedCommand('tv-remote'), /\blongpress\b/i, /\bselect\b/i],
+    forbiddenOutputs: [/\badb\b/i, /\bkeyevent\b/i, /--duration-ms/i, plannedCommand('longpress')],
+    strictFinalOutput: true,
+    allowOnlyLocalCliHelpCommands: true,
+  }),
   makeCase({
     id: 'ios-composite-horizontal-tabs-coordinate-fallback',
     contract: [
diff --git a/website/docs/docs/client-api.md b/website/docs/docs/client-api.md
index 62108abec..1dfa36e9a 100644
--- a/website/docs/docs/client-api.md
+++ b/website/docs/docs/client-api.md
@@ -228,6 +228,18 @@ await client.command.back({
   mode: 'system',
 });
 
+await client.command.tvRemote({
+  platform: 'android',
+  target: 'tv',
+  button: 'down',
+});
+
+await client.command.tvRemote({
+  platform: 'ios',
+  target: 'tv',
+  button: 'select',
+});
+
 await client.command.appSwitcher();
 ```
 
@@ -241,6 +253,7 @@ Supported command methods:
 - `appSwitcher`
 - `keyboard`
 - `clipboard`
+- `tvRemote`
 - `alert`
 
 Additional CLI-backed methods are exposed on their domain groups with typed option objects so Node consumers do not need to build raw daemon requests:
diff --git a/website/docs/docs/commands.md b/website/docs/docs/commands.md
index 0a8ad3e50..b66430a63 100644
--- a/website/docs/docs/commands.md
+++ b/website/docs/docs/commands.md
@@ -198,14 +198,23 @@ agent-device prepare ios-runner --platform ios --timeout 240000
 ```bash
 agent-device open YouTube --platform android --target tv
 agent-device apps --platform android --target tv
+agent-device snapshot -i --platform android --target tv
+agent-device tv-remote press down --platform android --target tv
+agent-device tv-remote press select --platform android --target tv
+agent-device tv-remote longpress select --platform android --target tv
+agent-device tv-remote press select --duration-ms 900 --platform android --target tv
+agent-device screenshot tv-focus.png --overlay-refs --platform android --target tv
 agent-device open Settings --platform ios --target tv
 agent-device screenshot apple-tv.png --platform ios --target tv
 ```
 
 - AndroidTV app launch and app listing resolve TV launchable activities via `LEANBACK_LAUNCHER`.
 - TV target selection supports both simulator/emulator and connected physical devices (AppleTV + AndroidTV).
+- TV targets are focus-first. Use `tv-remote` to move D-pad/remote focus before selecting a control; avoid raw `adb shell input keyevent` in command plans.
+- On Android TV, `tv-remote` maps to ADB keyevents. `tv-remote longpress <button>` is CLI sugar for a 500ms hold; `--duration-ms` overrides the preset and uses Android's longpress keyevent form for any positive duration because the platform command does not expose exact hold timing.
 - tvOS supports the same runner-driven interaction/snapshot flow as iOS (`snapshot`, `wait`, `press`, `fill`, `get`, `scroll`, `back`, `home`, `app-switcher`, `record`, and related selector flows).
-- On tvOS, runner `back`/`home`/`app-switcher` map to Siri Remote actions (`menu`, `home`, double-home).
+- On tvOS, `tv-remote`, runner `back`/`home`/`app-switcher` map to Siri Remote actions (`back` is Menu, `home` is Home, app switcher is double-home). `--duration-ms` is an exact remote-button hold duration.
+- Use `screenshot --overlay-refs` when visual focus evidence is useful or when focus metadata is unavailable/transient.
 - tvOS follows iOS simulator-only command semantics for helpers like `gesture pinch`, `settings`, and `push`.
 
 ## Desktop targets