@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Added strict `wait absent <selector> [timeoutMs]` polling for zero selector matches. Incomplete,
+  sparse, truncated, scoped, depth-limited, and Android unreadable captures cannot prove absence;
+  deadline diagnostics retain typed capture evidence and stable first-match details (#2236).
 - Fixed: `settings airplane on|off` now takes an Android device offline. It is applied through
   the connectivity service (`cmd connectivity airplane-mode`), which drives the radios, instead of
   writing `airplane_mode_on` and broadcasting `ACTION_AIRPLANE_MODE_CHANGED` — a broadcast Android
 
@@ -288,7 +288,10 @@ A recorded `id` never matches a node without that id.
 >   `is exists` (existence assertion with no unique winner; wait-like semantics without the
 >   guard-critical role), `is absent` (a strict one-capture absence observation has no resolved
 >   winner; it records as an ordinary observation and its `predicate_failed` failure is always an
->   action-failure, never an identity mismatch), every read-only `find` variant (fuzzy-locator resolution has no
+>   action-failure, never an identity mismatch), `wait absent` (strict zero-candidate polling has no
+>   resolved winner; its no-match success carries no `target-v1` or landmark annotation, and a
+>   `wait_target_present` deadline is an ordinary action-failure, never an identity mismatch or an
+>   ADR 0016 destination guard), every read-only `find` variant (fuzzy-locator resolution has no
 >   selector-chain identity token for the classifier, and publication already refuses mutating `find`
 >   as non-verifiable), and `wait text`/`wait stable`/duration waits/`wait @ref` (no element target, or
 >   a session-local ref that ADR 0016 already refuses to publish; `wait @ref` is rejected rather than
 
@@ -46,6 +46,16 @@ test('planPostResolutionTargetVerification: a non-selector wait form is inert (s
   );
 });
 
+test('planPostResolutionTargetVerification: wait absent is not a landmark or identity guard', () => {
+  assert.deepEqual(
+    planPostResolutionTargetVerification({
+      recorded: recorded(),
+      isSelectorWait: false,
+    }),
+    { kind: 'skip' },
+  );
+});
+
 test('planPostResolutionTargetVerification: a selector wait with a recorded-unverifiable annotation refuses up front', () => {
   assert.deepEqual(
     planPostResolutionTargetVerification({
 
@@ -10,6 +10,7 @@ export type WaitCommandTarget =
       text?: never;
       ref?: never;
       selector?: never;
+      absent?: never;
       stable?: never;
       quietMs?: never;
       timeoutMs?: never;
@@ -19,6 +20,7 @@ export type WaitCommandTarget =
       durationMs?: never;
       ref?: never;
       selector?: never;
+      absent?: never;
       stable?: never;
       quietMs?: never;
       timeoutMs?: number;
@@ -28,6 +30,7 @@ export type WaitCommandTarget =
       durationMs?: never;
       text?: never;
       selector?: never;
+      absent?: never;
       stable?: never;
       quietMs?: never;
       timeoutMs?: number;
@@ -37,6 +40,17 @@ export type WaitCommandTarget =
       durationMs?: never;
       text?: never;
       ref?: never;
+      absent?: never;
+      stable?: never;
+      quietMs?: never;
+      timeoutMs?: number;
+    })
+  | (SelectorSnapshotCommandOptions & {
+      absent: string;
+      durationMs?: never;
+      text?: never;
+      ref?: never;
+      selector?: never;
       stable?: never;
       quietMs?: never;
       timeoutMs?: number;
@@ -47,6 +61,7 @@ export type WaitCommandTarget =
       text?: never;
       ref?: never;
       selector?: never;
+      absent?: never;
       quietMs?: number;
       timeoutMs?: number;
     });
 
@@ -1,5 +1,5 @@
 /** The normalized wait target, independent of the positional grammar that produced it. */
-export type WaitRuntimeTarget = 'sleep' | 'text' | 'ref' | 'selector' | 'stable';
+export type WaitRuntimeTarget = 'sleep' | 'text' | 'ref' | 'selector' | 'absent' | 'stable';
 
 /**
  * Which wait shapes reach a device at all. A duration wait observes nothing, so it never asks
 
@@ -6,15 +6,17 @@
  * `wait_capture_stalled` means no readable capture established an observation
  * before the deadline and is retriable. `wait_deadline_exceeded` means a later
  * capture consumed the remaining budget after at least one readable capture.
- * `wait_target_absent` is the only ordinary absence verdict and therefore
- * always carries readable-capture evidence. The remaining reasons describe
+ * `wait_target_absent` is the ordinary timeout reason for a selector that was
+ * never found. `wait_target_present` is the strict-absence timeout reason when
+ * valid captures still contain matches. The remaining reasons describe
  * stability and replay-landmark refusals.
  */
 export const WAIT_REASONS = {
   captureStalled: 'wait_capture_stalled',
   deadlineExceeded: 'wait_deadline_exceeded',
   runnerRestartExhausted: 'wait_runner_restart_exhausted',
   targetAbsent: 'wait_target_absent',
+  targetPresent: 'wait_target_present',
   stableTimeout: 'wait_stable_timeout',
   landmarkIdentityMismatch: 'wait_landmark_identity_mismatch',
 } as const;
 
@@ -40,6 +40,23 @@ test('keeps compound selectors that include label as hard export errors', () =>
   ).toThrow(AppError);
 });
 
+test('does not export strict wait absent as Maestro notVisible', () => {
+  let thrown: unknown;
+  try {
+    exportReplayActionsToMaestro([action('wait', ['absent', 'label="Removed"', '1000'])], {
+      resolveSelector: (expression) =>
+        projectSelectorExpression(expression, MAESTRO_SELECTOR_PROJECTION),
+    });
+  } catch (error) {
+    thrown = error;
+  }
+
+  expect(thrown).toBeInstanceOf(AppError);
+  if (!(thrown instanceof AppError)) return;
+  expect(thrown.message).toMatch(/unsupported|strict absence/i);
+  expect(thrown.message).not.toMatch(/notVisible/i);
+});
+
 function action(command: string, positionals: string[]): SessionAction {
   return { ts: 0, command, positionals, flags: {} };
 }
@@ -322,6 +322,12 @@ function convertWaitAction(
       ],
     };
   }
