@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+- Fixed (android): `clipboard read` and `clipboard write` stop reporting success on a build whose
+  clipboard service has no shell command. Android 16 (API 36) answers every `adb shell cmd clipboard …`
+  with the framework default `Binder.handleShellCommand` — `No shell command implementation.` on
+  stderr and exit status 0 — and the exit status was consulted first, so a read reported `text: ""`,
+  a write reported "Clipboard updated", and `capabilities` advertised `clipboard` on a clipboard no
+  adb call ever touched. The response is now classified per stream into one typed verdict shared by
+  both legs and the capability probe: the service's own sentence on `stderr` outranks a clean exit
+  (a service that never ran wrote no payload to `stdout`), while `stdout` stays payload until the call
+  has failed. Such a device now refuses with `UNSUPPORTED_OPERATION` and a hint naming the substitute,
+  and the exported `readAndroidClipboardWithAdb` / `writeAndroidClipboardWithAdb` helpers reject
+  instead of resolving an empty string or nothing at all (#2674).
 - Fixed (limrun): `screenshot` on Limrun iOS direct sessions writes a PNG. Limrun serves its capture
   as JPEG and the interactor wrote those bytes straight to the `.png` path, so every capture failed
   downstream with "Screenshot file is not a valid PNG". The bytes are now sniffed and a JPEG is
 
@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { test } from 'vitest';
 import type { AndroidAdbExecutor } from '../adb-executor.ts';
-import { AppError } from '@agent-device/kernel/errors';
+import { AppError, normalizeError } from '@agent-device/kernel/errors';
 import { promises as fs } from 'node:fs';
 import {
   dismissAndroidKeyboard,
@@ -10,6 +10,7 @@ import {
   readAndroidClipboardWithAdb,
   writeAndroidClipboardWithAdb,
 } from '../device-input-state.ts';
+import { ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON } from '../clipboard-shell-response.ts';
 import {
   flushDiagnosticsToSessionFile,
   withDiagnosticsScope,
@@ -236,16 +237,55 @@ test('writeAndroidClipboardWithAdb leaves safe text unquoted', async () => {
   assert.deepEqual(calls, [['shell', 'cmd', 'clipboard', 'set', 'text', 'android-otp']]);
 });
 
-// A successful `clipboard get text` puts the clipboard's *contents* on stdout, so the missing-shell
-// prose is only ever evidence about a call that failed. Reading it on a clean exit turned a user who
-// had copied one of these phrases into a device that "does not support" its own working clipboard.
+// A read that ran puts the clipboard's *contents* on stdout, so prose there is evidence only about a
+// call that failed. Prose on stderr is about the call whatever the exit status says.
 test('readAndroidClipboardWithAdb returns contents that read like an adb refusal', async () => {
   for (const contents of ['Unknown command: clipboard', 'No shell command implementation.']) {
     const adb: AndroidAdbExecutor = async () => ({ stdout: contents, stderr: '', exitCode: 0 });
     assert.equal(await readAndroidClipboardWithAdb(adb), contents);
   }
 });
 
+// Android 16 (API 36) answers every `cmd clipboard` call this way, and reading the clean exit as
+// execution turned it into `clipboard read` → `text: ""` and `clipboard write` → "Clipboard updated".
+test('readAndroidClipboardWithAdb refuses the exit-0 no-implementation answer instead of empty text', async () => {
+  const adb: AndroidAdbExecutor = async () => ({
+    stdout: '',
+    stderr: 'No shell command implementation.',
+    exitCode: 0,
+  });
+
+  const error = await readAndroidClipboardWithAdb(adb).then(
+    () => assert.fail('expected the clipboard read to reject'),
+    (error: unknown) => error,
+  );
+  assert.ok(error instanceof AppError);
+  assert.equal(error.code, 'UNSUPPORTED_OPERATION');
+  assert.equal(
+    (error.details as { reason?: unknown }).reason,
+    ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON,
+  );
+});
+
+test('writeAndroidClipboardWithAdb refuses the exit-0 no-implementation answer instead of claiming success', async () => {
+  const adb: AndroidAdbExecutor = async () => ({
+    stdout: '',
+    stderr: 'No shell command implementation.',
+    exitCode: 0,
+  });
+
+  const error = await writeAndroidClipboardWithAdb(adb, 'android-otp').then(
+    () => assert.fail('expected the clipboard write to reject'),
+    (error: unknown) => error,
+  );
+  assert.ok(error instanceof AppError);
+  assert.equal(error.code, 'UNSUPPORTED_OPERATION');
+  assert.equal(
+    (error.details as { reason?: unknown }).reason,
+    ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON,
+  );
+});
+
 test('readAndroidClipboardWithAdb still reports a genuine missing shell command', async () => {
   const adb: AndroidAdbExecutor = async () => ({
     stdout: '',
@@ -258,14 +298,26 @@ test('readAndroidClipboardWithAdb still reports a genuine missing shell command'
   });
 });
 
+// A failed call that names no missing command stays the transport failure it is: the clipboard read
+// must not be relabelled, and the adb evidence has to survive for failure classification.
 test('readAndroidClipboardWithAdb reports a non-zero failure that names no missing command', async () => {
   const adb: AndroidAdbExecutor = async () => ({
     stdout: '',
     stderr: 'error: device offline',
     exitCode: 1,
   });
 
-  await assert.rejects(() => readAndroidClipboardWithAdb(adb));
+  const error = await readAndroidClipboardWithAdb(adb).then(
+    () => assert.fail('expected the clipboard read to reject'),
+    (error: unknown) => error,
+  );
+  assert.ok(error instanceof AppError);
+  assert.equal(error.code, 'COMMAND_FAILED');
+  const details = error.details as Record<string, unknown>;
+  assert.equal(details.exitCode, 1);
+  assert.equal(details.stderr, 'error: device offline');
+  assert.equal(details.processExitError, true);
+  assert.equal(typeof normalizeError(error).hint, 'string');
 });
 
 test('dismissAndroidKeyboard skips keyevent when keyboard is already hidden', async () => {
 
@@ -15,21 +15,31 @@ export async function runAndroidAdb(
   return await resolveAndroidAdbExecutor(device)(args, options);
 }
 
+const ANDROID_NO_SHELL_COMMAND_SENTENCE = 'no shell command implementation';
+const ANDROID_UNKNOWN_SUBCOMMAND_PHRASE = 'unknown command';
+
+/**
+ * Whether one adb output stream carries the sentence a device prints when its service implements no
+ * shell command at all: `Binder.handleShellCommand`'s framework default writes it to the **err**
+ * descriptor and returns a **zero** status, so this sentence outranks the exit status — a clean exit
+ * never discharges it. Ask it of a stream, never of a call: the `stdout` of a command with a payload
+ * is that payload (`cmd clipboard get text` answers with arbitrary user text, which may quote this
+ * sentence), so only `stderr` is prose about the call itself.
+ */
+export function reportsAndroidNoShellCommand(stream: string): boolean {
+  return stream.toLowerCase().includes(ANDROID_NO_SHELL_COMMAND_SENTENCE);
+}
+
 /**
- * Whether an adb `cmd <service> <command>` invocation was refused because this build ships no
- * shell implementation for it, rather than because the call itself failed.
- *
- * adb reports this condition in its output and nowhere else — no exit code or structured field
- * separates "service has no shell command" from any other non-zero result — so this is the one
- * place that reads that prose, and it hands every caller a typed answer instead.
- *
- * Only ever ask this about a call that *failed*. A command that succeeds prints its own payload
- * on stdout — `clipboard get text` returns arbitrary user text, which may quote these very
- * phrases — so callers must settle a zero exit before reaching for this.
+ * Whether a call that already failed was refused for having no shell implementation rather than by
+ * the failure itself. Both streams are consulted here because a call that never ran produced no
+ * payload to confuse with the prose, and the generic missing-subcommand wording counts: adb prints
+ * it too, so on its own it says nothing about the device's service and never overrides a clean exit.
  */
 export function isAndroidShellCommandUnsupported(stdout: string, stderr: string): boolean {
   const haystack = `${stdout}\n${stderr}`.toLowerCase();
   return (
-    haystack.includes('no shell command implementation') || haystack.includes('unknown command')
+    haystack.includes(ANDROID_NO_SHELL_COMMAND_SENTENCE) ||
+    haystack.includes(ANDROID_UNKNOWN_SUBCOMMAND_PHRASE)
   );
 }
@@ -0,0 +1,113 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { normalizeError } from '@agent-device/kernel/errors';
+import {
+  androidClipboardShellCommandUnavailableError,
+  androidClipboardShellSupportForVerdict,
+  ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON,
+  classifyAndroidClipboardShellResponse,
+} from './clipboard-shell-response.ts';
+
+// Android 16 (API 36): `ClipboardService` implements no shell command, so the framework default
+// answers with its sentence on stderr and a clean exit. A classifier that settles the exit status
+// first reports a clipboard that no adb call ever touched.
+test('clipboard shell classification refuses the no-implementation answer despite a clean exit', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: '',
+      stderr: 'No shell command implementation.',
+      exitCode: 0,
+    }),
+    'no-shell-command',
+  );
+});
+
+test('clipboard shell classification reports a clipboard the service actually answered', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: 'clipboard text: otp-123456\n',
+      stderr: '',
+      exitCode: 0,
+    }),
+    'executed',
+  );
+});
+
+// A read that ran answers on stdout with arbitrary user text, so stdout is never evidence about the
+// call — whatever a clipboard happens to hold stays clipboard contents.
+test('clipboard shell classification keeps copied prose from looking like a refusal', () => {
+  for (const contents of ['Unknown command: clipboard', 'No shell command implementation.']) {
+    assert.equal(
+      classifyAndroidClipboardShellResponse({ stdout: contents, stderr: '', exitCode: 0 }),
+      'executed',
+      contents,
+    );
+  }
+});
+
+// Older adb merges the device's streams onto stdout, so prose there is evidence once the call itself
+// is known to have failed.
+test('clipboard shell classification reads a refusal off stdout once the call failed', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: 'No shell command implementation.',
+      stderr: '',
+      exitCode: 255,
+    }),
+    'no-shell-command',
+  );
+});
+
+// `unknown command` is adb's own wording as well as a service's (`adb: unknown command features`), so
+// it cannot say anything about this device's clipboard service on a call that succeeded. Only the
+// framework's no-shell-command sentence outranks a clean exit.
+test('clipboard shell classification refuses to read adb prose as a device verdict', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: 'clipboard text: otp-123456\n',
+      stderr: 'adb: unknown command features',
+      exitCode: 0,
+    }),
+    'executed',
+  );
+});
+
+// Streams separated, both talking: a service that printed its no-shell-command sentence never ran
+// the command, so whatever shares the call is not the payload it was asked for.
+test('clipboard shell classification believes the sentence over a stream it did not write', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: 'clipboard text: otp-123456\n',
+      stderr: 'No shell command implementation.',
+      exitCode: 0,
+    }),
+    'no-shell-command',
+  );
+});
+
+test('clipboard shell classification keeps a broken transport out of the missing-command verdict', () => {
+  assert.equal(
+    classifyAndroidClipboardShellResponse({
+      stdout: '',
+      stderr: 'error: device offline',
+      exitCode: 1,
+    }),
+    'call-failed',
+  );
+});
+
+test('clipboard shell support verdicts carry the execution answer to admission', () => {
+  assert.equal(androidClipboardShellSupportForVerdict('executed'), 'supported');
+  assert.equal(androidClipboardShellSupportForVerdict('no-shell-command'), 'unsupported');
+  assert.equal(androidClipboardShellSupportForVerdict('call-failed'), 'probe-failed');
+});
+
+test('clipboard shell refusal is dispatchable and names the substitute', () => {
+  const error = androidClipboardShellCommandUnavailableError('read');
+  assert.equal(error.code, 'UNSUPPORTED_OPERATION');
+  assert.equal(
+    (error.details as { reason?: unknown }).reason,
+    ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON,
+  );
+  assert.match(String(normalizeError(error).hint), /pasting into a focused field/);
+});
@@ -0,0 +1,87 @@
+import type { AndroidClipboardShellSupport } from '@agent-device/contracts/android-clipboard-support';
+import { AppError } from '@agent-device/kernel/errors';
+import type { AndroidAdbExecutorResult } from './adb-executor.ts';
+import { isAndroidShellCommandUnsupported, reportsAndroidNoShellCommand } from './adb.ts';
+
+/** What the device answered an `adb shell cmd clipboard …` call. */
+export type AndroidClipboardShellVerdict = 'executed' | 'no-shell-command' | 'call-failed';
+
+/** Which clipboard subcommand was called, shared by the refusal wording and the reason. */
+export type AndroidClipboardOperation = 'read' | 'write';
+
+export const ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON =
+  'android_clipboard_shell_command_unavailable' as const;
+
+/**
+ * What to do instead, carried by both the fact that refuses admission and the error that refuses
+ * execution: the substitute is a device-side check, never another adb attempt.
+ */
+export const ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_HINT =
+  'This Android build ships no shell implementation for the clipboard service, so adb cannot read or write the clipboard on it. Verify a copy flow by pasting into a focused field and reading that field back.';
+
+/**
+ * Classifies one clipboard shell call from what the device said about it.
+ *
+ * A zero exit status does not settle whether the clipboard service ran the command: a service that
+ * implements no shell command prints `No shell command implementation.` to its **err** descriptor
+ * and returns 0 (`Binder.handleShellCommand`'s framework default, which is what Android's
+ * `ClipboardService` falls back to). So that sentence is evidence at every exit status, and it wins
+ * even against a non-empty stdout, because a service that never ran the command produced no payload
+ * for stdout to hold.
+ *
+ * Nothing else about a clean exit is evidence of refusal. A read that ran answers on stdout with
+ * arbitrary user text, which may quote any of these phrases, and the generic missing-subcommand
+ * prose is adb's own wording too — it can describe the client, not this device — so both are read
+ * only once the call has actually failed.
+ */
+export function classifyAndroidClipboardShellResponse(
+  result: Pick<AndroidAdbExecutorResult, 'exitCode' | 'stdout' | 'stderr'>,
+): AndroidClipboardShellVerdict {
+  if (reportsAndroidNoShellCommand(result.stderr)) return 'no-shell-command';
+  if (result.exitCode !== 0) {
+    return isAndroidShellCommandUnsupported(result.stdout, result.stderr)
+      ? 'no-shell-command'
+      : 'call-failed';
+  }
+  return 'executed';
+}
+
+/**
+ * Translates the execution verdict into the admission verdict the clipboard facts are stated in.
+ * A build that refused the probe's command will refuse the next one too, while a call that never
+ * reached a build proves nothing about it.
+ */
+export function androidClipboardShellSupportForVerdict(
+  verdict: AndroidClipboardShellVerdict,
+): AndroidClipboardShellSupport {
+  if (verdict === 'executed') return 'supported';
+  return verdict === 'no-shell-command' ? 'unsupported' : 'probe-failed';
+}
+
+/**
+ * The admission verdict for one probe call, for a caller that holds only what adb answered. The
+ * verdict vocabulary stays here: a caller that composes it itself would have to know which
+ * sentences outrank which streams, which is the part only this owner should assert.
+ */
+export function androidClipboardShellSupportForResult(
+  result: Pick<AndroidAdbExecutorResult, 'exitCode' | 'stdout' | 'stderr'>,
+): AndroidClipboardShellSupport {
+  return androidClipboardShellSupportForVerdict(classifyAndroidClipboardShellResponse(result));
+}
+
+/**
+ * The refusal for a build whose clipboard service exposes no shell command: not retryable, and not
+ * a permission to ask for, so it carries the substitute hint rather than a retriable detail.
+ */
+export function androidClipboardShellCommandUnavailableError(
+  operation: AndroidClipboardOperation,
+): AppError {
+  return new AppError(
+    'UNSUPPORTED_OPERATION',
+    `Android shell clipboard ${operation} is not supported on this device.`,
+    {
+      reason: ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_REASON,
+      hint: ANDROID_CLIPBOARD_SHELL_COMMAND_UNAVAILABLE_HINT,
+    },
+  );
+}