+  if (first === 'absent') {
+    return {
+      kind: 'unsupported',
+      message: 'strict wait absent requires zero selector matches and is unsupported by Maestro',
+    };
+  }
   if (first === 'text' && second) {
     return {
       kind: 'commands',
 
@@ -411,7 +411,11 @@ export const HUB_BUDGETS: Readonly<Record<string, number>> = Object.freeze({
   // #2148 moves output-only CLI dependencies behind call-time imports and reduces the entry
   // closure by two modules.
   // #2146 splits one eagerly reached URL utility into its client and Metro owners.
-  'src/cli.ts': 380,
+  // #2236 adds the typed pre-admission --scope/--depth refusal for `wait absent` to the existing
+  // wait command reader. That deliberately keeps the shared absence option contract and error
+  // modules on the CLI path; the measured two-module growth is the contract being loaded, not
+  // implementation or platform machinery being pulled in eagerly.
+  'src/cli.ts': 382,
   'src/platform-runtime.ts': 47,
   'src/core/command-descriptor/registry.ts': 72,
   'src/core/command-descriptor/platform-execution-entry.ts': 3,
 
@@ -0,0 +1,23 @@
+import assert from 'node:assert/strict';
+import { test } from 'vitest';
+import { createAgentDeviceClient } from '../agent-device-client.ts';
+import { createTransport } from './client-transport-fixture.ts';
+
+test('client.command.wait round-trips strict wait absent positionals', async () => {
+  const setup = createTransport(async () => ({ ok: true, data: { waitedMs: 0 } }));
+  const client = createAgentDeviceClient(setup.config, { transport: setup.transport });
+
+  await client.command.wait({ absent: 'label="Removed"', timeoutMs: 2500 });
+
+  assert.equal(setup.calls[0]?.command, 'wait');
+  assert.deepEqual(setup.calls[0]?.positionals, ['absent', 'label="Removed"', '2500']);
+
+  await assert.rejects(
+    async () => await client.command.wait({ absent: 'label="Removed"', depth: 2 }),
+    /wait absent does not support --depth/,
+  );
+  await assert.rejects(
+    async () => await client.command.wait({ absent: 'label="Removed"', scope: 'Root' }),
+    /wait absent does not support --scope/,
+  );
+});