From f5a90cdda9b429b72d9ef9b1429211a114ef71ab Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Fri, 6 Nov 2026 14:47:43 -0800
Subject: [PATCH 1/6] WDIO descriptor and desktopIt helper

---
 .changeset/input-lanes.md                     |   6 +
 .../desktop-driver/src/authoring/index.ts     |   9 +
 .../src/authoring/input.test.ts               |  32 +++
 .../desktop-driver/src/authoring/input.ts     | 167 +++++++++++++++
 .../hosts/native/NativeDesktopHost.test.ts    |  14 ++
 .../src/hosts/native/NativeDesktopHost.ts     |  12 +-
 packages/agentic/desktop-driver/src/index.ts  |   9 +
 .../agentic/desktop-driver/src/storybook.ts   |   8 +-
 .../config/transform-story-tests.cjs          |  83 ++++++++
 .../config/transform-story-tests.d.cts        |   3 +-
 .../storybook-desktop/references/commands.md  |   8 +
 .../references/story-tests.md                 |  45 +++-
 .../src/cli/DesktopStorybookCli.ts            |  96 +++++++--
 .../src/cli/createDesktopStorybookCommand.ts  |  17 +-
 .../storybook-desktop/src/cli/smokeTests.ts   |   4 +-
 .../storybook-desktop/src/config/commands.ts  |   1 +
 .../src/config/transformStoryTests.test.ts    |  10 +
 .../storybook-desktop/src/config/wdio.test.ts |  16 ++
 .../storybook-desktop/src/config/wdio.ts      |  23 +-
 .../src/driver/driverManifest.ts              |   4 +-
 .../src/driver/storyManifest.ts               |  12 +-
 .../src/testing/desktopIt.ts                  |  11 +
 .../src/testing/extractWdioTests.test.ts      |  31 +++
 .../src/testing/extractWdioTests.ts           |   7 +-
 .../storybook-desktop/src/testing/index.ts    |   3 +-
 .../src/testing/runWdioTests.test.ts          |  68 ++++++
 .../src/testing/runWdioTests.ts               | 197 +++++++++++++++---
 .../storybook-desktop/src/testing/types.ts    |   5 +-
 .../src/testing/wdio.types.test.ts            |  14 +-
 29 files changed, 844 insertions(+), 71 deletions(-)
 create mode 100644 .changeset/input-lanes.md
 create mode 100644 packages/agentic/desktop-driver/src/authoring/input.test.ts
 create mode 100644 packages/agentic/desktop-driver/src/authoring/input.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/desktopIt.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts

diff --git a/.changeset/input-lanes.md b/.changeset/input-lanes.md
new file mode 100644
index 0000000000..4c06b6b268
--- /dev/null
+++ b/.changeset/input-lanes.md
@@ -0,0 +1,6 @@
+---
+'@fluentui-react-native/desktop-driver': patch
+'@fluentui-react-native/storybook-desktop': patch
+---
+
+Add modality-aware desktop test descriptors and Storybook input-lane selection.
diff --git a/packages/agentic/desktop-driver/src/authoring/index.ts b/packages/agentic/desktop-driver/src/authoring/index.ts
index abc515c0d9..0fd5cd6695 100644
--- a/packages/agentic/desktop-driver/src/authoring/index.ts
+++ b/packages/agentic/desktop-driver/src/authoring/index.ts
@@ -14,6 +14,15 @@ export {
   desktopStoryPlatforms,
   validateDesktopStoryTests,
 } from './storyTests.js';
+export { desktopRequirements, matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './input.js';
+export type {
+  DesktopCaseOptions,
+  DesktopInput,
+  DesktopInputLane,
+  DesktopPlatforms,
+  DesktopRequirement,
+  ResolvedDesktopCaseOptions,
+} from './input.js';
 export type {
   DesktopStoryCapability,
   DesktopStoryExpectation,
diff --git a/packages/agentic/desktop-driver/src/authoring/input.test.ts b/packages/agentic/desktop-driver/src/authoring/input.test.ts
new file mode 100644
index 0000000000..1c02abba19
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/authoring/input.test.ts
@@ -0,0 +1,32 @@
+import { matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './input.js';
+
+describe('desktop input descriptors', () => {
+  test.each([
+    [undefined, [], 'both'],
+    [undefined, ['click'], 'both'],
+    [undefined, ['physical-click'], 'physical'],
+    [undefined, ['accessibility-click'], 'accessible'],
+    ['accessible', [], 'accessible'],
+    ['physical', ['click'], 'physical'],
+  ] as const)('derives input from %s and %s', (input, requires, expected) => {
+    expect(resolveDesktopInput(input, requires)).toBe(expected);
+  });
+
+  test('rejects mixed transports and explicit widening', () => {
+    expect(() => resolveDesktopInput(undefined, ['keyboard', 'accessibility-click'])).toThrow('split the case');
+    expect(() => resolveDesktopInput('both', ['physical-click'])).toThrow('cannot widen');
+    expect(() => resolveDesktopInput('physical', ['accessibility-click'])).toThrow('cannot widen');
+  });
+
+  test('validates platform filters and negation', () => {
+    expect(matchesDesktopPlatforms(['!win32'], 'windows')).toBe(true);
+    expect(matchesDesktopPlatforms(['!win32'], 'win32')).toBe(false);
+    expect(() => validateDesktopCaseOptions({ platforms: ['macos', '!win32'] })).toThrow('known');
+    expect(() => validateDesktopCaseOptions({ platforms: ['!macos', '!windows', '!win32'] })).toThrow('every platform');
+  });
+
+  test('rejects duplicate and unknown requirements', () => {
+    expect(() => validateDesktopCaseOptions({ requires: ['click', 'click'] })).toThrow('duplicate');
+    expect(() => validateDesktopCaseOptions({ requires: ['input'] })).toThrow('unsupported requirement');
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/authoring/input.ts b/packages/agentic/desktop-driver/src/authoring/input.ts
new file mode 100644
index 0000000000..ee0e353c51
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/authoring/input.ts
@@ -0,0 +1,167 @@
+import type { DesktopEndpoint } from '../protocol/types.js';
+
+export const desktopRequirements = [
+  'accessibility-actions',
+  'accessibility-click',
+  'click',
+  'element-screenshot',
+  'focus',
+  'keyboard',
+  'physical-click',
+  'screenshot',
+  'set-window-rect',
+  'wheel',
+] as const;
+
+export type DesktopRequirement = (typeof desktopRequirements)[number];
+export type DesktopInput = 'accessible' | 'physical' | 'both';
+export type DesktopInputLane = Exclude<DesktopInput, 'both'>;
+export type DesktopPlatforms =
+  | readonly [DesktopEndpoint, ...DesktopEndpoint[]]
+  | readonly [`!${DesktopEndpoint}`, ...`!${DesktopEndpoint}`[]];
+
+export type DesktopCaseOptions = {
+  input?: DesktopInput;
+  requires?: readonly DesktopRequirement[];
+  platforms?: DesktopPlatforms;
+  scope?: Readonly<Record<string, readonly [string, ...string[]]>>;
+  unsupported?: { platforms: DesktopPlatforms; reason: string; issue?: string };
+  quarantine?: {
+    issue: string;
+    reason: string;
+    expires: string;
+    platforms?: DesktopPlatforms;
+    input?: DesktopInputLane;
+  };
+};
+
+export type ResolvedDesktopCaseOptions = DesktopCaseOptions & {
+  input: DesktopInput;
+  inputSource: 'declared' | 'derived';
+};
+
+const physicalRequirements = new Set<DesktopRequirement>(['physical-click', 'keyboard', 'wheel']);
+const accessibleRequirements = new Set<DesktopRequirement>(['accessibility-click']);
+const endpoints = ['macos', 'windows', 'win32'] as const;
+const requirementSet = new Set<string>(desktopRequirements);
+
+export function resolveDesktopInput(input?: DesktopInput, requires: readonly DesktopRequirement[] = []): DesktopInput {
+  const physical = requires.some((requirement) => physicalRequirements.has(requirement));
+  const accessible = requires.some((requirement) => accessibleRequirements.has(requirement));
+  if (physical && accessible) {
+    throw new TypeError('A desktop test cannot require both physical and accessible input; split the case.');
+  }
+  const derived = physical ? 'physical' : accessible ? 'accessible' : 'both';
+  if (input !== undefined && derived !== 'both' && input !== derived) {
+    throw new TypeError(`input "${input}" cannot widen the modality derived from requires ("${derived}").`);
+  }
+  return input ?? derived;
+}
+
+export function validateDesktopCaseOptions(value: unknown, source = 'desktop test options'): ResolvedDesktopCaseOptions {
+  const options = object(value, source);
+  exactKeys(options, ['input', 'requires', 'platforms', 'scope', 'unsupported', 'quarantine'], source);
+  if (options.input !== undefined && !['accessible', 'physical', 'both'].includes(options.input as string)) {
+    throw new TypeError(`${source}.input must be accessible, physical, or both.`);
+  }
+  const requires: DesktopRequirement[] = [];
+  if (options.requires !== undefined) {
+    if (!Array.isArray(options.requires)) throw new TypeError(`${source}.requires must be an array.`);
+    const seen = new Set<string>();
+    for (const requirement of options.requires) {
+      if (typeof requirement !== 'string' || !requirementSet.has(requirement)) {
+        throw new TypeError(`${source}.requires contains an unsupported requirement.`);
+      }
+      if (seen.has(requirement)) throw new TypeError(`${source}.requires contains duplicate "${requirement}".`);
+      seen.add(requirement);
+      requires.push(requirement as DesktopRequirement);
+    }
+  }
+  validatePlatforms(options.platforms, `${source}.platforms`);
+  validateScope(options.scope, `${source}.scope`);
+  if (options.unsupported !== undefined) {
+    const unsupported = object(options.unsupported, `${source}.unsupported`);
+    exactKeys(unsupported, ['platforms', 'reason', 'issue'], `${source}.unsupported`);
+    validatePlatforms(unsupported.platforms, `${source}.unsupported.platforms`, true);
+    nonEmptyString(unsupported.reason, `${source}.unsupported.reason`);
+    if (unsupported.issue !== undefined) nonEmptyString(unsupported.issue, `${source}.unsupported.issue`);
+  }
+  if (options.quarantine !== undefined) {
+    const quarantine = object(options.quarantine, `${source}.quarantine`);
+    exactKeys(quarantine, ['issue', 'reason', 'expires', 'platforms', 'input'], `${source}.quarantine`);
+    nonEmptyString(quarantine.issue, `${source}.quarantine.issue`);
+    nonEmptyString(quarantine.reason, `${source}.quarantine.reason`);
+    if (typeof quarantine.expires !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(quarantine.expires)) {
+      throw new TypeError(`${source}.quarantine.expires must be an ISO date.`);
+    }
+    if (quarantine.input !== undefined && !['accessible', 'physical'].includes(quarantine.input as string)) {
+      throw new TypeError(`${source}.quarantine.input must be accessible or physical.`);
+    }
+    validatePlatforms(quarantine.platforms, `${source}.quarantine.platforms`);
+  }
+  const resolvedInput = resolveDesktopInput(options.input as DesktopInput | undefined, requires);
+  return {
+    ...(options.input === undefined ? {} : { input: options.input as DesktopInput }),
+    ...(options.requires === undefined ? {} : { requires }),
+    ...(options.platforms === undefined ? {} : { platforms: options.platforms as DesktopPlatforms }),
+    ...(options.scope === undefined ? {} : { scope: options.scope as DesktopCaseOptions['scope'] }),
+    ...(options.unsupported === undefined ? {} : { unsupported: options.unsupported as DesktopCaseOptions['unsupported'] }),
+    ...(options.quarantine === undefined ? {} : { quarantine: options.quarantine as DesktopCaseOptions['quarantine'] }),
+    input: resolvedInput,
+    inputSource: options.input === undefined ? 'derived' : 'declared',
+  };
+}
+
+export function matchesDesktopPlatforms(platforms: DesktopPlatforms | undefined, endpoint: DesktopEndpoint): boolean {
+  if (platforms === undefined) return true;
+  const negative = platforms[0].startsWith('!');
+  const values = platforms.map((platform) => (negative ? platform.slice(1) : platform));
+  return negative ? !values.includes(endpoint) : values.includes(endpoint);
+}
+
+function validatePlatforms(value: unknown, source: string, required = false): void {
+  if (value === undefined && !required) return;
+  if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${source} must be a non-empty platform list.`);
+  const negative = typeof value[0] === 'string' && value[0].startsWith('!');
+  const seen = new Set<string>();
+  for (const entry of value) {
+    if (typeof entry !== 'string') throw new TypeError(`${source} contains an unsupported platform.`);
+    const platform = negative ? entry.slice(1) : entry;
+    if (entry.startsWith('!') !== negative || !endpoints.includes(platform as (typeof endpoints)[number])) {
+      throw new TypeError(`${source} must contain only known ${negative ? 'negated ' : ''}platforms.`);
+    }
+    if (seen.has(platform)) throw new TypeError(`${source} contains duplicate "${entry}".`);
+    seen.add(platform);
+  }
+  if (negative && seen.size === endpoints.length) throw new TypeError(`${source} cannot exclude every platform.`);
+}
+
+function validateScope(value: unknown, source: string): void {
+  if (value === undefined) return;
+  const scope = object(value, source);
+  for (const [key, values] of Object.entries(scope)) {
+    if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(key)) throw new TypeError(`${source} contains invalid key "${key}".`);
+    if (!Array.isArray(values) || values.length === 0) throw new TypeError(`${source}.${key} must be a non-empty value list.`);
+    const seen = new Set<string>();
+    for (const item of values) {
+      if (typeof item !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(item)) {
+        throw new TypeError(`${source}.${key} contains an invalid value.`);
+      }
+      if (seen.has(item)) throw new TypeError(`${source}.${key} contains duplicate "${item}".`);
+      seen.add(item);
+    }
+  }
+}
+
+function object(value: unknown, source: string): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError(`${source} must be an object.`);
+  return value as Record<string, unknown>;
+}
+
+function exactKeys(value: Record<string, unknown>, allowed: readonly string[], source: string): void {
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new TypeError(`${source} contains unknown field "${key}".`);
+}
+
+function nonEmptyString(value: unknown, source: string): void {
+  if (typeof value !== 'string' || !value.trim()) throw new TypeError(`${source} must be a non-empty string.`);
+}
diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.test.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.test.ts
index ddcf1c77c9..710571be26 100644
--- a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.test.ts
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.test.ts
@@ -8,6 +8,7 @@ import {
   FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES,
   NativeDesktopHost,
   parseKeyedActions,
+  resolveDisabledInputFeatures,
   translateNativeError,
 } from './NativeDesktopHost';
 
@@ -20,6 +21,19 @@ describe('NativeDesktopHost accessibility action keys', () => {
     expect(parseKeyedActions({ actions: [], keys: [] })).toEqual([]);
   });
 
+  describe('NativeDesktopHost input feature policy', () => {
+    test('unions explicit masks with the operator environment mask', () => {
+      const previous = process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES];
+      process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES] = 'physicalClick,wheel';
+      try {
+        expect([...resolveDisabledInputFeatures(['keyboard'])].sort()).toEqual(['keyboard', 'physicalClick', 'wheel']);
+      } finally {
+        if (previous === undefined) delete process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES];
+        else process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES] = previous;
+      }
+    });
+  });
+
   test.each([
     ['no keys', { actions: ['AXPress'] }],
     ['lists of different lengths', { actions: ['AXPress', 'Toggle'], keys: ['k1'] }],
diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
index 8bd1da92d2..4c33f0aeb4 100644
--- a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
@@ -497,14 +497,14 @@ export function applyDisabledInputFeaturePolicy(
   return { ...hostInfo, features };
 }
 
-function resolveDisabledInputFeatures(configured?: readonly NativeDisabledInputFeature[]): ReadonlySet<NativeDisabledInputFeature> {
-  const values =
-    configured ??
-    process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES]
+export function resolveDisabledInputFeatures(configured?: readonly NativeDisabledInputFeature[]): ReadonlySet<NativeDisabledInputFeature> {
+  const values = [
+    ...(configured ?? []),
+    ...(process.env[FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES]
       ?.split(',')
       .map((value) => value.trim())
-      .filter(Boolean) ??
-    [];
+      .filter(Boolean) ?? []),
+  ];
   const allowed = new Set<NativeDisabledInputFeature>(['keyboard', 'physicalClick', 'wheel']);
   const resolved = new Set<NativeDisabledInputFeature>();
   for (const value of values) {
diff --git a/packages/agentic/desktop-driver/src/index.ts b/packages/agentic/desktop-driver/src/index.ts
index 5c66f111c9..3e556374bc 100644
--- a/packages/agentic/desktop-driver/src/index.ts
+++ b/packages/agentic/desktop-driver/src/index.ts
@@ -32,6 +32,15 @@ export {
   desktopStoryPlatforms,
   validateDesktopStoryTests,
 } from './authoring/storyTests.js';
+export { desktopRequirements, matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './authoring/input.js';
+export type {
+  DesktopCaseOptions,
+  DesktopInput,
+  DesktopInputLane,
+  DesktopPlatforms,
+  DesktopRequirement,
+  ResolvedDesktopCaseOptions,
+} from './authoring/input.js';
 export type {
   DesktopStoryCapability,
   DesktopStoryExpectation,
diff --git a/packages/agentic/desktop-driver/src/storybook.ts b/packages/agentic/desktop-driver/src/storybook.ts
index 4946ad486e..9aa50d9d49 100644
--- a/packages/agentic/desktop-driver/src/storybook.ts
+++ b/packages/agentic/desktop-driver/src/storybook.ts
@@ -1,4 +1,5 @@
 import type { DesktopStoryTests } from './authoring/storyTests.js';
+import type { ResolvedDesktopCaseOptions } from './authoring/input.js';
 import type { DesktopEndpoint } from './protocol/types.js';
 
 export type DesktopStoryManifestEntry = {
@@ -9,7 +10,12 @@ export type DesktopStoryManifestEntry = {
   tags: readonly string[];
   title: string;
   tests?: DesktopStoryTests;
-  wdio?: { digest: string; exportName: string; testNames?: readonly string[] };
+  wdio?: {
+    digest: string;
+    exportName: string;
+    testNames?: readonly string[];
+    cases?: readonly { name: string; options: ResolvedDesktopCaseOptions }[];
+  };
 };
 
 export type DesktopStoryManifest = {
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
index aac57cf91a..bc47137db0 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -57,6 +57,55 @@ function resolveInitializer(value, seen = new Set(), bindings = new Set()) {
   return value;
 }
 
+function importedDesktopIt(call) {
+  const callee = call.get('callee');
+  if (!callee.isIdentifier()) fail(call, 'array tests must be direct desktopIt imports.');
+  const binding = callee.scope.getBinding(callee.node.name);
+  const specifier = binding?.path;
+  const declaration = specifier?.parentPath;
+  if (
+    !specifier?.isImportSpecifier() ||
+    (specifier.node.imported.name ?? specifier.node.imported.value) !== 'desktopIt' ||
+    !declaration?.isImportDeclaration() ||
+    declaration.node.source.value !== '@fluentui-react-native/storybook-desktop/testing' ||
+    declaration.node.importKind === 'type' ||
+    specifier.node.importKind === 'type'
+  ) {
+    fail(call, 'array tests must use the desktopIt value imported from @fluentui-react-native/storybook-desktop/testing.');
+  }
+}
+
+function staticValue(value) {
+  value = unwrap(value);
+  if (value.isStringLiteral() || value.isBooleanLiteral() || value.isNullLiteral()) return value.node.value;
+  if (value.isNumericLiteral() && Number.isFinite(value.node.value)) return value.node.value;
+  if (value.isTemplateLiteral() && value.node.expressions.length === 0 && value.node.quasis.length === 1) {
+    return value.node.quasis[0].value.cooked;
+  }
+  if (value.isUnaryExpression({ operator: '-' }) && value.get('argument').isNumericLiteral()) {
+    return -value.node.argument.value;
+  }
+  if (value.isArrayExpression()) {
+    return value.get('elements').map((element) => {
+      if (!element?.node || element.isSpreadElement()) fail(element ?? value, 'descriptor arrays must contain static values.');
+      return staticValue(element);
+    });
+  }
+  if (value.isObjectExpression()) {
+    const result = {};
+    for (const property of value.get('properties')) {
+      if (!property.isObjectProperty() || property.node.computed || property.node.shorthand) {
+        fail(property, 'descriptor objects require static key/value properties.');
+      }
+      const key = keyName(property);
+      if (!key || Object.hasOwn(result, key)) fail(property, 'descriptor objects require unique static property names.');
+      result[key] = staticValue(property.get('value'));
+    }
+    return result;
+  }
+  fail(value, 'descriptor options must be a strict JSON literal.');
+}
+
 function collectCallbacks(value) {
   const requireCallback = (callback) => {
     if ((!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) || callback.node.generator) {
@@ -64,6 +113,29 @@ function collectCallbacks(value) {
     }
     return callback;
   };
+  if (value.isArrayExpression()) {
+    const callbacks = [];
+    const names = new Set();
+    for (const item of value.get('elements')) {
+      if (!item?.node || item.isSpreadElement() || !item.isCallExpression()) {
+        fail(item ?? value, 'desktopIt arrays require direct calls and cannot contain holes or spreads.');
+      }
+      importedDesktopIt(item);
+      const args = item.get('arguments');
+      if (args.length < 2 || args.length > 3 || args.some((argument) => argument.isSpreadElement())) {
+        fail(item, 'desktopIt requires a name, optional static options, and an inline callback.');
+      }
+      const name = args[0].isStringLiteral() ? args[0].node.value : undefined;
+      if (!name?.trim()) fail(args[0], 'desktopIt requires a non-empty literal test name.');
+      if (names.has(name)) fail(args[0], `duplicate test name "${name}".`);
+      names.add(name);
+      const options = args.length === 2 ? {} : staticValue(args[1]);
+      if (!options || typeof options !== 'object' || Array.isArray(options)) fail(args[1], 'desktopIt options must be an object.');
+      callbacks.push({ name, options, callback: requireCallback(unwrap(args[args.length - 1])) });
+    }
+    if (!callbacks.length) fail(value, 'a desktopIt array must contain at least one test.');
+    return callbacks;
+  }
   if (!value.isObjectExpression()) return [{ callback: requireCallback(value) }];
   const callbacks = [];
   const names = new Set();
@@ -276,6 +348,17 @@ module.exports = () => ({
         for (const { callback } of callbacks) compileWdioTest(callback, filename, state.file.code);
       }
       for (const { property } of tests.values()) if (!property.removed) property.remove();
+      program.scope.crawl();
+      for (const statement of program.get('body')) {
+        if (!statement.isImportDeclaration() || statement.node.source.value !== '@fluentui-react-native/storybook-desktop/testing')
+          continue;
+        for (const specifier of statement.get('specifiers')) {
+          if (!specifier.isImportSpecifier() || (specifier.node.imported.name ?? specifier.node.imported.value) !== 'desktopIt') continue;
+          const binding = statement.scope.getBinding(specifier.node.local.name);
+          if (!binding?.referencePaths.length) specifier.remove();
+        }
+        if (!statement.node.specifiers.length) statement.remove();
+      }
     },
   },
 });
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
index 8444ed0b64..67e6ed935c 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -5,12 +5,13 @@ declare function storyTests(): PluginObj;
 declare namespace storyTests {
   type Callback = {
     name?: string;
+    options?: Record<string, unknown>;
     callback: NodePath<types.FunctionExpression | types.ArrowFunctionExpression>;
   };
   type StoryTest = {
     callbacks: readonly Callback[];
     property: NodePath<types.ObjectProperty>;
-    value: NodePath<types.FunctionExpression | types.ArrowFunctionExpression | types.ObjectExpression>;
+    value: NodePath<types.FunctionExpression | types.ArrowFunctionExpression | types.ObjectExpression | types.ArrayExpression>;
   };
 
   function collectWdioTests(program: NodePath<types.Program>): ReadonlyMap<string, StoryTest>;
diff --git a/packages/agentic/storybook-desktop/references/commands.md b/packages/agentic/storybook-desktop/references/commands.md
index 27e2975392..f60208c21c 100644
--- a/packages/agentic/storybook-desktop/references/commands.md
+++ b/packages/agentic/storybook-desktop/references/commands.md
@@ -28,6 +28,7 @@ only). The mode precedence is CLI flag, `DESKTOP_REPORTER`, config, then
 | `instance --<platform>`                       | Inspect the active instance's ports and target      |
 | `test --<platform> --list`                    | Discover authored executable story-test IDs         |
 | `test --<platform> --test <glob>`             | Run matching isolated story callbacks               |
+| `test --<platform> --input accessible`        | Select accessible and `both` descriptor cases       |
 | `smoke --<platform> --mode stories`           | Build/bundle/launch, traverse stories, clean up     |
 | `smoke --<platform> --mode stories-and-tests` | Traverse stories and execute callbacks              |
 
@@ -60,6 +61,13 @@ Metro, generated runtime identity, and exact process cleanup. Windows RN Test
 App retains its required Metro port 8081; do not run concurrent Metro-backed
 Windows smokes.
 
+Storybook test and stories-and-tests smoke commands accept
+`--input accessible|physical`. The lane filters `desktopIt` cases by their
+resolved input and target platform. `driver --input` records the default lane
+for subsequent tests against that instance. Legacy callback collections are
+not eligible for input-lane runs. Input lanes cannot be combined with an
+explicit non-`auto` click mode.
+
 The TypeScript API exposes the same operations through `DesktopStorybookCli`.
 Higher-level supervisors should inject their shared reporter, runner, and
 services so runs join one owned lifecycle.
diff --git a/packages/agentic/storybook-desktop/references/story-tests.md b/packages/agentic/storybook-desktop/references/story-tests.md
index 1fd21d7e2e..62662edbbd 100644
--- a/packages/agentic/storybook-desktop/references/story-tests.md
+++ b/packages/agentic/storybook-desktop/references/story-tests.md
@@ -7,11 +7,12 @@ owner_paths:
 
 # Author story tests
 
-Story tests are statically extracted CSF `wdio` callbacks. Use top-level
-functions or named callback collections with literal names; callbacks must not
-close over module-local values. Import Node-only helpers through literal
-dynamic `import()` inside the callback. Keep test code out of the native
-bundle.
+Story tests are statically extracted CSF `wdio` callbacks. Use `desktopIt`
+descriptors when declaring input requirements or endpoint scope. Top-level
+functions or named callback collections remain supported for compatibility,
+but cannot be selected by an input lane. Callbacks must not close over
+module-local values. Import Node-only helpers through literal dynamic
+`import()` inside the callback. Keep test code out of the native bundle.
 
 ```tsx
 import type { StoryObj } from '@storybook/react-native';
@@ -37,6 +38,33 @@ export const Default: Story = {
 };
 ```
 
+For modality-aware tests, import the value helper and use an array of cases:
+
+```tsx
+import { desktopIt, type WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
+
+export const Default: WdioStory<StoryObj<typeof Button>> = {
+  args: { testID: 'save-button' },
+  wdio: [
+    desktopIt('activates in either input lane', { requires: ['click'] }, async ({ browser, expect }) => {
+      await (await browser.$('~save-button')).click();
+      await expect(await browser.$('~saved-message')).toBeDisplayed();
+    }),
+    desktopIt('uses a physical pointer', { requires: ['physical-click'], platforms: ['win32'] }, async ({ browser }) => {
+      await (await browser.$('~save-button')).click();
+    }),
+  ],
+};
+```
+
+`requires: ['click']` derives to `both` and adapts `element.click()` to the
+selected lane: accessibility click in the accessible lane and physical click
+in the physical lane. Explicit physical or accessibility requirements derive
+their matching lane. `input` may narrow a `both` case but cannot widen a
+transport-specific requirement. `platforms` is an allowlist by default;
+`['!win32']` excludes that endpoint. Platform selection uses the target
+endpoint, so Win32 remains distinct from Windows.
+
 The callback receives the real WebdriverIO `browser`, `expect-webdriverio`
 `expect`, typed `desktop` assertions/story commands, target `platform` (`macos`,
 `windows`, or `win32`), cooperative `signal`, and explicit `skip(reason)`.
@@ -73,6 +101,13 @@ editing callbacks because their digest participates in manifest freshness.
 filters names. `test` operates against an already running app/driver; smoke
 owns the complete app lifecycle.
 
+Use `storybook test --input accessible|physical` or
+`storybook smoke --mode stories-and-tests --input accessible|physical` to
+select declared cases. `storybook driver --input ...` supplies the default
+lane to a later `storybook test` invocation. `--input` cannot be combined
+with a non-default `--click-mode`. A lane requires descriptor cases and rejects
+legacy callback collections rather than silently treating them as `both`.
+
 Use the component authoring contract for component-specific test assertions.
 Legacy `parameters.desktopDriver` static plans remain for compatibility and
 are not the preferred story-test authoring API.
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
index 5a199c7cda..ad62fc01bf 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
@@ -48,6 +48,7 @@ import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopComman
 import { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } from './smokeTests.js';
 import { matchesWdioTest, runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
 import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
+import { matchesDesktopPlatforms } from '@fluentui-react-native/desktop-driver/authoring';
 
 type ResolvedDesktopStorybookInstance = DesktopStorybookInstance & {
   driverManifestPath?: string;
@@ -92,6 +93,7 @@ export type DesktopStorybookServerOptions = {
 };
 
 export type DesktopStorybookDriverOptions = DesktopStorybookServerOptions & {
+  input?: 'accessible' | 'physical';
   /**
    * Protects the driver with a grant authority and publishes one agent's connection descriptor, which the Desktop
    * Driver MCP adapter reads. WDIO `storybook test` cannot connect to an agent-served driver.
@@ -219,6 +221,7 @@ export class DesktopStorybookCli {
   async driver(platform: Platforms, options: DesktopStorybookDriverOptions = {}): Promise<void> {
     validateServerOptions(options);
     validateDriverHost(options.host);
+    const wdio = resolveWdioOptions({ ...this.config.wdio, ...(options.input ? { input: options.input } : {}) });
     const agent = options.agent && {
       descriptor: options.agent.descriptor ?? defaultAgentDescriptor,
       // The channel service runs in another working directory.
@@ -244,6 +247,7 @@ export class DesktopStorybookCli {
       resolvedInstance,
       nativeDriver,
       agent && { ...agent, ...(agentApplication ? { application: agentApplication } : {}) },
+      wdio,
     );
     resolvedInstance.driverManifestPath = driverManifest.path;
     this.services.start('metro', this.prepareCommand(defaultMetroCommand(resolvedInstance), platform, resolvedInstance));
@@ -329,16 +333,26 @@ export class DesktopStorybookCli {
   }
 
   async test(platform: Platforms, options: DesktopStorybookTestOptions = {}): Promise<void> {
-    const settings = resolveWdioOptions({
+    const overrides: DesktopStorybookWdioOptions = {
+      ...(options.clickMode === undefined ? {} : { clickMode: options.clickMode }),
+      ...(options.input === undefined ? {} : { input: options.input }),
+      ...(options.testReporter === undefined ? {} : { reporter: options.testReporter }),
+      ...(options.story === undefined ? {} : { story: options.story }),
+      ...(options.tag === undefined ? {} : { tag: options.tag }),
+      ...(options.test === undefined ? {} : { test: options.test }),
+      ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+    };
+    const initialSettings = resolveWdioOptions({
       ...this.config.wdio,
-      ...Object.fromEntries(
-        Object.entries({ ...options, reporter: options.testReporter }).filter(
-          ([key, value]) => key !== 'testReporter' && value !== undefined,
-        ),
-      ),
+      ...overrides,
     });
+    const connection = options.list ? undefined : this.testConnection(platform, options);
+    const settings =
+      connection?.input && initialSettings.input === undefined
+        ? resolveWdioOptions({ ...initialSettings, input: connection.input })
+        : initialSettings;
     const manifest = await this.createStoryManifest(this.config, platform);
-    const selected = selectWdioStories(manifest, settings);
+    const selected = selectWdioStories(manifest, settings, platform);
     if (selected.length === 0) {
       throw new Error('No executable wdio story tests matched the requested selection.');
     }
@@ -346,13 +360,32 @@ export class DesktopStorybookCli {
       const value = selected.map(({ id, sourcePath, wdio }) => ({
         id,
         sourcePath,
-        ...(wdio?.testNames ? { tests: wdio.testNames.filter((name) => matchesWdioTest(name, settings.test)) } : {}),
+        ...(wdio?.cases
+          ? {
+              tests: wdio.cases
+                .filter(
+                  ({ name, options: descriptor }) =>
+                    matchesWdioTest(name, settings.test) &&
+                    (!settings.input || descriptor.input === 'both' || descriptor.input === settings.input) &&
+                    matchesDesktopPlatforms(descriptor.platforms, platform),
+                )
+                .map(({ name, options: descriptor }) => ({
+                  name,
+                  input: descriptor.input,
+                  inputSource: descriptor.inputSource,
+                  requires: descriptor.requires ?? [],
+                  platforms: descriptor.platforms,
+                })),
+            }
+          : wdio?.testNames
+            ? { tests: wdio.testNames.filter((name) => matchesWdioTest(name, settings.test)) }
+            : {}),
       }));
       if (this.reporterMode === 'json' || this.reporterMode === 'ndjson') this.writeStructured(value);
       else this.output.write(`${JSON.stringify(value, null, 2)}\n`);
       return;
     }
-    const connection = this.testConnection(platform, options);
+    const activeConnection = connection ?? this.testConnection(platform, options);
     if (platform === 'macos' && !options.url) {
       await this.writeMacOSApplicationLease(
         path.join(this.config.projectRoot, 'storybook-desktop.generated', 'driver-manifest.macos.json'),
@@ -362,13 +395,14 @@ export class DesktopStorybookCli {
     const results = await runWdioStoryTests(
       {
         ...settings,
-        ...connection,
+        ...activeConnection,
         config: this.config,
         manifest,
         platform,
         errorOutput: this.errorOutput,
         report: this.reporter,
         signal: this.services.controller.signal,
+        input: settings.input,
       },
       this.runner,
     );
@@ -378,7 +412,10 @@ export class DesktopStorybookCli {
     );
   }
 
-  private testConnection(platform: Platforms, options: DesktopStorybookTestOptions): { targetId: string; url: string } {
+  private testConnection(
+    platform: Platforms,
+    options: DesktopStorybookTestOptions,
+  ): { input?: 'accessible' | 'physical'; targetId: string; url: string } {
     if (options.url || options.target) {
       if (!options.url || !options.target) {
         throw new Error('Pass --url and --target together, or omit both to use the running Storybook driver instance.');
@@ -415,7 +452,17 @@ export class DesktopStorybookCli {
         `The Storybook driver instance at ${manifestPath} serves an agent; restart storybook driver --${platform} without --agent to run storybook test.`,
       );
     }
-    return { targetId: manifest.targetId, url: loopbackUrl(manifest.driverPort) };
+    const input =
+      typeof manifest === 'object' &&
+      manifest !== null &&
+      'wdio' in manifest &&
+      typeof manifest.wdio === 'object' &&
+      manifest.wdio !== null &&
+      'input' in manifest.wdio &&
+      (manifest.wdio.input === 'accessible' || manifest.wdio.input === 'physical')
+        ? manifest.wdio.input
+        : undefined;
+    return { targetId: manifest.targetId, url: loopbackUrl(manifest.driverPort), ...(input ? { input } : {}) };
   }
 
   printInstance(platform: Platforms): void {
@@ -478,8 +525,15 @@ export class DesktopStorybookCli {
       throw unsupportedAction('smoke', platform);
     }
     if (smoke?.command) {
-      const instance = await this.resolveSmokeInstance(platform, smoke, mode);
-      await this.executePlan(withEnvironment(smoke.command, { [STORYBOOK_SMOKE_MODE]: mode }), platform, instance);
+      const instance = await this.resolveSmokeInstance(platform, smoke, mode, options.input);
+      await this.executePlan(
+        withEnvironment(smoke.command, {
+          [STORYBOOK_SMOKE_MODE]: mode,
+          ...(options.input ? { DESKTOP_INPUT: options.input } : {}),
+        }),
+        platform,
+        instance,
+      );
       return;
     }
     if (!smoke?.stop) {
@@ -488,8 +542,8 @@ export class DesktopStorybookCli {
       );
     }
 
-    const instance = await this.resolveSmokeInstance(platform, smoke, mode);
-    await this.runSmokeLifecycle(platform, smoke, instance, mode);
+    const instance = await this.resolveSmokeInstance(platform, smoke, mode, options.input);
+    await this.runSmokeLifecycle(platform, smoke, instance, mode, options.input);
   }
 
   private async executeAction(
@@ -509,6 +563,7 @@ export class DesktopStorybookCli {
     smoke: DesktopSmokeOptions,
     instance: ResolvedDesktopStorybookInstance,
     mode: DesktopSmokeMode,
+    input?: 'accessible' | 'physical',
   ): Promise<void> {
     const failures: unknown[] = [];
     let primaryFailure: unknown;
@@ -571,6 +626,7 @@ export class DesktopStorybookCli {
             targetId: this.targetId(platform),
             report: this.reporter,
             signal: this.services.controller.signal,
+            input,
           }),
         );
         this.output.write(`${formatDesktopStorybookSmokeTestSummary(result)}\n`);
@@ -624,6 +680,7 @@ export class DesktopStorybookCli {
     platform: Platforms,
     smoke: DesktopSmokeOptions,
     mode: DesktopSmokeMode,
+    input?: 'accessible' | 'physical',
   ): Promise<ResolvedDesktopStorybookInstance> {
     const storybookPort = smoke.serverUrl
       ? portFromUrl(smoke.serverUrl)
@@ -641,7 +698,10 @@ export class DesktopStorybookCli {
 
     if (mode === 'stories-and-tests') {
       const nativeDriver = await this.resolveDriver(platform);
-      resolvedInstance.driverManifestPath = (await this.writeDriverManifest(platform, resolvedInstance, nativeDriver)).path;
+      const wdio = resolveWdioOptions({ ...this.config.wdio, ...(input ? { input } : {}) });
+      resolvedInstance.driverManifestPath = (
+        await this.writeDriverManifest(platform, resolvedInstance, nativeDriver, undefined, wdio)
+      ).path;
     }
     if (platform === 'macos') {
       resolvedInstance.macosXcconfigPath = writeMacOSInstanceConfig(this.config.projectRoot, resolvedInstance);
@@ -659,6 +719,7 @@ export class DesktopStorybookCli {
     instance: DesktopStorybookInstance,
     nativeDriver: NativeDriverArtifact,
     agent?: CreateDesktopStorybookDriverManifestOptions['agent'],
+    wdio?: CreateDesktopStorybookDriverManifestOptions['wdio'],
   ): Promise<{ manifest: DesktopStorybookDriverManifest; path: string }> {
     const storyManifest = await this.createStoryManifest(this.config, platform);
     const outputPath = path.join(this.config.projectRoot, 'storybook-desktop.generated', `driver-manifest.${platform}.json`);
@@ -672,6 +733,7 @@ export class DesktopStorybookCli {
       platform,
       renderer,
       storyManifest,
+      ...(wdio ? { wdio } : {}),
     });
     writeDesktopStorybookDriverManifest(driverManifest, outputPath);
     return { manifest: driverManifest, path: outputPath };
diff --git a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
index 263ab8e307..f7552ff94f 100644
--- a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
+++ b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
@@ -36,9 +36,9 @@ type PlatformFlags = {
 };
 
 type ServerFlags = PlatformFlags & DesktopStorybookServerOptions;
-type DriverFlags = ServerFlags & { agent?: boolean; descriptor?: string; root?: string };
+type DriverFlags = ServerFlags & { agent?: boolean; descriptor?: string; root?: string; input?: 'accessible' | 'physical' };
 type ManifestFlags = PlatformFlags & { out?: string };
-type SmokeFlags = PlatformFlags & { mode: DesktopSmokeMode };
+type SmokeFlags = PlatformFlags & { mode: DesktopSmokeMode; input?: 'accessible' | 'physical' };
 type BuildDriverFlags = PlatformFlags & DesktopStorybookBuildDriverOptions;
 type PrepFlags = PlatformFlags & { driver: DesktopStorybookPrepOptions['driver'] };
 type GetApi = (flags: PlatformFlags) => Promise<DesktopStorybookCli>;
@@ -127,14 +127,19 @@ function addTestCommand(program: Command, getApi: GetApi): void {
     .option('--tag <tag>', 'filter story tags')
     .option('--url <url>', 'Desktop Driver URL (requires --target)')
     .option('--target <id>', 'registered target ID (requires --url)')
+    .addOption(new Option('--input <mode>', 'select accessible or physical input tests').choices(['accessible', 'physical']))
     .option('--timeout-ms <milliseconds>', 'timeout per executable test', Number)
     .addOption(new Option('--test-reporter <reporter>', 'Node test reporter').choices(['spec', 'tap', 'dot']))
     .addOption(new Option('--click-mode <mode>', 'native click semantics').choices(['auto', 'physical', 'accessibility']));
   addPlatformOptions(command);
   command.action(async (flags: PlatformFlags & DesktopStorybookTestOptions) => {
+    if (flags.input !== undefined && flags.clickMode !== undefined) {
+      throw new TypeError('--input cannot be combined with --click-mode.');
+    }
     const api = await getApi(flags);
     await api.test(resolvePlatform(flags, api), {
       clickMode: flags.clickMode,
+      input: flags.input,
       list: flags.list,
       testReporter: flags.testReporter,
       story: flags.story,
@@ -178,6 +183,7 @@ function addDriverCommand(program: Command, getApi: GetApi): void {
     .option('--agent', 'require a grant on every driver route and publish one agent connection descriptor')
     .option('--descriptor <name>', 'agent connection descriptor record name (default agent-connection.json)')
     .option('--root <path>', 'private storage root for the agent descriptor; defaults to the platform location');
+  command.addOption(new Option('--input <mode>', 'default input lane for Storybook tests').choices(['accessible', 'physical']));
   addPlatformOptions(command);
   command.action(async (flags: DriverFlags) => {
     if (!flags.agent && (flags.descriptor !== undefined || flags.root !== undefined)) {
@@ -187,6 +193,7 @@ function addDriverCommand(program: Command, getApi: GetApi): void {
     await api.driver(resolvePlatform(flags, api), {
       host: flags.host,
       port: flags.port,
+      input: flags.input,
       ...(flags.agent
         ? {
             agent: {
@@ -387,10 +394,14 @@ function addSmokeCommand(program: Command, getApi: GetApi): void {
         .choices([...desktopSmokeModes])
         .default('stories'),
     );
+  command.addOption(new Option('--input <mode>', 'select accessible or physical input tests').choices(['accessible', 'physical']));
   addPlatformOptions(command);
   command.action(async (flags: SmokeFlags) => {
+    if (flags.input !== undefined && flags.mode !== 'stories-and-tests') {
+      throw new TypeError('--input requires --mode stories-and-tests.');
+    }
     const api = await getApi(flags);
-    await api.smoke(resolvePlatform(flags, api), { mode: flags.mode });
+    await api.smoke(resolvePlatform(flags, api), { mode: flags.mode, input: flags.input });
   });
 }
 
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
index 2dcfb9a1f2..afa53f720f 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
@@ -21,6 +21,7 @@ type DesktopStorybookSmokeSession = Pick<DesktopWebdriverSession, 'delete' | 'li
 export type DesktopStorybookSmokeConnector = (options: DesktopWebdriverOptions) => Promise<DesktopStorybookSmokeSession>;
 
 export type DesktopStorybookSmokeTestOptions = {
+  input?: 'accessible' | 'physical';
   artifactsRoot?: string;
   config: DesktopStorybookConfig;
   driverUrl: string;
@@ -52,13 +53,14 @@ export async function runDesktopStorybookSmokeTests(
   const testTag = options.testTag ?? process.env.STORYBOOK_SMOKE_TAG;
   const wdioSettings = resolveWdioOptions({
     ...config.wdio,
+    ...(options.input ? { input: options.input } : {}),
     ...(storyPattern !== undefined ? { story: storyPattern } : {}),
     ...(testTag !== undefined ? { tag: testTag } : {}),
   });
   const planStoryIds = new Set(
     selectDesktopStoryTests(manifest, platform, { story: storyPattern, tag: testTag ?? 'desktop-e2e' }).map(({ entry }) => entry.id),
   );
-  const wdioStoryIds = new Set(selectWdioStories(manifest, wdioSettings).map(({ id }) => id));
+  const wdioStoryIds = new Set(selectWdioStories(manifest, wdioSettings, platform).map(({ id }) => id));
   const storyIds = [...new Set([...planStoryIds, ...wdioStoryIds])].sort();
   if (storyIds.length === 0) {
     throw new Error('No desktop story tests matched the smoke selection.');
diff --git a/packages/agentic/storybook-desktop/src/config/commands.ts b/packages/agentic/storybook-desktop/src/config/commands.ts
index 1061ef9350..7df2609e57 100644
--- a/packages/agentic/storybook-desktop/src/config/commands.ts
+++ b/packages/agentic/storybook-desktop/src/config/commands.ts
@@ -24,6 +24,7 @@ export type DesktopSmokeRunOptions = {
    * @default "stories"
    */
   mode?: DesktopSmokeMode;
+  input?: 'accessible' | 'physical';
 };
 
 export const STORYBOOK_SMOKE_MODE = 'STORYBOOK_SMOKE_MODE';
diff --git a/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
index 9aceedaba9..09d5c21dfb 100644
--- a/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
@@ -86,6 +86,16 @@ describe('native Storybook test stripping', () => {
     expect(output).toContain('Two');
   });
 
+  test('strips desktopIt calls and their unused import from the native story module', () => {
+    const output = transform(`
+      import { desktopIt, type WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
+      export const Example: WdioStory = { render: () => <View />, wdio: [desktopIt('case', () => console.log('node-only'))] };
+    `);
+    expect(output).not.toContain('desktopIt');
+    expect(output).not.toContain('node-only');
+    expect(output).toContain('render');
+  });
+
   test.each([
     [`export const Example = { wdio: importedCallback };`, /inline/],
     [`export const Example = { ...shared };`, /spread/],
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.test.ts b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
index dd816c2bfc..996fdf90c4 100644
--- a/packages/agentic/storybook-desktop/src/config/wdio.test.ts
+++ b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
@@ -24,4 +24,20 @@ describe('Storybook-owned wdio configuration', () => {
     expect(() => resolveWdioOptions({ story: '' })).toThrow('wdio.story');
     expect(() => resolveWdioOptions({ tag: ' ' })).toThrow('wdio.tag');
   });
+
+  test('resolves an explicit input lane and rejects conflicting click configuration', () => {
+    const previous = process.env.DESKTOP_INPUT;
+    delete process.env.DESKTOP_INPUT;
+    try {
+      expect(resolveWdioOptions({ input: 'accessible' })).toMatchObject({ input: 'accessible', clickMode: 'auto' });
+      expect(() => resolveWdioOptions({ input: 'physical', clickMode: 'physical' })).toThrow('cannot be combined with a click mode');
+      process.env.DESKTOP_INPUT = 'physical';
+      expect(resolveWdioOptions().input).toBe('physical');
+      expect(resolveWdioOptions({ input: 'accessible' }).input).toBe('accessible');
+      expect(() => resolveWdioOptions({ clickMode: 'physical' })).toThrow('cannot be combined');
+    } finally {
+      if (previous === undefined) delete process.env.DESKTOP_INPUT;
+      else process.env.DESKTOP_INPUT = previous;
+    }
+  });
 });
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.ts b/packages/agentic/storybook-desktop/src/config/wdio.ts
index 7e7b4102dd..f1525e685e 100644
--- a/packages/agentic/storybook-desktop/src/config/wdio.ts
+++ b/packages/agentic/storybook-desktop/src/config/wdio.ts
@@ -1,7 +1,9 @@
 import type { DesktopWebdriverOptions } from '@fluentui-react-native/desktop-driver/wdio';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
 
 export type DesktopStorybookWdioOptions = {
   clickMode?: DesktopWebdriverOptions['clickMode'];
+  input?: DesktopInputLane;
   reporter?: 'spec' | 'tap' | 'dot';
   story?: string;
   tag?: string;
@@ -13,6 +15,15 @@ export function resolveWdioOptions(
   options: DesktopStorybookWdioOptions = {},
 ): Readonly<Required<Pick<DesktopStorybookWdioOptions, 'timeoutMs' | 'reporter' | 'clickMode'>> & DesktopStorybookWdioOptions> {
   const { timeoutMs = 30_000, reporter = 'spec', clickMode = 'auto' } = options;
+  const requestedInput = options.input ?? process.env.DESKTOP_INPUT;
+  let input: DesktopInputLane | undefined;
+  if (requestedInput !== undefined) {
+    if (!isDesktopInputLane(requestedInput)) throw new TypeError('wdio.input must be accessible or physical.');
+    input = requestedInput;
+  }
+  if (input && clickMode !== 'auto') {
+    throw new TypeError('wdio.input cannot be combined with a click mode other than auto.');
+  }
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647) {
     throw new TypeError('wdio.timeoutMs must be a positive 32-bit integer.');
   }
@@ -27,5 +38,15 @@ export function resolveWdioOptions(
       throw new TypeError(`wdio.${key} must be a non-empty string.`);
     }
   }
-  return Object.freeze({ ...options, timeoutMs, reporter, clickMode });
+  return Object.freeze({
+    ...options,
+    ...(input ? { input } : {}),
+    timeoutMs,
+    reporter,
+    clickMode,
+  });
+}
+
+function isDesktopInputLane(value: string): value is DesktopInputLane {
+  return value === 'accessible' || value === 'physical';
 }
diff --git a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
index 6b5aa6afcc..69dd15764d 100644
--- a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
@@ -59,6 +59,7 @@ export type CreateDesktopStorybookDriverManifestOptions = {
   platform: Platforms;
   renderer?: DesktopStorybookDriverManifest['renderer'];
   storyManifest: DesktopStoryManifest;
+  wdio?: DesktopStorybookWdioOptions;
 };
 
 /** Returns the WebDriver target ID the embedded Storybook driver registers for an endpoint and renderer. */
@@ -81,6 +82,7 @@ export function createDesktopStorybookDriverManifest({
   platform,
   renderer = platform === 'win32' ? 'paper' : 'fabric',
   storyManifest,
+  wdio,
 }: CreateDesktopStorybookDriverManifestOptions): DesktopStorybookDriverManifest {
   const nativeOptions = config.getNativeDriverOptions(platform);
   if (nativeOptions === false) {
@@ -121,7 +123,7 @@ export function createDesktopStorybookDriverManifest({
     storybookPort: instance.storybookPort,
     targetId: desktopStorybookTargetId(config, platform, renderer),
     testIDPrefix: config.testIDPrefix,
-    wdio: config.wdio,
+    wdio: wdio ?? config.wdio,
   });
 }
 
diff --git a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
index c1f0a039f8..837bcf82e2 100644
--- a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
@@ -86,6 +86,7 @@ export async function createDesktopStoryManifest(
       for (const [exportName, staticStory] of stories) {
         const wdio = wdioTests.get(exportName);
         const testNames = wdio?.tests.flatMap(({ name }) => (name === undefined ? [] : [name]));
+        const cases = wdio?.tests.flatMap(({ name, options }) => (name === undefined || options === undefined ? [] : [{ name, options }]));
         const tests = readDesktopStoryTests(
           extractDesktopStoryTests(csf._storyAnnotations?.[exportName]?.parameters, sourceFile, staticStory.id) ??
             staticStory.parameters?.desktopDriver,
@@ -100,7 +101,16 @@ export async function createDesktopStoryManifest(
           tags: [...new Set([...(csf.meta?.tags ?? []), ...(staticStory.tags ?? []), 'story'])].sort(),
           title: csf.meta?.title ?? staticStory.id.split('--')[0],
           ...(tests ? { tests } : {}),
-          ...(wdio ? { wdio: { digest: wdio.digest, exportName, ...(testNames?.length ? { testNames } : {}) } } : {}),
+          ...(wdio
+            ? {
+                wdio: {
+                  digest: wdio.digest,
+                  exportName,
+                  ...(testNames?.length ? { testNames } : {}),
+                  ...(cases?.length ? { cases } : {}),
+                },
+              }
+            : {}),
         });
       }
 
diff --git a/packages/agentic/storybook-desktop/src/testing/desktopIt.ts b/packages/agentic/storybook-desktop/src/testing/desktopIt.ts
new file mode 100644
index 0000000000..c95a7580eb
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/desktopIt.ts
@@ -0,0 +1,11 @@
+import type { WdioDescriptor, WdioStoryCase, WdioStoryTest } from './types.js';
+
+export function desktopIt(name: string, run: WdioStoryTest): WdioStoryCase;
+export function desktopIt(name: string, options: Omit<WdioDescriptor, 'run'>, run: WdioStoryTest): WdioStoryCase;
+export function desktopIt(name: string, optionsOrRun: Omit<WdioDescriptor, 'run'> | WdioStoryTest, run?: WdioStoryTest): WdioStoryCase {
+  if (!name.trim()) throw new TypeError('A desktop story test requires a non-empty name.');
+  const options = typeof optionsOrRun === 'function' ? {} : optionsOrRun;
+  const callback = typeof optionsOrRun === 'function' ? optionsOrRun : run;
+  if (typeof callback !== 'function') throw new TypeError('A desktop story test requires a callback.');
+  return { name, ...options, run: callback };
+}
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
index f73abf0e39..0a5ff18bb4 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -33,6 +33,23 @@ describe('extractWdioTests', () => {
     );
   });
 
+  test('extracts desktopIt calls and their static descriptors without executing the story', () => {
+    const result = extractWdioTests(
+      `
+      import { desktopIt as test } from '@fluentui-react-native/storybook-desktop/testing';
+      export const Example = { wdio: [
+        test('accessible action', { requires: ['click'], platforms: ['!win32'] }, async ({ browser }) => { await browser.$('~button').click(); }),
+        test('default case', async () => {}),
+      ] };
+      `,
+      sourceFile,
+    ).get('Example')!;
+    expect(result.tests.map(({ name, options }) => ({ name, input: options?.input, requires: options?.requires }))).toEqual([
+      { name: 'accessible action', input: 'both', requires: ['click'] },
+      { name: 'default case', input: 'both', requires: undefined },
+    ]);
+  });
+
   test.each([
     ['{}', /at least one/],
     ["{ '': () => {} }", /non-empty/],
@@ -46,6 +63,20 @@ describe('extractWdioTests', () => {
     expect(() => extractWdioTests(`export const Example = { wdio: ${value} };`, sourceFile)).toThrow(message);
   });
 
+  test.each([
+    [`export const Example = { wdio: [desktopIt('case', () => {})] };`, /imported from/],
+    [
+      `import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing'; export const Example = { wdio: [desktopIt('case', { input: mode }, () => {})] };`,
+      /strict JSON literal/,
+    ],
+    [
+      `import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing'; const name = 'case'; export const Example = { wdio: [desktopIt(name, () => {})] };`,
+      /literal test name/,
+    ],
+  ])('rejects non-static desktopIt descriptors', (source, message) => {
+    expect(() => extractWdioTests(source, sourceFile)).toThrow(message);
+  });
+
   test('extracts a standalone typed callback without loading the native story module', async () => {
     const tests = extractWdioTests(
       `
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
index 493d5239bf..58e2eaf30f 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 
 import { transformSync, type NodePath, type types } from '@babel/core';
+import { validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
 
 import storyTests from '../../config/transform-story-tests.cjs';
 
@@ -8,7 +10,7 @@ const { collectWdioTests, compileWdioTest } = storyTests;
 
 export type ExtractedWdioStory = {
   digest: string;
-  tests: readonly { name?: string; code: string }[];
+  tests: readonly { name?: string; code: string; options?: ResolvedDesktopCaseOptions }[];
 };
 
 export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<string, ExtractedWdioStory> {
@@ -24,9 +26,10 @@ export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<
         visitor: {
           Program(program: NodePath<types.Program>) {
             for (const [exportName, { callbacks, value }] of collectWdioTests(program)) {
-              const compiled = callbacks.map(({ callback, name }) => ({
+              const compiled = callbacks.map(({ callback, name, options }) => ({
                 ...(name === undefined ? {} : { name }),
                 code: compileWdioTest(callback, sourceFile, code),
+                ...(options !== undefined ? { options: validateDesktopCaseOptions(options, `${sourceFile}.wdio`) } : {}),
               }));
               const source = code.slice(value.node.start!, value.node.end!);
               tests.set(exportName, {
diff --git a/packages/agentic/storybook-desktop/src/testing/index.ts b/packages/agentic/storybook-desktop/src/testing/index.ts
index e5df94e7d3..b1b449f558 100644
--- a/packages/agentic/storybook-desktop/src/testing/index.ts
+++ b/packages/agentic/storybook-desktop/src/testing/index.ts
@@ -1 +1,2 @@
-export type { WdioStory, WdioStoryContext, WdioStoryTest, WdioStoryTests } from './types.js';
+export { desktopIt } from './desktopIt.js';
+export type { WdioDescriptor, WdioStory, WdioStoryCase, WdioStoryContext, WdioStoryTest, WdioStoryTests } from './types.js';
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts
new file mode 100644
index 0000000000..5860dd8e4f
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts
@@ -0,0 +1,68 @@
+import { validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopStoryManifest } from '@fluentui-react-native/desktop-driver';
+
+import { missingRequirements, resolveCaseClickMode, selectWdioCases, selectWdioStories } from './runWdioTests.js';
+
+describe('WDIO input lane selection', () => {
+  const manifest: DesktopStoryManifest = {
+    endpoint: 'win32',
+    entries: [
+      {
+        id: 'button',
+        name: 'Button',
+        packageName: 'components',
+        sourcePath: 'button.stories.tsx',
+        tags: ['story'],
+        title: 'Button',
+        wdio: {
+          digest: 'digest',
+          exportName: 'Default',
+          testNames: ['adaptive', 'accessible', 'win32-only'],
+          cases: [
+            { name: 'adaptive', options: validateDesktopCaseOptions({ requires: ['click'] }) },
+            { name: 'accessible', options: validateDesktopCaseOptions({ requires: ['accessibility-click'] }) },
+            { name: 'win32-only', options: validateDesktopCaseOptions({ platforms: ['win32'] }) },
+          ],
+        },
+      },
+    ],
+    platformManifestDigest: 'digest',
+    portablePlanDigest: 'digest',
+    schemaVersion: 1,
+  };
+
+  test('selects by modality and target platform', () => {
+    expect(selectWdioStories(manifest, { input: 'accessible' }, 'win32').map(({ id }) => id)).toEqual(['button']);
+    expect(selectWdioCases(manifest.entries[0], { input: 'accessible' }, 'win32')?.map(({ name }) => name)).toEqual([
+      'adaptive',
+      'accessible',
+      'win32-only',
+    ]);
+    expect(selectWdioCases(manifest.entries[0], {}, 'macos')?.map(({ name }) => name)).toEqual(['adaptive', 'accessible']);
+    expect(selectWdioCases(manifest.entries[0], { input: 'physical' }, 'win32')?.map(({ name }) => name)).toEqual([
+      'adaptive',
+      'win32-only',
+    ]);
+    expect(selectWdioCases(manifest.entries[0], { input: 'physical', test: 'accessible' }, 'macos')).toEqual([]);
+    expect(selectWdioCases(manifest.entries[0], { input: 'physical', test: 'win32-only' }, 'macos')).toEqual([]);
+  });
+
+  test('rejects legacy callback entries in a lane', () => {
+    const legacy = {
+      ...manifest,
+      entries: [{ ...manifest.entries[0], wdio: { digest: 'legacy', exportName: 'Default', testNames: ['legacy'] } }],
+    } satisfies DesktopStoryManifest;
+    expect(() => selectWdioStories(legacy, { input: 'physical' }, 'win32')).toThrow('declare it with desktopIt');
+  });
+
+  test('adapts click requirements to each lane without fallback', () => {
+    const descriptor = validateDesktopCaseOptions({ requires: ['click'] });
+    const accessibleMode = resolveCaseClickMode(descriptor, 'auto', 'accessible');
+    const physicalMode = resolveCaseClickMode(descriptor, 'auto', 'physical');
+    expect(accessibleMode).toBe('accessibility');
+    expect(physicalMode).toBe('physical');
+    expect(missingRequirements(descriptor, { accessibilityClick: true, physicalClick: false }, physicalMode)).toEqual(['click']);
+    expect(missingRequirements(descriptor, { accessibilityClick: false, physicalClick: true }, accessibleMode)).toEqual(['click']);
+    expect(missingRequirements(descriptor, { accessibilityClick: true }, accessibleMode)).toEqual([]);
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
index 52cacc56c1..8ed1c3a371 100644
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -4,7 +4,8 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
 import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
-import type { DesktopArtifact } from '@fluentui-react-native/desktop-driver/authoring';
+import { matchesDesktopPlatforms } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopArtifact, DesktopInputLane, ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
 import { ArtifactManager, captureDesktopFailureEvidence } from '@fluentui-react-native/desktop-driver/artifacts';
 import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopReportWriter } from '@fluentui-react-native/desktop-test/reporting';
@@ -21,10 +22,11 @@ import { formatDesktopStorybookError, writeDesktopStorybookFailure, type Desktop
 export type WdioStoryTestResult = {
   storyId: string;
   testName?: string;
-  status: 'passed' | 'failed' | 'skipped';
+  status: 'passed' | 'failed' | 'skipped' | 'unsupported';
   durationMs: number;
   error?: string;
   skipReason?: string;
+  gap?: 'unsupported' | 'quarantine';
   evidenceErrors?: string[];
   artifacts?: readonly DesktopArtifact[];
 };
@@ -53,23 +55,50 @@ export class WdioStoryTestRunError extends Error {
   }
 }
 
+class MissingRequirementsError extends Error {
+  constructor(requirements: readonly string[]) {
+    super(`Missing desktop requirements: ${requirements.join(', ')}.`);
+  }
+}
+
 export function selectWdioStories(
   manifest: DesktopStoryManifest,
   options: DesktopStorybookWdioOptions,
+  platform?: Platforms,
 ): readonly DesktopStoryManifestEntry[] {
   return manifest.entries
     .filter((entry) => entry.wdio && (!options.story || path.matchesGlob(entry.id, options.story)))
     .filter((entry) => !options.tag || entry.tags.includes(options.tag))
-    .filter((entry) => (entry.wdio?.testNames ?? ['default']).some((name) => matchesWdioTest(name, options.test)))
+    .filter((entry) => {
+      if (options.input || entry.wdio?.cases) return (selectWdioCases(entry, options, platform)?.length ?? 0) > 0;
+      return (entry.wdio?.testNames ?? ['default']).some((name) => matchesWdioTest(name, options.test));
+    })
     .sort((left, right) => left.id.localeCompare(right.id));
 }
 
+export function selectWdioCases(
+  entry: DesktopStoryManifestEntry,
+  options: DesktopStorybookWdioOptions,
+  platform?: Platforms,
+): NonNullable<DesktopStoryManifestEntry['wdio']>['cases'] {
+  if (!entry.wdio?.cases?.length) {
+    if (!options.input) return undefined;
+    throw new Error(`Input lane "${options.input}" cannot run legacy wdio callback in "${entry.id}"; declare it with desktopIt.`);
+  }
+  return entry.wdio.cases.filter(
+    ({ name, options: descriptor }) =>
+      matchesWdioTest(name, options.test) &&
+      (!platform || matchesDesktopPlatforms(descriptor.platforms, platform)) &&
+      (!options.input || descriptor.input === 'both' || descriptor.input === options.input),
+  );
+}
+
 export async function runWdioStoryTests(
   options: RunWdioStoryTestsOptions,
   runner?: DesktopCommandRunner,
 ): Promise<readonly WdioStoryTestResult[]> {
   const settings = resolveWdioOptions(options);
-  const stories = selectWdioStories(options.manifest, settings);
+  const stories = selectWdioStories(options.manifest, settings, options.platform);
   if (stories.length === 0) {
     throw new Error('No executable wdio story tests matched the requested selection.');
   }
@@ -79,9 +108,19 @@ export async function runWdioStoryTests(
     if (!extracted || extracted.digest !== entry.wdio!.digest) {
       throw new Error(`Executable test source changed for ${entry.id}; regenerate the Storybook manifest.`);
     }
+    const selectedCases = selectWdioCases(entry, settings, options.platform);
     return extracted.tests
       .filter(({ name }) => matchesWdioTest(name ?? 'default', settings.test))
-      .map(({ name, code }) => ({ entry, code, testName: name }));
+      .map(({ name, code }) => ({
+        entry,
+        code,
+        testName: name,
+        descriptor: entry.wdio?.cases?.find((testCase) => testCase.name === name)?.options,
+      }))
+      .filter(({ testName }) => {
+        if (!selectedCases) return !settings.input;
+        return selectedCases.some(({ name }) => name === testName);
+      });
   });
   if (cases.length === 0) throw new Error('No executable wdio tests matched the requested selection.');
   const artifacts = new ArtifactManager(
@@ -112,7 +151,7 @@ export async function runWdioStoryTests(
   try {
     fs.mkdirSync(generatedRoot, { recursive: true });
     directory = fs.mkdtempSync(path.join(generatedRoot, 'run-'));
-    for (const [index, { entry, code, testName }] of cases.entries()) {
+    for (const [index, { entry, code, testName, descriptor }] of cases.entries()) {
       options.signal?.throwIfAborted();
       const displayName = testName === undefined ? entry.id : `${entry.id} / ${testName}`;
       const artifactId =
@@ -132,9 +171,29 @@ export async function runWdioStoryTests(
       const context = { story: entry.id, test: testName ?? 'default', endpoint: options.platform };
       options.report?.emit({ kind: 'scope-start', payload: { label: displayName, category: 'worker' } }, testId, context, testId);
       options.report?.emit({ kind: 'test-start', payload: { testId, title: displayName, attempt: 0 } }, testId, context);
+      const gap = descriptor && declaredGapFor(descriptor, options.platform, settings.input);
+      if (gap) {
+        result.status = 'unsupported';
+        result.skipReason = gap.reason;
+        result.gap = gap.kind;
+        result.durationMs = Date.now() - started;
+        results.push(result);
+        options.report?.emit(
+          {
+            kind: 'test-result',
+            payload: { testId, title: displayName, attempt: 0, status: 'unsupported', durationMs: result.durationMs, reason: gap.reason },
+          },
+          testId,
+          context,
+        );
+        options.report?.emit({ kind: 'scope-end', payload: { status: 'unsupported' } }, testId);
+        activeResult = undefined;
+        continue;
+      }
+      const clickMode = resolveCaseClickMode(descriptor, settings.clickMode, settings.input);
       // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
       const desktop = await connectDesktopWebdriver({
-        clickMode: settings.clickMode,
+        clickMode,
         launchMode: 'attach',
         platformName: options.platform === 'macos' ? 'macos' : 'windows',
         targetId: options.targetId,
@@ -147,6 +206,8 @@ export async function runWdioStoryTests(
         if (live.endpoint !== options.platform || live.platformManifestDigest !== options.manifest.platformManifestDigest) {
           throw new Error('The running Storybook manifest is stale or targets a different platform. Restart storybook driver and the app.');
         }
+        const missing = missingRequirements(descriptor, desktop.browser.capabilities['furn:features'], clickMode);
+        if (missing.length) throw new MissingRequirementsError(missing);
         phase = 'navigation';
         await desktop.openStory(entry.id);
         const resultPath = path.join(directory, `${index}.json`);
@@ -199,27 +260,32 @@ export async function runWdioStoryTests(
           result.skipReason = outcome.skipReason;
         }
       } catch (error) {
-        failure = error;
-        executionFailures.push(error);
-        result.error = formatDesktopStorybookError(error);
-        writeDesktopStorybookFailure(`wdio "${displayName}" during ${phase}`, error, options.errorOutput);
-        const evidence = await captureDesktopFailureEvidence(desktop.session, artifacts, artifactId);
-        result.artifacts = evidence.artifacts;
-        result.evidenceErrors = evidence.errors;
-        for (const artifact of result.artifacts)
-          options.report?.emit(
-            {
-              kind: 'artifact',
-              payload: {
-                path: path.relative(options.report.root, path.join(artifacts.root, artifact.path)),
-                description: `${displayName}: ${artifact.kind}`,
+        if (error instanceof MissingRequirementsError) {
+          result.status = 'unsupported';
+          result.skipReason = error.message;
+        } else {
+          failure = error;
+          executionFailures.push(error);
+          result.error = formatDesktopStorybookError(error);
+          writeDesktopStorybookFailure(`wdio "${displayName}" during ${phase}`, error, options.errorOutput);
+          const evidence = await captureDesktopFailureEvidence(desktop.session, artifacts, artifactId);
+          result.artifacts = evidence.artifacts;
+          result.evidenceErrors = evidence.errors;
+          for (const artifact of result.artifacts)
+            options.report?.emit(
+              {
+                kind: 'artifact',
+                payload: {
+                  path: path.relative(options.report.root, path.join(artifacts.root, artifact.path)),
+                  description: `${displayName}: ${artifact.kind}`,
+                },
               },
-            },
-            testId,
-          );
-        for (const evidenceError of result.evidenceErrors) {
-          options.report?.fail(new Error(evidenceError), 'evidence', testId);
-          writeDesktopStorybookFailure(`evidence for "${displayName}"`, evidenceError, options.errorOutput);
+              testId,
+            );
+          for (const evidenceError of result.evidenceErrors) {
+            options.report?.fail(new Error(evidenceError), 'evidence', testId);
+            writeDesktopStorybookFailure(`evidence for "${displayName}"`, evidenceError, options.errorOutput);
+          }
         }
       }
       phase = 'session cleanup';
@@ -243,7 +309,7 @@ export async function runWdioStoryTests(
             attempt: 0,
             status: result.status,
             durationMs: result.durationMs,
-            ...(result.status === 'skipped' ? { reason: result.skipReason } : {}),
+            ...(['skipped', 'unsupported'].includes(result.status) ? { reason: result.skipReason } : {}),
             ...(failure !== undefined ? { failure: options.report.failure(failure, 'test') } : {}),
           },
         },
@@ -283,7 +349,11 @@ export async function runWdioStoryTests(
   const failures: unknown[] = infrastructureFailure === undefined ? [] : [infrastructureFailure];
   failures.push(...executionFailures);
   const allSkipped = results.every(({ status }) => status === 'skipped');
-  const incomplete = results.length !== cases.length || (allSkipped && !options.optional);
+  const laneIncomplete =
+    !!settings.input &&
+    (!results.some(({ status }) => status === 'passed' || status === 'failed') ||
+      results.some(({ status, gap }) => status === 'skipped' || (status === 'unsupported' && gap === undefined)));
+  const incomplete = results.length !== cases.length || (allSkipped && !options.optional) || laneIncomplete;
   if (incomplete && failures.length === 0)
     failures.push(new Error('Required executable story cohort did not execute any tests or left selected work unfinished.'));
   try {
@@ -347,6 +417,75 @@ function csfTestId(storyId: string, testName?: string): string {
     .digest('hex')}`;
 }
 
+export function resolveCaseClickMode(
+  descriptor: ResolvedDesktopCaseOptions | undefined,
+  configured: 'auto' | 'physical' | 'accessibility',
+  input: DesktopInputLane | undefined,
+): 'auto' | 'physical' | 'accessibility' {
+  if (input === 'accessible') return 'accessibility';
+  if (input === 'physical') return 'physical';
+  if (descriptor?.input === 'accessible' || descriptor?.requires?.includes('accessibility-click')) return 'accessibility';
+  if (descriptor?.input === 'physical') return 'physical';
+  return configured;
+}
+
+export function missingRequirements(
+  descriptor: ResolvedDesktopCaseOptions | undefined,
+  features: Readonly<Record<string, unknown>> | undefined,
+  clickMode: 'auto' | 'physical' | 'accessibility',
+): string[] {
+  if (!descriptor?.requires?.length) return [];
+  const missing: string[] = [];
+  for (const requirement of descriptor.requires) {
+    const feature =
+      requirement === 'click'
+        ? clickMode === 'physical'
+          ? 'physicalClick'
+          : clickMode === 'accessibility'
+            ? 'accessibilityClick'
+            : undefined
+        : requirement === 'physical-click'
+          ? 'physicalClick'
+          : requirement === 'accessibility-click'
+            ? 'accessibilityClick'
+            : requirement === 'accessibility-actions'
+              ? 'accessibilityActions'
+              : requirement === 'element-screenshot'
+                ? 'elementScreenshot'
+                : requirement === 'set-window-rect'
+                  ? 'setWindowRect'
+                  : requirement;
+    if (requirement === 'click' && clickMode === 'auto') {
+      if (!features?.physicalClick && !features?.accessibilityClick) missing.push(requirement);
+    } else if (feature && features?.[feature] !== true) {
+      missing.push(requirement);
+    }
+  }
+  return missing;
+}
+
+function declaredGapFor(
+  descriptor: ResolvedDesktopCaseOptions,
+  endpoint: Platforms,
+  input: DesktopInputLane | undefined,
+): { kind: 'unsupported' | 'quarantine'; reason: string } | undefined {
+  if (descriptor.unsupported && matchesDesktopPlatforms(descriptor.unsupported.platforms, endpoint)) {
+    return { kind: 'unsupported', reason: descriptor.unsupported.reason };
+  }
+  const quarantine = descriptor.quarantine;
+  if (
+    quarantine &&
+    (!quarantine.platforms || matchesDesktopPlatforms(quarantine.platforms, endpoint)) &&
+    (!quarantine.input || quarantine.input === input)
+  ) {
+    if (Date.parse(`${quarantine.expires}T00:00:00Z`) < Date.now()) {
+      throw new Error(`Quarantine ${quarantine.issue} expired on ${quarantine.expires}.`);
+    }
+    return { kind: 'quarantine', reason: `${quarantine.issue}: ${quarantine.reason}` };
+  }
+  return undefined;
+}
+
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
diff --git a/packages/agentic/storybook-desktop/src/testing/types.ts b/packages/agentic/storybook-desktop/src/testing/types.ts
index 8077303d07..d87cbfc6e1 100644
--- a/packages/agentic/storybook-desktop/src/testing/types.ts
+++ b/packages/agentic/storybook-desktop/src/testing/types.ts
@@ -1,6 +1,7 @@
 import type { DesktopWebdriverSession } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopEndpoint } from '@fluentui-react-native/desktop-driver';
 import type { expect } from 'expect-webdriverio';
+import type { DesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
 
 export type WdioStoryContext = {
   browser: DesktopWebdriverSession['browser'];
@@ -13,8 +14,10 @@ export type WdioStoryContext = {
 
 export type WdioStoryTest = (context: WdioStoryContext) => void | Promise<void>;
 export type WdioStoryTests = Readonly<Record<string, WdioStoryTest>>;
+export type WdioDescriptor = DesktopCaseOptions & { run: WdioStoryTest };
+export type WdioStoryCase = WdioDescriptor & { name: string };
 
 /** Wrap StoryObj, importing this type only; callbacks execute in Node, not React Native. */
 export type WdioStory<TStory = object> = Omit<TStory, 'wdio'> & {
-  wdio?: WdioStoryTest | WdioStoryTests;
+  wdio?: readonly WdioStoryCase[] | WdioStoryTest | WdioStoryTests;
 };
diff --git a/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts b/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
index 10a341502e..176a4f80e6 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
@@ -1,4 +1,4 @@
-import type { WdioStory, WdioStoryContext } from './index.js';
+import { desktopIt, type WdioStory, type WdioStoryContext } from './index.js';
 
 const story: WdioStory = {
   wdio: async ({ browser, desktop, expect, signal, skip }) => {
@@ -38,6 +38,17 @@ const named: WdioStory = {
   },
 };
 
+const described: WdioStory = {
+  wdio: [
+    desktopIt('uses a lane-adaptive click', { requires: ['click'] }, async ({ browser }) => {
+      await (await browser.$('~button')).click();
+    }),
+    desktopIt('has the default descriptor', async ({ browser }) => {
+      await browser.$('~button');
+    }),
+  ],
+};
+
 const wrapped: WdioStory<{ args: { disabled: boolean }; wdio?: unknown }> = {
   args: { disabled: false },
   wdio: async ({ browser }) => {
@@ -56,5 +67,6 @@ test('exposes a type-only inline callback contract', () => {
   expect(typeof story.wdio).toBe('function');
   expect(typeof wrapped.wdio).toBe('function');
   expect(typeof named.wdio).toBe('object');
+  expect(Array.isArray(described.wdio)).toBe(true);
   expect(invalidArgs.args).toBeDefined();
 });

From 451e1cb0225851bccc0b8667be03762f2463871b Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Fri, 6 Nov 2026 17:40:20 -0800
Subject: [PATCH 2/6] Select and account for desktop WDIO cases by input lane

Finish part 1 of the input-lane work started in f5a90cdda. Cases declare
how they run with desktopIt, and a run selects the cases that apply to its
input lane, platform and scope and accounts for everything it excludes.

desktop-driver
- Add pure case selection and click-mode resolution, and move the
  requirement preflight and click-mode helpers here.
- Add the authoring/input leaf export so config-loading code can import
  scope helpers from source without the authoring index.

desktop-test
- Report the lane: a lane run is incomplete when it has skipped or
  undeclared-unsupported results, an empty selection or nothing executed.
- Add the Jasmine adapter (desktop-test/jasmine) with desktopIt and
  desktopDescribe, plus config-level test scopes and --input.

storybook-desktop
- Add --input accessible|physical to storybook test, driver and smoke.
  The lane comes from the flag, DESKTOP_INPUT or the attached driver.
- Select cases before they run, resolve declared gaps, assess each
  cohort, and reject direct input calls in declared cases at extraction.
- Fail closed when an accessible lane attaches to a driver that does not
  mask keyboard, physical click and wheel input.

native-core and apps/E2E
- Migrate the native-core Callout and FocusZone tests and
  ButtonV1.spec.win.ts to desktopIt.

Update the package references and add patch changesets.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .changeset/input-lanes.md                     |   3 +-
 .changeset/native-core-desktop-it.md          |   5 +
 .../src/ButtonV1/specs/ButtonV1.spec.win.ts   |  26 +-
 packages/agentic/desktop-driver/README.md     |  35 +-
 packages/agentic/desktop-driver/package.json  |   5 +
 .../desktop-driver/references/architecture.md |  38 +-
 .../desktop-driver/references/contributing.md |  35 +-
 .../references/test-integration.md            |  27 +-
 .../desktop-driver/src/authoring/index.ts     |  26 +-
 .../src/authoring/input.test.ts               | 125 +++++-
 .../desktop-driver/src/authoring/input.ts     | 172 +++++++-
 .../src/authoring/selection.test.ts           |  96 +++++
 .../desktop-driver/src/authoring/selection.ts | 116 ++++++
 packages/agentic/desktop-driver/src/index.ts  |  26 +-
 packages/agentic/desktop-test/package.json    |   5 +
 .../desktop-test/references/commands.md       |  35 +-
 .../desktop-test/references/configuration.md  |  28 ++
 .../desktop-test/references/contributing.md   |  13 +-
 .../desktop-test/references/reporting.md      |  55 ++-
 .../desktop-test/references/wdio-suites.md    |  65 +++
 packages/agentic/desktop-test/src/cli.ts      |  30 +-
 packages/agentic/desktop-test/src/config.ts   |  67 ++-
 .../desktop-test/src/contracts.contract.cjs   | 236 ++++++++++-
 .../desktop-test/src/contracts.test.ts        |   4 +
 packages/agentic/desktop-test/src/index.ts    |   2 +-
 .../agentic/desktop-test/src/integration.ts   |   3 +
 .../desktop-test/src/jasmine/adapter.test.ts  | 208 ++++++++++
 .../desktop-test/src/jasmine/adapter.ts       | 103 +++++
 .../agentic/desktop-test/src/jasmine/index.ts |  42 ++
 .../desktop-test/src/jasmine/registry.ts      |  72 ++++
 .../src/jasmine/selection.test.ts             |  50 +++
 .../desktop-test/src/jasmine/selection.ts     |  59 +++
 .../src/jasmine/specSelection.test.ts         | 183 +++++++++
 .../desktop-test/src/jasmine/specSelection.ts |  96 +++++
 .../src/reporting/collector.test.ts           | 121 ++++++
 .../desktop-test/src/reporting/collector.ts   |  32 +-
 .../desktop-test/src/reporting/index.ts       |  26 +-
 .../desktop-test/src/reporting/lane.test.ts   |  34 ++
 .../desktop-test/src/reporting/lane.ts        |  37 ++
 .../src/reporting/protocol.test.ts            |  50 ++-
 .../desktop-test/src/reporting/protocol.ts    |  22 +-
 .../src/reporting/results.test.ts             | 169 +++++++-
 .../desktop-test/src/reporting/results.ts     | 110 ++++-
 .../src/reporting/runQueries.test.ts          |  89 ++++
 .../desktop-test/src/reporting/runQueries.ts  |  56 ++-
 .../src/reporting/structured.test.ts          |  18 +
 .../desktop-test/src/reporting/structured.ts  |   5 +
 .../desktop-test/src/supervisor.test.ts       |  71 ++++
 .../agentic/desktop-test/src/supervisor.ts    |   8 +
 .../desktop-test/src/wdio/configuration.ts    |  12 +-
 .../agentic/desktop-test/src/wdio/reporter.ts |  28 +-
 packages/agentic/desktop-test/src/wdio/run.ts |  30 +-
 .../native-core/references/contributing.md    |   9 +
 .../components/callout/Callout.stories.tsx    | 383 +++++++++---------
 .../callout/menuComposition.wdio.ts           |  12 +-
 .../focus-zone/FocusZone.stories.tsx          |  97 ++---
 .../src/legacy/callout/Callout.stories.tsx    |  75 ++--
 .../storybook-desktop/config/server.cjs       |   7 +
 .../config/storybook-control.cjs              |   6 +-
 .../config/transform-story-tests.cjs          | 131 ++++++
 .../config/transform-story-tests.d.cts        |   4 +
 .../storybook-desktop/references/commands.md  |  16 +-
 .../references/contributing.md                |  10 +
 .../references/story-tests.md                 | 206 +++++++---
 .../src/cli/DesktopStorybookCli.test.ts       | 144 ++++++-
 .../src/cli/DesktopStorybookCli.ts            |  83 ++--
 .../src/cli/createDesktopStorybookCommand.ts  |  18 +
 .../src/cli/inputLane.test.ts                 | 101 +++++
 .../storybook-desktop/src/cli/inputLane.ts    |  42 ++
 .../src/cli/smokeTests.test.ts                | 124 ++++++
 .../storybook-desktop/src/cli/smokeTests.ts   |  37 +-
 .../src/config/integration.ts                 |   4 +-
 .../src/config/makeDesktopStorybookConfig.ts  |  11 +-
 .../storybook-desktop/src/config/wdio.test.ts |   5 +
 .../src/driver/driverManifest.ts              |  24 ++
 .../src/driver/serverIntegration.test.ts      |  58 +++
 .../src/testing/extractWdioTests.test.ts      | 111 +++++
 .../src/testing/extractWdioTests.ts           |  19 +-
 .../src/testing/laneVerdict.test.ts           |  75 ++++
 .../src/testing/laneVerdict.ts                |  72 ++++
 .../src/testing/runWdioTests.test.ts          |  68 ----
 .../src/testing/runWdioTests.ts               | 224 ++++------
 .../src/testing/selection.test.ts             | 301 ++++++++++++++
 .../src/testing/selection.ts                  | 194 +++++++++
 .../src/testing/wdioRunner.contract.cjs       |  64 +++
 .../src/testing/wdioRunner.test.ts            |  25 ++
 86 files changed, 5007 insertions(+), 762 deletions(-)
 create mode 100644 .changeset/native-core-desktop-it.md
 create mode 100644 packages/agentic/desktop-driver/src/authoring/selection.test.ts
 create mode 100644 packages/agentic/desktop-driver/src/authoring/selection.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/adapter.test.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/adapter.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/index.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/registry.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/selection.test.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/selection.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
 create mode 100644 packages/agentic/desktop-test/src/jasmine/specSelection.ts
 create mode 100644 packages/agentic/desktop-test/src/reporting/lane.test.ts
 create mode 100644 packages/agentic/desktop-test/src/reporting/lane.ts
 create mode 100644 packages/agentic/desktop-test/src/supervisor.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/cli/inputLane.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/laneVerdict.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/laneVerdict.ts
 delete mode 100644 packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/selection.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/selection.ts

diff --git a/.changeset/input-lanes.md b/.changeset/input-lanes.md
index 4c06b6b268..0b98bd6d1c 100644
--- a/.changeset/input-lanes.md
+++ b/.changeset/input-lanes.md
@@ -1,6 +1,7 @@
 ---
 '@fluentui-react-native/desktop-driver': patch
+'@fluentui-react-native/desktop-test': patch
 '@fluentui-react-native/storybook-desktop': patch
 ---
 
-Add modality-aware desktop test descriptors and Storybook input-lane selection.
+Add modality-aware desktop test descriptors: `desktopIt` and `desktopDescribe` declare `requires`, `input`, `platforms`, `scope`, and known gaps for Storybook cases and, through `desktop-test/jasmine`, WebdriverIO Jasmine specs. `--input accessible|physical` (or `DESKTOP_INPUT`) runs one input lane, selects the cases that apply, masks the host for the accessible lane, and reports the lane and what it excluded.
diff --git a/.changeset/native-core-desktop-it.md b/.changeset/native-core-desktop-it.md
new file mode 100644
index 0000000000..9195e49344
--- /dev/null
+++ b/.changeset/native-core-desktop-it.md
@@ -0,0 +1,5 @@
+---
+'@fluentui-react-native/native-core': patch
+---
+
+Declare the Callout and FocusZone desktop tests with `desktopIt` and `requires`, so each runs in the input lane it needs and the Win32 Tab-exit gap is declared instead of skipped at run time.
diff --git a/apps/E2E/src/ButtonV1/specs/ButtonV1.spec.win.ts b/apps/E2E/src/ButtonV1/specs/ButtonV1.spec.win.ts
index 2d03c4cb2d..4542acf99f 100644
--- a/apps/E2E/src/ButtonV1/specs/ButtonV1.spec.win.ts
+++ b/apps/E2E/src/ButtonV1/specs/ButtonV1.spec.win.ts
@@ -1,14 +1,17 @@
+import { desktopDescribe, desktopIt } from '@fluentui-react-native/desktop-test/jasmine';
+
 import { BUTTON_ACCESSIBILITY_LABEL, BUTTON_TEST_COMPONENT_LABEL } from '../../ButtonLegacy/consts';
 import { BUTTON_A11Y_ROLE, Keys, Attribute } from '../../common/consts';
 import ButtonV1PageObject from '../pages/ButtonV1PageObject';
 
 // Before testing begins, allow up to 60 seconds for app to open
-describe('ButtonV1 Testing Initialization', () => {
-  it('Wait for app load', async () => {
+desktopDescribe('ButtonV1 Testing Initialization', () => {
+  desktopIt('Wait for app load', async () => {
     expect(await ButtonV1PageObject.waitForInitialPageToDisplay()).toBeTrue();
   });
 
-  it('Click and navigate to ButtonV1 test page', async () => {
+  // Navigation scrolls the page list with the wheel whenever the page button is out of view.
+  desktopIt('Click and navigate to ButtonV1 test page', { requires: ['click', 'wheel'] }, async () => {
     /* Click on component button to navigate to test page */
     expect(await ButtonV1PageObject.navigateToPageAndLoadTests()).toBeTrue();
 
@@ -21,18 +24,19 @@ describe('ButtonV1 Testing Initialization', () => {
   });
 });
 
-describe('ButtonV1 Accessibility Testing', () => {
+// The setup scrolls the test element into view, which can inject native wheel input, so this group is physical.
+desktopDescribe('ButtonV1 Accessibility Testing', { requires: ['wheel'] }, () => {
   beforeEach(async () => {
     await ButtonV1PageObject.scrollToTestElement();
   });
 
-  it('Validate "accessibilityRole" value defaults to "ControlType.Button".', async () => {
+  desktopIt('Validate "accessibilityRole" value defaults to "ControlType.Button".', async () => {
     await expect(
       await ButtonV1PageObject.compareAttribute(ButtonV1PageObject._primaryComponent, Attribute.AccessibilityRole, BUTTON_A11Y_ROLE),
     ).toBeTruthy();
   });
 
-  it('Set "accessibilityLabel" prop. Validate "accessibilityLabel" value propagates to "Name" element attribute.', async () => {
+  desktopIt('Set "accessibilityLabel" prop. Validate "accessibilityLabel" value propagates to "Name" element attribute.', async () => {
     await expect(
       await ButtonV1PageObject.compareAttribute(
         ButtonV1PageObject._primaryComponent,
@@ -42,7 +46,7 @@ describe('ButtonV1 Accessibility Testing', () => {
     ).toBeTruthy();
   });
 
-  it('Do NOT set "accessibilityLabel" prop. Validate "Name" element attribute defaults to the button label.', async () => {
+  desktopIt('Do NOT set "accessibilityLabel" prop. Validate "Name" element attribute defaults to the button label.', async () => {
     await expect(
       await ButtonV1PageObject.compareAttribute(
         ButtonV1PageObject._secondaryComponent,
@@ -53,7 +57,7 @@ describe('ButtonV1 Accessibility Testing', () => {
   });
 });
 
-describe('ButtonV1 Functional Testing', () => {
+desktopDescribe('ButtonV1 Functional Testing', { requires: ['wheel'] }, () => {
   /* Scrolls and waits for the Button to be visible on the Test Page */
   beforeEach(async () => {
     await ButtonV1PageObject.scrollToTestElement();
@@ -63,7 +67,7 @@ describe('ButtonV1 Functional Testing', () => {
     await ButtonV1PageObject.resetTest();
   });
 
-  it('Click primary button. Validate onClick() callback was fired.', async () => {
+  desktopIt('Click primary button. Validate onClick() callback was fired.', { requires: ['physical-click'] }, async () => {
     await ButtonV1PageObject.click(ButtonV1PageObject._primaryComponent);
     await expect(
       await ButtonV1PageObject.waitForOnClickCallbackToFire(`The primary button failed to fire an onClick callback with a mouse click.`),
@@ -74,7 +78,7 @@ describe('ButtonV1 Functional Testing', () => {
       .toBeFalsy();
   });
 
-  it('Type "Enter" on primary button. Validate onClick() callback was fired.', async () => {
+  desktopIt('Type "Enter" on primary button. Validate onClick() callback was fired.', { requires: ['keyboard'] }, async () => {
     await ButtonV1PageObject.sendKeys(ButtonV1PageObject._primaryComponent, [Keys.ENTER]);
     await expect(
       await ButtonV1PageObject.waitForOnClickCallbackToFire(
@@ -87,7 +91,7 @@ describe('ButtonV1 Functional Testing', () => {
       .toBeFalsy();
   });
 
-  it('Type "Space" on primary button. Validate onClick() callback was fired.', async () => {
+  desktopIt('Type "Space" on primary button. Validate onClick() callback was fired.', { requires: ['keyboard'] }, async () => {
     await ButtonV1PageObject.sendKeys(ButtonV1PageObject._primaryComponent, [Keys.SPACE]);
 
     await expect(
diff --git a/packages/agentic/desktop-driver/README.md b/packages/agentic/desktop-driver/README.md
index e061eb895a..484c27638b 100644
--- a/packages/agentic/desktop-driver/README.md
+++ b/packages/agentic/desktop-driver/README.md
@@ -139,23 +139,24 @@ The [reference index](references/README.md) describes each package-owned guide.
 
 ## Public entry points
 
-| Export          | Purpose                                                                                   |
-| --------------- | ----------------------------------------------------------------------------------------- |
-| Package root    | Native-helper build/resolution, `DesktopHost`, server, low-level client, and common types |
-| `/authoring`    | Serializable story plans, selectors, capabilities, and result types                       |
-| `/wdio`         | WebdriverIO connection, custom commands, assertions, and story-plan runner                |
-| `/client`       | Low-level typed W3C client                                                                |
-| `/authority`    | Grants, private connection descriptors, and macOS owner-validated storage                 |
-| `/native`       | Native-helper build, resolution, and verification without loading the package root        |
-| `/server`       | Embeddable remote end, session manager, and target registry                               |
-| `/agent`        | Bounded JSON-safe inspection, action, and evidence API                                    |
-| `/operations`   | Versioned agent operation catalog, executor, and result types                             |
-| `/artifacts`    | Confined, atomic evidence persistence                                                     |
-| `/runner`       | Plan selection, sharding, execution, and result classification                            |
-| `/storybook`    | Story manifest and orchestration contracts, without a Storybook dependency                |
-| `/testing`      | Fake host, fake Storybook orchestrator, and protocol harnesses                            |
-| `/cli`          | Embeddable Commander command and CLI runner                                               |
-| `/cli/reporter` | Shared reporter mode resolution and structured output framing                             |
+| Export             | Purpose                                                                                   |
+| ------------------ | ----------------------------------------------------------------------------------------- |
+| Package root       | Native-helper build/resolution, `DesktopHost`, server, low-level client, and common types |
+| `/authoring`       | Serializable story plans, selectors, capabilities, result types, and case descriptors     |
+| `/wdio`            | WebdriverIO connection, custom commands, assertions, and story-plan runner                |
+| `/client`          | Low-level typed W3C client                                                                |
+| `/authority`       | Grants, private connection descriptors, and macOS owner-validated storage                 |
+| `/native`          | Native-helper build, resolution, and verification without loading the package root        |
+| `/server`          | Embeddable remote end, session manager, and target registry                               |
+| `/agent`           | Bounded JSON-safe inspection, action, and evidence API                                    |
+| `/operations`      | Versioned agent operation catalog, executor, and result types                             |
+| `/artifacts`       | Confined, atomic evidence persistence                                                     |
+| `/runner`          | Plan selection, sharding, execution, and result classification                            |
+| `/storybook`       | Story manifest and orchestration contracts, without a Storybook dependency                |
+| `/testing`         | Fake host, fake Storybook orchestrator, and protocol harnesses                            |
+| `/cli`             | Embeddable Commander command and CLI runner                                               |
+| `/cli/reporter`    | Shared reporter mode resolution and structured output framing                             |
+| `/authoring/input` | Descriptor vocabulary and scope rules with no runtime imports (loads from source)         |
 
 The service implements native application semantics rather than pretending to
 be a browser. Unsupported browser features return `unsupported operation`
diff --git a/packages/agentic/desktop-driver/package.json b/packages/agentic/desktop-driver/package.json
index 9764867493..bb7b57efae 100644
--- a/packages/agentic/desktop-driver/package.json
+++ b/packages/agentic/desktop-driver/package.json
@@ -53,6 +53,11 @@
       "import": "./lib/authoring/index.js",
       "default": "./src/authoring/index.ts"
     },
+    "./authoring/input": {
+      "types": "./lib/authoring/input.d.ts",
+      "import": "./lib/authoring/input.js",
+      "default": "./src/authoring/input.ts"
+    },
     "./agent": {
       "types": "./lib/agent/index.d.ts",
       "import": "./lib/agent/index.js",
diff --git a/packages/agentic/desktop-driver/references/architecture.md b/packages/agentic/desktop-driver/references/architecture.md
index 13a181c733..ae89c8e124 100644
--- a/packages/agentic/desktop-driver/references/architecture.md
+++ b/packages/agentic/desktop-driver/references/architecture.md
@@ -120,25 +120,25 @@ handoff are still work in progress; see [current status](current-status.md).
 
 ## Module ownership
 
-| Module             | Responsibility                                                     |
-| ------------------ | ------------------------------------------------------------------ |
-| `src/protocol`     | W3C parsing, actions, capabilities, timeouts, and errors           |
-| `src/server`       | HTTP routing, target registry, sessions, windows, and elements     |
-| `src/host`         | Platform-neutral `DesktopHost` and target contracts                |
-| `src/hosts/fake`   | Deterministic in-memory provider                                   |
-| `src/hosts/native` | Long-lived helper process and `DesktopHost` adapter                |
-| `src/native`       | Build, cache, resolution, verification, manifests, and wire types  |
-| `native/macos`     | Swift operating-system implementation                              |
-| `native/windows`   | Shared C++ Windows and Win32 implementation                        |
-| `src/client`       | Low-level typed W3C client                                         |
-| `src/wdio`         | Sanctioned WebdriverIO integration and custom commands             |
-| `src/authoring`    | Serializable story plans, selectors, capabilities, and results     |
-| `src/runner`       | Filtering, sharding, execution, and result classification          |
-| `src/artifacts`    | Confined atomic evidence                                           |
-| `src/agent`        | Bounded JSON-safe operations                                       |
-| `src/operations`   | Agent operation catalog, executor, references, ledger, and journal |
-| `src/testing`      | Fake harnesses and Storybook test doubles                          |
-| `src/cli`          | Commander parsing, JSON output, and process exit adaptation        |
+| Module             | Responsibility                                                                   |
+| ------------------ | -------------------------------------------------------------------------------- |
+| `src/protocol`     | W3C parsing, actions, capabilities, timeouts, and errors                         |
+| `src/server`       | HTTP routing, target registry, sessions, windows, and elements                   |
+| `src/host`         | Platform-neutral `DesktopHost` and target contracts                              |
+| `src/hosts/fake`   | Deterministic in-memory provider                                                 |
+| `src/hosts/native` | Long-lived helper process and `DesktopHost` adapter                              |
+| `src/native`       | Build, cache, resolution, verification, manifests, and wire types                |
+| `native/macos`     | Swift operating-system implementation                                            |
+| `native/windows`   | Shared C++ Windows and Win32 implementation                                      |
+| `src/client`       | Low-level typed W3C client                                                       |
+| `src/wdio`         | Sanctioned WebdriverIO integration and custom commands                           |
+| `src/authoring`    | Serializable story plans, selectors, capabilities, results, and case descriptors |
+| `src/runner`       | Filtering, sharding, execution, and result classification                        |
+| `src/artifacts`    | Confined atomic evidence                                                         |
+| `src/agent`        | Bounded JSON-safe operations                                                     |
+| `src/operations`   | Agent operation catalog, executor, references, ledger, and journal               |
+| `src/testing`      | Fake harnesses and Storybook test doubles                                        |
+| `src/cli`          | Commander parsing, JSON output, and process exit adaptation                      |
 
 ## Deliberate boundaries
 
diff --git a/packages/agentic/desktop-driver/references/contributing.md b/packages/agentic/desktop-driver/references/contributing.md
index 40e9c15a12..9d519cef3c 100644
--- a/packages/agentic/desktop-driver/references/contributing.md
+++ b/packages/agentic/desktop-driver/references/contributing.md
@@ -23,7 +23,7 @@ change-oriented guidance.
 | `src/native`       | Source build, cache, selection, verification, and native artifact types |
 | `native/macos`     | Swift implementation and self-test                                      |
 | `native/windows`   | Shared C++ Windows/Win32 implementation and self-test                   |
-| `src/authoring`    | Static JSON plan and result schemas                                     |
+| `src/authoring`    | Static JSON plan and result schemas, and the case descriptor            |
 | `src/runner`       | Plan selection, capability checks, execution, and classification        |
 | `src/wdio`         | Sanctioned WebdriverIO connection and commands                          |
 | `src/client`       | Low-level typed W3C client                                              |
@@ -38,6 +38,39 @@ Do not duplicate native build, cache, or verification logic in Storybook
 consumers. Do not move Storybook manifest generation or app lifecycle into this
 package.
 
+## Case descriptors and input lanes
+
+`src/authoring/input.ts` and `src/authoring/selection.ts` are the one
+implementation of the test case descriptor (`requires`, `input`, `platforms`,
+`scope`, and declared gaps). Storybook extraction and its runner, and the
+desktop-test Jasmine adapter, all call them; do not reimplement validation,
+merging, or a decision in a consumer. Keep both files pure data and functions,
+with no Node, React, or WebdriverIO imports, because stories and workers load
+them. `input.ts` also has no runtime imports at all (its one import is a type),
+and the `./authoring/input` subpath exports it directly: desktop-test's config
+loader reads scope domains from it, and a config file is loaded from source
+through a CommonJS fallback that cannot resolve this package's `.js`
+specifiers, so keep it that way.
+
+- Add a requirement to `desktopRequirements`, to the physical or accessible
+  requirement set in `input.ts` when it implies an input, and to the
+  `requirementFeature` map in `selection.ts` for the host feature that backs it,
+  together. A requirement whose feature a host did not report is unmet.
+- `mergeDesktopCaseOptions` only narrows: requirements union, `platforms` and
+  `scope` intersect, and a nested declaration can never widen or change its
+  group's input. An overlap that is empty is an error because the case could
+  never run. A group cannot carry a gap.
+- `decideDesktopCase` judges platform, then scope, then the lane, so a case is
+  excluded for one reason. It resolves a declared gap too, so an expired
+  quarantine stops a run before anything executes.
+- `resolveDesktopClickMode` lets a lane decide the click mode outright. That is
+  how one `click` requirement is an accessibility click in the accessible lane
+  and a physical click in the physical lane.
+- `accessibleLaneMaskedFeatures` (`keyboard`, `physicalClick`, `wheel`) is what
+  an accessible lane disables through the native host's `disabledInputFeatures`,
+  and `unmaskedAccessibleFeatures` fails closed when a host reports any of them
+  as still available. Change the set together with the hosts that apply it.
+
 ## Behavioral rules
 
 - Reserve a target before asynchronous launch or attach.
diff --git a/packages/agentic/desktop-driver/references/test-integration.md b/packages/agentic/desktop-driver/references/test-integration.md
index 82e57e60be..6e09fb1c46 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -98,15 +98,24 @@ exits, including on assertion failures, timeouts, or crashes. WebdriverIO's
 sets `waitforInterval` (100 ms) and `waitforTimeout` (5 s) explicitly; without
 an interval, `waitUntil` and `waitFor*` stop after their first unsatisfied poll.
 
-Storybook's preferred top-level `wdio` functions and named function collections
-use this pattern with Node's built-in test runner. Each function receives the
-target `platform` (`macos`, `windows`, or `win32`), and each named case gets an
-independent worker/session. Native feature flags are typed on the WebdriverIO
-browser's `furn:features` capability. Button now uses this authoring pattern
-instead of serializable plans. Extraction, native-bundle stripping, runner
-configuration, and source freshness belong to
-`@fluentui-react-native/storybook-desktop`,
-not this Storybook-independent package. Static plans below are unchanged.
+Storybook's preferred top-level `wdio` export is an array of `desktopIt` cases,
+which declare the input and platforms they need. Its older functions and named
+function collections use the same pattern with Node's built-in test runner.
+Each function receives the target `platform` (`macos`, `windows`, or `win32`),
+and each named case gets an independent worker/session. Native feature flags are
+typed on the WebdriverIO browser's `furn:features` capability. Button now uses
+this authoring pattern instead of serializable plans. Extraction, native-bundle
+stripping, runner configuration, and source freshness belong to
+`@fluentui-react-native/storybook-desktop`, not this Storybook-independent
+package. Static plans below are unchanged.
+
+The descriptor that `desktopIt` accepts (`requires`, `input`, `platforms`,
+`scope`, and declared gaps) is defined and decided in `./authoring`, so Storybook
+and `desktop-test` share one implementation. A runner that executes one input lane
+pins `furn:clickMode` with `resolveDesktopClickMode`: `element.click()` is then an
+accessibility click in the accessible lane and a physical click in the physical
+lane. `missingDesktopRequirements` judges a case's `requires` against the
+session's `furn:features`, and judges a `click` requirement by the pinned mode.
 
 ## Author portable story plans
 
diff --git a/packages/agentic/desktop-driver/src/authoring/index.ts b/packages/agentic/desktop-driver/src/authoring/index.ts
index 0fd5cd6695..96cae618c8 100644
--- a/packages/agentic/desktop-driver/src/authoring/index.ts
+++ b/packages/agentic/desktop-driver/src/authoring/index.ts
@@ -14,15 +14,39 @@ export {
   desktopStoryPlatforms,
   validateDesktopStoryTests,
 } from './storyTests.js';
-export { desktopRequirements, matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './input.js';
+export {
+  accessibleLaneMaskedFeatures,
+  desktopInputLanes,
+  desktopRequirements,
+  matchesDesktopPlatforms,
+  matchesDesktopScope,
+  mergeDesktopCaseOptions,
+  resolveDesktopInput,
+  resolveDesktopScopeDomains,
+  resolveDesktopScopeValues,
+  unmaskedAccessibleFeatures,
+  validateDesktopCaseOptions,
+  validateDesktopGroupOptions,
+} from './input.js';
 export type {
+  AccessibleLaneMaskedFeature,
   DesktopCaseOptions,
   DesktopInput,
   DesktopInputLane,
   DesktopPlatforms,
   DesktopRequirement,
+  DesktopScopeDomains,
+  DesktopScopeValues,
   ResolvedDesktopCaseOptions,
 } from './input.js';
+export { decideDesktopCase, missingDesktopRequirements, resolveDesktopClickMode } from './selection.js';
+export type {
+  DesktopCaseClickMode,
+  DesktopCaseDecision,
+  DesktopCaseTarget,
+  DesktopDeclaredGap,
+  DesktopExclusionReason,
+} from './selection.js';
 export type {
   DesktopStoryCapability,
   DesktopStoryExpectation,
diff --git a/packages/agentic/desktop-driver/src/authoring/input.test.ts b/packages/agentic/desktop-driver/src/authoring/input.test.ts
index 1c02abba19..0077d51cfc 100644
--- a/packages/agentic/desktop-driver/src/authoring/input.test.ts
+++ b/packages/agentic/desktop-driver/src/authoring/input.test.ts
@@ -1,4 +1,88 @@
-import { matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './input.js';
+import {
+  accessibleLaneMaskedFeatures,
+  matchesDesktopPlatforms,
+  matchesDesktopScope,
+  mergeDesktopCaseOptions,
+  resolveDesktopInput,
+  resolveDesktopScopeDomains,
+  resolveDesktopScopeValues,
+  unmaskedAccessibleFeatures,
+  validateDesktopCaseOptions,
+  validateDesktopGroupOptions,
+} from './input.js';
+
+describe('accessible lane masks', () => {
+  test('lists the features a lane must hide, and fails closed when a host does not report them', () => {
+    expect(accessibleLaneMaskedFeatures).toEqual(['keyboard', 'physicalClick', 'wheel']);
+    expect(unmaskedAccessibleFeatures({ keyboard: false, physicalClick: false, wheel: false, focus: true })).toEqual([]);
+    expect(unmaskedAccessibleFeatures({ keyboard: true, physicalClick: false, wheel: false })).toEqual(['keyboard']);
+    expect(unmaskedAccessibleFeatures({ keyboard: false })).toEqual(['physicalClick', 'wheel']);
+    expect(unmaskedAccessibleFeatures(undefined)).toEqual(['keyboard', 'physicalClick', 'wheel']);
+    expect(unmaskedAccessibleFeatures('masked')).toEqual(['keyboard', 'physicalClick', 'wheel']);
+  });
+});
+
+describe('desktop option groups', () => {
+  const group = (options: object) => validateDesktopGroupOptions(options);
+  const kase = (options: object) => validateDesktopCaseOptions(options);
+
+  test('a group cannot declare a gap, because a gap describes one case', () => {
+    expect(() => group({ unsupported: { platforms: ['win32'], reason: 'No.' } })).toThrow('declare the gap on the case');
+    expect(() => group({ quarantine: { issue: '#1', reason: 'Flaky.', expires: '2099-01-01' } })).toThrow('declare the gap on the case');
+  });
+
+  test('composes requirements, platforms and scope, and derives the input from the union', () => {
+    const merged = mergeDesktopCaseOptions(
+      group({ requires: ['wheel'], platforms: ['!win32'], scope: { 'rn.renderer': ['fabric', 'paper'] } }),
+      kase({ requires: ['wheel', 'focus'], platforms: ['windows', 'win32'], scope: { 'rn.renderer': ['fabric'] } }),
+    );
+    expect(merged).toEqual({
+      requires: ['wheel', 'focus'],
+      platforms: ['windows'],
+      scope: { 'rn.renderer': ['fabric'] },
+      input: 'physical',
+      inputSource: 'derived',
+    });
+  });
+
+  test('returns the case unchanged outside any group', () => {
+    const options = kase({ requires: ['click'] });
+    expect(mergeDesktopCaseOptions(undefined, options)).toBe(options);
+  });
+
+  test('lets a group narrow the input, but a nested declaration can never widen or switch it', () => {
+    const physical = group({ input: 'physical' });
+    expect(mergeDesktopCaseOptions(physical, kase({}))).toMatchObject({ input: 'physical', inputSource: 'declared' });
+    expect(mergeDesktopCaseOptions(physical, kase({ input: 'physical' }))).toMatchObject({ input: 'physical' });
+    expect(() => mergeDesktopCaseOptions(physical, kase({ input: 'both' }))).toThrow('cannot change the enclosing group');
+    expect(() => mergeDesktopCaseOptions(physical, kase({ input: 'accessible' }))).toThrow('cannot change the enclosing group');
+    expect(() => mergeDesktopCaseOptions(physical, kase({ requires: ['accessibility-click'] }))).toThrow('cannot widen');
+  });
+
+  test('keeps a group that requires a transport from being widened or mixed by a case', () => {
+    const keyboard = group({ requires: ['keyboard'] });
+    expect(() => mergeDesktopCaseOptions(keyboard, kase({ input: 'both' }))).toThrow('cannot widen');
+    expect(() => mergeDesktopCaseOptions(keyboard, kase({ requires: ['accessibility-click'] }))).toThrow('split the case');
+  });
+
+  test('an explicit both on a group narrows nothing', () => {
+    const open = group({ input: 'both' });
+    expect(mergeDesktopCaseOptions(open, kase({ requires: ['keyboard'] }))).toMatchObject({ input: 'physical', inputSource: 'derived' });
+    expect(mergeDesktopCaseOptions(open, kase({}))).toMatchObject({ input: 'both', inputSource: 'derived' });
+  });
+
+  test('rejects a case that could never run', () => {
+    expect(() => mergeDesktopCaseOptions(group({ platforms: ['win32'] }), kase({ platforms: ['!win32'] }))).toThrow('could never run');
+    expect(() =>
+      mergeDesktopCaseOptions(group({ scope: { 'rn.renderer': ['fabric'] } }), kase({ scope: { 'rn.renderer': ['paper'] } })),
+    ).toThrow('could never run');
+  });
+
+  test('carries a case gap through its groups', () => {
+    const unsupported = { platforms: ['win32'], reason: 'Win32 keeps the cycle behavior.', issue: '#4377' } as const;
+    expect(mergeDesktopCaseOptions(group({ requires: ['keyboard'] }), kase({ unsupported }))).toMatchObject({ unsupported });
+  });
+});
 
 describe('desktop input descriptors', () => {
   test.each([
@@ -30,3 +114,42 @@ describe('desktop input descriptors', () => {
     expect(() => validateDesktopCaseOptions({ requires: ['input'] })).toThrow('unsupported requirement');
   });
 });
+
+describe('desktop scope domains', () => {
+  const domains = resolveDesktopScopeDomains({ flavor: ['stable', 'insider'] });
+  const supplied = resolveDesktopScopeValues({ 'rn.renderer': 'fabric', flavor: 'stable' }, domains);
+
+  test('merges custom domains with the built-in renderer and reserves rn.*', () => {
+    expect(domains).toEqual({ 'rn.renderer': ['fabric', 'paper'], flavor: ['stable', 'insider'] });
+    expect(resolveDesktopScopeDomains()).toEqual({ 'rn.renderer': ['fabric', 'paper'] });
+    expect(() => resolveDesktopScopeDomains({ 'rn.renderer': ['x'] })).toThrow('reserved');
+    expect(() => resolveDesktopScopeDomains({ 'rn.other': ['x'] })).toThrow('reserved');
+    expect(() => resolveDesktopScopeDomains({ Flavor: ['x'] })).toThrow('invalid key');
+    expect(() => resolveDesktopScopeDomains({ flavor: [] })).toThrow('non-empty');
+  });
+
+  test('rejects supplied values outside their domain', () => {
+    expect(() => resolveDesktopScopeValues({ unknown: 'a' }, domains)).toThrow('unknown scope key');
+    expect(() => resolveDesktopScopeValues({ 'rn.renderer': 'metal' }, domains)).toThrow('must be one of: fabric, paper');
+    expect(() => resolveDesktopScopeValues({ flavor: 3 }, domains)).toThrow('must be one of');
+    expect(() => resolveDesktopScopeValues({ constructor: 'a' }, domains)).toThrow('unknown scope key');
+  });
+
+  test('ORs values within a key and ANDs keys', () => {
+    expect(matchesDesktopScope(undefined, supplied, domains)).toBe(true);
+    expect(matchesDesktopScope({ 'rn.renderer': ['fabric', 'paper'] }, supplied, domains)).toBe(true);
+    expect(matchesDesktopScope({ 'rn.renderer': ['paper'] }, supplied, domains)).toBe(false);
+    expect(matchesDesktopScope({ 'rn.renderer': ['fabric'], flavor: ['stable'] }, supplied, domains)).toBe(true);
+    expect(matchesDesktopScope({ 'rn.renderer': ['fabric'], flavor: ['insider'] }, supplied, domains)).toBe(false);
+  });
+
+  test('treats an undeclared key or value, or an unsupplied key, as a configuration error even when another key excludes', () => {
+    expect(() => matchesDesktopScope({ 'rn.renderer': ['paper'], missing: ['a'] }, supplied, domains)).toThrow(
+      'unknown scope key "missing"',
+    );
+    expect(() => matchesDesktopScope({ 'rn.renderer': ['paper'], flavor: ['beta'] }, supplied, domains)).toThrow('"beta"');
+    expect(() => matchesDesktopScope({ flavor: ['stable'] }, resolveDesktopScopeValues({}, domains), domains)).toThrow('not supplied');
+    const inherited: Record<string, [string, ...string[]]> = JSON.parse('{"constructor":["a"]}');
+    expect(() => matchesDesktopScope(inherited, supplied, domains)).toThrow('unknown scope key');
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/authoring/input.ts b/packages/agentic/desktop-driver/src/authoring/input.ts
index ee0e353c51..b81575801e 100644
--- a/packages/agentic/desktop-driver/src/authoring/input.ts
+++ b/packages/agentic/desktop-driver/src/authoring/input.ts
@@ -16,6 +16,21 @@ export const desktopRequirements = [
 export type DesktopRequirement = (typeof desktopRequirements)[number];
 export type DesktopInput = 'accessible' | 'physical' | 'both';
 export type DesktopInputLane = Exclude<DesktopInput, 'both'>;
+export const desktopInputLanes = ['accessible', 'physical'] as const satisfies readonly DesktopInputLane[];
+
+/**
+ * The input an accessible lane keeps from reaching the application. A host that reports any of these as anything other
+ * than `false` cannot back the lane, because a case could then deliver physical input without anyone noticing.
+ */
+export const accessibleLaneMaskedFeatures = ['keyboard', 'physicalClick', 'wheel'] as const;
+export type AccessibleLaneMaskedFeature = (typeof accessibleLaneMaskedFeatures)[number];
+
+/** The masked features a host still offers. A missing report counts as unmasked, so the check fails closed. */
+export function unmaskedAccessibleFeatures(features: unknown): readonly AccessibleLaneMaskedFeature[] {
+  const reported = typeof features === 'object' && features !== null ? (features as Readonly<Record<string, unknown>>) : {};
+  return accessibleLaneMaskedFeatures.filter((feature) => reported[feature] !== false);
+}
+
 export type DesktopPlatforms =
   | readonly [DesktopEndpoint, ...DesktopEndpoint[]]
   | readonly [`!${DesktopEndpoint}`, ...`!${DesktopEndpoint}`[]];
@@ -112,6 +127,78 @@ export function validateDesktopCaseOptions(value: unknown, source = 'desktop tes
   };
 }
 
+/**
+ * Validates the options of a group. A group scopes the cases inside it, so it can narrow where they run and add what they
+ * require, but a gap describes one case and cannot be declared on a group.
+ */
+export function validateDesktopGroupOptions(value: unknown, source = 'desktop group options'): ResolvedDesktopCaseOptions {
+  const options = validateDesktopCaseOptions(value, source);
+  if (options.unsupported || options.quarantine) {
+    throw new TypeError(`${source} cannot declare unsupported or quarantine; declare the gap on the case.`);
+  }
+  return options;
+}
+
+/**
+ * Composes the options of an enclosing group with those of a nested group or case. Requirements add up, platforms and
+ * scope values intersect, and `input` can only narrow, so nothing inside a group can claim less than the group's own setup
+ * needs. A combination that could never run is an error rather than a silent exclusion.
+ */
+export function mergeDesktopCaseOptions(
+  parent: ResolvedDesktopCaseOptions | undefined,
+  child: ResolvedDesktopCaseOptions,
+  source = 'desktop test options',
+): ResolvedDesktopCaseOptions {
+  if (!parent) return child;
+  const platforms = endpoints.filter(
+    (endpoint) => matchesDesktopPlatforms(parent.platforms, endpoint) && matchesDesktopPlatforms(child.platforms, endpoint),
+  );
+  if (platforms.length === 0) throw new TypeError(`${source}.platforms do not overlap the enclosing group's, so it could never run.`);
+  const scope = intersectScope(parent.scope, child.scope, source);
+  const input = mergeDeclaredInput(parent, child, source);
+  return validateDesktopCaseOptions(
+    {
+      ...(input ? { input } : {}),
+      requires: [...new Set([...(parent.requires ?? []), ...(child.requires ?? [])])],
+      ...(platforms.length < endpoints.length ? { platforms } : {}),
+      ...(scope ? { scope } : {}),
+      ...(child.unsupported ? { unsupported: child.unsupported } : {}),
+      ...(child.quarantine ? { quarantine: child.quarantine } : {}),
+    },
+    source,
+  );
+}
+
+function mergeDeclaredInput(
+  parent: ResolvedDesktopCaseOptions,
+  child: ResolvedDesktopCaseOptions,
+  source: string,
+): DesktopInput | undefined {
+  // An explicit `both` narrows nothing, so it must not stop a nested case from deriving a transport.
+  const enclosing = parent.inputSource === 'declared' && parent.input !== 'both' ? parent.input : undefined;
+  if (child.inputSource !== 'declared') return enclosing;
+  if (enclosing && child.input !== enclosing)
+    throw new TypeError(`${source}.input "${child.input}" cannot change the enclosing group's "${enclosing}".`);
+  return child.input;
+}
+
+function intersectScope(
+  parent: DesktopCaseOptions['scope'],
+  child: DesktopCaseOptions['scope'],
+  source: string,
+): Record<string, string[]> | undefined {
+  if (!parent && !child) return undefined;
+  const merged: Record<string, string[]> = {};
+  for (const key of new Set([...Object.keys(parent ?? {}), ...Object.keys(child ?? {})])) {
+    const left = parent?.[key];
+    const right = child?.[key];
+    const values = left && right ? left.filter((value) => right.includes(value)) : [...(left ?? right ?? [])];
+    if (values.length === 0) throw new TypeError(`${source}.scope.${key} does not overlap the enclosing group's, so it could never run.`);
+    merged[key] = values;
+  }
+  return merged;
+}
+
 export function matchesDesktopPlatforms(platforms: DesktopPlatforms | undefined, endpoint: DesktopEndpoint): boolean {
   if (platforms === undefined) return true;
   const negative = platforms[0].startsWith('!');
@@ -119,6 +206,67 @@ export function matchesDesktopPlatforms(platforms: DesktopPlatforms | undefined,
   return negative ? !values.includes(endpoint) : values.includes(endpoint);
 }
 
+/** Allowed values per scope key. */
+export type DesktopScopeDomains = Readonly<Record<string, readonly string[]>>;
+/** The one value a target holds for each scope key it supplies. */
+export type DesktopScopeValues = Readonly<Record<string, string>>;
+
+const builtInScopeDomains: DesktopScopeDomains = Object.freeze({ 'rn.renderer': Object.freeze(['fabric', 'paper']) });
+
+/**
+ * The built-in domains plus any custom ones. A consumer adds its own keys, such as a product flavor, but `rn.*` belongs to
+ * the framework so a test written for `rn.renderer` means the same thing everywhere.
+ */
+export function resolveDesktopScopeDomains(custom?: unknown, source = 'testScopes'): DesktopScopeDomains {
+  if (custom === undefined) return builtInScopeDomains;
+  const resolved: Record<string, readonly string[]> = { ...builtInScopeDomains };
+  for (const [key, values] of Object.entries(object(custom, source))) {
+    if (key.startsWith('rn.')) throw new TypeError(`${source} cannot declare "${key}"; the rn.* scope keys are reserved.`);
+    resolved[key] = Object.freeze([...scopeEntry(key, values, source)]);
+  }
+  return Object.freeze(resolved);
+}
+
+/** Checks that every key a target supplies is a known domain and that its value belongs to it. */
+export function resolveDesktopScopeValues(supplied: unknown, domains: DesktopScopeDomains, source = 'testScope'): DesktopScopeValues {
+  const resolved: Record<string, string> = {};
+  for (const [key, value] of Object.entries(object(supplied, source))) {
+    const domain = ownDomain(domains, key);
+    if (!domain) throw new TypeError(`${source} uses unknown scope key "${key}".`);
+    if (typeof value !== 'string' || !domain.includes(value)) throw new TypeError(`${source}.${key} must be one of: ${domain.join(', ')}.`);
+    resolved[key] = value;
+  }
+  return Object.freeze(resolved);
+}
+
+/**
+ * Values OR within a key and keys AND. An undeclared key or value, or a key the target does not supply, is a
+ * configuration error rather than an exclusion, so a typo cannot silently drop a case. Every key is checked before the
+ * result is returned.
+ */
+export function matchesDesktopScope(
+  scope: DesktopCaseOptions['scope'],
+  supplied: DesktopScopeValues,
+  domains: DesktopScopeDomains,
+  source = 'desktop test scope',
+): boolean {
+  let matches = true;
+  for (const [key, values] of Object.entries(scope ?? {})) {
+    const domain = ownDomain(domains, key);
+    if (!domain) throw new TypeError(`${source} uses unknown scope key "${key}".`);
+    const unknown = values.find((value) => !domain.includes(value));
+    if (unknown !== undefined) throw new TypeError(`${source}.${key} uses "${unknown}", which is not one of: ${domain.join(', ')}.`);
+    const actual = Object.hasOwn(supplied, key) ? supplied[key] : undefined;
+    if (actual === undefined) throw new TypeError(`${source}.${key} is not supplied by this target.`);
+    if (!values.includes(actual)) matches = false;
+  }
+  return matches;
+}
+
+function ownDomain(domains: DesktopScopeDomains, key: string): readonly string[] | undefined {
+  return Object.hasOwn(domains, key) ? domains[key] : undefined;
+}
+
 function validatePlatforms(value: unknown, source: string, required = false): void {
   if (value === undefined && !required) return;
   if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${source} must be a non-empty platform list.`);
@@ -138,19 +286,21 @@ function validatePlatforms(value: unknown, source: string, required = false): vo
 
 function validateScope(value: unknown, source: string): void {
   if (value === undefined) return;
-  const scope = object(value, source);
-  for (const [key, values] of Object.entries(scope)) {
-    if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(key)) throw new TypeError(`${source} contains invalid key "${key}".`);
-    if (!Array.isArray(values) || values.length === 0) throw new TypeError(`${source}.${key} must be a non-empty value list.`);
-    const seen = new Set<string>();
-    for (const item of values) {
-      if (typeof item !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(item)) {
-        throw new TypeError(`${source}.${key} contains an invalid value.`);
-      }
-      if (seen.has(item)) throw new TypeError(`${source}.${key} contains duplicate "${item}".`);
-      seen.add(item);
+  for (const [key, values] of Object.entries(object(value, source))) scopeEntry(key, values, source);
+}
+
+function scopeEntry(key: string, values: unknown, source: string): readonly string[] {
+  if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(key)) throw new TypeError(`${source} contains invalid key "${key}".`);
+  if (!Array.isArray(values) || values.length === 0) throw new TypeError(`${source}.${key} must be a non-empty value list.`);
+  const seen = new Set<string>();
+  for (const item of values) {
+    if (typeof item !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(item)) {
+      throw new TypeError(`${source}.${key} contains an invalid value.`);
     }
+    if (seen.has(item)) throw new TypeError(`${source}.${key} contains duplicate "${item}".`);
+    seen.add(item);
   }
+  return values as readonly string[];
 }
 
 function object(value: unknown, source: string): Record<string, unknown> {
diff --git a/packages/agentic/desktop-driver/src/authoring/selection.test.ts b/packages/agentic/desktop-driver/src/authoring/selection.test.ts
new file mode 100644
index 0000000000..2a8505dafc
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/authoring/selection.test.ts
@@ -0,0 +1,96 @@
+import { resolveDesktopScopeDomains, resolveDesktopScopeValues, validateDesktopCaseOptions } from './input.js';
+import { decideDesktopCase, missingDesktopRequirements, resolveDesktopClickMode } from './selection.js';
+import type { DesktopCaseTarget } from './selection.js';
+
+describe('decideDesktopCase', () => {
+  const domains = resolveDesktopScopeDomains();
+  const target = (overrides: Partial<DesktopCaseTarget> = {}): DesktopCaseTarget => ({
+    endpoint: 'windows',
+    domains,
+    values: resolveDesktopScopeValues({ 'rn.renderer': 'fabric' }, domains),
+    now: Date.parse('2026-01-01T00:00:00Z'),
+    ...overrides,
+  });
+  const decide = (options: object, overrides?: Partial<DesktopCaseTarget>) =>
+    decideDesktopCase(validateDesktopCaseOptions(options), target(overrides), 'story / case');
+
+  test('runs a case that applies, and ignores the input outside a lane', () => {
+    expect(decide({})).toEqual({ kind: 'run' });
+    expect(decide({ requires: ['keyboard'] })).toEqual({ kind: 'run' });
+    expect(decide({ requires: ['keyboard'] }, { lane: 'physical' })).toEqual({ kind: 'run' });
+  });
+
+  test('excludes by the first applicable reason: platform, then scope, then input', () => {
+    const options = { platforms: ['macos'], scope: { 'rn.renderer': ['paper'] }, requires: ['keyboard'] };
+    expect(decide(options, { lane: 'accessible' })).toEqual({ kind: 'excluded', reason: 'platform' });
+    expect(decide({ ...options, platforms: ['windows'] }, { lane: 'accessible' })).toEqual({ kind: 'excluded', reason: 'scope' });
+    expect(decide({ ...options, platforms: ['windows'], scope: { 'rn.renderer': ['fabric'] } }, { lane: 'accessible' })).toEqual({
+      kind: 'excluded',
+      reason: 'input',
+    });
+  });
+
+  test('keeps a case that runs in both lanes', () => {
+    expect(decide({ requires: ['click'] }, { lane: 'accessible' })).toEqual({ kind: 'run' });
+    expect(decide({ requires: ['click'] }, { lane: 'physical' })).toEqual({ kind: 'run' });
+  });
+
+  test('resolves a declared unsupported case as a gap instead of running or excluding it', () => {
+    const unsupported = { platforms: ['windows'], reason: 'Not projected yet.' };
+    expect(decide({ unsupported })).toEqual({ kind: 'gap', gap: { kind: 'unsupported', reason: 'Not projected yet.' } });
+    expect(decide({ unsupported }, { endpoint: 'macos' })).toEqual({ kind: 'run' });
+  });
+
+  test('applies a quarantine to its lane and platforms, and rejects an expired one before anything runs', () => {
+    const quarantine = { issue: '#9', reason: 'Flaky.', expires: '2026-06-01', input: 'physical', platforms: ['windows'] };
+    expect(decide({ quarantine }, { lane: 'physical' })).toEqual({ kind: 'gap', gap: { kind: 'quarantine', reason: '#9: Flaky.' } });
+    expect(decide({ quarantine }, { lane: 'accessible' })).toEqual({ kind: 'run' });
+    expect(decide({ quarantine })).toEqual({ kind: 'run' });
+    expect(decide({ quarantine }, { endpoint: 'win32', lane: 'physical' })).toEqual({ kind: 'run' });
+    expect(() => decide({ quarantine }, { lane: 'physical', now: Date.parse('2026-06-02T00:00:00Z') })).toThrow(
+      'Quarantine #9 expired on 2026-06-01.',
+    );
+  });
+});
+
+describe('click mode and requirement preflight', () => {
+  test('adapts a click requirement to the lane without falling back to the other transport', () => {
+    const descriptor = validateDesktopCaseOptions({ requires: ['click'] });
+    const accessibleMode = resolveDesktopClickMode(descriptor, 'auto', 'accessible');
+    const physicalMode = resolveDesktopClickMode(descriptor, 'auto', 'physical');
+    expect(accessibleMode).toBe('accessibility');
+    expect(physicalMode).toBe('physical');
+    expect(missingDesktopRequirements(descriptor, { accessibilityClick: true, physicalClick: false }, physicalMode)).toEqual(['click']);
+    expect(missingDesktopRequirements(descriptor, { accessibilityClick: false, physicalClick: true }, accessibleMode)).toEqual(['click']);
+    expect(missingDesktopRequirements(descriptor, { accessibilityClick: true }, accessibleMode)).toEqual([]);
+  });
+
+  test('outside a lane only an accessible case pins its click transport, and the rest keep the configured mode', () => {
+    expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['accessibility-click'] }), 'auto', undefined)).toBe(
+      'accessibility',
+    );
+    expect(resolveDesktopClickMode(validateDesktopCaseOptions({ input: 'accessible' }), 'physical', undefined)).toBe('accessibility');
+    // A physical case must not pin physical click, or a host that masks it fails the session instead of reporting unsupported.
+    expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['physical-click'] }), 'auto', undefined)).toBe('auto');
+    expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['keyboard'] }), 'auto', undefined)).toBe('auto');
+    expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['click'] }), 'physical', undefined)).toBe('physical');
+    expect(resolveDesktopClickMode(undefined, 'auto', undefined)).toBe('auto');
+  });
+
+  test('an automatic click needs either transport, and an absent report meets nothing', () => {
+    const click = validateDesktopCaseOptions({ requires: ['click'] });
+    expect(missingDesktopRequirements(click, { physicalClick: false, accessibilityClick: false }, 'auto')).toEqual(['click']);
+    expect(missingDesktopRequirements(click, { physicalClick: true }, 'auto')).toEqual([]);
+    expect(missingDesktopRequirements(validateDesktopCaseOptions({ requires: ['keyboard', 'focus'] }), undefined, 'auto')).toEqual([
+      'keyboard',
+      'focus',
+    ]);
+    expect(
+      missingDesktopRequirements(
+        validateDesktopCaseOptions({ requires: ['element-screenshot', 'set-window-rect'] }),
+        { elementScreenshot: true, setWindowRect: false },
+        'auto',
+      ),
+    ).toEqual(['set-window-rect']);
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/authoring/selection.ts b/packages/agentic/desktop-driver/src/authoring/selection.ts
new file mode 100644
index 0000000000..383ce5896f
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/authoring/selection.ts
@@ -0,0 +1,116 @@
+import type { DesktopEndpoint } from '../protocol/types.js';
+import { matchesDesktopPlatforms, matchesDesktopScope } from './input.js';
+import type { DesktopInputLane, DesktopRequirement, DesktopScopeDomains, DesktopScopeValues, ResolvedDesktopCaseOptions } from './input.js';
+
+/** Why a declared case is not part of a run. Excluded cases are not tests, so they are counted and never reported as skipped. */
+export type DesktopExclusionReason = 'platform' | 'scope' | 'input';
+
+/** A gap the author declared in advance. The case is selected and reported as unsupported, not executed. */
+export type DesktopDeclaredGap = { kind: 'unsupported' | 'quarantine'; reason: string };
+
+/** What a case is judged against: the endpoint and scope values of the target, and the input lane of the run if it has one. */
+export type DesktopCaseTarget = {
+  endpoint: DesktopEndpoint;
+  lane?: DesktopInputLane;
+  domains: DesktopScopeDomains;
+  values: DesktopScopeValues;
+  /** Clock for quarantine expiry. */
+  now?: number;
+};
+
+export type DesktopCaseDecision =
+  | { kind: 'excluded'; reason: DesktopExclusionReason }
+  | { kind: 'gap'; gap: DesktopDeclaredGap }
+  | { kind: 'run' };
+
+/**
+ * Decides one declared case before it executes. The first applicable reason wins, in platform, scope, input order, so a
+ * case never counts against two exclusions. A declared gap is resolved here too, which is why an expired quarantine
+ * stops the run before anything executes.
+ */
+export function decideDesktopCase(descriptor: ResolvedDesktopCaseOptions, target: DesktopCaseTarget, source: string): DesktopCaseDecision {
+  if (!matchesDesktopPlatforms(descriptor.platforms, target.endpoint)) return { kind: 'excluded', reason: 'platform' };
+  if (!matchesDesktopScope(descriptor.scope, target.values, target.domains, `${source} scope`))
+    return { kind: 'excluded', reason: 'scope' };
+  if (target.lane && descriptor.input !== 'both' && descriptor.input !== target.lane) return { kind: 'excluded', reason: 'input' };
+  const gap = declaredGap(descriptor, target);
+  return gap ? { kind: 'gap', gap } : { kind: 'run' };
+}
+
+/** How a session turns a click into input. `auto` lets the host pick; the other two pin one transport. */
+export type DesktopCaseClickMode = 'auto' | 'physical' | 'accessibility';
+
+/**
+ * The click mode a case runs under. A lane decides it outright, so a `click` requirement is an accessible click in the
+ * accessible lane and a physical click in the physical lane. Without a lane only an accessible case pins its transport,
+ * so it never moves the pointer. Any other case keeps the configured mode: a physical case on a host that masks physical
+ * click is then reported unsupported by the requirement preflight, as the skip it replaces was, instead of failing to
+ * create its session.
+ */
+export function resolveDesktopClickMode(
+  descriptor: ResolvedDesktopCaseOptions | undefined,
+  configured: DesktopCaseClickMode,
+  lane: DesktopInputLane | undefined,
+): DesktopCaseClickMode {
+  if (lane === 'accessible') return 'accessibility';
+  if (lane === 'physical') return 'physical';
+  if (descriptor?.input === 'accessible' || descriptor?.requires?.includes('accessibility-click')) return 'accessibility';
+  return configured;
+}
+
+/** The requirements a host cannot meet. `features` is what the host reported for the session; an absent report meets nothing. */
+export function missingDesktopRequirements(
+  descriptor: ResolvedDesktopCaseOptions | undefined,
+  features: Readonly<Record<string, unknown>> | undefined,
+  clickMode: DesktopCaseClickMode,
+): DesktopRequirement[] {
+  if (!descriptor?.requires?.length) return [];
+  const missing: DesktopRequirement[] = [];
+  for (const requirement of descriptor.requires) {
+    if (requirement === 'click') {
+      const met =
+        clickMode === 'physical'
+          ? features?.physicalClick === true
+          : clickMode === 'accessibility'
+            ? features?.accessibilityClick === true
+            : features?.physicalClick === true || features?.accessibilityClick === true;
+      if (!met) missing.push(requirement);
+    } else if (features?.[requirementFeature[requirement]] !== true) {
+      missing.push(requirement);
+    }
+  }
+  return missing;
+}
+
+/** The host feature that backs each requirement other than `click`, which depends on the click mode. */
+const requirementFeature: Record<Exclude<DesktopRequirement, 'click'>, string> = {
+  'accessibility-actions': 'accessibilityActions',
+  'accessibility-click': 'accessibilityClick',
+  'element-screenshot': 'elementScreenshot',
+  focus: 'focus',
+  keyboard: 'keyboard',
+  'physical-click': 'physicalClick',
+  screenshot: 'screenshot',
+  'set-window-rect': 'setWindowRect',
+  wheel: 'wheel',
+};
+
+function declaredGap(
+  descriptor: ResolvedDesktopCaseOptions,
+  { endpoint, lane, now = Date.now() }: DesktopCaseTarget,
+): DesktopDeclaredGap | undefined {
+  if (descriptor.unsupported && matchesDesktopPlatforms(descriptor.unsupported.platforms, endpoint)) {
+    return { kind: 'unsupported', reason: descriptor.unsupported.reason };
+  }
+  const quarantine = descriptor.quarantine;
+  if (
+    quarantine &&
+    (!quarantine.platforms || matchesDesktopPlatforms(quarantine.platforms, endpoint)) &&
+    (!quarantine.input || quarantine.input === lane)
+  ) {
+    if (Date.parse(`${quarantine.expires}T00:00:00Z`) < now)
+      throw new Error(`Quarantine ${quarantine.issue} expired on ${quarantine.expires}.`);
+    return { kind: 'quarantine', reason: `${quarantine.issue}: ${quarantine.reason}` };
+  }
+  return undefined;
+}
diff --git a/packages/agentic/desktop-driver/src/index.ts b/packages/agentic/desktop-driver/src/index.ts
index 3e556374bc..0479787d78 100644
--- a/packages/agentic/desktop-driver/src/index.ts
+++ b/packages/agentic/desktop-driver/src/index.ts
@@ -32,15 +32,39 @@ export {
   desktopStoryPlatforms,
   validateDesktopStoryTests,
 } from './authoring/storyTests.js';
-export { desktopRequirements, matchesDesktopPlatforms, resolveDesktopInput, validateDesktopCaseOptions } from './authoring/input.js';
+export {
+  accessibleLaneMaskedFeatures,
+  desktopInputLanes,
+  desktopRequirements,
+  matchesDesktopPlatforms,
+  matchesDesktopScope,
+  mergeDesktopCaseOptions,
+  resolveDesktopInput,
+  resolveDesktopScopeDomains,
+  resolveDesktopScopeValues,
+  unmaskedAccessibleFeatures,
+  validateDesktopCaseOptions,
+  validateDesktopGroupOptions,
+} from './authoring/input.js';
 export type {
+  AccessibleLaneMaskedFeature,
   DesktopCaseOptions,
   DesktopInput,
   DesktopInputLane,
   DesktopPlatforms,
   DesktopRequirement,
+  DesktopScopeDomains,
+  DesktopScopeValues,
   ResolvedDesktopCaseOptions,
 } from './authoring/input.js';
+export { decideDesktopCase, missingDesktopRequirements, resolveDesktopClickMode } from './authoring/selection.js';
+export type {
+  DesktopCaseClickMode,
+  DesktopCaseDecision,
+  DesktopCaseTarget,
+  DesktopDeclaredGap,
+  DesktopExclusionReason,
+} from './authoring/selection.js';
 export type {
   DesktopStoryCapability,
   DesktopStoryExpectation,
diff --git a/packages/agentic/desktop-test/package.json b/packages/agentic/desktop-test/package.json
index f86c5cecd6..8a01e622bb 100644
--- a/packages/agentic/desktop-test/package.json
+++ b/packages/agentic/desktop-test/package.json
@@ -55,6 +55,11 @@
       "import": "./lib/driverService.js",
       "default": "./src/driverService.ts"
     },
+    "./jasmine": {
+      "types": "./lib/jasmine/index.d.ts",
+      "import": "./lib/jasmine/index.js",
+      "default": "./src/jasmine/index.ts"
+    },
     "./wdio": {
       "types": "./lib/wdio/index.d.ts",
       "import": "./lib/wdio/index.js",
diff --git a/packages/agentic/desktop-test/references/commands.md b/packages/agentic/desktop-test/references/commands.md
index 47666999c4..817553b4bc 100644
--- a/packages/agentic/desktop-test/references/commands.md
+++ b/packages/agentic/desktop-test/references/commands.md
@@ -10,14 +10,15 @@ owner_paths:
 Expose `desktop-test` from the consumer workspace and run through that
 workspace's declared script.
 
-| Command                          | Purpose                                              |
-| -------------------------------- | ---------------------------------------------------- |
-| `build-driver`                   | Explicitly build or verify the native helper         |
-| `prep`, `bundle`, `build`, `run` | Run the selected target adapter stage                |
-| `test --suite <name> --list`     | Resolve groups without launching a target            |
-| `test --suite <name>`            | Run the selected WDIO suite                          |
-| `serve --reporter json`          | Start the real driver listener and required services |
-| `serve --agent`                  | Also require grants and publish an agent descriptor  |
+| Command                              | Purpose                                              |
+| ------------------------------------ | ---------------------------------------------------- |
+| `build-driver`                       | Explicitly build or verify the native helper         |
+| `prep`, `bundle`, `build`, `run`     | Run the selected target adapter stage                |
+| `test --suite <name> --list`         | Resolve groups without launching a target            |
+| `test --suite <name>`                | Run the selected WDIO suite                          |
+| `test --suite <name> --input <lane>` | Run one input lane (`accessible` or `physical`)      |
+| `serve --reporter json`              | Start the real driver listener and required services |
+| `serve --agent`                      | Also require grants and publish an agent descriptor  |
 
 Global reporter options are `--reporter auto|plain|github-actions|json|ndjson`
 and `--json` (an alias for `--reporter json`). Mode precedence is CLI flag,
@@ -58,6 +59,24 @@ For macOS RN Test App projects, run bundle before `prep`; CocoaPods embeds only
 resources present during pod installation. Changing the renderer requires
 rerunning `prep`. See [platform setup](platforms.md).
 
+## Input lanes
+
+`test --input accessible|physical` runs one input lane. `DESKTOP_INPUT` supplies
+the lane when the flag is absent, and an empty or unknown value is an error. The
+`accessible` lane starts the native host with keyboard, physical click, and wheel
+disabled and runs the tests that need no physical input; the `physical` lane
+runs tests that need it plus those that need neither. Tests declare which with
+the [`./jasmine` helpers](wdio-suites.md#declare-input-and-scope-in-jasmine-specs).
+A lane requires a Jasmine WDIO suite (or the Storybook suite, whose integration
+applies the lane itself) and rejects `--list`, which resolves spec files without
+regard to a lane. Without a lane every declared test runs, filtered by `platforms`
+and `scope`. See [input lanes in reporting](reporting.md#input-lanes) for how a
+lane run is judged.
+
+An imported integration that serves its own driver receives the lane and owns
+masking that driver. A host supplied through `hostFactory` is not masked by the
+harness, so the suite verifies the mask before running anything.
+
 The Storybook `csf-wdio` suite does not support generic `--list`. Discover story
 IDs with the Storybook integration's manifest/CLI, then select authored tests
 with its test filter. Use `storybook-desktop` smoke commands for a complete
diff --git a/packages/agentic/desktop-test/references/configuration.md b/packages/agentic/desktop-test/references/configuration.md
index 7895d23d4c..4a780442a7 100644
--- a/packages/agentic/desktop-test/references/configuration.md
+++ b/packages/agentic/desktop-test/references/configuration.md
@@ -37,6 +37,34 @@ The config schema rejects unknown fields, cycles, and unmatched spec patterns.
 Spec paths resolve against the suite project's root; target references and
 hooks resolve against their declaring config.
 
+## Scope domains
+
+A test can declare `scope` values so it runs only on some targets, such as one
+renderer or product flavor. Domains are declared in config. `rn.renderer`
+(`fabric`, `paper`) is built in and comes from the target's React Native host;
+the `rn.*` keys are reserved for the framework. A consumer that is not React
+Native, or that needs another dimension, lists its own keys in `testScopes`, each
+with a non-empty list of allowed values, and each target sets its own value in
+`testScope`:
+
+```ts
+export default defineDesktopConfig({
+  schemaVersion: 1,
+  projectRoot: new URL('.', import.meta.url),
+  testScopes: { flavor: ['stable', 'preview'] },
+  targets: {
+    windows: {
+      host: { kind: 'installed', application: { executablePath: 'C:\\apps\\Sample.exe', windowTitle: 'Sample' } },
+      testScope: { flavor: 'preview' },
+    },
+  },
+});
+```
+
+A `testScope` key that is not declared, a value outside its domain, or an attempt
+to set an `rn.*` key is a configuration error. So is a test scoped on a key its
+target does not supply: a typo or a missing value must not silently drop tests.
+
 ## Helper policy
 
 `nativeDriver` accepts only `cacheRoot`, `helperPath`, and `installRoot`.
diff --git a/packages/agentic/desktop-test/references/contributing.md b/packages/agentic/desktop-test/references/contributing.md
index d5f7175b95..ee9a698cc6 100644
--- a/packages/agentic/desktop-test/references/contributing.md
+++ b/packages/agentic/desktop-test/references/contributing.md
@@ -12,7 +12,18 @@ CLI stages are composed in `src/cli.ts`; process ownership is in
 `src/supervisor.ts`; shared native service, recovery, authority, descriptor and
 settled shutdown composition lives in the real `src/driverService.ts` module
 (also used by the Storybook channel child); reports are implemented in `src/reporting/`; and WDIO
-session wiring is in `src/wdio/`.
+session wiring is in `src/wdio/`. The `./jasmine` entry (`src/jasmine/`) holds the
+declaration helpers and the selection adapter that WDIO Jasmine suites use; input
+lane accounting is in `src/reporting/lane.ts`. Descriptor validation and per-case
+decisions come from `@fluentui-react-native/desktop-driver/authoring`, not from
+copies here.
+
+`src/config.ts` is also loaded from source through the CommonJS prebuild fallback
+that Storybook uses for `desktop.config.mts`, which cannot resolve desktop-driver's
+`.js` specifiers. Its runtime imports are therefore Node built-ins, sibling `.ts`
+modules and the leaf `@fluentui-react-native/desktop-driver/authoring/input`; import
+everything else from desktop-driver as types only. The storybook-desktop
+`sourceConfig` test guards this.
 
 Add contract coverage for schema, lifecycle, reporting protocol, and failure
 paths. Do not move Storybook-specific story extraction into this package.
diff --git a/packages/agentic/desktop-test/references/reporting.md b/packages/agentic/desktop-test/references/reporting.md
index 164b05dc64..4e91dc7319 100644
--- a/packages/agentic/desktop-test/references/reporting.md
+++ b/packages/agentic/desktop-test/references/reporting.md
@@ -65,6 +65,58 @@ directory or render a duplicate summary.
 Story-specific readiness, authenticated channel events, and callback execution
 are owned by `@fluentui-react-native/storybook-desktop`.
 
+## Input lanes
+
+A `test` run can execute one input lane (see [commands](commands.md#input-lanes)).
+Its report records the lane, counts what the run left out before executing, and
+holds every selected test to its declared outcome. `run.json` carries the lane as
+`{ input, source, masking?, policyEnforced }`:
+
+- `input`: `accessible` or `physical`.
+- `source`: `option` for `--input`, `environment` for `DESKTOP_INPUT`, or `driver`
+  when the lane was read from the driver instance a `test` attached to.
+- `masking` (accessible only): `host-masked` when this command started the host
+  with keyboard, physical click, and wheel disabled, or `verified-masked` when it
+  attached to a host and verified that mask before running anything.
+- `policyEnforced`: always `false`. The report records what was requested and how
+  the host was masked; it never claims what input a test delivered, so a physical
+  lane is labelled a pilot.
+
+Tests that a lane, a `platforms` list, or a `scope` leaves out are not tests, so
+they are never reported as skipped. A producer announces them in `selection`
+events, and `run.json` sums them as `selection.excluded: { platform, scope, input }`.
+A case counts once, under the first reason that applies in that order, and only if
+it matched the user's own filters, such as a story filter. A `selection` event
+with a `key` is counted once, so a retried worker that announces the same
+exclusions again does not double them. A run whose producers reported none has no
+`selection`.
+
+A lane run promised to execute its whole selection, so its verdict is stricter:
+
+- `failed`: a failed test or an infrastructure failure, as in any run.
+- `incomplete`: a selected test was skipped at run time, was `unsupported` with no
+  declaration (the host did not meet a `requires`), or no test executed. `optional`
+  never excuses these, so a lane that runs nothing is not reported `skipped`.
+- `passed`: otherwise. A test declared `unsupported` or `quarantine` is reported
+  unsupported without making the run incomplete. Summaries count them as
+  `N unsupported (N declared, N quarantined)` so an undeclared gap stands out.
+
+`failed` outranks `incomplete`, which outranks `passed`. A run without a lane keeps
+its existing verdict.
+
+The plain and GitHub summaries show the lane and exclusions on one line, such as
+`Selection: input accessible (host-masked) from --input; excluded 4 by platform, 0 by scope, 12 by input`.
+The JUnit file records the lane as the properties `desktop.input`,
+`desktop.input.label`, and `desktop.input.source`, the exclusions as
+`desktop.excluded.platform`, `desktop.excluded.scope`, and `desktop.excluded.input`,
+and `desktop.declaredUnsupported` and `desktop.quarantined` when present. The label
+is `accessible (host-masked)`, `accessible (verified-masked)`, or `physical pilot`.
+
+A delegated command, which inherits its parent's collector, sends its exclusions to
+the parent but not its lane, so the parent's `run.json` has no `lane`. The command
+still holds its own cohort to the lane: a Storybook `test` reports an incomplete
+cohort to the parent when a selected test has no declared gap and did not run.
+
 ## Persisted read queries
 
 The direct `@fluentui-react-native/desktop-test/reporting/run-queries` entry
@@ -117,7 +169,8 @@ external integration); `addSecret` can update the read redactor. The collector
 redacts before persistence, and queries redact again before clipping text.
 
 Readers submit only an opaque run ID, a declared operation, and its bounded
-parameters. `status` returns complete counts and terminal/coverage state.
+parameters. `status` returns complete counts, terminal/coverage state, and the
+run's input `lane` and `excluded` counts when it has them.
 `tests`, `work`, `failures`, and `artifacts` return pages with a default limit of
 10 and maximum of 25, capped at 16 KiB. Page IDs do not expose producer IDs or
 paths. Text fields are capped at 1 KiB after redaction. `omissions.items` counts
diff --git a/packages/agentic/desktop-test/references/wdio-suites.md b/packages/agentic/desktop-test/references/wdio-suites.md
index bf6a716e74..fa80879ec3 100644
--- a/packages/agentic/desktop-test/references/wdio-suites.md
+++ b/packages/agentic/desktop-test/references/wdio-suites.md
@@ -40,3 +40,68 @@ Prefer unique ids. A suite that depends on first-match lookup can set
 Component story callback extraction is owned by
 `@fluentui-react-native/storybook-desktop`; use this suite guide for ordinary
 WDIO suites and app-level E2E adapters.
+
+## Declare input and scope in Jasmine specs
+
+Declare each test with `desktopIt` and group tests with `desktopDescribe` from
+`@fluentui-react-native/desktop-test/jasmine`. They take the same descriptor as
+Storybook's `desktopIt` (`requires`, `input`, `platforms`, `scope`, `unsupported`,
+`quarantine`), and the options argument is optional:
+
+```ts
+import { desktopDescribe, desktopIt } from '@fluentui-react-native/desktop-test/jasmine';
+
+desktopDescribe('Button', () => {
+  desktopIt('renders', async () => {
+    await expect(await $('~button')).toBeDisplayed();
+  });
+  desktopIt('activates with Enter', { requires: ['keyboard'] }, async () => {
+    await browser.keys('\uE007');
+  });
+  desktopDescribe('Windows behavior', { platforms: ['windows', 'win32'] }, () => {
+    desktopIt('takes focus', { requires: ['focus'] }, async () => {
+      await expect(await $('~button')).toBeFocused();
+    });
+  });
+});
+```
+
+A group's options apply to everything inside it. Requirements add up, `platforms`
+and `scope` intersect, and a nested declaration can only narrow its group, so a
+combination that could never run is an error rather than a silent exclusion. A
+group cannot declare `unsupported` or `quarantine`; declare the gap on the test.
+A test's `input` comes from its `requires` unless declared; see "Declare how a case runs" in
+`@fluentui-react-native/storybook-desktop/references/story-tests.md`.
+A test that needs no input stays `both`.
+
+Run through `desktop-test test --suite <name>`, the harness hands each WDIO worker
+its endpoint, scope values, and optional lane as data in `DESKTOP_TEST_SELECTION`.
+Once the session exists and before any test runs, the adapter filters Jasmine's
+`specFilter`, so an excluded test never runs its hooks or body. Excluded tests
+are counted in the run's selection totals, not reported as skipped. A declared
+`unsupported` or active `quarantine` test is reported unsupported with its reason,
+and an expired quarantine fails that test. A test whose `requires` the host cannot
+meet is excluded the same way and reported unsupported.
+
+- **Lanes need declared tests.** An input lane runs only tests declared with
+  `desktopIt`. A test registered with plain `it` fails the run, which lists the first
+  ten, so migrate a whole file before running a lane against it. A plain `describe`
+  is fine; use `desktopDescribe` to scope its tests. Without a lane, plain specs run
+  unchanged.
+- **Click mode is session-wide.** WDIO owns the session, so the lane sets
+  `furn:clickMode` once: accessibility click in the accessible lane, physical
+  click in the physical lane. A `click` requirement follows it. Without a lane the
+  session uses `auto`, which lets the host choose.
+- **Untrustworthy selections fail closed.** A malformed selection, an unverifiable
+  Jasmine environment, or an accessible lane on a host that does not report keyboard,
+  physical click, and wheel disabled disables every test and fails the run.
+- **A bad declaration never throws.** Jasmine only warns when a spec file fails to
+  load, so a throw would silently drop every test after it. An invalid declaration
+  registers a failing test that reports the problem.
+- **Run outside the harness.** With no selection, such as plain `wdio`, every test
+  runs and descriptors are still validated.
+- `desktopIt` takes no timeout argument; the suite's `timeoutMs` applies.
+
+The input-call lint of Storybook cases does not apply here. Page objects and helpers
+hide the input a test sends, so the accessible lane's host mask is the safeguard that
+fails a test that reaches for physical input.
diff --git a/packages/agentic/desktop-test/src/cli.ts b/packages/agentic/desktop-test/src/cli.ts
index 833b7b1c29..3258f8a45e 100644
--- a/packages/agentic/desktop-test/src/cli.ts
+++ b/packages/agentic/desktop-test/src/cli.ts
@@ -11,15 +11,17 @@ import {
   tolerateClosedDesktopStdout,
 } from '@fluentui-react-native/desktop-driver/cli/reporter';
 import type { ResolvedDesktopReporterMode } from '@fluentui-react-native/desktop-driver/cli/reporter';
+import { desktopInputLanes } from '@fluentui-react-native/desktop-driver/authoring';
 import { desktopStageCommands } from './adapters.js';
 import { defaultAgentDescriptor } from './agentConnection.js';
 import type { DesktopAgentConnectionOptions } from './agentConnection.js';
 import { loadDesktopConfig, resolveDesktopSpecs, selectDesktopRenderer } from './config.js';
 import type { DesktopStage } from './config.js';
+import { createDesktopInputLane, desktopInputEnvironment, requestedDesktopInputLane } from './reporting/lane.js';
 import { createDesktopReportSession } from './reporting/session.js';
 import { DesktopStopRequested } from './services.js';
 import { DesktopSupervisor } from './supervisor.js';
-import { runDesktopWdioSuite } from './wdio/run.js';
+import { assertDesktopSuiteSupportsInput, runDesktopWdioSuite } from './wdio/run.js';
 
 type AgentFlags = { agent?: boolean; descriptor?: string; root?: string };
 
@@ -53,7 +55,13 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
     .command('test')
     .requiredOption('--suite <name>', 'configured suite')
     .option('--list', 'resolve exact spec groups without launching')
-    .action((options: { suite: string; list?: boolean }) => execute('test', options));
+    .addOption(
+      new Option(
+        '--input <lane>',
+        `run one input lane: accessible (keyboard, physical click and wheel masked) or physical; falls back to ${desktopInputEnvironment}`,
+      ).choices([...desktopInputLanes]),
+    )
+    .action((options: { suite: string; list?: boolean; input?: string }) => execute('test', options));
   let reporterMode: ResolvedDesktopReporterMode = 'plain';
   let reporterResolutionError: unknown;
   try {
@@ -82,7 +90,7 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
 
   async function execute(
     action: DesktopStage | 'build-driver' | 'serve' | 'test',
-    test?: { suite: string; list?: boolean },
+    test?: { suite: string; list?: boolean; input?: string },
     agentFlags: AgentFlags = {},
   ): Promise<void> {
     const options = program.opts<{
@@ -118,6 +126,11 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
     if (options.paper) target = selectDesktopRenderer(target, 'paper');
     const suite = test ? config.config.suites?.[test.suite] : undefined;
     if (test && !suite) throw Object.assign(new Error(`Unknown suite "${test.suite}".`), { code: 'config' });
+    if (test?.list && test.input !== undefined) {
+      throw Object.assign(new TypeError('--list resolves spec files, which do not depend on the input lane; omit --input.'), {
+        code: 'config',
+      });
+    }
     if (suite?.kind === 'wdio') {
       const specs = resolveDesktopSpecs(suite, target.endpoint, config.projectRoot);
       if (test?.list) {
@@ -131,6 +144,12 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
         return;
       }
     } else if (test?.list) throw Object.assign(new Error('--list currently requires a standalone WDIO suite.'), { code: 'config' });
+    // Only `test` has a lane. The environment stands in for the flag, but never for `--list`, which returned above.
+    const requestedLane = test
+      ? requestedDesktopInputLane({ flag: test.input, environment: process.env[desktopInputEnvironment] })
+      : undefined;
+    const input = requestedLane?.input;
+    if (suite?.kind === 'wdio') assertDesktopSuiteSupportsInput(test!.suite, suite, input);
     if (!agentFlags.agent && (agentFlags.descriptor !== undefined || agentFlags.root !== undefined))
       throw Object.assign(new TypeError('--descriptor and --root require --agent.'), { code: 'config' });
     // An integration serves through its own lifecycle, so it must publish the agent connection itself.
@@ -156,6 +175,7 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
       kind: action === 'test' ? 'tests' : 'lifecycle',
       optional: suite?.kind === 'wdio' && suite.optional,
       context: { endpoint: target.endpoint, renderer: target.host.renderer },
+      ...(requestedLane ? { lane: createDesktopInputLane(requestedLane.input, requestedLane.source) } : {}),
       reporterMode,
       eventLevel,
       suppressFinalOutput: action === 'serve' ? () => ready : false,
@@ -169,6 +189,7 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
       reportSession: session,
       integration: config.config.integration,
       ...(agent ? { agent } : {}),
+      ...(input ? { input } : {}),
     });
     session.onStop?.(() => owner.services.requestStop());
     const interrupt = () => owner.services.requestStop();
@@ -196,6 +217,7 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
             supervisor: owner,
             action,
             suite: test?.suite,
+            ...(input ? { input } : {}),
             ...(agent ? { agent } : {}),
             ...(action === 'serve' ? { reporterMode, onReady: markReady } : {}),
           }),
@@ -219,7 +241,7 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
             );
           markReady();
           await owner.services.guard(new Promise<never>(() => undefined));
-        } else if (suite?.kind === 'wdio') await runDesktopWdioSuite(owner, config, test!.suite);
+        } else if (suite?.kind === 'wdio') await runDesktopWdioSuite(owner, config, test!.suite, input);
         else throw new Error('The imported integration does not implement this suite.');
       }
     } catch (error) {
diff --git a/packages/agentic/desktop-test/src/config.ts b/packages/agentic/desktop-test/src/config.ts
index edf975b6bb..79fcd0ee85 100644
--- a/packages/agentic/desktop-test/src/config.ts
+++ b/packages/agentic/desktop-test/src/config.ts
@@ -4,6 +4,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createHash } from 'node:crypto';
 
 import type { DesktopEndpoint, DesktopRenderer, NativeDesktopApplicationDescriptor } from '@fluentui-react-native/desktop-driver';
+// The leaf subpath, not `/authoring`: a config file is also loaded from source through the CommonJS prebuild fallback,
+// which cannot resolve the `.js` specifiers inside the authoring index.
+import { resolveDesktopScopeDomains, resolveDesktopScopeValues } from '@fluentui-react-native/desktop-driver/authoring/input';
+import type { DesktopScopeDomains, DesktopScopeValues } from '@fluentui-react-native/desktop-driver/authoring/input';
 import type { DesktopReporterMode } from '@fluentui-react-native/desktop-driver/cli/reporter';
 import type { DesktopIntegration } from './integration.ts';
 
@@ -35,6 +39,11 @@ export type DesktopTargetConfig = {
   services?: readonly { id: string; command: DesktopCommand; readyUrl?: string }[];
   launchTimeoutMs?: number;
   nativeDriver?: { cacheRoot?: string; helperPath?: string; installRoot?: string };
+  /**
+   * The value this target holds for each custom `testScopes` key a test may scope on, such as a product flavor.
+   * `rn.renderer` is not set here; it comes from `host.renderer`.
+   */
+  testScope?: Readonly<Record<string, string>>;
 };
 
 export type DesktopTargetReference = { use: { config: string; target: string } };
@@ -68,6 +77,11 @@ export type DesktopConfig = {
   suites?: Readonly<Record<string, DesktopWdioSuite | { kind: 'csf-wdio' }>>;
   integration?: DesktopIntegration;
   reporting?: DesktopReportingConfig;
+  /**
+   * Custom scope domains: each key lists the values a test may scope on, and every target sets its own in `testScope`.
+   * The `rn.*` keys belong to the framework, so a consumer that is not React Native simply declares its own.
+   */
+  testScopes?: Readonly<Record<string, readonly [string, ...string[]]>>;
 };
 
 export type ResolvedDesktopTarget = DesktopTargetConfig & {
@@ -84,6 +98,8 @@ export type ResolvedDesktopConfig = {
   projectRoot: string;
   targets: Readonly<Record<string, ResolvedDesktopTarget>>;
   reporting: DesktopReportingConfig & { artifactsRoot: string };
+  /** The built-in scope domains plus this config's own. */
+  testScopes: DesktopScopeDomains;
 };
 
 const configNames = ['desktop.config.mts', 'desktop.config.ts', 'desktop.config.mjs', 'desktop.config.js', 'desktop.config.cjs'];
@@ -98,9 +114,10 @@ export function defineDesktopConfig<T extends DesktopConfig>(config: T): T {
 
 export function validateDesktopConfig(value: unknown): asserts value is DesktopConfig {
   const config = object(value, 'desktop config');
-  keys(config, ['schemaVersion', 'projectRoot', 'targets', 'suites', 'integration', 'reporting'], 'desktop config');
+  keys(config, ['schemaVersion', 'projectRoot', 'targets', 'suites', 'integration', 'reporting', 'testScopes'], 'desktop config');
   if (config.schemaVersion !== 1) throw new TypeError('Desktop config schemaVersion must be 1.');
   if (config.projectRoot !== undefined && !(config.projectRoot instanceof URL)) text(config.projectRoot, 'projectRoot');
+  const scopeDomains = resolveDesktopScopeDomains(config.testScopes);
   const targets = object(config.targets, 'targets');
   if (Object.keys(targets).length === 0) throw new TypeError('Desktop config must declare at least one target.');
   for (const [id, entry] of Object.entries(targets)) {
@@ -114,8 +131,9 @@ export function validateDesktopConfig(value: unknown): asserts value is DesktopC
       text(reference.target, `${id}.use.target`);
       continue;
     }
-    keys(target, ['endpoint', 'host', 'readiness', 'commands', 'services', 'launchTimeoutMs', 'nativeDriver'], `target ${id}`);
+    keys(target, ['endpoint', 'host', 'readiness', 'commands', 'services', 'launchTimeoutMs', 'nativeDriver', 'testScope'], `target ${id}`);
     oneOf(target.endpoint ?? id, endpoints, `${id}.endpoint`);
+    if (target.testScope !== undefined) validateTestScope(target.testScope, scopeDomains, id);
     const host = object(target.host, `${id}.host`);
     keys(host, ['kind', 'application', 'ownership', 'renderer', 'appConfigPath', 'component', 'windowTitle', 'bundleRoot'], `${id}.host`);
     oneOf(host.kind, ['installed', 'react-native-test-app', 'rex'], `${id}.host.kind`);
@@ -241,6 +259,8 @@ export async function loadDesktopConfig(configPath?: string, cwd = process.cwd()
     }
     return pending;
   };
+  const entry = await read(filename);
+  const testScopes = resolveDesktopScopeDomains(entry.config.testScopes);
   const resolve = async (filename: string, id: string, ancestry: readonly string[]): Promise<ResolvedDesktopTarget> => {
     const { config, root, file } = await read(filename);
     const key = `${file}#${id}`;
@@ -248,6 +268,8 @@ export async function loadDesktopConfig(configPath?: string, cwd = process.cwd()
     const target = config.targets[id];
     if (!target) throw new Error(`Unknown desktop target "${id}" in ${file}.`);
     if ('use' in target) return resolve(path.resolve(path.dirname(file), target.use.config), target.use.target, [...ancestry, key]);
+    // A referenced target was checked against its own config's domains; the config that uses it must declare them too.
+    if (target.testScope) resolveDesktopScopeValues(target.testScope, testScopes, `${id}.testScope`);
     const endpoint = target.endpoint ?? (id as DesktopEndpoint);
     const host = {
       ...target.host,
@@ -276,17 +298,38 @@ export async function loadDesktopConfig(configPath?: string, cwd = process.cwd()
         : undefined,
     });
   };
-  const { config, root, file } = await read(filename);
-  const targets = Object.fromEntries(await Promise.all(Object.keys(config.targets).map(async (id) => [id, await resolve(file, id, [])])));
+  const targets = Object.fromEntries(
+    await Promise.all(Object.keys(entry.config.targets).map(async (id) => [id, await resolve(entry.file, id, [])])),
+  );
   return {
-    config,
-    configPath: file,
-    projectRoot: root,
+    config: entry.config,
+    configPath: entry.file,
+    projectRoot: entry.root,
     targets: Object.freeze(targets),
-    reporting: { ...config.reporting, artifactsRoot: path.resolve(root, config.reporting?.artifactsRoot ?? 'artifacts/desktop') },
+    reporting: {
+      ...entry.config.reporting,
+      artifactsRoot: path.resolve(entry.root, entry.config.reporting?.artifactsRoot ?? 'artifacts/desktop'),
+    },
+    testScopes,
   };
 }
 
+/**
+ * The values a target holds for the scope domains: its own `testScope` plus the renderer its host runs. A caller that
+ * knows the renderer better than the host configuration, such as a Storybook run switched to Paper, passes it.
+ */
+export function resolveDesktopTestScope(
+  domains: DesktopScopeDomains,
+  target?: Pick<ResolvedDesktopTarget, 'host' | 'id' | 'testScope'>,
+  renderer: DesktopRenderer | undefined = target?.host.renderer,
+): DesktopScopeValues {
+  return resolveDesktopScopeValues(
+    { ...target?.testScope, ...(renderer ? { 'rn.renderer': renderer } : {}) },
+    domains,
+    target ? `${target.id}.testScope` : 'testScope',
+  );
+}
+
 export function selectDesktopRenderer(target: ResolvedDesktopTarget, renderer: DesktopRenderer): ResolvedDesktopTarget {
   if (target.endpoint !== 'macos' || target.host.kind !== 'react-native-test-app')
     throw new Error('Renderer switching requires a macOS RN Test App target; regenerate with prep after switching.');
@@ -327,6 +370,14 @@ function resolvePaths(root: string, settings: object, fields: readonly string[])
   );
 }
 
+function validateTestScope(value: unknown, domains: DesktopScopeDomains, id: string): void {
+  const scope = object(value, `${id}.testScope`);
+  for (const key of Object.keys(scope)) {
+    if (key.startsWith('rn.')) throw new TypeError(`${id}.testScope cannot set "${key}"; the rn.* values come from ${id}.host.`);
+  }
+  resolveDesktopScopeValues(scope, domains, `${id}.testScope`);
+}
+
 function validateApplication(value: unknown, context: string): void {
   const application = object(value, context);
   keys(
diff --git a/packages/agentic/desktop-test/src/contracts.contract.cjs b/packages/agentic/desktop-test/src/contracts.contract.cjs
index 7fef3c4e35..7182e5f8f1 100644
--- a/packages/agentic/desktop-test/src/contracts.contract.cjs
+++ b/packages/agentic/desktop-test/src/contracts.contract.cjs
@@ -49,7 +49,7 @@ async function main() {
   const { DesktopRunReporter } = await import(lib('reporting/collector.js'));
   const { NodeDesktopCommandRunner } = await import(lib('commands.js'));
   const { DesktopServiceScope, DesktopStopRequested } = await import(lib('services.js'));
-  const { loadDesktopConfig, defineDesktopConfig, resolveDesktopSpecs } = await import(lib('config.js'));
+  const { loadDesktopConfig, defineDesktopConfig, resolveDesktopSpecs, resolveDesktopTestScope } = await import(lib('config.js'));
   // Config resolution canonicalizes paths; macOS temporary directories are symlinked (/var -> /private/var).
   const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-harness-contract-')));
   const out = capture();
@@ -92,6 +92,43 @@ async function main() {
         'export default {schemaVersion:1, targets:{win32:{use:{config:"cycle.mjs",target:"win32"}}}}',
       );
       await assert.rejects(loadDesktopConfig(path.join(root, 'cycle.mjs')), /cycle/);
+      const flavored = (testScopes, testScope, host = app.targets.win32.host) => ({
+        ...app,
+        ...(testScopes ? { testScopes } : {}),
+        targets: { win32: { host, ...(testScope ? { testScope } : {}) } },
+      });
+      const flavors = { 'product.flavor': ['alpha', 'beta'] };
+      defineDesktopConfig(flavored(flavors, { 'product.flavor': 'beta' }));
+      assert.throws(() => defineDesktopConfig(flavored({ 'rn.renderer': ['x'] })), /reserved/);
+      assert.throws(() => defineDesktopConfig(flavored(flavors, { 'product.flavor': 'gamma' })), /must be one of: alpha, beta/);
+      assert.throws(() => defineDesktopConfig(flavored(flavors, { unknown: 'x' })), /unknown scope key "unknown"/);
+      assert.throws(() => defineDesktopConfig(flavored(flavors, { 'rn.renderer': 'paper' })), /cannot set "rn.renderer"/);
+      fs.mkdirSync(path.join(root, 'flavor'));
+      const paperHost = { ...app.targets.win32.host, renderer: 'paper' };
+      fs.writeFileSync(
+        path.join(root, 'flavor', 'desktop.config.mjs'),
+        `export default ${JSON.stringify(flavored(flavors, { 'product.flavor': 'beta' }, paperHost))};`,
+      );
+      const flavor = await loadDesktopConfig(path.join(root, 'flavor', 'desktop.config.mjs'));
+      assert.deepEqual({ ...flavor.testScopes }, { 'rn.renderer': ['fabric', 'paper'], ...flavors });
+      assert.deepEqual(
+        { ...resolveDesktopTestScope(flavor.testScopes, flavor.targets.win32) },
+        { 'product.flavor': 'beta', 'rn.renderer': 'paper' },
+      );
+      assert.deepEqual(
+        { ...resolveDesktopTestScope(flavor.testScopes, flavor.targets.win32, 'fabric') },
+        { 'product.flavor': 'beta', 'rn.renderer': 'fabric' },
+      );
+      assert.deepEqual(
+        { ...resolveDesktopTestScope(direct.testScopes, direct.targets.win32) },
+        {},
+        'no renderer is derived without a host renderer',
+      );
+      fs.writeFileSync(
+        path.join(root, 'flavor', 'consumer.mjs'),
+        `export default ${JSON.stringify({ schemaVersion: 1, targets: { win32: { use: { config: './desktop.config.mjs', target: 'win32' } } } })};`,
+      );
+      await assert.rejects(loadDesktopConfig(path.join(root, 'flavor', 'consumer.mjs')), /unknown scope key "product.flavor"/);
       fs.writeFileSync(path.join(root, 'one.spec.mjs'), '');
       fs.writeFileSync(path.join(root, 'two.spec.mjs'), '');
       assert.deepEqual(resolveDesktopSpecs({ kind: 'wdio', framework: 'jasmine', specs: [['*.spec.mjs']] }, 'win32', root), [
@@ -1188,11 +1225,110 @@ async function main() {
         logs.some((log) => log.includes('serve --agent requires an integration that supports agents; \\"fixture\\" does not.')),
         logs.join('\n'),
       );
+    } else if (mode === 'lane-cli') {
+      // Each invocation is its own process with no inherited collector, so its run result records the lane it was given.
+      const configPath = path.join(root, 'desktop.config.mjs');
+      fs.writeFileSync(path.join(root, 'spec.mjs'), 'export {};\n');
+      fs.writeFileSync(
+        configPath,
+        [
+          "import fs from 'node:fs';",
+          'export default {',
+          '  schemaVersion: 1,',
+          "  targets: { win32: { host: { kind: 'installed', application: { executablePath: 'not-launched.exe' } } } },",
+          '  suites: {',
+          "    csf: { kind: 'csf-wdio' },",
+          "    jasmine: { kind: 'wdio', framework: 'jasmine', specs: ['spec.mjs'] },",
+          "    mocha: { kind: 'wdio', framework: 'mocha', specs: ['spec.mjs'] },",
+          '  },',
+          '  reporting: { artifactsRoot: process.env.FIXTURE_ARTIFACTS },',
+          '  integration: {',
+          "    name: 'fixture',",
+          '    validate() {},',
+          '    async run({ action, suite, input, supervisor }) {',
+          '      fs.writeFileSync(process.env.FIXTURE_MARKER, JSON.stringify({ action, suite, input: input ?? null }));',
+          "      supervisor.reporter.emit({ kind: 'test-result', payload: { testId: 'fixture', title: 'fixture', attempt: 0, status: 'passed', durationMs: 1 } });",
+          '    },',
+          '  },',
+          '};',
+          '',
+        ].join('\n'),
+      );
+      const inherited = { ...process.env };
+      for (const name of ['DESKTOP_REPORT_CONTEXT', 'DESKTOP_INPUT', 'DESKTOP_REPORTER', 'DESKTOP_EVENTS']) delete inherited[name];
+      let invocations = 0;
+      const invoke = (args, environment = {}) => {
+        const index = invocations++;
+        const marker = path.join(root, `marker-${index}.json`);
+        const artifacts = path.join(root, `artifacts-${index}`);
+        const child = spawnSync(
+          process.execPath,
+          [path.join(packageRoot, 'config', 'cli.cjs'), '--config', configPath, '--target', 'win32', '--reporter', 'json', ...args],
+          { cwd: root, encoding: 'utf8', env: { ...inherited, FIXTURE_MARKER: marker, FIXTURE_ARTIFACTS: artifacts, ...environment } },
+        );
+        const runs = fs.existsSync(artifacts) ? fs.readdirSync(artifacts) : [];
+        return {
+          status: child.status,
+          diagnostics: `${child.stdout}\n${child.stderr}`,
+          marker: fs.existsSync(marker) ? JSON.parse(fs.readFileSync(marker, 'utf8')) : undefined,
+          result: runs.length ? JSON.parse(fs.readFileSync(path.join(artifacts, runs[0], 'run.json'), 'utf8')) : undefined,
+          error: child.stdout.startsWith('{') ? JSON.parse(child.stdout.split('\n')[0]).error : undefined,
+        };
+      };
+      const ran = (run, input, lane) => {
+        assert.equal(run.status, 0, run.diagnostics);
+        assert.deepEqual(run.marker, { action: 'test', suite: 'csf', input });
+        assert.deepEqual(run.result.lane, lane);
+      };
+      ran(invoke(['test', '--suite', 'csf', '--input', 'accessible']), 'accessible', {
+        input: 'accessible',
+        source: 'option',
+        masking: 'host-masked',
+        policyEnforced: false,
+      });
+      ran(invoke(['test', '--suite', 'csf'], { DESKTOP_INPUT: 'physical' }), 'physical', {
+        input: 'physical',
+        source: 'environment',
+        policyEnforced: false,
+      });
+      ran(invoke(['test', '--suite', 'csf', '--input', 'accessible'], { DESKTOP_INPUT: 'physical' }), 'accessible', {
+        input: 'accessible',
+        source: 'option',
+        masking: 'host-masked',
+        policyEnforced: false,
+      });
+      const unlaned = invoke(['test', '--suite', 'csf']);
+      assert.equal(unlaned.status, 0, unlaned.diagnostics);
+      assert.deepEqual(unlaned.marker, { action: 'test', suite: 'csf', input: null });
+      assert.equal('lane' in unlaned.result, false, 'a run with no lane must not claim one');
+      const refused = (run, pattern) => {
+        assert.equal(run.status, 1, run.diagnostics);
+        assert.equal(run.marker, undefined, 'a refused lane must not start the run');
+        assert.equal(run.result, undefined, 'a refused lane must not open a result');
+        assert.equal(run.error?.code, 'config', run.diagnostics);
+        assert.match(run.error.message, pattern);
+      };
+      refused(invoke(['test', '--suite', 'jasmine', '--list', '--input', 'accessible']), /--list resolves spec files/);
+      refused(
+        invoke(['test', '--suite', 'mocha', '--input', 'accessible']),
+        /--input accessible requires a jasmine suite; "mocha" uses mocha/,
+      );
+      refused(invoke(['test', '--suite', 'mocha'], { DESKTOP_INPUT: 'physical' }), /--input physical requires a jasmine suite/);
+      refused(invoke(['test', '--suite', 'csf'], { DESKTOP_INPUT: 'fast' }), /DESKTOP_INPUT must be accessible or physical/);
+      const listed = invoke(['test', '--suite', 'jasmine', '--list'], { DESKTOP_INPUT: 'accessible' });
+      assert.equal(listed.status, 0, `--list resolves files and ignores the environment lane\n${listed.diagnostics}`);
     } else {
       const { DesktopSupervisor } = await import(lib('supervisor.js'));
       const { runDesktopWdioSuite } = await import(lib('wdio/run.js'));
+      const { createDesktopInputLane } = await import(lib('reporting/lane.js'));
+      const { resolveDesktopScopeDomains } = await import('@fluentui-react-native/desktop-driver/authoring');
       const { FakeDesktopHost } = await import('@fluentui-react-native/desktop-driver/testing');
-      const run = reporter({ context: { endpoint: 'win32', renderer: 'paper' } });
+      const laneMode = mode.startsWith('lane-');
+      const retried = mode === 'retry' || mode === 'lane-physical';
+      const lane = laneMode ? createDesktopInputLane(mode === 'lane-physical' ? 'physical' : 'accessible', 'option') : undefined;
+      // The lane fixtures import the Jasmine adapter by file URL from the environment, so no value is spliced into source.
+      if (laneMode) process.env.DESKTOP_JASMINE_URL = lib('jasmine/index.js');
+      const run = reporter({ context: { endpoint: 'win32', renderer: 'paper' }, ...(lane ? { lane } : {}) });
       const fixture = path.join(root, mode === 'typescript' ? 'spec.ts' : 'spec.mjs');
       const second = path.join(root, 'second.mjs');
       let source;
@@ -1213,6 +1349,51 @@ async function main() {
           "describe('hook fixture',()=>{beforeAll(()=>{throw new Error('original setup failure');});it('does not execute',()=>{throw new Error('body must not run');});});";
       } else if (mode === 'crash') {
         source = 'process.exit(17);';
+      } else if (mode === 'lane-physical') {
+        source = [
+          "import fs from 'node:fs';",
+          'const { desktopIt, desktopDescribe } = await import(process.env.DESKTOP_JASMINE_URL);',
+          "const marker = new URL('./attempt', import.meta.url);",
+          'const mustNotRun = (what) => () => { throw new Error(`${what} must not run`); };',
+          "describe('physical lane fixture', () => {",
+          "  beforeAll(() => { globalThis.sharedHook = 'ran'; });",
+          "  desktopIt('runs when nothing is declared', () => { expect(globalThis.sharedHook).toBe('ran'); });",
+          "  desktopIt('clicks as the lane does', { requires: ['click'] }, async () => { await (await browser.$('~button-primary')).click(); });",
+          "  desktopIt('needs the keyboard', { requires: ['keyboard'] }, () => {});",
+          "  desktopIt('fails once, then retries', () => { if (!fs.existsSync(marker)) { fs.writeFileSync(marker, 'attempt'); throw new Error('first attempt'); } });",
+          "  desktopIt('accessible only', { requires: ['accessibility-click'] }, mustNotRun('an input-excluded case'));",
+          "  desktopIt('macOS only', { platforms: ['macos'] }, mustNotRun('a platform-excluded case'));",
+          "  desktopIt('fabric only', { scope: { 'rn.renderer': ['fabric'] } }, mustNotRun('a scope-excluded case'));",
+          "  desktopIt('declared gap', { unsupported: { platforms: ['win32'], reason: 'Declared gap.' } }, mustNotRun('a declared gap'));",
+          '});',
+          "desktopDescribe('excluded group', { platforms: ['macos'] }, () => {",
+          "  beforeAll(mustNotRun('the hook of an excluded group'));",
+          "  beforeEach(mustNotRun('the hook of an excluded group'));",
+          "  desktopIt('inside an excluded group', mustNotRun('a platform-excluded case'));",
+          '});',
+        ].join('\n');
+      } else if (mode === 'lane-accessible') {
+        source = [
+          'const { desktopIt } = await import(process.env.DESKTOP_JASMINE_URL);',
+          'const mustNotRun = (what) => () => { throw new Error(`${what} must not run`); };',
+          "describe('accessible lane fixture', () => {",
+          "  desktopIt('runs when nothing is declared', () => {});",
+          "  desktopIt('clicks as the lane does', { requires: ['click'] }, async () => { await (await browser.$('~button-primary')).click(); });",
+          "  desktopIt('clicks accessibly', { requires: ['accessibility-click'] }, async () => { await (await browser.$('~button-primary')).click(); });",
+          "  desktopIt('physical only', { requires: ['keyboard'] }, mustNotRun('an input-excluded case'));",
+          "  desktopIt('needs what the host lacks', { requires: ['accessibility-actions'] }, mustNotRun('a case the host cannot support'));",
+          '});',
+        ].join('\n');
+      } else if (mode === 'lane-blocked') {
+        source = [
+          "import fs from 'node:fs';",
+          'const { desktopIt } = await import(process.env.DESKTOP_JASMINE_URL);',
+          "const ran = new URL('./ran', import.meta.url);",
+          "describe('blocked lane fixture', () => {",
+          "  desktopIt('declared', () => { fs.writeFileSync(ran, 'ran'); });",
+          "  it('undeclared', () => { fs.writeFileSync(ran, 'ran'); });",
+          '});',
+        ].join('\n');
       } else if (mode === 'bail') {
         source = "describe('bail fixture',()=>{it('fails first',()=>{throw new Error('original bail failure');});});";
         fs.writeFileSync(
@@ -1236,7 +1417,11 @@ async function main() {
         projectRoot: packageRoot,
         configPath: path.join(root, 'desktop.config.mjs'),
       };
-      const host = new FakeDesktopHost({ endpoint: 'win32' });
+      // The accessible lane masks keyboard, physical click and wheel on the host. Only `lane-blocked` leaves them on.
+      const host = new FakeDesktopHost({
+        endpoint: 'win32',
+        ...(mode === 'lane-accessible' ? { features: { keyboard: false, physicalClick: false, wheel: false } } : {}),
+      });
       let launches = 0;
       const launch = host.launch.bind(host);
       host.launch = (...args) => {
@@ -1259,7 +1444,7 @@ async function main() {
               kind: 'wdio',
               framework: 'jasmine',
               specs: mode === 'bail' ? [fixture, second] : [[fixture, ...(mode === 'wdio' ? [second] : [])]],
-              specFileRetries: mode === 'retry' ? 1 : 0,
+              specFileRetries: retried ? 1 : 0,
             },
           },
         },
@@ -1267,6 +1452,7 @@ async function main() {
         configPath: target.configPath,
         targets: { win32: target },
         reporting: { artifactsRoot: root },
+        testScopes: resolveDesktopScopeDomains(),
       };
       if (mode === 'config-hook-failure')
         config.config.suites.fixture.readiness = { kind: 'native', testId: 'missing-readiness-marker', timeoutMs: 50 };
@@ -1294,7 +1480,7 @@ async function main() {
         });
         await assert.rejects(duplicate.start(), /Another desktop workload/);
         try {
-          await runDesktopWdioSuite(supervisor, config, 'fixture');
+          await runDesktopWdioSuite(supervisor, config, 'fixture', lane?.input);
         } catch (error) {
           failure = error;
           run.fail(error);
@@ -1303,7 +1489,7 @@ async function main() {
         await supervisor.close();
       }
       const result = await run.finish();
-      if (['hook-failure', 'config-hook-failure', 'config-load-failure', 'crash', 'bail'].includes(mode)) {
+      if (['hook-failure', 'config-hook-failure', 'config-load-failure', 'crash', 'bail', 'lane-blocked'].includes(mode)) {
         assert(failure, `hook failure must fail launcher\n${JSON.stringify(result)}\n${err.text()}\n${out.text()}`);
         assert.equal(result.status, 'failed');
         assert(!out.text().includes('PASSED WDIO fixture'), out.text());
@@ -1322,15 +1508,49 @@ async function main() {
             result.work.some(({ status }) => status === 'not-run'),
             JSON.stringify(result),
           );
+        if (mode === 'lane-blocked') {
+          // An unmasked accessible host and an undeclared spec are both reported, and neither spec ran.
+          const text = JSON.stringify(result);
+          assert(text.includes('needs a host that reports keyboard, physicalClick, wheel disabled'), text);
+          assert(text.includes('not declared with desktopIt or desktopDescribe'), text);
+          assert(!fs.existsSync(path.join(root, 'ran')), 'a blocked lane must not run any spec');
+          assert.equal(result.counts.executed, 0, text);
+          assert.equal(result.counts.skipped, 0, 'a blocked lane reports its fault, not every spec it disabled');
+        }
+      } else if (mode === 'lane-accessible') {
+        const text = JSON.stringify(result);
+        // The host cannot support one case. A lane run holds that against the run instead of quietly skipping it.
+        assert(failure && /incomplete/.test(failure.message), `${failure?.stack}\n${text}\n${err.text()}`);
+        assert.notEqual(result.status, 'passed', text);
+        assert.equal(launches, 1);
+        assert.equal(result.counts.passed, 3, text);
+        assert.equal(result.counts.failed, 0, text);
+        assert.equal(result.counts.unsupported, 1, text);
+        assert.equal(result.counts.declaredUnsupported, 0, text);
+        assert.deepEqual(result.selection.excluded, { platform: 0, scope: 0, input: 1 }, text);
+        assert.deepEqual(result.lane, { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false });
+        const clicks = host.actions.filter((action) => action.type === 'click');
+        assert(clicks.length === 2 && clicks.every((action) => action.mode === 'accessibility'), JSON.stringify(host.actions));
       } else {
         assert.equal(failure, undefined, `${failure?.stack}\n${err.text()}\n${out.text()}`);
         assert.equal(result.status, 'passed', JSON.stringify(result));
-        assert.equal(launches, mode === 'retry' ? 2 : 1, 'WDIO must own exactly one session per grouped attempt');
-        assert.equal(result.counts.flaky, mode === 'retry' ? 1 : 0, JSON.stringify(result));
+        assert.equal(launches, retried ? 2 : 1, 'WDIO must own exactly one session per grouped attempt');
+        assert.equal(result.counts.flaky, retried ? 1 : 0, JSON.stringify(result));
         if (mode === 'wdio') {
           assert.equal(result.counts.passed, 2);
           assert.equal(result.counts.skipped, 1);
         }
+        if (mode === 'lane-physical') {
+          const text = JSON.stringify(result);
+          assert.equal(result.counts.passed, 4, text);
+          assert.equal(result.counts.unsupported, 1, text);
+          assert.equal(result.counts.declaredUnsupported, 1, text);
+          // Both attempts announced the same exclusions, and a retried group still counts them once.
+          assert.deepEqual(result.selection.excluded, { platform: 2, scope: 1, input: 1 }, text);
+          assert.deepEqual(result.lane, { input: 'physical', source: 'option', policyEnforced: false });
+          const clicks = host.actions.filter((action) => action.type === 'click');
+          assert(clicks.length > 0 && clicks.every((action) => action.mode === 'physical'), JSON.stringify(host.actions));
+        }
       }
       assert(!fs.existsSync(path.join(root, 'locks', 'interactive.lock')));
     }
diff --git a/packages/agentic/desktop-test/src/contracts.test.ts b/packages/agentic/desktop-test/src/contracts.test.ts
index 559708c809..d666a3dcd5 100644
--- a/packages/agentic/desktop-test/src/contracts.test.ts
+++ b/packages/agentic/desktop-test/src/contracts.test.ts
@@ -25,6 +25,10 @@ describe('neutral desktop harness contracts', () => {
     'config-load-failure',
     'crash',
     'bail',
+    'lane-physical',
+    'lane-accessible',
+    'lane-blocked',
+    'lane-cli',
   ])(
     '%s contract',
     async (mode) => {
diff --git a/packages/agentic/desktop-test/src/index.ts b/packages/agentic/desktop-test/src/index.ts
index 946718dc9b..1b61b3ad75 100644
--- a/packages/agentic/desktop-test/src/index.ts
+++ b/packages/agentic/desktop-test/src/index.ts
@@ -10,7 +10,7 @@ export type {
   PublishDesktopAgentConnection,
 } from './agentConnection.js';
 export { DesktopServiceScope, DesktopStopRequested } from './services.js';
-export { defineDesktopConfig, loadDesktopConfig, resolveDesktopSpecs, validateDesktopConfig } from './config.js';
+export { defineDesktopConfig, loadDesktopConfig, resolveDesktopSpecs, resolveDesktopTestScope, validateDesktopConfig } from './config.js';
 export type { DesktopConfig, DesktopTargetConfig, DesktopWdioSuite, ResolvedDesktopConfig, ResolvedDesktopTarget } from './config.js';
 export type { DesktopIntegration } from './integration.js';
 export { desktopStageCommands, resolveDesktopApplication } from './adapters.js';
diff --git a/packages/agentic/desktop-test/src/integration.ts b/packages/agentic/desktop-test/src/integration.ts
index cdb74ede46..35fc5021a6 100644
--- a/packages/agentic/desktop-test/src/integration.ts
+++ b/packages/agentic/desktop-test/src/integration.ts
@@ -1,4 +1,5 @@
 import type { DesktopHost, DesktopTarget } from '@fluentui-react-native/desktop-driver';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
 import type { ResolvedDesktopReporterMode } from '@fluentui-react-native/desktop-driver/cli/reporter';
 import type { DesktopAgentConnectionOptions } from './agentConnection.js';
 import type { DesktopStage, ResolvedDesktopConfig, ResolvedDesktopTarget } from './config.js';
@@ -30,6 +31,8 @@ export type DesktopIntegration = {
     supervisor: DesktopSupervisor;
     action: DesktopStage | 'test' | 'serve';
     suite?: string;
+    /** Set only for `test`, when the run executes one input lane. The integration owns masking its own driver. */
+    input?: DesktopInputLane;
     /** Set only for `serve --agent`, and only for an integration that `supportsAgent`. */
     agent?: Pick<DesktopAgentConnectionOptions, 'descriptor' | 'root'>;
     /**
diff --git a/packages/agentic/desktop-test/src/jasmine/adapter.test.ts b/packages/agentic/desktop-test/src/jasmine/adapter.test.ts
new file mode 100644
index 0000000000..5b0764a76c
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/adapter.test.ts
@@ -0,0 +1,208 @@
+import { createDesktopJasmine } from './adapter.js';
+import type { DesktopJasmineApi } from './adapter.js';
+import { createDesktopJasmineRegistry, desktopSpecIdentifier, excludedSpecCounts } from './registry.js';
+import { desktopTestSelectionEnvironment, serializeDesktopTestSelection } from './selection.js';
+
+type DesktopBody = (done?: (error?: unknown) => void) => unknown;
+type Registered = { kind: 'describe' | 'it' | 'xit'; name: string; path: string[]; body?: DesktopBody };
+
+/** Registers what a Jasmine would, and hands back the metadata `it` and `xit` return. */
+function fakeJasmine(options: { identify?: boolean } = {}) {
+  const registered: Registered[] = [];
+  const path: string[] = [];
+  let next = 0;
+  const spec = (kind: 'it' | 'xit', name: string, body?: DesktopBody) => {
+    registered.push({ kind, name, path: [...path], body });
+    return options.identify === false ? undefined : { id: `spec${next++}`, description: name };
+  };
+  const api: DesktopJasmineApi = {
+    describe(name, body) {
+      registered.push({ kind: 'describe', name, path: [...path] });
+      path.push(name);
+      try {
+        body.call({});
+      } finally {
+        path.pop();
+      }
+    },
+    it: (name, body) => spec('it', name, body),
+    xit: (name) => spec('xit', name),
+  };
+  return { api, registered };
+}
+
+function laneEnvironment(lane?: 'accessible' | 'physical', extra: { testScopes?: unknown; values?: Record<string, string> } = {}) {
+  return {
+    [desktopTestSelectionEnvironment]: serializeDesktopTestSelection({
+      endpoint: 'win32',
+      ...(lane ? { lane } : {}),
+      ...(extra.testScopes ? { testScopes: extra.testScopes } : {}),
+      values: { 'rn.renderer': 'paper', ...extra.values },
+    }),
+  };
+}
+
+function setup(lane?: 'accessible' | 'physical', extra?: Parameters<typeof laneEnvironment>[1], options?: { identify?: boolean }) {
+  const registry = createDesktopJasmineRegistry(laneEnvironment(lane, extra));
+  const jasmine = fakeJasmine(options);
+  return { registry, ...jasmine, ...createDesktopJasmine(jasmine.api, registry) };
+}
+
+const body = () => undefined;
+
+describe('desktopIt without a selection', () => {
+  test('registers an ordinary spec, so a runner that does not select keeps working', () => {
+    const registry = createDesktopJasmineRegistry();
+    const { api, registered } = fakeJasmine();
+    const { desktopIt } = createDesktopJasmine(api, registry);
+    desktopIt('plain', body);
+    desktopIt('physical', { requires: ['keyboard'] }, body);
+
+    expect(registered.map(({ kind, name }) => `${kind}:${name}`)).toEqual(['it:plain', 'it:physical']);
+    expect(registry.errors).toEqual([]);
+  });
+
+  test('still rejects a declaration it cannot read', () => {
+    const registry = createDesktopJasmineRegistry();
+    const { api, registered } = fakeJasmine();
+    const { desktopIt } = createDesktopJasmine(api, registry);
+    desktopIt('bad', { requires: ['telepathy' as never] }, body);
+
+    expect(registered).toHaveLength(1);
+    expect(() => registered[0].body?.()).toThrow(/unsupported requirement/);
+    expect(registry.entries.get('badspec0')).toEqual({ kind: 'invalid' });
+  });
+});
+
+describe('desktopIt in a lane', () => {
+  test('runs what the lane covers and replaces the rest with placeholders that are counted by reason', () => {
+    const { desktopIt, registered, registry } = setup('accessible');
+    desktopIt('both', body);
+    desktopIt('accessible only', { requires: ['accessibility-click'] }, body);
+    desktopIt('physical only', { requires: ['keyboard'] }, body);
+    desktopIt('macOS only', { platforms: ['macos'] }, body);
+    desktopIt('fabric only', { scope: { 'rn.renderer': ['fabric'] } }, body);
+
+    expect(registered.map(({ kind, name }) => `${kind}:${name}`)).toEqual([
+      'it:both',
+      'it:accessible only',
+      'xit:physical only',
+      'xit:macOS only',
+      'xit:fabric only',
+    ]);
+    expect(excludedSpecCounts(registry)).toEqual({ platform: 1, scope: 1, input: 1 });
+    expect(registry.entries.get('physical onlyspec2')).toEqual({ kind: 'excluded', reason: 'input' });
+  });
+
+  test('a case is excluded once, for the first reason that applies', () => {
+    const { desktopIt, registry } = setup('accessible');
+    desktopIt('everything', { platforms: ['macos'], scope: { 'rn.renderer': ['fabric'] }, requires: ['keyboard'] }, body);
+
+    expect(excludedSpecCounts(registry)).toEqual({ platform: 1, scope: 0, input: 0 });
+  });
+
+  test('a declared gap becomes a placeholder that carries its reason, not an excluded case', () => {
+    const { desktopIt, registered, registry } = setup('physical');
+    desktopIt('known gap', { unsupported: { platforms: ['win32'], reason: 'Not on win32 yet.' } }, body);
+    desktopIt('known gap elsewhere', { unsupported: { platforms: ['macos'], reason: 'Not on macOS yet.' } }, body);
+
+    expect(registered.map(({ kind }) => kind)).toEqual(['xit', 'it']);
+    expect(registry.entries.get('known gapspec0')).toEqual({ kind: 'gap', gap: { kind: 'unsupported', reason: 'Not on win32 yet.' } });
+    expect(excludedSpecCounts(registry)).toEqual({ platform: 0, scope: 0, input: 0 });
+  });
+
+  test('an expired quarantine fails that case instead of hiding it', () => {
+    const { desktopIt, registered, registry } = setup('physical');
+    desktopIt('stale', { quarantine: { issue: '#1', reason: 'Flaky.', expires: '2000-01-01' } }, body);
+
+    expect(registered.map(({ kind }) => kind)).toEqual(['it']);
+    expect(() => registered[0].body?.()).toThrow('Quarantine #1 expired on 2000-01-01.');
+    expect(registry.entries.get('stalespec0')).toEqual({ kind: 'invalid' });
+  });
+
+  test('a custom scope key is checked against the domains the config declared', () => {
+    const extra = { testScopes: { flavor: ['dev', 'prod'] }, values: { flavor: 'dev' } };
+    const accepted = setup('physical', extra);
+    accepted.desktopIt('dev only', { scope: { flavor: ['dev'] } }, body);
+    accepted.desktopIt('prod only', { scope: { flavor: ['prod'] } }, body);
+    expect(accepted.registered.map(({ kind }) => kind)).toEqual(['it', 'xit']);
+
+    const unknown = setup('physical');
+    unknown.desktopIt('typo', { scope: { flavour: ['dev'] } }, body);
+    expect(() => unknown.registered[0].body?.()).toThrow(/unknown scope key "flavour"/);
+  });
+
+  test('records the spec by the identifier WDIO reports, and faults when Jasmine does not identify it', () => {
+    expect(desktopSpecIdentifier({ description: 'a case', id: 'spec7' })).toBe('a casespec7');
+    expect(desktopSpecIdentifier({ description: 'a case' })).toBeUndefined();
+
+    const { desktopIt, registry } = setup('physical', undefined, { identify: false });
+    desktopIt('anonymous', body);
+    expect(registry.errors).toEqual([expect.stringContaining('did not identify the spec registered for "anonymous"')]);
+  });
+});
+
+describe('desktopDescribe', () => {
+  test('adds what a group requires to every case inside it, however deep', () => {
+    const { desktopDescribe, desktopIt, registered } = setup('accessible');
+    desktopDescribe('group', { requires: ['keyboard'] }, () => {
+      desktopIt('inherits', body);
+      desktopDescribe('nested', () => desktopIt('also inherits', body));
+    });
+    desktopIt('outside', body);
+
+    expect(registered.filter(({ kind }) => kind !== 'describe').map(({ kind, name }) => `${kind}:${name}`)).toEqual([
+      'xit:inherits',
+      'xit:also inherits',
+      'it:outside',
+    ]);
+  });
+
+  test('narrows platforms to the overlap of the group and the case', () => {
+    const { desktopDescribe, desktopIt, registered } = setup('physical');
+    desktopDescribe('group', { platforms: ['!macos'] }, () => {
+      desktopIt('keeps win32', { platforms: ['macos', 'win32'] }, body);
+      desktopIt('loses win32', { platforms: ['macos', 'windows'] }, body);
+    });
+
+    expect(registered.filter(({ kind }) => kind !== 'describe').map(({ kind, name }) => `${kind}:${name}`)).toEqual([
+      'it:keeps win32',
+      'xit:loses win32',
+    ]);
+  });
+
+  test('a case that could never run inside its group is a failing spec, not a silent exclusion', () => {
+    const { desktopDescribe, desktopIt, registered } = setup('physical');
+    desktopDescribe('group', { platforms: ['macos'] }, () => {
+      desktopIt('never', { platforms: ['win32'] }, body);
+    });
+
+    const specs = registered.filter(({ kind }) => kind === 'it');
+    expect(specs).toHaveLength(1);
+    expect(() => specs[0].body?.()).toThrow(/do not overlap the enclosing group's, so it could never run/);
+  });
+
+  test('a group cannot declare a gap, so its body does not run and one spec reports why', () => {
+    const { desktopDescribe, registered } = setup('physical');
+    const inner = jest.fn();
+    desktopDescribe('group', { unsupported: { platforms: ['win32'], reason: 'No.' } } as never, inner);
+
+    expect(inner).not.toHaveBeenCalled();
+    const specs = registered.filter(({ kind }) => kind === 'it');
+    expect(specs).toHaveLength(1);
+    expect(() => specs[0].body?.()).toThrow(/cannot declare unsupported or quarantine/);
+  });
+
+  test('a group that throws still releases its options for the next group', () => {
+    const { desktopDescribe, desktopIt, registered, registry } = setup('accessible');
+    expect(() =>
+      desktopDescribe('throws', { requires: ['keyboard'] }, () => {
+        throw new Error('boom');
+      }),
+    ).toThrow('boom');
+    expect(registry.groups).toEqual([]);
+
+    desktopIt('after', body);
+    expect(registered.filter(({ kind }) => kind === 'it' || kind === 'xit').map(({ kind }) => kind)).toEqual(['it']);
+  });
+});
diff --git a/packages/agentic/desktop-test/src/jasmine/adapter.ts b/packages/agentic/desktop-test/src/jasmine/adapter.ts
new file mode 100644
index 0000000000..9139684e15
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/adapter.ts
@@ -0,0 +1,103 @@
+import {
+  decideDesktopCase,
+  mergeDesktopCaseOptions,
+  validateDesktopCaseOptions,
+  validateDesktopGroupOptions,
+} from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopCaseOptions, ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import { desktopSpecIdentifier } from './registry.js';
+import type { DesktopJasmineRegistry, DesktopSpecEntry } from './registry.js';
+
+export type DesktopSpecBody = (done: (error?: unknown) => void) => unknown;
+export type DesktopGroupBody = (this: unknown) => void;
+/** A group scopes the cases inside it. A gap describes one case, so a group cannot declare one. */
+export type DesktopGroupOptions = Omit<DesktopCaseOptions, 'unsupported' | 'quarantine'>;
+
+/** The part of the Jasmine globals the adapter registers specs through. */
+export type DesktopJasmineApi = {
+  describe(name: string, body: DesktopGroupBody): unknown;
+  it(name: string, body: DesktopSpecBody): unknown;
+  xit(name: string): unknown;
+};
+
+/**
+ * Declares tests with their input modality and the places they run, and registers them with Jasmine.
+ *
+ * `desktopIt` and `desktopDescribe` never throw for a bad declaration: Jasmine only warns when a spec file fails to load,
+ * so a throw would silently drop every test after it. A bad declaration becomes a failing spec that reports the problem.
+ */
+export function createDesktopJasmine(api: DesktopJasmineApi, registry: DesktopJasmineRegistry) {
+  function record(spec: unknown, name: string, entry: DesktopSpecEntry): void {
+    const identifier = desktopSpecIdentifier(spec as { description?: unknown; id?: unknown } | undefined);
+    if (identifier === undefined) {
+      registry.errors.push(`Jasmine did not identify the spec registered for "${name}", so its selection cannot be verified.`);
+      return;
+    }
+    registry.entries.set(identifier, entry);
+  }
+
+  function failing(name: string, error: unknown): void {
+    record(
+      api.it(name, () => {
+        throw error;
+      }),
+      name,
+      { kind: 'invalid' },
+    );
+  }
+
+  function desktopIt(name: string, optionsOrBody: DesktopCaseOptions | DesktopSpecBody, maybeBody?: DesktopSpecBody): void {
+    const hasOptions = typeof optionsOrBody !== 'function';
+    const body = hasOptions ? maybeBody : optionsOrBody;
+    const title = typeof name === 'string' && name.trim() ? name : 'desktopIt';
+    const source = `desktopIt("${title}")`;
+    let descriptor: ResolvedDesktopCaseOptions;
+    let decision: ReturnType<typeof decideDesktopCase>;
+    try {
+      if (title !== name) throw new TypeError('desktopIt requires a non-empty name.');
+      if (typeof body !== 'function') throw new TypeError(`${source} requires a test function.`);
+      const declared = validateDesktopCaseOptions(hasOptions ? optionsOrBody : {}, `${source} options`);
+      descriptor = mergeDesktopCaseOptions(registry.groups.at(-1), declared, source);
+      decision = registry.selection ? decideDesktopCase(descriptor, registry.selection, source) : { kind: 'run' };
+    } catch (error) {
+      failing(title, error);
+      return;
+    }
+    if (decision.kind === 'run') {
+      record(api.it(name, body), name, { kind: 'run', descriptor });
+      return;
+    }
+    // A placeholder keeps the spec out of Jasmine's hooks and body without reporting it as a skipped test.
+    const entry: DesktopSpecEntry =
+      decision.kind === 'excluded' ? { kind: 'excluded', reason: decision.reason } : { kind: 'gap', gap: decision.gap };
+    record(api.xit(name), name, entry);
+  }
+
+  function desktopDescribe(name: string, optionsOrBody: DesktopGroupOptions | DesktopGroupBody, maybeBody?: DesktopGroupBody): void {
+    const hasOptions = typeof optionsOrBody !== 'function';
+    const body = hasOptions ? maybeBody : optionsOrBody;
+    const title = typeof name === 'string' && name.trim() ? name : 'desktopDescribe';
+    const source = `desktopDescribe("${title}")`;
+    let group: ResolvedDesktopCaseOptions;
+    try {
+      if (title !== name) throw new TypeError('desktopDescribe requires a non-empty name.');
+      if (typeof body !== 'function') throw new TypeError(`${source} requires a body.`);
+      const declared = validateDesktopGroupOptions(hasOptions ? optionsOrBody : {}, `${source} options`);
+      group = mergeDesktopCaseOptions(registry.groups.at(-1), declared, source);
+    } catch (error) {
+      // The body does not run, so nothing inside an unreadable group is selected by accident.
+      api.describe(title, () => failing('has invalid desktop options', error));
+      return;
+    }
+    api.describe(name, function (this: unknown) {
+      registry.groups.push(group);
+      try {
+        body.call(this);
+      } finally {
+        registry.groups.pop();
+      }
+    });
+  }
+
+  return { desktopIt, desktopDescribe };
+}
diff --git a/packages/agentic/desktop-test/src/jasmine/index.ts b/packages/agentic/desktop-test/src/jasmine/index.ts
new file mode 100644
index 0000000000..b602b7c452
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/index.ts
@@ -0,0 +1,42 @@
+import { createDesktopJasmine } from './adapter.js';
+import type { DesktopGroupBody, DesktopGroupOptions, DesktopJasmineApi, DesktopSpecBody } from './adapter.js';
+import { desktopJasmineRegistry } from './registry.js';
+import type { DesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+
+export type {
+  DesktopCaseOptions,
+  DesktopInput,
+  DesktopPlatforms,
+  DesktopRequirement,
+} from '@fluentui-react-native/desktop-driver/authoring';
+export type { DesktopGroupBody, DesktopGroupOptions, DesktopSpecBody } from './adapter.js';
+
+// The Jasmine globals exist only once a framework has installed them, so they are read when a declaration runs.
+const globals = () => globalThis as unknown as DesktopJasmineApi;
+const jasmineApi: DesktopJasmineApi = {
+  describe: (name, body) => globals().describe(name, body),
+  it: (name, body) => globals().it(name, body),
+  xit: (name) => globals().xit(name),
+};
+const adapter = () => createDesktopJasmine(jasmineApi, desktopJasmineRegistry());
+
+/**
+ * Declares a Jasmine test with the input it needs and where it runs. The descriptor decides whether the test is part of a
+ * run: `requires` implies the input modality, `platforms` and `scope` narrow where it runs, and `unsupported` or
+ * `quarantine` report a known gap instead of executing.
+ */
+export function desktopIt(name: string, body: DesktopSpecBody): void;
+export function desktopIt(name: string, options: DesktopCaseOptions, body: DesktopSpecBody): void;
+export function desktopIt(name: string, optionsOrBody: DesktopCaseOptions | DesktopSpecBody, maybeBody?: DesktopSpecBody): void {
+  adapter().desktopIt(name, optionsOrBody, maybeBody);
+}
+
+/**
+ * Declares a Jasmine group whose options apply to every test inside it: requirements add up, platforms and scope intersect,
+ * and a nested declaration can only narrow its group.
+ */
+export function desktopDescribe(name: string, body: DesktopGroupBody): void;
+export function desktopDescribe(name: string, options: DesktopGroupOptions, body: DesktopGroupBody): void;
+export function desktopDescribe(name: string, optionsOrBody: DesktopGroupOptions | DesktopGroupBody, maybeBody?: DesktopGroupBody): void {
+  adapter().desktopDescribe(name, optionsOrBody, maybeBody);
+}
diff --git a/packages/agentic/desktop-test/src/jasmine/registry.ts b/packages/agentic/desktop-test/src/jasmine/registry.ts
new file mode 100644
index 0000000000..d927d700f1
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/registry.ts
@@ -0,0 +1,72 @@
+import type {
+  DesktopDeclaredGap,
+  DesktopExclusionReason,
+  DesktopRequirement,
+  ResolvedDesktopCaseOptions,
+} from '@fluentui-react-native/desktop-driver/authoring';
+import type { SelectionExclusions } from '../reporting/protocol.js';
+import { desktopTestSelectionEnvironment, parseDesktopTestSelection } from './selection.js';
+import type { DesktopTestSelection } from './selection.js';
+
+/** What the adapter decided for a spec it registered. */
+export type DesktopSpecEntry =
+  /** Executes, unless a preflight found that the host cannot meet what it requires. */
+  | { kind: 'run'; descriptor: ResolvedDesktopCaseOptions; missing?: readonly DesktopRequirement[] }
+  /** Registered as a placeholder that never runs and is counted, not reported as a test. */
+  | { kind: 'excluded'; reason: DesktopExclusionReason }
+  /** Registered as a placeholder that is reported as unsupported, with the reason its author gave. */
+  | { kind: 'gap'; gap: DesktopDeclaredGap }
+  /** A failing spec the adapter registered in place of a declaration it could not accept. */
+  | { kind: 'invalid' };
+
+/** What one worker process learned while its spec files registered their tests. */
+export type DesktopJasmineRegistry = {
+  /** Absent when no desktop-test run started this process, in which case declarations are only validated. */
+  readonly selection: DesktopTestSelection | undefined;
+  /** Keyed by the identifier WDIO reports for a spec: its description followed by its Jasmine id. */
+  readonly entries: Map<string, DesktopSpecEntry>;
+  /** The enclosing `desktopDescribe` options while a group body registers, innermost last. */
+  readonly groups: ResolvedDesktopCaseOptions[];
+  /** Faults that make the selection untrustworthy, such as a spec the adapter could not identify. */
+  readonly errors: string[];
+  /** Set once every spec was disabled because of a fault, so the reporter shows the fault instead of a wall of skips. */
+  blocked: boolean;
+};
+
+const registryKey = Symbol.for('@fluentui-react-native/desktop-test/jasmine-registry');
+
+/**
+ * The registry of this process. It lives on `globalThis` because the spec files and the reporter share one worker process
+ * but may load this module through different paths, such as source and its build.
+ */
+export function desktopJasmineRegistry(environment: NodeJS.ProcessEnv = process.env): DesktopJasmineRegistry {
+  const holder = globalThis as { [registryKey]?: DesktopJasmineRegistry };
+  return (holder[registryKey] ??= createDesktopJasmineRegistry(environment));
+}
+
+export function createDesktopJasmineRegistry(environment: NodeJS.ProcessEnv = {}): DesktopJasmineRegistry {
+  const errors: string[] = [];
+  let selection: DesktopTestSelection | undefined;
+  const raw = environment[desktopTestSelectionEnvironment];
+  if (raw !== undefined) {
+    try {
+      selection = parseDesktopTestSelection(raw);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { selection, entries: new Map(), groups: [], errors, blocked: false };
+}
+
+/** The identifier WDIO's Jasmine adapter reports for a spec, so the reporter can find what the adapter decided. */
+export function desktopSpecIdentifier(spec: { description?: unknown; id?: unknown } | undefined): string | undefined {
+  return typeof spec?.description === 'string' && typeof spec.id === 'string' ? `${spec.description}${spec.id}` : undefined;
+}
+
+export function excludedSpecCounts(registry: DesktopJasmineRegistry): SelectionExclusions {
+  const excluded = { platform: 0, scope: 0, input: 0 };
+  for (const entry of registry.entries.values()) {
+    if (entry.kind === 'excluded') excluded[entry.reason]++;
+  }
+  return excluded;
+}
diff --git a/packages/agentic/desktop-test/src/jasmine/selection.test.ts b/packages/agentic/desktop-test/src/jasmine/selection.test.ts
new file mode 100644
index 0000000000..83edda6692
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/selection.test.ts
@@ -0,0 +1,50 @@
+import {
+  desktopTestSelectionEnvironment,
+  desktopTestSelectionFromEnvironment,
+  parseDesktopTestSelection,
+  serializeDesktopTestSelection,
+} from './selection.js';
+
+describe('desktop test selection', () => {
+  test('round-trips a lane, the custom scope domains and the target values', () => {
+    const raw = serializeDesktopTestSelection({
+      endpoint: 'macos',
+      lane: 'accessible',
+      testScopes: { flavor: ['dev', 'prod'] },
+      values: { 'rn.renderer': 'fabric', flavor: 'dev' },
+    });
+
+    const selection = parseDesktopTestSelection(raw);
+
+    expect(selection).toMatchObject({ endpoint: 'macos', lane: 'accessible', values: { 'rn.renderer': 'fabric', flavor: 'dev' } });
+    expect(selection.domains.flavor).toEqual(['dev', 'prod']);
+    expect(selection.domains['rn.renderer']).toEqual(['fabric', 'paper']);
+  });
+
+  test('no lane means a run that only applies platform, scope and declared gaps', () => {
+    const selection = parseDesktopTestSelection(serializeDesktopTestSelection({ endpoint: 'win32', values: {} }));
+
+    expect(selection.lane).toBeUndefined();
+  });
+
+  test('is absent when no run started the process, and malformed values fail loudly rather than being guessed at', () => {
+    expect(desktopTestSelectionFromEnvironment({})).toBeUndefined();
+    expect(desktopTestSelectionFromEnvironment({ [desktopTestSelectionEnvironment]: '{"endpoint":"win32","values":{}}' })).toMatchObject({
+      endpoint: 'win32',
+    });
+    expect(() => desktopTestSelectionFromEnvironment({ [desktopTestSelectionEnvironment]: '' })).toThrow('is not valid JSON');
+  });
+
+  test.each([
+    ['not json', 'is not valid JSON'],
+    ['[]', 'must be an object'],
+    ['null', 'must be an object'],
+    ['{"endpoint":"linux","values":{}}', 'endpoint must be one of: macos, windows, win32'],
+    ['{"endpoint":"win32","lane":"fast","values":{}}', 'lane must be one of: accessible, physical'],
+    ['{"endpoint":"win32","values":{},"extra":1}', 'unknown key "extra"'],
+    ['{"endpoint":"win32","values":{"flavor":"dev"}}', 'flavor'],
+    ['{"endpoint":"win32","testScopes":{"rn.renderer":["x"]},"values":{}}', 'rn.renderer'],
+  ])('rejects %s', (raw, message) => {
+    expect(() => parseDesktopTestSelection(raw)).toThrow(message);
+  });
+});
diff --git a/packages/agentic/desktop-test/src/jasmine/selection.ts b/packages/agentic/desktop-test/src/jasmine/selection.ts
new file mode 100644
index 0000000000..b7e23d54db
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/selection.ts
@@ -0,0 +1,59 @@
+import type { DesktopEndpoint } from '@fluentui-react-native/desktop-driver';
+import { desktopInputLanes, resolveDesktopScopeDomains, resolveDesktopScopeValues } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopCaseTarget, DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
+
+/** Carries a run's selection from its launcher to its WDIO workers. The value is data that is parsed, never evaluated. */
+export const desktopTestSelectionEnvironment = 'DESKTOP_TEST_SELECTION';
+
+/** What a worker judges each declared case against. */
+export type DesktopTestSelection = Omit<DesktopCaseTarget, 'now'>;
+
+/** The serialized selection: the custom scope domains and the target's values, which a worker validates again. */
+export type DesktopTestSelectionRequest = {
+  endpoint: DesktopEndpoint;
+  lane?: DesktopInputLane;
+  testScopes?: unknown;
+  values: Readonly<Record<string, string>>;
+};
+
+const endpoints: readonly string[] = ['macos', 'windows', 'win32'];
+
+export function serializeDesktopTestSelection(request: DesktopTestSelectionRequest): string {
+  const { endpoint, lane, testScopes, values } = request;
+  return JSON.stringify({ endpoint, ...(lane ? { lane } : {}), ...(testScopes ? { testScopes } : {}), values });
+}
+
+/** Validates the selection a launcher sent. A malformed one is an error, so a worker never guesses what to run. */
+export function parseDesktopTestSelection(raw: string): DesktopTestSelection {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new TypeError(`${desktopTestSelectionEnvironment} is not valid JSON.`);
+  }
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new TypeError(`${desktopTestSelectionEnvironment} must be an object.`);
+  }
+  const selection = value as Record<string, unknown>;
+  const unknown = Object.keys(selection).find((key) => !['endpoint', 'lane', 'testScopes', 'values'].includes(key));
+  if (unknown !== undefined) throw new TypeError(`${desktopTestSelectionEnvironment} has unknown key "${unknown}".`);
+  if (typeof selection.endpoint !== 'string' || !endpoints.includes(selection.endpoint)) {
+    throw new TypeError(`${desktopTestSelectionEnvironment}.endpoint must be one of: ${endpoints.join(', ')}.`);
+  }
+  if (selection.lane !== undefined && !desktopInputLanes.some((lane) => lane === selection.lane)) {
+    throw new TypeError(`${desktopTestSelectionEnvironment}.lane must be one of: ${desktopInputLanes.join(', ')}.`);
+  }
+  const domains = resolveDesktopScopeDomains(selection.testScopes, `${desktopTestSelectionEnvironment}.testScopes`);
+  return {
+    endpoint: selection.endpoint as DesktopEndpoint,
+    ...(selection.lane ? { lane: selection.lane as DesktopInputLane } : {}),
+    domains,
+    values: resolveDesktopScopeValues(selection.values ?? {}, domains, `${desktopTestSelectionEnvironment}.values`),
+  };
+}
+
+/** The selection of this process, or undefined when no desktop-test run started it. */
+export function desktopTestSelectionFromEnvironment(environment: NodeJS.ProcessEnv = process.env): DesktopTestSelection | undefined {
+  const raw = environment[desktopTestSelectionEnvironment];
+  return raw === undefined ? undefined : parseDesktopTestSelection(raw);
+}
diff --git a/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts b/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
new file mode 100644
index 0000000000..85c105ec72
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
@@ -0,0 +1,183 @@
+import { createDesktopJasmine } from './adapter.js';
+import type { DesktopJasmineApi } from './adapter.js';
+import { createDesktopJasmineRegistry } from './registry.js';
+import { desktopTestSelectionEnvironment, serializeDesktopTestSelection } from './selection.js';
+import { selectDesktopSpecs } from './specSelection.js';
+import type { DesktopJasmineEnvironment } from './specSelection.js';
+
+type Node = { id?: string; description: string; children?: Node[] };
+type SpecFilter = (spec: unknown) => boolean;
+
+const masked = { keyboard: false, physicalClick: false, wheel: false };
+const body = () => undefined;
+
+/** A Jasmine-shaped suite tree that the adapter registers into, and the environment that exposes it. */
+function setup(lane?: 'accessible' | 'physical', configured?: SpecFilter) {
+  const registry = createDesktopJasmineRegistry({
+    [desktopTestSelectionEnvironment]: serializeDesktopTestSelection({
+      endpoint: 'win32',
+      ...(lane ? { lane } : {}),
+      values: { 'rn.renderer': 'paper' },
+    }),
+  });
+  const root: Node = { description: 'top suite', children: [] };
+  const stack = [root];
+  let next = 0;
+  const add = (description: string) => {
+    const spec = { id: `spec${next++}`, description };
+    stack.at(-1)!.children!.push(spec);
+    return spec;
+  };
+  const api: DesktopJasmineApi = {
+    describe(description, suiteBody) {
+      const suite: Node = { description, children: [] };
+      stack.at(-1)!.children!.push(suite);
+      stack.push(suite);
+      try {
+        suiteBody.call({});
+      } finally {
+        stack.pop();
+      }
+    },
+    it: (description) => add(description),
+    xit: (description) => add(description),
+  };
+  let specFilter = configured;
+  const configure = jest.fn((configuration: { specFilter: SpecFilter }) => {
+    specFilter = configuration.specFilter;
+  });
+  const environment: DesktopJasmineEnvironment = { configuration: () => ({ specFilter }), configure, topSuite: () => root };
+  const spec = (description: string) => {
+    const found = root.children!.flatMap((child) => (child.children ?? [child]) as Node[]).find((node) => node.description === description);
+    if (!found) throw new Error(`No spec named ${description}.`);
+    return found;
+  };
+  return {
+    registry,
+    environment,
+    configure,
+    api,
+    spec,
+    runs: (description: string) => specFilter?.(spec(description)) ?? true,
+    ...createDesktopJasmine(api, registry),
+  };
+}
+
+describe('selectDesktopSpecs preflight', () => {
+  test('excludes a spec the host cannot support, so its hooks never run, and leaves the rest', () => {
+    const { desktopIt, environment, registry, runs } = setup('physical');
+    desktopIt('needs keyboard', { requires: ['keyboard'] }, body);
+    desktopIt('needs click', { requires: ['physical-click'] }, body);
+    desktopIt('needs nothing', body);
+
+    selectDesktopSpecs(registry, environment, { keyboard: false, physicalClick: true });
+
+    expect([runs('needs keyboard'), runs('needs click'), runs('needs nothing')]).toEqual([false, true, true]);
+    expect(registry.entries.get('needs keyboardspec0')).toMatchObject({ kind: 'run', missing: ['keyboard'] });
+    expect(registry.entries.get('needs clickspec1')).not.toHaveProperty('missing');
+  });
+
+  test('keeps the filter the user already configured', () => {
+    const { desktopIt, environment, registry, runs } = setup('physical', (spec) => (spec as Node).description !== 'user filtered');
+    desktopIt('user filtered', body);
+    desktopIt('needs keyboard', { requires: ['keyboard'] }, body);
+    desktopIt('kept', body);
+
+    selectDesktopSpecs(registry, environment, { keyboard: false });
+
+    expect([runs('user filtered'), runs('needs keyboard'), runs('kept')]).toEqual([false, false, true]);
+  });
+
+  test('does not touch the filter when the host meets every requirement', () => {
+    const { configure, desktopIt, environment, registry } = setup('physical');
+    desktopIt('needs keyboard', { requires: ['keyboard'] }, body);
+
+    selectDesktopSpecs(registry, environment, { keyboard: true });
+
+    expect(configure).not.toHaveBeenCalled();
+  });
+
+  test('judges a click requirement by what the lane clicks with', () => {
+    const physical = setup('physical');
+    physical.desktopIt('clicks', { requires: ['click'] }, body);
+    selectDesktopSpecs(physical.registry, physical.environment, { physicalClick: false, accessibilityClick: true });
+    expect(physical.runs('clicks')).toBe(false);
+
+    const accessible = setup('accessible');
+    accessible.desktopIt('clicks', { requires: ['click'] }, body);
+    selectDesktopSpecs(accessible.registry, accessible.environment, { ...masked, accessibilityClick: true });
+    expect(accessible.runs('clicks')).toBe(true);
+  });
+});
+
+describe('selectDesktopSpecs fail-closed checks', () => {
+  test('an accessible lane on a host that still offers physical input disables every spec and says why', () => {
+    const { desktopIt, environment, registry, runs } = setup('accessible');
+    desktopIt('fine', body);
+
+    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true, physicalClick: false })).toThrow(
+      'The accessible input lane needs a host that reports keyboard, wheel disabled, and this one does not.',
+    );
+    expect(registry.blocked).toBe(true);
+    expect(runs('fine')).toBe(false);
+  });
+
+  test('an absent feature report counts as unmasked', () => {
+    const { environment, registry } = setup('accessible');
+
+    expect(() => selectDesktopSpecs(registry, environment, undefined)).toThrow(/keyboard, physicalClick, wheel disabled/);
+  });
+
+  test('an accessible lane on a masked host runs', () => {
+    const { desktopIt, environment, registry, runs } = setup('accessible');
+    desktopIt('fine', body);
+
+    selectDesktopSpecs(registry, environment, masked);
+
+    expect(registry.blocked).toBe(false);
+    expect(runs('fine')).toBe(true);
+  });
+
+  test('the physical lane needs no mask', () => {
+    const { desktopIt, environment, registry } = setup('physical');
+    desktopIt('fine', body);
+
+    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true })).not.toThrow();
+  });
+
+  test('a lane refuses specs that were not declared with desktopIt, however many', () => {
+    const { api, desktopIt, environment, registry, runs } = setup('physical');
+    desktopIt('declared', body);
+    api.describe('legacy', () => {
+      for (let index = 0; index < 12; index++) api.it(`spec ${index}`, body);
+    });
+
+    expect(() => selectDesktopSpecs(registry, environment, {})).toThrow(
+      /12 specs were not declared with desktopIt or desktopDescribe: "legacy spec 0", .*"legacy spec 9" and 2 more\./,
+    );
+    expect(registry.blocked).toBe(true);
+    expect(runs('declared')).toBe(false);
+  });
+
+  test('a lane cannot be verified without Jasmine, so it blocks', () => {
+    const { registry } = setup('physical');
+
+    expect(() => selectDesktopSpecs(registry, undefined, {})).toThrow('Jasmine did not expose its environment');
+    expect(registry.blocked).toBe(true);
+  });
+
+  test('without a lane, undeclared specs are tolerated', () => {
+    const { api, environment, registry } = setup();
+    api.it('legacy', body);
+
+    expect(() => selectDesktopSpecs(registry, environment, {})).not.toThrow();
+  });
+
+  test('a fault found while registering blocks the run even without a lane, together with any other problem', () => {
+    const { environment, registry } = setup('accessible');
+    registry.errors.push('Jasmine did not identify the spec registered for "ghost", so its selection cannot be verified.');
+
+    expect(() => selectDesktopSpecs(registry, environment, {})).toThrow(/ghost[\s\S]*accessible input lane/);
+    expect(registry.blocked).toBe(true);
+  });
+});
diff --git a/packages/agentic/desktop-test/src/jasmine/specSelection.ts b/packages/agentic/desktop-test/src/jasmine/specSelection.ts
new file mode 100644
index 0000000000..ac3c059544
--- /dev/null
+++ b/packages/agentic/desktop-test/src/jasmine/specSelection.ts
@@ -0,0 +1,96 @@
+import {
+  missingDesktopRequirements,
+  resolveDesktopClickMode,
+  unmaskedAccessibleFeatures,
+} from '@fluentui-react-native/desktop-driver/authoring';
+import { desktopSpecIdentifier } from './registry.js';
+import type { DesktopJasmineRegistry } from './registry.js';
+
+type JasmineNode = { id?: unknown; description?: unknown; children?: readonly JasmineNode[] };
+type JasmineSpecFilter = (spec: unknown) => boolean;
+
+/** The part of Jasmine's environment that applying a selection needs. */
+export type DesktopJasmineEnvironment = {
+  configuration(): { specFilter?: JasmineSpecFilter };
+  configure(configuration: { specFilter: JasmineSpecFilter }): void;
+  topSuite(): JasmineNode;
+};
+
+/** The environment of the Jasmine this process runs under, if a framework installed one. */
+export function currentDesktopJasmineEnvironment(): DesktopJasmineEnvironment | undefined {
+  const jasmine = (globalThis as { jasmine?: { getEnv?: () => DesktopJasmineEnvironment } }).jasmine;
+  return jasmine?.getEnv?.();
+}
+
+const listedSpecs = 10;
+
+/**
+ * Applies a run's selection once the spec files have registered their tests and the host is known, before any test runs.
+ *
+ * A fault that makes the selection untrustworthy disables every spec and throws, so a lane never executes a test it cannot
+ * vouch for. Otherwise, a test whose requirements the host cannot meet is excluded here and reported as unsupported.
+ */
+export function selectDesktopSpecs(
+  registry: DesktopJasmineRegistry,
+  environment: DesktopJasmineEnvironment | undefined,
+  features: unknown,
+): void {
+  const lane = registry.selection?.lane;
+  const problems = [...registry.errors];
+  if (lane === 'accessible') {
+    const unmasked = unmaskedAccessibleFeatures(features);
+    if (unmasked.length > 0) {
+      problems.push(`The accessible input lane needs a host that reports ${unmasked.join(', ')} disabled, and this one does not.`);
+    }
+  }
+  if (lane) {
+    const undeclared = environment ? undeclaredSpecs(registry, environment) : undefined;
+    if (!undeclared) problems.push('Jasmine did not expose its environment, so the specs of an input lane cannot be verified.');
+    else if (undeclared.length > 0) {
+      const listed = undeclared.slice(0, listedSpecs).join(', ');
+      const more = undeclared.length > listedSpecs ? ` and ${undeclared.length - listedSpecs} more` : '';
+      problems.push(
+        `An input lane runs only declared tests, but ${undeclared.length} ${undeclared.length === 1 ? 'spec was' : 'specs were'} not declared with desktopIt or desktopDescribe: ${listed}${more}.`,
+      );
+    }
+  }
+  if (problems.length > 0) {
+    registry.blocked = true;
+    environment?.configure({ specFilter: () => false });
+    throw new Error(problems.join('\n'));
+  }
+  if (!environment) return;
+  // The session's click mode is the lane's, so this is what a `click` requirement would really do.
+  const clickMode = resolveDesktopClickMode(undefined, 'auto', lane);
+  const unavailable = new Set<string>();
+  for (const [identifier, entry] of registry.entries) {
+    if (entry.kind !== 'run') continue;
+    const missing = missingDesktopRequirements(entry.descriptor, features as Readonly<Record<string, unknown>> | undefined, clickMode);
+    if (missing.length === 0) continue;
+    entry.missing = missing;
+    unavailable.add(identifier);
+  }
+  if (unavailable.size === 0) return;
+  const configured = environment.configuration().specFilter;
+  // A filtered spec is excluded before Jasmine runs its hooks, which an executed-then-skipped spec could not avoid.
+  environment.configure({
+    specFilter: (spec) => {
+      const identifier = desktopSpecIdentifier(spec as { description?: unknown; id?: unknown });
+      return !(identifier !== undefined && unavailable.has(identifier)) && (configured?.(spec) ?? true);
+    },
+  });
+}
+
+/** The full names of the specs no `desktopIt` registered. */
+function undeclaredSpecs(registry: DesktopJasmineRegistry, environment: DesktopJasmineEnvironment): string[] {
+  const undeclared: string[] = [];
+  const visit = (node: JasmineNode, path: readonly string[]) => {
+    for (const child of node.children ?? []) {
+      const names = [...path, String(child.description)];
+      if (child.children) visit(child, names);
+      else if (!registry.entries.has(desktopSpecIdentifier(child) ?? '')) undeclared.push(`"${names.join(' ')}"`);
+    }
+  };
+  visit(environment.topSuite(), []);
+  return undeclared;
+}
diff --git a/packages/agentic/desktop-test/src/reporting/collector.test.ts b/packages/agentic/desktop-test/src/reporting/collector.test.ts
index 40d556cf07..3d2d3f3f39 100644
--- a/packages/agentic/desktop-test/src/reporting/collector.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/collector.test.ts
@@ -3,6 +3,127 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { DesktopRunReporter } from './collector.js';
+import type { DesktopInputLaneReport } from './results.js';
+
+describe('desktop run reporter input lanes', () => {
+  const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false };
+  let artifactsRoot: string;
+
+  beforeEach(() => {
+    artifactsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-desktop-lane-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(artifactsRoot, { force: true, recursive: true });
+  });
+
+  function start(reporterMode: 'plain' | 'ndjson', lane?: DesktopInputLaneReport) {
+    let written = '';
+    const output = {
+      write: (chunk: string) => {
+        written += chunk;
+        return true;
+      },
+    };
+    const reporter = new DesktopRunReporter({
+      artifactsRoot,
+      errorOutput: output,
+      output,
+      reporterMode,
+      summary: false,
+      ...(lane ? { lane } : {}),
+    });
+    return { reporter, output: () => written };
+  }
+
+  function unsupported(reporter: DesktopRunReporter, testId: string, gap?: 'unsupported' | 'quarantine'): void {
+    reporter.emit({
+      kind: 'test-result',
+      payload: {
+        testId,
+        title: testId,
+        attempt: 0,
+        status: 'unsupported',
+        durationMs: 0,
+        reason: 'Not available.',
+        ...(gap ? { gap } : {}),
+      },
+    });
+  }
+
+  function passed(reporter: DesktopRunReporter, testId: string): void {
+    reporter.emit({ kind: 'test-result', payload: { testId, title: testId, attempt: 0, status: 'passed', durationMs: 1 } });
+  }
+
+  test('persists the lane and sums exclusions from every producer without selecting them as tests', async () => {
+    const { reporter } = start('plain', accessible);
+    reporter.emit({ kind: 'selection', payload: { excluded: { platform: 2, scope: 0, input: 5 } } });
+    reporter.emit({ kind: 'selection', payload: { excluded: { platform: 1, scope: 1, input: 4 } } });
+    passed(reporter, 'case');
+    const result = await reporter.finish();
+
+    expect(result).toMatchObject({
+      status: 'passed',
+      lane: accessible,
+      selection: { excluded: { platform: 3, scope: 1, input: 9 } },
+      counts: { selected: 1, passed: 1 },
+    });
+    expect(JSON.parse(fs.readFileSync(path.join(reporter.root, 'run.json'), 'utf8'))).toMatchObject({
+      lane: accessible,
+      selection: { excluded: { platform: 3, scope: 1, input: 9 } },
+    });
+  });
+
+  test('counts a keyed selection once, so a retried worker does not double its exclusions', async () => {
+    const { reporter } = start('plain', accessible);
+    const excluded = { platform: 1, scope: 2, input: 3 };
+    reporter.emit({ kind: 'selection', payload: { excluded, key: 'wdio-group' } });
+    reporter.emit({ kind: 'selection', payload: { excluded, key: 'wdio-group' } });
+    reporter.emit({ kind: 'selection', payload: { excluded: { platform: 0, scope: 0, input: 1 }, key: 'another-group' } });
+    passed(reporter, 'case');
+
+    expect(await reporter.finish()).toMatchObject({ selection: { excluded: { platform: 1, scope: 2, input: 4 } } });
+  });
+
+  test('omits the selection when no producer reported one', async () => {
+    const { reporter } = start('plain', accessible);
+    passed(reporter, 'case');
+
+    expect(await reporter.finish()).not.toHaveProperty('selection');
+  });
+
+  test('a lane run is incomplete when a case was unsupported without a declaration', async () => {
+    const { reporter, output } = start('plain', accessible);
+    passed(reporter, 'case');
+    unsupported(reporter, 'declared', 'unsupported');
+    unsupported(reporter, 'missing');
+    reporter.emit({ kind: 'selection', payload: { excluded: { platform: 0, scope: 0, input: 3 } } });
+    const result = await reporter.finish();
+
+    expect(result.status).toBe('incomplete');
+    expect(output()).toContain('2 unsupported (1 declared, 0 quarantined)');
+    expect(output()).toContain('[desktop] input accessible (host-masked) from --input; excluded 0 by platform, 0 by scope, 3 by input');
+  });
+
+  test('the same unsupported case does not fail a compatibility run', async () => {
+    const { reporter, output } = start('plain');
+    passed(reporter, 'case');
+    unsupported(reporter, 'missing');
+    const result = await reporter.finish();
+
+    expect(result.status).toBe('passed');
+    expect(result).not.toHaveProperty('lane');
+    expect(output()).not.toContain('excluded');
+  });
+
+  test('the ndjson start message names the lane', async () => {
+    const { reporter, output } = start('ndjson', accessible);
+    passed(reporter, 'case');
+    await reporter.finish();
+
+    expect(JSON.parse(output().split('\n')[0])).toMatchObject({ type: 'start', lane: accessible });
+  });
+});
 
 describe('desktop run reporter final output', () => {
   let artifactsRoot: string;
diff --git a/packages/agentic/desktop-test/src/reporting/collector.ts b/packages/agentic/desktop-test/src/reporting/collector.ts
index 4acbd00b8d..c2d81db4cf 100644
--- a/packages/agentic/desktop-test/src/reporting/collector.ts
+++ b/packages/agentic/desktop-test/src/reporting/collector.ts
@@ -9,12 +9,20 @@ import {
   DesktopReportedError,
   redactDesktopSecrets,
   sanitizeDesktopReport,
+  selectionExclusionReasons,
   serializeReportError,
   validateDesktopEvent,
 } from './protocol.js';
 import type { CollectedDesktopEvent, EventContext, EventEmitter, FailureKind, ReportError, ReportFailure } from './protocol.js';
-import { projectDesktopRunSummary, renderJUnit, renderRunSummary, summarizeDesktopRun } from './results.js';
-import type { DesktopRunResult, DesktopTestResult, DesktopWorkResult } from './results.js';
+import {
+  describeDesktopSelection,
+  describeDesktopUnsupported,
+  projectDesktopRunSummary,
+  renderJUnit,
+  renderRunSummary,
+  summarizeDesktopRun,
+} from './results.js';
+import type { DesktopInputLaneReport, DesktopRunResult, DesktopTestResult, DesktopWorkResult } from './results.js';
 import { includeDesktopEvent, projectDesktopEvent } from './structured.js';
 import type { DesktopEventLevel } from './structured.js';
 import type { DesktopReportingConfig } from '../config.js';
@@ -25,6 +33,8 @@ export type ReportOutput = Pick<NodeJS.WriteStream, 'write'>;
 export type DesktopRunReporterOptions = DesktopReportingConfig & {
   artifactsRoot: string;
   context?: EventContext;
+  /** The input lane this run executes. Lane runs hold every selected case to its declared outcome. */
+  lane?: DesktopInputLaneReport;
   kind?: 'tests' | 'lifecycle';
   optional?: boolean;
   output?: ReportOutput;
@@ -68,6 +78,9 @@ export class DesktopRunReporter {
   private readonly presentedFailures = new Set<string>();
   private readonly secrets = new Set<string>();
   private readonly artifacts = new Map<string, string>();
+  private readonly excluded = { platform: 0, scope: 0, input: 0 };
+  private readonly selectionKeys = new Set<string>();
+  private excludedReported = false;
   private readonly options: DesktopRunReporterOptions;
   private readonly actions: boolean;
   private readonly output: ReportOutput;
@@ -136,6 +149,7 @@ export class DesktopRunReporter {
         runId: this.runId,
         kind: options.kind ?? 'tests',
         ...(options.context ? { context: options.context } : {}),
+        ...(options.lane ? { lane: options.lane } : {}),
         artifactsRoot: clipStructuredText(this.root, 512),
       };
       this.enqueue(() => this.write(this.output, `${JSON.stringify(start)}\n`), 0);
@@ -314,6 +328,14 @@ export class DesktopRunReporter {
       test.status = test.attempts[test.attempts.length - 1].status;
       test.flaky = test.status === 'passed' && test.attempts.some(({ status }) => status === 'failed');
       this.tests.set(p.testId, test);
+    } else if (event.kind === 'selection') {
+      this.excludedReported = true;
+      // A keyed event is idempotent: a retried worker announces the same exclusions again.
+      if (event.payload.key !== undefined) {
+        if (this.selectionKeys.has(event.payload.key)) return;
+        this.selectionKeys.add(event.payload.key);
+      }
+      for (const reason of selectionExclusionReasons) this.excluded[reason] += event.payload.excluded[reason];
     } else if (event.kind === 'artifact') this.artifacts.set(event.payload.path, event.payload.description);
   }
 
@@ -495,6 +517,8 @@ export class DesktopRunReporter {
       finishedAt: new Date().toISOString(),
       durationMs: Date.now() - this.startedAt.getTime(),
       context: this.options.context,
+      ...(this.options.lane ? { lane: this.options.lane } : {}),
+      ...(this.excludedReported ? { selection: { excluded: { ...this.excluded } } } : {}),
       optional: this.options.optional,
       incomplete:
         [...this.scopes.values()].some(({ finished }) => !finished) ||
@@ -551,8 +575,10 @@ export class DesktopRunReporter {
     let result = persist();
     const c = result.counts;
     this.logger.log(
-      `[desktop] ${result.status.toUpperCase()}: ${c.selected} selected, ${c.executed} executed, ${c.passed} passed, ${c.failed} failed, ${c.skipped} skipped, ${c.unsupported} unsupported, ${c.incomplete} incomplete, ${c.retries} retries, ${c.flaky} flaky; ${result.work.filter(({ status }) => status === 'not-run').length} groups not run; ${path.join(this.root, 'run.json')}`,
+      `[desktop] ${result.status.toUpperCase()}: ${c.selected} selected, ${c.executed} executed, ${c.passed} passed, ${c.failed} failed, ${c.skipped} skipped, ${describeDesktopUnsupported(c)}, ${c.incomplete} incomplete, ${c.retries} retries, ${c.flaky} flaky; ${result.work.filter(({ status }) => status === 'not-run').length} groups not run; ${path.join(this.root, 'run.json')}`,
     );
+    const selection = describeDesktopSelection(result);
+    if (selection) this.logger.log(`[desktop] ${selection}`);
     await this.queue;
     result = persist();
     if (this.presentationFailed && !this.structured) {
diff --git a/packages/agentic/desktop-test/src/reporting/index.ts b/packages/agentic/desktop-test/src/reporting/index.ts
index 428250bac3..16383d62c2 100644
--- a/packages/agentic/desktop-test/src/reporting/index.ts
+++ b/packages/agentic/desktop-test/src/reporting/index.ts
@@ -11,11 +11,33 @@ export type {
   FailureKind,
   ReportError,
   ReportFailure,
+  SelectionExclusions,
+  TestGap,
   TestStatus,
 } from './protocol.js';
 export type { DesktopEventRecord } from './structured.js';
 export type { DesktopEventLevel } from '@fluentui-react-native/desktop-driver/cli/reporter';
-export { desktopRunExitCode, projectDesktopRunSummary, renderJUnit, renderRunSummary, summarizeDesktopRun } from './results.js';
-export type { DesktopRunResult, DesktopRunSummary, DesktopTestAttempt, DesktopTestResult } from './results.js';
+export { createDesktopInputLane, desktopInputEnvironment, parseDesktopInputLane, requestedDesktopInputLane } from './lane.js';
+export type { DesktopInputLaneName, RequestedDesktopInputLane } from './lane.js';
+export {
+  describeDesktopInputLane,
+  describeDesktopSelection,
+  describeDesktopUnsupported,
+  desktopInputLaneSources,
+  desktopRunExitCode,
+  projectDesktopRunSummary,
+  renderJUnit,
+  renderRunSummary,
+  summarizeDesktopRun,
+} from './results.js';
+export type {
+  DesktopInputLaneReport,
+  DesktopInputLaneSource,
+  DesktopRunResult,
+  DesktopRunSummary,
+  DesktopSelectionReport,
+  DesktopTestAttempt,
+  DesktopTestResult,
+} from './results.js';
 export { connectReportProducer, DESKTOP_REPORT_CONTEXT, startReportTransport } from './transport.js';
 export type { ReportProducer, ReportTransport, ReportTransportContext } from './transport.js';
diff --git a/packages/agentic/desktop-test/src/reporting/lane.test.ts b/packages/agentic/desktop-test/src/reporting/lane.test.ts
new file mode 100644
index 0000000000..f10c320dd9
--- /dev/null
+++ b/packages/agentic/desktop-test/src/reporting/lane.test.ts
@@ -0,0 +1,34 @@
+import { createDesktopInputLane, desktopInputEnvironment, parseDesktopInputLane, requestedDesktopInputLane } from './lane.js';
+
+describe('requested desktop input lane', () => {
+  test('the flag wins over the environment', () => {
+    expect(requestedDesktopInputLane({ flag: 'physical', environment: 'accessible' })).toEqual({ input: 'physical', source: 'option' });
+  });
+
+  test('the environment applies when there is no flag', () => {
+    expect(requestedDesktopInputLane({ environment: 'accessible' })).toEqual({ input: 'accessible', source: 'environment' });
+    expect(requestedDesktopInputLane({})).toBeUndefined();
+  });
+
+  test('an empty value is invalid rather than unset, and an error names where it came from', () => {
+    expect(() => requestedDesktopInputLane({ environment: '' })).toThrow(`${desktopInputEnvironment} must be accessible or physical.`);
+    expect(() => requestedDesktopInputLane({ flag: 'fast' })).toThrow('--input must be accessible or physical.');
+    expect(() => parseDesktopInputLane('Physical', 'x')).toThrow(expect.objectContaining({ code: 'config' }));
+  });
+});
+
+describe('createDesktopInputLane', () => {
+  test('an accessible lane says how it was masked, and neither lane claims enforcement yet', () => {
+    expect(createDesktopInputLane('accessible', 'option')).toEqual({
+      input: 'accessible',
+      source: 'option',
+      masking: 'host-masked',
+      policyEnforced: false,
+    });
+    expect(createDesktopInputLane('accessible', 'driver', 'verified-masked')).toMatchObject({
+      masking: 'verified-masked',
+      source: 'driver',
+    });
+    expect(createDesktopInputLane('physical', 'environment')).toEqual({ input: 'physical', source: 'environment', policyEnforced: false });
+  });
+});
diff --git a/packages/agentic/desktop-test/src/reporting/lane.ts b/packages/agentic/desktop-test/src/reporting/lane.ts
new file mode 100644
index 0000000000..49064f01e2
--- /dev/null
+++ b/packages/agentic/desktop-test/src/reporting/lane.ts
@@ -0,0 +1,37 @@
+import type { DesktopInputLaneReport, DesktopInputLaneSource } from './results.js';
+
+/** Selects the input lane of a `test` run when `--input` is absent. */
+export const desktopInputEnvironment = 'DESKTOP_INPUT';
+
+export type DesktopInputLaneName = DesktopInputLaneReport['input'];
+
+export type RequestedDesktopInputLane = { input: DesktopInputLaneName; source: Extract<DesktopInputLaneSource, 'option' | 'environment'> };
+
+/** Validates a requested lane. `source` names where the value came from, so a bad one points at the right place. */
+export function parseDesktopInputLane(value: string, source: string): DesktopInputLaneName {
+  if (value !== 'accessible' && value !== 'physical') {
+    throw Object.assign(new TypeError(`${source} must be accessible or physical.`), { code: 'config' });
+  }
+  return value;
+}
+
+/** The lane a command was asked for: `--input`, then `DESKTOP_INPUT`. An empty environment value is invalid, not unset. */
+export function requestedDesktopInputLane(request: { flag?: string; environment?: string }): RequestedDesktopInputLane | undefined {
+  if (request.flag !== undefined) return { input: parseDesktopInputLane(request.flag, '--input'), source: 'option' };
+  if (request.environment !== undefined) {
+    return { input: parseDesktopInputLane(request.environment, desktopInputEnvironment), source: 'environment' };
+  }
+  return undefined;
+}
+
+/**
+ * How an accessible lane was masked. `host-masked` means this command started the host with keyboard, physical click and
+ * wheel disabled. `verified-masked` means it attached to a host and checked the mask before running anything.
+ */
+export function createDesktopInputLane(
+  input: DesktopInputLaneName,
+  source: DesktopInputLaneSource,
+  masking: 'host-masked' | 'verified-masked' = 'host-masked',
+): DesktopInputLaneReport {
+  return input === 'physical' ? { input, source, policyEnforced: false } : { input, source, masking, policyEnforced: false };
+}
diff --git a/packages/agentic/desktop-test/src/reporting/protocol.test.ts b/packages/agentic/desktop-test/src/reporting/protocol.test.ts
index 19f5fc1fac..2462042655 100644
--- a/packages/agentic/desktop-test/src/reporting/protocol.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/protocol.test.ts
@@ -1,4 +1,52 @@
-import { redactDesktopSecrets } from './protocol';
+import { redactDesktopSecrets, validateDesktopEvent } from './protocol';
+
+describe('declared gaps and selection events', () => {
+  function event(kind: string, payload: Record<string, unknown>): unknown {
+    return {
+      schemaVersion: 1,
+      runId: 'run-id',
+      eventId: 'event-id',
+      sourceId: 'worker',
+      sourceSequence: 1,
+      scopeId: 'scope-id',
+      timestamp: new Date(0).toISOString(),
+      kind,
+      payload,
+    };
+  }
+  const result = { testId: 'test', title: 'test', attempt: 0, durationMs: 0, reason: 'Declared in the story.' };
+
+  test.each(['unsupported', 'quarantine'])('accepts a %s gap on an unsupported result', (gap) => {
+    expect(() => validateDesktopEvent(event('test-result', { ...result, status: 'unsupported', gap }))).not.toThrow();
+  });
+
+  test.each(['skipped', 'failed', 'passed'])('rejects a declared gap on a %s result', (status) => {
+    expect(() => validateDesktopEvent(event('test-result', { ...result, status, gap: 'unsupported' }))).toThrow();
+  });
+
+  test('rejects an unknown gap kind', () => {
+    expect(() => validateDesktopEvent(event('test-result', { ...result, status: 'unsupported', gap: 'flaky' }))).toThrow();
+  });
+
+  test('accepts exactly the three non-negative integer exclusion counts', () => {
+    expect(() => validateDesktopEvent(event('selection', { excluded: { platform: 1, scope: 0, input: 12 } }))).not.toThrow();
+  });
+
+  test('accepts an optional idempotency key and rejects an empty one', () => {
+    const excluded = { platform: 1, scope: 0, input: 0 };
+    expect(() => validateDesktopEvent(event('selection', { excluded, key: 'wdio-group' }))).not.toThrow();
+    expect(() => validateDesktopEvent(event('selection', { excluded, key: '' }))).toThrow();
+  });
+
+  test.each([
+    ['a missing reason', { platform: 1, scope: 0 }],
+    ['an unknown reason', { platform: 1, scope: 0, input: 0, flaky: 1 }],
+    ['a negative count', { platform: -1, scope: 0, input: 0 }],
+    ['a fractional count', { platform: 0.5, scope: 0, input: 0 }],
+  ])('rejects a selection with %s', (_name, excluded) => {
+    expect(() => validateDesktopEvent(event('selection', { excluded }))).toThrow();
+  });
+});
 
 describe('redactDesktopSecrets', () => {
   test('redacts known secrets, longest first', () => {
diff --git a/packages/agentic/desktop-test/src/reporting/protocol.ts b/packages/agentic/desktop-test/src/reporting/protocol.ts
index 447455b715..524c10f50b 100644
--- a/packages/agentic/desktop-test/src/reporting/protocol.ts
+++ b/packages/agentic/desktop-test/src/reporting/protocol.ts
@@ -15,6 +15,12 @@ export class DesktopReportedError extends Error {
   }
 }
 export type TestStatus = 'passed' | 'failed' | 'skipped' | 'unsupported' | 'cancelled' | 'not-run' | 'incomplete';
+/** A declared gap: the producer knows the case cannot run here and says why, so it is not a silent skip. */
+export type TestGap = 'unsupported' | 'quarantine';
+export const testGaps: readonly TestGap[] = ['unsupported', 'quarantine'];
+/** Cases a producer removed from its selection before any session existed, by the reason they were removed. */
+export type SelectionExclusions = { platform: number; scope: number; input: number };
+export const selectionExclusionReasons: readonly (keyof SelectionExclusions)[] = ['platform', 'scope', 'input'];
 export type EventContext = {
   endpoint?: 'macos' | 'windows' | 'win32';
   renderer?: 'fabric' | 'paper';
@@ -43,9 +49,11 @@ export type EventData =
         status: TestStatus;
         durationMs: number;
         reason?: string;
+        gap?: TestGap;
         failure?: ReportFailure;
       };
     }
+  | { kind: 'selection'; payload: { excluded: SelectionExclusions; key?: string } }
   | { kind: 'artifact'; payload: { path: string; description: string } }
   | { kind: 'producer-finished'; payload: { status: 'passed' | 'failed' } }
   | { kind: 'run-finished'; payload: { status: TestStatus; resultPath: string } };
@@ -74,7 +82,8 @@ const payloadFields = {
   diagnostic: ['level', 'message', 'failure'],
   output: ['stream', 'text'],
   'test-start': ['testId', 'title', 'attempt'],
-  'test-result': ['testId', 'title', 'attempt', 'status', 'durationMs', 'reason', 'failure'],
+  'test-result': ['testId', 'title', 'attempt', 'status', 'durationMs', 'reason', 'gap', 'failure'],
+  selection: ['excluded', 'key'],
   artifact: ['path', 'description'],
   'producer-finished': ['status'],
   'run-finished': ['status', 'resultPath'],
@@ -178,9 +187,20 @@ export function validateDesktopEvent(value: unknown): asserts value is DesktopEv
           throw new TypeError('Non-executed test results require a reason.');
         }
         if (payload.status === 'failed' && !payload.failure) throw new TypeError('Failed test results require their original failure.');
+        if (payload.gap !== undefined) {
+          member(payload.gap, testGaps);
+          if (payload.status !== 'unsupported') throw new TypeError('A declared gap is only valid on an unsupported test result.');
+        }
         if (payload.failure !== undefined) validateFailure(payload.failure);
       }
       break;
+    case 'selection': {
+      const excluded = record(payload.excluded, 'excluded');
+      exactKeys(excluded, selectionExclusionReasons);
+      for (const reason of selectionExclusionReasons) integer(excluded[reason], `excluded.${reason}`, 0);
+      if (payload.key !== undefined) requireText(payload.key, 'selection key');
+      break;
+    }
     case 'artifact':
       requireText(payload.path, 'artifact path');
       requireText(payload.description, 'artifact description');
diff --git a/packages/agentic/desktop-test/src/reporting/results.test.ts b/packages/agentic/desktop-test/src/reporting/results.test.ts
index af29cd80c3..82208acd89 100644
--- a/packages/agentic/desktop-test/src/reporting/results.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/results.test.ts
@@ -1,7 +1,174 @@
 import os from 'node:os';
 import path from 'node:path';
 
-import { projectDesktopRunSummary, summarizeDesktopRun } from './results.js';
+import {
+  describeDesktopSelection,
+  describeDesktopUnsupported,
+  projectDesktopRunSummary,
+  renderJUnit,
+  renderRunSummary,
+  summarizeDesktopRun,
+} from './results.js';
+import type { DesktopInputLaneReport, DesktopRunResult, DesktopTestResult } from './results.js';
+
+const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false };
+
+function outcome(
+  status: DesktopTestResult['status'],
+  gap?: 'unsupported' | 'quarantine',
+  testId = `${status}-${gap ?? 'plain'}`,
+): DesktopTestResult {
+  return {
+    testId,
+    title: testId,
+    status,
+    flaky: false,
+    attempts: [
+      {
+        attempt: 0,
+        status,
+        durationMs: 1,
+        ...(status === 'passed' ? {} : { reason: 'Not executed.' }),
+        ...(gap ? { gap } : {}),
+      },
+    ],
+  };
+}
+
+function summarize(
+  tests: DesktopTestResult[],
+  extra: { lane?: DesktopInputLaneReport; optional?: boolean; kind?: 'tests' | 'lifecycle' } = {},
+): DesktopRunResult {
+  const { lane, optional, kind = 'tests' } = extra;
+  return summarizeDesktopRun({
+    schemaVersion: 1,
+    runId: 'run-id',
+    kind,
+    startedAt: new Date(0).toISOString(),
+    finishedAt: new Date(1).toISOString(),
+    durationMs: 1,
+    ...(lane ? { lane } : {}),
+    ...(optional !== undefined ? { optional } : {}),
+    tests,
+    work: [],
+    failures: [],
+    artifacts: [],
+  });
+}
+
+describe('input lane verdicts', () => {
+  test('compatibility runs keep skipped and unsupported cases non-blocking', () => {
+    expect(summarize([outcome('passed'), outcome('skipped'), outcome('unsupported')]).status).toBe('passed');
+  });
+
+  test.each([
+    ['unsupported', 'declaredUnsupported'],
+    ['quarantine', 'quarantined'],
+  ] as const)('a declared %s gap is a deliberate gap, not a lane failure', (gap, subset) => {
+    const result = summarize([outcome('passed'), outcome('unsupported', gap)], { lane: accessible });
+
+    expect(result.status).toBe('passed');
+    expect(result.counts).toMatchObject({
+      unsupported: 1,
+      declaredUnsupported: Number(gap === 'unsupported'),
+      quarantined: Number(gap === 'quarantine'),
+    });
+    expect(result.counts[subset]).toBe(1);
+  });
+
+  test('an undeclared unsupported case means the lane did not cover its selection', () => {
+    const result = summarize([outcome('passed'), outcome('unsupported')], { lane: accessible });
+
+    expect(result.status).toBe('incomplete');
+    expect(result.counts).toMatchObject({ unsupported: 1, declaredUnsupported: 0, quarantined: 0 });
+  });
+
+  test('a skipped case means the lane did not cover its selection', () => {
+    expect(summarize([outcome('passed'), outcome('skipped')], { lane: accessible }).status).toBe('incomplete');
+  });
+
+  test('optional never masks a lane that skipped or executed nothing', () => {
+    expect(summarize([outcome('passed'), outcome('skipped')], { lane: accessible, optional: true }).status).toBe('incomplete');
+    expect(summarize([outcome('unsupported', 'unsupported')], { lane: accessible, optional: true }).status).toBe('incomplete');
+    expect(summarize([outcome('skipped')], { optional: true }).status).toBe('skipped');
+  });
+
+  test('an empty lane selection is incomplete', () => {
+    expect(summarize([], { lane: accessible }).status).toBe('incomplete');
+  });
+
+  test('failures still fail a lane run', () => {
+    const failed = outcome('failed');
+    failed.attempts[0].failure = { failureId: 'f', kind: 'test', error: { name: 'Error', message: 'boom' } };
+
+    expect(summarize([outcome('passed'), failed], { lane: accessible }).status).toBe('failed');
+  });
+
+  test('lifecycle runs ignore the lane', () => {
+    expect(summarize([], { lane: accessible, kind: 'lifecycle' }).status).toBe('passed');
+  });
+});
+
+describe('input lane and exclusion reporting', () => {
+  const selection = { excluded: { platform: 2, scope: 1, input: 7 } };
+  const result = (): DesktopRunResult => ({
+    ...summarize([outcome('passed'), outcome('unsupported', 'unsupported'), outcome('unsupported', 'quarantine', 'quarantined-case')], {
+      lane: accessible,
+    }),
+    selection,
+  });
+
+  test('names the lane, its source and each exclusion on one line', () => {
+    expect(describeDesktopSelection(result())).toBe(
+      'input accessible (host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input',
+    );
+    expect(describeDesktopSelection({ lane: { input: 'physical', source: 'environment', policyEnforced: false } })).toBe(
+      'input physical pilot from DESKTOP_INPUT',
+    );
+    expect(
+      describeDesktopSelection({ lane: { input: 'accessible', source: 'driver', masking: 'verified-masked', policyEnforced: false } }),
+    ).toBe('input accessible (verified-masked) from the driver instance');
+    expect(describeDesktopSelection({})).toBeUndefined();
+  });
+
+  test('breaks unsupported cases into declared and quarantined', () => {
+    expect(describeDesktopUnsupported(result().counts)).toBe('2 unsupported (1 declared, 1 quarantined)');
+  });
+
+  test('JUnit records the lane and exclusions and labels declared gaps', () => {
+    const xml = renderJUnit(result());
+
+    expect(xml).toContain('<property name="desktop.input" value="accessible"/>');
+    expect(xml).toContain('<property name="desktop.input.label" value="accessible (host-masked)"/>');
+    expect(xml).toContain('<property name="desktop.input.source" value="option"/>');
+    expect(xml).toContain('<property name="desktop.excluded.platform" value="2"/>');
+    expect(xml).toContain('<property name="desktop.excluded.input" value="7"/>');
+    expect(xml).toContain('<skipped message="declared unsupported: Not executed."/>');
+    expect(xml).toContain('<skipped message="quarantined: Not executed."/>');
+    expect(xml).toContain('skipped="2"');
+  });
+
+  test('JUnit stays free of lane properties for compatibility runs', () => {
+    expect(renderJUnit(summarize([outcome('passed')]))).not.toContain('<properties>');
+  });
+
+  test('the Markdown summary leads with the selection and splits unsupported counts', () => {
+    const markdown = renderRunSummary(result());
+
+    expect(markdown).toContain('Selection: input accessible (host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input.');
+    expect(markdown).toContain('2 unsupported (1 declared, 1 quarantined)');
+    expect(markdown).toContain('declared unsupported: Not executed.');
+  });
+
+  test('the bounded summary carries the lane and exclusions', () => {
+    const summary = projectDesktopRunSummary(result(), path.join(os.tmpdir(), 'desktop-artifacts', 'run-id'));
+
+    expect(summary.lane).toEqual(accessible);
+    expect(summary.excluded).toEqual(selection.excluded);
+    expect(summary.skippedReasons).toContain('declared unsupported: Not executed.');
+    expect(Buffer.byteLength(JSON.stringify(summary))).toBeLessThanOrEqual(4 * 1024);
+  });
+});
 
 describe('bounded desktop run summary', () => {
   test('keeps large suites and failure messages within the document limit', () => {
diff --git a/packages/agentic/desktop-test/src/reporting/results.ts b/packages/agentic/desktop-test/src/reporting/results.ts
index 2470c157bc..02fa673fe8 100644
--- a/packages/agentic/desktop-test/src/reporting/results.ts
+++ b/packages/agentic/desktop-test/src/reporting/results.ts
@@ -1,15 +1,28 @@
 import path from 'node:path';
 
-import type { EventContext, ReportFailure, TestStatus } from './protocol.js';
+import type { EventContext, ReportFailure, SelectionExclusions, TestGap, TestStatus } from './protocol.js';
 
 export type DesktopTestAttempt = {
   attempt: number;
   status: TestStatus;
   durationMs: number;
   reason?: string;
+  /** Present only on an `unsupported` attempt the producer declared in advance, never on a missing requirement. */
+  gap?: TestGap;
   failure?: ReportFailure;
   context?: EventContext;
 };
+/**
+ * The input lane a run was asked to execute. It records the request and how the host was masked; it never claims what
+ * input a session delivered or enforced, hence the literal `policyEnforced: false`.
+ */
+export const desktopInputLaneSources = ['option', 'environment', 'driver'] as const;
+/** `driver` means the lane was read from the attached driver instance's manifest instead of being requested here. */
+export type DesktopInputLaneSource = (typeof desktopInputLaneSources)[number];
+export type DesktopInputLaneReport =
+  | { input: 'accessible'; source: DesktopInputLaneSource; masking: 'host-masked' | 'verified-masked'; policyEnforced: false }
+  | { input: 'physical'; source: DesktopInputLaneSource; policyEnforced: false };
+export type DesktopSelectionReport = { excluded: SelectionExclusions };
 export type DesktopTestResult = {
   testId: string;
   title: string;
@@ -34,13 +47,22 @@ export type DesktopRunResult = {
   finishedAt: string;
   durationMs: number;
   context?: EventContext;
+  /** Set when the run executes one input lane. Lane runs treat undeclared skips and unsupported cases as non-success. */
+  lane?: DesktopInputLaneReport;
+  /** What producers removed from their selection before execution. Excluded cases are not tests. */
+  selection?: DesktopSelectionReport;
   counts: {
     selected: number;
     executed: number;
     passed: number;
     failed: number;
     skipped: number;
+    /** Every test whose final status is `unsupported`, declared or not. */
     unsupported: number;
+    /** The subset of `unsupported` that carries a declared `unsupported` gap. */
+    declaredUnsupported: number;
+    /** The subset of `unsupported` that carries a declared `quarantine` gap. */
+    quarantined: number;
     incomplete: number;
     retries: number;
     flaky: number;
@@ -59,6 +81,8 @@ export type DesktopRunSummary = {
   status: TestStatus;
   durationMs: number;
   context?: Pick<EventContext, 'endpoint' | 'renderer'>;
+  lane?: DesktopInputLaneReport;
+  excluded?: SelectionExclusions;
   counts: DesktopRunResult['counts'];
   problems: {
     kind: 'test' | 'infrastructure' | 'unfinished';
@@ -122,7 +146,7 @@ export function projectDesktopRunSummary(result: DesktopRunResult, root: string)
     ...new Set(
       result.tests.flatMap((test) =>
         test.attempts.flatMap((attempt) =>
-          attempt.reason && ['skipped', 'unsupported'].includes(attempt.status) ? [clipText(attempt.reason, 256)] : [],
+          attempt.reason && ['skipped', 'unsupported'].includes(attempt.status) ? [clipText(describeReason(attempt), 256)] : [],
         ),
       ),
     ),
@@ -152,6 +176,8 @@ export function projectDesktopRunSummary(result: DesktopRunResult, root: string)
         }
       : {}),
     counts: result.counts,
+    ...(result.lane ? { lane: result.lane } : {}),
+    ...(result.selection ? { excluded: result.selection.excluded } : {}),
     problems: problems.slice(0, SUMMARY_MAX_PROBLEMS),
     skippedReasons: skippedReasons.slice(0, SUMMARY_MAX_PROBLEMS),
     artifacts,
@@ -205,6 +231,8 @@ export function summarizeDesktopRun(
     failed: 0,
     skipped: 0,
     unsupported: 0,
+    declaredUnsupported: 0,
+    quarantined: 0,
     incomplete: 0,
     retries: 0,
     flaky: 0,
@@ -217,18 +245,26 @@ export function summarizeDesktopRun(
     else if (test.status === 'passed') counts.passed++;
     else if (test.status === 'failed') counts.failed++;
     else if (test.status === 'skipped') counts.skipped++;
-    else if (test.status === 'unsupported') counts.unsupported++;
+    else if (test.status === 'unsupported') {
+      counts.unsupported++;
+      const gap = test.attempts.at(-1)?.gap;
+      if (gap === 'unsupported') counts.declaredUnsupported++;
+      else if (gap === 'quarantine') counts.quarantined++;
+    }
   }
   const infrastructureFailed = input.failures.some(({ kind }) => kind !== 'test') || input.work.some(({ status }) => status === 'failed');
   const unfinishedWork = input.work.some(({ status }) => ['not-run', 'incomplete', 'cancelled'].includes(status));
   const noExecution = input.kind === 'tests' && counts.executed === 0;
+  // A lane run promised to execute its whole selection. Only a declared gap may leave a selected case unexecuted, and a
+  // run that executed nothing is never optional.
+  const laneUnmet = input.kind === 'tests' && input.lane !== undefined && counts.skipped + undeclaredUnsupported(counts) > 0;
   const status =
     infrastructureFailed || counts.failed > 0
       ? 'failed'
-      : input.incomplete || unfinishedWork || counts.incomplete > 0 || (input.kind === 'tests' && counts.selected === 0)
+      : input.incomplete || unfinishedWork || counts.incomplete > 0 || laneUnmet || (input.kind === 'tests' && counts.selected === 0)
         ? 'incomplete'
         : noExecution
-          ? input.optional
+          ? input.optional && input.lane === undefined
             ? 'skipped'
             : 'incomplete'
           : 'passed';
@@ -236,6 +272,46 @@ export function summarizeDesktopRun(
   return { ...result, status, counts };
 }
 
+/** Unsupported cases nothing declared in advance: a requirement the target did not meet. */
+function undeclaredUnsupported(counts: Pick<DesktopRunResult['counts'], 'unsupported' | 'declaredUnsupported' | 'quarantined'>): number {
+  return counts.unsupported - counts.declaredUnsupported - counts.quarantined;
+}
+
+const gapLabels = { unsupported: 'declared unsupported', quarantine: 'quarantined' } as const;
+
+/** A reason with its declared-gap label, so a declared gap never reads like a missing requirement. */
+function describeReason(attempt: Pick<DesktopTestAttempt, 'gap' | 'reason'>): string {
+  const reason = attempt.reason ?? '';
+  return attempt.gap ? `${gapLabels[attempt.gap]}: ${reason}` : reason;
+}
+
+/** `accessible (host-masked)`, `accessible (verified-masked)` or `physical pilot`; never a claim of enforced input. */
+export function describeDesktopInputLane(lane: DesktopInputLaneReport): string {
+  return lane.input === 'physical' ? 'physical pilot' : `accessible (${lane.masking})`;
+}
+
+function describeLaneSource(lane: DesktopInputLaneReport): string {
+  return lane.source === 'option' ? '--input' : lane.source === 'environment' ? 'DESKTOP_INPUT' : 'the driver instance';
+}
+
+/** One line naming the lane and what each producer excluded before execution, or `undefined` when neither applies. */
+export function describeDesktopSelection(result: Pick<DesktopRunResult, 'lane' | 'selection'>): string | undefined {
+  const parts: string[] = [];
+  if (result.lane) parts.push(`input ${describeDesktopInputLane(result.lane)} from ${describeLaneSource(result.lane)}`);
+  if (result.selection) {
+    const { platform, scope, input } = result.selection.excluded;
+    parts.push(`excluded ${platform} by platform, ${scope} by scope, ${input} by input`);
+  }
+  return parts.length ? parts.join('; ') : undefined;
+}
+
+/** The unsupported count with its declared and quarantined subsets, so undeclared gaps stand out. */
+export function describeDesktopUnsupported(
+  counts: Pick<DesktopRunResult['counts'], 'unsupported' | 'declaredUnsupported' | 'quarantined'>,
+): string {
+  return `${counts.unsupported} unsupported (${counts.declaredUnsupported} declared, ${counts.quarantined} quarantined)`;
+}
+
 export function desktopRunExitCode(result: DesktopRunResult): number {
   return result.status === 'passed' || result.status === 'skipped' ? 0 : 1;
 }
@@ -253,7 +329,7 @@ export function renderJUnit(result: DesktopRunResult): string {
         : test.status === 'passed'
           ? ''
           : ['skipped', 'unsupported'].includes(test.status)
-            ? `<skipped message="${xml(latest.reason ?? test.status)}"/>`
+            ? `<skipped message="${xml(latest.reason === undefined ? test.status : describeReason(latest))}"/>`
             : `<error type="${test.status}" message="${xml(latest.reason ?? 'Missing terminal test result')}"/>`;
     return `<testcase name="${xml(test.title)}" classname="${xml(test.testId)}" time="${latest.durationMs / 1000}">${body}<system-out>${xml(history)}</system-out></testcase>`;
   });
@@ -270,18 +346,34 @@ export function renderJUnit(result: DesktopRunResult): string {
     cases.push(
       '<testcase name="required cohort" classname="desktop.infrastructure"><error type="incomplete" message="No required tests executed or a producer did not finish."/></testcase>',
     );
-  return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuites><testsuite name="${xml(result.runId)}" tests="${cases.length}" failures="${result.counts.failed}" errors="${infrastructure.length + unfinishedWork.length + result.counts.incomplete + Number(incomplete)}" skipped="${result.counts.skipped + result.counts.unsupported}" time="${result.durationMs / 1000}">${cases.join('')}</testsuite></testsuites>\n`;
+  const properties: [string, string][] = [];
+  if (result.lane)
+    properties.push(
+      ['desktop.input', result.lane.input],
+      ['desktop.input.label', describeDesktopInputLane(result.lane)],
+      ['desktop.input.source', result.lane.source],
+    );
+  if (result.selection)
+    for (const [reason, count] of Object.entries(result.selection.excluded)) properties.push([`desktop.excluded.${reason}`, String(count)]);
+  if (result.counts.declaredUnsupported) properties.push(['desktop.declaredUnsupported', String(result.counts.declaredUnsupported)]);
+  if (result.counts.quarantined) properties.push(['desktop.quarantined', String(result.counts.quarantined)]);
+  const propertyXml = properties.length
+    ? `<properties>${properties.map(([name, value]) => `<property name="${xml(name)}" value="${xml(value)}"/>`).join('')}</properties>`
+    : '';
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuites><testsuite name="${xml(result.runId)}" tests="${cases.length}" failures="${result.counts.failed}" errors="${infrastructure.length + unfinishedWork.length + result.counts.incomplete + Number(incomplete)}" skipped="${result.counts.skipped + result.counts.unsupported}" time="${result.durationMs / 1000}">${propertyXml}${cases.join('')}</testsuite></testsuites>\n`;
 }
 
 export function renderRunSummary(result: DesktopRunResult): string {
   const c = result.counts;
   const reasons = [
-    ...new Set(result.tests.flatMap((test) => test.attempts.flatMap((attempt) => (attempt.reason ? [attempt.reason] : [])))),
+    ...new Set(result.tests.flatMap((test) => test.attempts.flatMap((attempt) => (attempt.reason ? [describeReason(attempt)] : [])))),
   ];
+  const selection = describeDesktopSelection(result);
   return (
     `## Desktop tests: ${result.status}\n\n` +
     `Run: \`${result.runId}\`; endpoint: ${result.context?.endpoint ?? 'native'}; renderer: ${result.context?.renderer ?? 'not applicable'}.\n\n` +
-    `Selected ${c.selected}; executed ${c.executed}; passed ${c.passed}; failed ${c.failed}; skipped ${c.skipped}; unsupported ${c.unsupported}; incomplete ${c.incomplete}; retries ${c.retries}; flaky ${c.flaky}.\n\n` +
+    (selection ? `Selection: ${selection}.\n\n` : '') +
+    `Selected ${c.selected}; executed ${c.executed}; passed ${c.passed}; failed ${c.failed}; skipped ${c.skipped}; ${describeDesktopUnsupported(c)}; incomplete ${c.incomplete}; retries ${c.retries}; flaky ${c.flaky}.\n\n` +
     `Selected groups ${result.work.length}; not run ${result.work.filter(({ status }) => status === 'not-run').length}; incomplete ${result.work.filter(({ status }) => status === 'incomplete').length}.\n\n` +
     `Infrastructure/evidence/cleanup failures: ${result.failures.filter(({ kind }) => kind !== 'test').length}.\n\n` +
     (reasons.length
diff --git a/packages/agentic/desktop-test/src/reporting/runQueries.test.ts b/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
index 75a352a566..b04dad2753 100644
--- a/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
@@ -332,6 +332,95 @@ describe('persisted desktop run queries', () => {
     await expect(client.query({ operation: 'status', runId: reporter.runId })).rejects.toThrow();
   });
 
+  describe('input lane runs', () => {
+    const lane = { input: 'accessible', source: 'environment', masking: 'verified-masked', policyEnforced: false } as const;
+    let laneReporter: DesktopRunReporter;
+    let laneClient: DesktopRunQueryClient;
+
+    beforeEach(async () => {
+      laneReporter = new DesktopRunReporter({
+        artifactsRoot: root,
+        output: { write: () => true },
+        reporterMode: 'json',
+        summary: false,
+        lane,
+      });
+      service.registerRun({ runId: laneReporter.runId, root: laneReporter.root, expiresAt: Date.now() + 60_000 });
+      laneClient = service.connect(service.issueGrant({ runIds: [laneReporter.runId], expiresAt: Date.now() + 60_000 }));
+      laneReporter.emit({ kind: 'selection', payload: { excluded: { platform: 1, scope: 2, input: 3 } } });
+      laneReporter.emit({ kind: 'test-result', payload: { testId: 'ok', title: 'ok', attempt: 0, status: 'passed', durationMs: 1 } });
+      laneReporter.emit({
+        kind: 'test-result',
+        payload: { testId: 'gap', title: 'gap', attempt: 0, status: 'unsupported', durationMs: 0, reason: 'Declared.', gap: 'quarantine' },
+      });
+      await laneReporter.finish();
+    });
+
+    function rewriteLane(change: (result: DesktopRunResult) => void): void {
+      const file = path.join(laneReporter.root, 'run.json');
+      const result = JSON.parse(fs.readFileSync(file, 'utf8')) as DesktopRunResult;
+      change(result);
+      fs.writeFileSync(file, JSON.stringify(result));
+    }
+
+    test('reads back the lane, the exclusions and each declared gap', async () => {
+      expect(await laneClient.query({ operation: 'status', runId: laneReporter.runId })).toMatchObject({
+        terminal: true,
+        status: 'passed',
+        lane,
+        excluded: { platform: 1, scope: 2, input: 3 },
+        counts: { unsupported: 1, quarantined: 1, declaredUnsupported: 0 },
+      });
+      expect(await laneClient.query({ operation: 'tests', runId: laneReporter.runId })).toMatchObject({
+        items: [
+          { title: 'ok', status: 'passed' },
+          { title: 'gap', status: 'unsupported', gap: 'quarantine', message: 'Declared.' },
+        ],
+      });
+    });
+
+    test('a declared gap edited out of the retained report no longer reads as a passing lane', async () => {
+      rewriteLane((result) => {
+        delete result.tests[1].attempts[0].gap;
+      });
+
+      expect(await laneClient.query({ operation: 'status', runId: laneReporter.runId })).toMatchObject({
+        status: 'incomplete',
+        counts: { unsupported: 1, quarantined: 0, declaredUnsupported: 0 },
+      });
+    });
+
+    test('reads a lane taken from the driver instance and rejects an unknown source', async () => {
+      rewriteLane((result) => {
+        Object.assign(result, { lane: { ...lane, source: 'driver' } });
+      });
+      expect(await laneClient.query({ operation: 'status', runId: laneReporter.runId })).toMatchObject({
+        lane: { ...lane, source: 'driver' },
+      });
+
+      rewriteLane((result) => {
+        Object.assign(result, { lane: { ...lane, source: 'cli' } });
+      });
+      await expect(laneClient.query({ operation: 'status', runId: laneReporter.runId })).rejects.toThrow();
+    });
+
+    test.each([
+      ['a lane that claims enforcement', (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, policyEnforced: true } })],
+      ['a physical lane with masking', (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, input: 'physical' } })],
+      [
+        'a negative exclusion count',
+        (result: DesktopRunResult) => Object.assign(result, { selection: { excluded: { platform: -1, scope: 0, input: 0 } } }),
+      ],
+      ['a gap on a passed attempt', (result: DesktopRunResult) => Object.assign(result.tests[0].attempts[0], { gap: 'unsupported' })],
+    ])('rejects %s in a retained report', async (_name, change) => {
+      rewriteLane((result) => {
+        change(result);
+      });
+
+      await expect(laneClient.query({ operation: 'status', runId: laneReporter.runId })).rejects.toThrow();
+    });
+  });
+
   test('snapshot persistence failures remain reporting failures after the writer recovers', async () => {
     const write = fs.writeFileSync;
     const injected = jest.spyOn(fs, 'writeFileSync').mockImplementation((file, ...args) => {
diff --git a/packages/agentic/desktop-test/src/reporting/runQueries.ts b/packages/agentic/desktop-test/src/reporting/runQueries.ts
index e75938f236..1f6843a2be 100644
--- a/packages/agentic/desktop-test/src/reporting/runQueries.ts
+++ b/packages/agentic/desktop-test/src/reporting/runQueries.ts
@@ -4,10 +4,10 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isNativeError } from 'node:util/types';
 
 import { desktopArtifactPath } from './collector.js';
-import { DesktopReportedError, reportStatuses, redactDesktopSecrets } from './protocol.js';
-import type { TestStatus } from './protocol.js';
-import { summarizeDesktopRun } from './results.js';
-import type { DesktopRunResult } from './results.js';
+import { DesktopReportedError, reportStatuses, redactDesktopSecrets, selectionExclusionReasons, testGaps } from './protocol.js';
+import type { SelectionExclusions, TestGap, TestStatus } from './protocol.js';
+import { desktopInputLaneSources, summarizeDesktopRun } from './results.js';
+import type { DesktopInputLaneReport, DesktopRunResult, DesktopSelectionReport } from './results.js';
 
 export type DesktopRunQuery =
   | { operation: 'status'; runId: string }
@@ -20,11 +20,15 @@ export type DesktopRunStatus = {
   terminal: boolean;
   status: TestStatus;
   counts: DesktopRunResult['counts'];
+  lane?: DesktopInputLaneReport;
+  excluded?: SelectionExclusions;
 };
 export type DesktopRunQueryItem = {
   id: string;
   title: string;
   status?: TestStatus;
+  /** Set on an `unsupported` test whose gap was declared in advance. */
+  gap?: TestGap;
   message?: string;
 };
 export type DesktopRunPage = {
@@ -176,7 +180,15 @@ export class DesktopRunQueryService {
     });
     if (result.status === 'failed') canonical.status = 'failed';
     if (input.operation === 'status')
-      return { schemaVersion: 1, runId: run.runId, terminal, status: canonical.status, counts: canonical.counts };
+      return {
+        schemaVersion: 1,
+        runId: run.runId,
+        terminal,
+        status: canonical.status,
+        counts: canonical.counts,
+        ...(canonical.lane ? { lane: canonical.lane } : {}),
+        ...(canonical.selection ? { excluded: canonical.selection.excluded } : {}),
+      };
     let offset = 0;
     if (input.cursor) {
       const cursor = grant.cursors.get(input.cursor);
@@ -225,6 +237,7 @@ export class DesktopRunQueryService {
         id: item.id,
         title: title.text,
         ...(item.status ? { status: item.status } : {}),
+        ...(item.gap ? { gap: item.gap } : {}),
         ...(message ? { message: message.text } : {}),
       },
       omitted: title.omitted + (message?.omitted ?? 0),
@@ -239,6 +252,7 @@ export class DesktopRunQueryService {
           id: id('test', test.testId),
           title: test.title,
           status: test.status,
+          ...(test.attempts.at(-1)?.gap ? { gap: test.attempts.at(-1)!.gap } : {}),
           message: test.attempts.at(-1)?.failure?.error.message ?? test.attempts.at(-1)?.reason,
         }));
       case 'work':
@@ -346,11 +360,15 @@ function parseResult(text: string, runId: string): DesktopRunResult & { terminal
         throw new TypeError('Invalid persisted desktop attempt duration.');
       const reason = attempt.reason;
       if (reason !== undefined) textField(reason);
+      const gap = attempt.gap;
+      if (gap !== undefined && (!testGaps.includes(gap as TestGap) || attempt.status !== 'unsupported'))
+        throw new TypeError('Invalid persisted desktop test gap.');
       return {
         attempt: attempt.attempt,
         durationMs: attempt.durationMs,
         status: attempt.status,
         ...(typeof reason === 'string' ? { reason } : {}),
+        ...(gap !== undefined ? { gap: gap as TestGap } : {}),
         ...(attempt.failure !== undefined ? { failure: new DesktopReportedError(attempt.failure).failure } : {}),
       };
     });
@@ -375,6 +393,8 @@ function parseResult(text: string, runId: string): DesktopRunResult & { terminal
   textField(value.finishedAt);
   if (typeof value.durationMs !== 'number' || !Number.isFinite(value.durationMs) || value.durationMs < 0)
     throw new TypeError('Invalid persisted desktop run duration.');
+  const lane = laneField(value.lane);
+  const selection = selectionField(value.selection);
   const result = summarizeDesktopRun({
     schemaVersion: 1,
     runId,
@@ -382,6 +402,8 @@ function parseResult(text: string, runId: string): DesktopRunResult & { terminal
     startedAt: value.startedAt,
     finishedAt: value.finishedAt,
     durationMs: value.durationMs,
+    ...(lane ? { lane } : {}),
+    ...(selection ? { selection } : {}),
     tests,
     work,
     failures,
@@ -390,6 +412,30 @@ function parseResult(text: string, runId: string): DesktopRunResult & { terminal
   return { ...result, status: value.status, ...(typeof value.terminal === 'boolean' ? { terminal: value.terminal } : {}) };
 }
 
+function laneField(value: unknown): DesktopInputLaneReport | undefined {
+  if (value === undefined) return undefined;
+  const lane = record(value);
+  const source = desktopInputLaneSources.find((candidate) => candidate === lane.source);
+  if (lane.policyEnforced !== false || source === undefined) throw new TypeError('Invalid persisted desktop input lane.');
+  if (lane.input === 'physical' && lane.masking === undefined) return { input: 'physical', source, policyEnforced: false };
+  if (lane.input === 'accessible' && (lane.masking === 'host-masked' || lane.masking === 'verified-masked'))
+    return { input: 'accessible', source, masking: lane.masking, policyEnforced: false };
+  throw new TypeError('Invalid persisted desktop input lane.');
+}
+
+function selectionField(value: unknown): DesktopSelectionReport | undefined {
+  if (value === undefined) return undefined;
+  const excluded = record(record(value).excluded);
+  const counts = {} as SelectionExclusions;
+  for (const reason of selectionExclusionReasons) {
+    const count = excluded[reason];
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+      throw new TypeError('Invalid persisted desktop exclusion count.');
+    counts[reason] = count;
+  }
+  return { excluded: counts };
+}
+
 function record(value: unknown): Record<string, unknown> {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('Expected a desktop run query object.');
   return value as Record<string, unknown>;
diff --git a/packages/agentic/desktop-test/src/reporting/structured.test.ts b/packages/agentic/desktop-test/src/reporting/structured.test.ts
index 1a7f5b1760..74a2c7f3d8 100644
--- a/packages/agentic/desktop-test/src/reporting/structured.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/structured.test.ts
@@ -20,6 +20,24 @@ describe('structured desktop events', () => {
     expect(includeDesktopEvent(event, 'milestones', 'service')).toBe(true);
   });
 
+  test('exclusion counts are progress detail and project as plain numbers', () => {
+    const event = makeEvent({ kind: 'selection', payload: { excluded: { platform: 1, scope: 0, input: 2 } } });
+
+    expect(includeDesktopEvent(event, 'milestones')).toBe(false);
+    expect(includeDesktopEvent(event, 'progress')).toBe(true);
+    expect(projectDesktopEvent(event).payload).toEqual({ excluded: { platform: 1, scope: 0, input: 2 } });
+  });
+
+  test('a declared gap stays visible at every level and projects with its reason', () => {
+    const event = makeEvent({
+      kind: 'test-result',
+      payload: { testId: 'test', title: 'gap', attempt: 0, status: 'unsupported', durationMs: 0, reason: 'Declared.', gap: 'quarantine' },
+    });
+
+    expect(includeDesktopEvent(event, 'milestones')).toBe(true);
+    expect(projectDesktopEvent(event).payload).toMatchObject({ status: 'unsupported', gap: 'quarantine', reason: 'Declared.' });
+  });
+
   test('projects and bounds large event text while retaining canonical IDs', () => {
     const event = makeEvent({
       kind: 'output',
diff --git a/packages/agentic/desktop-test/src/reporting/structured.ts b/packages/agentic/desktop-test/src/reporting/structured.ts
index 8e89133ea6..544be9ebc9 100644
--- a/packages/agentic/desktop-test/src/reporting/structured.ts
+++ b/packages/agentic/desktop-test/src/reporting/structured.ts
@@ -41,6 +41,7 @@ export function includeDesktopEvent(event: DesktopEvent, level: DesktopEventLeve
       return event.payload.status !== 'passed';
     case 'work-selected':
     case 'test-start':
+    case 'selection':
     case 'output':
       return false;
   }
@@ -88,8 +89,12 @@ export function projectDesktopEvent(event: CollectedDesktopEvent): DesktopEventR
       payload.status = event.payload.status;
       payload.durationMs = event.payload.durationMs;
       if (event.payload.reason) payload.reason = clip(event.payload.reason);
+      if (event.payload.gap) payload.gap = event.payload.gap;
       if (event.payload.failure) payload.failure = projectFailure(event.payload.failure);
       break;
+    case 'selection':
+      payload.excluded = { ...event.payload.excluded };
+      break;
     case 'artifact':
       payload.path = clip(event.payload.path);
       payload.description = clip(event.payload.description);
diff --git a/packages/agentic/desktop-test/src/supervisor.test.ts b/packages/agentic/desktop-test/src/supervisor.test.ts
new file mode 100644
index 0000000000..35ced5e4cf
--- /dev/null
+++ b/packages/agentic/desktop-test/src/supervisor.test.ts
@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { accessibleLaneMaskedFeatures } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
+import type { ResolvedDesktopTarget } from './config.js';
+import { startNativeDesktopService } from './driverService.js';
+import { DesktopRunReporter } from './reporting/collector.js';
+import { DesktopSupervisor } from './supervisor.js';
+
+jest.mock('./driverService', () => ({ startDesktopService: jest.fn(), startNativeDesktopService: jest.fn() }));
+jest.mock('./adapters', () => ({ resolveDesktopApplication: jest.fn(async () => ({ executablePath: 'Fixture.app' })) }));
+
+describe('desktop supervisor input lane', () => {
+  const platform = Object.getOwnPropertyDescriptor(process, 'platform')!;
+  const startNative = startNativeDesktopService as jest.MockedFunction<typeof startNativeDesktopService>;
+  let artifactsRoot: string;
+
+  beforeEach(() => {
+    artifactsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-desktop-supervisor-'));
+    // The helper is mocked, so any host can stand in for the macOS machine the endpoint requires.
+    Object.defineProperty(process, 'platform', { ...platform, value: 'darwin' });
+    startNative.mockReset();
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- the mocked service stands in for a loopback Desktop Driver
+    startNative.mockResolvedValue({ url: 'http://127.0.0.1:1', close: async () => undefined } as Awaited<
+      ReturnType<typeof startNativeDesktopService>
+    >);
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', platform);
+    fs.rmSync(artifactsRoot, { force: true, recursive: true });
+  });
+
+  async function nativeServiceOptions(input?: DesktopInputLane) {
+    const output = { write: () => true };
+    const reporter = new DesktopRunReporter({ artifactsRoot, errorOutput: output, output, reporterMode: 'plain', summary: false });
+    const target: ResolvedDesktopTarget = {
+      endpoint: 'macos',
+      id: 'fixture',
+      instanceId: 'fixture-1',
+      projectRoot: artifactsRoot,
+      configPath: path.join(artifactsRoot, 'desktop.config.mts'),
+      host: { kind: 'installed' },
+    };
+    const supervisor = new DesktopSupervisor({
+      target,
+      reporter,
+      reportSession: { reporter, delegated: true, environment: {}, close: async () => 0 },
+      ...(input ? { input } : {}),
+    });
+    try {
+      await supervisor.start();
+    } finally {
+      await supervisor.close();
+    }
+    expect(startNative).toHaveBeenCalledTimes(1);
+    return startNative.mock.calls[0][0];
+  }
+
+  test('starts the native host with physical input disabled for an accessible lane', async () => {
+    const options = await nativeServiceOptions('accessible');
+    expect(options.disabledInputFeatures).toEqual([...accessibleLaneMaskedFeatures]);
+  });
+
+  test.each([['physical' as const], [undefined]])('leaves the native host unmasked for %s', async (input) => {
+    const options = await nativeServiceOptions(input);
+    expect(options).not.toHaveProperty('disabledInputFeatures');
+  });
+});
diff --git a/packages/agentic/desktop-test/src/supervisor.ts b/packages/agentic/desktop-test/src/supervisor.ts
index 4249c82ea6..eeb3766491 100644
--- a/packages/agentic/desktop-test/src/supervisor.ts
+++ b/packages/agentic/desktop-test/src/supervisor.ts
@@ -4,6 +4,8 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 
 import type { DesktopDriverServer, DesktopHost } from '@fluentui-react-native/desktop-driver';
+import { accessibleLaneMaskedFeatures } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
 import type { DesktopAgentConnectionOptions } from './agentConnection.js';
 import { startDesktopService, startNativeDesktopService } from './driverService.js';
 import type { DesktopService, DesktopServiceOptions } from './driverService.js';
@@ -32,6 +34,11 @@ export type DesktopSupervisorOptions = {
    */
   agent?: DesktopAgentConnectionOptions;
   recovery?: DesktopServiceOptions['recovery'];
+  /**
+   * The input lane of a `test` run. An accessible lane starts the native host with keyboard, physical click and wheel
+   * disabled. A host supplied through `hostFactory` is not masked here, so the suite verifies it before running anything.
+   */
+  input?: DesktopInputLane;
 };
 
 export class DesktopSupervisor {
@@ -147,6 +154,7 @@ export class DesktopSupervisor {
     if (application.leaseNonce) this.reporter.addSecret(application.leaseNonce);
     return startNativeDesktopService({
       ...options,
+      ...(this.options.input === 'accessible' ? { disabledInputFeatures: accessibleLaneMaskedFeatures } : {}),
       application,
       nativeDriver: this.target.nativeDriver,
       endpoint: this.target.endpoint,
diff --git a/packages/agentic/desktop-test/src/wdio/configuration.ts b/packages/agentic/desktop-test/src/wdio/configuration.ts
index 506294ad4f..f16768c542 100644
--- a/packages/agentic/desktop-test/src/wdio/configuration.ts
+++ b/packages/agentic/desktop-test/src/wdio/configuration.ts
@@ -2,7 +2,11 @@ import { pathToFileURL } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { installDesktopWebdriverCommands } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopEndpoint, DesktopRenderer } from '@fluentui-react-native/desktop-driver';
+import { resolveDesktopClickMode } from '@fluentui-react-native/desktop-driver/authoring';
 import type { DesktopReadiness } from '../config.js';
+import { desktopJasmineRegistry } from '../jasmine/registry.js';
+import { desktopTestSelectionFromEnvironment } from '../jasmine/selection.js';
+import { currentDesktopJasmineEnvironment, selectDesktopSpecs } from '../jasmine/specSelection.js';
 import { connectReportProducer } from '../reporting/transport.js';
 import { DesktopReportedError, serializeReportError } from '../reporting/protocol.js';
 
@@ -56,6 +60,8 @@ export async function createDesktopWdioConfiguration(settings: DesktopWdioSettin
   }
   const address = new URL(settings.url);
   const readiness = settings.readiness;
+  // The launcher read the selection too, so a malformed one fails the run before any worker starts.
+  const selection = desktopTestSelectionFromEnvironment();
   const configuration = {
     ...hooks,
     runner: 'local',
@@ -88,7 +94,7 @@ export async function createDesktopWdioConfiguration(settings: DesktopWdioSettin
         platformName: settings.endpoint === 'macos' ? 'macos' : 'windows',
         'furn:target': settings.targetId,
         'furn:launchMode': settings.ownership === 'external' ? 'attach' : 'launch',
-        'furn:clickMode': 'auto',
+        'furn:clickMode': resolveDesktopClickMode(undefined, 'auto', selection?.lane),
       },
     ],
     beforeSession: async (...args: unknown[]) => {
@@ -97,6 +103,10 @@ export async function createDesktopWdioConfiguration(settings: DesktopWdioSettin
     },
     before: async (capabilities: unknown, specs: unknown, browser: WebdriverIO.Browser) => {
       installDesktopWebdriverCommands(browser, settings.url);
+      // Before the application is touched: a lane that cannot vouch for its tests must stop here.
+      if (settings.framework === 'jasmine') {
+        selectDesktopSpecs(desktopJasmineRegistry(), currentDesktopJasmineEnvironment(), browser.capabilities['furn:features']);
+      }
       if ((await browser.getWindowHandles()).length === 0) throw new Error('Native application did not expose a window.');
       if (readiness?.testId) {
         await browser.$(`~${readiness.testId}`).waitForDisplayed({
diff --git a/packages/agentic/desktop-test/src/wdio/reporter.ts b/packages/agentic/desktop-test/src/wdio/reporter.ts
index ab5b3df4e4..7379061b54 100644
--- a/packages/agentic/desktop-test/src/wdio/reporter.ts
+++ b/packages/agentic/desktop-test/src/wdio/reporter.ts
@@ -1,6 +1,8 @@
 import { createHash, randomUUID } from 'node:crypto';
 import WDIOReporter from '@wdio/reporter';
 import type { HookStats, RunnerStats, TestStats } from '@wdio/reporter';
+import { desktopJasmineRegistry, excludedSpecCounts } from '../jasmine/registry.js';
+import type { DesktopSpecEntry } from '../jasmine/registry.js';
 import { connectReportProducer } from '../reporting/transport.js';
 import type { ReportProducer } from '../reporting/transport.js';
 import { serializeReportError } from '../reporting/protocol.js';
@@ -71,6 +73,7 @@ export default class DesktopWdioReporter extends WDIOReporter {
   }
 
   override onTestStart(test: TestStats): void {
+    if (this.hidden(test)) return;
     this.report(
       { kind: 'test-start', payload: { testId: this.testId(test), title: test.fullTitle, attempt: this.attempt(test) } },
       { ...this.context, test: test.uid },
@@ -90,13 +93,29 @@ export default class DesktopWdioReporter extends WDIOReporter {
     this.testResult(test);
   }
 
+  /** The spec the Jasmine adapter registered for a test, when `desktopIt` declared it. */
+  private entry(test: TestStats): DesktopSpecEntry | undefined {
+    return desktopJasmineRegistry().entries.get(test.uid);
+  }
+
+  /** An excluded case is not a test, and a blocked run reports its fault rather than every spec it disabled. */
+  private hidden(test: TestStats): boolean {
+    return desktopJasmineRegistry().blocked || this.entry(test)?.kind === 'excluded';
+  }
+
   private testResult(test: TestStats): void {
+    if (this.hidden(test)) return;
     const testId = this.testId(test);
     const attempt = this.attempt(test);
     const key = `${testId}/${attempt}`;
     if (this.endedTests.has(key)) return;
     this.endedTests.add(key);
-    const status = test.state === 'pending' ? 'skipped' : test.state;
+    const entry = this.entry(test);
+    // A spec the adapter replaced or filtered out finishes as skipped or pending and never ran, whichever the framework calls it.
+    const notExecuted = test.state === 'pending' || test.state === 'skipped';
+    const gap = notExecuted && entry?.kind === 'gap' ? entry.gap : undefined;
+    const missing = notExecuted && entry?.kind === 'run' ? entry.missing : undefined;
+    const status = gap || missing?.length ? 'unsupported' : test.state === 'pending' ? 'skipped' : test.state;
     this.report(
       {
         kind: 'test-result',
@@ -106,6 +125,8 @@ export default class DesktopWdioReporter extends WDIOReporter {
           attempt,
           status,
           durationMs: test.duration,
+          ...(gap ? { gap: gap.kind, reason: gap.reason } : {}),
+          ...(missing?.length ? { reason: `Missing desktop requirements: ${missing.join(', ')}.` } : {}),
           ...(status === 'skipped' ? { reason: test.pendingReason || 'Skipped by the test framework.' } : {}),
           ...(status === 'failed'
             ? { failure: this.failure(`${key}/failure`, test.error ?? new AggregateError(test.errors ?? [], 'WDIO test failed.'), 'test') }
@@ -143,6 +164,11 @@ export default class DesktopWdioReporter extends WDIOReporter {
           failure: this.failure(`${this.scopeId}/runner`, new Error(runner.error), 'infrastructure'),
         },
       });
+    const excluded = excludedSpecCounts(desktopJasmineRegistry());
+    // Keyed by the spec group, so a retried attempt that announces the same exclusions again is counted once.
+    if (excluded.platform + excluded.scope + excluded.input > 0) {
+      this.report({ kind: 'selection', payload: { excluded, key: this.groupId } });
+    }
     this.report({ kind: 'scope-end', payload: { status: runner.failures || runner.error ? 'failed' : 'passed' } });
     this.schedule((producer) => producer.finish(runner.failures || runner.error ? 'failed' : 'passed'));
   }
diff --git a/packages/agentic/desktop-test/src/wdio/run.ts b/packages/agentic/desktop-test/src/wdio/run.ts
index c86eeb5efe..e9db1b7bbf 100644
--- a/packages/agentic/desktop-test/src/wdio/run.ts
+++ b/packages/agentic/desktop-test/src/wdio/run.ts
@@ -2,15 +2,32 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { resolve } from 'import-meta-resolve';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
 import type { ResolvedDesktopConfig, DesktopWdioSuite } from '../config.js';
-import { resolveDesktopSpecs } from '../config.js';
+import { resolveDesktopSpecs, resolveDesktopTestScope } from '../config.js';
+import { desktopTestSelectionEnvironment, serializeDesktopTestSelection } from '../jasmine/selection.js';
 import type { DesktopSupervisor } from '../supervisor.js';
 import type { DesktopWdioSettings } from './configuration.js';
 import { wdioGroupId } from './identity.js';
 
-export async function runDesktopWdioSuite(supervisor: DesktopSupervisor, config: ResolvedDesktopConfig, suiteName: string): Promise<void> {
+/** A lane selects tests through the Jasmine adapter, so a suite on another framework cannot honor one. */
+export function assertDesktopSuiteSupportsInput(suiteName: string, suite: DesktopWdioSuite, input: DesktopInputLane | undefined): void {
+  if (input && suite.framework !== 'jasmine') {
+    throw Object.assign(new TypeError(`--input ${input} requires a jasmine suite; "${suiteName}" uses ${suite.framework}.`), {
+      code: 'config',
+    });
+  }
+}
+
+export async function runDesktopWdioSuite(
+  supervisor: DesktopSupervisor,
+  config: ResolvedDesktopConfig,
+  suiteName: string,
+  input?: DesktopInputLane,
+): Promise<void> {
   const suite = config.config.suites?.[suiteName];
   if (!suite || suite.kind !== 'wdio') throw new Error(`No standalone WDIO suite "${suiteName}" is configured.`);
+  assertDesktopSuiteSupportsInput(suiteName, suite, input);
   const specs = resolveDesktopSpecs(suite, supervisor.target.endpoint, config.projectRoot);
   const workIds: string[] = [];
   for (const selected of specs) {
@@ -58,12 +75,19 @@ export async function runDesktopWdioSuite(supervisor: DesktopSupervisor, config:
     { mode: 0o600 },
   );
   const launcher = modulePath('@wdio/cli');
+  // The selection travels as data in the environment: a worker parses it, and nothing is spliced into code that runs.
+  const selection = serializeDesktopTestSelection({
+    endpoint: supervisor.target.endpoint,
+    ...(input ? { lane: input } : {}),
+    testScopes: config.config.testScopes,
+    values: resolveDesktopTestScope(config.testScopes, supervisor.target),
+  });
   await supervisor.worker(
     {
       command: process.execPath,
       args: [fileURLToPath(new URL('../../config/launcher.cjs', import.meta.url)), pathToFileURL(launcher).href, configPath],
       cwd: config.projectRoot,
-      env: { E2ETEST_PLATFORM: supervisor.target.endpoint, NATIVE_TESTING: 'false' },
+      env: { E2ETEST_PLATFORM: supervisor.target.endpoint, NATIVE_TESTING: 'false', [desktopTestSelectionEnvironment]: selection },
       label: `WDIO ${suiteName} (${supervisor.target.endpoint})`,
     },
     suiteDeadline(suite, specs.length),
diff --git a/packages/agentic/native-core/references/contributing.md b/packages/agentic/native-core/references/contributing.md
index abd2c0a237..f0e813a66a 100644
--- a/packages/agentic/native-core/references/contributing.md
+++ b/packages/agentic/native-core/references/contributing.md
@@ -55,6 +55,15 @@ full catalog before running the selected native tests.
 Add `--paper` to run the macOS Paper lane; a successful Paper build alone does
 not establish Paper runtime or input parity.
 
+Executable cases are declared with `desktopIt` and its `requires` list (see
+`@fluentui-react-native/storybook-desktop/references/story-tests.md`), not with run-time
+`skip` guards. Cases that click or type declare `physical-click` and `keyboard`, which
+derive the `physical` input lane; `focus` only asks the host to report focus support.
+Only the placement cases declare no requirement and run in both lanes. The Win32
+Tab-exit behavior (#4377) is a declared `unsupported` gap, not a skip. Add
+`--input accessible` or `--input physical` to select a lane: `accessible` selects only
+the placement cases, and `physical` selects every case.
+
 ## Apple boundary probe
 
 After building macOS Storybook, run the reproducible Apple boundary probe:
diff --git a/packages/agentic/native-core/src/components/callout/Callout.stories.tsx b/packages/agentic/native-core/src/components/callout/Callout.stories.tsx
index 2056a387f9..4010ef6020 100644
--- a/packages/agentic/native-core/src/components/callout/Callout.stories.tsx
+++ b/packages/agentic/native-core/src/components/callout/Callout.stories.tsx
@@ -4,6 +4,7 @@ import { Pressable, Text, View, StyleSheet } from 'react-native';
 import type { Meta, StoryObj } from '@storybook/react-native';
 import { useFocusablePressable } from '@fluentui-react-native/framework-base';
 import type { PointerFocusMode } from '@fluentui-react-native/framework-base';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Callout } from './Callout';
@@ -344,83 +345,78 @@ export default meta;
 type Story = WdioStory<StoryObj<ExampleProps>>;
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: {
-    'light-dismisses on an outside owner click and explicitly rearms': async ({ browser, expect, platform, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Light dismissal requires physical owner input.');
-        return;
-      }
-      const status = await browser.$('~modern-callout-status');
-      const dismissal = await browser.$('~modern-callout-dismissal');
-      // The App SDK notification itself has no cause; its unclassified path can win the outside-pointer race.
-      const expected = platform === 'windows' ? /^Dismissed: (outside-pointer|native-light-dismiss)$/ : 'Dismissed: outside-pointer';
-      for (let attempt = 0; attempt < 2; attempt++) {
+  wdio: [
+    desktopIt(
+      'light-dismisses on an outside owner click and explicitly rearms',
+      { requires: ['physical-click'] },
+      async ({ browser, expect, platform }) => {
+        const status = await browser.$('~modern-callout-status');
+        const dismissal = await browser.$('~modern-callout-dismissal');
+        // The App SDK notification itself has no cause; its unclassified path can win the outside-pointer race.
+        const expected = platform === 'windows' ? /^Dismissed: (outside-pointer|native-light-dismiss)$/ : 'Dismissed: outside-pointer';
+        for (let attempt = 0; attempt < 2; attempt++) {
+          await expect(status).toHaveText('Ready');
+          await expect(dismissal).toHaveText('Open');
+          await status.click();
+          await expect(dismissal).toHaveText(expected);
+          // A latched presentation must not reopen merely because open remains true; readiness would reset the label.
+          await browser.pause(500);
+          await expect(dismissal).toHaveText(expected);
+          await (await browser.$('~modern-callout-reopen')).click();
+        }
         await expect(status).toHaveText('Ready');
         await expect(dismissal).toHaveText('Open');
-        await status.click();
-        await expect(dismissal).toHaveText(expected);
-        // A latched presentation must not reopen merely because open remains true; readiness would reset the label.
+      },
+    ),
+    desktopIt(
+      'keeps the presentation open for pointer input on its view anchor',
+      { requires: ['physical-click'] },
+      async ({ browser, expect, platform }) => {
+        await expect(await browser.$('~modern-callout-status')).toHaveText('Ready');
+        const dismissal = await browser.$('~modern-callout-dismissal');
+        await expect(dismissal).toHaveText('Open');
+        await (await browser.$('~modern-callout-anchor')).click();
         await browser.pause(500);
-        await expect(dismissal).toHaveText(expected);
-        await (await browser.$('~modern-callout-reopen')).click();
-      }
-      await expect(status).toHaveText('Ready');
-      await expect(dismissal).toHaveText('Open');
-    },
-    'keeps the presentation open for pointer input on its view anchor': async ({ browser, expect, platform, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Anchor input requires physical owner input.');
-        return;
-      }
-      await expect(await browser.$('~modern-callout-status')).toHaveText('Ready');
-      const dismissal = await browser.$('~modern-callout-dismissal');
-      await expect(dismissal).toHaveText('Open');
-      await (await browser.$('~modern-callout-anchor')).click();
-      await browser.pause(500);
-      await expect(dismissal).toHaveText('Open');
-      await (await browser.$('~modern-callout-status')).click();
-      await expect(dismissal).toHaveText(
-        platform === 'windows' ? /^Dismissed: (outside-pointer|native-light-dismiss)$/ : 'Dismissed: outside-pointer',
-      );
-    },
-    'places content below the view anchor with the requested gap': async (context) => {
+        await expect(dismissal).toHaveText('Open');
+        await (await browser.$('~modern-callout-status')).click();
+        await expect(dismissal).toHaveText(
+          platform === 'windows' ? /^Dismissed: (outside-pointer|native-light-dismiss)$/ : 'Dismissed: outside-pointer',
+        );
+      },
+    ),
+    desktopIt('places content below the view anchor with the requested gap', async (context) => {
       const { expectCalloutPlacement } = await import('./placement.wdio.ts');
       await expectCalloutPlacement(context);
-    },
-  },
+    }),
+  ],
 };
 export const NativeOperations: Story = {
   args: { exercise: 'commands' },
   tags: ['desktop-e2e'],
-  wdio: {
-    'readies, confirms descendant focus, closes, and explicitly rearms': async ({ browser, expect, platform, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Physical owner input unavailable.');
-        return;
-      }
-      const status = await browser.$('~modern-callout-status');
-      const operations = await browser.$('~modern-callout-operations');
-      await expect(status).toHaveText('Ready');
-      for (let attempt = 0; attempt < 2; attempt++) {
-        await (await browser.$('~modern-callout-reopen')).click();
-        await expect(operations).toHaveText('confirmed/confirmed/confirmed');
-        await expect(await browser.$('~modern-callout-dismissal')).toHaveText('Dismissed: programmatic');
-        await expect(await browser.$('~modern-callout-focus-status')).toHaveText('Child focused');
-        // Windows popups are owned tool windows that the driver does not enumerate as top-level windows.
-        if (platform === 'macos') await browser.waitUntil(async () => (await browser.getWindowHandles()).length === 1, { timeout: 5000 });
-      }
-    },
-  },
+  wdio: [
+    desktopIt(
+      'readies, confirms descendant focus, closes, and explicitly rearms',
+      { requires: ['physical-click'] },
+      async ({ browser, expect, platform }) => {
+        const status = await browser.$('~modern-callout-status');
+        const operations = await browser.$('~modern-callout-operations');
+        await expect(status).toHaveText('Ready');
+        for (let attempt = 0; attempt < 2; attempt++) {
+          await (await browser.$('~modern-callout-reopen')).click();
+          await expect(operations).toHaveText('confirmed/confirmed/confirmed');
+          await expect(await browser.$('~modern-callout-dismissal')).toHaveText('Dismissed: programmatic');
+          await expect(await browser.$('~modern-callout-focus-status')).toHaveText('Child focused');
+          // Windows popups are owned tool windows that the driver does not enumerate as top-level windows.
+          if (platform === 'macos') await browser.waitUntil(async () => (await browser.getWindowHandles()).length === 1, { timeout: 5000 });
+        }
+      },
+    ),
+  ],
 };
 export const KeyboardDismissal: Story = {
   args: { exercise: 'focus' },
-  wdio: {
-    'dismisses focused content on Escape': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features?.physicalClick || !features.keyboard) {
-        skip('Escape dismissal requires physical owner and keyboard input.');
-        return;
-      }
+  wdio: [
+    desktopIt('dismisses focused content on Escape', { requires: ['physical-click', 'keyboard'] }, async ({ browser, expect }) => {
       const status = await browser.$('~modern-callout-status');
       await expect(status).toHaveText('Ready');
       await (await browser.$('~modern-callout-reopen')).click();
@@ -430,195 +426,186 @@ export const KeyboardDismissal: Story = {
       await expect(dismissal).toHaveText('Open');
       await browser.keys('\uE00C');
       await expect(dismissal).toHaveText('Dismissed: escape');
-    },
-  },
+    }),
+  ],
 };
 export const FirstFocusable: Story = {
   render: () => <EntryFocusExample strategy="first" />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'confirms the first eligible content without a FocusZone': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Entry focus requires physical owner activation.');
-        return;
-      }
+  wdio: [
+    desktopIt('confirms the first eligible content without a FocusZone', { requires: ['physical-click'] }, async ({ browser, expect }) => {
       await (await browser.$('~entry-callout-open')).click();
       await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
       await expect(await browser.$('~entry-callout-focused')).toHaveText('First');
-    },
-  },
+    }),
+  ],
 };
 export const LastFocusable: Story = {
   render: () => <EntryFocusExample strategy="last" />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'confirms the last eligible nested content without a FocusZone': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Entry focus requires physical owner activation.');
-        return;
-      }
-      await (await browser.$('~entry-callout-open')).click();
-      await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
-      await expect(await browser.$('~entry-callout-focused')).toHaveText('Last');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'confirms the last eligible nested content without a FocusZone',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        await (await browser.$('~entry-callout-open')).click();
+        await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
+        await expect(await browser.$('~entry-callout-focused')).toHaveText('Last');
+      },
+    ),
+  ],
 };
 export const EmptyFocus: Story = {
   render: () => <EntryFocusExample strategy="first" empty />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'reports missing eligible content instead of manufacturing focus confirmation': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Entry focus requires physical owner activation.');
-        return;
-      }
-      await (await browser.$('~entry-callout-open')).click();
-      await expect(await browser.$('~entry-callout-status')).toHaveText('not-mounted');
-      await expect(await browser.$('~entry-callout-focused')).toHaveText('None');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'reports missing eligible content instead of manufacturing focus confirmation',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        await (await browser.$('~entry-callout-open')).click();
+        await expect(await browser.$('~entry-callout-status')).toHaveText('not-mounted');
+        await expect(await browser.$('~entry-callout-focused')).toHaveText('None');
+      },
+    ),
+  ],
 };
 export const ContainerFocus: Story = {
   render: () => <EntryFocusExample strategy="first" empty container />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'confirms an explicitly focusable empty content container': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Container focus requires physical owner activation.');
-        return;
-      }
+  wdio: [
+    desktopIt('confirms an explicitly focusable empty content container', { requires: ['physical-click'] }, async ({ browser, expect }) => {
       await (await browser.$('~entry-callout-open')).click();
       await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
       await expect(await browser.$('~entry-callout-focused')).toHaveText('Container');
-    },
-  },
+    }),
+  ],
 };
 export const DeferredContainerFocus: Story = {
   render: () => <EntryFocusExample strategy="first" empty container="deferred" />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'orders a focus request after the content update committed before it': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Container focus requires physical owner activation.');
-        return;
-      }
-      await (await browser.$('~entry-callout-open')).click();
-      await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
-      await expect(await browser.$('~entry-callout-focused')).toHaveText('Container');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'orders a focus request after the content update committed before it',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        await (await browser.$('~entry-callout-open')).click();
+        await expect(await browser.$('~entry-callout-status')).toHaveText('confirmed');
+        await expect(await browser.$('~entry-callout-focused')).toHaveText('Container');
+      },
+    ),
+  ],
 };
 export const LocalRectangle: Story = {
   args: { anchorKind: 'rect' },
-  wdio: {
-    'places content below the local rectangle with the requested gap': async (context) => {
+  wdio: [
+    desktopIt('places content below the local rectangle with the requested gap', async (context) => {
       const { expectCalloutPlacement } = await import('./placement.wdio.ts');
       await expectCalloutPlacement(context, { x: 40, y: 30, height: 30 });
-    },
-  },
+    }),
+  ],
 };
 export const LocalPoint: Story = {
   args: { anchorKind: 'point' },
-  wdio: {
-    'places content below the local point with the requested gap': async (context) => {
+  wdio: [
+    desktopIt('places content below the local point with the requested gap', async (context) => {
       const { expectCalloutPlacement } = await import('./placement.wdio.ts');
       await expectCalloutPlacement(context, { x: 40, y: 60, height: 0 });
-    },
-  },
+    }),
+  ],
 };
 export const MenuComposition: Story = {
   render: ({ pointerFocus }) => <MenuCompositionExample pointerFocus={pointerFocus} />,
   args: { pointerFocus: 'platform' },
   argTypes: { pointerFocus: { control: 'select', options: ['platform', 'always', 'never'] } },
   tags: ['desktop-e2e'],
-  wdio: {
-    'enters a FocusZone, navigates by arrow, and follows the platform focus convention on Escape': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      const { exerciseMenuComposition } = await import('./menuComposition.wdio.ts');
-      // Windows and Win32 focus a pressed trigger, so closing the menu restores it. AppKit leaves keyboard focus where
-      // it was on click, so macOS restores the owner window's previous first responder instead.
-      await exerciseMenuComposition({ browser, expect, skip }, { restoresTrigger: platform !== 'macos' });
-    },
-  },
+  wdio: [
+    desktopIt(
+      'enters a FocusZone, navigates by arrow, and follows the platform focus convention on Escape',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async ({ browser, expect, platform }) => {
+        const { exerciseMenuComposition } = await import('./menuComposition.wdio.ts');
+        // Windows and Win32 focus a pressed trigger, so closing the menu restores it. AppKit leaves keyboard focus where
+        // it was on click, so macOS restores the owner window's previous first responder instead.
+        await exerciseMenuComposition({ browser, expect }, { restoresTrigger: platform !== 'macos' });
+      },
+    ),
+  ],
 };
 export const TabContinuation: Story = {
   render: () => <MenuCompositionExample pointerFocus="always" tabNavigation="continue" />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'closes on Tab and continues past the anchor, and on Shift+Tab returns to it': async ({ browser, expect, platform, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (platform === 'win32') {
-        skip('Win32 hosts keep the cycle behavior (#4377).');
-        return;
-      }
-      if (!features?.physicalClick || !features.keyboard || !features.focus) {
-        skip('Tab exit requires physical owner input, keyboard input, and focus observation.');
-        return;
-      }
-      const trigger = await browser.$('~modern-menu-trigger');
-      const status = await browser.$('~modern-menu-status');
-      await trigger.click();
-      await expect(status).toHaveText('Ready: confirmed');
-      await browser.keys('\uE004');
-      await expect(status).toHaveText('Dismissed: tab-forward');
-      await browser.waitUntil(async () => (await (await browser.$('~modern-menu-after')).getProperty('focused')) === true, {
-        timeout: 5000,
-        timeoutMsg: 'Expected Tab to continue to the view after the anchor.',
-      });
-      await trigger.click();
-      await expect(status).toHaveText('Ready: confirmed');
-      await browser.keys(['\uE008', '\uE004']);
-      await expect(status).toHaveText('Dismissed: tab-backward');
-      await browser.waitUntil(async () => (await trigger.getProperty('focused')) === true, {
-        timeout: 5000,
-        timeoutMsg: 'Expected Shift+Tab to focus the anchor.',
-      });
-    },
-  },
+  wdio: [
+    desktopIt(
+      'closes on Tab and continues past the anchor, and on Shift+Tab returns to it',
+      {
+        requires: ['physical-click', 'keyboard', 'focus'],
+        unsupported: { platforms: ['win32'], reason: 'Win32 hosts keep the cycle behavior.', issue: '#4377' },
+      },
+      async ({ browser, expect }) => {
+        const trigger = await browser.$('~modern-menu-trigger');
+        const status = await browser.$('~modern-menu-status');
+        await trigger.click();
+        await expect(status).toHaveText('Ready: confirmed');
+        await browser.keys('\uE004');
+        await expect(status).toHaveText('Dismissed: tab-forward');
+        await browser.waitUntil(async () => (await (await browser.$('~modern-menu-after')).getProperty('focused')) === true, {
+          timeout: 5000,
+          timeoutMsg: 'Expected Tab to continue to the view after the anchor.',
+        });
+        await trigger.click();
+        await expect(status).toHaveText('Ready: confirmed');
+        await browser.keys(['\uE008', '\uE004']);
+        await expect(status).toHaveText('Dismissed: tab-backward');
+        await browser.waitUntil(async () => (await trigger.getProperty('focused')) === true, {
+          timeout: 5000,
+          timeoutMsg: 'Expected Shift+Tab to focus the anchor.',
+        });
+      },
+    ),
+  ],
 };
 export const TabDismissal: Story = {
   render: () => <MenuCompositionExample pointerFocus="always" tabNavigation="dismiss" />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'closes on Tab and leaves the owner window its retained focus': async ({ browser, expect, platform, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (platform === 'win32') {
-        skip('Win32 hosts keep the cycle behavior (#4377).');
-        return;
-      }
-      if (!features?.physicalClick || !features.keyboard || !features.focus) {
-        skip('Tab exit requires physical owner input, keyboard input, and focus observation.');
-        return;
-      }
-      const trigger = await browser.$('~modern-menu-trigger');
-      const status = await browser.$('~modern-menu-status');
-      await trigger.click();
-      await expect(status).toHaveText('Ready: confirmed');
-      await browser.keys('\uE004');
-      await expect(status).toHaveText('Dismissed: tab-forward');
-      await browser.waitUntil(async () => (await trigger.getProperty('focused')) === true, {
-        timeout: 5000,
-        timeoutMsg: 'Expected the owner window to keep the focused trigger.',
-      });
-      expect(await (await browser.$('~modern-menu-after')).getProperty('focused')).toBe(false);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'closes on Tab and leaves the owner window its retained focus',
+      {
+        requires: ['physical-click', 'keyboard', 'focus'],
+        unsupported: { platforms: ['win32'], reason: 'Win32 hosts keep the cycle behavior.', issue: '#4377' },
+      },
+      async ({ browser, expect }) => {
+        const trigger = await browser.$('~modern-menu-trigger');
+        const status = await browser.$('~modern-menu-status');
+        await trigger.click();
+        await expect(status).toHaveText('Ready: confirmed');
+        await browser.keys('\uE004');
+        await expect(status).toHaveText('Dismissed: tab-forward');
+        await browser.waitUntil(async () => (await trigger.getProperty('focused')) === true, {
+          timeout: 5000,
+          timeoutMsg: 'Expected the owner window to keep the focused trigger.',
+        });
+        expect(await (await browser.$('~modern-menu-after')).getProperty('focused')).toBe(false);
+      },
+    ),
+  ],
 };
 export const MenuCompositionFocusingTrigger: Story = {
   render: ({ pointerFocus }) => <MenuCompositionExample pointerFocus={pointerFocus} />,
   args: { pointerFocus: 'always' },
   argTypes: MenuComposition.argTypes,
   tags: ['desktop-e2e'],
-  wdio: {
-    'restores keyboard focus to a trigger focused on press': async ({ browser, expect, skip }) => {
-      const { exerciseMenuComposition } = await import('./menuComposition.wdio.ts');
-      await exerciseMenuComposition({ browser, expect, skip }, { restoresTrigger: true });
-    },
-  },
+  wdio: [
+    desktopIt(
+      'restores keyboard focus to a trigger focused on press',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async ({ browser, expect }) => {
+        const { exerciseMenuComposition } = await import('./menuComposition.wdio.ts');
+        await exerciseMenuComposition({ browser, expect }, { restoresTrigger: true });
+      },
+    ),
+  ],
 };
 const styles = StyleSheet.create({
   story: { padding: 24, gap: 16 },
diff --git a/packages/agentic/native-core/src/components/callout/menuComposition.wdio.ts b/packages/agentic/native-core/src/components/callout/menuComposition.wdio.ts
index ecf57e52c0..38f8554eea 100644
--- a/packages/agentic/native-core/src/components/callout/menuComposition.wdio.ts
+++ b/packages/agentic/native-core/src/components/callout/menuComposition.wdio.ts
@@ -2,18 +2,14 @@ import type { WdioStoryContext } from '@fluentui-react-native/storybook-desktop/
 
 /**
  * Opens the menu by pointer, enters its FocusZone, navigates by arrow with wrapping, and closes it with Escape, twice.
- * `restoresTrigger` states whether the pressed trigger took keyboard focus, which decides whether the owner window
- * returns focus to it when the menu closes.
+ * The calling case declares the physical click, keyboard and focus observation it needs. `restoresTrigger` states
+ * whether the pressed trigger took keyboard focus, which decides whether the owner window returns focus to it when the
+ * menu closes.
  */
 export async function exerciseMenuComposition(
-  { browser, expect, skip }: Pick<WdioStoryContext, 'browser' | 'expect' | 'skip'>,
+  { browser, expect }: Pick<WdioStoryContext, 'browser' | 'expect'>,
   { restoresTrigger }: { restoresTrigger: boolean },
 ): Promise<void> {
-  const features = browser.capabilities['furn:features'];
-  if (!features?.physicalClick || !features.keyboard || !features.focus) {
-    skip('Menu composition requires physical owner input, keyboard input, and focus observation.');
-    return;
-  }
   const trigger = await browser.$('~modern-menu-trigger');
   const status = await browser.$('~modern-menu-status');
   const focused = await browser.$('~modern-menu-focus');
diff --git a/packages/agentic/native-core/src/components/focus-zone/FocusZone.stories.tsx b/packages/agentic/native-core/src/components/focus-zone/FocusZone.stories.tsx
index 9614a69b70..b9fd07ca76 100644
--- a/packages/agentic/native-core/src/components/focus-zone/FocusZone.stories.tsx
+++ b/packages/agentic/native-core/src/components/focus-zone/FocusZone.stories.tsx
@@ -2,6 +2,7 @@
 import * as React from 'react';
 import { Pressable, Text, View, StyleSheet } from 'react-native';
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { FocusZone } from './FocusZone';
@@ -150,71 +151,63 @@ export default meta;
 type Story = WdioStory<StoryObj<typeof FocusZone>>;
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: {
-    'confirms native default, edge, and specific descendant requests': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Native commands require physical input for their owner controls.');
-        return;
-      }
-      for (const [strategy, item] of [
-        ['default', 2],
-        ['first', 1],
-        ['last', 3],
-        ['default', 2],
-        ['target', 2],
-        ['first', 1],
-      ] as const) {
-        await (await browser.$(`~modern-focus-request-${strategy}`)).click();
-        await expect(await browser.$('~modern-focus-status')).toHaveText('confirmed');
-        await browser.waitUntil(async () => (await (await browser.$(`~modern-focus-item-${item}`)).getProperty('focused')) === true, {
-          timeout: 5000,
-          timeoutMsg: `Expected actual focus on item ${item}.`,
-        });
-      }
-    },
-  },
+  wdio: [
+    desktopIt(
+      'confirms native default, edge, and specific descendant requests',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        for (const [strategy, item] of [
+          ['default', 2],
+          ['first', 1],
+          ['last', 3],
+          ['default', 2],
+          ['target', 2],
+          ['first', 1],
+        ] as const) {
+          await (await browser.$(`~modern-focus-request-${strategy}`)).click();
+          await expect(await browser.$('~modern-focus-status')).toHaveText('confirmed');
+          await browser.waitUntil(async () => (await (await browser.$(`~modern-focus-item-${item}`)).getProperty('focused')) === true, {
+            timeout: 5000,
+            timeoutMsg: `Expected actual focus on item ${item}.`,
+          });
+        }
+      },
+    ),
+  ],
 };
 export const Disabled: Story = {
   args: { disabled: true },
-  wdio: {
-    'refuses a disabled-zone request': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Physical input unavailable.');
-        return;
-      }
+  wdio: [
+    desktopIt('refuses a disabled-zone request', { requires: ['physical-click'] }, async ({ browser, expect }) => {
       await (await browser.$('~modern-focus-request-first')).click();
       await expect(await browser.$('~modern-focus-status')).toHaveText('not-focusable');
-    },
-  },
+    }),
+  ],
 };
 export const TargetLifetimes: Story = {
   render: () => <TargetLifetimesExample />,
-  wdio: {
-    'rejects unfocusable and outside live targets': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Physical input unavailable.');
-        return;
-      }
+  wdio: [
+    desktopIt('rejects unfocusable and outside live targets', { requires: ['physical-click'] }, async ({ browser, expect }) => {
       await (await browser.$('~modern-focus-request-unfocusable')).click();
       await expect(await browser.$('~modern-focus-status')).toHaveText('not-focusable');
       await (await browser.$('~modern-focus-request-outside')).click();
       await expect(await browser.$('~modern-focus-status')).toHaveText('not-mounted');
       expect(await (await browser.$('~modern-focus-outside')).getProperty('focused')).toBe(false);
-    },
-    'cancels pre-aborted requests and invalidates detached commands': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Physical input unavailable.');
-        return;
-      }
-      await (await browser.$('~modern-focus-request-cancelled')).click();
-      await expect(await browser.$('~modern-focus-status')).toHaveText('cancelled');
-      expect(await (await browser.$('~modern-focus-item-1')).getProperty('focused')).toBe(false);
-      await (await browser.$('~modern-focus-unmount')).click();
-      await expect(await browser.$('~modern-focus-zone')).not.toExist();
-      await (await browser.$('~modern-focus-request-detached')).click();
-      await expect(await browser.$('~modern-focus-status')).toHaveText('not-mounted');
-    },
-  },
+    }),
+    desktopIt(
+      'cancels pre-aborted requests and invalidates detached commands',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        await (await browser.$('~modern-focus-request-cancelled')).click();
+        await expect(await browser.$('~modern-focus-status')).toHaveText('cancelled');
+        expect(await (await browser.$('~modern-focus-item-1')).getProperty('focused')).toBe(false);
+        await (await browser.$('~modern-focus-unmount')).click();
+        await expect(await browser.$('~modern-focus-zone')).not.toExist();
+        await (await browser.$('~modern-focus-request-detached')).click();
+        await expect(await browser.$('~modern-focus-status')).toHaveText('not-mounted');
+      },
+    ),
+  ],
 };
 const styles = StyleSheet.create({
   story: { padding: 24, gap: 16 },
diff --git a/packages/agentic/native-core/src/legacy/callout/Callout.stories.tsx b/packages/agentic/native-core/src/legacy/callout/Callout.stories.tsx
index 2a4d0b6e8b..864f43add9 100644
--- a/packages/agentic/native-core/src/legacy/callout/Callout.stories.tsx
+++ b/packages/agentic/native-core/src/legacy/callout/Callout.stories.tsx
@@ -2,6 +2,7 @@
 import * as React from 'react';
 import { Pressable, StyleSheet, Text, View } from 'react-native';
 
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 import type { Meta, StoryObj } from '@storybook/react-native';
 
@@ -185,32 +186,31 @@ type Story = WdioStory<StoryObj<typeof Callout>>;
 export const Default: Story = {
   tags: ['desktop-e2e'],
   render: (args) => <CalloutExample {...args} defaultVisible />,
-  wdio: {
-    'opens, light-dismisses, and recreates a native popup': async ({ browser, expect, platform, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features?.physicalClick) {
-        skip('Popup lifecycle qualification requires physical pointer input.');
-        return;
-      }
-      const status = await browser.$('~agentic-storybook-callout-status');
-      for (let attempt = 0; attempt < 2; attempt++) {
-        await expect(status).toHaveText('Native window: Shown');
-        // Only the AppKit provider enumerates the popup as a top-level window.
-        if (platform === 'macos') expect(await browser.getWindowHandles()).toHaveLength(2);
-        await status.click();
-        if (platform === 'macos') {
-          await browser.waitUntil(async () => (await browser.getWindowHandles()).length === 1, {
-            timeout: 5000,
-            timeoutMsg: 'Expected dismissal to remove the native Callout window.',
-          });
-        }
-        await expect(status).toHaveText('Native window: Dismissed');
-        if (attempt === 0) {
-          await (await browser.$('~agentic-storybook-callout-trigger')).click();
+  wdio: [
+    desktopIt(
+      'opens, light-dismisses, and recreates a native popup',
+      { requires: ['physical-click'] },
+      async ({ browser, expect, platform }) => {
+        const status = await browser.$('~agentic-storybook-callout-status');
+        for (let attempt = 0; attempt < 2; attempt++) {
+          await expect(status).toHaveText('Native window: Shown');
+          // Only the AppKit provider enumerates the popup as a top-level window.
+          if (platform === 'macos') expect(await browser.getWindowHandles()).toHaveLength(2);
+          await status.click();
+          if (platform === 'macos') {
+            await browser.waitUntil(async () => (await browser.getWindowHandles()).length === 1, {
+              timeout: 5000,
+              timeoutMsg: 'Expected dismissal to remove the native Callout window.',
+            });
+          }
+          await expect(status).toHaveText('Native window: Dismissed');
+          if (attempt === 0) {
+            await (await browser.$('~agentic-storybook-callout-trigger')).click();
+          }
         }
-      }
-    },
-  },
+      },
+    ),
+  ],
 };
 
 export const Placement: Story = {
@@ -230,19 +230,18 @@ export const WindowCommands: Story = {
   },
   render: (args) => <CalloutExample {...args} defaultVisible showWindowCommands />,
   tags: ['desktop-e2e'],
-  wdio: {
-    'dismisses initially focused content on Escape': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features?.physicalClick || !features.keyboard) {
-        skip('Escape dismissal requires an interactive desktop with keyboard input.');
-        return;
-      }
-      const status = await browser.$('~agentic-storybook-callout-status');
-      await expect(status).toHaveText('Native window: Shown');
-      await browser.keys('\uE00C');
-      await expect(status).toHaveText('Native window: Dismissed');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'dismisses initially focused content on Escape',
+      { requires: ['physical-click', 'keyboard'] },
+      async ({ browser, expect }) => {
+        const status = await browser.$('~agentic-storybook-callout-status');
+        await expect(status).toHaveText('Native window: Shown');
+        await browser.keys('\uE00C');
+        await expect(status).toHaveText('Native window: Dismissed');
+      },
+    ),
+  ],
   parameters: {
     docs: {
       description: {
diff --git a/packages/agentic/storybook-desktop/config/server.cjs b/packages/agentic/storybook-desktop/config/server.cjs
index 99421e224d..f4c461e76b 100644
--- a/packages/agentic/storybook-desktop/config/server.cjs
+++ b/packages/agentic/storybook-desktop/config/server.cjs
@@ -113,6 +113,11 @@ async function startDesktopStorybookServer({
     keepAlive = setInterval(() => undefined, 60_000);
     if (driverManifest) {
       const { StorybookChannelOrchestrator } = await import('../lib/driver/index.js');
+      // An accessible driver cannot perform physical input, so every test that attaches to it runs the accessible lane.
+      const maskedFeatures =
+        driverManifest.wdio?.input === 'accessible'
+          ? (await import('@fluentui-react-native/desktop-driver/authoring')).accessibleLaneMaskedFeatures
+          : undefined;
       const target = {
         endpoint: driverManifest.endpoint,
         id: driverManifest.targetId,
@@ -130,6 +135,7 @@ async function startDesktopStorybookServer({
           platformName: target.platformName,
           storyRootTestId: target.storyRootTestId,
           windows: createFakeStoryWindows(driverManifest.storyManifest, target.storyRootTestId),
+          ...(maskedFeatures ? { features: Object.fromEntries(maskedFeatures.map((feature) => [feature, false])) } : {}),
         });
         driver = await createDesktopDriverServer({
           host,
@@ -149,6 +155,7 @@ async function startDesktopStorybookServer({
           onStderr: (text) =>
             report.reporter.emit({ kind: 'output', payload: { stream: 'stderr', text } }, 'native-helper', { service: 'native-helper' }),
           onFailure: fatal,
+          ...(maskedFeatures ? { disabledInputFeatures: maskedFeatures } : {}),
           ...(agent
             ? {
                 agent: { descriptor: agent.descriptor, ...(agent.root === undefined ? {} : { root: agent.root }) },
diff --git a/packages/agentic/storybook-desktop/config/storybook-control.cjs b/packages/agentic/storybook-desktop/config/storybook-control.cjs
index 40df0e989b..2e1f1aa09c 100644
--- a/packages/agentic/storybook-desktop/config/storybook-control.cjs
+++ b/packages/agentic/storybook-desktop/config/storybook-control.cjs
@@ -145,8 +145,12 @@ async function runAuthoredTests() {
   const configUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'config', 'index.js')).href;
   const { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } = await import(smokeTestsUrl);
   const { makeDesktopStorybookConfig } = await import(configUrl);
+  // The driver instance's lane is a per-run choice the CLI resolved, so it travels as an option, not as configuration.
+  const { input, ...wdio } = manifest.wdio ?? {};
   const result = await runDesktopStorybookSmokeTests({
-    config: makeDesktopStorybookConfig({ projectRoot: process.cwd(), wdio: manifest.wdio }),
+    config: makeDesktopStorybookConfig({ projectRoot: process.cwd(), wdio }),
+    ...(input ? { input } : {}),
+    ...(manifest.scope ? { scope: manifest.scope } : {}),
     // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- the Desktop Driver is loopback-only
     driverUrl: `http://127.0.0.1:${manifest.driverPort}`,
     manifest: manifest.storyManifest,
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
index bc47137db0..ae64781038 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -242,6 +242,136 @@ function collectWdioTests(program) {
   return tests;
 }
 
+// The physical requirement each WebDriver action source type implies, in the order messages list them.
+const actionSourceRequirements = { key: 'keyboard', pointer: 'physical-click', wheel: 'wheel' };
+const requirementInputKinds = { keyboard: 'keyboard', 'physical-click': 'pointer', wheel: 'wheel' };
+const valueCommands = new Set(['setValue', 'addValue', 'clearValue']);
+
+function memberName(callee) {
+  const property = callee.node.property;
+  if (!callee.node.computed) return types.isIdentifier(property) ? property.name : undefined;
+  if (types.isStringLiteral(property)) return property.value;
+  return types.isTemplateLiteral(property) && property.expressions.length === 0 ? property.quasis[0].value.cooked : undefined;
+}
+
+function isBrowser(object) {
+  object = unwrap(object);
+  if (object.isIdentifier({ name: 'browser' })) return true;
+  return (object.isMemberExpression() || object.isOptionalMemberExpression()) && memberName(object) === 'browser';
+}
+
+/** Follows a constant to the value it holds, so a payload declared above the call is still read. */
+function readConstant(value, seen = new Set()) {
+  value = unwrap(value);
+  if (value.isIdentifier()) {
+    const binding = value.scope.getBinding(value.node.name);
+    const declarator = binding?.path;
+    if (
+      binding?.constant &&
+      declarator?.isVariableDeclarator() &&
+      declarator.node.init &&
+      declarator.get('id').isIdentifier() &&
+      !seen.has(binding)
+    ) {
+      seen.add(binding);
+      return readConstant(declarator.get('init'), seen);
+    }
+  }
+  return value;
+}
+
+function readString(value) {
+  value = readConstant(value);
+  if (value.isStringLiteral()) return value.node.value;
+  return value.isTemplateLiteral() && value.node.expressions.length === 0 ? value.node.quasis[0].value.cooked : undefined;
+}
+
+function actionSourceType(source) {
+  source = readConstant(source);
+  if (!source.isObjectExpression()) return undefined;
+  let type;
+  for (const property of source.get('properties')) {
+    // A spread or a computed key could supply or replace the type.
+    if (!property.isObjectProperty() || property.node.computed) return undefined;
+    if (keyName(property) === 'type') type = readString(property.get('value'));
+  }
+  return type;
+}
+
+/** The physical requirements of a WebDriver action payload, and whether every source in it could be read. */
+function readActionSources(payload) {
+  payload = readConstant(payload);
+  if (!payload.isArrayExpression()) return undefined;
+  const requires = new Set();
+  let readable = true;
+  for (const element of payload.get('elements')) {
+    const type = element?.node && !element.isSpreadElement() ? actionSourceType(element) : undefined;
+    if (type === undefined) readable = false;
+    else if (Object.hasOwn(actionSourceRequirements, type)) requires.add(actionSourceRequirements[type]);
+  }
+  return { requires: Object.values(actionSourceRequirements).filter((requirement) => requires.has(requirement)), readable };
+}
+
+/** A call that sends physical input, with the requirements that input implies. Those are undefined when the call cannot be read. */
+function directInputCall(call) {
+  const callee = call.get('callee');
+  if (!callee.isMemberExpression() && !callee.isOptionalMemberExpression()) return undefined;
+  const name = memberName(callee);
+  const argument = call.node.arguments[0] ? call.get('arguments.0') : undefined;
+  if (valueCommands.has(name)) return { call: name, requires: ['keyboard'] };
+  if (name === 'keys' && isBrowser(callee.get('object'))) return { call: 'browser.keys', requires: ['keyboard'] };
+  if (name === 'action' && isBrowser(callee.get('object'))) {
+    const type = argument && readString(argument);
+    if (type === undefined) return { call: 'browser.action', requires: undefined };
+    return Object.hasOwn(actionSourceRequirements, type)
+      ? { call: 'browser.action', requires: [actionSourceRequirements[type]] }
+      : undefined;
+  }
+  if (name === 'performActions') {
+    const sources = argument && readActionSources(argument);
+    if (!sources) return { call: 'performActions', requires: undefined };
+    if (sources.requires.length) return { call: 'performActions', requires: sources.requires };
+    return sources.readable ? undefined : { call: 'performActions', requires: undefined };
+  }
+  return undefined;
+}
+
+/**
+ * Rejects a case that also runs in the accessible input lane but sends physical input itself: the keyboard commands, the value
+ * commands that may type, and WebDriver actions with key, pointer or wheel sources. The check reads literals only. Input sent
+ * through a helper or an alias is stopped by the accessible lane's host masks when the case runs.
+ */
+function rejectDirectInput(callback, { name, input, inputSource }) {
+  if (input === 'physical') return;
+  let finding;
+  callback.traverse({
+    'CallExpression|OptionalCallExpression'(call) {
+      const found = finding ? undefined : directInputCall(call);
+      if (found) finding = { ...found, path: call };
+    },
+  });
+  if (!finding) return;
+  const subject = name ? `"${name}"` : 'This case';
+  const declared = inputSource === 'declared';
+  if (finding.requires === undefined) {
+    const declaration = declared ? "input: 'physical'" : 'requires for the physical input it sends (keyboard, physical-click or wheel)';
+    fail(
+      finding.path,
+      `${subject} runs in the accessible input lane, but calls ${finding.call} with an argument this check cannot read. ` +
+        `Pass a literal list of input sources, or declare ${declaration}.`,
+    );
+  }
+  const kinds = finding.requires.map((requirement) => requirementInputKinds[requirement]).join(' and ');
+  const declaration = declared
+    ? "input: 'physical'"
+    : `requires: [${finding.requires.map((requirement) => `'${requirement}'`).join(', ')}]`;
+  fail(
+    finding.path,
+    `${subject} runs in the accessible input lane, but ${finding.call} sends physical ${kinds} input. ` +
+      `Declare ${declaration} so it runs only in the physical lane, or remove the call.`,
+  );
+}
+
 function compileWdioTest(callback, sourceFile, source) {
   const file = types.file(types.program([types.expressionStatement(types.cloneNode(callback.node, true))]));
   const result = transformFromAstSync(file, source, {
@@ -365,3 +495,4 @@ module.exports = () => ({
 
 module.exports.collectWdioTests = collectWdioTests;
 module.exports.compileWdioTest = compileWdioTest;
+module.exports.rejectDirectInput = rejectDirectInput;
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
index 67e6ed935c..e620c955b8 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -16,6 +16,10 @@ declare namespace storyTests {
 
   function collectWdioTests(program: NodePath<types.Program>): ReadonlyMap<string, StoryTest>;
   function compileWdioTest(callback: Callback['callback'], sourceFile: string, source: string): string;
+  function rejectDirectInput(
+    callback: Callback['callback'],
+    descriptor: { name?: string; input: 'accessible' | 'physical' | 'both'; inputSource: 'declared' | 'derived' },
+  ): void;
 }
 
 export = storyTests;
diff --git a/packages/agentic/storybook-desktop/references/commands.md b/packages/agentic/storybook-desktop/references/commands.md
index f60208c21c..a82fa228d0 100644
--- a/packages/agentic/storybook-desktop/references/commands.md
+++ b/packages/agentic/storybook-desktop/references/commands.md
@@ -29,6 +29,8 @@ only). The mode precedence is CLI flag, `DESKTOP_REPORTER`, config, then
 | `test --<platform> --list`                    | Discover authored executable story-test IDs         |
 | `test --<platform> --test <glob>`             | Run matching isolated story callbacks               |
 | `test --<platform> --input accessible`        | Select accessible and `both` descriptor cases       |
+| `test --<platform> --list --input physical`   | Preview a lane's selection and exclusions           |
+| `driver --<platform> --input accessible`      | Start a driver that masks physical input            |
 | `smoke --<platform> --mode stories`           | Build/bundle/launch, traverse stories, clean up     |
 | `smoke --<platform> --mode stories-and-tests` | Traverse stories and execute callbacks              |
 
@@ -63,10 +65,16 @@ Windows smokes.
 
 Storybook test and stories-and-tests smoke commands accept
 `--input accessible|physical`. The lane filters `desktopIt` cases by their
-resolved input and target platform. `driver --input` records the default lane
-for subsequent tests against that instance. Legacy callback collections are
-not eligible for input-lane runs. Input lanes cannot be combined with an
-explicit non-`auto` click mode.
+resolved input, target platform, and scope. Without a flag the lane comes from
+`DESKTOP_INPUT`, then from the driver instance a `test` attaches to; none of them
+means compatibility mode, which runs every case as before. `driver --input`
+starts the driver for that lane and records it for subsequent tests against the
+instance. An `accessible` driver masks keyboard, physical click, and wheel, and
+`test --input accessible` verifies the mask before running anything: a driver
+that is not masked fails the run rather than letting a case move the pointer.
+Legacy callback collections are not eligible for input-lane runs. Input lanes
+cannot be combined with an explicit non-`auto` click mode. See
+[story tests](story-tests.md#run-an-input-lane).
 
 The TypeScript API exposes the same operations through `DesktopStorybookCli`.
 Higher-level supervisors should inject their shared reporter, runner, and
diff --git a/packages/agentic/storybook-desktop/references/contributing.md b/packages/agentic/storybook-desktop/references/contributing.md
index 207be56c30..8a1ac7efea 100644
--- a/packages/agentic/storybook-desktop/references/contributing.md
+++ b/packages/agentic/storybook-desktop/references/contributing.md
@@ -17,6 +17,16 @@ The channel child in `config/server.cjs` constructs its native driver through
 helper policy, authority, descriptor publication and settled driver shutdown
 in that shared harness implementation, not a parallel Storybook copy.
 
+Input lanes cross these areas. The descriptor schema, merge, and per-case
+decision belong to `@fluentui-react-native/desktop-driver/authoring`; do not
+copy them here. `src/cli/inputLane.ts` resolves the requested lane,
+`src/testing/selection.ts` decides every case before launch and renders
+`test --list`, `src/testing/laneVerdict.ts` judges a lane run's accounting, and
+`config/server.cjs` masks the accessible lane's physical input on the driver.
+`config/transform-story-tests.cjs` is both the Metro Babel plugin and the shared
+AST library: its `rejectDirectInput` check runs from `src/testing/extractWdioTests.ts`
+only, because the Metro transform has no validated descriptor to judge by.
+
 Keep story callbacks statically extractable and authentication checks
 fail-closed. Update references when commands, supported config, outputs, or
 readiness contracts change.
diff --git a/packages/agentic/storybook-desktop/references/story-tests.md b/packages/agentic/storybook-desktop/references/story-tests.md
index 62662edbbd..438c0e09a7 100644
--- a/packages/agentic/storybook-desktop/references/story-tests.md
+++ b/packages/agentic/storybook-desktop/references/story-tests.md
@@ -7,63 +7,123 @@ owner_paths:
 
 # Author story tests
 
-Story tests are statically extracted CSF `wdio` callbacks. Use `desktopIt`
-descriptors when declaring input requirements or endpoint scope. Top-level
-functions or named callback collections remain supported for compatibility,
-but cannot be selected by an input lane. Callbacks must not close over
-module-local values. Import Node-only helpers through literal dynamic
-`import()` inside the callback. Keep test code out of the native bundle.
+Story tests are statically extracted CSF `wdio` callbacks. Declare each case
+with `desktopIt`: its descriptor says which input the case needs and where it
+runs, so a run can select it for the input lane, platform, and scope it
+exercises. Callbacks must not close over module-local values. Import Node-only
+helpers through literal dynamic `import()` inside the callback. Keep test code
+out of the native bundle.
 
 ```tsx
 import type { StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 type Story = WdioStory<StoryObj<typeof Button>>;
 
 export const Default: Story = {
-  args: { testID: 'save-button' },
-  wdio: {
-    'is enabled': async ({ browser, expect }) => {
-      await expect(await browser.$('~save-button')).toBeEnabled();
-    },
-    'supports activation': async ({ browser, platform, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features?.physicalClick) {
-        skip('Physical pointer input is unavailable.');
-        return;
-      }
-      await (await browser.$('~save-button')).click();
-    },
-  },
-};
-```
-
-For modality-aware tests, import the value helper and use an array of cases:
-
-```tsx
-import { desktopIt, type WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
-
-export const Default: WdioStory<StoryObj<typeof Button>> = {
   args: { testID: 'save-button' },
   wdio: [
-    desktopIt('activates in either input lane', { requires: ['click'] }, async ({ browser, expect }) => {
+    desktopIt('is enabled', async ({ browser, expect }) => {
+      await expect(await browser.$('~save-button')).toBeEnabled();
+    }),
+    desktopIt('activates', { requires: ['click'] }, async ({ browser, expect }) => {
       await (await browser.$('~save-button')).click();
       await expect(await browser.$('~saved-message')).toBeDisplayed();
     }),
-    desktopIt('uses a physical pointer', { requires: ['physical-click'], platforms: ['win32'] }, async ({ browser }) => {
-      await (await browser.$('~save-button')).click();
+    desktopIt('activates with Enter', { requires: ['keyboard'], platforms: ['!macos'] }, async ({ browser, expect }) => {
+      await browser.keys('\uE007');
+      await expect(await browser.$('~saved-message')).toBeDisplayed();
     }),
   ],
 };
 ```
 
-`requires: ['click']` derives to `both` and adapts `element.click()` to the
-selected lane: accessibility click in the accessible lane and physical click
-in the physical lane. Explicit physical or accessibility requirements derive
-their matching lane. `input` may narrow a `both` case but cannot widen a
-transport-specific requirement. `platforms` is an allowlist by default;
-`['!win32']` excludes that endpoint. Platform selection uses the target
-endpoint, so Win32 remains distinct from Windows.
+`desktopIt(name, run)` declares a case with no restrictions, so it runs in every
+lane on every platform. `desktopIt(name, options, run)` adds a descriptor. The
+older object of named callbacks and the single `wdio: async (context) => ...`
+form remain supported for compatibility, but a legacy callback has no
+descriptor, so an input lane rejects it, listing the story IDs to migrate,
+instead of treating it as `both`.
+
+## Declare how a case runs
+
+The descriptor is a strict static JSON literal; an unknown field, a computed
+value, or an invalid combination fails extraction with source context.
+
+| Field         | Meaning                                                                                              |
+| ------------- | ---------------------------------------------------------------------------------------------------- |
+| `requires`    | Host capabilities the case needs. They also derive the input lane (below).                           |
+| `input`       | `accessible`, `physical`, or `both`. Defaults to what `requires` derives, else `both`.               |
+| `platforms`   | Endpoints the case runs on: `macos`, `windows`, `win32`. Omitted means every endpoint.               |
+| `scope`       | Custom scope values, such as `{ 'rn.renderer': ['fabric'] }`. Omitted means every value.             |
+| `unsupported` | A known gap: `{ platforms, reason, issue? }`. The case is reported unsupported instead of executing. |
+| `quarantine`  | A temporary gap: `{ issue, reason, expires, platforms?, input? }`, with `expires` as `YYYY-MM-DD`.   |
+
+### Input and requirements
+
+Most cases need no `input`: their `requires` already says what they send.
+
+| Requirement                                                                             | Derived input | Meaning                                                                |
+| --------------------------------------------------------------------------------------- | ------------- | ---------------------------------------------------------------------- |
+| `keyboard`, `physical-click`, `wheel`                                                   | `physical`    | Operating-system input that moves the real pointer or sends key events |
+| `accessibility-click`                                                                   | `accessible`  | The element's accessibility action                                     |
+| `click`                                                                                 | `both`        | `element.click()`, which follows the lane (below)                      |
+| `accessibility-actions`, `element-screenshot`, `focus`, `screenshot`, `set-window-rect` | `both`        | The host must offer the feature                                        |
+
+A case with no requirements is `both` and runs in every lane. Requiring both a
+physical and an accessibility transport is an error; split the case. An explicit
+`input` may narrow a `both` case but cannot widen a transport requirement.
+
+`requires: ['click']` makes `element.click()` follow the lane: an accessibility
+click in the accessible lane and a physical click in the physical lane. Without
+a lane, an accessible case still uses accessibility clicks and every other case
+follows the configured `--click-mode`, so a physical case on a host that masks
+physical click is reported unsupported instead of failing its session. Before
+a case runs, the host's reported features must meet each requirement. A case it
+cannot meet is reported unsupported, never passed, and makes a lane run
+incomplete unless the case declares the gap.
+
+### Platforms and scope
+
+`platforms` is an allowlist: `['win32']` runs only on Win32. Negate with
+`['!win32']` to run everywhere else; a list holds either allowed or negated
+endpoints, never both. Platform selection uses the target endpoint, so Win32
+remains distinct from Windows.
+
+`scope` narrows by values the target holds. Values within a key are alternatives
+and keys combine. `rn.renderer` (`fabric` or `paper`) is built in and the
+`rn.*` keys are reserved for the framework. A consumer declares its own keys in
+the desktop config's `testScopes`, such as `{ flavor: ['stable', 'preview'] }`,
+and each target sets its value in `testScope`. A key or value outside the declared
+domains, or a key the target does not supply, is a configuration error rather
+than a silent exclusion, so a typo cannot drop a case.
+
+A case that does not match the target is excluded, not skipped: it is not a test
+and is counted only in the run's selection totals.
+
+### Known gaps
+
+Declare a gap instead of calling `skip` at run time. `unsupported` lists the
+endpoints where the behavior does not work yet, with a reason and ideally an
+issue. `quarantine` suspends a flaky case until its `expires` date, optionally for
+one endpoint or lane. An expired quarantine fails the run before anything
+executes. Declared gaps are reported as unsupported with their reason and do not
+make a lane run incomplete; a run-time `skip(reason)` does, so reserve it for
+conditions no descriptor can state.
+
+```tsx
+desktopIt(
+  'closes on Tab and continues past the anchor',
+  {
+    requires: ['physical-click', 'keyboard', 'focus'],
+    unsupported: { platforms: ['win32'], reason: 'Win32 hosts keep the cycle behavior.', issue: '#4377' },
+  },
+  async ({ browser, expect }) => {
+    // ...
+  },
+);
+```
 
 The callback receives the real WebdriverIO `browser`, `expect-webdriverio`
 `expect`, typed `desktop` assertions/story commands, target `platform` (`macos`,
@@ -85,10 +145,10 @@ Metro resolves their dependencies.
 
 Use native selectors and WebDriver operations; the app has no DOM or JavaScript
 execution surface. Read native properties through `getProperty()` rather than
-ordinary object matchers. Feature-check native actions and explicitly skip
-unsupported cases; never turn unsupported state into false. For example,
-`getProperty('accessibilityActions')` lists the action names an element
-publishes (such as `Toggle` or `Select`) when
+ordinary object matchers. Declare the capabilities a case needs in `requires`
+rather than feature-checking inside the callback, and never turn unsupported
+state into false. For example, `getProperty('accessibilityActions')` lists the
+action names an element publishes (such as `Toggle` or `Select`) when
 `browser.capabilities['furn:features']?.accessibilityActions` is true.
 
 Tests in one story run in declaration order, each in its own Node process and
@@ -101,12 +161,62 @@ editing callbacks because their digest participates in manifest freshness.
 filters names. `test` operates against an already running app/driver; smoke
 owns the complete app lifecycle.
 
+## Run an input lane
+
+A lane runs only the cases that apply to one way of driving the app. The
+`accessible` lane runs `accessible` and `both` cases through accessibility
+actions, so it never moves the pointer or sends key events and is safe on a
+machine someone is using. The `physical` lane runs `physical` and `both` cases
+with real pointer, keyboard, and wheel input, so it needs a machine nobody is
+using. Without a lane, every case runs as before (compatibility mode) and click
+behavior follows `--click-mode`.
+
 Use `storybook test --input accessible|physical` or
-`storybook smoke --mode stories-and-tests --input accessible|physical` to
-select declared cases. `storybook driver --input ...` supplies the default
-lane to a later `storybook test` invocation. `--input` cannot be combined
-with a non-default `--click-mode`. A lane requires descriptor cases and rejects
-legacy callback collections rather than silently treating them as `both`.
+`storybook smoke --mode stories-and-tests --input accessible|physical` to run
+one lane. `DESKTOP_INPUT` supplies the lane when no flag is given.
+`storybook driver --input ...` records the default lane for a later
+`storybook test` against that driver. `--input` cannot be combined with a
+non-default `--click-mode`. `test --list` shows, for each story, the cases the
+lane runs with their resolved input, requirements, platforms, and scope, and the
+cases it excludes with the reason; add `--input` to preview a lane.
+
+The accessible lane holds a case to accessible input by masking the host, not by
+trusting the case: the driver reports keyboard, physical click, and wheel as
+unavailable, so a case that tries them fails instead of silently moving the
+pointer. `smoke` and `driver --input accessible` start the driver already
+masked. `test --input accessible` attaches to a running driver and verifies the
+mask from the session's reported features before it runs anything. A driver that
+does not report all three as unavailable stops the run as an infrastructure
+failure rather than running unmasked, so attach the lane to a driver started
+with `driver --input accessible`.
+
+A lane that executes no case is not a passing run, and neither is a lane run
+that leaves a case unsupported or skipped without a declared gap. Excluded cases
+never count against a run: they are not tests.
+
+## Keep physical input out of accessible cases
+
+Extraction checks every `desktopIt` case that can run in the accessible lane
+(any case that is not `physical`) and fails with a source-context error when its
+callback calls an API that sends physical input without declaring it:
+
+- `browser.keys(...)`, which sends key events (`keyboard`);
+- `setValue`, `addValue`, or `clearValue` on any object (`keyboard`);
+- `browser.action('key' | 'pointer' | 'wheel')` and `performActions` with `key`,
+  `pointer`, or `wheel` sources (`keyboard`, `physical-click`, or `wheel`).
+
+Declare the matching `requires`, or `input: 'physical'` when the case already
+declares its input, so it runs only in the physical lane, or remove the call. A
+call whose arguments the check cannot read, such as a computed action list,
+fails the same way, because it cannot tell what the call sends. The message
+names the call and the requirement to declare.
+
+The check reads the callback only. It does not follow helper functions or aliases,
+and `setValue`, `addValue`, and `clearValue` are matched by name, so a method you
+define with one of those names is flagged too. Input hidden behind a helper is
+instead caught at run time by the accessible lane's host mask. Legacy callbacks
+are not checked, and the Metro transform does not run the check; extraction
+(`storybook manifest`, `test`, `smoke`) does.
 
 Use the component authoring contract for component-specific test assertions.
 Legacy `parameters.desktopDriver` static plans remain for compatibility and
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
index c94989b0b2..8729f91a2c 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import type { NativeDriverArtifact } from '@fluentui-react-native/desktop-driver';
+import type { DesktopStoryManifestEntry, NativeDriverArtifact } from '@fluentui-react-native/desktop-driver';
+import { validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
 import { DesktopServiceScope } from '@fluentui-react-native/desktop-test';
 import type { ResolvedDesktopConfig, ResolvedDesktopTarget } from '@fluentui-react-native/desktop-test';
 import { selectDesktopRenderer } from '@fluentui-react-native/desktop-test/config';
@@ -11,6 +12,7 @@ import { STORYBOOK_SMOKE_MODE } from '../config/commands';
 import { DesktopStorybookConfig, makeDesktopStorybookConfig } from '../config/makeDesktopStorybookConfig';
 import { FURN_STORYBOOK_BUNDLE_IDENTIFIER, FURN_STORYBOOK_INSTANCE_ID } from '../config/instance';
 import { FURN_STORYBOOK_PLATFORM } from '../config/platforms';
+import { desktopStorybookTargetId } from '../driver/driverManifest';
 import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopCommand } from './commandRunner';
 import { createDesktopStorybookCommand } from './createDesktopStorybookCommand';
 import {
@@ -76,6 +78,33 @@ const createEmptyStoryManifest = async (_config: unknown, platform: 'macos' | 'w
   schemaVersion: 1 as const,
 });
 
+function declaredStoryEntry(id: string, cases: readonly (readonly [name: string, options: unknown])[]): DesktopStoryManifestEntry {
+  return {
+    id,
+    name: 'Default',
+    title: 'Button',
+    sourcePath: 'button.stories.tsx',
+    packageName: 'fixture',
+    tags: [],
+    wdio: {
+      exportName: 'Default',
+      digest: 'declared',
+      testNames: cases.map(([name]) => name),
+      cases: cases.map(([name, options]) => ({ name, options: validateDesktopCaseOptions(options) })),
+    },
+  };
+}
+
+function storyManifestOf(...entries: DesktopStoryManifestEntry[]) {
+  return async () => ({
+    endpoint: 'macos' as const,
+    schemaVersion: 1 as const,
+    platformManifestDigest: 'digest',
+    portablePlanDigest: 'portable',
+    entries,
+  });
+}
+
 describe('macOS application leases', () => {
   test('validates exact running application records and rejects ambiguity', () => {
     expect(
@@ -360,6 +389,115 @@ describe('DesktopStorybookCli', () => {
     await expect(cli.test('macos', { timeoutMs: 0 })).rejects.toThrow('wdio.timeoutMs');
   });
 
+  describe('input lane selection', () => {
+    const cases = [
+      ['adaptive', { requires: ['click'] }],
+      ['typing', { requires: ['keyboard'] }],
+      ['win32-only', { platforms: ['win32'] }],
+      ['paper-only', { scope: { 'rn.renderer': ['paper'] } }],
+      ['fabric-only', { scope: { 'rn.renderer': ['fabric'] } }],
+    ] as const;
+    const config = () => makeDesktopStorybookConfig({ projectRoot: storybookRoot, storyPackages: [] });
+    const list = async (flags: string[], ...entries: DesktopStoryManifestEntry[]) => {
+      const output = { write: jest.fn() };
+      await createDesktopStorybookCommand({ config: config(), createStoryManifest: storyManifestOf(...entries), output }).parseAsync([
+        'node',
+        'storybook',
+        'test',
+        '--macos',
+        '--list',
+        ...flags,
+      ]);
+      return JSON.parse(output.write.mock.calls[0][0]);
+    };
+    // An explicit URL and target stand in for a running driver, so selection is what these runs exercise.
+    const connection = { url: 'https://127.0.0.1:1234', target: 'fixture' };
+    const run = (options: Parameters<DesktopStorybookCli['test']>[1], ...entries: DesktopStoryManifestEntry[]) =>
+      new DesktopStorybookCli(config(), { createStoryManifest: storyManifestOf(...entries), output: { write: jest.fn() } }).test('macos', {
+        ...connection,
+        ...options,
+      });
+    const legacyEntry = (id: string): DesktopStoryManifestEntry => ({
+      ...declaredStoryEntry(id, []),
+      wdio: { exportName: 'Default', digest: 'legacy' },
+    });
+
+    test.each([
+      [
+        'accessible',
+        ['adaptive', 'fabric-only'],
+        [
+          ['typing', 'input'],
+          ['win32-only', 'platform'],
+          ['paper-only', 'scope'],
+        ],
+      ],
+      [
+        'physical',
+        ['adaptive', 'typing', 'fabric-only'],
+        [
+          ['win32-only', 'platform'],
+          ['paper-only', 'scope'],
+        ],
+      ],
+    ])('lists what the %s lane runs and why each other matching case is left out', async (input, selected, excluded) => {
+      const [story] = await list(['--input', input], declaredStoryEntry('button--default', cases));
+      expect(story.tests.map(({ name }: { name: string }) => name)).toEqual(selected);
+      expect(story.excluded.map(({ name, reason }: { name: string; reason: string }) => [name, reason])).toEqual(excluded);
+      expect(story.tests[0]).toEqual({ name: 'adaptive', input: 'both', inputSource: 'derived', requires: ['click'] });
+    });
+
+    test('lists every declared case that targets the platform when no lane is selected', async () => {
+      const [story] = await list([], declaredStoryEntry('button--default', cases));
+      expect(story.tests.map(({ name }: { name: string }) => name)).toEqual(['adaptive', 'typing', 'fabric-only']);
+      expect(story.excluded.map(({ reason }: { reason: string }) => reason)).toEqual(['platform', 'scope']);
+    });
+
+    test('names every legacy callback a lane cannot run, so they migrate in one pass', async () => {
+      await expect(run({ input: 'accessible' }, legacyEntry('a--default'), legacyEntry('b--default'))).rejects.toThrow(
+        'Input lane "accessible" cannot run legacy wdio callbacks; declare them with desktopIt: a--default, b--default.',
+      );
+    });
+
+    test('explains an empty selection by what the target and lane excluded', async () => {
+      await expect(run({ input: 'accessible' }, declaredStoryEntry('button--default', cases.slice(1, 3)))).rejects.toThrow(
+        'No executable wdio story tests matched the requested selection (excluded 1 by platform, 0 by scope, 1 by input).',
+      );
+    });
+
+    test('does not blame a narrow filter for cases it never asked for', async () => {
+      await expect(run({ input: 'accessible', test: 'typing' }, declaredStoryEntry('button--default', cases))).rejects.toThrow(
+        'No executable wdio story tests matched the requested selection (excluded 0 by platform, 0 by scope, 1 by input).',
+      );
+    });
+
+    test('takes the lane of the running driver instance unless a flag or the environment names one', async () => {
+      const manifestPath = path.join(storybookRoot, 'storybook-desktop.generated', 'driver-manifest.macos.json');
+      const cli = new DesktopStorybookCli(config(), {
+        createStoryManifest: storyManifestOf(declaredStoryEntry('button--default', cases.slice(1, 2))),
+        output: { write: jest.fn() },
+      });
+      fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+      fs.writeFileSync(
+        manifestPath,
+        JSON.stringify({
+          endpoint: 'macos',
+          instanceId: cli.instance.id,
+          renderer: 'fabric',
+          driverPort: 7100,
+          targetId: desktopStorybookTargetId(config(), 'macos', 'fabric'),
+          wdio: { input: 'accessible' },
+        }),
+      );
+      try {
+        // The only case needs a physical keyboard, so only the inherited accessible lane can leave it out.
+        await expect(cli.test('macos', {})).rejects.toThrow('excluded 0 by platform, 0 by scope, 1 by input');
+      } finally {
+        fs.rmSync(manifestPath, { force: true });
+      }
+    });
+  });
+
   test('starts the config-owned server with platform and connection options', async () => {
     const runner = new RecordingRunner();
     const services = new DesktopServiceScope(runner);
@@ -486,6 +624,9 @@ describe('DesktopStorybookCli', () => {
 
       expect(fabricManifest.renderer).toBe('fabric');
       expect(paperManifest.renderer).toBe('paper');
+      // The control process that runs smoke tests has no desktop configuration, so the manifest carries the scope values.
+      expect(fabricManifest.scope.values).toMatchObject({ 'rn.renderer': 'fabric' });
+      expect(paperManifest.scope.values).toMatchObject({ 'rn.renderer': 'paper' });
       expect(paperManifest.bridgeNonce).not.toBe(fabricManifest.bridgeNonce);
       expect(repeatedPaperManifest.bridgeNonce).toBe(paperManifest.bridgeNonce);
     } finally {
@@ -1018,6 +1159,7 @@ describe('DesktopStorybookCli', () => {
       manifest: await createEmptyStoryManifest(cli.config, 'macos'),
       platform: 'macos',
       report: undefined,
+      scope: { domains: { 'rn.renderer': ['fabric', 'paper'] }, values: { 'rn.renderer': 'fabric' } },
       signal: expect.any(AbortSignal),
       targetId: 'agenticstorybook-macos',
     });
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
index ad62fc01bf..ff7da2de2f 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
@@ -2,8 +2,14 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import { createServer } from 'node:net';
 import path from 'node:path';
-import { defaultAgentDescriptor, DesktopServiceScope, resolveDesktopApplication } from '@fluentui-react-native/desktop-test';
+import {
+  defaultAgentDescriptor,
+  DesktopServiceScope,
+  resolveDesktopApplication,
+  resolveDesktopTestScope,
+} from '@fluentui-react-native/desktop-test';
 import type { DesktopReportWriter } from '@fluentui-react-native/desktop-test/reporting';
+import { resolveDesktopScopeDomains } from '@fluentui-react-native/desktop-driver/authoring';
 import { formatDesktopReporterValue } from '@fluentui-react-native/desktop-driver/cli/reporter';
 import type { ResolvedDesktopReporterMode } from '@fluentui-react-native/desktop-driver/cli/reporter';
 
@@ -38,7 +44,9 @@ import {
   writeDesktopStoryManifest,
 } from '../driver/index.js';
 import {
+  desktopStorybookDriverManifestPath,
   desktopStorybookTargetId,
+  driverManifestInput,
   type CreateDesktopStorybookDriverManifestOptions,
   type DesktopStorybookAgentManifest,
   type DesktopStorybookDriverManifest,
@@ -46,9 +54,11 @@ import {
 import { NodeDesktopCommandRunner, STORYBOOK_VERBOSE } from './commandRunner.js';
 import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopCommand } from './commandRunner.js';
 import { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } from './smokeTests.js';
-import { matchesWdioTest, runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
+import { runWdioStoryTests } from '../testing/runWdioTests.js';
+import { describeWdioCounts } from '../testing/laneVerdict.js';
+import { decideWdioSelection, describeWdioExclusions, listWdioSelection } from '../testing/selection.js';
+import type { WdioSelectionContext } from '../testing/selection.js';
 import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
-import { matchesDesktopPlatforms } from '@fluentui-react-native/desktop-driver/authoring';
 
 type ResolvedDesktopStorybookInstance = DesktopStorybookInstance & {
   driverManifestPath?: string;
@@ -352,45 +362,20 @@ export class DesktopStorybookCli {
         ? resolveWdioOptions({ ...initialSettings, input: connection.input })
         : initialSettings;
     const manifest = await this.createStoryManifest(this.config, platform);
-    const selected = selectWdioStories(manifest, settings, platform);
-    if (selected.length === 0) {
-      throw new Error('No executable wdio story tests matched the requested selection.');
+    const scope = this.scopeContext(platform);
+    const selection = decideWdioSelection(manifest, settings, { platform, scope });
+    if (selection.stories.length === 0) {
+      throw new Error(`No executable wdio story tests matched the requested selection${describeWdioExclusions(selection)}.`);
     }
     if (options.list) {
-      const value = selected.map(({ id, sourcePath, wdio }) => ({
-        id,
-        sourcePath,
-        ...(wdio?.cases
-          ? {
-              tests: wdio.cases
-                .filter(
-                  ({ name, options: descriptor }) =>
-                    matchesWdioTest(name, settings.test) &&
-                    (!settings.input || descriptor.input === 'both' || descriptor.input === settings.input) &&
-                    matchesDesktopPlatforms(descriptor.platforms, platform),
-                )
-                .map(({ name, options: descriptor }) => ({
-                  name,
-                  input: descriptor.input,
-                  inputSource: descriptor.inputSource,
-                  requires: descriptor.requires ?? [],
-                  platforms: descriptor.platforms,
-                })),
-            }
-          : wdio?.testNames
-            ? { tests: wdio.testNames.filter((name) => matchesWdioTest(name, settings.test)) }
-            : {}),
-      }));
+      const value = listWdioSelection(selection, settings);
       if (this.reporterMode === 'json' || this.reporterMode === 'ndjson') this.writeStructured(value);
       else this.output.write(`${JSON.stringify(value, null, 2)}\n`);
       return;
     }
     const activeConnection = connection ?? this.testConnection(platform, options);
     if (platform === 'macos' && !options.url) {
-      await this.writeMacOSApplicationLease(
-        path.join(this.config.projectRoot, 'storybook-desktop.generated', 'driver-manifest.macos.json'),
-        settings.timeoutMs,
-      );
+      await this.writeMacOSApplicationLease(desktopStorybookDriverManifestPath(this.config.projectRoot, 'macos'), settings.timeoutMs);
     }
     const results = await runWdioStoryTests(
       {
@@ -399,6 +384,7 @@ export class DesktopStorybookCli {
         config: this.config,
         manifest,
         platform,
+        scope,
         errorOutput: this.errorOutput,
         report: this.reporter,
         signal: this.services.controller.signal,
@@ -406,10 +392,14 @@ export class DesktopStorybookCli {
       },
       this.runner,
     );
-    this.output.write(
-      `Ran ${results.length} executable wdio tests (${results.filter(({ status }) => status === 'passed').length} passed, ` +
-        `${results.filter(({ status }) => status === 'skipped').length} skipped).\n`,
-    );
+    this.output.write(`Ran ${results.length} executable wdio tests (${describeWdioCounts(results)}).\n`);
+  }
+
+  /** The scope domains and the values this endpoint's target holds, which declared case `scope` selection reads. */
+  private scopeContext(platform: Platforms): NonNullable<WdioSelectionContext['scope']> {
+    const domains = this.config.desktop?.testScopes ?? resolveDesktopScopeDomains();
+    // This run's renderer wins over the host configuration, since `--paper` switches it.
+    return { domains, values: resolveDesktopTestScope(domains, this.config.getDesktopTarget(platform), this.renderer(platform)) };
   }
 
   private testConnection(
@@ -422,7 +412,7 @@ export class DesktopStorybookCli {
       }
       return { targetId: options.target, url: options.url };
     }
-    const manifestPath = path.join(this.config.projectRoot, 'storybook-desktop.generated', `driver-manifest.${platform}.json`);
+    const manifestPath = desktopStorybookDriverManifestPath(this.config.projectRoot, platform);
     if (!fs.existsSync(manifestPath)) {
       throw new Error(`Start storybook driver --${platform} and launch the app before running storybook test.`);
     }
@@ -452,16 +442,7 @@ export class DesktopStorybookCli {
         `The Storybook driver instance at ${manifestPath} serves an agent; restart storybook driver --${platform} without --agent to run storybook test.`,
       );
     }
-    const input =
-      typeof manifest === 'object' &&
-      manifest !== null &&
-      'wdio' in manifest &&
-      typeof manifest.wdio === 'object' &&
-      manifest.wdio !== null &&
-      'input' in manifest.wdio &&
-      (manifest.wdio.input === 'accessible' || manifest.wdio.input === 'physical')
-        ? manifest.wdio.input
-        : undefined;
+    const input = driverManifestInput(manifest);
     return { targetId: manifest.targetId, url: loopbackUrl(manifest.driverPort), ...(input ? { input } : {}) };
   }
 
@@ -623,6 +604,7 @@ export class DesktopStorybookCli {
             driverUrl: loopbackUrl(instance.driverPort),
             manifest: await this.createStoryManifest(this.config, platform),
             platform,
+            scope: this.scopeContext(platform),
             targetId: this.targetId(platform),
             report: this.reporter,
             signal: this.services.controller.signal,
@@ -722,7 +704,7 @@ export class DesktopStorybookCli {
     wdio?: CreateDesktopStorybookDriverManifestOptions['wdio'],
   ): Promise<{ manifest: DesktopStorybookDriverManifest; path: string }> {
     const storyManifest = await this.createStoryManifest(this.config, platform);
-    const outputPath = path.join(this.config.projectRoot, 'storybook-desktop.generated', `driver-manifest.${platform}.json`);
+    const outputPath = desktopStorybookDriverManifestPath(this.config.projectRoot, platform);
     const renderer = this.renderer(platform);
     const driverManifest = createDesktopStorybookDriverManifest({
       ...(agent ? { agent } : {}),
@@ -732,6 +714,7 @@ export class DesktopStorybookCli {
       nativeDriver,
       platform,
       renderer,
+      scope: this.scopeContext(platform),
       storyManifest,
       ...(wdio ? { wdio } : {}),
     });
diff --git a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
index f7552ff94f..404f6a88d7 100644
--- a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
+++ b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
@@ -26,6 +26,7 @@ import type {
   DesktopStorybookTestOptions,
 } from './DesktopStorybookCli.js';
 import { DesktopStorybookCli } from './DesktopStorybookCli.js';
+import { resolveCommandInputLane, readDriverInstanceInput } from './inputLane.js';
 import { loadDesktopStorybookConfig } from './loadConfig.js';
 
 type PlatformFlags = {
@@ -276,10 +277,27 @@ export async function runDesktopStorybookCli(argv: readonly string[] = process.a
       configured: options.config.desktop?.reporting?.events,
     });
     options.reporterMode = reporterMode;
+    const actionOptions = action.opts<PlatformFlags & { input?: string; mode?: string; target?: string; url?: string }>();
+    const platform = selectedPlatform(actionOptions) ?? options.config.platform;
+    const { projectRoot } = options.config;
+    const lane =
+      action.name() === 'test' || action.name() === 'smoke'
+        ? resolveCommandInputLane({
+            command: action.name() as 'test' | 'smoke',
+            runsTests: action.name() === 'test' || actionOptions.mode === 'stories-and-tests',
+            flag: actionOptions.input,
+            environment: process.env.DESKTOP_INPUT,
+            driverInput:
+              action.name() === 'test' && platform && !actionOptions.url && !actionOptions.target
+                ? () => readDriverInstanceInput(projectRoot, platform)
+                : undefined,
+          })
+        : undefined;
     session = await createDesktopReportSession({
       ...options.config.desktop?.reporting,
       artifactsRoot: options.config.desktop?.reporting.artifactsRoot ?? path.join(options.config.projectRoot, 'artifacts', 'desktop'),
       kind: ['test', 'smoke'].includes(action.name()) ? 'tests' : 'lifecycle',
+      ...(lane ? { lane } : {}),
       reporterMode,
       eventLevel,
       // A long-lived command's readiness record is its only output; before readiness, a failure reports its summary.
diff --git a/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts b/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
new file mode 100644
index 0000000000..1d9202f145
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { readDriverInstanceInput, resolveCommandInputLane } from './inputLane.js';
+
+describe('command input lane', () => {
+  const driverInput = jest.fn((): 'accessible' | 'physical' | undefined => 'physical');
+  beforeEach(() => driverInput.mockClear());
+
+  test('has no lane in compatibility mode', () => {
+    expect(resolveCommandInputLane({ command: 'test', runsTests: true, driverInput: () => undefined })).toBeUndefined();
+    expect(resolveCommandInputLane({ command: 'test', runsTests: true })).toBeUndefined();
+  });
+
+  test('a run that executes no authored tests has no lane to account for', () => {
+    expect(resolveCommandInputLane({ command: 'smoke', runsTests: false, flag: 'accessible', driverInput })).toBeUndefined();
+    expect(driverInput).not.toHaveBeenCalled();
+  });
+
+  test('prefers the flag, then the environment, then the driver instance', () => {
+    const request = { command: 'test', runsTests: true, driverInput } as const;
+    expect(resolveCommandInputLane({ ...request, flag: 'accessible', environment: 'physical' })).toMatchObject({
+      input: 'accessible',
+      source: 'option',
+    });
+    expect(resolveCommandInputLane({ ...request, environment: 'accessible' })).toMatchObject({
+      input: 'accessible',
+      source: 'environment',
+    });
+    expect(resolveCommandInputLane(request)).toMatchObject({ input: 'physical', source: 'driver' });
+  });
+
+  test('does not read the driver instance when a flag or environment names the lane', () => {
+    resolveCommandInputLane({ command: 'test', runsTests: true, flag: 'physical', driverInput });
+    resolveCommandInputLane({ command: 'test', runsTests: true, environment: 'physical', driverInput });
+    expect(driverInput).not.toHaveBeenCalled();
+  });
+
+  test('labels how an accessible lane is masked by who owns the driver, and never a physical lane', () => {
+    expect(resolveCommandInputLane({ command: 'smoke', runsTests: true, flag: 'accessible' })).toEqual({
+      input: 'accessible',
+      source: 'option',
+      masking: 'host-masked',
+      policyEnforced: false,
+    });
+    expect(resolveCommandInputLane({ command: 'test', runsTests: true, flag: 'accessible' })).toEqual({
+      input: 'accessible',
+      source: 'option',
+      masking: 'verified-masked',
+      policyEnforced: false,
+    });
+    expect(resolveCommandInputLane({ command: 'smoke', runsTests: true, flag: 'physical' })).toEqual({
+      input: 'physical',
+      source: 'option',
+      policyEnforced: false,
+    });
+  });
+
+  test.each([
+    ['flag', { flag: 'both' }, '--input must be accessible or physical.'],
+    ['environment', { environment: 'Physical' }, 'DESKTOP_INPUT must be accessible or physical.'],
+    ['empty flag', { flag: '' }, '--input must be accessible or physical.'],
+    ['empty environment', { environment: '' }, 'DESKTOP_INPUT must be accessible or physical.'],
+  ] as const)('rejects an invalid %s', (_name, request, message) => {
+    expect(() => resolveCommandInputLane({ command: 'test', runsTests: true, ...request })).toThrow(
+      expect.objectContaining({ message, code: 'config' }),
+    );
+  });
+});
+
+describe('driver instance input', () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'storybook-input-lane-'));
+    fs.mkdirSync(path.join(root, 'storybook-desktop.generated'));
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+  const write = (contents: string) =>
+    fs.writeFileSync(path.join(root, 'storybook-desktop.generated', 'driver-manifest.win32.json'), contents);
+
+  test('reads the lane a driver instance was started for', () => {
+    write(JSON.stringify({ wdio: { input: 'accessible' } }));
+    expect(readDriverInstanceInput(root, 'win32')).toBe('accessible');
+  });
+
+  test.each([
+    ['no lane', JSON.stringify({ wdio: {} })],
+    ['an unknown lane', JSON.stringify({ wdio: { input: 'both' } })],
+    ['no wdio settings', JSON.stringify({})],
+    ['malformed JSON', '{'],
+    ['a non-object manifest', 'null'],
+  ])('declares none for %s', (_name, contents) => {
+    write(contents);
+    expect(readDriverInstanceInput(root, 'win32')).toBeUndefined();
+  });
+
+  test('declares none without a manifest for the endpoint', () => {
+    expect(readDriverInstanceInput(root, 'macos')).toBeUndefined();
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/cli/inputLane.ts b/packages/agentic/storybook-desktop/src/cli/inputLane.ts
new file mode 100644
index 0000000000..8a6e36dd39
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/cli/inputLane.ts
@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
+import { createDesktopInputLane, requestedDesktopInputLane } from '@fluentui-react-native/desktop-test/reporting';
+import type { DesktopInputLaneReport } from '@fluentui-react-native/desktop-test/reporting';
+
+import type { Platforms } from '../config/platforms.js';
+import { desktopStorybookDriverManifestPath, driverManifestInput } from '../driver/driverManifest.js';
+
+export type CommandInputLaneRequest = {
+  command: 'test' | 'smoke';
+  /** `smoke` runs authored tests only in its stories-and-tests mode; a run without tests has no lane to account for. */
+  runsTests: boolean;
+  flag?: string;
+  environment?: string;
+  /** The lane the attached driver instance was started for. Only `test` attaches to one, and only without `--url`. */
+  driverInput?: () => DesktopInputLane | undefined;
+};
+
+/**
+ * The lane a `test` or `smoke` run holds its tests to, and where it came from: `--input`, then `DESKTOP_INPUT`, then
+ * the driver instance `test` attaches to. No lane is compatibility mode, which keeps the behavior from before lanes.
+ * An accessible lane's masking depends on who owns the driver: `smoke` starts it masked, while `test` attaches to one
+ * and verifies the mask before it runs anything.
+ */
+export function resolveCommandInputLane(request: CommandInputLaneRequest): DesktopInputLaneReport | undefined {
+  if (!request.runsTests) return undefined;
+  const masking = request.command === 'smoke' ? 'host-masked' : 'verified-masked';
+  const requested = requestedDesktopInputLane({ flag: request.flag, environment: request.environment });
+  if (requested) return createDesktopInputLane(requested.input, requested.source, masking);
+  const input = request.driverInput?.();
+  return input ? createDesktopInputLane(input, 'driver', masking) : undefined;
+}
+
+/** The lane the running driver instance for an endpoint declares. A missing or unreadable manifest declares none. */
+export function readDriverInstanceInput(projectRoot: string, platform: Platforms): DesktopInputLane | undefined {
+  try {
+    return driverManifestInput(JSON.parse(fs.readFileSync(desktopStorybookDriverManifestPath(projectRoot, platform), 'utf8')));
+  } catch {
+    return undefined;
+  }
+}
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
index da8b2d0bac..c07b9ee7b2 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
@@ -4,10 +4,13 @@ import path from 'node:path';
 
 import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
 import type { DesktopStoryRunResult } from '@fluentui-react-native/desktop-driver/authoring';
+import { validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopReportWriter } from '@fluentui-react-native/desktop-test/reporting';
 
 import { makeDesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { runWdioStoryTests } from '../testing/runWdioTests.js';
 import { WdioStoryTestRunError } from '../testing/runWdioTests.js';
+import { csfTestId } from '../testing/selection.js';
 import {
   formatDesktopStorybookSmokeTestSummary,
   runDesktopStorybookSmokeTests,
@@ -31,6 +34,32 @@ function story(id: string, wdio = false): DesktopStoryManifestEntry {
   };
 }
 
+function declaredStory(id: string, cases: readonly (readonly [name: string, options: unknown])[]): DesktopStoryManifestEntry {
+  return {
+    ...story(id),
+    tests: undefined,
+    wdio: {
+      exportName: 'Default',
+      digest: 'callback',
+      testNames: cases.map(([name]) => name),
+      cases: cases.map(([name, descriptor]) => ({ name, options: validateDesktopCaseOptions(descriptor) })),
+    },
+  };
+}
+
+function fakeReport(root: string) {
+  const emit = jest.fn();
+  const report = {
+    runId: 'run',
+    root,
+    emit,
+    artifactPath: (name: string) => path.join(root, name),
+    failure: jest.fn(),
+    fail: jest.fn(),
+  } as unknown as DesktopReportWriter;
+  return { report, emit };
+}
+
 const manifest: DesktopStoryManifest = {
   endpoint: 'windows',
   entries: [story(buttonId)],
@@ -290,4 +319,99 @@ describe('runDesktopStorybookSmokeTests', () => {
     await expect(runDesktopStorybookSmokeTests(options, connect)).rejects.toThrow('No desktop story tests');
     expect(connect).not.toHaveBeenCalled();
   });
+
+  describe('input lanes', () => {
+    test('announces every selected case up front and runs each story against that announcement', async () => {
+      const { report, emit } = fakeReport(root);
+      options.report = report;
+      options.input = 'accessible';
+      options.scope = { domains: { 'rn.renderer': ['fabric', 'paper'] }, values: { 'rn.renderer': 'fabric' } };
+      options.manifest = {
+        ...manifest,
+        entries: [
+          declaredStory(buttonId, [
+            ['plain', {}],
+            ['typed', { requires: ['keyboard'] }],
+          ]),
+          declaredStory(inputId, [['typing', { requires: ['accessibility-click'] }]]),
+        ],
+      };
+      const runWdio: jest.MockedFunction<typeof runWdioStoryTests> = jest.fn(async ({ story }) => [
+        { storyId: story!, testName: 'ran', status: 'passed' as const, durationMs: 1 },
+      ]);
+
+      await runDesktopStorybookSmokeTests(options, jest.fn(), runWdio);
+
+      const events = emit.mock.calls.map(([event]) => event);
+      expect(events.filter(({ kind }) => kind === 'selection')).toEqual([
+        { kind: 'selection', payload: { excluded: { platform: 0, scope: 0, input: 1 } } },
+      ]);
+      expect(events.filter(({ kind }) => kind === 'work-selected').map(({ payload }) => payload.workId)).toEqual([
+        `smoke:${buttonId}`,
+        `smoke:${inputId}`,
+        csfTestId(buttonId, 'plain'),
+        csfTestId(inputId, 'typing'),
+      ]);
+      expect(runWdio).toHaveBeenCalledWith(
+        expect.objectContaining({ story: buttonId, input: 'accessible', scope: options.scope, announced: true, optional: true }),
+        undefined,
+      );
+    });
+
+    test('rejects legacy callbacks before connecting', async () => {
+      options.input = 'physical';
+      options.manifest = { ...manifest, entries: [{ ...story(buttonId, true), tests: undefined }] };
+      const connect = jest.fn();
+      await expect(runDesktopStorybookSmokeTests(options, connect)).rejects.toThrow(
+        `Input lane "physical" cannot run legacy wdio callbacks; declare them with desktopIt: ${buttonId}.`,
+      );
+      expect(connect).not.toHaveBeenCalled();
+    });
+
+    test('states a lane selection that left every case out and explains why', async () => {
+      const { report, emit } = fakeReport(root);
+      options.report = report;
+      options.input = 'accessible';
+      options.manifest = { ...manifest, entries: [declaredStory(buttonId, [['typed', { requires: ['keyboard'] }]])] };
+      await expect(runDesktopStorybookSmokeTests(options, jest.fn())).rejects.toThrow(
+        'No desktop story tests matched the smoke selection (excluded 0 by platform, 0 by scope, 1 by input).',
+      );
+      expect(emit).toHaveBeenCalledWith({ kind: 'selection', payload: { excluded: { platform: 0, scope: 0, input: 1 } } });
+    });
+
+    test('a lane that executed no wdio test is not a passing run even when static plans passed', async () => {
+      options.input = 'accessible';
+      options.manifest = { ...manifest, entries: [{ ...story(buttonId), wdio: declaredStory(buttonId, [['plain', {}]]).wdio }] };
+      const connect: DesktopStorybookSmokeConnector = async () => ({
+        delete: async () => undefined,
+        listStories: async () => options.manifest,
+        runStoryTests: async () => planResult(),
+      });
+      const runWdio = jest.fn(async () => [
+        { storyId: buttonId, testName: 'plain', status: 'unsupported' as const, gap: 'unsupported' as const, durationMs: 0 },
+      ]);
+      await expect(runDesktopStorybookSmokeTests(options, connect, runWdio)).rejects.toThrow(
+        'Input lane "accessible" executed no wdio story tests; it is not a passing run.',
+      );
+    });
+  });
+
+  test('does not pass a cohort that only skipped or was unsupported', async () => {
+    options.manifest = { ...manifest, entries: [{ ...story(buttonId, true), tests: undefined }] };
+    const runWdio = jest.fn(async () => [
+      { storyId: buttonId, status: 'unsupported' as const, gap: 'unsupported' as const, durationMs: 0 },
+    ]);
+    await expect(runDesktopStorybookSmokeTests(options, jest.fn(), runWdio)).rejects.toThrow('only skipped or unsupported');
+  });
+
+  test('breaks unsupported down in the summary only when something is unsupported', () => {
+    const wdio = [{ storyId: buttonId, status: 'passed' as const, durationMs: 1 }];
+    expect(formatDesktopStorybookSmokeTestSummary({ ...planResult(), wdio })).toBe('Ran 2 desktop story tests (2 passed, 0 skipped).');
+    expect(
+      formatDesktopStorybookSmokeTestSummary({
+        ...planResult(),
+        wdio: [...wdio, { storyId: inputId, status: 'unsupported' as const, gap: 'unsupported' as const, durationMs: 0 }],
+      }),
+    ).toBe('Ran 3 desktop story tests (2 passed, 0 skipped, 1 unsupported (1 declared, 0 quarantined)).');
+  });
 });
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
index afa53f720f..c45a586c70 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
@@ -12,7 +12,9 @@ import type { DesktopWebdriverOptions, DesktopWebdriverSession } from '@fluentui
 import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { Platforms } from '../config/platforms.js';
 import { resolveWdioOptions } from '../config/wdio.js';
-import { runWdioStoryTests, selectWdioStories, WdioStoryTestRunError, type WdioStoryTestResult } from '../testing/runWdioTests.js';
+import { describeWdioCounts, hasExecutedWdioCase } from '../testing/laneVerdict.js';
+import { runWdioStoryTests, WdioStoryTestRunError, type WdioStoryTestResult } from '../testing/runWdioTests.js';
+import { decideWdioSelection, describeWdioExclusions, plannedWdioWork, type WdioSelectionContext } from '../testing/selection.js';
 import { writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 import type { DesktopCommandRunner } from './commandRunner.js';
 
@@ -22,6 +24,8 @@ export type DesktopStorybookSmokeConnector = (options: DesktopWebdriverOptions)
 
 export type DesktopStorybookSmokeTestOptions = {
   input?: 'accessible' | 'physical';
+  /** The scope domains and values of this target, for case `scope` selection. */
+  scope?: WdioSelectionContext['scope'];
   artifactsRoot?: string;
   config: DesktopStorybookConfig;
   driverUrl: string;
@@ -60,10 +64,16 @@ export async function runDesktopStorybookSmokeTests(
   const planStoryIds = new Set(
     selectDesktopStoryTests(manifest, platform, { story: storyPattern, tag: testTag ?? 'desktop-e2e' }).map(({ entry }) => entry.id),
   );
-  const wdioStoryIds = new Set(selectWdioStories(manifest, wdioSettings, platform).map(({ id }) => id));
+  const wdioSelection = decideWdioSelection(manifest, wdioSettings, { platform, scope: options.scope });
+  const wdioStoryIds = new Set(wdioSelection.stories.map(({ id }) => id));
+  const { platform: byPlatform, scope: byScope, input: byInput } = wdioSelection.excluded;
+  // A lane always states what it excluded, even when nothing; compatibility mode only when something was excluded.
+  if (options.report && (wdioSettings.input || byPlatform + byScope + byInput > 0)) {
+    options.report.emit({ kind: 'selection', payload: { excluded: wdioSelection.excluded } });
+  }
   const storyIds = [...new Set([...planStoryIds, ...wdioStoryIds])].sort();
   if (storyIds.length === 0) {
-    throw new Error('No desktop story tests matched the smoke selection.');
+    throw new Error(`No desktop story tests matched the smoke selection${describeWdioExclusions(wdioSelection)}.`);
   }
   const artifacts = new ArtifactManager(
     options.artifactsRoot ??
@@ -77,6 +87,8 @@ export async function runDesktopStorybookSmokeTests(
   const failures: unknown[] = [];
   const staticFailures = new Map<string, Error>();
   for (const storyId of storyIds) options.report?.emit({ kind: 'work-selected', payload: { workId: `smoke:${storyId}`, label: storyId } });
+  // Every selected case is announced up front, so a fail-fast stop leaves the remaining cases accounted for as not run.
+  for (const payload of plannedWdioWork(wdioSelection, wdioSettings)) options.report?.emit({ kind: 'work-selected', payload });
 
   for (const storyId of storyIds) {
     const scope = `smoke:${storyId}`;
@@ -106,6 +118,7 @@ export async function runDesktopStorybookSmokeTests(
                 config,
                 manifest,
                 platform,
+                scope: options.scope,
                 story: storyId,
                 targetId: options.targetId,
                 url: options.driverUrl,
@@ -113,6 +126,7 @@ export async function runDesktopStorybookSmokeTests(
                 report: options.report,
                 signal: options.signal,
                 optional: true,
+                announced: true,
               },
               options.commandRunner,
             )),
@@ -154,9 +168,18 @@ export async function runDesktopStorybookSmokeTests(
     }
     failures.push(new Error('Executable smoke tests reported failures.'));
   }
-  const allSkipped = tests.length + wdio.length > 0 && [...tests, ...wdio].every(({ status }) => status === 'skipped');
+  const allSkipped =
+    tests.length + wdio.length > 0 && [...tests, ...wdio].every(({ status }) => status === 'skipped' || status === 'unsupported');
   if (allSkipped && failures.length === 0)
-    failures.push(new Error('Required desktop smoke cohort only skipped tests; it is not a passing run.'));
+    failures.push(new Error('Required desktop smoke cohort only skipped or unsupported tests; it is not a passing run.'));
+  // Smoke runs one story at a time as optional, so the lane's requirement to execute something is judged for the cohort here.
+  if (wdioSettings.input && failures.length === 0 && !hasExecutedWdioCase(wdio)) {
+    failures.push(
+      new Error(
+        `Input lane "${wdioSettings.input}" executed no wdio story tests${describeWdioExclusions(wdioSelection)}; it is not a passing run.`,
+      ),
+    );
+  }
   const result: DesktopStorybookSmokeTestResult = {
     endpoint: platform,
     finishedAt: new Date().toISOString(),
@@ -289,9 +312,7 @@ async function runStoryPlans(
 
 export function formatDesktopStorybookSmokeTestSummary(result: DesktopStorybookSmokeTestResult): string {
   const results = [...result.tests, ...(result.wdio ?? [])];
-  const passed = results.filter(({ status }) => status === 'passed').length;
-  const skipped = results.filter(({ status }) => status === 'skipped').length;
-  return `Ran ${results.length} desktop story tests (${passed} passed, ${skipped} skipped).`;
+  return `Ran ${results.length} desktop story tests (${describeWdioCounts(results)}).`;
 }
 
 function errorMessage(error: unknown): string {
diff --git a/packages/agentic/storybook-desktop/src/config/integration.ts b/packages/agentic/storybook-desktop/src/config/integration.ts
index 3d1b8f00c3..6bf1071cde 100644
--- a/packages/agentic/storybook-desktop/src/config/integration.ts
+++ b/packages/agentic/storybook-desktop/src/config/integration.ts
@@ -32,7 +32,7 @@ export function storybook(options: DesktopStorybookConfigOptions = {}): Storyboo
     configure(projectRoot, desktop) {
       return new DesktopStorybookConfig({ ...options, projectRoot }, desktop);
     },
-    async run({ config, target, supervisor, action, agent, reporterMode, onReady }) {
+    async run({ config, target, supervisor, action, agent, input, reporterMode, onReady }) {
       const { DesktopStorybookCli } = await import('@fluentui-react-native/storybook-desktop/cli');
       const api = new DesktopStorybookCli(this.configure(config.projectRoot, config), {
         paper: target.endpoint === 'macos' && target.host.renderer === 'paper',
@@ -43,7 +43,7 @@ export function storybook(options: DesktopStorybookConfigOptions = {}): Storyboo
         ...(onReady ? { onReady } : {}),
       });
       if (action === 'serve') await api.driver(target.endpoint, agent ? { agent } : {});
-      else if (action === 'test') await api.smoke(target.endpoint, { mode: 'stories-and-tests' });
+      else if (action === 'test') await api.smoke(target.endpoint, { mode: 'stories-and-tests', ...(input ? { input } : {}) });
       else await api[action](target.endpoint);
     },
   };
diff --git a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
index f65a554091..b61e6f19e6 100644
--- a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
+++ b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
@@ -116,8 +116,11 @@ export type DesktopStorybookConfigOptions = StorySettings & {
    */
   platformOptions?: DesktopPlatformOptionsMap;
 
-  /** Defaults for executable story callbacks, run by `storybook-desktop test`. */
-  wdio?: DesktopStorybookWdioOptions;
+  /**
+   * Defaults for executable story callbacks, run by `storybook-desktop test`. The input lane is chosen per run with
+   * `--input` or `DESKTOP_INPUT`, so it cannot be configured here.
+   */
+  wdio?: Omit<DesktopStorybookWdioOptions, 'input'>;
 };
 
 export type ResolvedPackage = {
@@ -532,6 +535,10 @@ function defaultSmokeOptions(config: DesktopStorybookConfig, platform: Platforms
 }
 
 function normalizeConfig(config: DesktopStorybookConfigOptions, projectRoot: string): DesktopStorybookConfigOptions {
+  // A configured lane would run tests the report session never holds to a lane, so the lane has one per-run source.
+  if (config.wdio && 'input' in config.wdio) {
+    throw new TypeError('wdio.input is chosen per run with --input or DESKTOP_INPUT; it cannot be configured.');
+  }
   const wdio = resolveWdioOptions(config.wdio);
   validatePlatforms(config.platforms, 'config');
   validatePlatformSettings(config.platformSettings, 'config');
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.test.ts b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
index 996fdf90c4..e275ae5b52 100644
--- a/packages/agentic/storybook-desktop/src/config/wdio.test.ts
+++ b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
@@ -25,6 +25,11 @@ describe('Storybook-owned wdio configuration', () => {
     expect(() => resolveWdioOptions({ tag: ' ' })).toThrow('wdio.tag');
   });
 
+  test('rejects a configured input lane, which is chosen per run', () => {
+    // @ts-expect-error `input` is not a configurable default.
+    expect(() => makeDesktopStorybookConfig({ wdio: { input: 'accessible' } })).toThrow('wdio.input is chosen per run');
+  });
+
   test('resolves an explicit input lane and rejects conflicting click configuration', () => {
     const previous = process.env.DESKTOP_INPUT;
     delete process.env.DESKTOP_INPUT;
diff --git a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
index 69dd15764d..3e4ac5b7a0 100644
--- a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
@@ -3,12 +3,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import type { DesktopStoryManifest, NativeDesktopApplicationDescriptor, NativeDriverArtifact } from '@fluentui-react-native/desktop-driver';
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
 import { selectDesktopRenderer } from '@fluentui-react-native/desktop-test/config';
 
 import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { DesktopStorybookInstance } from '../config/instance.js';
 import type { Platforms } from '../config/platforms.js';
 import type { DesktopStorybookWdioOptions } from '../config/wdio.js';
+import type { WdioSelectionContext } from '../testing/selection.js';
 
 /** Asks the channel service to protect its driver with a grant authority and publish one agent's connection. */
 export type DesktopStorybookAgentManifest = {
@@ -43,6 +45,11 @@ export type DesktopStorybookDriverManifest = {
   portablePlanDigest: string;
   renderer: 'fabric' | 'paper';
   schemaVersion: 2;
+  /**
+   * The scope domains and the values this target holds, which declared test `scope` selection reads. The driver's
+   * CLI resolves them from the full desktop configuration, which a smoke control process does not have.
+   */
+  scope?: NonNullable<WdioSelectionContext['scope']>;
   storyManifest: DesktopStoryManifest;
   storybookPort: number;
   targetId: string;
@@ -58,6 +65,7 @@ export type CreateDesktopStorybookDriverManifestOptions = {
   nativeDriver: NativeDriverArtifact;
   platform: Platforms;
   renderer?: DesktopStorybookDriverManifest['renderer'];
+  scope?: DesktopStorybookDriverManifest['scope'];
   storyManifest: DesktopStoryManifest;
   wdio?: DesktopStorybookWdioOptions;
 };
@@ -81,6 +89,7 @@ export function createDesktopStorybookDriverManifest({
   nativeDriver,
   platform,
   renderer = platform === 'win32' ? 'paper' : 'fabric',
+  scope,
   storyManifest,
   wdio,
 }: CreateDesktopStorybookDriverManifestOptions): DesktopStorybookDriverManifest {
@@ -119,6 +128,9 @@ export function createDesktopStorybookDriverManifest({
     portablePlanDigest: storyManifest.portablePlanDigest,
     renderer,
     schemaVersion: 2,
+    ...(scope
+      ? { scope: Object.freeze({ domains: Object.freeze({ ...scope.domains }), values: Object.freeze({ ...scope.values }) }) }
+      : {}),
     storyManifest,
     storybookPort: instance.storybookPort,
     targetId: desktopStorybookTargetId(config, platform, renderer),
@@ -136,3 +148,15 @@ export function writeDesktopStorybookDriverManifest(manifest: DesktopStorybookDr
     fs.writeFileSync(outputPath, content);
   }
 }
+
+/** Where the running driver instance for an endpoint publishes its manifest. */
+export function desktopStorybookDriverManifestPath(projectRoot: string, platform: Platforms): string {
+  return path.join(projectRoot, 'storybook-desktop.generated', `driver-manifest.${platform}.json`);
+}
+
+/** The input lane a driver instance was started for, read from any parsed manifest; absent when it declares none. */
+export function driverManifestInput(manifest: unknown): DesktopInputLane | undefined {
+  const wdio = typeof manifest === 'object' && manifest !== null && 'wdio' in manifest ? manifest.wdio : undefined;
+  const input = typeof wdio === 'object' && wdio !== null && 'input' in wdio ? wdio.input : undefined;
+  return input === 'accessible' || input === 'physical' ? input : undefined;
+}
diff --git a/packages/agentic/storybook-desktop/src/driver/serverIntegration.test.ts b/packages/agentic/storybook-desktop/src/driver/serverIntegration.test.ts
index bdea026b70..c7bf96822d 100644
--- a/packages/agentic/storybook-desktop/src/driver/serverIntegration.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/serverIntegration.test.ts
@@ -94,6 +94,64 @@ describe('desktop Storybook server integration', () => {
     expect(output.join('')).toContain('WebDriver ');
   });
 
+  test.each([
+    ['accessible', { keyboard: false, physicalClick: false, wheel: false }],
+    ['physical', { keyboard: true, physicalClick: true, wheel: true }],
+  ] as const)('starts a driver for the %s input lane with matching physical input features', async (input, expected) => {
+    const [storybookPort, driverPort] = await Promise.all([getAvailablePort(), getAvailablePort()]);
+    const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-storybook-driver-'));
+    const manifestPath = path.join(temporaryDirectory, 'driver-manifest.json');
+    const projectRoot = path.resolve(__dirname, '../../../../../apps/storybook');
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify({ ...createIntegrationManifest(temporaryDirectory, storybookPort, driverPort), wdio: { input } }),
+    );
+    const sink = { write: () => true };
+    const reporter = new DesktopRunReporter({
+      artifactsRoot: temporaryDirectory,
+      kind: 'lifecycle',
+      output: sink,
+      errorOutput: sink,
+      summary: false,
+    });
+    const transport = await startReportTransport(reporter);
+    const runner = new NodeDesktopCommandRunner({ reporter, environment: transport.environment });
+    const child = runner.start({
+      command: process.execPath,
+      args: [path.resolve(__dirname, '../../config/server-runner.cjs')],
+      cwd: projectRoot,
+      env: {
+        STORYBOOK_CONFIG_PATH: path.join(projectRoot, 'src'),
+        STORYBOOK_DRIVER_MANIFEST: manifestPath,
+        STORYBOOK_NATIVE_DRIVER_FAKE: '1',
+        STORYBOOK_PROJECT_ROOT: projectRoot,
+        STORYBOOK_SMOKE_MODE: 'stories-and-tests',
+        STORYBOOK_WS_PORT: String(storybookPort),
+      },
+    });
+
+    try {
+      await waitForResponse(loopbackUrl(driverPort, '/status'));
+      const client = createDesktopDriverClient({ url: loopbackUrl(driverPort, '') });
+      const session = await client.newSession({
+        alwaysMatch: { platformName: 'windows', 'furn:target': 'integration-windows', 'furn:launchMode': 'attach' },
+      });
+      // The accessible lane trusts this report, so the driver itself must show physical input disabled.
+      expect(session.capabilities['furn:features']).toMatchObject(expected);
+      await session.delete();
+    } finally {
+      try {
+        await child.stop();
+        await child.completed;
+        await runner.close();
+        await transport.close();
+        await reporter.finish();
+      } finally {
+        fs.rmSync(temporaryDirectory, { force: true, recursive: true });
+      }
+    }
+  });
+
   test('refuses an agent connection from the fake driver', async () => {
     const [storybookPort, driverPort] = await Promise.all([getAvailablePort(), getAvailablePort()]);
     const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-storybook-driver-'));
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
index 0a5ff18bb4..16766657bb 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -285,4 +285,115 @@ describe('extractWdioTests', () => {
     expect(digest(source.replace("'test'", "'changed'"))).not.toBe(digest(source));
     expect(digest(source.replace('console.log', '/* source change */ console.log'))).not.toBe(digest(source));
   });
+
+  describe('direct physical input', () => {
+    const desktopCase = (body: string, options?: string) =>
+      `import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
+      export const Example = { wdio: [desktopIt('case', ${options === undefined ? '' : `${options}, `}async (context) => { const { browser } = context; ${body} })] };`;
+    const key = `{ type: 'key', id: 'keyboard', actions: [{ type: 'keyDown', value: 'a' }] }`;
+    const pointer = `{ type: 'pointer', id: 'mouse', actions: [{ type: 'pointerMove', x: 1, y: 1 }] }`;
+    const wheel = `{ type: 'wheel', id: 'wheel', actions: [{ type: 'scroll', deltaY: 10 }] }`;
+    const pause = `{ type: 'none', id: 'pause', actions: [{ type: 'pause', duration: 100 }] }`;
+
+    test.each([
+      ['browser.keys', `await browser.keys('a');`, /browser\.keys sends physical keyboard input.*requires: \['keyboard'\]/],
+      ['an optional browser.keys', `await browser?.keys('a');`, /browser\.keys sends physical keyboard input/],
+      ['a computed browser.keys', `await browser['keys']('a');`, /browser\.keys sends physical keyboard input/],
+      ['a keys call through the context', `await context.browser.keys('a');`, /browser\.keys sends physical keyboard input/],
+      ['setValue', `await (await browser.$('~input')).setValue('a');`, /setValue sends physical keyboard input/],
+      ['addValue', `await (await browser.$('~input')).addValue('a');`, /addValue sends physical keyboard input/],
+      ['clearValue', `await (await browser.$('~input')).clearValue();`, /clearValue sends physical keyboard input/],
+      ['key actions', `await browser.performActions([${key}]);`, /performActions sends physical keyboard input/],
+      ['pointer actions', `await browser.performActions([${pointer}]);`, /sends physical pointer input.*requires: \['physical-click'\]/],
+      ['wheel actions', `await browser.performActions([${wheel}]);`, /sends physical wheel input.*requires: \['wheel'\]/],
+      [
+        'actions with several physical sources',
+        `await browser.performActions([${wheel}, ${pause}, ${key}]);`,
+        /sends physical keyboard and wheel input.*requires: \['keyboard', 'wheel'\]/,
+      ],
+      [
+        'actions held in a constant',
+        `const actions = [${pointer}]; await browser.performActions(actions);`,
+        /sends physical pointer input/,
+      ],
+      ['an action builder', `await browser.action('key').down('a').perform();`, /browser\.action sends physical keyboard input/],
+      [
+        'a call inside a nested function',
+        `await browser.waitUntil(async () => { await browser.keys('a'); return true; });`,
+        /browser\.keys sends physical keyboard input/,
+      ],
+      [
+        'actions built elsewhere',
+        `const buildActions = () => []; await browser.performActions(buildActions());`,
+        /performActions with an argument this check cannot read/,
+      ],
+      ['actions held in a variable that changes', `let actions = []; actions = [1]; await browser.performActions(actions);`, /cannot read/],
+      ['actions with a spread source', `const sources = []; await browser.performActions([...sources]);`, /cannot read/],
+      [
+        'actions with a source that has a spread',
+        `const source = {}; await browser.performActions([{ ...source, id: 'a' }]);`,
+        /cannot read/,
+      ],
+      ['actions without an argument', `await browser.performActions();`, /cannot read/],
+      [
+        'an action builder with a variable type',
+        `await browser.action(context.type).perform();`,
+        /browser\.action with an argument this check cannot read/,
+      ],
+    ])('rejects %s in a case that also runs in the accessible lane', (_name, body, message) => {
+      expect(() => extractWdioTests(desktopCase(body), sourceFile)).toThrow(message);
+    });
+
+    test.each([
+      ['an explicit both', `{ input: 'both' }`],
+      ['an explicit accessible case', `{ input: 'accessible' }`],
+      ['an accessibility click', `{ requires: ['accessibility-click'] }`],
+      ['neutral requirements', `{ requires: ['click', 'focus'] }`],
+    ])('rejects the keyboard in %s with the case name and source location', (_name, options) => {
+      let error: Error | undefined;
+      try {
+        extractWdioTests(desktopCase(`await browser.keys('a');`, options), sourceFile);
+      } catch (caught) {
+        error = caught as Error;
+      }
+      expect(error?.message).toContain('"case" runs in the accessible input lane');
+      expect(error?.message).toContain(sourceFile);
+    });
+
+    test('suggests the declaration that matches how the case chose its input', () => {
+      expect(() => extractWdioTests(desktopCase(`await browser.keys('a');`, `{ input: 'both' }`), sourceFile)).toThrow(
+        /Declare input: 'physical'/,
+      );
+      expect(() => extractWdioTests(desktopCase(`await browser.keys('a');`), sourceFile)).toThrow(/Declare requires: \['keyboard'\]/);
+    });
+
+    test.each([
+      ['derives physical from keyboard', `{ requires: ['keyboard'] }`],
+      ['derives physical from a physical click', `{ requires: ['physical-click', 'wheel'] }`],
+      ['declares physical', `{ input: 'physical' }`],
+    ])('allows direct input in a case that %s', (_name, options) => {
+      const body = `await browser.keys('a'); await (await browser.$('~input')).setValue('a'); await browser.performActions([${key}, ${pointer}, ${wheel}]);`;
+      expect(() => extractWdioTests(desktopCase(body, options), sourceFile)).not.toThrow();
+    });
+
+    test('allows calls that do not send physical input', () => {
+      const body = `
+        const names = Object.keys({ a: 1 });
+        const map = new Map([[1, 2]]);
+        for (const entry of map.keys()) names.push(String(entry));
+        await browser.performActions([${pause}]);
+        await browser.performActions([]);
+        const store = { setValueLater: () => {} };
+        store.setValueLater();
+        await (await browser.$('~button')).click();
+      `;
+      expect(() => extractWdioTests(desktopCase(body), sourceFile)).not.toThrow();
+    });
+
+    test('does not read legacy callbacks, which declare no input', () => {
+      expect(() =>
+        extractWdioTests(`export const Example = { wdio: { legacy: async ({ browser }) => { await browser.keys('a'); } } };`, sourceFile),
+      ).not.toThrow();
+    });
+  });
 });
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
index 58e2eaf30f..4bf2066810 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -6,7 +6,7 @@ import type { ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-
 
 import storyTests from '../../config/transform-story-tests.cjs';
 
-const { collectWdioTests, compileWdioTest } = storyTests;
+const { collectWdioTests, compileWdioTest, rejectDirectInput } = storyTests;
 
 export type ExtractedWdioStory = {
   digest: string;
@@ -26,11 +26,18 @@ export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<
         visitor: {
           Program(program: NodePath<types.Program>) {
             for (const [exportName, { callbacks, value }] of collectWdioTests(program)) {
-              const compiled = callbacks.map(({ callback, name, options }) => ({
-                ...(name === undefined ? {} : { name }),
-                code: compileWdioTest(callback, sourceFile, code),
-                ...(options !== undefined ? { options: validateDesktopCaseOptions(options, `${sourceFile}.wdio`) } : {}),
-              }));
+              const compiled = callbacks.map(({ callback, name, options }) => {
+                const compiledCode = compileWdioTest(callback, sourceFile, code);
+                const descriptor = options === undefined ? undefined : validateDesktopCaseOptions(options, `${sourceFile}.wdio`);
+                if (descriptor !== undefined) {
+                  rejectDirectInput(callback, { name, input: descriptor.input, inputSource: descriptor.inputSource });
+                }
+                return {
+                  ...(name === undefined ? {} : { name }),
+                  code: compiledCode,
+                  ...(descriptor === undefined ? {} : { options: descriptor }),
+                };
+              });
               const source = code.slice(value.node.start!, value.node.end!);
               tests.set(exportName, {
                 tests: compiled,
diff --git a/packages/agentic/storybook-desktop/src/testing/laneVerdict.test.ts b/packages/agentic/storybook-desktop/src/testing/laneVerdict.test.ts
new file mode 100644
index 0000000000..845858dd7f
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/laneVerdict.test.ts
@@ -0,0 +1,75 @@
+import { assessWdioCohort, hasExecutedWdioCase, describeWdioCounts, type WdioCaseOutcome } from './laneVerdict.js';
+
+const result = (testName: string, status: WdioCaseOutcome['status'], gap?: WdioCaseOutcome['gap']): WdioCaseOutcome => ({
+  storyId: 'story',
+  testName,
+  status,
+  ...(gap ? { gap } : {}),
+});
+
+describe('WDIO cohort verdict', () => {
+  test('a compatibility cohort needs one executed test unless it is optional', () => {
+    expect(assessWdioCohort({ results: [result('a', 'passed'), result('b', 'skipped')], selected: 2 })).toMatchObject({
+      executed: true,
+      incomplete: false,
+    });
+    expect(assessWdioCohort({ results: [result('a', 'skipped')], selected: 1 })).toMatchObject({
+      incomplete: true,
+      message: expect.stringContaining('no selected test executed'),
+    });
+    expect(assessWdioCohort({ results: [result('a', 'unsupported')], selected: 1 })).toMatchObject({ incomplete: true });
+    expect(assessWdioCohort({ results: [result('a', 'unsupported')], selected: 1, optional: true })).toMatchObject({ incomplete: false });
+    expect(assessWdioCohort({ results: [result('a', 'passed'), result('b', 'unsupported')], selected: 2 })).toMatchObject({
+      incomplete: false,
+    });
+  });
+
+  test('a lane rejects a skip and an undeclared unsupported result, and names them', () => {
+    for (const status of ['skipped', 'unsupported'] as const) {
+      expect(assessWdioCohort({ results: [result('a', 'passed'), result('b', status)], selected: 2, lane: 'accessible' })).toMatchObject({
+        executed: true,
+        incomplete: true,
+        message: expect.stringContaining('the accessible lane could not run 1 selected tests that have no declared gap (story / b)'),
+      });
+    }
+  });
+
+  test('a lane accepts declared gaps and optional never masks an undeclared one', () => {
+    const declared = [result('a', 'passed'), result('b', 'unsupported', 'unsupported'), result('c', 'unsupported', 'quarantine')];
+    expect(assessWdioCohort({ results: declared, selected: 3, lane: 'physical' })).toMatchObject({ incomplete: false });
+    expect(
+      assessWdioCohort({ results: [result('a', 'unsupported', 'unsupported')], selected: 1, lane: 'physical', optional: true }),
+    ).toMatchObject({ executed: false, incomplete: false });
+    expect(assessWdioCohort({ results: [result('a', 'unsupported')], selected: 1, lane: 'physical', optional: true })).toMatchObject({
+      incomplete: true,
+    });
+    expect(assessWdioCohort({ results: [result('a', 'unsupported', 'unsupported')], selected: 1, lane: 'physical' })).toMatchObject({
+      incomplete: true,
+      message: expect.stringContaining('no selected test executed'),
+    });
+  });
+
+  test('selected work that never finished is incomplete in every mode', () => {
+    expect(assessWdioCohort({ results: [result('a', 'passed')], selected: 3 })).toMatchObject({
+      incomplete: true,
+      message: expect.stringContaining('2 of 3 selected tests did not finish'),
+    });
+  });
+
+  test('counts only passes and failures as executed', () => {
+    expect(hasExecutedWdioCase([result('a', 'skipped'), result('b', 'unsupported')])).toBe(false);
+    expect(hasExecutedWdioCase([result('a', 'failed')])).toBe(true);
+  });
+
+  test('summarizes counts and breaks unsupported down only when present', () => {
+    expect(describeWdioCounts([result('a', 'passed'), result('b', 'skipped')])).toBe('1 passed, 1 skipped');
+    expect(
+      describeWdioCounts([
+        result('a', 'passed'),
+        result('b', 'unsupported', 'unsupported'),
+        result('c', 'unsupported', 'quarantine'),
+        result('d', 'unsupported'),
+      ]),
+    ).toBe('1 passed, 0 skipped, 3 unsupported (1 declared, 1 quarantined)');
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/laneVerdict.ts b/packages/agentic/storybook-desktop/src/testing/laneVerdict.ts
new file mode 100644
index 0000000000..e33f24a8fc
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/laneVerdict.ts
@@ -0,0 +1,72 @@
+import type { DesktopInputLane } from '@fluentui-react-native/desktop-driver/authoring';
+import { describeDesktopUnsupported } from '@fluentui-react-native/desktop-test/reporting';
+
+export type WdioCaseOutcome = {
+  storyId: string;
+  testName?: string;
+  status: 'passed' | 'failed' | 'skipped' | 'unsupported';
+  gap?: 'unsupported' | 'quarantine';
+};
+
+export type WdioCohortVerdict = {
+  /** At least one selected case ran to a pass or a failure. */
+  executed: boolean;
+  incomplete: boolean;
+  /** Why the cohort is incomplete. */
+  message?: string;
+};
+
+export function hasExecutedWdioCase(results: readonly Pick<WdioCaseOutcome, 'status'>[]): boolean {
+  return results.some(({ status }) => status === 'passed' || status === 'failed');
+}
+
+/** Counts for a summary line. The unsupported breakdown appears only when something is unsupported, so other summaries are unchanged. */
+export function describeWdioCounts(results: readonly { status: string; gap?: WdioCaseOutcome['gap'] }[]): string {
+  const count = (status: string) => results.filter((result) => result.status === status).length;
+  const parts = [`${count('passed')} passed`, `${count('skipped')} skipped`];
+  const unsupported = results.filter(({ status }) => status === 'unsupported');
+  if (unsupported.length) {
+    parts.push(
+      describeDesktopUnsupported({
+        unsupported: unsupported.length,
+        declaredUnsupported: unsupported.filter(({ gap }) => gap === 'unsupported').length,
+        quarantined: unsupported.filter(({ gap }) => gap === 'quarantine').length,
+      }),
+    );
+  }
+  return parts.join(', ');
+}
+
+/**
+ * A cohort is incomplete when selected work did not finish, or when nothing executed and it is not `optional`. In an
+ * input lane a run-time skip, or an `unsupported` result with no declared gap, is also incomplete, and `optional` never
+ * masks it: only a declaration may excuse a case the lane selected. A cohort that is all declared gaps is the caller's
+ * to judge, because a smoke run executes one story at a time and so cannot require every story to run something.
+ */
+export function assessWdioCohort(options: {
+  results: readonly WdioCaseOutcome[];
+  selected: number;
+  lane?: DesktopInputLane;
+  optional?: boolean;
+}): WdioCohortVerdict {
+  const { results, selected, lane, optional } = options;
+  const executed = hasExecutedWdioCase(results);
+  const undeclared = lane
+    ? results.filter(({ status, gap }) => status === 'skipped' || (status === 'unsupported' && gap === undefined))
+    : [];
+  const reasons: string[] = [];
+  if (results.length !== selected) reasons.push(`${selected - results.length} of ${selected} selected tests did not finish`);
+  if (undeclared.length) {
+    const names = undeclared.slice(0, 5).map(({ storyId, testName }) => (testName === undefined ? storyId : `${storyId} / ${testName}`));
+    const more = undeclared.length > names.length ? `, and ${undeclared.length - names.length} more` : '';
+    reasons.push(
+      `the ${lane} lane could not run ${undeclared.length} selected tests that have no declared gap (${names.join(', ')}${more})`,
+    );
+  }
+  if (!executed && !optional) reasons.push('no selected test executed');
+  return {
+    executed,
+    incomplete: reasons.length > 0,
+    ...(reasons.length ? { message: `Required executable story cohort is incomplete: ${reasons.join('; ')}.` } : {}),
+  };
+}
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts
deleted file mode 100644
index 5860dd8e4f..0000000000
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
-import type { DesktopStoryManifest } from '@fluentui-react-native/desktop-driver';
-
-import { missingRequirements, resolveCaseClickMode, selectWdioCases, selectWdioStories } from './runWdioTests.js';
-
-describe('WDIO input lane selection', () => {
-  const manifest: DesktopStoryManifest = {
-    endpoint: 'win32',
-    entries: [
-      {
-        id: 'button',
-        name: 'Button',
-        packageName: 'components',
-        sourcePath: 'button.stories.tsx',
-        tags: ['story'],
-        title: 'Button',
-        wdio: {
-          digest: 'digest',
-          exportName: 'Default',
-          testNames: ['adaptive', 'accessible', 'win32-only'],
-          cases: [
-            { name: 'adaptive', options: validateDesktopCaseOptions({ requires: ['click'] }) },
-            { name: 'accessible', options: validateDesktopCaseOptions({ requires: ['accessibility-click'] }) },
-            { name: 'win32-only', options: validateDesktopCaseOptions({ platforms: ['win32'] }) },
-          ],
-        },
-      },
-    ],
-    platformManifestDigest: 'digest',
-    portablePlanDigest: 'digest',
-    schemaVersion: 1,
-  };
-
-  test('selects by modality and target platform', () => {
-    expect(selectWdioStories(manifest, { input: 'accessible' }, 'win32').map(({ id }) => id)).toEqual(['button']);
-    expect(selectWdioCases(manifest.entries[0], { input: 'accessible' }, 'win32')?.map(({ name }) => name)).toEqual([
-      'adaptive',
-      'accessible',
-      'win32-only',
-    ]);
-    expect(selectWdioCases(manifest.entries[0], {}, 'macos')?.map(({ name }) => name)).toEqual(['adaptive', 'accessible']);
-    expect(selectWdioCases(manifest.entries[0], { input: 'physical' }, 'win32')?.map(({ name }) => name)).toEqual([
-      'adaptive',
-      'win32-only',
-    ]);
-    expect(selectWdioCases(manifest.entries[0], { input: 'physical', test: 'accessible' }, 'macos')).toEqual([]);
-    expect(selectWdioCases(manifest.entries[0], { input: 'physical', test: 'win32-only' }, 'macos')).toEqual([]);
-  });
-
-  test('rejects legacy callback entries in a lane', () => {
-    const legacy = {
-      ...manifest,
-      entries: [{ ...manifest.entries[0], wdio: { digest: 'legacy', exportName: 'Default', testNames: ['legacy'] } }],
-    } satisfies DesktopStoryManifest;
-    expect(() => selectWdioStories(legacy, { input: 'physical' }, 'win32')).toThrow('declare it with desktopIt');
-  });
-
-  test('adapts click requirements to each lane without fallback', () => {
-    const descriptor = validateDesktopCaseOptions({ requires: ['click'] });
-    const accessibleMode = resolveCaseClickMode(descriptor, 'auto', 'accessible');
-    const physicalMode = resolveCaseClickMode(descriptor, 'auto', 'physical');
-    expect(accessibleMode).toBe('accessibility');
-    expect(physicalMode).toBe('physical');
-    expect(missingRequirements(descriptor, { accessibilityClick: true, physicalClick: false }, physicalMode)).toEqual(['click']);
-    expect(missingRequirements(descriptor, { accessibilityClick: false, physicalClick: true }, accessibleMode)).toEqual(['click']);
-    expect(missingRequirements(descriptor, { accessibilityClick: true }, accessibleMode)).toEqual([]);
-  });
-});
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
index 8ed1c3a371..524bd88ae3 100644
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -3,9 +3,13 @@ import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 
-import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
-import { matchesDesktopPlatforms } from '@fluentui-react-native/desktop-driver/authoring';
-import type { DesktopArtifact, DesktopInputLane, ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopStoryManifest } from '@fluentui-react-native/desktop-driver';
+import {
+  missingDesktopRequirements,
+  resolveDesktopClickMode,
+  unmaskedAccessibleFeatures,
+  type DesktopArtifact,
+} from '@fluentui-react-native/desktop-driver/authoring';
 import { ArtifactManager, captureDesktopFailureEvidence } from '@fluentui-react-native/desktop-driver/artifacts';
 import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopReportWriter } from '@fluentui-react-native/desktop-test/reporting';
@@ -16,6 +20,15 @@ import type { Platforms } from '../config/platforms.js';
 import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
 import { NodeDesktopCommandRunner, type DesktopCommandRunner, type PreparedDesktopCommand } from '../cli/commandRunner.js';
 import { extractWdioTests } from './extractWdioTests.js';
+import { assessWdioCohort } from './laneVerdict.js';
+import {
+  csfTestId,
+  decideWdioSelection,
+  describeWdioExclusions,
+  matchesWdioTest,
+  plannedWdioWork,
+  type WdioSelectionContext,
+} from './selection.js';
 import type { WdioWorkerOptions } from './worker.js';
 import { formatDesktopStorybookError, writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 
@@ -35,6 +48,8 @@ export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
   config: DesktopStorybookConfig;
   manifest: DesktopStoryManifest;
   platform: Platforms;
+  /** The scope domains and values of this target, for case `scope` selection. */
+  scope?: WdioSelectionContext['scope'];
   targetId: string;
   url: string;
   artifactsRoot?: string;
@@ -42,6 +57,8 @@ export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
   report?: DesktopReportWriter;
   signal?: AbortSignal;
   optional?: boolean;
+  /** The caller already reported the selection and announced the planned work, so this call must not repeat it. */
+  announced?: boolean;
 };
 
 export class WdioStoryTestRunError extends Error {
@@ -61,36 +78,13 @@ class MissingRequirementsError extends Error {
   }
 }
 
-export function selectWdioStories(
-  manifest: DesktopStoryManifest,
-  options: DesktopStorybookWdioOptions,
-  platform?: Platforms,
-): readonly DesktopStoryManifestEntry[] {
-  return manifest.entries
-    .filter((entry) => entry.wdio && (!options.story || path.matchesGlob(entry.id, options.story)))
-    .filter((entry) => !options.tag || entry.tags.includes(options.tag))
-    .filter((entry) => {
-      if (options.input || entry.wdio?.cases) return (selectWdioCases(entry, options, platform)?.length ?? 0) > 0;
-      return (entry.wdio?.testNames ?? ['default']).some((name) => matchesWdioTest(name, options.test));
-    })
-    .sort((left, right) => left.id.localeCompare(right.id));
-}
-
-export function selectWdioCases(
-  entry: DesktopStoryManifestEntry,
-  options: DesktopStorybookWdioOptions,
-  platform?: Platforms,
-): NonNullable<DesktopStoryManifestEntry['wdio']>['cases'] {
-  if (!entry.wdio?.cases?.length) {
-    if (!options.input) return undefined;
-    throw new Error(`Input lane "${options.input}" cannot run legacy wdio callback in "${entry.id}"; declare it with desktopIt.`);
+/** The driver cannot show it disabled physical input, so an accessible lane could not keep its guarantee. */
+class UnmaskedLaneError extends Error {
+  constructor(unmasked: readonly string[]) {
+    super(
+      `The accessible input lane needs a driver that reports ${unmasked.join(', ')} disabled, and this one does not. Start it with "driver --input accessible".`,
+    );
   }
-  return entry.wdio.cases.filter(
-    ({ name, options: descriptor }) =>
-      matchesWdioTest(name, options.test) &&
-      (!platform || matchesDesktopPlatforms(descriptor.platforms, platform)) &&
-      (!options.input || descriptor.input === 'both' || descriptor.input === options.input),
-  );
 }
 
 export async function runWdioStoryTests(
@@ -98,31 +92,37 @@ export async function runWdioStoryTests(
   runner?: DesktopCommandRunner,
 ): Promise<readonly WdioStoryTestResult[]> {
   const settings = resolveWdioOptions(options);
-  const stories = selectWdioStories(options.manifest, settings, options.platform);
-  if (stories.length === 0) {
-    throw new Error('No executable wdio story tests matched the requested selection.');
+  const selection = decideWdioSelection(options.manifest, settings, { platform: options.platform, scope: options.scope });
+  const planned = plannedWdioWork(selection, settings);
+  const { platform: byPlatform, scope: byScope, input: byInput } = selection.excluded;
+  // Reported before any empty-selection error so the exclusions are accounted for. A lane always states them,
+  // even when nothing was excluded; compatibility mode only when it excluded something.
+  if (!options.announced && options.report && (settings.input || byPlatform + byScope + byInput > 0)) {
+    options.report.emit({ kind: 'selection', payload: { excluded: selection.excluded } });
+  }
+  if (selection.stories.length === 0) {
+    throw new Error(`No executable wdio story tests matched the requested selection${describeWdioExclusions(selection)}.`);
   }
-  const cases = stories.flatMap((entry) => {
+  const cases = selection.stories.flatMap((entry) => {
     const sourceFile = path.join(options.config.resolvePackage(entry.packageName).root, entry.sourcePath);
     const extracted = extractWdioTests(fs.readFileSync(sourceFile, 'utf8'), sourceFile).get(entry.wdio!.exportName);
     if (!extracted || extracted.digest !== entry.wdio!.digest) {
       throw new Error(`Executable test source changed for ${entry.id}; regenerate the Storybook manifest.`);
     }
-    const selectedCases = selectWdioCases(entry, settings, options.platform);
+    const declared = selection.selected.get(entry.id);
     return extracted.tests
       .filter(({ name }) => matchesWdioTest(name ?? 'default', settings.test))
-      .map(({ name, code }) => ({
-        entry,
-        code,
-        testName: name,
-        descriptor: entry.wdio?.cases?.find((testCase) => testCase.name === name)?.options,
-      }))
-      .filter(({ testName }) => {
-        if (!selectedCases) return !settings.input;
-        return selectedCases.some(({ name }) => name === testName);
+      .flatMap(({ name, code }) => {
+        const decision = name === undefined ? undefined : declared?.get(name);
+        if (declared && !decision) return [];
+        return [{ entry, code, testName: name, descriptor: decision?.descriptor, gap: decision?.gap }];
       });
   });
   if (cases.length === 0) throw new Error('No executable wdio tests matched the requested selection.');
+  const plannedIds = new Set(planned.map(({ workId }) => workId));
+  if (cases.length !== plannedIds.size || cases.some(({ entry, testName }) => !plannedIds.has(csfTestId(entry.id, testName)))) {
+    throw new Error('The executable tests differ from the selected manifest cases; regenerate the Storybook manifest.');
+  }
   const artifacts = new ArtifactManager(
     options.artifactsRoot ??
       (options.report
@@ -135,11 +135,7 @@ export async function runWdioStoryTests(
   ).href;
   const results: WdioStoryTestResult[] = [];
   const executionFailures: unknown[] = [];
-  for (const { entry, testName } of cases)
-    options.report?.emit({
-      kind: 'work-selected',
-      payload: { workId: csfTestId(entry.id, testName), label: `${entry.id} / ${testName ?? 'default'}` },
-    });
+  if (!options.announced) for (const payload of planned) options.report?.emit({ kind: 'work-selected', payload });
   const ownedRunner = runner ? undefined : new NodeDesktopCommandRunner({ reporter: options.report });
   const commands = runner ?? ownedRunner!;
   let directory: string | undefined;
@@ -151,7 +147,7 @@ export async function runWdioStoryTests(
   try {
     fs.mkdirSync(generatedRoot, { recursive: true });
     directory = fs.mkdtempSync(path.join(generatedRoot, 'run-'));
-    for (const [index, { entry, code, testName, descriptor }] of cases.entries()) {
+    for (const [index, { entry, code, testName, descriptor, gap }] of cases.entries()) {
       options.signal?.throwIfAborted();
       const displayName = testName === undefined ? entry.id : `${entry.id} / ${testName}`;
       const artifactId =
@@ -171,7 +167,6 @@ export async function runWdioStoryTests(
       const context = { story: entry.id, test: testName ?? 'default', endpoint: options.platform };
       options.report?.emit({ kind: 'scope-start', payload: { label: displayName, category: 'worker' } }, testId, context, testId);
       options.report?.emit({ kind: 'test-start', payload: { testId, title: displayName, attempt: 0 } }, testId, context);
-      const gap = descriptor && declaredGapFor(descriptor, options.platform, settings.input);
       if (gap) {
         result.status = 'unsupported';
         result.skipReason = gap.reason;
@@ -181,7 +176,15 @@ export async function runWdioStoryTests(
         options.report?.emit(
           {
             kind: 'test-result',
-            payload: { testId, title: displayName, attempt: 0, status: 'unsupported', durationMs: result.durationMs, reason: gap.reason },
+            payload: {
+              testId,
+              title: displayName,
+              attempt: 0,
+              status: 'unsupported',
+              durationMs: result.durationMs,
+              reason: gap.reason,
+              gap: gap.kind,
+            },
           },
           testId,
           context,
@@ -190,7 +193,7 @@ export async function runWdioStoryTests(
         activeResult = undefined;
         continue;
       }
-      const clickMode = resolveCaseClickMode(descriptor, settings.clickMode, settings.input);
+      const clickMode = resolveDesktopClickMode(descriptor, settings.clickMode, settings.input);
       // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
       const desktop = await connectDesktopWebdriver({
         clickMode,
@@ -206,7 +209,13 @@ export async function runWdioStoryTests(
         if (live.endpoint !== options.platform || live.platformManifestDigest !== options.manifest.platformManifestDigest) {
           throw new Error('The running Storybook manifest is stale or targets a different platform. Restart storybook driver and the app.');
         }
-        const missing = missingRequirements(descriptor, desktop.browser.capabilities['furn:features'], clickMode);
+        if (settings.input === 'accessible') {
+          // A driver that cannot report its physical input disabled fails closed rather than silently running unmasked.
+          phase = 'lane verification';
+          const unmasked = unmaskedAccessibleFeatures(desktop.browser.capabilities['furn:features']);
+          if (unmasked.length) throw new UnmaskedLaneError(unmasked);
+        }
+        const missing = missingDesktopRequirements(descriptor, desktop.browser.capabilities['furn:features'], clickMode);
         if (missing.length) throw new MissingRequirementsError(missing);
         phase = 'navigation';
         await desktop.openStory(entry.id);
@@ -263,6 +272,8 @@ export async function runWdioStoryTests(
         if (error instanceof MissingRequirementsError) {
           result.status = 'unsupported';
           result.skipReason = error.message;
+        } else if (error instanceof UnmaskedLaneError) {
+          failure = error;
         } else {
           failure = error;
           executionFailures.push(error);
@@ -298,6 +309,11 @@ export async function runWdioStoryTests(
           `Could not release the wdio session for ${displayName}; stopping before another test starts.`,
         );
       }
+      // Every case would fail the same way, so stop here and let the run report it once, against this case.
+      if (failure instanceof UnmaskedLaneError) {
+        phase = 'lane verification';
+        throw failure;
+      }
       result.durationMs = Date.now() - started;
       results.push(result);
       options.report?.emit(
@@ -348,14 +364,9 @@ export async function runWdioStoryTests(
   }
   const failures: unknown[] = infrastructureFailure === undefined ? [] : [infrastructureFailure];
   failures.push(...executionFailures);
-  const allSkipped = results.every(({ status }) => status === 'skipped');
-  const laneIncomplete =
-    !!settings.input &&
-    (!results.some(({ status }) => status === 'passed' || status === 'failed') ||
-      results.some(({ status, gap }) => status === 'skipped' || (status === 'unsupported' && gap === undefined)));
-  const incomplete = results.length !== cases.length || (allSkipped && !options.optional) || laneIncomplete;
-  if (incomplete && failures.length === 0)
-    failures.push(new Error('Required executable story cohort did not execute any tests or left selected work unfinished.'));
+  const verdict = assessWdioCohort({ results, selected: cases.length, lane: settings.input, optional: options.optional });
+  const incomplete = verdict.incomplete;
+  if (incomplete && failures.length === 0) failures.push(new Error(verdict.message));
   try {
     const reportPath = artifacts.writeMetadata('run', {
       endpoint: options.platform,
@@ -364,9 +375,9 @@ export async function runWdioStoryTests(
         ? incomplete && executionFailures.length === 0 && infrastructureFailure === undefined
           ? 'incomplete'
           : 'failed'
-        : allSkipped
-          ? 'skipped'
-          : 'passed',
+        : verdict.executed
+          ? 'passed'
+          : 'skipped',
       ...(infrastructureFailure === undefined ? {} : { error: errorMessage(infrastructureFailure) }),
       tests: results,
     });
@@ -407,85 +418,6 @@ function isWorkerResult(value: unknown): value is WorkerResult {
   );
 }
 
-export function matchesWdioTest(name: string, pattern?: string): boolean {
-  return pattern === undefined || path.matchesGlob(name, pattern);
-}
-
-function csfTestId(storyId: string, testName?: string): string {
-  return `csf-${createHash('sha256')
-    .update(JSON.stringify([storyId, testName ?? 'default']))
-    .digest('hex')}`;
-}
-
-export function resolveCaseClickMode(
-  descriptor: ResolvedDesktopCaseOptions | undefined,
-  configured: 'auto' | 'physical' | 'accessibility',
-  input: DesktopInputLane | undefined,
-): 'auto' | 'physical' | 'accessibility' {
-  if (input === 'accessible') return 'accessibility';
-  if (input === 'physical') return 'physical';
-  if (descriptor?.input === 'accessible' || descriptor?.requires?.includes('accessibility-click')) return 'accessibility';
-  if (descriptor?.input === 'physical') return 'physical';
-  return configured;
-}
-
-export function missingRequirements(
-  descriptor: ResolvedDesktopCaseOptions | undefined,
-  features: Readonly<Record<string, unknown>> | undefined,
-  clickMode: 'auto' | 'physical' | 'accessibility',
-): string[] {
-  if (!descriptor?.requires?.length) return [];
-  const missing: string[] = [];
-  for (const requirement of descriptor.requires) {
-    const feature =
-      requirement === 'click'
-        ? clickMode === 'physical'
-          ? 'physicalClick'
-          : clickMode === 'accessibility'
-            ? 'accessibilityClick'
-            : undefined
-        : requirement === 'physical-click'
-          ? 'physicalClick'
-          : requirement === 'accessibility-click'
-            ? 'accessibilityClick'
-            : requirement === 'accessibility-actions'
-              ? 'accessibilityActions'
-              : requirement === 'element-screenshot'
-                ? 'elementScreenshot'
-                : requirement === 'set-window-rect'
-                  ? 'setWindowRect'
-                  : requirement;
-    if (requirement === 'click' && clickMode === 'auto') {
-      if (!features?.physicalClick && !features?.accessibilityClick) missing.push(requirement);
-    } else if (feature && features?.[feature] !== true) {
-      missing.push(requirement);
-    }
-  }
-  return missing;
-}
-
-function declaredGapFor(
-  descriptor: ResolvedDesktopCaseOptions,
-  endpoint: Platforms,
-  input: DesktopInputLane | undefined,
-): { kind: 'unsupported' | 'quarantine'; reason: string } | undefined {
-  if (descriptor.unsupported && matchesDesktopPlatforms(descriptor.unsupported.platforms, endpoint)) {
-    return { kind: 'unsupported', reason: descriptor.unsupported.reason };
-  }
-  const quarantine = descriptor.quarantine;
-  if (
-    quarantine &&
-    (!quarantine.platforms || matchesDesktopPlatforms(quarantine.platforms, endpoint)) &&
-    (!quarantine.input || quarantine.input === input)
-  ) {
-    if (Date.parse(`${quarantine.expires}T00:00:00Z`) < Date.now()) {
-      throw new Error(`Quarantine ${quarantine.issue} expired on ${quarantine.expires}.`);
-    }
-    return { kind: 'quarantine', reason: `${quarantine.issue}: ${quarantine.reason}` };
-  }
-  return undefined;
-}
-
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
diff --git a/packages/agentic/storybook-desktop/src/testing/selection.test.ts b/packages/agentic/storybook-desktop/src/testing/selection.test.ts
new file mode 100644
index 0000000000..847a27062e
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/selection.test.ts
@@ -0,0 +1,301 @@
+import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
+import { resolveDesktopScopeDomains, validateDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+
+import {
+  csfTestId,
+  decideWdioSelection,
+  describeWdioExclusions,
+  listWdioSelection,
+  plannedWdioWork,
+  type WdioSelection,
+} from './selection.js';
+
+type DeclaredCase = readonly [name: string, options: unknown];
+
+function declared(id: string, cases: readonly DeclaredCase[], tags: string[] = ['story']): DesktopStoryManifestEntry {
+  return {
+    id,
+    name: id,
+    packageName: 'components',
+    sourcePath: `${id}.stories.tsx`,
+    tags,
+    title: id,
+    wdio: {
+      digest: 'digest',
+      exportName: 'Default',
+      testNames: cases.map(([name]) => name),
+      cases: cases.map(([name, options]) => ({ name, options: validateDesktopCaseOptions(options) })),
+    },
+  };
+}
+
+function legacy(id: string, testNames?: string[]): DesktopStoryManifestEntry {
+  return {
+    id,
+    name: id,
+    packageName: 'components',
+    sourcePath: `${id}.stories.tsx`,
+    tags: ['story'],
+    title: id,
+    wdio: { digest: 'legacy', exportName: 'Default', ...(testNames ? { testNames } : {}) },
+  };
+}
+
+function manifestOf(...entries: DesktopStoryManifestEntry[]): DesktopStoryManifest {
+  return { endpoint: 'win32', entries, platformManifestDigest: 'digest', portablePlanDigest: 'digest', schemaVersion: 1 };
+}
+
+const selectedNames = (selection: WdioSelection, id = 'button') => [...(selection.selected.get(id)?.keys() ?? [])];
+
+const button = declared('button', [
+  ['adaptive', { requires: ['click'] }],
+  ['accessible', { requires: ['accessibility-click'] }],
+  ['win32-only', { platforms: ['win32'] }],
+]);
+
+describe('WDIO selection', () => {
+  test('selects by input lane and target platform', () => {
+    const manifest = manifestOf(button);
+    expect(selectedNames(decideWdioSelection(manifest, { input: 'accessible' }, { platform: 'win32' }))).toEqual([
+      'adaptive',
+      'accessible',
+      'win32-only',
+    ]);
+    expect(selectedNames(decideWdioSelection(manifest, {}, { platform: 'macos' }))).toEqual(['adaptive', 'accessible']);
+    expect(selectedNames(decideWdioSelection(manifest, { input: 'physical' }, { platform: 'win32' }))).toEqual(['adaptive', 'win32-only']);
+  });
+
+  test('records every decision with its first exclusion reason', () => {
+    const selection = decideWdioSelection(manifestOf(button), { input: 'physical' }, { platform: 'macos' });
+    expect(selection.decisions.map(({ name, excluded }) => [name, excluded])).toEqual([
+      ['adaptive', undefined],
+      ['accessible', 'input'],
+      ['win32-only', 'platform'],
+    ]);
+    expect(selection.excluded).toEqual({ platform: 1, scope: 0, input: 1 });
+  });
+
+  test('counts exclusions only among the cases the user filters selected', () => {
+    const manifest = manifestOf(button, declared('other', [['unrelated', { platforms: ['win32'] }]]));
+    const byTest = decideWdioSelection(manifest, { input: 'physical', test: 'accessible' }, { platform: 'macos' });
+    expect(byTest.stories).toEqual([]);
+    expect(byTest.excluded).toEqual({ platform: 0, scope: 0, input: 1 });
+    const byStory = decideWdioSelection(manifest, { input: 'physical', story: 'button', test: 'win32-only' }, { platform: 'macos' });
+    expect(byStory.excluded).toEqual({ platform: 1, scope: 0, input: 0 });
+    expect(describeWdioExclusions(byStory)).toBe(' (excluded 1 by platform, 0 by scope, 0 by input)');
+    expect(describeWdioExclusions(decideWdioSelection(manifest, {}, { platform: 'win32' }))).toBe('');
+  });
+
+  test('excludes by platform, then scope, then input', () => {
+    const layered = manifestOf(
+      declared('layered', [['all', { platforms: ['win32'], scope: { 'rn.renderer': ['paper'] }, requires: ['keyboard'] }]]),
+    );
+    const decide = (platform: 'macos' | 'win32', renderer: string) =>
+      decideWdioSelection(
+        layered,
+        { input: 'accessible' },
+        { platform, scope: { domains: resolveDesktopScopeDomains(), values: { 'rn.renderer': renderer } } },
+      );
+    expect(decide('macos', 'fabric').excluded).toEqual({ platform: 1, scope: 0, input: 0 });
+    expect(decide('win32', 'fabric').excluded).toEqual({ platform: 0, scope: 1, input: 0 });
+    expect(decide('win32', 'paper').excluded).toEqual({ platform: 0, scope: 0, input: 1 });
+  });
+
+  test('scopes cases by a value the target holds, including custom domains', () => {
+    const domains = resolveDesktopScopeDomains({ 'product.flavor': ['alpha', 'beta'] });
+    const scoped = manifestOf(
+      declared('scoped', [
+        ['paper-only', { scope: { 'rn.renderer': ['paper'] } }],
+        ['beta-only', { scope: { 'product.flavor': ['beta'] } }],
+        ['both-keys', { scope: { 'rn.renderer': ['paper', 'fabric'], 'product.flavor': ['alpha'] } }],
+      ]),
+    );
+    const values = (renderer: string, flavor: string) => ({ domains, values: { 'rn.renderer': renderer, 'product.flavor': flavor } });
+    expect(selectedNames(decideWdioSelection(scoped, {}, { platform: 'win32', scope: values('paper', 'beta') }), 'scoped')).toEqual([
+      'paper-only',
+      'beta-only',
+    ]);
+    expect(selectedNames(decideWdioSelection(scoped, {}, { platform: 'win32', scope: values('fabric', 'alpha') }), 'scoped')).toEqual([
+      'both-keys',
+    ]);
+  });
+
+  test('treats a scope key the target does not supply as a configuration error rather than an exclusion', () => {
+    const scoped = manifestOf(declared('scoped', [['paper-only', { scope: { 'rn.renderer': ['paper'] } }]]));
+    expect(() => decideWdioSelection(scoped, {}, { platform: 'win32' })).toThrow('is not supplied by this target');
+    const custom = manifestOf(declared('scoped', [['flavored', { scope: { 'product.flavor': ['beta'] } }]]));
+    expect(() =>
+      decideWdioSelection(custom, {}, { platform: 'win32', scope: { domains: resolveDesktopScopeDomains(), values: {} } }),
+    ).toThrow('unknown scope key "product.flavor"');
+    const outside = manifestOf(declared('scoped', [['bogus', { scope: { 'rn.renderer': ['bogus'] } }]]));
+    expect(() =>
+      decideWdioSelection(
+        outside,
+        {},
+        { platform: 'win32', scope: { domains: resolveDesktopScopeDomains(), values: { 'rn.renderer': 'paper' } } },
+      ),
+    ).toThrow('is not one of: fabric, paper');
+  });
+
+  test('does not evaluate the scope of a case another platform already excluded', () => {
+    const scoped = manifestOf(declared('scoped', [['win32-paper', { platforms: ['win32'], scope: { 'rn.renderer': ['paper'] } }]]));
+    expect(decideWdioSelection(scoped, {}, { platform: 'macos' }).excluded).toEqual({ platform: 1, scope: 0, input: 0 });
+  });
+
+  test('filters by story glob and tag and orders stories by id', () => {
+    const manifest = manifestOf(
+      declared('zeta', [['a', {}]], ['wide']),
+      declared('alpha', [['a', {}]], ['wide']),
+      declared('middle', [['a', {}]], ['narrow']),
+    );
+    expect(decideWdioSelection(manifest, {}, { platform: 'win32' }).stories.map(({ id }) => id)).toEqual(['alpha', 'middle', 'zeta']);
+    expect(decideWdioSelection(manifest, { tag: 'wide' }, { platform: 'win32' }).stories.map(({ id }) => id)).toEqual(['alpha', 'zeta']);
+    expect(decideWdioSelection(manifest, { story: 'm*' }, { platform: 'win32' }).stories.map(({ id }) => id)).toEqual(['middle']);
+  });
+
+  describe('legacy callbacks', () => {
+    test('run in compatibility mode when a name matches the test filter', () => {
+      const manifest = manifestOf(legacy('plain'), legacy('named', ['first', 'second']), declared('button', [['a', {}]]));
+      expect(decideWdioSelection(manifest, {}, { platform: 'win32' }).stories.map(({ id }) => id)).toEqual(['button', 'named', 'plain']);
+      expect(decideWdioSelection(manifest, { test: 'sec*' }, { platform: 'win32' }).stories.map(({ id }) => id)).toEqual(['named']);
+      expect(decideWdioSelection(manifest, { test: 'nothing' }, { platform: 'win32' }).stories).toEqual([]);
+    });
+
+    test('are rejected together in a lane so one pass migrates them', () => {
+      const manifest = manifestOf(legacy('b-legacy'), legacy('a-legacy', ['first']), declared('button', [['a', {}]]));
+      expect(() => decideWdioSelection(manifest, { input: 'physical' }, { platform: 'win32' })).toThrow(
+        'Input lane "physical" cannot run legacy wdio callbacks; declare them with desktopIt: a-legacy, b-legacy.',
+      );
+    });
+
+    test('are ignored in a lane when the test filter names nothing they define, and summarized past ten', () => {
+      const many = Array.from({ length: 12 }, (_, index) => legacy(`legacy-${String(index).padStart(2, '0')}`));
+      expect(() => decideWdioSelection(manifestOf(...many), { input: 'accessible' }, { platform: 'win32' })).toThrow(
+        /legacy-00, legacy-01.*legacy-09, and 2 more\.$/,
+      );
+      expect(decideWdioSelection(manifestOf(...many), { input: 'accessible', test: 'absent' }, { platform: 'win32' }).stories).toEqual([]);
+    });
+  });
+
+  describe('declared gaps', () => {
+    const gapped = manifestOf(
+      declared('gapped', [
+        ['unsupported', { unsupported: { platforms: ['win32'], reason: 'No host support.' } }],
+        ['quarantined', { quarantine: { issue: '#9', reason: 'flaky', expires: '2026-01-01' } }],
+        ['physical-quarantine', { quarantine: { issue: '#10', reason: 'drifts', expires: '2026-01-01', input: 'physical' } }],
+      ]),
+    );
+    const before = Date.parse('2025-12-31T00:00:00Z');
+
+    test('are resolved at selection time for the cases that run', () => {
+      const win32 = decideWdioSelection(gapped, { input: 'physical' }, { platform: 'win32', now: before });
+      expect([...win32.selected.get('gapped')!.values()].map(({ name, gap }) => [name, gap])).toEqual([
+        ['unsupported', { kind: 'unsupported', reason: 'No host support.' }],
+        ['quarantined', { kind: 'quarantine', reason: '#9: flaky' }],
+        ['physical-quarantine', { kind: 'quarantine', reason: '#10: drifts' }],
+      ]);
+      const macos = decideWdioSelection(gapped, { input: 'accessible' }, { platform: 'macos', now: before });
+      expect([...macos.selected.get('gapped')!.values()].map(({ name, gap }) => [name, gap?.kind])).toEqual([
+        ['unsupported', undefined],
+        ['quarantined', 'quarantine'],
+        ['physical-quarantine', undefined],
+      ]);
+    });
+
+    test('stop the run before anything executes once a quarantine expires', () => {
+      expect(() => decideWdioSelection(gapped, {}, { platform: 'win32', now: Date.parse('2026-06-01T00:00:00Z') })).toThrow(
+        'Quarantine #9 expired on 2026-01-01.',
+      );
+    });
+
+    test('are not evaluated for a case the lane already excluded', () => {
+      const excludedByLane = manifestOf(
+        declared('gapped', [
+          ['accessible', { requires: ['accessibility-click'], quarantine: { issue: '#9', reason: 'old', expires: '2020-01-01' } }],
+        ]),
+      );
+      expect(decideWdioSelection(excludedByLane, { input: 'physical' }, { platform: 'win32' }).excluded.input).toBe(1);
+    });
+  });
+
+  test('plans the work each selected case announces, legacy included', () => {
+    const manifest = manifestOf(
+      declared('button', [
+        ['adaptive', {}],
+        ['physical', { requires: ['keyboard'] }],
+      ]),
+      legacy('named', ['x', 'y']),
+    );
+    const planned = plannedWdioWork(decideWdioSelection(manifest, {}, { platform: 'win32' }), {});
+    expect(planned).toEqual([
+      { workId: csfTestId('button', 'adaptive'), label: 'button / adaptive' },
+      { workId: csfTestId('button', 'physical'), label: 'button / physical' },
+      { workId: csfTestId('named', 'x'), label: 'named / x' },
+      { workId: csfTestId('named', 'y'), label: 'named / y' },
+    ]);
+    const filtered = plannedWdioWork(decideWdioSelection(manifest, { test: 'y' }, { platform: 'win32' }), { test: 'y' });
+    expect(filtered.map(({ label }) => label)).toEqual(['named / y']);
+    const lane = plannedWdioWork(decideWdioSelection(manifestOf(manifest.entries[0]), { input: 'accessible' }, { platform: 'win32' }), {});
+    expect(lane.map(({ label }) => label)).toEqual(['button / adaptive']);
+  });
+
+  test('names a legacy callback without a declared name "default"', () => {
+    const planned = plannedWdioWork(decideWdioSelection(manifestOf(legacy('plain')), {}, { platform: 'win32' }), {});
+    expect(planned).toEqual([{ workId: csfTestId('plain', 'default'), label: 'plain / default' }]);
+    expect(csfTestId('plain')).toBe(csfTestId('plain', 'default'));
+  });
+
+  describe('listing', () => {
+    const listed = manifestOf(
+      declared('button', [
+        ['adaptive', { requires: ['click'] }],
+        ['physical', { requires: ['keyboard'], platforms: ['win32'] }],
+        ['accessible', { requires: ['accessibility-click'], unsupported: { platforms: ['win32'], reason: 'No host support.' } }],
+      ]),
+      legacy('named', ['first', 'second']),
+      legacy('plain'),
+      declared('only-physical', [['physical', { requires: ['keyboard'] }]]),
+    );
+
+    test('shows the selected cases with their gaps and the excluded cases with their first reason', () => {
+      const selection = decideWdioSelection(listed, { input: 'accessible', story: 'button' }, { platform: 'win32' });
+      expect(selection.stories.map(({ id }) => id)).toEqual(['button']);
+      expect(listWdioSelection(selection, {})).toEqual([
+        {
+          id: 'button',
+          sourcePath: 'button.stories.tsx',
+          tests: [
+            { name: 'adaptive', input: 'both', inputSource: 'derived', requires: ['click'] },
+            {
+              name: 'accessible',
+              input: 'accessible',
+              inputSource: 'derived',
+              requires: ['accessibility-click'],
+              gap: { kind: 'unsupported', reason: 'No host support.' },
+            },
+          ],
+          excluded: [
+            { name: 'physical', input: 'physical', inputSource: 'derived', requires: ['keyboard'], platforms: ['win32'], reason: 'input' },
+          ],
+        },
+      ]);
+    });
+
+    test('lists a legacy callback by its names, or alone when it names none', () => {
+      const selection = decideWdioSelection(listed, { story: '{named,plain}', test: 'sec*' }, { platform: 'macos' });
+      expect(listWdioSelection(selection, { test: 'sec*' })).toEqual([{ id: 'named', sourcePath: 'named.stories.tsx', tests: ['second'] }]);
+      expect(listWdioSelection(decideWdioSelection(listed, { story: 'plain' }, { platform: 'macos' }), {})).toEqual([
+        { id: 'plain', sourcePath: 'plain.stories.tsx' },
+      ]);
+    });
+
+    test('omits excluded when every matching case runs', () => {
+      const [story] = listWdioSelection(decideWdioSelection(listed, { story: 'only-physical' }, { platform: 'win32' }), {});
+      expect(story).toEqual({
+        id: 'only-physical',
+        sourcePath: 'only-physical.stories.tsx',
+        tests: [{ name: 'physical', input: 'physical', inputSource: 'derived', requires: ['keyboard'] }],
+      });
+    });
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/selection.ts b/packages/agentic/storybook-desktop/src/testing/selection.ts
new file mode 100644
index 0000000000..e4ae0f18a5
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/selection.ts
@@ -0,0 +1,194 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
+import { decideDesktopCase, resolveDesktopScopeDomains } from '@fluentui-react-native/desktop-driver/authoring';
+import type {
+  DesktopCaseTarget,
+  DesktopDeclaredGap,
+  DesktopScopeDomains,
+  DesktopScopeValues,
+  ResolvedDesktopCaseOptions,
+} from '@fluentui-react-native/desktop-driver/authoring';
+import type { SelectionExclusions } from '@fluentui-react-native/desktop-test/reporting';
+
+import type { Platforms } from '../config/platforms.js';
+import type { DesktopStorybookWdioOptions } from '../config/wdio.js';
+
+export type WdioSelectionContext = {
+  platform: Platforms;
+  /** The domains and the values this target holds. Without it only the built-in domains exist and no key is supplied. */
+  scope?: { domains: DesktopScopeDomains; values: DesktopScopeValues };
+  /** Clock for quarantine expiry. */
+  now?: number;
+};
+
+export type WdioDeclaredGap = DesktopDeclaredGap;
+
+/** One declared case that matched the user's filters. A case with no `excluded` reason is part of the run. */
+export type WdioCaseDecision = {
+  storyId: string;
+  name: string;
+  descriptor: ResolvedDesktopCaseOptions;
+  /** The first reason, in platform, scope, input order, that this target or lane does not run the case. */
+  excluded?: keyof SelectionExclusions;
+  /** Declared `unsupported` or quarantine; the case is selected but not executed. */
+  gap?: WdioDeclaredGap;
+};
+
+export type WdioSelection = {
+  /** Stories with at least one selected case, or a legacy callback that compatibility mode may run. */
+  stories: readonly DesktopStoryManifestEntry[];
+  /** Every declared case that matched the user's filters, in story and source order. */
+  decisions: readonly WdioCaseDecision[];
+  /** The selected declared cases by story and name. Legacy callbacks are absent. */
+  selected: ReadonlyMap<string, ReadonlyMap<string, WdioCaseDecision>>;
+  /** Only cases that matched the user's filters count, so a narrow `--story` is not blamed for what it never asked for. */
+  excluded: SelectionExclusions;
+};
+
+/**
+ * Decides every case before any session exists. Legacy callbacks run in compatibility mode and are an error in a lane,
+ * where each is listed so they can be migrated in one pass. Declared gaps are resolved here too, so an expired
+ * quarantine stops the run before anything executes.
+ */
+export function decideWdioSelection(
+  manifest: DesktopStoryManifest,
+  options: DesktopStorybookWdioOptions,
+  context: WdioSelectionContext,
+): WdioSelection {
+  const domains = context.scope?.domains ?? resolveDesktopScopeDomains();
+  const target: DesktopCaseTarget = {
+    endpoint: context.platform,
+    ...(options.input ? { lane: options.input } : {}),
+    domains,
+    values: context.scope?.values ?? {},
+    now: context.now,
+  };
+  const stories: DesktopStoryManifestEntry[] = [];
+  const decisions: WdioCaseDecision[] = [];
+  const selected = new Map<string, Map<string, WdioCaseDecision>>();
+  const excluded: SelectionExclusions = { platform: 0, scope: 0, input: 0 };
+  const legacy: string[] = [];
+  const entries = manifest.entries
+    .filter((entry) => entry.wdio && (!options.story || path.matchesGlob(entry.id, options.story)))
+    .filter((entry) => !options.tag || entry.tags.includes(options.tag))
+    .sort((left, right) => left.id.localeCompare(right.id));
+  for (const entry of entries) {
+    const cases = entry.wdio!.cases;
+    if (!cases?.length) {
+      if (!(entry.wdio!.testNames ?? ['default']).some((name) => matchesWdioTest(name, options.test))) continue;
+      if (options.input) legacy.push(entry.id);
+      else stories.push(entry);
+      continue;
+    }
+    const chosen = new Map<string, WdioCaseDecision>();
+    for (const { name, options: descriptor } of cases) {
+      if (!matchesWdioTest(name, options.test)) continue;
+      const outcome = decideDesktopCase(descriptor, target, `${entry.id} / ${name}`);
+      const decision: WdioCaseDecision = { storyId: entry.id, name, descriptor };
+      if (outcome.kind === 'excluded') {
+        decision.excluded = outcome.reason;
+        excluded[outcome.reason]++;
+      } else {
+        if (outcome.kind === 'gap') decision.gap = outcome.gap;
+        chosen.set(name, decision);
+      }
+      decisions.push(decision);
+    }
+    if (chosen.size) {
+      stories.push(entry);
+      selected.set(entry.id, chosen);
+    }
+  }
+  if (legacy.length) {
+    const shown = legacy.slice(0, 10).join(', ');
+    const more = legacy.length > 10 ? `, and ${legacy.length - 10} more` : '';
+    throw new Error(`Input lane "${options.input}" cannot run legacy wdio callbacks; declare them with desktopIt: ${shown}${more}.`);
+  }
+  return { stories, decisions, selected, excluded };
+}
+
+/** The work a selection announces before launch, so work that never starts is still accounted for. */
+export function plannedWdioWork(
+  selection: WdioSelection,
+  options: Pick<DesktopStorybookWdioOptions, 'test'>,
+): readonly { workId: string; label: string }[] {
+  return selection.stories.flatMap((entry) => {
+    const declared = selection.selected.get(entry.id);
+    const names = declared
+      ? [...declared.keys()]
+      : (entry.wdio?.testNames ?? ['default']).filter((name) => matchesWdioTest(name, options.test));
+    return names.map((name) => ({ workId: csfTestId(entry.id, name), label: `${entry.id} / ${name}` }));
+  });
+}
+
+/** One declared case in a `--list` result. */
+export type WdioListedCase = Pick<ResolvedDesktopCaseOptions, 'input' | 'inputSource' | 'platforms' | 'scope'> & {
+  name: string;
+  requires: NonNullable<ResolvedDesktopCaseOptions['requires']>;
+  /** Selected but not executed: a declared `unsupported` entry or an active quarantine. */
+  gap?: WdioDeclaredGap;
+};
+
+export type WdioListedStory = {
+  id: string;
+  sourcePath: string;
+  /** The names of a legacy callback, or the declared cases this target and lane run. */
+  tests?: readonly string[] | readonly WdioListedCase[];
+  /** Declared cases that matched the filters but do not run, each with the first reason it was excluded. */
+  excluded?: readonly (WdioListedCase & { reason: keyof SelectionExclusions })[];
+};
+
+/** What a selection would run, and why each other declared case that matched the filters would not. */
+export function listWdioSelection(selection: WdioSelection, options: Pick<DesktopStorybookWdioOptions, 'test'>): WdioListedStory[] {
+  const decided = new Map<string, WdioCaseDecision[]>();
+  for (const decision of selection.decisions) {
+    const story = decided.get(decision.storyId);
+    if (story) story.push(decision);
+    else decided.set(decision.storyId, [decision]);
+  }
+  return selection.stories.map(({ id, sourcePath, wdio }) => {
+    const decisions = decided.get(id);
+    if (!selection.selected.has(id)) {
+      const names = wdio?.testNames?.filter((name) => matchesWdioTest(name, options.test));
+      return { id, sourcePath, ...(names ? { tests: names } : {}) };
+    }
+    const excluded = decisions!.flatMap((decision) => (decision.excluded ? [{ ...listedCase(decision), reason: decision.excluded }] : []));
+    return {
+      id,
+      sourcePath,
+      tests: decisions!.filter(({ excluded }) => !excluded).map(listedCase),
+      ...(excluded.length ? { excluded } : {}),
+    };
+  });
+}
+
+/** Names what a selection left out, so an empty selection explains itself. Empty when nothing was excluded. */
+export function describeWdioExclusions({ excluded }: Pick<WdioSelection, 'excluded'>): string {
+  const { platform, scope, input } = excluded;
+  return platform + scope + input > 0 ? ` (excluded ${platform} by platform, ${scope} by scope, ${input} by input)` : '';
+}
+
+export function matchesWdioTest(name: string, pattern?: string): boolean {
+  return pattern === undefined || path.matchesGlob(name, pattern);
+}
+
+export function csfTestId(storyId: string, testName?: string): string {
+  return `csf-${createHash('sha256')
+    .update(JSON.stringify([storyId, testName ?? 'default']))
+    .digest('hex')}`;
+}
+
+function listedCase({ name, descriptor, gap }: WdioCaseDecision): WdioListedCase {
+  const { input, inputSource, platforms, scope, requires = [] } = descriptor;
+  return {
+    name,
+    input,
+    inputSource,
+    requires,
+    ...(platforms ? { platforms } : {}),
+    ...(scope ? { scope } : {}),
+    ...(gap ? { gap } : {}),
+  };
+}
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index a8bae915fc..3736a9666e 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -25,6 +25,7 @@ async function main() {
     path.join(root, 'fixture.stories.ts'),
     `
     import 'react-native-must-never-load-in-node';
+    import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
     export default { title: 'Fixture/Button' };
     export const Pass = {
       tags: ['grouped', 'desktop-e2e'],
@@ -88,6 +89,17 @@ async function main() {
         await expect(await browser.$('~button-primary')).toBeEnabled();
       },
     }};
+    export const Lane = { tags: ['desktop-e2e'], wdio: [
+      desktopIt('accessible only', { requires: ['accessibility-click'] }, async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      }),
+      desktopIt('either lane', async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      }),
+      desktopIt('physical only', { requires: ['physical-click'] }, async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      }),
+    ]};
   `,
   );
   const storyPackage = { name: 'inline-fixture', root, manifest: { name: 'inline-fixture' }, storyPatterns: ['*.stories.ts'] };
@@ -326,6 +338,46 @@ async function main() {
     } finally {
       await restrictedButtonHarness.close();
     }
+    const laneResults = (results) => results.map(({ testName, status }) => ({ testName, status }));
+    // The accessible lane trusts the driver's own report, so a driver that does not show physical input disabled fails closed.
+    const unmaskedReport = new DesktopRunReporter({
+      artifactsRoot: path.join(root, 'lane-reports'),
+      lane: { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false },
+      summary: false,
+    });
+    let unmaskedLane;
+    try {
+      await run('lane', { input: 'accessible', report: unmaskedReport });
+      throw new Error('An accessible lane must not run against a driver that reports physical input enabled.');
+    } catch (error) {
+      if (!(error instanceof Error) || !(error instanceof WdioStoryTestRunError) || !('results' in error) || !Array.isArray(error.results))
+        throw error;
+      unmaskedLane = { results: laneResults(error.results), message: error.message };
+    }
+    const unmaskedLaneResult = await unmaskedReport.finish();
+    const maskedHarness = await createDesktopDriverStoryHarness(manifest, {
+      features: { keyboard: false, physicalClick: false, wheel: false },
+    });
+    let accessibleLane;
+    try {
+      accessibleLane = laneResults(
+        await run('lane', { input: 'accessible', targetId: maskedHarness.target.id, url: maskedHarness.server.url }),
+      );
+    } finally {
+      await maskedHarness.close();
+    }
+    const physicalLane = laneResults(await run('lane', { input: 'physical' }));
+    // Without a lane a declared physical case must not pin physical click: a host that masks it reports the case unsupported
+    // rather than failing to create the session, as the skip it replaces did not fail.
+    const unmaskedPhysicalHarness = await createDesktopDriverStoryHarness(manifest, { features: { physicalClick: false } });
+    let compatibilityLane;
+    try {
+      compatibilityLane = laneResults(
+        await run('lane', { targetId: unmaskedPhysicalHarness.target.id, url: unmaskedPhysicalHarness.server.url }),
+      );
+    } finally {
+      await unmaskedPhysicalHarness.close();
+    }
     process.stdout.write(
       '\nWDIO_RESULT ' +
         JSON.stringify({
@@ -338,6 +390,18 @@ async function main() {
           smokeFailureLogged,
           button: button.map(({ testName, status }) => ({ testName, status })),
           restrictedButton: restrictedButton.map(({ testName, status }) => ({ testName, status })),
+          lane: {
+            accessible: accessibleLane,
+            physical: physicalLane,
+            compatibility: compatibilityLane,
+            unmasked: {
+              ...unmaskedLane,
+              status: unmaskedLaneResult.status,
+              failed: unmaskedLaneResult.counts.failed,
+              excluded: unmaskedLaneResult.selection?.excluded,
+              reported: unmaskedLaneResult.failures.map(({ error }) => error.message),
+            },
+          },
           platforms,
           namedFailureResults: namedFailureResults.map(({ testName, status }) => ({ testName, status })),
           namedTimeout,
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index 01a741bdfd..c69d9b8c56 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -23,6 +23,7 @@ test('executes isolated inline code and releases sessions after assertion failur
           !diagnostics.includes('wdio "fixture-button--fail" during execution') ||
           !diagnostics.includes('wdio "fixture-button--navigation-failure" during navigation') ||
           !diagnostics.includes('Storybook context did not settle.') ||
+          !diagnostics.includes('wdio "fixture-button--lane / accessible only" during lane verification') ||
           diagnostics.includes('Navigation refused before dispatch') ||
           output.includes('[storybook] OK wdio "fixture-button--exit-zero"')
         ) {
@@ -55,6 +56,30 @@ test('executes isolated inline code and releases sessions after assertion failur
       { testName: 'exposes enabled button semantics', status: 'passed' },
       { testName: 'supports native pointer activation', status: 'skipped' },
     ],
+    lane: {
+      accessible: [
+        { testName: 'accessible only', status: 'passed' },
+        { testName: 'either lane', status: 'passed' },
+      ],
+      physical: [
+        { testName: 'either lane', status: 'passed' },
+        { testName: 'physical only', status: 'passed' },
+      ],
+      // No lane, and a host that masks physical click: the physical case is unsupported, not a failed session.
+      compatibility: [
+        { testName: 'accessible only', status: 'passed' },
+        { testName: 'either lane', status: 'passed' },
+        { testName: 'physical only', status: 'unsupported' },
+      ],
+      // A driver that does not report physical input disabled stops the lane at its first case, reported once.
+      unmasked: {
+        results: [{ testName: 'accessible only', status: 'failed' }],
+        status: 'failed',
+        failed: 1,
+        excluded: { platform: 0, scope: 0, input: 1 },
+        reported: [expect.stringContaining('driver --input accessible')],
+      },
+    },
     platforms: Object.fromEntries(
       ['macos', 'windows', 'win32'].map((platform) => [
         platform,

From 188114c0d2c526229e717126e8b1b1539c9a4012 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Fri, 6 Nov 2026 20:11:46 -0800
Subject: [PATCH 3/6] Migrate desktop story tests to declared input lanes

Replace remaining component story runtime skips with desktopIt requirements, platform scopes and declared gaps. Carry the Win32 preview fixes from #4431 and split accessible and advisory physical Storybook CI lanes without changing aggregate PR requirements.

Co-authored-by: Srividya Ramaswamy <sriramas@microsoft.com>

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .changeset/components-desktop-it.md           |   5 +
 .changeset/desktop-driver-ci-input-lanes.md   |   5 +
 .changeset/storybook-runtime-win32-preview.md |   5 +
 .github/workflows/pr.yml                      |  52 +-
 apps/storybook/README.md                      |   6 +-
 apps/storybook/agent-map.yaml                 |   3 +-
 .../references/tests-and-stories.md           |  59 +-
 .../src/common/desktopFocus.wdio.ts           |  12 -
 .../src/components/avatar/avatar.stories.tsx  |  46 +-
 .../src/components/button/button.stories.tsx  | 641 +++++++++---------
 .../src/components/card/card.stories.tsx      |  13 +-
 .../components/checkbox/checkbox.stories.tsx  |  35 +-
 .../components/dropdown/dropdown.stories.tsx  | 238 +++----
 .../src/components/input/input.stories.tsx    | 134 ++--
 .../listbox-item/listbox-item.stories.tsx     | 144 ++--
 .../menu-button/menu-button.stories.tsx       | 108 +--
 .../menu-item/menu-item.stories.tsx           | 183 +++--
 .../src/components/menu/menu.stories.tsx      | 385 ++++++-----
 .../components/popover/popover.stories.tsx    | 183 ++---
 .../src/components/radio/radio.stories.tsx    |  96 ++-
 .../components/skeleton/skeleton.stories.tsx  |  57 +-
 .../components/spinner/spinner.stories.tsx    |  49 +-
 .../src/components/switch/switch.stories.tsx  |  59 +-
 .../components/tablist/tablist.stories.tsx    | 147 ++--
 .../src/components/tag/tag.stories.tsx        |  17 +-
 .../focus-zone/focus-zone.stories.tsx         | 114 ++--
 .../layout-stable-text.stories.tsx            |   9 +-
 .../references/ci-integration.md              |  29 +-
 .../storybook-desktop-runtime/README.md       |   5 +
 .../references/runtime-contract.md            |   9 +
 .../src/StorybookUI.test.tsx                  |  83 +++
 .../src/StorybookUI.win32.tsx                 |  10 +-
 .../createDesktopStorybookPreview.win32.tsx   |  42 ++
 .../driver/representativePlans.contract.cjs   |   3 +
 .../src/testing/wdioRunner.test.ts            |   3 +-
 35 files changed, 1629 insertions(+), 1360 deletions(-)
 create mode 100644 .changeset/components-desktop-it.md
 create mode 100644 .changeset/desktop-driver-ci-input-lanes.md
 create mode 100644 .changeset/storybook-runtime-win32-preview.md
 create mode 100644 packages/agentic/storybook-desktop-runtime/src/StorybookUI.test.tsx
 create mode 100644 packages/agentic/storybook-desktop-runtime/src/createDesktopStorybookPreview.win32.tsx

diff --git a/.changeset/components-desktop-it.md b/.changeset/components-desktop-it.md
new file mode 100644
index 0000000000..a2dde1a2b6
--- /dev/null
+++ b/.changeset/components-desktop-it.md
@@ -0,0 +1,5 @@
+---
+'@fluentui-react-native/components': patch
+---
+
+Declare every component and primitive story test with `desktopIt`, so each case states the input it needs, the endpoints it runs on, and its known gaps instead of skipping at run time, and remove the internal `requireDesktopFocus` story helper.
diff --git a/.changeset/desktop-driver-ci-input-lanes.md b/.changeset/desktop-driver-ci-input-lanes.md
new file mode 100644
index 0000000000..b1984ac91f
--- /dev/null
+++ b/.changeset/desktop-driver-ci-input-lanes.md
@@ -0,0 +1,5 @@
+---
+'@fluentui-react-native/desktop-driver': patch
+---
+
+Describe the Storybook CI input lanes: the hosted Windows and Win32 jobs run the accessible lane, and an advisory Win32 job runs the physical lane.
diff --git a/.changeset/storybook-runtime-win32-preview.md b/.changeset/storybook-runtime-win32-preview.md
new file mode 100644
index 0000000000..e83d056a3a
--- /dev/null
+++ b/.changeset/storybook-runtime-win32-preview.md
@@ -0,0 +1,5 @@
+---
+'@fluentui-react-native/storybook-desktop-runtime': patch
+---
+
+Scroll the Win32 story preview inside its viewport and remount the preview for each navigation generation, so story tests start from a fresh, reachable preview.
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 6e324b297f..337071ba23 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -445,7 +445,7 @@ jobs:
           }
 
       - name: Smoke test Windows Storybook
-        run: yarn storybook smoke --windows --mode stories-and-tests
+        run: yarn storybook smoke --windows --mode stories-and-tests --input accessible
         working-directory: apps/storybook
 
       - name: Upload Windows Storybook artifacts
@@ -510,7 +510,7 @@ jobs:
           if-no-files-found: warn
 
   win32-storybook:
-    name: Win32 Storybook PR
+    name: Win32 Storybook PR (accessible)
     runs-on: windows-latest
     timeout-minutes: 60
     steps:
@@ -537,14 +537,58 @@ jobs:
           disabled-input-features: keyboard,physicalClick,wheel
 
       - name: Smoke test Win32 Storybook
-        run: yarn storybook smoke --win32 --mode stories-and-tests
+        run: yarn storybook smoke --win32 --mode stories-and-tests --input accessible
         working-directory: apps/storybook
 
       - name: Upload Win32 Storybook artifacts
         if: ${{ always() }}
         uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
-          name: Storybook_win32_paper_${{ github.run_id }}_${{ github.run_attempt }}
+          name: Storybook_win32_paper_accessible_${{ github.run_id }}_${{ github.run_attempt }}
+          path: |
+            apps/storybook/artifacts/win32
+            apps/storybook/artifacts/desktop
+            ${{ steps.desktop-driver.outputs.doctor-path }}
+            ${{ steps.desktop-driver.outputs.cache-root }}/v1/artifacts/**/build.log
+            ${{ steps.desktop-driver.outputs.cache-root }}/v1/diagnostics/**
+          if-no-files-found: warn
+
+  # An advisory pilot outside the aggregate PR check: hosted physical input is not yet qualified (#4349).
+  win32-storybook-physical:
+    name: Win32 Storybook PR (physical)
+    runs-on: windows-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Set up toolchain
+        uses: microsoft/react-native-test-app/.github/actions/setup-toolchain@1c99dd2947a77097bf937701e3dcc90aa109d17e # 5.4.15
+        with:
+          platform: windows
+          node-version: 22
+
+      - name: Install dependencies
+        run: yarn
+
+      - name: Build packages
+        run: yarn build
+
+      - name: Set up Win32 Desktop Driver
+        id: desktop-driver
+        uses: ./.github/actions/setup-desktop-driver
+        with:
+          platform: win32
+
+      - name: Smoke test Win32 Storybook
+        run: yarn storybook smoke --win32 --mode stories-and-tests --input physical
+        working-directory: apps/storybook
+
+      - name: Upload Win32 Storybook artifacts
+        if: ${{ always() }}
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: Storybook_win32_paper_physical_${{ github.run_id }}_${{ github.run_attempt }}
           path: |
             apps/storybook/artifacts/win32
             apps/storybook/artifacts/desktop
diff --git a/apps/storybook/README.md b/apps/storybook/README.md
index cbc89ee41d..50e75358cb 100644
--- a/apps/storybook/README.md
+++ b/apps/storybook/README.md
@@ -23,7 +23,11 @@ yarn storybook smoke --macos --mode stories-and-tests
 ```
 
 Replace `macos` with `windows` or `win32`. Use `yarn storybook test
---<platform> --list` to discover executable story-test names. Runtime IDs and
+--<platform> --list` to discover executable story-test names. Add
+`--input accessible` to `test` or `smoke --mode stories-and-tests` to exclude
+cases that need physical input, or `--input physical` on an unattended
+machine. Accessible runs avoid pointer and keyboard injection, but may still
+activate windows or change focus; keep desktop workloads exclusive. Runtime IDs and
 listener ports are available through the app's `desktop-driver` command.
 See `agent-map.yaml` for the current command contract and paths.
 
diff --git a/apps/storybook/agent-map.yaml b/apps/storybook/agent-map.yaml
index b90f1bd39f..f8243cf7b1 100644
--- a/apps/storybook/agent-map.yaml
+++ b/apps/storybook/agent-map.yaml
@@ -31,11 +31,12 @@ services:
   executable_tests:
     command: yarn storybook test --<platform>
     discovery: yarn storybook test --<platform> --list
-    authoring: top-level wdio callbacks or named callback collections in CSF3 stories
+    authoring: desktopIt cases with input, platform, and gap descriptors in CSF3 story wdio arrays
     config: desktop.config.mts Storybook integration wdio settings
     lifecycle: attached-session-per-test-with-isolated-node-worker
     context_platform: macos-or-windows-or-win32-target-endpoint
     test_filter: --test <name-glob>
+    input_lane: --input accessible|physical
     smoke_mode: stories-and-tests
     execution: navigate-and-remount-then-run-tests-grouped-by-story
 
diff --git a/packages/agentic/components/references/tests-and-stories.md b/packages/agentic/components/references/tests-and-stories.md
index edc3276894..5691b7398f 100644
--- a/packages/agentic/components/references/tests-and-stories.md
+++ b/packages/agentic/components/references/tests-and-stories.md
@@ -137,23 +137,41 @@ validate.
 Prefer executable WebdriverIO tests under `wdio`, typed with
 `WdioStory<StoryObj<typeof Component>>` from
 `@fluentui-react-native/storybook-desktop/testing` using `import type`.
-The story is the suite (`describe`), and named functions are its cases (`it`):
+The story is the suite (`describe`). Declare each case (`it`) with `desktopIt`
+from the same entry point, adding a descriptor when the case needs host input
+or applies only to some endpoints:
 
 ```tsx
 export const Default: Story = {
-  wdio: {
-    'is enabled': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('is enabled', async ({ browser, expect }) => {
       await expect(await browser.$('~story-button')).toBeEnabled();
-    },
-  },
+    }),
+    desktopIt('moves focus with Tab', { requires: ['physical-click', 'keyboard', 'focus'] }, async ({ browser, expect }) => {
+      // ...
+    }),
+  ],
 };
 ```
 
 Each callback receives `browser`, `expect`, `platform`, `desktop`, `signal`,
 and `skip`. The typed target `platform` is `macos`, `windows`, or `win32`;
 Win32 is distinct from its WebDriver `platformName` of `windows`. Branch
-inside callbacks for genuine platform differences and use explicit skip
-reasons for unsupported `browser.capabilities['furn:features']`.
+inside callbacks for genuine platform differences in one assertion. Do not
+call `skip` or feature-check `browser.capabilities['furn:features']` for a
+condition the descriptor can state:
+
+- `requires` lists the host capabilities the case uses, and its physical
+  entries put the case in the physical input lane. Focus and keyboard cases
+  declare `['physical-click', 'keyboard', 'focus']`. A case that reads only
+  native state declares nothing and runs in both lanes. Use `click` when either
+  click transport proves the behavior, `physical-click` for pointer-specific
+  behavior, and `accessibility-click` for UIA or AX action dispatch.
+- `platforms` scopes the case to endpoints, such as `['win32']` or `['!macos']`.
+  Split a case when endpoints need different transports rather than branching
+  on the click mode.
+- `unsupported` records a known product gap on named endpoints with a reason,
+  and `quarantine` suspends a flaky case with an issue and an `expires` date.
 
 All catalog tests use WDIO; custom `desktopDriver` plans remain only in runner
 compatibility fixtures. Keep names static and callbacks self-contained. Node helpers may be
@@ -162,11 +180,13 @@ story-module bindings. The shared Babel config strips all test functions
 before native dependency collection. Named cases get independent previews,
 sessions, workers, deadlines, results, and failure evidence.
 
-The single-function `wdio` form remains supported. Run with
-`yarn storybook test --<platform>` and optionally `--test <name-glob>`.
-`--list` discovers names without executing code. The `stories-and-tests`
+Run with `yarn storybook test --<platform>`, optionally with `--test <name-glob>`
+and `--input accessible|physical` to select one input lane. `--list` discovers
+cases and their resolved input without executing code. The `stories-and-tests`
 smoke mode runs these functions alongside remaining legacy plans, grouped by
-story. See the executable test contract (`@fluentui-react-native/storybook-desktop/references/story-tests.md`).
+story. See the executable test contract
+(`@fluentui-react-native/storybook-desktop/references/story-tests.md`) for the
+full descriptor, lane, and reporting rules.
 
 The components package's `test:stories` project checks every test-bearing story
 without emitting it into the component library. Add new test-bearing files to
@@ -191,9 +211,12 @@ timing.
 ### Desktop focus test scope
 
 Keep shared requirements executable on Windows Fabric, Office Win32, and macOS.
-`requireDesktopFocus` checks native capabilities, not an operating-system
-allowlist. A missing capability skips the case with a reason; a platform
-difference usually changes one assertion rather than skipping the entire case.
+Focus cases declare `requires: ['physical-click', 'keyboard', 'focus']`, which
+describes native capabilities, not an operating-system allowlist. The physical
+lane runs them, the accessible lane excludes them, and a run without a lane
+reports a case whose capability the host lacks as unsupported, with its reason,
+instead of executing it. A platform difference
+usually changes one assertion rather than excluding the entire case.
 
 | Behavior                                                                                                       | Scope and expected result                                                                                                                                                                                                                    |
 | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -225,13 +248,15 @@ resolved-style coverage without incidental scene rerenders, plus native visual
 evidence for renderer appearance. Likewise, a checked/selected state read after
 a physical click does not exercise UIA/AX action dispatch.
 
-Report passed, failed, and skipped counts together. A zero-exit smoke traversal
-with platform-skipped focus cases is not cross-platform focus qualification.
+Report passed, failed, skipped, unsupported, and excluded counts together. A
+zero-exit accessible-lane run excludes every focus case and is not
+cross-platform focus qualification.
 
 The macOS Fabric View does not project disabled or selected accessibility state
 to AXEnabled/AXSelected (C-A11Y-005 in the
 repository evidence reference `accessibility.action-transport-evidence`). Those native
-announcement assertions are isolated in explicitly skipped cases; shared
+announcement assertions are isolated in cases declaring
+`unsupported: { platforms: ['macos'], reason }`; shared
 focus, activation, and selection-callback cases still run. Do not substitute
 rendered state for an AX result or describe these skips as intended macOS
 semantics. Track the native projection gap and revisit the cases when the
diff --git a/packages/agentic/components/src/common/desktopFocus.wdio.ts b/packages/agentic/components/src/common/desktopFocus.wdio.ts
index c22e292b55..e2432891fd 100644
--- a/packages/agentic/components/src/common/desktopFocus.wdio.ts
+++ b/packages/agentic/components/src/common/desktopFocus.wdio.ts
@@ -1,17 +1,5 @@
 import type { WdioStoryContext } from '@fluentui-react-native/storybook-desktop/testing';
 
-export function requireDesktopFocus({ browser, skip }: Pick<WdioStoryContext, 'browser' | 'skip'>): boolean {
-  const features = browser.capabilities['furn:features'];
-  if (!features) {
-    throw new Error('Desktop Driver did not provide feature capabilities.');
-  }
-  if (!features.physicalClick || !features.keyboard || !features.focus) {
-    skip('Native focus qualification requires physical pointer input, keyboard input, and focus observation.');
-    return false;
-  }
-  return true;
-}
-
 /** Click-to-focus is Windows-specific; ordinary AppKit controls need not take focus on click. */
 export async function expectWindowsPointerFocus(
   { browser, platform }: Pick<WdioStoryContext, 'browser' | 'platform'>,
diff --git a/packages/agentic/components/src/components/avatar/avatar.stories.tsx b/packages/agentic/components/src/components/avatar/avatar.stories.tsx
index f27248cc3d..2f1c700e57 100644
--- a/packages/agentic/components/src/components/avatar/avatar.stories.tsx
+++ b/packages/agentic/components/src/components/avatar/avatar.stories.tsx
@@ -3,6 +3,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Avatar } from './avatar';
@@ -108,32 +109,35 @@ export const ActivityRing: Story = {
       },
     },
   },
-  wdio: {
-    'AVT-004 exposes the informative identity as a named native image': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('AVT-004 exposes the informative identity as a named native image', async ({ browser, expect }) => {
       const avatar = await browser.$('~agentic-storybook-avatar-activity-ring');
       await expect(avatar).toExist();
       expect(await avatar.getTagName()).toBe('image');
       expect(await avatar.getProperty('name')).toBe('Lydia Mitchelson');
-    },
-    'toggles the activity ring at every size without crashing or changing avatar bounds': async ({ browser, desktop, expect }) => {
-      const assert: typeof import('node:assert') = (await import('node:assert')).default;
-      for (const size of [16, 20, 24, 28, 32, 40, 56, 120]) {
-        for (const activityRing of [false, true]) {
-          await desktop.session.updateStoryArgs('components-avatar--activity-ring', { activityRing, size });
-          await expect(await browser.$('~agentic-storybook-avatar-ring-state')).toHaveText(
-            `Activity ring ${activityRing ? 'on' : 'off'}, size ${size}`,
-          );
-          const avatar = await browser.$('~agentic-storybook-avatar-activity-ring');
-          await expect(avatar).toExist();
-          const bounds = await browser.getElementRect(await avatar.elementId);
-          assert(
-            Math.abs(bounds.width - size) <= 1 && Math.abs(bounds.height - size) <= 1,
-            'The activity ring must not resize the avatar.',
-          );
+    }),
+    desktopIt(
+      'toggles the activity ring at every size without crashing or changing avatar bounds',
+      async ({ browser, desktop, expect }) => {
+        const assert: typeof import('node:assert') = (await import('node:assert')).default;
+        for (const size of [16, 20, 24, 28, 32, 40, 56, 120]) {
+          for (const activityRing of [false, true]) {
+            await desktop.session.updateStoryArgs('components-avatar--activity-ring', { activityRing, size });
+            await expect(await browser.$('~agentic-storybook-avatar-ring-state')).toHaveText(
+              `Activity ring ${activityRing ? 'on' : 'off'}, size ${size}`,
+            );
+            const avatar = await browser.$('~agentic-storybook-avatar-activity-ring');
+            await expect(avatar).toExist();
+            const bounds = await browser.getElementRect(await avatar.elementId);
+            assert(
+              Math.abs(bounds.width - size) <= 1 && Math.abs(bounds.height - size) <= 1,
+              'The activity ring must not resize the avatar.',
+            );
+          }
         }
-      }
-    },
-  },
+      },
+    ),
+  ],
 };
 
 const styles = StyleSheet.create({
diff --git a/packages/agentic/components/src/components/button/button.stories.tsx b/packages/agentic/components/src/components/button/button.stories.tsx
index a178b57d9a..b20507a710 100644
--- a/packages/agentic/components/src/components/button/button.stories.tsx
+++ b/packages/agentic/components/src/components/button/button.stories.tsx
@@ -8,6 +8,7 @@ import type { Meta, StoryObj } from '@storybook/react-native';
 import { ThemedRoot, useRootInputModality } from '@fluentui-react-native/design';
 import { resolveAccessibilityAction } from '@fluentui-react-native/framework-base';
 import type { FocusKeyboardEvent, FocusRequest } from '@fluentui-react-native/framework-base';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Button } from './button';
@@ -96,28 +97,26 @@ type Story = WdioStory<StoryObj<typeof Button>>;
 
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: {
-    'exposes enabled button semantics': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('exposes enabled button semantics', async ({ browser, expect }) => {
       const assert: typeof import('node:assert') = (await import('node:assert')).default;
       const button = await browser.$('~agentic-storybook-button');
       await expect(button).toExist();
       await expect(button).toBeEnabled();
       assert.strictEqual(await button.getTagName(), 'button');
-    },
-    'supports native pointer activation': async ({ browser, expect, platform, skip }) => {
-      const { expectWindowsPointerFocus } = await import('../../common/desktopFocus.wdio.ts');
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (!features.physicalClick || !features.elementScreenshot || (platform !== 'macos' && !features.focus)) {
-        skip('This test requires physical clicks, element screenshots, and focus on Windows/Win32.');
-        return;
-      }
-      const button = await browser.$('~agentic-storybook-button');
-      await button.click();
-      await expectWindowsPointerFocus({ browser, platform }, 'agentic-storybook-button');
-      expect(await browser.takeElementScreenshot(await button.elementId)).toMatch(/^iVBORw0KGgo/);
-    },
-  },
+    }),
+    desktopIt(
+      'supports native pointer activation',
+      { requires: ['physical-click', 'element-screenshot', 'focus'] },
+      async ({ browser, expect, platform }) => {
+        const { expectWindowsPointerFocus } = await import('../../common/desktopFocus.wdio.ts');
+        const button = await browser.$('~agentic-storybook-button');
+        await button.click();
+        await expectWindowsPointerFocus({ browser, platform }, 'agentic-storybook-button');
+        expect(await browser.takeElementScreenshot(await button.elementId)).toMatch(/^iVBORw0KGgo/);
+      },
+    ),
+  ],
 };
 
 function ModalityProbe({ testID = 'focus-input-modality' }: { testID?: string }) {
@@ -168,149 +167,165 @@ function FocusManagementScene() {
 export const FocusManagement: Story = {
   render: () => <FocusManagementScene />,
   tags: ['desktop-focus'],
-  wdio: {
-    'honors pointer focus policy and invokes exactly once per Enter and Space': async (context) => {
-      const { requireDesktopFocus, expectNativeState, expectWindowsPointerFocus, focusByTab } =
-        await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      const button = await browser.$('~focus-probe-button');
-      const count = await browser.$('~focus-probe-count');
-      await (await browser.$('~focus-probe-entry')).click();
-      await expectNativeState(browser, 'focus-probe-entry', 'focused', true);
-      await button.click();
-      await expectWindowsPointerFocus(context, 'focus-probe-button');
-      await expect(count).toHaveText('1');
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      await expect(await browser.$('~focus-probe-state')).toHaveText('focused');
-      await browser.keys('\uE007');
-      await expect(count).toHaveText('2');
-      await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
-      await browser.keys('\uE00D');
-      await expect(count).toHaveText('3');
-      await button.click();
-      await expect(count).toHaveText('4');
-      await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
-    },
-    'updates same-target modality without refocusing and shares it with nested themes': async (context) => {
-      const { requireDesktopFocus, expectNativeState, expectWindowsPointerFocus, focusByTab } =
-        await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      const button = await browser.$('~focus-probe-button');
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      await button.click();
-      await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
-      await expect(await browser.$('~focus-probe-focus-count')).toHaveText('1');
-      await browser.keys('x');
-      await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
-      await expect(await browser.$('~focus-nested-modality')).toHaveText('keyboard');
-      await expect(await browser.$('~focus-probe-count')).toHaveText('1');
-      await button.click();
-      await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
-      await expect(await browser.$('~focus-probe-focus-count')).toHaveText('1');
-      await (await browser.$('~focus-probe-nested')).click();
-      await expectWindowsPointerFocus(context, 'focus-probe-nested');
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-probe-next', 'focused', true);
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-probe-nested', 'focused', true);
-      await browser.keys('x');
-      await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
-      await expect(await browser.$('~focus-nested-modality')).toHaveText('keyboard');
-      await expect(await browser.$('~focus-probe-state')).toHaveText('blurred');
-    },
-    'skips disabled stops and does not activate the new owner on a stale key-up': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect, platform } = context;
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      try {
-        await browser.performActions([
-          {
-            type: 'key',
-            id: 'focus-keyboard',
-            actions: [
-              { type: 'keyDown', value: '\uE007' },
-              { type: 'keyDown', value: '\uE004' },
-              { type: 'keyUp', value: '\uE004' },
-              { type: 'keyUp', value: '\uE007' },
-            ],
-          },
-        ]);
-      } finally {
-        await browser.releaseActions();
-      }
-      await expectNativeState(browser, 'focus-probe-next', 'focused', true);
-      await expectNativeState(browser, 'focus-probe-disabled', 'focused', false);
-      await expect(await browser.$('~focus-probe-state')).toHaveText('blurred');
-      await expect(await browser.$('~focus-probe-count')).toHaveText(platform === 'macos' ? '1' : '0');
-      await expect(await browser.$('~focus-probe-pressed')).toHaveText('false');
-      await expect(await browser.$('~focus-probe-next-count')).toHaveText('0');
-      await browser.keys(['\uE008', '\uE004']);
-      await expectNativeState(browser, 'focus-probe-button', 'focused', true);
-    },
-    'suppresses repeats and activates at the native platform key phase': async (context) => {
-      const { requireDesktopFocus, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect, platform } = context;
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      try {
-        await browser.performActions([
-          {
-            type: 'key',
-            id: 'focus-keyboard',
-            actions: [
-              { type: 'keyDown', value: '\uE00D' },
-              { type: 'keyDown', value: '\uE00D' },
-              { type: 'keyDown', value: '\uE00D' },
-            ],
-          },
-        ]);
-        await expect(await browser.$('~focus-probe-count')).toHaveText(platform === 'macos' ? '1' : '0');
-        await browser.performActions([{ type: 'key', id: 'focus-keyboard', actions: [{ type: 'keyUp', value: '\uE00D' }] }]);
+  wdio: [
+    desktopIt(
+      'honors pointer focus policy and invokes exactly once per Enter and Space',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, expectWindowsPointerFocus, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        const button = await browser.$('~focus-probe-button');
+        const count = await browser.$('~focus-probe-count');
+        await (await browser.$('~focus-probe-entry')).click();
+        await expectNativeState(browser, 'focus-probe-entry', 'focused', true);
+        await button.click();
+        await expectWindowsPointerFocus(context, 'focus-probe-button');
+        await expect(count).toHaveText('1');
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        await expect(await browser.$('~focus-probe-state')).toHaveText('focused');
+        await browser.keys('\uE007');
+        await expect(count).toHaveText('2');
+        await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
+        await browser.keys('\uE00D');
+        await expect(count).toHaveText('3');
+        await button.click();
+        await expect(count).toHaveText('4');
+        await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
+      },
+    ),
+    desktopIt(
+      'updates same-target modality without refocusing and shares it with nested themes',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, expectWindowsPointerFocus, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        const button = await browser.$('~focus-probe-button');
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        await button.click();
+        await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
+        await expect(await browser.$('~focus-probe-focus-count')).toHaveText('1');
+        await browser.keys('x');
+        await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
+        await expect(await browser.$('~focus-nested-modality')).toHaveText('keyboard');
         await expect(await browser.$('~focus-probe-count')).toHaveText('1');
-        await expect(await browser.$('~focus-probe-pressed')).toHaveText('false');
-      } finally {
-        await browser.releaseActions();
-      }
-    },
-    'releases pressed feedback after an intervening key without a stale activation': async (context) => {
-      if (context.platform === 'win32') {
-        context.skip('Quarantined until #4373 is fixed: Win32 does not forward onPressOut after Space with an intervening key.');
-        return;
-      }
-      const { requireDesktopFocus, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect, platform } = context;
-      await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
-      try {
-        await browser.performActions([
-          {
-            type: 'key',
-            id: 'focus-keyboard',
-            actions: [
-              { type: 'keyDown', value: '\uE00D' },
-              { type: 'keyDown', value: 'x' },
-              { type: 'keyUp', value: 'x' },
-              { type: 'keyUp', value: '\uE00D' },
-            ],
-          },
-        ]);
+        await button.click();
+        await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
+        await expect(await browser.$('~focus-probe-focus-count')).toHaveText('1');
+        await (await browser.$('~focus-probe-nested')).click();
+        await expectWindowsPointerFocus(context, 'focus-probe-nested');
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-probe-next', 'focused', true);
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-probe-nested', 'focused', true);
+        await browser.keys('x');
+        await expect(await browser.$('~focus-input-modality')).toHaveText('keyboard');
+        await expect(await browser.$('~focus-nested-modality')).toHaveText('keyboard');
+        await expect(await browser.$('~focus-probe-state')).toHaveText('blurred');
+      },
+    ),
+    desktopIt(
+      'skips disabled stops and does not activate the new owner on a stale key-up',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect, platform } = context;
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        try {
+          await browser.performActions([
+            {
+              type: 'key',
+              id: 'focus-keyboard',
+              actions: [
+                { type: 'keyDown', value: '\uE007' },
+                { type: 'keyDown', value: '\uE004' },
+                { type: 'keyUp', value: '\uE004' },
+                { type: 'keyUp', value: '\uE007' },
+              ],
+            },
+          ]);
+        } finally {
+          await browser.releaseActions();
+        }
+        await expectNativeState(browser, 'focus-probe-next', 'focused', true);
+        await expectNativeState(browser, 'focus-probe-disabled', 'focused', false);
+        await expect(await browser.$('~focus-probe-state')).toHaveText('blurred');
         await expect(await browser.$('~focus-probe-count')).toHaveText(platform === 'macos' ? '1' : '0');
         await expect(await browser.$('~focus-probe-pressed')).toHaveText('false');
-        await expect(await browser.$('~focus-probe-release-count')).toHaveText('1');
-      } finally {
-        await browser.releaseActions();
-      }
-    },
-    'exposes the native disabled accessibility state': async ({ browser, expect }) => {
+        await expect(await browser.$('~focus-probe-next-count')).toHaveText('0');
+        await browser.keys(['\uE008', '\uE004']);
+        await expectNativeState(browser, 'focus-probe-button', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'suppresses repeats and activates at the native platform key phase',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect, platform } = context;
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        try {
+          await browser.performActions([
+            {
+              type: 'key',
+              id: 'focus-keyboard',
+              actions: [
+                { type: 'keyDown', value: '\uE00D' },
+                { type: 'keyDown', value: '\uE00D' },
+                { type: 'keyDown', value: '\uE00D' },
+              ],
+            },
+          ]);
+          await expect(await browser.$('~focus-probe-count')).toHaveText(platform === 'macos' ? '1' : '0');
+          await browser.performActions([{ type: 'key', id: 'focus-keyboard', actions: [{ type: 'keyUp', value: '\uE00D' }] }]);
+          await expect(await browser.$('~focus-probe-count')).toHaveText('1');
+          await expect(await browser.$('~focus-probe-pressed')).toHaveText('false');
+        } finally {
+          await browser.releaseActions();
+        }
+      },
+    ),
+    desktopIt(
+      'releases pressed feedback after an intervening key without a stale activation',
+      {
+        requires: ['physical-click', 'keyboard', 'focus'],
+        quarantine: {
+          issue: '#4373',
+          reason: 'Win32 does not forward onPressOut after Space with an intervening key.',
+          expires: '2027-01-31',
+          platforms: ['win32'],
+        },
+      },
+      async (context) => {
+        const { focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect, platform } = context;
+        await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
+        try {
+          await browser.performActions([
+            {
+              type: 'key',
+              id: 'focus-keyboard',
+              actions: [
+                { type: 'keyDown', value: '\uE00D' },
+                { type: 'keyDown', value: 'x' },
+                { type: 'keyUp', value: 'x' },
+                { type: 'keyUp', value: '\uE00D' },
+              ],
+            },
+          ]);
+          await expect(await browser.$('~focus-probe-count')).toHaveText(platform === 'macos' ? '1' : '0');
+          await expect(await browser.$('~focus-probe-pressed')).toHaveText('false');
+          await expect(await browser.$('~focus-probe-release-count')).toHaveText('1');
+        } finally {
+          await browser.releaseActions();
+        }
+      },
+    ),
+    desktopIt('exposes the native disabled accessibility state', async ({ browser, expect }) => {
       await expect(await browser.$('~focus-probe-disabled')).not.toBeEnabled();
-    },
-    'releases repeated modifiers before the next Tab': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+    }),
+    desktopIt('releases repeated modifiers before the next Tab', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
       const { browser } = context;
       await focusByTab(browser, 'focus-probe-entry', 'focus-probe-button');
       try {
@@ -331,8 +346,8 @@ export const FocusManagement: Story = {
       } finally {
         await browser.releaseActions();
       }
-    },
-  },
+    }),
+  ],
 };
 
 function FocusRequestsScene() {
@@ -361,32 +376,35 @@ function FocusRequestsScene() {
 export const FocusRequests: Story = {
   render: () => <FocusRequestsScene />,
   tags: ['desktop-focus'],
-  wdio: {
-    'confirms native requests without changing modality and rejects disabled or detached targets': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect, platform } = context;
-      const command = await browser.$('~focus-request-command');
-      const status = await browser.$('~focus-request-status');
-      await command.click();
-      await expectNativeState(browser, 'focus-request-target', 'focused', true);
-      await expect(status).toHaveText('confirmed');
-      await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
-      await (await browser.$('~focus-request-entry')).click();
-      await expectNativeState(browser, 'focus-request-entry', 'focused', true);
-      await (await browser.$('~focus-request-disable')).click();
-      await expectNativeState(browser, 'focus-request-target', 'focused', false);
-      if (platform !== 'macos') {
-        await expect(await browser.$('~focus-request-target')).not.toBeEnabled();
-      }
-      await command.click();
-      await expect(status).toHaveText('not-focusable');
-      await (await browser.$('~focus-request-mount')).click();
-      await expect(await browser.$('~focus-request-target')).not.toExist();
-      await command.click();
-      await expect(status).toHaveText('not-mounted');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'confirms native requests without changing modality and rejects disabled or detached targets',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect, platform } = context;
+        const command = await browser.$('~focus-request-command');
+        const status = await browser.$('~focus-request-status');
+        await command.click();
+        await expectNativeState(browser, 'focus-request-target', 'focused', true);
+        await expect(status).toHaveText('confirmed');
+        await expect(await browser.$('~focus-input-modality')).toHaveText('pointer');
+        await (await browser.$('~focus-request-entry')).click();
+        await expectNativeState(browser, 'focus-request-entry', 'focused', true);
+        await (await browser.$('~focus-request-disable')).click();
+        await expectNativeState(browser, 'focus-request-target', 'focused', false);
+        if (platform !== 'macos') {
+          await expect(await browser.$('~focus-request-target')).not.toBeEnabled();
+        }
+        await command.click();
+        await expect(status).toHaveText('not-focusable');
+        await (await browser.$('~focus-request-mount')).click();
+        await expect(await browser.$('~focus-request-target')).not.toExist();
+        await command.click();
+        await expect(status).toHaveText('not-mounted');
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
@@ -518,41 +536,35 @@ export const Selected: Story = {
 };
 
 export const ExternallyDrivenSelection: Story = {
-  wdio: {
-    'starts unselected': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('starts unselected', async ({ browser, expect }) => {
       await expect(await browser.$('~agentic-storybook-button-selection-state')).toHaveText('Not selected');
-    },
-    'updates and resets caller-owned selection': async ({ browser, expect, platform, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (platform === 'macos' && !features.physicalClick) {
-        skip('macOS caller-owned selection requires physical pointer input; the custom Toggle action is not an AXPress route.');
-        return;
-      }
-      if (!features.physicalClick && !features.accessibilityClick) {
-        skip('This test requires native accessibility activation or physical pointer input.');
-        return;
-      }
-      const { clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
+    }),
+    desktopIt('updates and resets caller-owned selection', { requires: ['click'], platforms: ['!macos'] }, async ({ browser, expect }) => {
       const favorite = await browser.$('~agentic-storybook-button-favorite');
-      const reset = await browser.$('~agentic-storybook-button-reset');
       const status = await browser.$('~agentic-storybook-button-selection-state');
       await expect(favorite).toBeEnabled();
       await expect(status).toHaveText('Not selected');
-      if (platform === 'macos') {
-        await clickPhysical(browser, 'agentic-storybook-button-favorite');
-      } else {
-        await favorite.click();
-      }
+      await favorite.click();
       await expect(status).toHaveText('Selected');
-      if (platform === 'macos') {
-        await clickPhysical(browser, 'agentic-storybook-button-reset');
-      } else {
-        await reset.click();
-      }
+      await (await browser.$('~agentic-storybook-button-reset')).click();
       await expect(status).toHaveText('Not selected');
-    },
-  },
+    }),
+    desktopIt(
+      'updates and resets caller-owned selection with a physical pointer',
+      { requires: ['physical-click'], platforms: ['macos'] },
+      async ({ browser, expect }) => {
+        const { clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
+        const status = await browser.$('~agentic-storybook-button-selection-state');
+        await expect(await browser.$('~agentic-storybook-button-favorite')).toBeEnabled();
+        await expect(status).toHaveText('Not selected');
+        await clickPhysical(browser, 'agentic-storybook-button-favorite');
+        await expect(status).toHaveText('Selected');
+        await clickPhysical(browser, 'agentic-storybook-button-reset');
+        await expect(status).toHaveText('Not selected');
+      },
+    ),
+  ],
   render: () => {
     const ToggleGroup = () => {
       const [selected, setSelected] = useState(false);
@@ -624,8 +636,8 @@ export const NativeNames: Story = {
       <Button content="Save" aria-label="ARIA action" testID="button-name-aria" />
     </View>
   ),
-  wdio: {
-    'BTN-004 exposes plain, slot and numeric native names while preserving caller names': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('BTN-004 exposes plain, slot and numeric native names while preserving caller names', async ({ browser, expect }) => {
       for (const [id, name] of [
         ['button-name-plain', 'Save'],
         ['button-name-slot', 'Slot label'],
@@ -637,8 +649,8 @@ export const NativeNames: Story = {
         expect(await button.getTagName()).toBe('button');
         expect(await button.getProperty('name')).toBe(name);
       }
-    },
-  },
+    }),
+  ],
 };
 
 export const NativeToggleSemantics: Story = {
@@ -677,8 +689,8 @@ export const NativeToggleSemantics: Story = {
     };
     return <Scene />;
   },
-  wdio: {
-    'BTN-004 BTN-005 exposes native button roles and enabled or disabled state': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('BTN-004 BTN-005 exposes native button roles and enabled or disabled state', async ({ browser, expect }) => {
       const off = await browser.$('~button-native-toggle-off');
       const on = await browser.$('~button-native-toggle-on');
       const disabled = await browser.$('~button-native-toggle-disabled');
@@ -688,71 +700,57 @@ export const NativeToggleSemantics: Story = {
       await expect(off).toBeEnabled();
       await expect(on).toBeEnabled();
       await expect(disabled).toBeDisabled();
-    },
-    'BTN-005 Windows native checked projection reflects caller selection including disabled': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform === 'macos') {
-        skip(
-          'Native checked projection is unsupported for the retained macOS AXButton role; shared role and enabled-state checks run separately.',
-        );
-        return;
-      }
-      const off = await browser.$('~button-native-toggle-off');
-      const on = await browser.$('~button-native-toggle-on');
-      const disabled = await browser.$('~button-native-toggle-disabled');
-      expect(await off.getProperty('checked')).toBe(false);
-      expect(await on.getProperty('checked')).toBe(true);
-      expect(await disabled.getProperty('checked')).toBe(true);
-    },
-    'BTN-005 Win32 Toggle forwards once without a press or a controlled selection change': async ({ browser, expect, platform, skip }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies Win32 native Toggle transport.');
-        return;
-      }
-      if (!browser.capabilities['furn:features']?.accessibilityClick) {
-        skip('Native accessibility click is unavailable.');
-        return;
-      }
-      expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
-      const button = await browser.$('~button-native-toggle-on');
-      const actions = await browser.$('~button-native-toggle-actions');
-      const presses = await browser.$('~button-native-toggle-presses');
-      await expect(actions).toHaveAttribute('name', '0:none');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await button.getProperty('checked')).toBe(true);
-      await button.click();
-      await expect(actions).toHaveAttribute('name', '1:Toggle');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await button.getProperty('checked')).toBe(true);
-    },
-    'BTN-004 Win32 disabled public activation rejects without callbacks or a checked-state change': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies the Win32 disabled accessibility-click route, not disabled-provider dispatch.');
-        return;
-      }
-      if (!browser.capabilities['furn:features']?.accessibilityClick) {
-        skip('Native accessibility click is unavailable.');
-        return;
-      }
-      expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
-      const button = await browser.$('~button-native-toggle-disabled');
-      await expect(button).toBeDisabled();
-      expect(await button.getProperty('checked')).toBe(true);
-      await expect(button.click()).rejects.toThrow();
-      await expect(await browser.$('~button-native-toggle-actions')).toHaveAttribute('name', '0:none');
-      await expect(await browser.$('~button-native-toggle-presses')).toHaveAttribute('name', '0');
-      expect(await button.getProperty('checked')).toBe(true);
-    },
-  },
+    }),
+    desktopIt(
+      'BTN-005 Windows native checked projection reflects caller selection including disabled',
+      {
+        unsupported: {
+          platforms: ['macos'],
+          reason:
+            'Native checked projection is unsupported for the retained macOS AXButton role (C-A11Y-005); shared role and enabled-state checks run separately.',
+        },
+      },
+      async ({ browser, expect }) => {
+        const off = await browser.$('~button-native-toggle-off');
+        const on = await browser.$('~button-native-toggle-on');
+        const disabled = await browser.$('~button-native-toggle-disabled');
+        expect(await off.getProperty('checked')).toBe(false);
+        expect(await on.getProperty('checked')).toBe(true);
+        expect(await disabled.getProperty('checked')).toBe(true);
+      },
+    ),
+    desktopIt(
+      'BTN-005 Win32 Toggle forwards once without a press or a controlled selection change',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
+        const button = await browser.$('~button-native-toggle-on');
+        const actions = await browser.$('~button-native-toggle-actions');
+        const presses = await browser.$('~button-native-toggle-presses');
+        await expect(actions).toHaveAttribute('name', '0:none');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await button.getProperty('checked')).toBe(true);
+        await button.click();
+        await expect(actions).toHaveAttribute('name', '1:Toggle');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await button.getProperty('checked')).toBe(true);
+      },
+    ),
+    desktopIt(
+      'BTN-004 Win32 disabled public activation rejects without callbacks or a checked-state change',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
+        const button = await browser.$('~button-native-toggle-disabled');
+        await expect(button).toBeDisabled();
+        expect(await button.getProperty('checked')).toBe(true);
+        await expect(button.click()).rejects.toThrow();
+        await expect(await browser.$('~button-native-toggle-actions')).toHaveAttribute('name', '0:none');
+        await expect(await browser.$('~button-native-toggle-presses')).toHaveAttribute('name', '0');
+        expect(await button.getProperty('checked')).toBe(true);
+      },
+    ),
+  ],
   parameters: {
     docs: {
       description: {
@@ -795,49 +793,40 @@ export const NativeToggleSelection: Story = {
     };
     return <Scene />;
   },
-  wdio: {
-    'BTN-002 BTN-005 Win32 native Toggle updates caller selection without reflow or duplicate presses': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies caller handling of Win32 native Toggle events.');
-        return;
-      }
-      if (!browser.capabilities['furn:features']?.accessibilityClick) {
-        skip('Native accessibility click is unavailable.');
-        return;
-      }
-      expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
-      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      const button = await browser.$('~button-native-selection');
-      const state = await browser.$('~button-native-selection-state');
-      const actions = await browser.$('~button-native-selection-actions');
-      const presses = await browser.$('~button-native-selection-presses');
-      await expect(state).toHaveAttribute('name', 'false');
-      await expect(actions).toHaveAttribute('name', '0');
-      await expect(presses).toHaveAttribute('name', '0');
-      await expectNativeState(browser, 'button-native-selection', 'checked', false);
-      const before = await browser.getElementRect(await button.elementId);
-      await button.click();
-      await expect(state).toHaveAttribute('name', 'true');
-      await expect(actions).toHaveAttribute('name', '1');
-      await expectNativeState(browser, 'button-native-selection', 'checked', true);
-      const selected = await browser.getElementRect(await button.elementId);
-      expect(selected.width).toBe(before.width);
-      expect(selected.height).toBe(before.height);
-      await button.click();
-      await expect(state).toHaveAttribute('name', 'false');
-      await expect(actions).toHaveAttribute('name', '2');
-      await expect(presses).toHaveAttribute('name', '0');
-      await expectNativeState(browser, 'button-native-selection', 'checked', false);
-      const reset = await browser.getElementRect(await button.elementId);
-      expect(reset.width).toBe(before.width);
-      expect(reset.height).toBe(before.height);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'BTN-002 BTN-005 Win32 native Toggle updates caller selection without reflow or duplicate presses',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const button = await browser.$('~button-native-selection');
+        const state = await browser.$('~button-native-selection-state');
+        const actions = await browser.$('~button-native-selection-actions');
+        const presses = await browser.$('~button-native-selection-presses');
+        await expect(state).toHaveAttribute('name', 'false');
+        await expect(actions).toHaveAttribute('name', '0');
+        await expect(presses).toHaveAttribute('name', '0');
+        await expectNativeState(browser, 'button-native-selection', 'checked', false);
+        const before = await browser.getElementRect(await button.elementId);
+        await button.click();
+        await expect(state).toHaveAttribute('name', 'true');
+        await expect(actions).toHaveAttribute('name', '1');
+        await expectNativeState(browser, 'button-native-selection', 'checked', true);
+        const selected = await browser.getElementRect(await button.elementId);
+        expect(selected.width).toBe(before.width);
+        expect(selected.height).toBe(before.height);
+        await button.click();
+        await expect(state).toHaveAttribute('name', 'false');
+        await expect(actions).toHaveAttribute('name', '2');
+        await expect(presses).toHaveAttribute('name', '0');
+        await expectNativeState(browser, 'button-native-selection', 'checked', false);
+        const reset = await browser.getElementRect(await button.elementId);
+        expect(reset.width).toBe(before.width);
+        expect(reset.height).toBe(before.height);
+      },
+    ),
+  ],
   parameters: {
     docs: {
       description: {
diff --git a/packages/agentic/components/src/components/card/card.stories.tsx b/packages/agentic/components/src/components/card/card.stories.tsx
index abb2cc2960..af43d1c1ce 100644
--- a/packages/agentic/components/src/components/card/card.stories.tsx
+++ b/packages/agentic/components/src/components/card/card.stories.tsx
@@ -4,6 +4,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Button } from '../button/button';
@@ -175,8 +176,8 @@ export const NativeStructure: Story = {
       },
     },
   },
-  wdio: {
-    'CRD-002 renders structured sections in reading order': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('CRD-002 renders structured sections in reading order', async ({ browser, expect }) => {
       expect(browser.capabilities.setWindowRect).toBe(true);
       const originalWindow = await browser.getWindowRect();
       const requestedWindow = {
@@ -249,13 +250,13 @@ export const NativeStructure: Story = {
       } finally {
         await browser.setWindowRect(originalWindow.x, originalWindow.y, originalWindow.width, originalWindow.height);
       }
-    },
-    'CRD-005 keeps a nested action enabled inside a disabled selectable surface': async ({ browser, expect }) => {
+    }),
+    desktopIt('CRD-005 keeps a nested action enabled inside a disabled selectable surface', async ({ browser, expect }) => {
       const help = await browser.$('~card-spec-help');
       expect(await help.getTagName()).toBe('button');
       await expect(help).toBeEnabled();
-    },
-  },
+    }),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/components/checkbox/checkbox.stories.tsx b/packages/agentic/components/src/components/checkbox/checkbox.stories.tsx
index 58abff9734..3592436535 100644
--- a/packages/agentic/components/src/components/checkbox/checkbox.stories.tsx
+++ b/packages/agentic/components/src/components/checkbox/checkbox.stories.tsx
@@ -4,6 +4,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Checkbox } from './checkbox';
@@ -66,14 +67,8 @@ type Story = WdioStory<StoryObj<typeof Checkbox>>;
 
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: {
-    'toggles native checked state in both directions': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (!features.physicalClick) {
-        skip('This test requires physical pointer input.');
-        return;
-      }
+  wdio: [
+    desktopIt('toggles native checked state in both directions', { requires: ['physical-click'] }, async ({ browser, expect }) => {
       const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const checkbox = await browser.$('~agentic-storybook-checkbox');
       expect(await checkbox.getTagName()).toBe('checkbox');
@@ -82,8 +77,8 @@ export const Default: Story = {
       await expectNativeState(browser, 'agentic-storybook-checkbox', 'checked', true);
       await checkbox.click();
       await expectNativeState(browser, 'agentic-storybook-checkbox', 'checked', false);
-    },
-  },
+    }),
+  ],
 };
 
 export const Overview: Story = {
@@ -170,8 +165,8 @@ export const HiddenLabel: Story = {
       <Checkbox label="Save drafts" showLabel={false} testID="checkbox-fallback-name" />
     </StoryGroup>
   ),
-  wdio: {
-    'CBX-004 preserves native explicit and fallback names without visible labels': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('CBX-004 preserves native explicit and fallback names without visible labels', async ({ browser, expect }) => {
       const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const explicit = await browser.$('~checkbox-explicit-name');
       const fallback = await browser.$('~checkbox-fallback-name');
@@ -181,8 +176,8 @@ export const HiddenLabel: Story = {
       expect(await fallback.getProperty('name')).toBe('Save drafts');
       await expectNativeState(browser, 'checkbox-explicit-name', 'checked', false);
       await expectNativeState(browser, 'checkbox-fallback-name', 'checked', false);
-    },
-  },
+    }),
+  ],
   parameters: {
     docs: {
       description: {
@@ -245,24 +240,24 @@ export const ConstrainedText: Story = {
       },
     },
   },
-  wdio: {
-    'CBX-003 wraps the label into a taller constrained row': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('CBX-003 wraps the label into a taller constrained row', async ({ browser, expect }) => {
       const narrow = await browser.$('~checkbox-narrow-label');
       const wide = await browser.$('~checkbox-wide-label');
       const narrowRect = await browser.getElementRect(await narrow.elementId);
       const wideRect = await browser.getElementRect(await wide.elementId);
       expect(narrowRect.width).toBeLessThan(wideRect.width);
       expect(narrowRect.height).toBeGreaterThan(wideRect.height);
-    },
-    'CBX-003 wraps secondary text into a taller constrained row': async ({ browser, expect }) => {
+    }),
+    desktopIt('CBX-003 wraps secondary text into a taller constrained row', async ({ browser, expect }) => {
       const narrow = await browser.$('~checkbox-narrow-secondary');
       const wide = await browser.$('~checkbox-wide-secondary');
       const narrowRect = await browser.getElementRect(await narrow.elementId);
       const wideRect = await browser.getElementRect(await wide.elementId);
       expect(narrowRect.width).toBeLessThan(wideRect.width);
       expect(narrowRect.height).toBeGreaterThan(wideRect.height);
-    },
-  },
+    }),
+  ],
 };
 
 const styles = StyleSheet.create({
diff --git a/packages/agentic/components/src/components/dropdown/dropdown.stories.tsx b/packages/agentic/components/src/components/dropdown/dropdown.stories.tsx
index af904d28d0..0adf27daf6 100644
--- a/packages/agentic/components/src/components/dropdown/dropdown.stories.tsx
+++ b/packages/agentic/components/src/components/dropdown/dropdown.stories.tsx
@@ -3,6 +3,7 @@ import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -119,8 +120,8 @@ type Story = WdioStory<StoryObj<SceneProps>>;
 
 export const Default: Story = {
   tags: ['desktop-focus'],
-  wdio: {
-    'DRP-011 exposes a named, empty, collapsed native combobox before input': async ({ browser, expect, platform }) => {
+  wdio: [
+    desktopIt('DRP-011 exposes a named, empty, collapsed native combobox before input', async ({ browser, expect, platform }) => {
       const trigger = await browser.$('~dropdown-trigger');
       expect(await trigger.getProperty('role')).toBe('combobox');
       expect(await trigger.getProperty('name')).toBe('Fruit');
@@ -131,50 +132,54 @@ export const Default: Story = {
       }
       // macOS Fabric converts empty accessibilityValue.text to nil; Paper and UIA retain the empty string.
       expect(await trigger.getProperty('value')).toBe(platform === 'macos' && renderer === 'fabric' ? null : '');
-    },
-    'opens from the keyboard on the first option and commits with Enter': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
-      expect(await (await browser.$('~dropdown-trigger')).getProperty('expanded')).toBe(true);
-      await browser.keys('\uE015');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Banana');
-      // The disabled Cherry option is never a focus stop.
-      await browser.keys('\uE015');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Grape');
-      await browser.keys('\uE013');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Banana');
-      await browser.keys('\uE007');
-      await expect(await browser.$('~dropdown-selection')).toHaveText('Banana');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
-      await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
-      expect(await (await browser.$('~dropdown-trigger')).getProperty('value')).toBe('Banana');
-    },
-    'reopens on the selected option and navigates with Home and End': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      const { openDropdownFromKeyboard } = await import('./dropdown.wdio.ts');
-      await openDropdownFromKeyboard(context, 'Apple');
-      await browser.keys('\uE010');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Mango');
-      await browser.keys('\uE00D');
-      await expect(await browser.$('~dropdown-selection')).toHaveText('Mango');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Mango');
-      await browser.keys('\uE011');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Apple');
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
-      expect(await (await browser.$('~dropdown-selection')).getText()).toBe('Mango');
-    },
-    'exposes a named list of selectable options': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+    }),
+    desktopIt(
+      'opens from the keyboard on the first option and commits with Enter',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
+        expect(await (await browser.$('~dropdown-trigger')).getProperty('expanded')).toBe(true);
+        await browser.keys('\uE015');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Banana');
+        // The disabled Cherry option is never a focus stop.
+        await browser.keys('\uE015');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Grape');
+        await browser.keys('\uE013');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Banana');
+        await browser.keys('\uE007');
+        await expect(await browser.$('~dropdown-selection')).toHaveText('Banana');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
+        await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
+        expect(await (await browser.$('~dropdown-trigger')).getProperty('value')).toBe('Banana');
+      },
+    ),
+    desktopIt(
+      'reopens on the selected option and navigates with Home and End',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        const { openDropdownFromKeyboard } = await import('./dropdown.wdio.ts');
+        await openDropdownFromKeyboard(context, 'Apple');
+        await browser.keys('\uE010');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Mango');
+        await browser.keys('\uE00D');
+        await expect(await browser.$('~dropdown-selection')).toHaveText('Mango');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Mango');
+        await browser.keys('\uE011');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Apple');
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
+        expect(await (await browser.$('~dropdown-selection')).getText()).toBe('Mango');
+      },
+    ),
+    desktopIt('exposes a named list of selectable options', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
       const { expectMenuClosed, inWindowWith } = await import('../menu/menu.wdio.ts');
       const { browser, expect } = context;
       await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
@@ -195,10 +200,9 @@ export const Default: Story = {
       await (await browser.$('~dropdown-trigger')).click();
       await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: trigger');
       await expectMenuClosed(context, 'dropdown-trigger');
-    },
-    'closes on Tab and moves focus past the trigger': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+    }),
+    desktopIt('closes on Tab and moves focus past the trigger', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { expectMenuClosed } = await import('../menu/menu.wdio.ts');
       const { browser, expect } = context;
       await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
@@ -207,37 +211,42 @@ export const Default: Story = {
       // The Win32 host cannot continue Tab past its owner, so focus returns to the trigger there.
       await expectNativeState(browser, context.platform === 'win32' ? 'dropdown-trigger' : 'dropdown-after', 'focused', true);
       await expectMenuClosed(context, 'dropdown-trigger');
-    },
-    'closes on Shift+Tab and returns focus to the trigger': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
-      await browser.keys(['\uE008', '\uE004']);
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
-    },
-    'opens from the pointer on the first option and selects with a click': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectMenuClosed, inWindowWith } = await import('../menu/menu.wdio.ts');
-      const { browser, expect } = context;
-      await (await browser.$('~dropdown-trigger')).click();
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Apple');
-      await inWindowWith(context, 'dropdown-grape', async () => {
-        await (await browser.$('~dropdown-grape')).click();
-      });
-      await expect(await browser.$('~dropdown-selection')).toHaveText('Grape');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
-      await expectMenuClosed(context, 'dropdown-trigger');
-      await (await browser.$('~dropdown-trigger')).click();
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
-      await (await browser.$('~dropdown-trigger')).click();
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: trigger');
-      await expectMenuClosed(context, 'dropdown-trigger');
-    },
-  },
+    }),
+    desktopIt(
+      'closes on Shift+Tab and returns focus to the trigger',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
+        await browser.keys(['\uE008', '\uE004']);
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'opens from the pointer on the first option and selects with a click',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectMenuClosed, inWindowWith } = await import('../menu/menu.wdio.ts');
+        const { browser, expect } = context;
+        await (await browser.$('~dropdown-trigger')).click();
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Apple');
+        await inWindowWith(context, 'dropdown-grape', async () => {
+          await (await browser.$('~dropdown-grape')).click();
+        });
+        await expect(await browser.$('~dropdown-selection')).toHaveText('Grape');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
+        await expectMenuClosed(context, 'dropdown-trigger');
+        await (await browser.$('~dropdown-trigger')).click();
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Opened: trigger');
+        await (await browser.$('~dropdown-trigger')).click();
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: trigger');
+        await expectMenuClosed(context, 'dropdown-trigger');
+      },
+    ),
+  ],
 };
 
 export const Multiple: Story = {
@@ -246,10 +255,9 @@ export const Multiple: Story = {
   parameters: {
     docs: { description: { story: 'Activation toggles options and keeps the list open; the trigger summarizes long selections.' } },
   },
-  wdio: {
-    'toggles options and stays open until dismissed': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+  wdio: [
+    desktopIt('toggles options and stays open until dismissed', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { browser, expect } = context;
       await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Apple');
       await browser.keys('\uE007');
@@ -265,8 +273,8 @@ export const Multiple: Story = {
       await browser.keys('\uE00C');
       await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: dismiss');
       await expectNativeState(browser, 'dropdown-trigger', 'focused', true);
-    },
-  },
+    }),
+  ],
 };
 
 /** A long list that scrolls inside the popup. */
@@ -313,29 +321,31 @@ export const LongList: Story = {
   parameters: {
     docs: { description: { story: 'A controlled selection in a list taller than the popup, which scrolls the focused option into view.' } },
   },
-  wdio: {
-    'enters on the controlled selection and reaches the end of a scrolling list': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { inWindowWith } = await import('../menu/menu.wdio.ts');
-      const { browser, expect } = context;
-      await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Kyoto');
-      await browser.keys('\uE010');
-      await expect(await browser.$('~dropdown-focus')).toHaveText('Tokyo');
-      await inWindowWith(context, 'dropdown-tokyo', async () => {
-        const rect = async (id: string) => browser.getElementRect(await (await browser.$(`~${id}`)).elementId);
-        const list = await rect('dropdown-list');
-        const option = await rect('dropdown-tokyo');
-        // The focused last option is scrolled within the list's visible bounds.
-        expect(option.y).toBeGreaterThanOrEqual(list.y - 1);
-        expect(option.y + option.height).toBeLessThanOrEqual(list.y + list.height + 1);
-        // A macOS window switch makes the owner window key, so commit with the pointer rather than a key.
-        await (await browser.$('~dropdown-tokyo')).click();
-      });
-      await expect(await browser.$('~dropdown-selection')).toHaveText('Tokyo');
-      await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'enters on the controlled selection and reaches the end of a scrolling list',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { inWindowWith } = await import('../menu/menu.wdio.ts');
+        const { browser, expect } = context;
+        await (await import('./dropdown.wdio.ts')).openDropdownFromKeyboard(context, 'Kyoto');
+        await browser.keys('\uE010');
+        await expect(await browser.$('~dropdown-focus')).toHaveText('Tokyo');
+        await inWindowWith(context, 'dropdown-tokyo', async () => {
+          const rect = async (id: string) => browser.getElementRect(await (await browser.$(`~${id}`)).elementId);
+          const list = await rect('dropdown-list');
+          const option = await rect('dropdown-tokyo');
+          // The focused last option is scrolled within the list's visible bounds.
+          expect(option.y).toBeGreaterThanOrEqual(list.y - 1);
+          expect(option.y + option.height).toBeLessThanOrEqual(list.y + list.height + 1);
+          // A macOS window switch makes the owner window key, so commit with the pointer rather than a key.
+          await (await browser.$('~dropdown-tokyo')).click();
+        });
+        await expect(await browser.$('~dropdown-selection')).toHaveText('Tokyo');
+        await expect(await browser.$('~dropdown-reason')).toHaveText('Closed: select');
+      },
+    ),
+  ],
 };
 
 /** Variants, sizes, and states side by side. */
@@ -370,15 +380,15 @@ function GalleryScene() {
 
 export const Appearance: Story = {
   render: () => <GalleryScene />,
-  wdio: {
-    'DRP-011 exposes a nonempty selected native value without input': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('DRP-011 exposes a nonempty selected native value without input', async ({ browser, expect }) => {
       const trigger = await browser.$('~dropdown-selected-trigger');
       expect(await trigger.getProperty('role')).toBe('combobox');
       expect(await trigger.getProperty('name')).toBe('Selected');
       expect(await trigger.getProperty('expanded')).toBe(false);
       expect(await trigger.getProperty('value')).toBe('Banana');
-    },
-  },
+    }),
+  ],
   parameters: {
     controls: { disable: true },
     docs: {
diff --git a/packages/agentic/components/src/components/input/input.stories.tsx b/packages/agentic/components/src/components/input/input.stories.tsx
index f229d3118d..0d56d9ab2d 100644
--- a/packages/agentic/components/src/components/input/input.stories.tsx
+++ b/packages/agentic/components/src/components/input/input.stories.tsx
@@ -3,6 +3,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 import { directComponent } from '@fluentui-react-native/framework-base';
 
@@ -77,22 +78,16 @@ type Story = WdioStory<StoryObj<typeof Input>>;
 
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: {
-    'accepts keyboard input and clears it': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (!features.keyboard) {
-        skip('This test requires keyboard input.');
-        return;
-      }
+  wdio: [
+    desktopIt('accepts keyboard input and clears it', { requires: ['keyboard'] }, async ({ browser, expect }) => {
       const input = await browser.$('~agentic-storybook-input');
       expect(await input.getTagName()).toBe('textbox');
       await input.addValue('Ada');
       await expect(input).toHaveValue('Ada');
       await input.clearValue();
       await expect(input).toHaveValue('');
-    },
-  },
+    }),
+  ],
 };
 
 export const FocusManagement: Story = {
@@ -104,33 +99,39 @@ export const FocusManagement: Story = {
       <Button content="After the input" testID="focus-input-after" />
     </View>
   ),
-  wdio: {
-    'keeps editing keys in the TextInput and skips disabled fields on Tab': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      const input = await browser.$('~focus-input');
-      await input.setValue('Ada');
-      await expectNativeState(browser, 'focus-input', 'focused', true);
-      await browser.keys('\uE012');
-      await browser.keys('x');
-      await expect(input).toHaveValue('Adxa');
-      await expectNativeState(browser, 'focus-input', 'focused', true);
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-input-after', 'focused', true);
-      await expectNativeState(browser, 'focus-input-disabled', 'focused', false);
-    },
-    'takes native focus from a physical pointer click': async (context) => {
-      const { requireDesktopFocus, expectNativeState, expectWindowsPointerFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser } = context;
-      await (await browser.$('~focus-input-after')).click();
-      await expectWindowsPointerFocus(context, 'focus-input-after');
-      await (await browser.$('~focus-input')).click();
-      await expectWindowsPointerFocus(context, 'focus-input');
-      await expectNativeState(browser, 'focus-input-after', 'focused', false);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'keeps editing keys in the TextInput and skips disabled fields on Tab',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        const input = await browser.$('~focus-input');
+        await input.setValue('Ada');
+        await expectNativeState(browser, 'focus-input', 'focused', true);
+        await browser.keys('\uE012');
+        await browser.keys('x');
+        await expect(input).toHaveValue('Adxa');
+        await expectNativeState(browser, 'focus-input', 'focused', true);
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-input-after', 'focused', true);
+        await expectNativeState(browser, 'focus-input-disabled', 'focused', false);
+      },
+    ),
+    desktopIt(
+      'takes native focus from a physical pointer click',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, expectWindowsPointerFocus } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser } = context;
+        await (await browser.$('~focus-input-after')).click();
+        await expectWindowsPointerFocus(context, 'focus-input-after');
+        await (await browser.$('~focus-input')).click();
+        await expectWindowsPointerFocus(context, 'focus-input');
+        await expectNativeState(browser, 'focus-input-after', 'focused', false);
+      },
+    ),
+  ],
 };
 
 function FocusTreatmentProbe(props: InputProps) {
@@ -173,37 +174,40 @@ export const FocusTreatment: Story = {
       },
     },
   },
-  wdio: {
-    'retains native editor focus and geometry through every focus-treatment variant': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (await browser.$('~focus-field-entry')).click();
-      await expectNativeState(browser, 'focus-field-entry', 'focused', true);
-      for (const variant of ['outline', 'underline']) {
-        for (const suffix of ['', '-error', '-readonly']) {
-          const id = `focus-field-${variant}${suffix}`;
-          const field = await browser.$(`~${id}`);
-          const before = await browser.getElementRect(await field.elementId);
-          await browser.keys('\uE004');
-          await expectNativeState(browser, id, 'focused', true);
-          await expect(await browser.$(`~${id}-indicator`)).toHaveText('true');
-          if (suffix === '-readonly') {
-            expect(await field.getTagName()).toBe('textbox');
-            await expect(field).toBeEnabled();
-            await browser.keys('x');
-            await expect(field).toHaveValue('Read only');
+  wdio: [
+    desktopIt(
+      'retains native editor focus and geometry through every focus-treatment variant',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (await browser.$('~focus-field-entry')).click();
+        await expectNativeState(browser, 'focus-field-entry', 'focused', true);
+        for (const variant of ['outline', 'underline']) {
+          for (const suffix of ['', '-error', '-readonly']) {
+            const id = `focus-field-${variant}${suffix}`;
+            const field = await browser.$(`~${id}`);
+            const before = await browser.getElementRect(await field.elementId);
+            await browser.keys('\uE004');
             await expectNativeState(browser, id, 'focused', true);
+            await expect(await browser.$(`~${id}-indicator`)).toHaveText('true');
+            if (suffix === '-readonly') {
+              expect(await field.getTagName()).toBe('textbox');
+              await expect(field).toBeEnabled();
+              await browser.keys('x');
+              await expect(field).toHaveValue('Read only');
+              await expectNativeState(browser, id, 'focused', true);
+            }
+            const after = await browser.getElementRect(await field.elementId);
+            expect({ width: after.width, height: after.height }).toEqual({ width: before.width, height: before.height });
           }
-          const after = await browser.getElementRect(await field.elementId);
-          expect({ width: after.width, height: after.height }).toEqual({ width: before.width, height: before.height });
         }
-      }
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-field-after', 'focused', true);
-      await expectNativeState(browser, 'focus-field-disabled', 'focused', false);
-    },
-  },
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-field-after', 'focused', true);
+        await expectNativeState(browser, 'focus-field-disabled', 'focused', false);
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/components/listbox-item/listbox-item.stories.tsx b/packages/agentic/components/src/components/listbox-item/listbox-item.stories.tsx
index c5cad07c83..4dbe50eb47 100644
--- a/packages/agentic/components/src/components/listbox-item/listbox-item.stories.tsx
+++ b/packages/agentic/components/src/components/listbox-item/listbox-item.stories.tsx
@@ -5,6 +5,7 @@ import { StyleSheet, Text, View } from 'react-native';
 import type { AccessibilityActionEvent, ViewProps } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 import { directComponent } from '@fluentui-react-native/framework-base';
 
@@ -92,39 +93,38 @@ export const NativeSelection: Story = {
       <ListboxItem content="Disabled selected option" selected disabled testID="listbox-fix-disabled" />
     </View>
   ),
-  wdio: {
-    'LBI-005 standalone unselected exposes an enabled native button': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('LBI-005 standalone unselected exposes an enabled native button', async ({ browser, expect }) => {
       const option = await browser.$('~listbox-fix-unselected');
       expect(await option.getTagName()).toBe('button');
       await expect(option).toBeEnabled();
-    },
-    'LBI-005 standalone selected exposes an enabled native button': async ({ browser, expect }) => {
+    }),
+    desktopIt('LBI-005 standalone selected exposes an enabled native button', async ({ browser, expect }) => {
       const option = await browser.$('~listbox-fix-selected');
       expect(await option.getTagName()).toBe('button');
       await expect(option).toBeEnabled();
-    },
-    'LBI-005 standalone disabled selection exposes a disabled native button': async ({ browser, expect }) => {
+    }),
+    desktopIt('LBI-005 standalone disabled selection exposes a disabled native button', async ({ browser, expect }) => {
       const option = await browser.$('~listbox-fix-disabled');
       expect(await option.getTagName()).toBe('button');
       await expect(option).toBeDisabled();
-    },
-    'LBI-005 Windows native checked projection reflects standalone selection including disabled': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform === 'macos') {
-        skip(
-          'Native checked projection is unsupported for the retained macOS AXButton role; shared role and enabled-state checks run separately.',
-        );
-        return;
-      }
-      expect(await (await browser.$('~listbox-fix-unselected')).getProperty('checked')).toBe(false);
-      expect(await (await browser.$('~listbox-fix-selected')).getProperty('checked')).toBe(true);
-      expect(await (await browser.$('~listbox-fix-disabled')).getProperty('checked')).toBe(true);
-    },
-  },
+    }),
+    desktopIt(
+      'LBI-005 Windows native checked projection reflects standalone selection including disabled',
+      {
+        unsupported: {
+          platforms: ['macos'],
+          reason:
+            'Native checked projection is unsupported for the retained macOS AXButton role (C-A11Y-005); shared role and enabled-state checks run separately.',
+        },
+      },
+      async ({ browser, expect }) => {
+        expect(await (await browser.$('~listbox-fix-unselected')).getProperty('checked')).toBe(false);
+        expect(await (await browser.$('~listbox-fix-selected')).getProperty('checked')).toBe(true);
+        expect(await (await browser.$('~listbox-fix-disabled')).getProperty('checked')).toBe(true);
+      },
+    ),
+  ],
 };
 
 export const NativeToggleActions: Story = {
@@ -137,63 +137,45 @@ export const NativeToggleActions: Story = {
       },
     },
   },
-  wdio: {
-    'LBI-005 Win32 native Toggle forwards once without a press or controlled selection change': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies the Win32 Toggle action transport; other hosts require their own action invocation.');
-        return;
-      }
-      if (!browser.capabilities['furn:features']?.accessibilityClick) {
-        skip('Native accessibility click is unavailable.');
-        return;
-      }
-      expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
-      const option = await browser.$('~listbox-toggle-option');
-      const actions = await browser.$('~listbox-toggle-actions');
-      const presses = await browser.$('~listbox-toggle-presses');
-      expect(await option.getProperty('checked')).toBe(true);
-      await expect(actions).toHaveAttribute('name', '0:none');
-      await expect(presses).toHaveAttribute('name', '0');
-      await option.click();
-      await expect(actions).toHaveAttribute('name', '1:Toggle');
-      expect(await option.getProperty('checked')).toBe(true);
-      await expect(presses).toHaveAttribute('name', '0');
-      await expect(actions).toHaveAttribute('name', '1:Toggle');
-    },
-    'LBI-003 LBI-005 Win32 disabled native activation has no callbacks or selection change': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies the Win32 disabled accessibility-click route.');
-        return;
-      }
-      if (!browser.capabilities['furn:features']?.accessibilityClick) {
-        skip('Native accessibility click is unavailable.');
-        return;
-      }
-      expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
-      const option = await browser.$('~listbox-toggle-disabled');
-      const actions = await browser.$('~listbox-toggle-disabled-actions');
-      const presses = await browser.$('~listbox-toggle-disabled-presses');
-      await expect(option).toBeDisabled();
-      expect(await option.getProperty('checked')).toBe(true);
-      await expect(actions).toHaveAttribute('name', '0');
-      await expect(presses).toHaveAttribute('name', '0');
-      // The public protocol command avoids WDIO's DOM-based element-error recovery.
-      await expect(browser.elementClick(await option.elementId)).rejects.toThrow('cannot be clicked');
-      expect(await option.getProperty('checked')).toBe(true);
-      await expect(actions).toHaveAttribute('name', '0');
-      await expect(presses).toHaveAttribute('name', '0');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'LBI-005 Win32 native Toggle forwards once without a press or controlled selection change',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
+        const option = await browser.$('~listbox-toggle-option');
+        const actions = await browser.$('~listbox-toggle-actions');
+        const presses = await browser.$('~listbox-toggle-presses');
+        expect(await option.getProperty('checked')).toBe(true);
+        await expect(actions).toHaveAttribute('name', '0:none');
+        await expect(presses).toHaveAttribute('name', '0');
+        await option.click();
+        await expect(actions).toHaveAttribute('name', '1:Toggle');
+        expect(await option.getProperty('checked')).toBe(true);
+        await expect(presses).toHaveAttribute('name', '0');
+        await expect(actions).toHaveAttribute('name', '1:Toggle');
+      },
+    ),
+    desktopIt(
+      'LBI-003 LBI-005 Win32 disabled native activation has no callbacks or selection change',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        expect(browser.capabilities['furn:clickMode']).toBe('accessibility');
+        const option = await browser.$('~listbox-toggle-disabled');
+        const actions = await browser.$('~listbox-toggle-disabled-actions');
+        const presses = await browser.$('~listbox-toggle-disabled-presses');
+        await expect(option).toBeDisabled();
+        expect(await option.getProperty('checked')).toBe(true);
+        await expect(actions).toHaveAttribute('name', '0');
+        await expect(presses).toHaveAttribute('name', '0');
+        // The public protocol command avoids WDIO's DOM-based element-error recovery.
+        await expect(browser.elementClick(await option.elementId)).rejects.toThrow('cannot be clicked');
+        expect(await option.getProperty('checked')).toBe(true);
+        await expect(actions).toHaveAttribute('name', '0');
+        await expect(presses).toHaveAttribute('name', '0');
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/components/menu-button/menu-button.stories.tsx b/packages/agentic/components/src/components/menu-button/menu-button.stories.tsx
index f83a332e00..435caff5d6 100644
--- a/packages/agentic/components/src/components/menu-button/menu-button.stories.tsx
+++ b/packages/agentic/components/src/components/menu-button/menu-button.stories.tsx
@@ -3,6 +3,7 @@ import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -102,42 +103,44 @@ export default meta;
 type Story = WdioStory<StoryObj<SceneProps>>;
 export const Default: Story = {
   tags: ['desktop-focus'],
-  wdio: {
-    'MNB-006 exposes a named, collapsed native button before input': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('MNB-006 exposes a named, collapsed native button before input', async ({ browser, expect }) => {
       const trigger = await browser.$('~menu-button-trigger');
       expect(await trigger.getProperty('role')).toBe('button');
       expect(await trigger.getProperty('name')).toBe('New');
       expect(await trigger.getProperty('expanded')).toBe(false);
       await expect(trigger).toBeEnabled();
-    },
-    'opens on Down to the first row and on Up to the last row': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { inWindowWith } = await import('../menu/menu.wdio.ts');
-      const { browser, expect } = context;
-      await (await import('../../common/desktopFocus.wdio.ts')).focusByTab(context.browser, 'menu-button-entry', 'menu-button-trigger');
-      expect(await (await browser.$('~menu-button-trigger')).getProperty('role')).toBe('button');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
-      expect(await (await browser.$('~menu-button-trigger')).getProperty('expanded')).toBe(true);
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~menu-button-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
-      await browser.keys('\uE013');
-      await expect(await browser.$('~menu-button-focus')).toHaveText('Folder');
-      await browser.keys('\uE007');
-      await expect(await browser.$('~menu-button-action')).toHaveText('Folder');
-      await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
-      await inWindowWith(context, 'menu-button-menu', async () => {
-        expect(await (await browser.$('~menu-button-menu')).getProperty('role')).toBe('menu');
-        expect(await (await browser.$('~menu-button-menu')).getProperty('name')).toBe('New');
-      });
-    },
-    'closes on Tab and moves focus past the trigger': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+    }),
+    desktopIt(
+      'opens on Down to the first row and on Up to the last row',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { inWindowWith } = await import('../menu/menu.wdio.ts');
+        const { browser, expect } = context;
+        await (await import('../../common/desktopFocus.wdio.ts')).focusByTab(context.browser, 'menu-button-entry', 'menu-button-trigger');
+        expect(await (await browser.$('~menu-button-trigger')).getProperty('role')).toBe('button');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
+        expect(await (await browser.$('~menu-button-trigger')).getProperty('expanded')).toBe(true);
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~menu-button-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
+        await browser.keys('\uE013');
+        await expect(await browser.$('~menu-button-focus')).toHaveText('Folder');
+        await browser.keys('\uE007');
+        await expect(await browser.$('~menu-button-action')).toHaveText('Folder');
+        await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
+        await inWindowWith(context, 'menu-button-menu', async () => {
+          expect(await (await browser.$('~menu-button-menu')).getProperty('role')).toBe('menu');
+          expect(await (await browser.$('~menu-button-menu')).getProperty('name')).toBe('New');
+        });
+      },
+    ),
+    desktopIt('closes on Tab and moves focus past the trigger', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { expectMenuClosed } = await import('../menu/menu.wdio.ts');
       const { browser, expect } = context;
       await (await import('../../common/desktopFocus.wdio.ts')).focusByTab(context.browser, 'menu-button-entry', 'menu-button-trigger');
@@ -148,21 +151,22 @@ export const Default: Story = {
       // The Win32 host cannot continue Tab past its owner, so focus returns to the trigger there.
       await expectNativeState(browser, context.platform === 'win32' ? 'menu-button-trigger' : 'menu-button-after', 'focused', true);
       await expectMenuClosed(context, 'menu-button-trigger');
-    },
-    'closes on Shift+Tab and returns focus to the trigger': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (await import('../../common/desktopFocus.wdio.ts')).focusByTab(context.browser, 'menu-button-entry', 'menu-button-trigger');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
-      await browser.keys(['\uE008', '\uE004']);
-      await expect(await browser.$('~menu-button-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
-    },
-    'toggles from the pointer without reopening': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+    }),
+    desktopIt(
+      'closes on Shift+Tab and returns focus to the trigger',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (await import('../../common/desktopFocus.wdio.ts')).focusByTab(context.browser, 'menu-button-entry', 'menu-button-trigger');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-button-focus')).toHaveText('Message');
+        await browser.keys(['\uE008', '\uE004']);
+        await expect(await browser.$('~menu-button-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'menu-button-trigger', 'focused', true);
+      },
+    ),
+    desktopIt('toggles from the pointer without reopening', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
       const { expectMenuClosed } = await import('../menu/menu.wdio.ts');
       const { browser, expect } = context;
       const trigger = await browser.$('~menu-button-trigger');
@@ -171,8 +175,8 @@ export const Default: Story = {
       await trigger.click();
       await expect(await browser.$('~menu-button-reason')).toHaveText('Closed: trigger');
       await expectMenuClosed(context, 'menu-button-trigger');
-    },
-  },
+    }),
+  ],
 };
 
 export const Variants: Story = {
@@ -199,14 +203,14 @@ export const AccessibleNames: Story = {
       </MenuButton>
     </View>
   ),
-  wdio: {
-    'MNB-006 exposes slot, numeric and explicit native names without input': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('MNB-006 exposes slot, numeric and explicit native names without input', async ({ browser, expect }) => {
       expect(await (await browser.$('~menu-button-slot-name')).getProperty('name')).toBe('Create');
       expect(await (await browser.$('~menu-button-numeric-name')).getProperty('name')).toBe('0');
       expect(await (await browser.$('~menu-button-explicit-name')).getProperty('name')).toBe('Create document');
       expect(await (await browser.$('~menu-button-alias-name')).getProperty('name')).toBe('More actions');
-    },
-  },
+    }),
+  ],
   parameters: {
     docs: {
       description: {
diff --git a/packages/agentic/components/src/components/menu-item/menu-item.stories.tsx b/packages/agentic/components/src/components/menu-item/menu-item.stories.tsx
index 9ca5e46619..49cb3f195b 100644
--- a/packages/agentic/components/src/components/menu-item/menu-item.stories.tsx
+++ b/packages/agentic/components/src/components/menu-item/menu-item.stories.tsx
@@ -5,6 +5,7 @@ import { StyleSheet, Text, View } from 'react-native';
 import type { AccessibilityActionEvent } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 import { FocusZone } from '@fluentui-react-native/native-core/legacy';
 
@@ -97,60 +98,55 @@ export const NativeIndicatorSemantics: Story = {
     };
     return <Scene />;
   },
-  wdio: {
-    'MNI-003 Win32 exposes checked native indicator roles, names and availability': async ({ browser, expect, platform, skip }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies Win32 UI Automation indicator-state projection.');
-        return;
-      }
-      for (const [id, name, checked] of [
-        ['menu-item-native-single-off', 'Single choice off', false],
-        ['menu-item-native-single-on', 'Single choice on', true],
-        ['menu-item-native-multi-off', 'Multiple choice off', false],
-        ['menu-item-native-multi-on', 'Multiple choice on', true],
-        ['menu-item-native-disabled', 'Disabled choice', true],
-      ] as const) {
-        const row = await browser.$(`~${id}`);
-        expect(await row.getTagName()).toBe('menuitem');
-        expect(await row.getProperty('name')).toBe(name);
-        expect(await row.getProperty('checked')).toBe(checked);
-      }
-      expect(await (await browser.$('~menu-item-native-single-off')).getProperty('selected')).toBe(false);
-      expect(await (await browser.$('~menu-item-native-single-on')).getProperty('selected')).toBe(true);
-      await expect(await browser.$('~menu-item-native-disabled')).toBeDisabled();
-    },
-    'MNI-003 Win32 Toggle forwards once without changing selection or pressing and disabled public activation rejects': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies Win32 UI Automation Toggle transport.');
-        return;
-      }
-      const row = await browser.$('~menu-item-native-multi-off');
-      const disabled = await browser.$('~menu-item-native-disabled');
-      const actions = await browser.$('~menu-item-native-actions');
-      const presses = await browser.$('~menu-item-native-presses');
-      await expect(actions).toHaveAttribute('name', '0');
-      await row.click();
-      await expect(actions).toHaveAttribute('name', '1');
-      await expect(await browser.$('~menu-item-native-last-action')).toHaveAttribute('name', 'Toggle');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await row.getProperty('checked')).toBe(false);
-      let rejection: unknown;
-      try {
-        await disabled.click();
-      } catch (error) {
-        rejection = error;
-      }
-      expect(rejection).toBeDefined();
-      await expect(actions).toHaveAttribute('name', '1');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await disabled.getProperty('checked')).toBe(true);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'MNI-003 Win32 exposes checked native indicator roles, names and availability',
+      { platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        for (const [id, name, checked] of [
+          ['menu-item-native-single-off', 'Single choice off', false],
+          ['menu-item-native-single-on', 'Single choice on', true],
+          ['menu-item-native-multi-off', 'Multiple choice off', false],
+          ['menu-item-native-multi-on', 'Multiple choice on', true],
+          ['menu-item-native-disabled', 'Disabled choice', true],
+        ] as const) {
+          const row = await browser.$(`~${id}`);
+          expect(await row.getTagName()).toBe('menuitem');
+          expect(await row.getProperty('name')).toBe(name);
+          expect(await row.getProperty('checked')).toBe(checked);
+        }
+        expect(await (await browser.$('~menu-item-native-single-off')).getProperty('selected')).toBe(false);
+        expect(await (await browser.$('~menu-item-native-single-on')).getProperty('selected')).toBe(true);
+        await expect(await browser.$('~menu-item-native-disabled')).toBeDisabled();
+      },
+    ),
+    desktopIt(
+      'MNI-003 Win32 Toggle forwards once without changing selection or pressing and disabled public activation rejects',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        const row = await browser.$('~menu-item-native-multi-off');
+        const disabled = await browser.$('~menu-item-native-disabled');
+        const actions = await browser.$('~menu-item-native-actions');
+        const presses = await browser.$('~menu-item-native-presses');
+        await expect(actions).toHaveAttribute('name', '0');
+        await row.click();
+        await expect(actions).toHaveAttribute('name', '1');
+        await expect(await browser.$('~menu-item-native-last-action')).toHaveAttribute('name', 'Toggle');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await row.getProperty('checked')).toBe(false);
+        let rejection: unknown;
+        try {
+          await disabled.click();
+        } catch (error) {
+          rejection = error;
+        }
+        expect(rejection).toBeDefined();
+        await expect(actions).toHaveAttribute('name', '1');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await disabled.getProperty('checked')).toBe(true);
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
@@ -274,48 +270,51 @@ export const DisabledFocusable: Story = {
   parameters: {
     docs: { description: { story: 'An opted-in disabled row remains a focus stop, announces disabled, and cannot activate.' } },
   },
-  wdio: {
-    'exposes disabled native menu-item semantics': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('exposes disabled native menu-item semantics', async ({ browser, expect }) => {
       const row = await browser.$('~disabled-menu-command');
       expect(await row.getTagName()).toBe('menuitem');
       await expect(row).toBeDisabled();
       await expect(await browser.$('~disabled-menu-count')).toHaveText('0');
-    },
-    'navigates onto a disabled row without activating it': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab, clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await focusByTab(browser, 'disabled-menu-entry', 'disabled-menu-before');
-      await browser.keys('\uE015');
-      await expectNativeState(browser, 'disabled-menu-command', 'focused', true);
-      await expect(await browser.$('~disabled-menu-command')).toBeDisabled();
-      await browser.keys('\uE007');
-      await browser.keys('\uE00D');
-      await clickPhysical(browser, 'disabled-menu-command');
-      await expect(await browser.$('~disabled-menu-count')).toHaveText('0');
-      await expectNativeState(browser, 'disabled-menu-command', 'focused', true);
-      await browser.keys('\uE015');
-      await expectNativeState(browser, 'disabled-menu-after', 'focused', true);
-    },
-    'updates native disabled state without replacing the command': async ({ browser, expect, skip }) => {
-      if (!browser.capabilities['furn:features']?.physicalClick) {
-        skip('Changing availability requires physical pointer input.');
-        return;
-      }
-      const row = await browser.$('~disabled-menu-command');
-      const { clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
-      await expect(row).toBeDisabled();
-      await (await browser.$('~disabled-menu-toggle')).click();
-      await expect(row).toBeEnabled();
-      expect(await row.getTagName()).toBe('menuitem');
-      await clickPhysical(browser, 'disabled-menu-command');
-      await expect(await browser.$('~disabled-menu-count')).toHaveText('1');
-      await (await browser.$('~disabled-menu-toggle')).click();
-      await expect(row).toBeDisabled();
-      await clickPhysical(browser, 'disabled-menu-command');
-      await expect(await browser.$('~disabled-menu-count')).toHaveText('1');
-    },
-  },
+    }),
+    desktopIt(
+      'navigates onto a disabled row without activating it',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab, clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await focusByTab(browser, 'disabled-menu-entry', 'disabled-menu-before');
+        await browser.keys('\uE015');
+        await expectNativeState(browser, 'disabled-menu-command', 'focused', true);
+        await expect(await browser.$('~disabled-menu-command')).toBeDisabled();
+        await browser.keys('\uE007');
+        await browser.keys('\uE00D');
+        await clickPhysical(browser, 'disabled-menu-command');
+        await expect(await browser.$('~disabled-menu-count')).toHaveText('0');
+        await expectNativeState(browser, 'disabled-menu-command', 'focused', true);
+        await browser.keys('\uE015');
+        await expectNativeState(browser, 'disabled-menu-after', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'updates native disabled state without replacing the command',
+      { requires: ['physical-click'] },
+      async ({ browser, expect }) => {
+        const row = await browser.$('~disabled-menu-command');
+        const { clickPhysical } = await import('../../common/desktopFocus.wdio.ts');
+        await expect(row).toBeDisabled();
+        await (await browser.$('~disabled-menu-toggle')).click();
+        await expect(row).toBeEnabled();
+        expect(await row.getTagName()).toBe('menuitem');
+        await clickPhysical(browser, 'disabled-menu-command');
+        await expect(await browser.$('~disabled-menu-count')).toHaveText('1');
+        await (await browser.$('~disabled-menu-toggle')).click();
+        await expect(row).toBeDisabled();
+        await clickPhysical(browser, 'disabled-menu-command');
+        await expect(await browser.$('~disabled-menu-count')).toHaveText('1');
+      },
+    ),
+  ],
 };
 
 const styles = StyleSheet.create({
diff --git a/packages/agentic/components/src/components/menu/menu.stories.tsx b/packages/agentic/components/src/components/menu/menu.stories.tsx
index 131aead60f..c4018672bc 100644
--- a/packages/agentic/components/src/components/menu/menu.stories.tsx
+++ b/packages/agentic/components/src/components/menu/menu.stories.tsx
@@ -3,6 +3,7 @@ import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -112,45 +113,47 @@ type Story = WdioStory<StoryObj<SceneProps>>;
 
 export const Default: Story = {
   tags: ['desktop-focus'],
-  wdio: {
-    'opens from the keyboard on the first row and closes on activation': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (
-        await import('./menu.wdio.ts')
-      ).openMenuFromKeyboard(context, {
-        entry: 'menu-entry',
-        trigger: 'menu-trigger',
-        reason: 'menu-reason',
-        focus: 'menu-focus',
-        first: 'Cut',
-      });
-      expect(await (await browser.$('~menu-trigger')).getProperty('expanded')).toBe(true);
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('Copy');
-      // The disabled Paste row is a focus stop by default on Windows and Win32, but not on macOS.
-      const pasteStops = context.platform !== 'macos';
-      if (pasteStops) {
+  wdio: [
+    desktopIt(
+      'opens from the keyboard on the first row and closes on activation',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (
+          await import('./menu.wdio.ts')
+        ).openMenuFromKeyboard(context, {
+          entry: 'menu-entry',
+          trigger: 'menu-trigger',
+          reason: 'menu-reason',
+          focus: 'menu-focus',
+          first: 'Cut',
+        });
+        expect(await (await browser.$('~menu-trigger')).getProperty('expanded')).toBe(true);
         await browser.keys('\uE015');
-        await expect(await browser.$('~menu-focus')).toHaveText('Paste');
-      }
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('Share');
-      await browser.keys('\uE013');
-      if (pasteStops) {
-        await expect(await browser.$('~menu-focus')).toHaveText('Paste');
+        await expect(await browser.$('~menu-focus')).toHaveText('Copy');
+        // The disabled Paste row is a focus stop by default on Windows and Win32, but not on macOS.
+        const pasteStops = context.platform !== 'macos';
+        if (pasteStops) {
+          await browser.keys('\uE015');
+          await expect(await browser.$('~menu-focus')).toHaveText('Paste');
+        }
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-focus')).toHaveText('Share');
         await browser.keys('\uE013');
-      }
-      await expect(await browser.$('~menu-focus')).toHaveText('Copy');
-      await browser.keys('\uE007');
-      await expect(await browser.$('~menu-action')).toHaveText('Copy');
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: action');
-      await expectNativeState(browser, 'menu-trigger', 'focused', true);
-    },
-    'navigates with Home, End, and type-ahead': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+        if (pasteStops) {
+          await expect(await browser.$('~menu-focus')).toHaveText('Paste');
+          await browser.keys('\uE013');
+        }
+        await expect(await browser.$('~menu-focus')).toHaveText('Copy');
+        await browser.keys('\uE007');
+        await expect(await browser.$('~menu-action')).toHaveText('Copy');
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: action');
+        await expectNativeState(browser, 'menu-trigger', 'focused', true);
+      },
+    ),
+    desktopIt('navigates with Home, End, and type-ahead', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { browser, expect } = context;
       await (
         await import('./menu.wdio.ts')
@@ -174,128 +177,140 @@ export const Default: Story = {
       await browser.keys('\uE00C');
       await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
       await expectNativeState(browser, 'menu-trigger', 'focused', true);
-    },
-    'opens and closes two submenu levels with arrows and Escape': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (
-        await import('./menu.wdio.ts')
-      ).openMenuFromKeyboard(context, {
-        entry: 'menu-entry',
-        trigger: 'menu-trigger',
-        reason: 'menu-reason',
-        focus: 'menu-focus',
-        first: 'Cut',
-      });
-      await browser.keys('s');
-      await expect(await browser.$('~menu-focus')).toHaveText('Share');
-      await browser.keys('\uE014');
-      await expect(await browser.$('~menu-focus')).toHaveText('Email');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('More');
-      await browser.keys('\uE014');
-      await expect(await browser.$('~menu-focus')).toHaveText('Print');
-      // A restored row was already its popup's first responder, so its focus is observed through the next arrow key.
-      await browser.keys('\uE012');
-      await browser.keys('\uE013');
-      await expect(await browser.$('~menu-focus')).toHaveText('Email');
-      await browser.keys('\uE00C');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('Delete');
-      expect(await (await browser.$('~menu-reason')).getText()).toBe('Opened: trigger');
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'menu-trigger', 'focused', true);
-    },
-    'closes the whole menu on Tab from a submenu and returns to the trigger': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectMenuClosed } = await import('./menu.wdio.ts');
-      const { browser, expect } = context;
-      await (
-        await import('./menu.wdio.ts')
-      ).openMenuFromKeyboard(context, {
-        entry: 'menu-entry',
-        trigger: 'menu-trigger',
-        reason: 'menu-reason',
-        focus: 'menu-focus',
-        first: 'Cut',
-      });
-      await browser.keys('s');
-      await browser.keys('\uE014');
-      await expect(await browser.$('~menu-focus')).toHaveText('Email');
-      await browser.keys('\uE004');
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
-      await expectMenuClosed(context, 'menu-trigger');
-      await expectNativeState(browser, 'menu-trigger', 'focused', true);
-    },
-    'exposes named menu surfaces and submenu expanded state': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectMenuClosed, inWindowWith } = await import('./menu.wdio.ts');
-      const { browser, expect } = context;
-      await (
-        await import('./menu.wdio.ts')
-      ).openMenuFromKeyboard(context, {
-        entry: 'menu-entry',
-        trigger: 'menu-trigger',
-        reason: 'menu-reason',
-        focus: 'menu-focus',
-        first: 'Cut',
-      });
-      await browser.keys('s');
-      await browser.keys('\uE014');
-      await expect(await browser.$('~menu-focus')).toHaveText('Email');
-      // Inspecting another window moves key status, so semantics are read after the keyboard steps.
-      expect(await (await browser.$('~menu-trigger')).getProperty('expanded')).toBe(true);
-      await inWindowWith(context, 'menu-surface', async () => {
-        const surface = await browser.$('~menu-surface');
-        expect(await surface.getProperty('role')).toBe('menu');
-        expect(await surface.getProperty('name')).toBe('Edit');
-        expect(await (await browser.$('~menu-share')).getProperty('expanded')).toBe(true);
-        expect(await (await browser.$('~menu-paste')).getProperty('enabled')).toBe(false);
-      });
-      await inWindowWith(context, 'menu-share-surface', async () => {
-        const surface = await browser.$('~menu-share-surface');
-        expect(await surface.getProperty('role')).toBe('menu');
-        expect(await surface.getProperty('name')).toBe('Share');
-      });
-      await (await browser.$('~menu-trigger')).click();
-      await expectMenuClosed(context, 'menu-trigger');
-    },
-    'opens from the pointer without a focused row and enters on Down': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectMenuClosed } = await import('./menu.wdio.ts');
-      const { browser, expect } = context;
-      await (await browser.$('~menu-trigger')).click();
-      await expect(await browser.$('~menu-reason')).toHaveText('Opened: trigger');
-      await browser.pause(300);
-      expect(await (await browser.$('~menu-focus')).getText()).toBe('None');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('Cut');
-      await (await browser.$('~menu-trigger')).click();
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: trigger');
-      await expectMenuClosed(context, 'menu-trigger');
-    },
-    'opens submenus on hover and closes the family when a nested row runs': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectMenuClosed, hover, inWindowWith } = await import('./menu.wdio.ts');
-      const { browser, expect } = context;
-      await (await browser.$('~menu-trigger')).click();
-      await expect(await browser.$('~menu-reason')).toHaveText('Opened: trigger');
-      await hover(context, 'menu-share');
-      await hover(context, 'menu-more');
-      await inWindowWith(context, 'menu-export', async () => {
-        await (await browser.$('~menu-export')).click();
-      });
-      await expect(await browser.$('~menu-action')).toHaveText('Export');
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: action');
-      await expectMenuClosed(context, 'menu-trigger');
-    },
-  },
+    }),
+    desktopIt(
+      'opens and closes two submenu levels with arrows and Escape',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await (
+          await import('./menu.wdio.ts')
+        ).openMenuFromKeyboard(context, {
+          entry: 'menu-entry',
+          trigger: 'menu-trigger',
+          reason: 'menu-reason',
+          focus: 'menu-focus',
+          first: 'Cut',
+        });
+        await browser.keys('s');
+        await expect(await browser.$('~menu-focus')).toHaveText('Share');
+        await browser.keys('\uE014');
+        await expect(await browser.$('~menu-focus')).toHaveText('Email');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-focus')).toHaveText('More');
+        await browser.keys('\uE014');
+        await expect(await browser.$('~menu-focus')).toHaveText('Print');
+        // A restored row was already its popup's first responder, so its focus is observed through the next arrow key.
+        await browser.keys('\uE012');
+        await browser.keys('\uE013');
+        await expect(await browser.$('~menu-focus')).toHaveText('Email');
+        await browser.keys('\uE00C');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-focus')).toHaveText('Delete');
+        expect(await (await browser.$('~menu-reason')).getText()).toBe('Opened: trigger');
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'menu-trigger', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'closes the whole menu on Tab from a submenu and returns to the trigger',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { expectMenuClosed } = await import('./menu.wdio.ts');
+        const { browser, expect } = context;
+        await (
+          await import('./menu.wdio.ts')
+        ).openMenuFromKeyboard(context, {
+          entry: 'menu-entry',
+          trigger: 'menu-trigger',
+          reason: 'menu-reason',
+          focus: 'menu-focus',
+          first: 'Cut',
+        });
+        await browser.keys('s');
+        await browser.keys('\uE014');
+        await expect(await browser.$('~menu-focus')).toHaveText('Email');
+        await browser.keys('\uE004');
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
+        await expectMenuClosed(context, 'menu-trigger');
+        await expectNativeState(browser, 'menu-trigger', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'exposes named menu surfaces and submenu expanded state',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectMenuClosed, inWindowWith } = await import('./menu.wdio.ts');
+        const { browser, expect } = context;
+        await (
+          await import('./menu.wdio.ts')
+        ).openMenuFromKeyboard(context, {
+          entry: 'menu-entry',
+          trigger: 'menu-trigger',
+          reason: 'menu-reason',
+          focus: 'menu-focus',
+          first: 'Cut',
+        });
+        await browser.keys('s');
+        await browser.keys('\uE014');
+        await expect(await browser.$('~menu-focus')).toHaveText('Email');
+        // Inspecting another window moves key status, so semantics are read after the keyboard steps.
+        expect(await (await browser.$('~menu-trigger')).getProperty('expanded')).toBe(true);
+        await inWindowWith(context, 'menu-surface', async () => {
+          const surface = await browser.$('~menu-surface');
+          expect(await surface.getProperty('role')).toBe('menu');
+          expect(await surface.getProperty('name')).toBe('Edit');
+          expect(await (await browser.$('~menu-share')).getProperty('expanded')).toBe(true);
+          expect(await (await browser.$('~menu-paste')).getProperty('enabled')).toBe(false);
+        });
+        await inWindowWith(context, 'menu-share-surface', async () => {
+          const surface = await browser.$('~menu-share-surface');
+          expect(await surface.getProperty('role')).toBe('menu');
+          expect(await surface.getProperty('name')).toBe('Share');
+        });
+        await (await browser.$('~menu-trigger')).click();
+        await expectMenuClosed(context, 'menu-trigger');
+      },
+    ),
+    desktopIt(
+      'opens from the pointer without a focused row and enters on Down',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectMenuClosed } = await import('./menu.wdio.ts');
+        const { browser, expect } = context;
+        await (await browser.$('~menu-trigger')).click();
+        await expect(await browser.$('~menu-reason')).toHaveText('Opened: trigger');
+        await browser.pause(300);
+        expect(await (await browser.$('~menu-focus')).getText()).toBe('None');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-focus')).toHaveText('Cut');
+        await (await browser.$('~menu-trigger')).click();
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: trigger');
+        await expectMenuClosed(context, 'menu-trigger');
+      },
+    ),
+    desktopIt(
+      'opens submenus on hover and closes the family when a nested row runs',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectMenuClosed, hover, inWindowWith } = await import('./menu.wdio.ts');
+        const { browser, expect } = context;
+        await (await browser.$('~menu-trigger')).click();
+        await expect(await browser.$('~menu-reason')).toHaveText('Opened: trigger');
+        await hover(context, 'menu-share');
+        await hover(context, 'menu-more');
+        await inWindowWith(context, 'menu-export', async () => {
+          await (await browser.$('~menu-export')).click();
+        });
+        await expect(await browser.$('~menu-action')).toHaveText('Export');
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: action');
+        await expectMenuClosed(context, 'menu-trigger');
+      },
+    ),
+  ],
 };
 
 export const DisabledFocusable: Story = {
@@ -304,31 +319,33 @@ export const DisabledFocusable: Story = {
   parameters: {
     docs: { description: { story: 'Disabled rows stay discoverable as focus stops and refuse activation.' } },
   },
-  wdio: {
-    'keeps a disabled row focusable without running it': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (
-        await import('./menu.wdio.ts')
-      ).openMenuFromKeyboard(context, {
-        entry: 'menu-entry',
-        trigger: 'menu-trigger',
-        reason: 'menu-reason',
-        focus: 'menu-focus',
-        first: 'Cut',
-      });
-      await browser.keys('\uE015');
-      await browser.keys('\uE015');
-      await expect(await browser.$('~menu-focus')).toHaveText('Paste');
-      await browser.keys('\uE007');
-      await browser.pause(300);
-      expect(await (await browser.$('~menu-action')).getText()).toBe('None');
-      expect(await (await browser.$('~menu-reason')).getText()).toBe('Opened: trigger');
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'keeps a disabled row focusable without running it',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { browser, expect } = context;
+        await (
+          await import('./menu.wdio.ts')
+        ).openMenuFromKeyboard(context, {
+          entry: 'menu-entry',
+          trigger: 'menu-trigger',
+          reason: 'menu-reason',
+          focus: 'menu-focus',
+          first: 'Cut',
+        });
+        await browser.keys('\uE015');
+        await browser.keys('\uE015');
+        await expect(await browser.$('~menu-focus')).toHaveText('Paste');
+        await browser.keys('\uE007');
+        await browser.pause(300);
+        expect(await (await browser.$('~menu-action')).getText()).toBe('None');
+        expect(await (await browser.$('~menu-reason')).getText()).toBe('Opened: trigger');
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~menu-reason')).toHaveText('Closed: dismiss');
+      },
+    ),
+  ],
 };
 
 const styles = StyleSheet.create({
diff --git a/packages/agentic/components/src/components/popover/popover.stories.tsx b/packages/agentic/components/src/components/popover/popover.stories.tsx
index 578bfaa073..00ecce4427 100644
--- a/packages/agentic/components/src/components/popover/popover.stories.tsx
+++ b/packages/agentic/components/src/components/popover/popover.stories.tsx
@@ -3,6 +3,7 @@ import * as React from 'react';
 import { StyleSheet, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -127,64 +128,71 @@ type Story = WdioStory<StoryObj<SceneProps>>;
 
 export const Default: Story = {
   tags: ['desktop-focus'],
-  wdio: {
-    'opens below the trigger as a named group and enters its first content': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { inPopupWindow, ownerScreenRect, surfaceScreenRect } = await import('./popover.wdio.ts');
-      const { browser, expect } = context;
-      const trigger = await browser.$('~popover-trigger');
-      expect(await trigger.getProperty('expanded')).toBe(false);
-      await trigger.click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~popover-focus')).toHaveText('First');
-      expect(await trigger.getProperty('expanded')).toBe(true);
-      await inPopupWindow(context, async () => {
-        const surface = await browser.$('~popover-surface');
-        expect(await surface.getProperty('role')).toBe('group');
-        expect(await surface.getProperty('name')).toBe('File details');
-      });
-      const anchor = await ownerScreenRect(context, 'popover-trigger');
-      const popup = await surfaceScreenRect(context, 'popover-surface');
-      // The Win32 host ignores the placement gap and places the popup flush against the trigger.
-      const gap = context.platform === 'win32' ? 0 : 4;
-      expect(Math.abs(popup.x + popup.width / 2 - (anchor.x + anchor.width / 2))).toBeLessThanOrEqual(1);
-      expect(Math.abs(popup.y - (anchor.y + anchor.height + gap))).toBeLessThanOrEqual(1);
-    },
-    'keeps Tab inside the popup and returns focus to the trigger on Escape': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await focusByTab(browser, 'popover-entry', 'popover-trigger');
-      await browser.keys('\uE007');
-      await expect(await browser.$('~popover-focus')).toHaveText('First');
-      await browser.keys('\uE004');
-      await expect(await browser.$('~popover-focus')).toHaveText('Second');
-      await browser.keys('\uE004');
-      await expect(await browser.$('~popover-focus')).toHaveText('First');
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
-      await expectNativeState(browser, 'popover-trigger', 'focused', true);
-    },
-    'closes on outside input and on a trigger press without reopening': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectClosed } = await import('./popover.wdio.ts');
-      const { browser, expect } = context;
-      const trigger = await browser.$('~popover-trigger');
-      await trigger.click();
-      await expect(await browser.$('~popover-focus')).toHaveText('First');
-      await (await browser.$('~popover-entry')).click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
-      await expectClosed(context, 'popover-trigger');
-      await trigger.click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~popover-focus')).toHaveText('First');
-      await trigger.click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Closed: trigger');
-      await expectClosed(context, 'popover-trigger');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'opens below the trigger as a named group and enters its first content',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { inPopupWindow, ownerScreenRect, surfaceScreenRect } = await import('./popover.wdio.ts');
+        const { browser, expect } = context;
+        const trigger = await browser.$('~popover-trigger');
+        expect(await trigger.getProperty('expanded')).toBe(false);
+        await trigger.click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~popover-focus')).toHaveText('First');
+        expect(await trigger.getProperty('expanded')).toBe(true);
+        await inPopupWindow(context, async () => {
+          const surface = await browser.$('~popover-surface');
+          expect(await surface.getProperty('role')).toBe('group');
+          expect(await surface.getProperty('name')).toBe('File details');
+        });
+        const anchor = await ownerScreenRect(context, 'popover-trigger');
+        const popup = await surfaceScreenRect(context, 'popover-surface');
+        // The Win32 host ignores the placement gap and places the popup flush against the trigger.
+        const gap = context.platform === 'win32' ? 0 : 4;
+        expect(Math.abs(popup.x + popup.width / 2 - (anchor.x + anchor.width / 2))).toBeLessThanOrEqual(1);
+        expect(Math.abs(popup.y - (anchor.y + anchor.height + gap))).toBeLessThanOrEqual(1);
+      },
+    ),
+    desktopIt(
+      'keeps Tab inside the popup and returns focus to the trigger on Escape',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await focusByTab(browser, 'popover-entry', 'popover-trigger');
+        await browser.keys('\uE007');
+        await expect(await browser.$('~popover-focus')).toHaveText('First');
+        await browser.keys('\uE004');
+        await expect(await browser.$('~popover-focus')).toHaveText('Second');
+        await browser.keys('\uE004');
+        await expect(await browser.$('~popover-focus')).toHaveText('First');
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
+        await expectNativeState(browser, 'popover-trigger', 'focused', true);
+      },
+    ),
+    desktopIt(
+      'closes on outside input and on a trigger press without reopening',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectClosed } = await import('./popover.wdio.ts');
+        const { browser, expect } = context;
+        const trigger = await browser.$('~popover-trigger');
+        await trigger.click();
+        await expect(await browser.$('~popover-focus')).toHaveText('First');
+        await (await browser.$('~popover-entry')).click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
+        await expectClosed(context, 'popover-trigger');
+        await trigger.click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~popover-focus')).toHaveText('First');
+        await trigger.click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Closed: trigger');
+        await expectClosed(context, 'popover-trigger');
+      },
+    ),
+  ],
 };
 
 export const Placement: Story = {
@@ -200,18 +208,20 @@ export const StaticContent: Story = {
   parameters: {
     docs: { description: { story: 'Without focusable content, the surface itself becomes the entry focus stop.' } },
   },
-  wdio: {
-    'focuses the surface when no content can take focus': async (context) => {
-      const { requireDesktopFocus } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await (await browser.$('~popover-trigger')).click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~popover-focus')).toHaveText('Surface');
-      await browser.keys('\uE00C');
-      await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'focuses the surface when no content can take focus',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { browser, expect } = context;
+        await (await browser.$('~popover-trigger')).click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~popover-focus')).toHaveText('Surface');
+        await browser.keys('\uE00C');
+        await expect(await browser.$('~popover-reason')).toHaveText('Closed: dismiss');
+      },
+    ),
+  ],
 };
 
 export const Controlled: Story = {
@@ -220,21 +230,24 @@ export const Controlled: Story = {
   parameters: {
     docs: { description: { story: 'Content closes a controlled Popover; focus returns to its trigger.' } },
   },
-  wdio: {
-    'returns focus to the trigger when content closes the popup': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { expectClosed } = await import('./popover.wdio.ts');
-      const { browser, expect } = context;
-      await (await browser.$('~popover-trigger')).click();
-      await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
-      await expect(await browser.$('~popover-focus')).toHaveText('Save');
-      await browser.keys('\uE007');
-      await expect(await browser.$('~popover-name')).toHaveText('Quarterly report (renamed)');
-      await expectClosed(context, 'popover-trigger');
-      await expectNativeState(browser, 'popover-trigger', 'focused', true);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'returns focus to the trigger when content closes the popup',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { expectClosed } = await import('./popover.wdio.ts');
+        const { browser, expect } = context;
+        await (await browser.$('~popover-trigger')).click();
+        await expect(await browser.$('~popover-reason')).toHaveText('Opened: trigger');
+        await expect(await browser.$('~popover-focus')).toHaveText('Save');
+        await browser.keys('\uE007');
+        await expect(await browser.$('~popover-name')).toHaveText('Quarterly report (renamed)');
+        await expectClosed(context, 'popover-trigger');
+        await expectNativeState(browser, 'popover-trigger', 'focused', true);
+      },
+    ),
+  ],
 };
 
 const styles = StyleSheet.create({
diff --git a/packages/agentic/components/src/components/radio/radio.stories.tsx b/packages/agentic/components/src/components/radio/radio.stories.tsx
index 2553e01fef..b24391c69a 100644
--- a/packages/agentic/components/src/components/radio/radio.stories.tsx
+++ b/packages/agentic/components/src/components/radio/radio.stories.tsx
@@ -3,6 +3,7 @@ import { useState } from 'react';
 import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 import type { AccessibilityActionEvent } from 'react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
@@ -92,56 +93,51 @@ export const NativeSelectionSemantics: Story = {
     };
     return <Scene />;
   },
-  wdio: {
-    'RAD-003 RAD-005 Win32 exposes native RadioButton selection, names and disabled state': async ({ browser, expect, platform, skip }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies Win32 UI Automation SelectionItem projection.');
-        return;
-      }
-      for (const [id, name, selected] of [
-        ['radio-native-off', 'Unselected option', false],
-        ['radio-native-on', 'Selected option', true],
-        ['radio-native-disabled', 'Disabled option', true],
-      ] as const) {
-        const radio = await browser.$(`~${id}`);
-        expect(await radio.getTagName()).toBe('radio');
-        expect(await radio.getProperty('name')).toBe(name);
-        expect(await radio.getProperty('selected')).toBe(selected);
-      }
-      await expect(await browser.$('~radio-native-disabled')).toBeDisabled();
-    },
-    'RAD-003 Win32 Select forwards once without self-selection or presses and disabled public activation rejects': async ({
-      browser,
-      expect,
-      platform,
-      skip,
-    }) => {
-      if (platform !== 'win32') {
-        skip('This case qualifies Win32 UI Automation Select transport.');
-        return;
-      }
-      const radio = await browser.$('~radio-native-off');
-      const disabled = await browser.$('~radio-native-disabled');
-      const actions = await browser.$('~radio-native-actions');
-      const presses = await browser.$('~radio-native-presses');
-      await expect(actions).toHaveAttribute('name', '0');
-      await radio.click();
-      await expect(actions).toHaveAttribute('name', '1');
-      await expect(await browser.$('~radio-native-last-action')).toHaveAttribute('name', 'Select');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await radio.getProperty('selected')).toBe(false);
-      let rejection: unknown;
-      try {
-        await disabled.click();
-      } catch (error) {
-        rejection = error;
-      }
-      expect(rejection).toBeDefined();
-      await expect(actions).toHaveAttribute('name', '1');
-      await expect(presses).toHaveAttribute('name', '0');
-      expect(await disabled.getProperty('selected')).toBe(true);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'RAD-003 RAD-005 Win32 exposes native RadioButton selection, names and disabled state',
+      { platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        for (const [id, name, selected] of [
+          ['radio-native-off', 'Unselected option', false],
+          ['radio-native-on', 'Selected option', true],
+          ['radio-native-disabled', 'Disabled option', true],
+        ] as const) {
+          const radio = await browser.$(`~${id}`);
+          expect(await radio.getTagName()).toBe('radio');
+          expect(await radio.getProperty('name')).toBe(name);
+          expect(await radio.getProperty('selected')).toBe(selected);
+        }
+        await expect(await browser.$('~radio-native-disabled')).toBeDisabled();
+      },
+    ),
+    desktopIt(
+      'RAD-003 Win32 Select forwards once without self-selection or presses and disabled public activation rejects',
+      { requires: ['accessibility-click'], platforms: ['win32'] },
+      async ({ browser, expect }) => {
+        const radio = await browser.$('~radio-native-off');
+        const disabled = await browser.$('~radio-native-disabled');
+        const actions = await browser.$('~radio-native-actions');
+        const presses = await browser.$('~radio-native-presses');
+        await expect(actions).toHaveAttribute('name', '0');
+        await radio.click();
+        await expect(actions).toHaveAttribute('name', '1');
+        await expect(await browser.$('~radio-native-last-action')).toHaveAttribute('name', 'Select');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await radio.getProperty('selected')).toBe(false);
+        let rejection: unknown;
+        try {
+          await disabled.click();
+        } catch (error) {
+          rejection = error;
+        }
+        expect(rejection).toBeDefined();
+        await expect(actions).toHaveAttribute('name', '1');
+        await expect(presses).toHaveAttribute('name', '0');
+        expect(await disabled.getProperty('selected')).toBe(true);
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/components/skeleton/skeleton.stories.tsx b/packages/agentic/components/src/components/skeleton/skeleton.stories.tsx
index 878b24042c..d7318a8eef 100644
--- a/packages/agentic/components/src/components/skeleton/skeleton.stories.tsx
+++ b/packages/agentic/components/src/components/skeleton/skeleton.stories.tsx
@@ -5,6 +5,7 @@ import { StyleSheet, Text, View } from 'react-native';
 import type { Meta, StoryObj } from '@storybook/react-native';
 import { useReducedMotion } from '@fluentui-react-native/framework-base';
 import { useThemeState } from '@fluentui-react-native/design';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -87,35 +88,33 @@ export const Motion: Story = {
       },
     },
   },
-  wdio: {
-    'renders changing native pixels when gradient animation is available': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (!features.elementScreenshot) {
-        skip('This test requires native element screenshots.');
-        return;
-      }
-      const preference = await browser.$('~skeleton-motion-preference');
-      await browser.waitUntil(async () =>
-        ['Motion enabled', 'Reduced motion enabled', 'Gradient unavailable for native platform colors'].includes(
-          await preference.getText(),
-        ),
-      );
-      const skeleton = await browser.$('~skeleton-motion');
-      await expect(skeleton).toExist();
-      expect(await browser.isElementDisplayed(await skeleton.elementId)).toBe(true);
-      const frames = new Set<string>();
-      for (let index = 0; index < 5; index++) {
-        frames.add(await browser.takeElementScreenshot(await skeleton.elementId));
-        await browser.pause(117);
-      }
-      if ((await preference.getText()) === 'Motion enabled') {
-        expect(frames.size).toBeGreaterThan(1);
-      } else {
-        expect(frames.size).toBe(1);
-      }
-    },
-  },
+  wdio: [
+    desktopIt(
+      'renders changing native pixels when gradient animation is available',
+      { requires: ['element-screenshot'] },
+      async ({ browser, expect }) => {
+        const preference = await browser.$('~skeleton-motion-preference');
+        await browser.waitUntil(async () =>
+          ['Motion enabled', 'Reduced motion enabled', 'Gradient unavailable for native platform colors'].includes(
+            await preference.getText(),
+          ),
+        );
+        const skeleton = await browser.$('~skeleton-motion');
+        await expect(skeleton).toExist();
+        expect(await browser.isElementDisplayed(await skeleton.elementId)).toBe(true);
+        const frames = new Set<string>();
+        for (let index = 0; index < 5; index++) {
+          frames.add(await browser.takeElementScreenshot(await skeleton.elementId));
+          await browser.pause(117);
+        }
+        if ((await preference.getText()) === 'Motion enabled') {
+          expect(frames.size).toBeGreaterThan(1);
+        } else {
+          expect(frames.size).toBe(1);
+        }
+      },
+    ),
+  ],
 };
 
 export const Default: Story = {
diff --git a/packages/agentic/components/src/components/spinner/spinner.stories.tsx b/packages/agentic/components/src/components/spinner/spinner.stories.tsx
index 8333075f7f..a22de0bff9 100644
--- a/packages/agentic/components/src/components/spinner/spinner.stories.tsx
+++ b/packages/agentic/components/src/components/spinner/spinner.stories.tsx
@@ -4,6 +4,7 @@ import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
 import { useReducedMotion } from '@fluentui-react-native/framework-base';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { StoryStatus } from '../../common/StoryStatus.story-helpers';
@@ -93,31 +94,29 @@ export const Motion: Story = {
       },
     },
   },
-  wdio: {
-    'renders changing native pixels unless reduced motion is enabled': async ({ browser, expect, skip }) => {
-      const features = browser.capabilities['furn:features'];
-      if (!features) throw new Error('Desktop Driver did not provide feature capabilities.');
-      if (!features.elementScreenshot) {
-        skip('This test requires native element screenshots.');
-        return;
-      }
-      const preference = await browser.$('~spinner-motion-preference');
-      await browser.waitUntil(async () => ['Motion enabled', 'Reduced motion enabled'].includes(await preference.getText()));
-      const spinner = await browser.$('~spinner-motion');
-      await expect(spinner).toExist();
-      expect(await browser.isElementDisplayed(await spinner.elementId)).toBe(true);
-      const frames = new Set<string>();
-      for (let index = 0; index < 5; index++) {
-        frames.add(await browser.takeElementScreenshot(await spinner.elementId));
-        await browser.pause(117);
-      }
-      if ((await preference.getText()) === 'Motion enabled') {
-        expect(frames.size).toBeGreaterThan(1);
-      } else {
-        expect(frames.size).toBe(1);
-      }
-    },
-  },
+  wdio: [
+    desktopIt(
+      'renders changing native pixels unless reduced motion is enabled',
+      { requires: ['element-screenshot'] },
+      async ({ browser, expect }) => {
+        const preference = await browser.$('~spinner-motion-preference');
+        await browser.waitUntil(async () => ['Motion enabled', 'Reduced motion enabled'].includes(await preference.getText()));
+        const spinner = await browser.$('~spinner-motion');
+        await expect(spinner).toExist();
+        expect(await browser.isElementDisplayed(await spinner.elementId)).toBe(true);
+        const frames = new Set<string>();
+        for (let index = 0; index < 5; index++) {
+          frames.add(await browser.takeElementScreenshot(await spinner.elementId));
+          await browser.pause(117);
+        }
+        if ((await preference.getText()) === 'Motion enabled') {
+          expect(frames.size).toBeGreaterThan(1);
+        } else {
+          expect(frames.size).toBe(1);
+        }
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/components/switch/switch.stories.tsx b/packages/agentic/components/src/components/switch/switch.stories.tsx
index b1bc0483bd..a052319744 100644
--- a/packages/agentic/components/src/components/switch/switch.stories.tsx
+++ b/packages/agentic/components/src/components/switch/switch.stories.tsx
@@ -4,6 +4,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Switch } from './switch';
@@ -94,30 +95,32 @@ function FocusManagementScene() {
 export const FocusManagement: Story = {
   render: () => <FocusManagementScene />,
   tags: ['desktop-focus'],
-  wdio: {
-    'toggles exactly once per pointer, Enter, and Space activation': async (context) => {
-      const { requireDesktopFocus, expectNativeState, expectWindowsPointerFocus, focusByTab } =
-        await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      const control = await browser.$('~focus-switch');
-      const count = await browser.$('~focus-switch-count');
-      await (await browser.$('~focus-switch-entry')).click();
-      await expectNativeState(browser, 'focus-switch-entry', 'focused', true);
-      await expectNativeState(browser, 'focus-switch', 'checked', false);
-      await control.click();
-      await expectWindowsPointerFocus(context, 'focus-switch');
-      await expect(count).toHaveText('1');
-      await expectNativeState(browser, 'focus-switch', 'checked', true);
-      await focusByTab(browser, 'focus-switch-entry', 'focus-switch');
-      await browser.keys('\uE007');
-      await expect(count).toHaveText('2');
-      await expectNativeState(browser, 'focus-switch', 'checked', false);
-      await browser.keys('\uE00D');
-      await expect(count).toHaveText('3');
-      await expectNativeState(browser, 'focus-switch', 'checked', true);
-    },
-  },
+  wdio: [
+    desktopIt(
+      'toggles exactly once per pointer, Enter, and Space activation',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, expectWindowsPointerFocus, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        const control = await browser.$('~focus-switch');
+        const count = await browser.$('~focus-switch-count');
+        await (await browser.$('~focus-switch-entry')).click();
+        await expectNativeState(browser, 'focus-switch-entry', 'focused', true);
+        await expectNativeState(browser, 'focus-switch', 'checked', false);
+        await control.click();
+        await expectWindowsPointerFocus(context, 'focus-switch');
+        await expect(count).toHaveText('1');
+        await expectNativeState(browser, 'focus-switch', 'checked', true);
+        await focusByTab(browser, 'focus-switch-entry', 'focus-switch');
+        await browser.keys('\uE007');
+        await expect(count).toHaveText('2');
+        await expectNativeState(browser, 'focus-switch', 'checked', false);
+        await browser.keys('\uE00D');
+        await expect(count).toHaveText('3');
+        await expectNativeState(browser, 'focus-switch', 'checked', true);
+      },
+    ),
+  ],
 };
 
 export const Overview: Story = {
@@ -196,16 +199,16 @@ export const Checked: Story = {
       },
     },
   },
-  wdio: {
-    'SWCH-001 SWCH-006 projects both initial checked values without input': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('SWCH-001 SWCH-006 projects both initial checked values without input', async ({ browser, expect }) => {
       const off = await browser.$('~switch-spec-off');
       const on = await browser.$('~switch-spec-on');
       await expect(off).toBeEnabled();
       await expect(on).toBeEnabled();
       expect(await off.getProperty('checked')).toBe(false);
       expect(await on.getProperty('checked')).toBe(true);
-    },
-  },
+    }),
+  ],
 };
 
 export const ExternallyDrivenChecked: Story = {
diff --git a/packages/agentic/components/src/components/tablist/tablist.stories.tsx b/packages/agentic/components/src/components/tablist/tablist.stories.tsx
index d2c685b0fe..9ba639e478 100644
--- a/packages/agentic/components/src/components/tablist/tablist.stories.tsx
+++ b/packages/agentic/components/src/components/tablist/tablist.stories.tsx
@@ -3,6 +3,7 @@ import { useState } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Tab } from '../tab/tab';
@@ -86,80 +87,92 @@ function FocusManagementScene({ selectionFollowsFocus = true }: { selectionFollo
 export const FocusManagement: Story = {
   render: () => <FocusManagementScene />,
   tags: ['desktop-focus'],
-  wdio: {
-    'commits selection before focus, skips disabled tabs, and supports wrap, Home, and End': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
-      await expect(await browser.$('~focus-tab-disabled')).not.toBeEnabled();
-      for (const [key, id, value] of [
-        ['\uE014', 'focus-tab-two', 'focus-panel-two'],
-        ['\uE014', 'focus-tab-one', 'focus-panel-one'],
-        ['\uE010', 'focus-tab-two', 'focus-panel-two'],
-        ['\uE011', 'focus-tab-one', 'focus-panel-one'],
-      ]) {
-        await browser.keys(key);
-        await expectNativeState(browser, id, 'focused', true);
-        await expectNativeState(browser, id, 'selected', true);
-        await expect(await browser.$('~focus-tab-selection')).toHaveText(value);
-        await expect(await browser.$('~focus-tab-selection-at-focus')).toHaveText(value);
-        await expectNativeState(browser, 'focus-tab-disabled', 'focused', false);
-      }
-    },
-    'leaves modified navigation chords to their owner': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect, platform } = context;
-      // Control+Arrow is a macOS system shortcut, not a key the app can promise to receive.
-      const modifiers =
-        platform === 'macos'
-          ? [['\uE008', 'Shift']]
-          : [
-              ['\uE009', 'Control'],
-              ['\uE008', 'Shift'],
-            ];
-      for (const [modifier, name] of modifiers) {
+  wdio: [
+    desktopIt(
+      'commits selection before focus, skips disabled tabs, and supports wrap, Home, and End',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
+        await expect(await browser.$('~focus-tab-disabled')).not.toBeEnabled();
+        for (const [key, id, value] of [
+          ['\uE014', 'focus-tab-two', 'focus-panel-two'],
+          ['\uE014', 'focus-tab-one', 'focus-panel-one'],
+          ['\uE010', 'focus-tab-two', 'focus-panel-two'],
+          ['\uE011', 'focus-tab-one', 'focus-panel-one'],
+        ]) {
+          await browser.keys(key);
+          await expectNativeState(browser, id, 'focused', true);
+          await expectNativeState(browser, id, 'selected', true);
+          await expect(await browser.$('~focus-tab-selection')).toHaveText(value);
+          await expect(await browser.$('~focus-tab-selection-at-focus')).toHaveText(value);
+          await expectNativeState(browser, 'focus-tab-disabled', 'focused', false);
+        }
+      },
+    ),
+    desktopIt(
+      'leaves modified navigation chords to their owner',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect, platform } = context;
+        // Control+Arrow is a macOS system shortcut, not a key the app can promise to receive.
+        const modifiers =
+          platform === 'macos'
+            ? [['\uE008', 'Shift']]
+            : [
+                ['\uE009', 'Control'],
+                ['\uE008', 'Shift'],
+              ];
+        for (const [modifier, name] of modifiers) {
+          await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
+          await browser.keys([modifier, '\uE014']);
+          await expect(await browser.$('~focus-tab-owner-key')).toHaveText(`${name}+ArrowRight`);
+          await expectNativeState(browser, 'focus-tab-one', 'selected', true);
+          await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-one');
+        }
+      },
+    ),
+    desktopIt(
+      'exposes native selected and disabled accessibility states',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { browser, expect } = context;
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
         await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
-        await browser.keys([modifier, '\uE014']);
-        await expect(await browser.$('~focus-tab-owner-key')).toHaveText(`${name}+ArrowRight`);
+        await expect(await browser.$('~focus-tab-disabled')).not.toBeEnabled();
         await expectNativeState(browser, 'focus-tab-one', 'selected', true);
-        await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-one');
-      }
-    },
-    'exposes native selected and disabled accessibility states': async (context) => {
-      const { browser, expect } = context;
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
-      await expect(await browser.$('~focus-tab-disabled')).not.toBeEnabled();
-      await expectNativeState(browser, 'focus-tab-one', 'selected', true);
-      await browser.keys('\uE014');
-      await expectNativeState(browser, 'focus-tab-one', 'selected', false);
-      await expectNativeState(browser, 'focus-tab-two', 'selected', true);
-    },
-  },
+        await browser.keys('\uE014');
+        await expectNativeState(browser, 'focus-tab-one', 'selected', false);
+        await expectNativeState(browser, 'focus-tab-two', 'selected', true);
+      },
+    ),
+  ],
 };
 
 export const ManualFocusManagement: Story = {
   render: () => <FocusManagementScene selectionFollowsFocus={false} />,
   tags: ['desktop-focus'],
-  wdio: {
-    'keeps manual selection independent until Enter activates the focused tab': async (context) => {
-      const { requireDesktopFocus, expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, expect } = context;
-      await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
-      await browser.keys('\uE014');
-      await expectNativeState(browser, 'focus-tab-two', 'focused', true);
-      await expectNativeState(browser, 'focus-tab-one', 'selected', true);
-      await expectNativeState(browser, 'focus-tab-two', 'selected', false);
-      await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-one');
-      await browser.keys('\uE007');
-      await expectNativeState(browser, 'focus-tab-two', 'selected', true);
-      await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-two');
-    },
-  },
+  wdio: [
+    desktopIt(
+      'keeps manual selection independent until Enter activates the focused tab',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState, focusByTab } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, expect } = context;
+        await focusByTab(browser, 'focus-tab-entry', 'focus-tab-one');
+        await browser.keys('\uE014');
+        await expectNativeState(browser, 'focus-tab-two', 'focused', true);
+        await expectNativeState(browser, 'focus-tab-one', 'selected', true);
+        await expectNativeState(browser, 'focus-tab-two', 'selected', false);
+        await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-one');
+        await browser.keys('\uE007');
+        await expectNativeState(browser, 'focus-tab-two', 'selected', true);
+        await expect(await browser.$('~focus-tab-selection')).toHaveText('focus-panel-two');
+      },
+    ),
+  ],
 };
 
 export const Controlled: Story = {
diff --git a/packages/agentic/components/src/components/tag/tag.stories.tsx b/packages/agentic/components/src/components/tag/tag.stories.tsx
index b90f5aa9b0..1c330ab095 100644
--- a/packages/agentic/components/src/components/tag/tag.stories.tsx
+++ b/packages/agentic/components/src/components/tag/tag.stories.tsx
@@ -3,6 +3,7 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Tag } from './tag';
@@ -77,24 +78,24 @@ export default meta;
 type Story = WdioStory<StoryObj<typeof Tag>>;
 
 export const Default: Story = {
-  wdio: {
-    'TAG-004 TAG-008 exposes the whole enabled tag as a native button': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('TAG-004 TAG-008 exposes the whole enabled tag as a native button', async ({ browser, expect }) => {
       const tag = await browser.$('~agentic-storybook-tag');
       expect(await tag.getTagName()).toBe('button');
       await expect(tag).toBeEnabled();
-    },
-  },
+    }),
+  ],
 };
 
 export const NativeDisabled: Story = {
   args: { content: 'Unavailable filter', disabled: true },
-  wdio: {
-    'TAG-008 exposes disabled native button semantics': async ({ browser, expect }) => {
+  wdio: [
+    desktopIt('TAG-008 exposes disabled native button semantics', async ({ browser, expect }) => {
       const tag = await browser.$('~agentic-storybook-tag');
       expect(await tag.getTagName()).toBe('button');
       await expect(tag).toBeDisabled();
-    },
-  },
+    }),
+  ],
 };
 
 export const Overview: Story = {
diff --git a/packages/agentic/components/src/primitives/focus-zone/focus-zone.stories.tsx b/packages/agentic/components/src/primitives/focus-zone/focus-zone.stories.tsx
index 11f443be8b..49afb72af2 100644
--- a/packages/agentic/components/src/primitives/focus-zone/focus-zone.stories.tsx
+++ b/packages/agentic/components/src/primitives/focus-zone/focus-zone.stories.tsx
@@ -4,6 +4,7 @@ import { Platform, Pressable, StyleSheet, Text, View } from 'react-native';
 import type { StyleProp, ViewStyle } from 'react-native';
 
 import { useFocusablePressable, useFocusTarget } from '@fluentui-react-native/framework-base';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 import { FocusZone } from '@fluentui-react-native/native-core/legacy';
 import type { FocusZoneDirection, FocusZoneProps, FocusZoneTabNavigation } from '@fluentui-react-native/native-core/legacy';
@@ -239,23 +240,25 @@ type Story = WdioStory<StoryObj<typeof FocusZone>>;
 export const Default: Story = {
   tags: ['desktop-e2e'],
   render: (args) => <FocusZoneExample {...args} />,
-  wdio: {
-    'uses platform directional navigation and exits the zone on Tab': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser, platform } = context;
-      await (await browser.$('~focus-zone-item-1')).click();
-      await expectNativeState(browser, 'focus-zone-item-1', 'focused', true);
-      await browser.keys('\uE014');
-      await expectNativeState(browser, 'focus-zone-item-2', 'focused', true);
-      await browser.keys('\uE015');
-      await expectNativeState(browser, platform === 'macos' ? 'focus-zone-item-5' : 'focus-zone-item-3', 'focused', true);
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-zone-after', 'focused', true);
-    },
-    'Shift+Tab exits to a preceding sibling': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+  wdio: [
+    desktopIt(
+      'uses platform directional navigation and exits the zone on Tab',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser, platform } = context;
+        await (await browser.$('~focus-zone-item-1')).click();
+        await expectNativeState(browser, 'focus-zone-item-1', 'focused', true);
+        await browser.keys('\uE014');
+        await expectNativeState(browser, 'focus-zone-item-2', 'focused', true);
+        await browser.keys('\uE015');
+        await expectNativeState(browser, platform === 'macos' ? 'focus-zone-item-5' : 'focus-zone-item-3', 'focused', true);
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-zone-after', 'focused', true);
+      },
+    ),
+    desktopIt('Shift+Tab exits to a preceding sibling', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { browser } = context;
       await (await browser.$('~focus-zone-item-2')).click();
       await expectNativeState(browser, 'focus-zone-item-2', 'focused', true);
@@ -265,8 +268,8 @@ export const Default: Story = {
         await browser.releaseActions();
       }
       await expectNativeState(browser, 'focus-zone-before', 'focused', true);
-    },
-  },
+    }),
+  ],
   parameters: {
     docs: {
       description: {
@@ -298,17 +301,16 @@ export const TwoDimensionalNavigation: Story = {
     use2DNavigation: true,
   },
   render: (args) => <FocusZoneExample {...args} />,
-  wdio: {
-    'moves geometrically between rows': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
+  wdio: [
+    desktopIt('moves geometrically between rows', { requires: ['physical-click', 'keyboard', 'focus'] }, async (context) => {
+      const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
       const { browser } = context;
       await (await browser.$('~focus-zone-item-1')).click();
       await expectNativeState(browser, 'focus-zone-item-1', 'focused', true);
       await browser.keys('\uE015');
       await expectNativeState(browser, 'focus-zone-item-4', 'focused', true);
-    },
-  },
+    }),
+  ],
   parameters: {
     docs: {
       description: {
@@ -353,35 +355,41 @@ export const FirstChildTabExit: Story = {
     tabKeyNavigation: 'None',
   },
   render: (args) => <FirstChildTabExitExample {...args} />,
-  wdio: {
-    'Shift+Tab skips the first-child zone and later siblings while climbing ancestors': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser } = context;
-      for (const item of ['focus-zone-first-child-first', 'focus-zone-first-child-last']) {
-        await (await browser.$(`~${item}`)).click();
-        await expectNativeState(browser, item, 'focused', true);
-        try {
-          await browser.keys(['\uE008', '\uE004']);
-        } finally {
-          await browser.releaseActions();
+  wdio: [
+    desktopIt(
+      'Shift+Tab skips the first-child zone and later siblings while climbing ancestors',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser } = context;
+        for (const item of ['focus-zone-first-child-first', 'focus-zone-first-child-last']) {
+          await (await browser.$(`~${item}`)).click();
+          await expectNativeState(browser, item, 'focused', true);
+          try {
+            await browser.keys(['\uE008', '\uE004']);
+          } finally {
+            await browser.releaseActions();
+          }
+          await expectNativeState(browser, 'focus-zone-previous', 'focused', true);
+          await expectNativeState(browser, item, 'focused', false);
+          await expectNativeState(browser, 'focus-zone-later-sibling', 'focused', false);
+          await expectNativeState(browser, 'focus-zone-later-ancestor-sibling', 'focused', false);
         }
-        await expectNativeState(browser, 'focus-zone-previous', 'focused', true);
-        await expectNativeState(browser, item, 'focused', false);
-        await expectNativeState(browser, 'focus-zone-later-sibling', 'focused', false);
-        await expectNativeState(browser, 'focus-zone-later-ancestor-sibling', 'focused', false);
-      }
-    },
-    'Tab exits a first-child zone to its next sibling': async (context) => {
-      const { requireDesktopFocus, expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
-      if (!requireDesktopFocus(context)) return;
-      const { browser } = context;
-      await (await browser.$('~focus-zone-first-child-first')).click();
-      await expectNativeState(browser, 'focus-zone-first-child-first', 'focused', true);
-      await browser.keys('\uE004');
-      await expectNativeState(browser, 'focus-zone-later-sibling', 'focused', true);
-    },
-  },
+      },
+    ),
+    desktopIt(
+      'Tab exits a first-child zone to its next sibling',
+      { requires: ['physical-click', 'keyboard', 'focus'] },
+      async (context) => {
+        const { expectNativeState } = await import('../../common/desktopFocus.wdio.ts');
+        const { browser } = context;
+        await (await browser.$('~focus-zone-first-child-first')).click();
+        await expectNativeState(browser, 'focus-zone-first-child-first', 'focused', true);
+        await browser.keys('\uE004');
+        await expectNativeState(browser, 'focus-zone-later-sibling', 'focused', true);
+      },
+    ),
+  ],
   parameters: {
     docs: {
       description: {
diff --git a/packages/agentic/components/src/primitives/layout-stable-text/layout-stable-text.stories.tsx b/packages/agentic/components/src/primitives/layout-stable-text/layout-stable-text.stories.tsx
index 43ed87a954..cd0feb88d3 100644
--- a/packages/agentic/components/src/primitives/layout-stable-text/layout-stable-text.stories.tsx
+++ b/packages/agentic/components/src/primitives/layout-stable-text/layout-stable-text.stories.tsx
@@ -5,6 +5,7 @@ import { StyleSheet, Text, View } from 'react-native';
 import type { LayoutRectangle } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
+import { desktopIt } from '@fluentui-react-native/storybook-desktop/testing';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { LayoutStableText } from './layout-stable-text';
@@ -158,8 +159,8 @@ export const Overview: Story = {
       },
     },
   },
-  wdio: {
-    'centers the intrinsic smaller line inside its larger reserve': async ({ browser, expect, platform }) => {
+  wdio: [
+    desktopIt('centers the intrinsic smaller line inside its larger reserve', async ({ browser, expect, platform }) => {
       const assert: typeof import('node:assert') = (await import('node:assert')).default;
       if (platform === 'macos') {
         // Measure both Text line boxes; Paper rounds Text and wrapper View frames differently.
@@ -194,8 +195,8 @@ export const Overview: Story = {
       const reservedCenter = reservedBounds.y + reservedBounds.height / 2;
       const visibleCenter = visibleBounds.y + visibleBounds.height / 2;
       assert(Math.abs(reservedCenter - visibleCenter) <= 1, 'Visible text must be vertically centered within one layout pixel.');
-    },
-  },
+    }),
+  ],
 };
 
 export const WeightReservation: Story = {
diff --git a/packages/agentic/desktop-driver/references/ci-integration.md b/packages/agentic/desktop-driver/references/ci-integration.md
index b7a912c246..9be669e235 100644
--- a/packages/agentic/desktop-driver/references/ci-integration.md
+++ b/packages/agentic/desktop-driver/references/ci-integration.md
@@ -107,20 +107,25 @@ This repository's current PR workflow provides examples in
 - `windows-storybook` prepares the generated app, installs the required Windows
   App Runtime for that app, runs the shared Windows native build contract,
   and asks the same setup action to verify the `windows` endpoint before
-  running Windows `stories-and-tests`;
+  running Windows `stories-and-tests` in the accessible lane
+  (`--input accessible`);
 - `win32-storybook` asks the setup action to build the same Windows provider
   into its own job-local cache, verify the `win32` endpoint, and pin later
-  resolution before running the authored plans through the prebuilt Paper
-  endpoint.
-
-Both Windows jobs upload their doctor report, successful native build log, and
-preserved failed-build diagnostics with the Storybook artifacts. Neither
-`prep` nor `smoke` may compile a helper after the explicit build step.
-Because GitHub-hosted Windows does not provide authoritative global input,
-both jobs disable keyboard, physical-click, and wheel capabilities through the
-registered host policy. The authored input plans therefore report explicit
-capability skips, and so do the Windows native contract's physical-input and
-window-capture fixture scenarios, because hosted Windows Graphics Capture cannot
+  resolution before running the accessible lane through the prebuilt Paper
+  endpoint. `win32-storybook-physical` runs the physical lane
+  (`--input physical`) the same way with every input feature enabled. It is an
+  advisory pilot outside the aggregate `PR` check until hosted physical input
+  is qualified.
+
+The Windows Storybook jobs upload their doctor report, successful native build
+log, and preserved failed-build diagnostics with the Storybook artifacts.
+Neither `prep` nor `smoke` may compile a helper after the explicit build step.
+Because GitHub-hosted Windows is not qualified to provide authoritative global
+input, the accessible jobs disable keyboard, physical-click, and wheel
+capabilities through the registered host policy, and their lanes exclude the
+cases that declare those requirements instead of skipping them. The Windows
+native contract's physical-input and window-capture fixture scenarios still
+report explicit capability skips, because hosted Windows Graphics Capture cannot
 create a capture item. Interactive self-hosted qualification must leave those
 features enabled.
 
diff --git a/packages/agentic/storybook-desktop-runtime/README.md b/packages/agentic/storybook-desktop-runtime/README.md
index e9996cbaa2..454629bf3d 100644
--- a/packages/agentic/storybook-desktop-runtime/README.md
+++ b/packages/agentic/storybook-desktop-runtime/README.md
@@ -9,6 +9,11 @@ Consumers normally install and invoke `storybook-desktop`; this package is
 separate so the CLI package stays peer-free and receives the runtime workspace
 locator.
 
+Win32 test generations reset the preview subtree and its scroll position while
+preserving the surrounding desktop chrome preferences.
+Its scrollable story viewport centers small stories without clipping the start
+of oversized stories behind the chrome.
+
 Read the [integration reference](references/integration.md) before wiring the
 runtime into an app, and the [runtime contract](references/runtime-contract.md)
 before changing bridge, Metro, theme, or chrome behavior. The
diff --git a/packages/agentic/storybook-desktop-runtime/references/runtime-contract.md b/packages/agentic/storybook-desktop-runtime/references/runtime-contract.md
index 3987305bb3..2161c4db45 100644
--- a/packages/agentic/storybook-desktop-runtime/references/runtime-contract.md
+++ b/packages/agentic/storybook-desktop-runtime/references/runtime-contract.md
@@ -15,6 +15,15 @@ ready/error events correlate instance, target, request/run IDs, and preview
 generation. Each named test gets a keyed preview remount. Preserve these
 contracts and fail closed on stale or uncorrelated messages.
 
+Win32 remounts the entire preview subtree for each test generation, including
+the story viewport, so retained scroll position cannot put the next test's
+controls behind the chrome. Sidebar and addon preferences remain outside that
+remount.
+
+The Win32 story decorator uses a scrollable viewport with naturally sized
+content. Small stories remain centered; oversized stories start within the
+viewport and can scroll instead of overflowing behind the chrome.
+
 ## Theme and chrome
 
 One Flex `ThemedRoot` covers the app, toolbar, and chrome, so the Storybook
diff --git a/packages/agentic/storybook-desktop-runtime/src/StorybookUI.test.tsx b/packages/agentic/storybook-desktop-runtime/src/StorybookUI.test.tsx
new file mode 100644
index 0000000000..16bd0caa85
--- /dev/null
+++ b/packages/agentic/storybook-desktop-runtime/src/StorybookUI.test.tsx
@@ -0,0 +1,83 @@
+import * as React from 'react';
+import { Pressable, StyleSheet, Text, View } from 'react-native';
+import { fireEvent, render } from '@testing-library/react-native';
+import { theme } from '@storybook/react-native-theming';
+
+import { DesktopStorybookConfigProvider, useDesktopStorybookConfig } from './DesktopStorybookConfig';
+import { Win32StoryViewport } from './createDesktopStorybookPreview.win32';
+import { StorybookUIComponent } from './StorybookUI.win32';
+
+jest.mock('@storybook/react-native-ui-common', () => ({
+  StorageProvider: ({ children }: { children: React.ReactNode }) => children,
+}));
+jest.mock('@storybook/react-native-ui-lite', () => ({ Sidebar: () => null }));
+jest.mock('./Win32AddonsPanel', () => ({ Win32AddonsPanel: () => null }));
+jest.mock('./Win32CalloutPortal', () => ({ Win32CalloutPortal: () => null }));
+jest.mock('./Win32ResizeHandle', () => ({ Win32ResizeHandle: () => null }));
+jest.mock('./DesktopStoryRoot', () => ({ DesktopStoryRoot: ({ children }: { children: React.ReactNode }) => children }));
+
+const storage = { getItem: () => null, setItem: () => undefined };
+const setStory = jest.fn();
+
+function Canvas() {
+  const [offset, setOffset] = React.useState(0);
+  return (
+    <Win32StoryViewport>
+      <Text testID="canvas-offset">{offset}</Text>
+      <Pressable testID="scroll-canvas" onPress={() => setOffset(99)} />
+    </Win32StoryViewport>
+  );
+}
+
+function Harness({ requestId }: { requestId: string }) {
+  const { prepareStory } = useDesktopStorybookConfig();
+  React.useEffect(() => {
+    prepareStory({ requestId, runId: 'fixture-run', storyId: 'fixture--default' });
+  }, [prepareStory, requestId]);
+  return (
+    <StorybookUIComponent setStory={setStory} storage={storage} storyHash={{}} theme={theme}>
+      <Canvas />
+    </StorybookUIComponent>
+  );
+}
+
+function scene(requestId: string) {
+  return (
+    <DesktopStorybookConfigProvider testIDPrefix="test">
+      <Harness requestId={requestId} />
+    </DesktopStorybookConfigProvider>
+  );
+}
+
+// Cold CI workers can take more than five seconds to initialize the real ScrollView.
+test('resets the whole Win32 preview for a new test generation without resetting chrome preferences', async () => {
+  const screen = await render(scene('first'));
+  await fireEvent.press(screen.getByTestId('scroll-canvas'));
+  expect(screen.getByTestId('canvas-offset')).toHaveTextContent('99');
+  await fireEvent.press(screen.getByTestId('test-win32-hide-sidebar'));
+  expect(screen.getByTestId('test-win32-show-sidebar')).toBeOnTheScreen();
+  expect(screen.getByTestId('canvas-offset')).toHaveTextContent('99');
+
+  await screen.rerender(scene('second'));
+
+  expect(screen.getByTestId('canvas-offset')).toHaveTextContent('0');
+  expect(screen.getByTestId('test-win32-show-sidebar')).toBeOnTheScreen();
+}, 15_000);
+
+test('allows oversized Win32 stories to grow inside the scrollable preview rather than overflow a fixed-height centered view', async () => {
+  const screen = await render(
+    <DesktopStorybookConfigProvider testIDPrefix="test">
+      <Win32StoryViewport>
+        <View style={{ height: 700 }}>
+          <Text testID="last-control">Last control</Text>
+        </View>
+      </Win32StoryViewport>
+    </DesktopStorybookConfigProvider>,
+  );
+  const viewport = screen.getByTestId('test-story-viewport');
+  const contentStyle = StyleSheet.flatten(viewport.props.contentContainerStyle);
+  expect(contentStyle).toMatchObject({ flexGrow: 1, justifyContent: 'center' });
+  expect(contentStyle.flex).toBeUndefined();
+  expect(viewport.props.keyboardShouldPersistTaps).toBe('handled');
+  expect(screen.getByTestId('last-control')).toBeOnTheScreen();
+});
diff --git a/packages/agentic/storybook-desktop-runtime/src/StorybookUI.win32.tsx b/packages/agentic/storybook-desktop-runtime/src/StorybookUI.win32.tsx
index 072c72495e..2f2789cfc9 100644
--- a/packages/agentic/storybook-desktop-runtime/src/StorybookUI.win32.tsx
+++ b/packages/agentic/storybook-desktop-runtime/src/StorybookUI.win32.tsx
@@ -6,7 +6,7 @@ import { StorageProvider } from '@storybook/react-native-ui-common';
 import type { SBUI, Selection } from '@storybook/react-native-ui-common';
 import { Sidebar } from '@storybook/react-native-ui-lite';
 
-import { useDesktopStorybookTestID } from './DesktopStorybookConfig';
+import { useDesktopStorybookConfig, useDesktopStorybookTestID } from './DesktopStorybookConfig';
 import { Win32AddonsPanel } from './Win32AddonsPanel';
 import { Win32CalloutPortal } from './Win32CalloutPortal';
 import { Win32ResizeHandle } from './Win32ResizeHandle';
@@ -15,6 +15,8 @@ const emptyRefs = {};
 const emptyStatus = {};
 
 export const StorybookUIComponent: SBUI = ({ children, setStory, storage, story, storyHash, storyBackgroundColor, theme }) => {
+  const { selection } = useDesktopStorybookConfig();
+  const previewKey = selection ? `${story?.id ?? ''}:${selection.runId}:${selection.previewGeneration}` : story?.id;
   const storiesAnchorRef = React.useRef<View>(null);
   const addonsAnchorRef = React.useRef<View>(null);
   const [sidebarVisible, setSidebarVisible] = React.useState(true);
@@ -174,7 +176,11 @@ export const StorybookUIComponent: SBUI = ({ children, setStory, storage, story,
                 </Text>
               </View>
             ) : null}
-            <View style={[styles.preview, { backgroundColor: storyBackgroundColor ?? theme.background.preview }]} testID={previewTestID}>
+            <View
+              key={previewKey}
+              style={[styles.preview, { backgroundColor: storyBackgroundColor ?? theme.background.preview }]}
+              testID={previewTestID}
+            >
               {children}
             </View>
             {addonsVisible ? (
diff --git a/packages/agentic/storybook-desktop-runtime/src/createDesktopStorybookPreview.win32.tsx b/packages/agentic/storybook-desktop-runtime/src/createDesktopStorybookPreview.win32.tsx
new file mode 100644
index 0000000000..63da2281e2
--- /dev/null
+++ b/packages/agentic/storybook-desktop-runtime/src/createDesktopStorybookPreview.win32.tsx
@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+import { ScrollView, StyleSheet } from 'react-native';
+import type { Preview } from '@storybook/react-native';
+
+import { DesktopStoryRoot } from './DesktopStoryRoot';
+import { useDesktopStorybookTestID } from './DesktopStorybookConfig';
+
+export function Win32StoryViewport({ children }: { children: ReactNode }) {
+  const testID = useDesktopStorybookTestID('story-viewport');
+  return (
+    <ScrollView contentContainerStyle={styles.story} keyboardShouldPersistTaps="handled" style={styles.viewport} testID={testID}>
+      {children}
+    </ScrollView>
+  );
+}
+
+export function createDesktopStorybookPreview(): Preview {
+  return {
+    decorators: [
+      (Story, context) => (
+        <DesktopStoryRoot storyId={context.id}>
+          <Win32StoryViewport>
+            <Story />
+          </Win32StoryViewport>
+        </DesktopStoryRoot>
+      ),
+    ],
+    parameters: {},
+  };
+}
+
+const styles = StyleSheet.create({
+  story: {
+    alignItems: 'center',
+    flexGrow: 1,
+    justifyContent: 'center',
+    padding: 16,
+  },
+  viewport: {
+    flex: 1,
+  },
+});
diff --git a/packages/agentic/storybook-desktop/src/driver/representativePlans.contract.cjs b/packages/agentic/storybook-desktop/src/driver/representativePlans.contract.cjs
index 233c61c9d9..11ed4826ce 100644
--- a/packages/agentic/storybook-desktop/src/driver/representativePlans.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/driver/representativePlans.contract.cjs
@@ -32,6 +32,9 @@ async function main() {
     if (!typedStories.includes(entry.sourcePath)) {
       throw new Error(`WDIO story is not included in test:stories: ${entry.sourcePath}`);
     }
+    if (!entry.wdio.cases?.length || entry.wdio.cases.length !== entry.wdio.testNames?.length) {
+      throw new Error(`Every component WDIO case must use desktopIt: ${entry.sourcePath} / ${entry.wdio.exportName}`);
+    }
   }
   const selectedIds = new Set(['components-button--default', 'components-checkbox--default', 'components-input--default']);
   const planned = manifest.entries.filter(({ id }) => selectedIds.has(id));
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index c69d9b8c56..46d1b1d4d2 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -52,9 +52,10 @@ test('executes isolated inline code and releases sessions after assertion failur
       { testName: 'exposes enabled button semantics', status: 'passed' },
       { testName: 'supports native pointer activation', status: 'passed' },
     ],
+    // The migrated case declares physical-click, so a host without it reports the case unsupported before execution.
     restrictedButton: [
       { testName: 'exposes enabled button semantics', status: 'passed' },
-      { testName: 'supports native pointer activation', status: 'skipped' },
+      { testName: 'supports native pointer activation', status: 'unsupported' },
     ],
     lane: {
       accessible: [

From 9d3e115167506a407db0249f80f62024180d4398 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Sat, 7 Nov 2026 15:08:59 -0800
Subject: [PATCH 4/6] Enforce desktop session input policy

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .changeset/session-input-policy.md            |   7 +
 .../agentic/desktop-driver/native/PROTOCOL.md |  33 +++
 .../desktop-driver/native/macos/README.md     |  11 +
 .../DesktopDriverHost/Accessibility.swift     |  21 +-
 .../Sources/DesktopDriverHost/Driver.swift    |  33 ++-
 .../Sources/DesktopDriverHost/Host.swift      |   1 +
 .../Sources/DesktopDriverHost/SelfTest.swift  |  21 ++
 .../desktop-driver/native/windows/README.md   |  16 +-
 .../native/windows/src/automation.cpp         |  33 ++-
 .../native/windows/src/automation.h           |   8 +-
 .../native/windows/src/driver.cpp             |  24 +-
 .../native/windows/src/host.cpp               |   2 +-
 .../native/windows/src/selftest.cpp           |  49 ++++
 .../desktop-driver/references/protocol.md     |  17 +-
 .../references/test-integration.md            |  27 +-
 .../desktop-driver/src/authoring/index.ts     |  13 +
 .../src/authoring/input.test.ts               |  70 +++++
 .../desktop-driver/src/authoring/input.ts     | 152 +++++++++-
 .../src/authoring/selection.test.ts           |   2 +
 .../desktop-driver/src/authoring/selection.ts |   5 +-
 .../src/client/DesktopDriverClient.ts         |  12 +
 .../agentic/desktop-driver/src/host/types.ts  |  15 +-
 .../src/hosts/fake/FakeDesktopHost.ts         |  16 +-
 .../native/NativeDesktopHost.input.test.ts    | 125 ++++++++
 .../NativeDesktopHost.observation.test.ts     |  65 +----
 .../src/hosts/native/NativeDesktopHost.ts     |  39 ++-
 packages/agentic/desktop-driver/src/index.ts  |  13 +
 .../desktop-driver/src/operations/act.ts      |  34 ++-
 .../desktop-driver/src/operations/runtime.ts  |   3 +-
 .../src/protocol/capabilities.ts              |  30 +-
 .../src/server/SessionManager.ts              |  11 +-
 .../src/server/createDesktopDriverServer.ts   | 101 ++++++-
 .../src/server/desktopDriver.test.ts          |   1 +
 .../src/server/operations.test.ts             |   6 +-
 .../src/server/sessionInput.test.ts           | 272 ++++++++++++++++++
 .../desktop-driver/src/server/sessionInput.ts | 155 ++++++++++
 .../src/server/sessionOperations.ts           |  29 +-
 .../src/testing/scriptedNativeHelper.ts       |  72 +++++
 .../src/wdio/DesktopWebdriver.test.ts         |  20 ++
 .../src/wdio/DesktopWebdriver.ts              |  43 ++-
 .../src/wdio/input.contract.cjs               |  34 +++
 .../desktop-test/references/commands.md       |   8 +-
 .../desktop-test/references/reporting.md      |  19 +-
 .../desktop-test/references/wdio-suites.md    |  11 +-
 packages/agentic/desktop-test/src/cli.ts      |   3 +-
 .../desktop-test/src/contracts.contract.cjs   |  45 ++-
 .../desktop-test/src/jasmine/adapter.test.ts  |  63 ++++
 .../desktop-test/src/jasmine/adapter.ts       |  49 +++-
 .../agentic/desktop-test/src/jasmine/index.ts |  11 +-
 .../desktop-test/src/jasmine/registry.ts      |   9 +-
 .../src/jasmine/specSelection.test.ts         |  39 ++-
 .../desktop-test/src/jasmine/specSelection.ts |   7 +
 .../src/reporting/collector.test.ts           |   6 +-
 .../desktop-test/src/reporting/collector.ts   |   3 +
 .../desktop-test/src/reporting/index.ts       |   2 +
 .../desktop-test/src/reporting/lane.test.ts   |  15 +-
 .../desktop-test/src/reporting/lane.ts        |  11 +-
 .../src/reporting/protocol.test.ts            |  28 ++
 .../desktop-test/src/reporting/protocol.ts    |  35 ++-
 .../src/reporting/results.test.ts             |  21 +-
 .../desktop-test/src/reporting/results.ts     |  24 +-
 .../src/reporting/runQueries.test.ts          |  29 +-
 .../desktop-test/src/reporting/runQueries.ts  |  27 +-
 .../desktop-test/src/wdio/configuration.ts    |   9 +-
 .../agentic/desktop-test/src/wdio/reporter.ts |   3 +
 .../config/transform-story-tests.cjs          | 186 +++++++++++-
 .../config/transform-story-tests.d.cts        |   8 +-
 .../storybook-desktop/references/commands.md  |   7 +-
 .../references/story-tests.md                 |  22 +-
 .../src/cli/inputLane.test.ts                 |   9 +-
 .../storybook-desktop/src/cli/inputLane.ts    |   6 +-
 .../src/testing/extractWdioTests.test.ts      |  97 +++++++
 .../src/testing/extractWdioTests.ts           |   2 +-
 .../src/testing/runWdioTests.ts               |  67 ++++-
 .../src/testing/wdioRunner.contract.cjs       | 114 +++++++-
 .../src/testing/wdioRunner.test.ts            |  47 ++-
 76 files changed, 2404 insertions(+), 279 deletions(-)
 create mode 100644 .changeset/session-input-policy.md
 create mode 100644 packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
 create mode 100644 packages/agentic/desktop-driver/src/server/sessionInput.test.ts
 create mode 100644 packages/agentic/desktop-driver/src/server/sessionInput.ts
 create mode 100644 packages/agentic/desktop-driver/src/testing/scriptedNativeHelper.ts
 create mode 100644 packages/agentic/desktop-driver/src/wdio/input.contract.cjs

diff --git a/.changeset/session-input-policy.md b/.changeset/session-input-policy.md
new file mode 100644
index 0000000000..1407b644fc
--- /dev/null
+++ b/.changeset/session-input-policy.md
@@ -0,0 +1,7 @@
+---
+'@fluentui-react-native/desktop-driver': patch
+'@fluentui-react-native/desktop-test': patch
+'@fluentui-react-native/storybook-desktop': patch
+---
+
+Enforce input policy per WebDriver session and report case-level input mechanism receipts.
diff --git a/packages/agentic/desktop-driver/native/PROTOCOL.md b/packages/agentic/desktop-driver/native/PROTOCOL.md
index 8e1db1651f..5848f2a3d1 100644
--- a/packages/agentic/desktop-driver/native/PROTOCOL.md
+++ b/packages/agentic/desktop-driver/native/PROTOCOL.md
@@ -283,6 +283,39 @@ one input turn and refuses a display name the element does not publish
 exactly once, so a key never reaches a different action than the one the
 agent named.
 
+### Clear mechanisms
+
+The mutating `clear` command takes `{ "elementId": "<id>" }`. Helpers that
+advertise `strictClear` in `hello.features` and in the `features` map of the
+`probe` result also accept an optional `mechanism` of `"semantic"` or
+`"keyboard"`, and answer every successful clear with
+`{ "mechanism": "semantic" | "keyboard" }`, naming the mechanism that cleared
+the element:
+
+- Without `mechanism`, the helper writes an empty value through the platform
+  accessibility value (macOS `AXValue`, the Windows UI Automation Value
+  pattern) and, when the element has no writable value or the write is
+  refused, falls back to focusing the element and pressing select-all and
+  Delete.
+- `semantic` uses only the value write and never falls back to the keyboard.
+  An element without a writable value fails `element-not-interactable` with
+  effect `none` before anything is dispatched, and a broken element is
+  `stale-element`. A write that was dispatched and failed settles as any other
+  mutation does: a refusal that proves the write never acted is `none`, any
+  other failure is `unknown`, and a write that never settles is
+  `mutation-indeterminate`.
+- `keyboard` skips the value write and clears only with the keyboard, behind
+  the same input authority, session, focus, and physical input lock checks as
+  the fallback. A check that refuses, such as `input-unavailable`, dispatches
+  nothing and is `none`.
+
+Any other `mechanism`, including one that is not a string, fails
+`invalid-params` with effect `none`. Node never sends `mechanism` unless the
+feature is negotiated, and treats a result without a recognized `mechanism`,
+such as the `null` an older helper returns, as not saying which mechanism
+cleared. The parameter, result, and feature are additive and do not change the
+wire version.
+
 ### Bounded observation
 
 Helpers that advertise `boundedObservation` in `hello.features` and in the
diff --git a/packages/agentic/desktop-driver/native/macos/README.md b/packages/agentic/desktop-driver/native/macos/README.md
index 6a803f8dd3..e333b9eaed 100644
--- a/packages/agentic/desktop-driver/native/macos/README.md
+++ b/packages/agentic/desktop-driver/native/macos/README.md
@@ -289,6 +289,17 @@ responsible process and an unlocked interactive Aqua session. Missing authority
 returns `input-unavailable`; the provider never substitutes unrelated
 accessibility activation and reports physical success.
 
+The helper advertises `strictClear`. `clear` writes an empty `AXValue` when
+`AXUIElementIsAttributeSettable` reports the value settable, and otherwise
+activates the application, focuses the element, and presses Command-A and
+Delete under the physical input lock. A request may name `mechanism`:
+`semantic` only writes `AXValue` and fails `element-not-interactable` with
+effect `none` when the value is not settable, and `keyboard` skips the write
+and needs the same physical input authority as the fallback. Every successful
+clear returns `{ "mechanism": "semantic" | "keyboard" }`. The `probe` feature
+is `true` even without Accessibility trust, because each mechanism reports its
+own refusal.
+
 A locked screen or a login session that is not the active console prevents
 applications from publishing complete accessibility windows and from receiving
 physical input. Launch, attach, window discovery, and new pointer, keyboard,
diff --git a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Accessibility.swift b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Accessibility.swift
index a8e67b97eb..bb9ef8508a 100644
--- a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Accessibility.swift
+++ b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Accessibility.swift
@@ -378,11 +378,27 @@ final class AccessibilityEngine {
     }
   }
 
-  func tryClearValue(_ elementID: String) throws -> Bool {
+  /// Writes an empty `AXValue` and reports whether that cleared the element. Without `strict`, an element whose value
+  /// cannot be written answers false so the caller can clear with the keyboard. With it, the method never answers
+  /// false: such an element fails `element-not-interactable` before anything is dispatched, and a failed check or
+  /// write fails with the effect the ledger recorded.
+  func tryClearValue(_ elementID: String, strict: Bool = false) throws -> Bool {
     let record = try requireRecord(elementID)
     try validateLive(record)
     var settable: DarwinBoolean = false
     let settableError = AXUIElementIsAttributeSettable(record.element, kAXValueAttribute as CFString, &settable)
+    if strict {
+      if settableError == .attributeUnsupported || settableError == .noValue
+        || (settableError == .success && !settable.boolValue)
+      {
+        try fail(ErrorCode.notInteractable, "The element does not expose a writable value to clear.")
+      }
+      try throwAX(
+        settableError,
+        operation: "Checking whether the element value can be set",
+        staleMessage: "Element \"\(elementID)\" is no longer available."
+      )
+    }
     if settableError == .attributeUnsupported || settableError == .noValue || !settable.boolValue {
       return false
     }
@@ -398,6 +414,9 @@ final class AccessibilityEngine {
     if error == .invalidUIElement {
       try fail(ErrorCode.staleElement, "Element \"\(elementID)\" is no longer available.")
     }
+    if strict {
+      try throwAX(error, operation: "Clearing the element value")
+    }
     return error == .success
   }
 
diff --git a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Driver.swift b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Driver.swift
index 0139f02414..da3d893ae4 100644
--- a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Driver.swift
+++ b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Driver.swift
@@ -198,8 +198,9 @@ final class Driver {
       )
       return CommandResult()
     case "clear":
-      try clear(elementID: try requireString(params, "elementId"), token: token)
-      return CommandResult()
+      let elementID = try requireString(params, "elementId")
+      let mechanism = try clearMechanism(params)
+      return CommandResult(result: ["mechanism": try clear(elementID: elementID, mechanism: mechanism, token: token)])
     case "sendKeys":
       guard let text = params["text"] as? String else {
         try fail(ErrorCode.invalidParams, "The sendKeys request requires a string \"text\".")
@@ -296,6 +297,7 @@ final class Driver {
         "physicalClick": trusted,
         "screenshot": screenshot,
         "setWindowRect": trusted,
+        "strictClear": true,
         "wheel": trusted,
         "windowEvents": trusted,
       ],
@@ -520,16 +522,34 @@ final class Driver {
     }
   }
 
-  private func clear(elementID: String, token: CancellationToken) throws {
+  /// The clear mechanism a request names, or nil when the helper may choose. Anything else is refused before dispatch.
+  private func clearMechanism(_ params: JSONObject) throws -> String? {
+    guard let value = params["mechanism"] else {
+      return nil
+    }
+    guard let mechanism = value as? String, mechanism == "semantic" || mechanism == "keyboard" else {
+      try fail(ErrorCode.invalidParams, "The clear mechanism must be \"semantic\" or \"keyboard\".")
+    }
+    return mechanism
+  }
+
+  /// Clears the element and returns the mechanism that did. Without a requested mechanism the value write comes first
+  /// and the keyboard is its fallback; a requested mechanism is the only one used.
+  private func clear(elementID: String, mechanism: String?, token: CancellationToken) throws -> String {
     let window = try windowForElement(elementID)
     _ = try accessibility.snapshot(elementID: elementID, window: window, token: token)
-    if try accessibility.tryClearValue(elementID) {
-      return
+    if mechanism != "keyboard", try accessibility.tryClearValue(elementID, strict: mechanism == "semantic") {
+      return "semantic"
+    }
+    guard mechanism != "semantic" else {
+      try fail(ErrorCode.internalError, "The semantic clear ended without clearing or failing.")
     }
     guard input.physicalInputAvailable() else {
       try fail(
         ErrorCode.inputUnavailable,
-        "The element does not expose a writable value and physical input requires Accessibility permission."
+        mechanism == "keyboard"
+          ? "Physical keyboard input requires Accessibility permission in System Settings > Privacy & Security > Accessibility."
+          : "The element does not expose a writable value and physical input requires Accessibility permission."
       )
     }
     try withPhysicalInput(token: token) {
@@ -538,6 +558,7 @@ final class Driver {
       try token.wait(milliseconds: 16)
       try input.pressCommandADelete(token: token)
     }
+    return "keyboard"
   }
 
   private func sendKeys(elementID: String, text: String, token: CancellationToken) throws {
diff --git a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Host.swift b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Host.swift
index 62a46b3185..bd81f63e6b 100644
--- a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Host.swift
+++ b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/Host.swift
@@ -31,6 +31,7 @@ func createHello() -> JSONObject {
       "releaseActions",
       "setWindowRect",
       "source",
+      "strictClear",
       "tree",
       "wheel",
       "windowEvents",
diff --git a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/SelfTest.swift b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/SelfTest.swift
index 4a0d75eb0e..be7174e15e 100644
--- a/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/SelfTest.swift
+++ b/packages/agentic/desktop-driver/native/macos/Sources/DesktopDriverHost/SelfTest.swift
@@ -772,6 +772,26 @@ final class SelfTestRunner {
       actions?.code == ErrorCode.invalidParams && actions?.effect == .noEffect,
       "a malformed input sequence reports no effect"
     )
+    for mechanism: Any in ["pointer", "", 1, NSNull()] {
+      residue.dispatching()
+      let clear = failure("clear", ["elementId": "element-missing", "mechanism": mechanism]) as? HelperError
+      check(
+        clear?.code == ErrorCode.invalidParams && clear?.effect == .noEffect,
+        "a clear naming an unknown mechanism (\(mechanism)) is refused before dispatch"
+      )
+    }
+    for mechanism in ["semantic", "keyboard"] {
+      let clear = failure("clear", ["elementId": "element-missing", "mechanism": mechanism]) as? HelperError
+      check(
+        clear?.code == ErrorCode.staleElement && clear?.effect == .noEffect,
+        "a \(mechanism) clear of a missing element reports no effect"
+      )
+    }
+    let probe = try? driver.execute(command: "probe", params: [:], token: token).result as? JSONObject
+    check(
+      (probe?["features"] as? JSONObject)?["strictClear"] as? Bool == true,
+      "probe reports that clear honors a requested mechanism"
+    )
     let read = failure("windows") as? HelperError
     check(read != nil && read?.effect == nil, "a read-only command does not claim an effect")
     let unsupported = failure("not-a-command") as? HelperError
@@ -931,6 +951,7 @@ final class SelfTestRunner {
       (hello["features"] as? [String])?.contains("performAccessibilityAction") == true,
       "hello advertises performing accessibility actions"
     )
+    check((hello["features"] as? [String])?.contains("strictClear") == true, "hello advertises strict clear")
   }
 
   private func testAccessibilityActionNames() {
diff --git a/packages/agentic/desktop-driver/native/windows/README.md b/packages/agentic/desktop-driver/native/windows/README.md
index 3a16feea72..e130e6fdbe 100644
--- a/packages/agentic/desktop-driver/native/windows/README.md
+++ b/packages/agentic/desktop-driver/native/windows/README.md
@@ -172,6 +172,19 @@ accessibility clicks. Neither names nor keys enter the native command journal.
 The `observe` `actions` fact uses cached pattern-availability properties, so
 listing actions adds no per-node provider calls to the bounded walk.
 
+### Clear mechanisms
+
+The helper advertises `strictClear`. `clear` writes an empty value through the
+UIA Value pattern when the element exposes one that is not read-only, and
+otherwise presses Ctrl+A and Delete after focusing the element. A request may
+name `mechanism`: `semantic` only writes the value and fails
+`element-not-interactable` with effect `none` when the pattern is missing or
+read-only, and `keyboard` skips the write and takes the same input authority,
+focus check, and physical input lock as the fallback. The value write uses the
+bounded mutation worker, effect ledger, and lease-scoped quarantine, so a
+`semantic` write that never settles is `mutation-indeterminate`. Every
+successful clear returns `{ "mechanism": "semantic" | "keyboard" }`.
+
 ### Window events and identity
 
 Window lifecycle comes from out-of-context `SetWinEventHook` notifications
@@ -213,7 +226,8 @@ point. A `SendInput` call that injects fewer events than requested fails as
 
 `click` mode `auto` falls back to accessibility activation when physical input
 is unavailable, and an explicit `physical` request reports `input-unavailable`.
-Element `sendKeys` and the physical `clear` fallback activate the target window
+Element `sendKeys` and the keyboard `clear` (the fallback, or a `keyboard`
+mechanism) activate the target window
 and verify keyboard focus before sending, which is stricter than the macOS
 `clear`; `performActions` activates only when the foreground belongs to another
 application. The helper has no `uiAccess` manifest, and the occlusion check
diff --git a/packages/agentic/desktop-driver/native/windows/src/automation.cpp b/packages/agentic/desktop-driver/native/windows/src/automation.cpp
index 2181d6726f..e75f46fda6 100644
--- a/packages/agentic/desktop-driver/native/windows/src/automation.cpp
+++ b/packages/agentic/desktop-driver/native/windows/src/automation.cpp
@@ -1422,17 +1422,35 @@ void Automation::PerformAccessibilityAction(const std::string& elementId, const
   }
 }
 
-bool Automation::TryClearValue(const std::string& elementId) {
+bool Automation::TryClearValue(const std::string& elementId, bool strict) {
   const ElementRecord& record = RequireRecord(elementId);
   winrt::com_ptr<IUIAutomationValuePattern> value;
-  if (FAILED(record.element->GetCurrentPatternAs(UIA_ValuePatternId, IID_PPV_ARGS(value.put()))) || !value) {
-    return false;
+  const HRESULT query = record.element->GetCurrentPatternAs(UIA_ValuePatternId, IID_PPV_ARGS(value.put()));
+  if (FAILED(query) || !value) {
+    if (!strict) {
+      return false;
+    }
+    if (query == UIA_E_ELEMENTNOTAVAILABLE) {
+      Fail(kErrorStaleElement, "The element is no longer available.");
+    }
+    if (SUCCEEDED(query) || query == UIA_E_NOTSUPPORTED || query == E_NOINTERFACE || query == E_NOTIMPL ||
+        query == E_FAIL) {
+      Fail(kErrorNotInteractable, "The element does not expose a writable value to clear.");
+    }
+    FailHresult(kErrorAutomationFailed, "Reading the element value pattern", query);
   }
   const auto readOnly = std::make_shared<BOOL>(TRUE);
   const HRESULT state = BoundedRead([value, readOnly]() { return value->get_CurrentIsReadOnly(readOnly.get()); },
                                     "Reading the element value state");
   if (FAILED(state) || *readOnly != FALSE) {
-    return false;
+    if (!strict) {
+      return false;
+    }
+    if (state == UIA_E_ELEMENTNOTAVAILABLE) {
+      Fail(kErrorStaleElement, "The element is no longer available.");
+    }
+    CheckHresult(kErrorAutomationFailed, "Reading the element value state", state);
+    Fail(kErrorNotInteractable, "The element's value is read-only, so it cannot be cleared.");
   }
   const HRESULT result = CountedMutation(
       [value]() {
@@ -1442,6 +1460,13 @@ bool Automation::TryClearValue(const std::string& elementId) {
         return assigned;
       },
       "Clearing the element value");
+  if (strict) {
+    if (result == UIA_E_ELEMENTNOTAVAILABLE) {
+      Fail(kErrorStaleElement, "The element is no longer available.");
+    }
+    CheckHresult(result == UIA_E_ELEMENTNOTENABLED ? kErrorNotInteractable : kErrorAutomationFailed,
+                 "Clearing the element value", result);
+  }
   return SUCCEEDED(result);
 }
 
diff --git a/packages/agentic/desktop-driver/native/windows/src/automation.h b/packages/agentic/desktop-driver/native/windows/src/automation.h
index 8388fd088d..8f0a5c9565 100644
--- a/packages/agentic/desktop-driver/native/windows/src/automation.h
+++ b/packages/agentic/desktop-driver/native/windows/src/automation.h
@@ -103,7 +103,13 @@ class Automation {
   void AccessibilityClick(const std::string& elementId, const CancellationToken& token);
   json::Value AccessibilityActions(const std::string& elementId, const CancellationToken& token);
   void PerformAccessibilityAction(const std::string& elementId, const std::string& key, const CancellationToken& token);
-  bool TryClearValue(const std::string& elementId);
+  // Writes an empty value through the Value pattern and reports whether that
+  // cleared the element. Without `strict`, an element without a writable value
+  // or a refused write returns false so the caller can clear with the
+  // keyboard. With it, the method never returns false: such an element fails
+  // as not interactable before anything is dispatched, and a failed write
+  // fails with the effect the ledger recorded.
+  bool TryClearValue(const std::string& elementId, bool strict = false);
   bool HasKeyboardFocus(const std::string& elementId);
 
   void ForgetWindow(const std::string& windowId);
diff --git a/packages/agentic/desktop-driver/native/windows/src/driver.cpp b/packages/agentic/desktop-driver/native/windows/src/driver.cpp
index c88fa2c719..30ce1ebd88 100644
--- a/packages/agentic/desktop-driver/native/windows/src/driver.cpp
+++ b/packages/agentic/desktop-driver/native/windows/src/driver.cpp
@@ -41,6 +41,19 @@ std::string RequireString(const json::Value& params, std::string_view key) {
   return value->AsString();
 }
 
+// The clear mechanism a request names, or empty when the helper may choose.
+// Anything else is refused before dispatch.
+std::string RequireClearMechanism(const json::Value& params) {
+  const json::Value* mechanism = params.Find("mechanism");
+  if (mechanism == nullptr) {
+    return {};
+  }
+  if (!mechanism->IsString() || (mechanism->AsString() != "semantic" && mechanism->AsString() != "keyboard")) {
+    Fail(kErrorInvalidParams, "The clear mechanism must be \"semantic\" or \"keyboard\".");
+  }
+  return mechanism->AsString();
+}
+
 int ActionButton(const json::Value& action) {
   const json::Value* button = action.Find("button");
   if (button == nullptr || !button->IsNumber()) {
@@ -274,6 +287,7 @@ json::Value Driver::ProbeResult(const json::Value& params) {
   features.Set("physicalClick", json::Value::Bool(physical));
   features.Set("screenshot", json::Value::Bool(screenshot));
   features.Set("setWindowRect", json::Value::Bool(true));
+  features.Set("strictClear", json::Value::Bool(true));
   features.Set("wheel", json::Value::Bool(physical));
   features.Set("windowEvents", json::Value::Bool(true));
 
@@ -769,9 +783,14 @@ CommandResult Driver::ExecuteCommand(const std::string& command, const json::Val
   }
   if (command == "clear") {
     const std::string elementId = RequireString(params, "elementId");
+    const std::string mechanism = RequireClearMechanism(params);
     RequireLiveElement(elementId, token);
     const MutationScope scope(LeaseIdForElement(elementId));
-    if (!automation_.TryClearValue(elementId)) {
+    const bool semantic = mechanism != "keyboard" && automation_.TryClearValue(elementId, mechanism == "semantic");
+    if (!semantic && mechanism == "semantic") {
+      Fail(kErrorInternal, "The semantic clear ended without clearing or failing.");
+    }
+    if (!semantic) {
       RunPhysical(token, [&]() {
         const HWND window = FocusForKeyboard(elementId, token);
         const KeyboardGuardScope guard(input_, KeyboardGuardFor(window));
@@ -779,7 +798,8 @@ CommandResult Driver::ExecuteCommand(const std::string& command, const json::Val
         input_.PressChord({VK_DELETE}, token);
       });
     }
-    result.result = json::Value::Null();
+    result.result = json::Value::Object();
+    result.result.Set("mechanism", json::Value::String(std::string(semantic ? "semantic" : "keyboard")));
     return result;
   }
   if (command == "sendKeys") {
diff --git a/packages/agentic/desktop-driver/native/windows/src/host.cpp b/packages/agentic/desktop-driver/native/windows/src/host.cpp
index 33438b374d..e57a83c72f 100644
--- a/packages/agentic/desktop-driver/native/windows/src/host.cpp
+++ b/packages/agentic/desktop-driver/native/windows/src/host.cpp
@@ -51,7 +51,7 @@ json::Value CreateHello() {
   for (const char* feature : {"accessibilityActions", "accessibilityClick", "performAccessibilityAction",
                               "activeElement", "boundedObservation", "capture", "elementCapture",
                               "find", "hitTest", "keyboard", "launch", "attach", "pointer", "probe", "releaseActions",
-                              "setWindowRect", "source", "tree", "wheel", "windowEvents"}) {
+                              "setWindowRect", "source", "strictClear", "tree", "wheel", "windowEvents"}) {
     features.Append(json::Value::String(std::string(feature)));
   }
   hello.Set("features", features);
diff --git a/packages/agentic/desktop-driver/native/windows/src/selftest.cpp b/packages/agentic/desktop-driver/native/windows/src/selftest.cpp
index 4dc88d981d..a357f57b6d 100644
--- a/packages/agentic/desktop-driver/native/windows/src/selftest.cpp
+++ b/packages/agentic/desktop-driver/native/windows/src/selftest.cpp
@@ -404,6 +404,11 @@ void TestHello() {
       std::any_of(features->Items().begin(), features->Items().end(),
                   [](const json::Value& feature) { return feature.AsString() == "boundedObservation"; });
   Check(announcesObservation, "hello announces bounded observation");
+  const bool announcesStrictClear =
+      features != nullptr &&
+      std::any_of(features->Items().begin(), features->Items().end(),
+                  [](const json::Value& feature) { return feature.AsString() == "strictClear"; });
+  Check(announcesStrictClear, "hello announces strict clear");
 }
 
 void TestReleaseLedger() {
@@ -2817,6 +2822,50 @@ void TestDriverMutationEffects() {
   Check(recordedInputs.empty() && buttonClicks.load() == 0 && IsWindow(window) != FALSE,
         "rejected and cancelled mutations reach nothing");
 
+  // A clear that names its mechanism uses only that mechanism.
+  const auto clearWith = [](const std::string& elementId, const char* mechanism) {
+    json::Value request = StringFields({{"elementId", elementId}});
+    if (mechanism != nullptr) {
+      request.Set("mechanism", json::Value::String(std::string(mechanism)));
+    }
+    return request;
+  };
+  json::Value numericMechanism = StringFields({{"elementId", editId}});
+  numericMechanism.Set("mechanism", json::Value::Integer(1));
+  bool unknownMechanismsRefused = true;
+  for (const json::Value& params : std::vector<json::Value>{clearWith(editId, "pointer"), clearWith(editId, ""),
+                                                            numericMechanism}) {
+    unknownMechanismsRefused =
+        unknownMechanismsRefused && effectOf("clear", params, token, &code) == "none" && code == kErrorInvalidParams;
+  }
+  Check(unknownMechanismsRefused, "a clear naming an unknown mechanism is refused before dispatch");
+  SetWindowTextW(edit, L"abc");
+  Check(effectOf("clear", clearWith(buttonId, "semantic"), token, &code) == "none" && code == kErrorNotInteractable,
+        "a semantic clear of an element without a value is refused before dispatch");
+  SendMessageW(edit, EM_SETREADONLY, TRUE, 0);
+  Check(effectOf("clear", clearWith(editId, "semantic"), token, &code) == "none" && code == kErrorNotInteractable &&
+            GetWindowTextLengthW(edit) == 3,
+        "a semantic clear of a read-only value is refused before dispatch");
+  SendMessageW(edit, EM_SETREADONLY, FALSE, 0);
+  driver.InputForTesting().UseTestEnvironment([]() {
+    return InteractiveWith([](InputEnvironment& environment) { environment.lock = SessionLock::Locked; });
+  });
+  Check(effectOf("clear", clearWith(editId, "keyboard"), token, &code) == "none" && code == kErrorInputUnavailable &&
+            GetWindowTextLengthW(edit) == 3,
+        "a keyboard clear honors the input gates instead of writing the value");
+  driver.InputForTesting().UseTestEnvironment([]() { return InteractiveEnvironmentForTesting(); });
+  const CommandResult semanticClear = driver.Execute("clear", clearWith(editId, "semantic"), token);
+  Check(semanticClear.result.StringField("mechanism") == "semantic" && GetWindowTextLengthW(edit) == 0,
+        "a semantic clear writes the value and reports it");
+  SetWindowTextW(edit, L"abc");
+  const CommandResult chosenClear = driver.Execute("clear", clearWith(editId, nullptr), token);
+  Check(chosenClear.result.StringField("mechanism") == "semantic" && GetWindowTextLengthW(edit) == 0 &&
+            recordedInputs.empty(),
+        "a clear that names no mechanism reports the value write it chose");
+  const CommandResult probe = driver.Execute("probe", empty, token);
+  const json::Value* features = probe.result.Find("features");
+  Check(features != nullptr && features->BoolField("strictClear"), "the probe reports strict clear");
+
   // Stopped after part of the command reached the application.
   recordedInputs.clear();
   const json::Value brokenSequence =
diff --git a/packages/agentic/desktop-driver/references/protocol.md b/packages/agentic/desktop-driver/references/protocol.md
index c8a40be15b..a9570a475b 100644
--- a/packages/agentic/desktop-driver/references/protocol.md
+++ b/packages/agentic/desktop-driver/references/protocol.md
@@ -39,12 +39,21 @@ Supported extension capabilities:
 - `furn:renderer`;
 - `furn:launchMode`: `launch` or `attach`;
 - `furn:clickMode`: `physical`, `accessibility`, or `auto`;
+- `furn:inputMode`: `accessible`, `physical`, or `compatibility` (the default);
 - returned `furn:features`.
 
 Capability matching implements W3C `alwaysMatch` and ordered `firstMatch`,
 rejects duplicate merge keys, and returns `session not created` when no
 registered target can satisfy a candidate.
 
+`furn:inputMode` is fixed for the session and returned in its capabilities.
+`accessible` permits accessibility clicks, named accessibility actions, and
+semantic clears, and rejects keyboard, pointer, and wheel input before
+dispatch. `physical` permits physical and accessibility input, but clears only
+with keyboard input. `compatibility` preserves the previous behavior and leaves
+mechanism choice to the host. A strict mode pins `furn:clickMode`; a conflicting
+explicit click mode prevents session creation.
+
 ## W3C routes
 
 Implemented standard behavior:
@@ -63,6 +72,10 @@ Implemented standard behavior:
 
 Implemented `furn` extensions:
 
+- `GET /session/{id}/furn/input`, returning the fixed input mode and counts of
+  input deliveries by mechanism;
+- `POST /session/{id}/element/{element-id}/furn/accessibility-action`, invoking
+  one uniquely named action published by that element;
 - `GET /session/{id}/furn/manifest`;
 - `GET|POST /session/{id}/furn/story`;
 - `POST /session/{id}/furn/story/reset`;
@@ -150,7 +163,9 @@ reads `AXUIElementCopyActionNames` and lists an authored custom action, such as
 `Toggle` or `Select`, by name without any provider handle, alongside any standard
 actions the element publishes. An element that publishes none returns `[]`; hosts
 without the feature, including Windows and Win32, return `unsupported operation`
-rather than `[]`. The property only lists actions; it does not invoke them.
+rather than `[]`. The property only lists actions; it does not invoke them. The named-action
+extension invokes one action by its unique published name; its request is
+serialized with input and obeys the session's `furn:inputMode`.
 What an element publishes depends on the renderer: React Native macOS Fabric
 publishes every declared `accessibilityActions` entry by `name`, while Paper
 publishes only entries that declare a `label` and lists them by that label
diff --git a/packages/agentic/desktop-driver/references/test-integration.md b/packages/agentic/desktop-driver/references/test-integration.md
index 6e09fb1c46..b1cb942a58 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -38,6 +38,7 @@ import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/w
 
 const desktop = await connectDesktopWebdriver({
   clickMode: 'auto',
+  inputMode: 'accessible',
   launchMode: 'attach',
   platformName: 'macos',
   targetId: 'component-storybook-macos',
@@ -53,6 +54,21 @@ try {
 }
 ```
 
+`inputMode` defaults to `compatibility`. Use `accessible` to refuse keyboard,
+pointer, and wheel input before dispatch, or `physical` to require physical
+clears and clicks while still permitting accessibility actions. The selected
+mode is fixed in the session's returned `furn:inputMode` capability. Read
+`desktop.input()` (or `desktop.browser.desktopInput()`) for that mode and the
+session's delivery counts. A declared test runner compares those receipts with
+the case's `requires`; an undeclared mechanism fails the test, while an unused
+requirement is reported without failing it.
+
+WDIO's `element.desktopPerformAccessibilityAction(name)` invokes a uniquely
+published accessibility action without pointer or keyboard input. Declare
+`perform-accessibility-action` on the case that uses it. In an accessible
+session, `setValue` is rejected before WDIO's client-side clear step; `clear`
+remains available as a semantic clear.
+
 Use standard WebdriverIO APIs only where the
 [implemented protocol](protocol.md) supports them. Browser navigation, cookies,
 frames, JavaScript execution, prompts, printing, CSS values, and shadow roots
@@ -111,11 +127,12 @@ package. Static plans below are unchanged.
 
 The descriptor that `desktopIt` accepts (`requires`, `input`, `platforms`,
 `scope`, and declared gaps) is defined and decided in `./authoring`, so Storybook
-and `desktop-test` share one implementation. A runner that executes one input lane
-pins `furn:clickMode` with `resolveDesktopClickMode`: `element.click()` is then an
-accessibility click in the accessible lane and a physical click in the physical
-lane. `missingDesktopRequirements` judges a case's `requires` against the
-session's `furn:features`, and judges a `click` requirement by the pinned mode.
+and `desktop-test` share one implementation. A runner that executes one input
+lane requests and verifies the matching `furn:inputMode`; the policy pins
+`furn:clickMode`, so `element.click()` is an accessibility click in the
+accessible lane and a physical click in the physical lane.
+`missingDesktopRequirements` judges a case's `requires` against the session's
+`furn:features`, and judges a `click` requirement by the pinned mode.
 
 ## Author portable story plans
 
diff --git a/packages/agentic/desktop-driver/src/authoring/index.ts b/packages/agentic/desktop-driver/src/authoring/index.ts
index 96cae618c8..9c25e6a6e3 100644
--- a/packages/agentic/desktop-driver/src/authoring/index.ts
+++ b/packages/agentic/desktop-driver/src/authoring/index.ts
@@ -16,27 +16,40 @@ export {
 } from './storyTests.js';
 export {
   accessibleLaneMaskedFeatures,
+  compareDesktopInputReceipts,
+  desktopInputMechanisms,
+  desktopInputModeAllows,
+  desktopInputModes,
   desktopInputLanes,
   desktopRequirements,
+  describeUndeclaredDesktopInput,
   matchesDesktopPlatforms,
   matchesDesktopScope,
   mergeDesktopCaseOptions,
   resolveDesktopInput,
   resolveDesktopScopeDomains,
   resolveDesktopScopeValues,
+  subtractDesktopInputReceipts,
   unmaskedAccessibleFeatures,
   validateDesktopCaseOptions,
   validateDesktopGroupOptions,
+  validateDesktopInputReceipts,
+  validateDesktopSessionInput,
 } from './input.js';
 export type {
   AccessibleLaneMaskedFeature,
   DesktopCaseOptions,
   DesktopInput,
+  DesktopInputComparison,
   DesktopInputLane,
+  DesktopInputMechanism,
+  DesktopInputMode,
+  DesktopInputReceipts,
   DesktopPlatforms,
   DesktopRequirement,
   DesktopScopeDomains,
   DesktopScopeValues,
+  DesktopSessionInput,
   ResolvedDesktopCaseOptions,
 } from './input.js';
 export { decideDesktopCase, missingDesktopRequirements, resolveDesktopClickMode } from './selection.js';
diff --git a/packages/agentic/desktop-driver/src/authoring/input.test.ts b/packages/agentic/desktop-driver/src/authoring/input.test.ts
index 0077d51cfc..3023b25cfa 100644
--- a/packages/agentic/desktop-driver/src/authoring/input.test.ts
+++ b/packages/agentic/desktop-driver/src/authoring/input.test.ts
@@ -1,14 +1,19 @@
 import {
   accessibleLaneMaskedFeatures,
+  compareDesktopInputReceipts,
+  describeUndeclaredDesktopInput,
+  desktopInputModeAllows,
   matchesDesktopPlatforms,
   matchesDesktopScope,
   mergeDesktopCaseOptions,
   resolveDesktopInput,
   resolveDesktopScopeDomains,
   resolveDesktopScopeValues,
+  subtractDesktopInputReceipts,
   unmaskedAccessibleFeatures,
   validateDesktopCaseOptions,
   validateDesktopGroupOptions,
+  validateDesktopSessionInput,
 } from './input.js';
 
 describe('accessible lane masks', () => {
@@ -98,10 +103,17 @@ describe('desktop input descriptors', () => {
 
   test('rejects mixed transports and explicit widening', () => {
     expect(() => resolveDesktopInput(undefined, ['keyboard', 'accessibility-click'])).toThrow('split the case');
+    expect(() => resolveDesktopInput('both', ['physical-click', 'perform-accessibility-action'])).toThrow('split the case');
     expect(() => resolveDesktopInput('both', ['physical-click'])).toThrow('cannot widen');
     expect(() => resolveDesktopInput('physical', ['accessibility-click'])).toThrow('cannot widen');
   });
 
+  test('runs a case that needs both transports only in a declared physical lane', () => {
+    expect(resolveDesktopInput('physical', ['physical-click', 'perform-accessibility-action'])).toBe('physical');
+    expect(resolveDesktopInput('physical', ['keyboard', 'accessibility-click'])).toBe('physical');
+    expect(resolveDesktopInput(undefined, ['perform-accessibility-action'])).toBe('accessible');
+  });
+
   test('validates platform filters and negation', () => {
     expect(matchesDesktopPlatforms(['!win32'], 'windows')).toBe(true);
     expect(matchesDesktopPlatforms(['!win32'], 'win32')).toBe(false);
@@ -153,3 +165,61 @@ describe('desktop scope domains', () => {
     expect(() => matchesDesktopScope(inherited, supplied, domains)).toThrow('unknown scope key');
   });
 });
+
+describe('desktop input receipts', () => {
+  const kase = (options: object) => validateDesktopCaseOptions(options);
+
+  test('fails a mechanism nothing declared and reports a declared transport left unused', () => {
+    expect(compareDesktopInputReceipts(kase({ requires: ['click'] }), { 'accessibility-click': 2 })).toEqual({
+      undeclared: [],
+      unused: [],
+    });
+    expect(compareDesktopInputReceipts(kase({ requires: ['physical-click', 'keyboard'] }), { pointer: 1 })).toEqual({
+      undeclared: [],
+      unused: ['keyboard'],
+    });
+    expect(compareDesktopInputReceipts(kase({ requires: ['accessibility-click'] }), { 'physical-click': 1, 'semantic-clear': 1 })).toEqual({
+      undeclared: ['physical-click'],
+      unused: ['accessibility-click'],
+    });
+    expect(compareDesktopInputReceipts(undefined, { 'unattributed-clear': 1, wheel: 1 })).toEqual({
+      undeclared: ['unattributed-clear', 'wheel'],
+      unused: [],
+    });
+    expect(compareDesktopInputReceipts(kase({ requires: ['focus'] }), {})).toEqual({ undeclared: [], unused: [] });
+  });
+
+  test('lets any click declaration account for the transport an auto session chose', () => {
+    const physical = kase({ requires: ['accessibility-click', 'keyboard'], input: 'physical' });
+    expect(compareDesktopInputReceipts(physical, { 'physical-click': 1, keyboard: 1 }, 'auto')).toEqual({ undeclared: [], unused: [] });
+    expect(compareDesktopInputReceipts(physical, { 'physical-click': 1, keyboard: 1 }, 'physical')).toEqual({
+      undeclared: ['physical-click'],
+      unused: ['accessibility-click'],
+    });
+    // A pointer action is physical whatever the click mode, so only physical-click declares it.
+    expect(compareDesktopInputReceipts(kase({ requires: ['click'] }), { pointer: 1 }, 'auto').undeclared).toEqual(['pointer']);
+    expect(describeUndeclaredDesktopInput(['keyboard', 'accessibility-click'])).toBe(
+      'The test delivered input it does not declare: keyboard (declare keyboard), accessibility-click (declare accessibility-click or click).',
+    );
+  });
+
+  test('takes per-case deltas from a shared session and rejects malformed reports', () => {
+    expect(subtractDesktopInputReceipts({ keyboard: 3, 'physical-click': 1 }, { keyboard: 1, 'physical-click': 1 })).toEqual({
+      keyboard: 2,
+    });
+    expect(() => compareDesktopInputReceipts(undefined, { typing: 1 })).toThrow('unknown mechanism');
+    expect(() => compareDesktopInputReceipts(undefined, { keyboard: 0 })).toThrow('positive integer');
+    expect(validateDesktopSessionInput({ mode: 'accessible', receipts: {} })).toEqual({ mode: 'accessible', receipts: {} });
+    expect(() => validateDesktopSessionInput({ receipts: {} })).toThrow('mode');
+  });
+
+  test('lets each policy deliver only its own mechanisms', () => {
+    expect(desktopInputModeAllows('accessible', 'accessibility-action')).toBe(true);
+    expect(desktopInputModeAllows('accessible', 'semantic-clear')).toBe(true);
+    expect(desktopInputModeAllows('accessible', 'pointer')).toBe(false);
+    expect(desktopInputModeAllows('accessible', 'unattributed-clear')).toBe(false);
+    expect(desktopInputModeAllows('physical', 'accessibility-click')).toBe(true);
+    expect(desktopInputModeAllows('physical', 'semantic-clear')).toBe(false);
+    expect(desktopInputModeAllows('compatibility', 'unattributed-clear')).toBe(true);
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/authoring/input.ts b/packages/agentic/desktop-driver/src/authoring/input.ts
index b81575801e..4bf362d7a3 100644
--- a/packages/agentic/desktop-driver/src/authoring/input.ts
+++ b/packages/agentic/desktop-driver/src/authoring/input.ts
@@ -7,6 +7,7 @@ export const desktopRequirements = [
   'element-screenshot',
   'focus',
   'keyboard',
+  'perform-accessibility-action',
   'physical-click',
   'screenshot',
   'set-window-rect',
@@ -18,6 +19,142 @@ export type DesktopInput = 'accessible' | 'physical' | 'both';
 export type DesktopInputLane = Exclude<DesktopInput, 'both'>;
 export const desktopInputLanes = ['accessible', 'physical'] as const satisfies readonly DesktopInputLane[];
 
+/**
+ * The input policy a Desktop Driver session enforces, fixed when the session is created (`furn:inputMode`). `accessible`
+ * delivers only semantic input, `physical` clicks physically and clears with the keyboard, and `compatibility`, the
+ * default, enforces nothing beyond the host's own masks.
+ */
+export const desktopInputModes = ['accessible', 'compatibility', 'physical'] as const;
+export type DesktopInputMode = (typeof desktopInputModes)[number];
+
+/**
+ * How a session delivered input, as it records it when it dispatches. `unattributed-clear` is a clear whose host did not
+ * say whether it set the value or typed, so it counts as possible keyboard input.
+ */
+export const desktopInputMechanisms = [
+  'accessibility-action',
+  'accessibility-click',
+  'keyboard',
+  'physical-click',
+  'pointer',
+  'semantic-clear',
+  'unattributed-clear',
+  'wheel',
+] as const;
+export type DesktopInputMechanism = (typeof desktopInputMechanisms)[number];
+
+/** How many times a session delivered input by each mechanism. A mechanism it never used is absent. */
+export type DesktopInputReceipts = Readonly<Partial<Record<DesktopInputMechanism, number>>>;
+
+/** What `GET /session/:id/furn/input` returns: the session's policy and the input it delivered. */
+export type DesktopSessionInput = {
+  mode: DesktopInputMode;
+  receipts: DesktopInputReceipts;
+};
+
+/**
+ * Whether a session's input policy lets it deliver a mechanism. An accessible session delivers only semantic input; a
+ * physical session clicks physically or semantically but clears only with the keyboard. A strict session never makes an
+ * unattributed clear, because it always says how to clear.
+ */
+export function desktopInputModeAllows(mode: DesktopInputMode, mechanism: DesktopInputMechanism): boolean {
+  switch (mode) {
+    case 'accessible':
+      return mechanism === 'accessibility-action' || mechanism === 'accessibility-click' || mechanism === 'semantic-clear';
+    case 'physical':
+      return mechanism !== 'semantic-clear' && mechanism !== 'unattributed-clear';
+    default:
+      return true;
+  }
+}
+
+/**
+ * The declarations that account for each mechanism. A semantic clear needs none: it is not physical input, and a case
+ * that clears declares the keyboard its physical variant types with.
+ */
+const mechanismRequirements: Readonly<Record<DesktopInputMechanism, readonly DesktopRequirement[]>> = {
+  'accessibility-action': ['perform-accessibility-action'],
+  'accessibility-click': ['accessibility-click', 'click'],
+  keyboard: ['keyboard'],
+  'physical-click': ['physical-click', 'click'],
+  pointer: ['physical-click'],
+  'semantic-clear': [],
+  'unattributed-clear': ['keyboard'],
+  wheel: ['wheel'],
+};
+
+/** What one case delivered, judged against what it declared. */
+export type DesktopInputComparison = {
+  /** Mechanisms the case delivered that none of its declarations accounts for. Any entry fails the case. */
+  undeclared: DesktopInputMechanism[];
+  /** Transport requirements the case declared and never exercised. Reported, never failed. */
+  unused: DesktopRequirement[];
+};
+
+/** Subtracts one receipt snapshot from a later one of the same session, for a runner that shares a session across cases. */
+export function subtractDesktopInputReceipts(after: DesktopInputReceipts, before: DesktopInputReceipts): DesktopInputReceipts {
+  const delta: Partial<Record<DesktopInputMechanism, number>> = {};
+  for (const mechanism of desktopInputMechanisms) {
+    const count = (after[mechanism] ?? 0) - (before[mechanism] ?? 0);
+    if (count > 0) delta[mechanism] = count;
+  }
+  return delta;
+}
+
+/**
+ * Compares the input a case delivered with its declaration. Receipts are the authority: a declaration only promises, so
+ * a mechanism nothing declared fails the case, while a declared transport the case did not use is only reported. Pass the
+ * session's click mode: under `auto` the host, not the case, chose how to click, so any click declaration accounts for
+ * either click transport.
+ */
+export function compareDesktopInputReceipts(
+  descriptor: Pick<DesktopCaseOptions, 'requires'> | undefined,
+  receipts: unknown,
+  clickMode?: 'accessibility' | 'auto' | 'physical',
+): DesktopInputComparison {
+  const delivered = validateDesktopInputReceipts(receipts);
+  const used = desktopInputMechanisms.filter((mechanism) => delivered[mechanism] !== undefined);
+  const declared = descriptor?.requires ?? [];
+  const hostClicks = clickMode === 'auto' && declared.some((requirement) => clickRequirements.has(requirement));
+  const accounts = (mechanism: DesktopInputMechanism): readonly DesktopRequirement[] =>
+    hostClicks && clickMechanisms.has(mechanism)
+      ? [...mechanismRequirements[mechanism], ...clickRequirements]
+      : mechanismRequirements[mechanism];
+  const undeclared = used.filter(
+    (mechanism) => accounts(mechanism).length > 0 && !accounts(mechanism).some((requirement) => declared.includes(requirement)),
+  );
+  const unused = declared.filter(
+    (requirement) => inputRequirements.has(requirement) && !used.some((mechanism) => accounts(mechanism).includes(requirement)),
+  );
+  return { undeclared, unused };
+}
+
+/** Names each undeclared mechanism with the requirements that would declare it, for the failure of a case that delivered it. */
+export function describeUndeclaredDesktopInput(undeclared: readonly DesktopInputMechanism[]): string {
+  const named = undeclared.map((mechanism) => `${mechanism} (declare ${mechanismRequirements[mechanism].join(' or ')})`);
+  return `The test delivered input it does not declare: ${named.join(', ')}.`;
+}
+
+/** Checks a receipt report read from a driver, so a malformed one is an error rather than an empty record. */
+export function validateDesktopInputReceipts(value: unknown, source = 'input receipts'): DesktopInputReceipts {
+  const receipts = object(value, source);
+  for (const [mechanism, count] of Object.entries(receipts)) {
+    if (!(desktopInputMechanisms as readonly string[]).includes(mechanism))
+      throw new TypeError(`${source} has unknown mechanism "${mechanism}".`);
+    if (!Number.isSafeInteger(count) || (count as number) < 1) throw new TypeError(`${source}.${mechanism} must be a positive integer.`);
+  }
+  return receipts as DesktopInputReceipts;
+}
+
+/** Checks a session's input report, so a driver that omits its policy is never mistaken for one that enforces it. */
+export function validateDesktopSessionInput(value: unknown, source = 'session input'): DesktopSessionInput {
+  const report = object(value, source);
+  exactKeys(report, ['mode', 'receipts'], source);
+  if (!(desktopInputModes as readonly unknown[]).includes(report.mode))
+    throw new TypeError(`${source}.mode must be one of: ${desktopInputModes.join(', ')}.`);
+  return { mode: report.mode as DesktopInputMode, receipts: validateDesktopInputReceipts(report.receipts, `${source}.receipts`) };
+}
+
 /**
  * The input an accessible lane keeps from reaching the application. A host that reports any of these as anything other
  * than `false` cannot back the lane, because a case could then deliver physical input without anyone noticing.
@@ -56,15 +193,26 @@ export type ResolvedDesktopCaseOptions = DesktopCaseOptions & {
 };
 
 const physicalRequirements = new Set<DesktopRequirement>(['physical-click', 'keyboard', 'wheel']);
-const accessibleRequirements = new Set<DesktopRequirement>(['accessibility-click']);
+const accessibleRequirements = new Set<DesktopRequirement>(['accessibility-click', 'perform-accessibility-action']);
+/** Requirements that promise input, so receipts can show one went unused. */
+const inputRequirements = new Set<DesktopRequirement>(['click', ...physicalRequirements, ...accessibleRequirements]);
+const clickRequirements = new Set<DesktopRequirement>(['accessibility-click', 'click', 'physical-click']);
+const clickMechanisms = new Set<DesktopInputMechanism>(['accessibility-click', 'physical-click']);
 const endpoints = ['macos', 'windows', 'win32'] as const;
 const requirementSet = new Set<string>(desktopRequirements);
 
+/**
+ * Derives a case's input lane from what it requires. A case that needs both transports runs only in the physical lane,
+ * whose sessions also deliver declared accessible input, and must say so with an explicit `input: 'physical'`.
+ */
 export function resolveDesktopInput(input?: DesktopInput, requires: readonly DesktopRequirement[] = []): DesktopInput {
   const physical = requires.some((requirement) => physicalRequirements.has(requirement));
   const accessible = requires.some((requirement) => accessibleRequirements.has(requirement));
   if (physical && accessible) {
-    throw new TypeError('A desktop test cannot require both physical and accessible input; split the case.');
+    if (input === 'physical') return input;
+    throw new TypeError(
+      'A desktop test that requires both physical and accessible input must declare input: "physical", whose sessions deliver both; otherwise split the case.',
+    );
   }
   const derived = physical ? 'physical' : accessible ? 'accessible' : 'both';
   if (input !== undefined && derived !== 'both' && input !== derived) {
diff --git a/packages/agentic/desktop-driver/src/authoring/selection.test.ts b/packages/agentic/desktop-driver/src/authoring/selection.test.ts
index 2a8505dafc..ecccdeabff 100644
--- a/packages/agentic/desktop-driver/src/authoring/selection.test.ts
+++ b/packages/agentic/desktop-driver/src/authoring/selection.test.ts
@@ -70,6 +70,8 @@ describe('click mode and requirement preflight', () => {
       'accessibility',
     );
     expect(resolveDesktopClickMode(validateDesktopCaseOptions({ input: 'accessible' }), 'physical', undefined)).toBe('accessibility');
+    const mixed = validateDesktopCaseOptions({ input: 'physical', requires: ['physical-click', 'accessibility-click'] });
+    expect(resolveDesktopClickMode(mixed, 'auto', undefined)).toBe('auto');
     // A physical case must not pin physical click, or a host that masks it fails the session instead of reporting unsupported.
     expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['physical-click'] }), 'auto', undefined)).toBe('auto');
     expect(resolveDesktopClickMode(validateDesktopCaseOptions({ requires: ['keyboard'] }), 'auto', undefined)).toBe('auto');
diff --git a/packages/agentic/desktop-driver/src/authoring/selection.ts b/packages/agentic/desktop-driver/src/authoring/selection.ts
index 383ce5896f..f91c005d33 100644
--- a/packages/agentic/desktop-driver/src/authoring/selection.ts
+++ b/packages/agentic/desktop-driver/src/authoring/selection.ts
@@ -43,7 +43,7 @@ export type DesktopCaseClickMode = 'auto' | 'physical' | 'accessibility';
 /**
  * The click mode a case runs under. A lane decides it outright, so a `click` requirement is an accessible click in the
  * accessible lane and a physical click in the physical lane. Without a lane only an accessible case pins its transport,
- * so it never moves the pointer. Any other case keeps the configured mode: a physical case on a host that masks physical
+ * so it never moves the pointer; a case that also requires physical input is a physical case. Any other case keeps the configured mode: a physical case on a host that masks physical
  * click is then reported unsupported by the requirement preflight, as the skip it replaces was, instead of failing to
  * create its session.
  */
@@ -54,7 +54,7 @@ export function resolveDesktopClickMode(
 ): DesktopCaseClickMode {
   if (lane === 'accessible') return 'accessibility';
   if (lane === 'physical') return 'physical';
-  if (descriptor?.input === 'accessible' || descriptor?.requires?.includes('accessibility-click')) return 'accessibility';
+  if (descriptor?.input === 'accessible') return 'accessibility';
   return configured;
 }
 
@@ -89,6 +89,7 @@ const requirementFeature: Record<Exclude<DesktopRequirement, 'click'>, string> =
   'element-screenshot': 'elementScreenshot',
   focus: 'focus',
   keyboard: 'keyboard',
+  'perform-accessibility-action': 'performAccessibilityAction',
   'physical-click': 'physicalClick',
   screenshot: 'screenshot',
   'set-window-rect': 'setWindowRect',
diff --git a/packages/agentic/desktop-driver/src/client/DesktopDriverClient.ts b/packages/agentic/desktop-driver/src/client/DesktopDriverClient.ts
index 17f8b1e67a..33b4ad8066 100644
--- a/packages/agentic/desktop-driver/src/client/DesktopDriverClient.ts
+++ b/packages/agentic/desktop-driver/src/client/DesktopDriverClient.ts
@@ -1,5 +1,7 @@
 import { randomUUID } from 'node:crypto';
 
+import { validateDesktopSessionInput } from '../authoring/input.js';
+import type { DesktopSessionInput } from '../authoring/input.js';
 import { WebDriverError } from '../protocol/errors.js';
 import { webElementIdentifier } from '../protocol/constants.js';
 import type { DesktopTreeNode, DesktopWindowEventLog } from '../host/types.js';
@@ -198,6 +200,11 @@ export class DesktopSessionClient {
     return this.command('GET', '/furn/window-events');
   }
 
+  /** The session's input policy, and how many times it has delivered input through each mechanism. */
+  async getInput(): Promise<DesktopSessionInput> {
+    return validateDesktopSessionInput(await this.command('GET', '/furn/input'));
+  }
+
   /** The agent operations this session offers, with the JSON Schema of each one's input and result. */
   operations(): Promise<OperationCatalog> {
     return this.command('GET', '/furn/ops');
@@ -338,6 +345,11 @@ export class DesktopElementClient {
     return this.command('POST', '/value', { text });
   }
 
+  /** Performs the one accessibility action the element publishes under this name, such as `increment`. */
+  performAccessibilityAction(name: string): Promise<null> {
+    return this.command('POST', '/furn/accessibility-action', { name });
+  }
+
   getText(): Promise<string> {
     return this.command('GET', '/text');
   }
diff --git a/packages/agentic/desktop-driver/src/host/types.ts b/packages/agentic/desktop-driver/src/host/types.ts
index d7a4eabb43..13b2541ed7 100644
--- a/packages/agentic/desktop-driver/src/host/types.ts
+++ b/packages/agentic/desktop-driver/src/host/types.ts
@@ -11,6 +11,9 @@ export type Rect = {
 
 export type SupportedValue<T> = { supported: true; value: T } | { supported: false; reason: string };
 
+/** How a host clears a value: by setting it through the accessibility tree, or by selecting and deleting with keys. */
+export type DesktopClearMechanism = 'keyboard' | 'semantic';
+
 export type DesktopHostFeatures = {
   /** The host lists an element's accessibility actions, including authored custom actions such as `Select` and `Toggle`. */
   accessibilityActions?: boolean;
@@ -28,6 +31,11 @@ export type DesktopHostFeatures = {
   physicalClick: boolean;
   screenshot: boolean;
   setWindowRect: boolean;
+  /**
+   * The host clears with the mechanism it is asked for: `semantic` only sets the value through the accessibility tree,
+   * `keyboard` only selects and deletes with synthesized keys, and either fails without falling back to the other.
+   */
+  strictClear?: boolean;
   wheel: boolean;
   /** The host records a native window-event timeline for diagnostics. */
   windowEvents?: boolean;
@@ -277,7 +285,12 @@ export interface DesktopHost {
   hitTest(windowId: string, x: number, y: number, signal?: AbortSignal): Promise<NativeElementSnapshot | null>;
 
   click(elementId: string, mode: DesktopClickMode, signal?: AbortSignal): Promise<void>;
-  clear(elementId: string, signal?: AbortSignal): Promise<void>;
+  /**
+   * Clears an element's value. Without a mechanism the host chooses, preferring a semantic clear; with one, a host that
+   * advertises `features.strictClear` uses only that mechanism. Resolves with the mechanism used, or nothing when the host
+   * cannot say, which counts as possible keyboard input.
+   */
+  clear(elementId: string, signal?: AbortSignal, mechanism?: DesktopClearMechanism): Promise<DesktopClearMechanism | void>;
   sendKeys(elementId: string, text: string, signal?: AbortSignal): Promise<void>;
   performActions(actions: readonly NativeActionSequence[], signal?: AbortSignal): Promise<void>;
   releaseActions(signal?: AbortSignal): Promise<void>;
diff --git a/packages/agentic/desktop-driver/src/hosts/fake/FakeDesktopHost.ts b/packages/agentic/desktop-driver/src/hosts/fake/FakeDesktopHost.ts
index eab73c3adf..4fe6fc55d8 100644
--- a/packages/agentic/desktop-driver/src/hosts/fake/FakeDesktopHost.ts
+++ b/packages/agentic/desktop-driver/src/hosts/fake/FakeDesktopHost.ts
@@ -2,6 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 
 import type {
   ApplicationLease,
+  DesktopClearMechanism,
   DesktopHost,
   DesktopHostEvent,
   DesktopHostFeatures,
@@ -120,6 +121,7 @@ const defaultFeatures: DesktopHostFeatures = {
   physicalClick: true,
   screenshot: true,
   setWindowRect: true,
+  strictClear: true,
   wheel: true,
 };
 
@@ -535,13 +537,23 @@ export class FakeDesktopHost implements DesktopHost {
     });
   }
 
-  async clear(elementId: string, signal?: AbortSignal): Promise<void> {
+  /** Clears semantically when the element has a value to set, and otherwise with the keyboard, unless told which. */
+  async clear(elementId: string, signal?: AbortSignal, mechanism?: DesktopClearMechanism): Promise<DesktopClearMechanism> {
     return this.mutate('clear', signal, (observed) => {
       throwIfAborted(observed);
       const element = this.requireElement(elementId);
+      const settable = element.value !== undefined;
+      const used = mechanism ?? (settable ? 'semantic' : 'keyboard');
+      if (used === 'semantic' && !settable) {
+        throw reportEffect(new HostWebDriverError('element not interactable', `Element "${elementId}" has no value to set.`), 'none');
+      }
+      if (used === 'keyboard' && !this.features.keyboard) {
+        throw reportEffect(new HostUnsupportedError('The fake target does not type.'), 'none');
+      }
       element.value = '';
       element.text = '';
-      this.actions.push({ type: 'clear', elementId });
+      this.actions.push({ type: 'clear', elementId, mechanism: used });
+      return used;
     });
   }
 
diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
new file mode 100644
index 0000000000..c765306f35
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
@@ -0,0 +1,125 @@
+import type { DesktopHostFeatures } from '../../host/types';
+import type { NativeDriverArtifact } from '../../native/types';
+import { readFailureEffect } from '../../protocol/settlement';
+import { scriptNativeHelper } from '../../testing/scriptedNativeHelper';
+import type { ScriptedNativeRequest } from '../../testing/scriptedNativeHelper';
+import { NativeDesktopHost } from './NativeDesktopHost';
+import type { NativeDisabledInputFeature } from './NativeDesktopHost';
+
+const mockSpawn = jest.fn();
+jest.mock('node:child_process', () => ({ spawn: (...args: unknown[]) => mockSpawn(...args) }));
+
+const artifact: NativeDriverArtifact = {
+  architecture: 'arm64',
+  artifactId: 'artifact',
+  artifactRoot: 'artifact-root',
+  buildFingerprint: 'build',
+  buildId: 'build',
+  compatibilityKey: 'compatibility',
+  configuration: 'release',
+  endpoints: ['macos'],
+  executablePath: 'driver',
+  features: [],
+  origin: 'cache',
+  provider: 'macos',
+  schemaVersion: 1,
+  signing: { mode: 'none' },
+  sourceDigest: 'source',
+  wireProtocol: { major: 1, minor: 0 },
+};
+
+const features: DesktopHostFeatures = {
+  accessibilityClick: true,
+  elementScreenshot: true,
+  focus: true,
+  keyboard: true,
+  physicalClick: true,
+  screenshot: true,
+  setWindowRect: true,
+  wheel: true,
+};
+
+/** A probed host whose helper clears with the mechanism it was asked for, or reports none when it predates strict clear. */
+async function probedHost(strictClear: boolean, disabledInputFeatures: readonly NativeDisabledInputFeature[] = []) {
+  const received = scriptNativeHelper(mockSpawn, (message: ScriptedNativeRequest, send) => {
+    const params = message.params as { mechanism?: string } | undefined;
+    const result =
+      message.command === 'probe'
+        ? {
+            endpoint: 'macos',
+            features: { ...features, ...(strictClear ? { strictClear } : {}) },
+            platformName: 'macos',
+            protocolVersion: 1,
+          }
+        : message.command === 'clear'
+          ? strictClear
+            ? { mechanism: params?.mechanism ?? 'semantic' }
+            : {}
+          : {};
+    send({ id: message.id, result, type: 'response' });
+  });
+  const host = new NativeDesktopHost({ application: { windowTitle: 'Test App' }, artifact, disabledInputFeatures, endpoint: 'macos' });
+  await host.probe();
+  return { host, received };
+}
+
+describe('NativeDesktopHost input delivery', () => {
+  beforeEach(() => {
+    mockSpawn.mockReset();
+  });
+
+  test('asks a strict helper for the mechanism, and returns the one it used', async () => {
+    const { host, received } = await probedHost(true);
+
+    await expect(host.clear('e1', undefined, 'keyboard')).resolves.toBe('keyboard');
+    await expect(host.clear('e1')).resolves.toBe('semantic');
+
+    expect(received.filter((message) => message.command === 'clear')).toMatchObject([
+      { params: { elementId: 'e1', mechanism: 'keyboard' } },
+      { params: { elementId: 'e1' } },
+    ]);
+    expect(received[2].params).not.toHaveProperty('mechanism');
+    await host.dispose();
+  });
+
+  test('clears semantically where the keyboard is masked, and only when the helper can promise to', async () => {
+    const strict = await probedHost(true, ['keyboard', 'physicalClick', 'wheel']);
+    await expect(strict.host.clear('e1')).resolves.toBe('semantic');
+    const keyboard = await strict.host.clear('e1', undefined, 'keyboard').catch((error: unknown) => error);
+    expect(keyboard).toMatchObject({ name: 'HostUnsupportedError' });
+    expect(readFailureEffect(keyboard)).toBe('none');
+    expect(strict.received.filter((message) => message.command === 'clear')).toMatchObject([
+      { params: { elementId: 'e1', mechanism: 'semantic' } },
+    ]);
+    await strict.host.dispose();
+
+    const legacy = await probedHost(false, ['keyboard', 'physicalClick', 'wheel']);
+    for (const attempt of [legacy.host.clear('e1'), legacy.host.clear('e1', undefined, 'semantic')]) {
+      const failure = await attempt.catch((error: unknown) => error);
+      expect(failure).toMatchObject({ name: 'HostUnsupportedError' });
+      expect(readFailureEffect(failure)).toBe('none');
+    }
+    expect(legacy.received.some((message) => message.command === 'clear')).toBe(false);
+    await legacy.host.dispose();
+  });
+
+  test('leaves a clear unattributed when the helper does not say how it cleared', async () => {
+    const { host } = await probedHost(false);
+
+    await expect(host.clear('e1')).resolves.toBeUndefined();
+    await host.dispose();
+  });
+
+  test('lets a masked target pause, because a pause delivers nothing', async () => {
+    const { host, received } = await probedHost(true, ['keyboard', 'physicalClick', 'wheel']);
+    const pause = [{ actions: [{ duration: 0, type: 'pause' as const }], id: 'keys', type: 'key' as const }];
+
+    await host.performActions(pause);
+    await expect(host.performActions([{ actions: [{ type: 'keyDown', value: 'a' }], id: 'keys', type: 'key' }])).rejects.toMatchObject({
+      name: 'HostUnsupportedError',
+    });
+
+    expect(received.filter((message) => message.command === 'performActions')).toMatchObject([{ params: { actions: pause } }]);
+    await host.dispose();
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.observation.test.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.observation.test.ts
index 525582e6c1..53d853fe73 100644
--- a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.observation.test.ts
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.observation.test.ts
@@ -1,9 +1,7 @@
-import { EventEmitter } from 'node:events';
-import { PassThrough } from 'node:stream';
-
 import type { NativeObserveRequest } from '../../host/types';
-import type { NativeDriverArtifact, NativeHostJsonMessage } from '../../native/types';
-import { encodeJsonFrame, NativeFrameDecoder } from './framing';
+import type { NativeDriverArtifact } from '../../native/types';
+import { scriptNativeHelper } from '../../testing/scriptedNativeHelper';
+import type { ScriptedNativeRequest, ScriptedNativeSend } from '../../testing/scriptedNativeHelper';
 import { NativeDesktopHost } from './NativeDesktopHost';
 
 const mockSpawn = jest.fn();
@@ -42,62 +40,9 @@ const sample = {
   unsupportedFacts: [],
 };
 
-class FakeChild extends EventEmitter {
-  readonly stdin = new PassThrough();
-  readonly stdout = new PassThrough();
-  readonly stderr = new PassThrough();
-  exitCode: number | null = null;
-  signalCode: NodeJS.Signals | null = null;
-
-  kill(): boolean {
-    this.finish();
-    return true;
-  }
-
-  finish(): void {
-    this.exitCode = 0;
-    setImmediate(() => {
-      this.emit('exit', 0, null);
-      this.emit('close', 0, null);
-    });
-  }
-}
-
-type Send = (message: NativeHostJsonMessage) => void;
-
 /** A host whose helper answers each request through `handler`; the helper acknowledges `dispose` and exits. */
-function createHost(handler: (message: Extract<NativeHostJsonMessage, { type: 'request' }>, send: Send) => void) {
-  const child = new FakeChild();
-  const decoder = new NativeFrameDecoder();
-  const received: Extract<NativeHostJsonMessage, { type: 'request' }>[] = [];
-  const send: Send = (message) => void child.stdout.write(encodeJsonFrame(message));
-  child.stdin.on('data', (chunk: Buffer) => decoder.write(chunk));
-  decoder.on('json', (message) => {
-    if (message.type !== 'request') {
-      return;
-    }
-    if (message.command === 'dispose') {
-      send({ id: message.id, result: {}, type: 'response' });
-      child.finish();
-      return;
-    }
-    received.push(message);
-    handler(message, send);
-  });
-  mockSpawn.mockImplementationOnce(() => {
-    setImmediate(() =>
-      send({
-        architecture: 'arm64',
-        buildId: 'build',
-        features: ['boundedObservation'],
-        protocol: { major: 1, minor: 0 },
-        provider: 'macos',
-        sourceDigest: 'source',
-        type: 'hello',
-      }),
-    );
-    return child;
-  });
+function createHost(handler: (message: ScriptedNativeRequest, send: ScriptedNativeSend) => void) {
+  const received = scriptNativeHelper(mockSpawn, handler, ['boundedObservation']);
   return { host: new NativeDesktopHost({ application: { windowTitle: 'Test App' }, artifact, endpoint: 'macos' }), received };
 }
 
diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
index 4c33f0aeb4..81410b560d 100644
--- a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.ts
@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 
 import type {
   ApplicationLease,
+  DesktopClearMechanism,
   DesktopHost,
   DesktopHostEvent,
   DesktopHostFeatures,
@@ -59,6 +60,8 @@ export class NativeDesktopHost implements DesktopHost {
   private potentialKeys = new Set<string>();
   private failure?: Error;
   private processPromise?: Promise<NativeHostProcess>;
+  /** What the helper last reported it supports. Every session is created after a probe. */
+  private probedFeatures?: DesktopHostFeatures;
 
   constructor({ application, artifact, disabledInputFeatures, endpoint, onStderr, onFailure }: NativeDesktopHostOptions) {
     if (!artifact.endpoints.includes(endpoint)) {
@@ -74,7 +77,9 @@ export class NativeDesktopHost implements DesktopHost {
 
   async probe(signal?: AbortSignal): Promise<DesktopHostInfo> {
     const hostInfo = await this.request<DesktopHostInfo>('probe', { endpoint: this.endpoint }, signal);
-    return applyDisabledInputFeaturePolicy(hostInfo, this.disabledInputFeatures);
+    const masked = applyDisabledInputFeaturePolicy(hostInfo, this.disabledInputFeatures);
+    this.probedFeatures = masked.features;
+    return masked;
   }
 
   async launch(target: DesktopTarget, signal?: AbortSignal): Promise<ApplicationLease> {
@@ -146,11 +151,27 @@ export class NativeDesktopHost implements DesktopHost {
     }
   }
 
-  async clear(elementId: string, signal?: AbortSignal): Promise<void> {
-    if (this.disabledInputFeatures.has('keyboard')) {
-      throw rejectedBeforeDispatch(new HostUnsupportedError('Physical keyboard fallback is disabled by the registered target policy.'));
+  /**
+   * A target that masks the keyboard may still clear semantically, so an unspecified clear is narrowed to the semantic
+   * mechanism there rather than refused, when the probed helper clears strictly. Without a mechanism a helper that
+   * predates strict clear reports none, and the clear stays unattributed.
+   */
+  async clear(elementId: string, signal?: AbortSignal, mechanism?: DesktopClearMechanism): Promise<DesktopClearMechanism | void> {
+    if (mechanism === 'keyboard' && this.disabledInputFeatures.has('keyboard')) {
+      throw rejectedBeforeDispatch(new HostUnsupportedError('Physical keyboard input is disabled by the registered target policy.'));
+    }
+    const requested = mechanism ?? (this.disabledInputFeatures.has('keyboard') ? 'semantic' : undefined);
+    if (requested && this.probedFeatures?.strictClear !== true) {
+      throw rejectedBeforeDispatch(
+        new HostUnsupportedError(
+          mechanism
+            ? `The native helper cannot clear with only the ${mechanism} mechanism.`
+            : 'Physical keyboard fallback is disabled by the registered target policy, and the native helper cannot clear only semantically.',
+        ),
+      );
     }
-    await this.request('clear', { elementId }, signal);
+    const result = await this.request<unknown>('clear', { elementId, ...(requested ? { mechanism: requested } : {}) }, signal);
+    return parseClearMechanism(result);
   }
 
   async sendKeys(elementId: string, text: string, signal?: AbortSignal): Promise<void> {
@@ -167,6 +188,8 @@ export class NativeDesktopHost implements DesktopHost {
 
   async performActions(actions: readonly NativeActionSequence[], signal?: AbortSignal): Promise<void> {
     for (const sequence of actions) {
+      // A source that only pauses delivers nothing, so a masked target may still wait with one.
+      if (sequence.actions.every((action) => action.type === 'pause')) continue;
       if (
         (sequence.type === 'key' && this.disabledInputFeatures.has('keyboard')) ||
         (sequence.type === 'pointer' && this.disabledInputFeatures.has('physicalClick')) ||
@@ -547,6 +570,12 @@ const nativeWebDriverErrorCodes: Readonly<Record<string, WebDriverErrorCode>> =
 };
 
 /** Marks a failure raised before any command reached the provider, so no effect can have been dispatched. */
+/** The mechanism a helper reports it cleared with. A helper that predates strict clear reports none. */
+function parseClearMechanism(result: unknown): DesktopClearMechanism | undefined {
+  const mechanism = typeof result === 'object' && result !== null ? (result as { mechanism?: unknown }).mechanism : undefined;
+  return mechanism === 'keyboard' || mechanism === 'semantic' ? mechanism : undefined;
+}
+
 function rejectedBeforeDispatch<T>(error: T): T {
   return error instanceof Error ? attachFailureEffect(error, 'none') : error;
 }
diff --git a/packages/agentic/desktop-driver/src/index.ts b/packages/agentic/desktop-driver/src/index.ts
index 0479787d78..7dc58ae333 100644
--- a/packages/agentic/desktop-driver/src/index.ts
+++ b/packages/agentic/desktop-driver/src/index.ts
@@ -34,27 +34,40 @@ export {
 } from './authoring/storyTests.js';
 export {
   accessibleLaneMaskedFeatures,
+  compareDesktopInputReceipts,
+  desktopInputMechanisms,
+  desktopInputModeAllows,
+  desktopInputModes,
   desktopInputLanes,
   desktopRequirements,
+  describeUndeclaredDesktopInput,
   matchesDesktopPlatforms,
   matchesDesktopScope,
   mergeDesktopCaseOptions,
   resolveDesktopInput,
   resolveDesktopScopeDomains,
   resolveDesktopScopeValues,
+  subtractDesktopInputReceipts,
   unmaskedAccessibleFeatures,
   validateDesktopCaseOptions,
   validateDesktopGroupOptions,
+  validateDesktopInputReceipts,
+  validateDesktopSessionInput,
 } from './authoring/input.js';
 export type {
   AccessibleLaneMaskedFeature,
   DesktopCaseOptions,
   DesktopInput,
+  DesktopInputComparison,
   DesktopInputLane,
+  DesktopInputMechanism,
+  DesktopInputMode,
+  DesktopInputReceipts,
   DesktopPlatforms,
   DesktopRequirement,
   DesktopScopeDomains,
   DesktopScopeValues,
+  DesktopSessionInput,
   ResolvedDesktopCaseOptions,
 } from './authoring/input.js';
 export { decideDesktopCase, missingDesktopRequirements, resolveDesktopClickMode } from './authoring/selection.js';
diff --git a/packages/agentic/desktop-driver/src/operations/act.ts b/packages/agentic/desktop-driver/src/operations/act.ts
index 0214525a58..a5eccc8a57 100644
--- a/packages/agentic/desktop-driver/src/operations/act.ts
+++ b/packages/agentic/desktop-driver/src/operations/act.ts
@@ -27,8 +27,8 @@ export type ActionName = (typeof actionNames)[number];
 /**
  * How the provider carried the action out. `physical-pointer` is a synthesized click at a hit-tested point,
  * `accessibility` is an accessibility action (the element's default one for `activate`, the named one for `perform`),
- * `keyboard` is synthesized key input to the focused element, and `provider` means the provider chose and did not say,
- * as `clear` does when it can set a value directly.
+ * `keyboard` is synthesized key input to the focused element, and `provider` means the provider chose and did not say.
+ * A `clear` reports `accessibility` when it set the value directly and `keyboard` when it typed, when the provider says.
  */
 export const actionMechanisms = ['physical-pointer', 'accessibility', 'keyboard', 'provider'] as const;
 export type ActionMechanism = (typeof actionMechanisms)[number];
@@ -333,25 +333,34 @@ async function performNamedAction(runtime: OperationRuntime, entry: ReferenceEnt
   );
 }
 
-/** Dispatches one action on a revalidated element. Runs inside the physical input turn. */
+/**
+ * Dispatches one action on a revalidated element. Runs inside the physical input turn. Resolves with the mechanism when
+ * the provider decided it, as it does for `clear`.
+ */
 export async function dispatchAction(
   runtime: OperationRuntime,
   options: { action: ActionName; name?: string; text?: string },
   entry: ReferenceEntry,
   snapshot: NativeElementSnapshot,
-): Promise<void> {
+): Promise<ActionMechanism | undefined> {
   const { host } = runtime;
   switch (options.action) {
     case 'click':
-      return physicalClick(runtime, entry, snapshot);
+      await physicalClick(runtime, entry, snapshot);
+      return undefined;
     case 'activate':
-      return runtime.mutate(`Activating reference ${entry.reference}`, (signal) => host.click(entry.nativeId, 'accessibility', signal));
+      await runtime.mutate(`Activating reference ${entry.reference}`, (signal) => host.click(entry.nativeId, 'accessibility', signal));
+      return undefined;
     case 'perform':
-      return performNamedAction(runtime, entry, options.name!);
+      await performNamedAction(runtime, entry, options.name!);
+      return undefined;
     case 'type':
-      return runtime.mutate(`Typing into reference ${entry.reference}`, (signal) => host.sendKeys(entry.nativeId, options.text!, signal));
-    case 'clear':
-      return runtime.mutate(`Clearing reference ${entry.reference}`, (signal) => host.clear(entry.nativeId, signal));
+      await runtime.mutate(`Typing into reference ${entry.reference}`, (signal) => host.sendKeys(entry.nativeId, options.text!, signal));
+      return undefined;
+    case 'clear': {
+      const used = await runtime.mutate(`Clearing reference ${entry.reference}`, (signal) => host.clear(entry.nativeId, signal));
+      return used === 'semantic' ? 'accessibility' : used;
+    }
   }
 }
 
@@ -363,6 +372,7 @@ export async function performAction(runtime: OperationRuntime, input: ActOptions
   assertNotQuarantined(runtime);
   assertActionSupported(runtime, input.action);
   const { entry, proof } = input.find ? await proveSelector(runtime, input.find) : resolveProven(runtime, input.ref!, input.sample!);
+  let delivered: ActionMechanism | undefined;
   try {
     await runtime.input(async () => {
       if (runtime.signal.aborted) {
@@ -373,7 +383,7 @@ export async function performAction(runtime: OperationRuntime, input: ActOptions
       }
       const snapshot = await revalidate(runtime, entry, proof);
       requireInteractable(runtime, input.action, input.ref, snapshot);
-      await dispatchAction(runtime, input, entry, snapshot);
+      delivered = await dispatchAction(runtime, input, entry, snapshot);
     });
   } catch (error) {
     // Every primary mutation settles through `runtime.mutate`, which reports what it did; a failure without a report
@@ -384,7 +394,7 @@ export async function performAction(runtime: OperationRuntime, input: ActOptions
   return {
     action: input.action,
     disposition: 'applied',
-    mechanism: mechanismOf[input.action],
+    mechanism: delivered ?? mechanismOf[input.action],
     ref: entry.reference,
     sample: proof.sample,
     ...(warnings.length > 0 ? { warnings } : {}),
diff --git a/packages/agentic/desktop-driver/src/operations/runtime.ts b/packages/agentic/desktop-driver/src/operations/runtime.ts
index d8e0baa0db..ce90ac0bbf 100644
--- a/packages/agentic/desktop-driver/src/operations/runtime.ts
+++ b/packages/agentic/desktop-driver/src/operations/runtime.ts
@@ -16,7 +16,8 @@ export type OperationHost = {
   activate(windowId: string, signal: AbortSignal): Promise<void>;
   captureElement(nativeId: string, signal: AbortSignal): Promise<NativeImage>;
   captureWindow(windowId: string, signal: AbortSignal): Promise<NativeImage>;
-  clear(nativeId: string, signal: AbortSignal): Promise<void>;
+  /** Resolves with how the value was cleared, or nothing when the provider did not say. */
+  clear(nativeId: string, signal: AbortSignal): Promise<'keyboard' | 'semantic' | undefined>;
   click(nativeId: string, mode: 'accessibility' | 'physical', signal: AbortSignal): Promise<void>;
   hitTest(windowId: string, x: number, y: number, signal: AbortSignal): Promise<NativeElementSnapshot | null>;
   /** The element's published actions with their keys. Called only when `capabilities.accessibilityActions` is true. */
diff --git a/packages/agentic/desktop-driver/src/protocol/capabilities.ts b/packages/agentic/desktop-driver/src/protocol/capabilities.ts
index 5e8eee1716..12c2ac4141 100644
--- a/packages/agentic/desktop-driver/src/protocol/capabilities.ts
+++ b/packages/agentic/desktop-driver/src/protocol/capabilities.ts
@@ -1,3 +1,5 @@
+import { desktopInputModes } from '../authoring/input.js';
+import type { DesktopInputMode } from '../authoring/input.js';
 import type { DesktopHostInfo, DesktopTarget } from '../host/types.js';
 import { invalidArgument, toWebDriverError, WebDriverError } from './errors.js';
 import { withCommandTimeout } from './timeouts.js';
@@ -20,6 +22,7 @@ const standardCapabilities = new Set([
 export type MatchedCapabilities = {
   clickMode: DesktopClickMode;
   hostInfo: DesktopHostInfo;
+  inputMode: DesktopInputMode;
   launchMode: 'attach' | 'launch';
   requested: Record<string, unknown>;
   target: DesktopTarget;
@@ -54,6 +57,7 @@ export async function matchCapabilities(
   for (const requested of candidates) {
     validateCapabilityNames(requested);
     const requestedClickMode = validateClickMode(requested['furn:clickMode']);
+    const inputMode = validateInputMode(requested['furn:inputMode']);
     const launchMode = validateLaunchMode(requested['furn:launchMode']);
     const targetId = requested['furn:target'];
     const candidatesForTarget =
@@ -80,8 +84,8 @@ export async function matchCapabilities(
         const webdriverError = toWebDriverError(error);
         throw new WebDriverError('session not created', webdriverError.message, webdriverError.data);
       }
-      const clickMode = resolveClickMode(requestedClickMode, host);
-      return { clickMode, hostInfo: host, launchMode, requested, target };
+      const clickMode = resolveClickMode(requestedClickMode, host, inputMode);
+      return { clickMode, hostInfo: host, inputMode, launchMode, requested, target };
     }
   }
 
@@ -101,6 +105,7 @@ export function createReturnedCapabilities(
     'furn:clickMode': matched.clickMode,
     'furn:endpoint': matched.target.endpoint,
     'furn:features': host.features,
+    'furn:inputMode': matched.inputMode,
     ...(matched.target.renderer ? { 'furn:renderer': matched.target.renderer } : {}),
     'furn:storybook': Boolean(matched.target.storyOrchestrator),
     'furn:target': matched.target.id,
@@ -130,6 +135,14 @@ function validateClickMode(requested: unknown): DesktopClickMode | 'auto' {
   return clickMode;
 }
 
+function validateInputMode(requested: unknown): DesktopInputMode {
+  const inputMode = requested ?? 'compatibility';
+  if (!(desktopInputModes as readonly unknown[]).includes(inputMode)) {
+    throw invalidArgument(`"furn:inputMode" must be one of: ${desktopInputModes.join(', ')}.`);
+  }
+  return inputMode as DesktopInputMode;
+}
+
 function validateLaunchMode(requested: unknown): 'attach' | 'launch' {
   const launchMode = requested ?? 'launch';
   if (launchMode !== 'attach' && launchMode !== 'launch') {
@@ -138,7 +151,18 @@ function validateLaunchMode(requested: unknown): 'attach' | 'launch' {
   return launchMode;
 }
 
-function resolveClickMode(clickMode: DesktopClickMode | 'auto', host: DesktopHostInfo): DesktopClickMode {
+/**
+ * A strict input mode decides the click transport, so a conflicting request fails. It does not require the host to
+ * click at all, because a session may only type or clear; a click the host cannot deliver is refused when it is sent.
+ */
+function resolveClickMode(clickMode: DesktopClickMode | 'auto', host: DesktopHostInfo, inputMode: DesktopInputMode): DesktopClickMode {
+  if (inputMode !== 'compatibility') {
+    const pinned: DesktopClickMode = inputMode === 'accessible' ? 'accessibility' : 'physical';
+    if (clickMode !== 'auto' && clickMode !== pinned) {
+      throw new WebDriverError('session not created', `"furn:clickMode" "${clickMode}" conflicts with "furn:inputMode" "${inputMode}".`);
+    }
+    return pinned;
+  }
   if (clickMode === 'physical' && !host.features.physicalClick) {
     throw new WebDriverError('session not created', 'The target does not support physical click input.');
   }
diff --git a/packages/agentic/desktop-driver/src/server/SessionManager.ts b/packages/agentic/desktop-driver/src/server/SessionManager.ts
index 8b430c3741..5df7b5ba60 100644
--- a/packages/agentic/desktop-driver/src/server/SessionManager.ts
+++ b/packages/agentic/desktop-driver/src/server/SessionManager.ts
@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 
+import type { DesktopInputMechanism, DesktopInputMode } from '../authoring/input.js';
 import type {
   ApplicationLease,
   DesktopHostInfo,
@@ -97,6 +98,10 @@ export type DesktopSession = {
   elementIdsByNativeId: Map<string, string>;
   hostInfo: DesktopHostInfo;
   id: string;
+  /** The input policy fixed at creation (`furn:inputMode`). It never changes for the life of the session. */
+  readonly inputMode: DesktopInputMode;
+  /** How many times the session delivered input by each mechanism, including deliveries whose outcome was not observed. */
+  inputReceipts: Map<DesktopInputMechanism, number>;
   inputState: WebDriverInputState;
   issuedElementIds: Set<string>;
   lease: ApplicationLease;
@@ -249,6 +254,7 @@ export class SessionManager {
     clickMode: DesktopClickMode,
     launchMode: 'attach' | 'launch',
     owner?: SessionOwner,
+    inputMode: DesktopInputMode = 'compatibility',
   ): Promise<DesktopSession> {
     if (this.closing) {
       return Promise.reject(new WebDriverError('session not created', 'Desktop Driver is shutting down.'));
@@ -259,7 +265,7 @@ export class SessionManager {
       return Promise.reject(new WebDriverError('session not created', 'The grant for this request was revoked.'));
     }
     const controller = new AbortController();
-    const result = this.createSession(target, hostInfo, clickMode, launchMode, owner, controller.signal);
+    const result = this.createSession(target, hostInfo, clickMode, launchMode, inputMode, owner, controller.signal);
     const settled = result.then(
       () => undefined,
       () => undefined,
@@ -300,6 +306,7 @@ export class SessionManager {
     hostInfo: DesktopHostInfo,
     clickMode: DesktopClickMode,
     launchMode: 'attach' | 'launch',
+    inputMode: DesktopInputMode,
     owner?: SessionOwner,
     signal?: AbortSignal,
   ): Promise<DesktopSession> {
@@ -375,6 +382,8 @@ export class SessionManager {
         elementIdsByNativeId: new Map(),
         hostInfo,
         id: randomUUID(),
+        inputMode,
+        inputReceipts: new Map(),
         inputState: createInputState(),
         issuedElementIds: new Set(),
         lease,
diff --git a/packages/agentic/desktop-driver/src/server/createDesktopDriverServer.ts b/packages/agentic/desktop-driver/src/server/createDesktopDriverServer.ts
index b2dac9e849..f3b7c20f48 100644
--- a/packages/agentic/desktop-driver/src/server/createDesktopDriverServer.ts
+++ b/packages/agentic/desktop-driver/src/server/createDesktopDriverServer.ts
@@ -2,7 +2,15 @@ import { Buffer } from 'node:buffer';
 import { createServer } from 'node:http';
 import type { IncomingMessage, Server, ServerResponse } from 'node:http';
 
-import type { DesktopTarget, DesktopTreeNode, NativeActionSequence, NativeElementSnapshot, NativeSelector, Rect } from '../host/types.js';
+import type {
+  DesktopTarget,
+  DesktopTreeNode,
+  NativeAccessibilityAction,
+  NativeActionSequence,
+  NativeElementSnapshot,
+  NativeSelector,
+  Rect,
+} from '../host/types.js';
 import { DesktopAuthority, grantAllowsTarget } from '../authority/grants.js';
 import type { DesktopGrant } from '../authority/grants.js';
 import type { PrivateStorage } from '../authority/privateStorage.js';
@@ -15,6 +23,15 @@ import { withCommandTimeout } from '../protocol/timeouts.js';
 import type { NewSessionRequest, WebDriverActionSequence, WebDriverElement, WebDriverResponse } from '../protocol/types.js';
 import { SessionManager } from './SessionManager.js';
 import type { DesktopSession, ElementRecord, MutationOptions, RecoverTargetRequest, RecoverTargetResult } from './SessionManager.js';
+import {
+  actionMechanisms,
+  assertInputAllowed,
+  clickMechanism,
+  deliverClear,
+  deliverInput,
+  describeSessionInput,
+  strictClearMechanism,
+} from './sessionInput.js';
 import { SettlementJournal } from './settlementJournal.js';
 import type { ProbeApplication } from './settlementJournal.js';
 import { createOperationRuntime, handleOperationRoute, requestBodyLimit } from './sessionOperations.js';
@@ -342,7 +359,14 @@ async function route(context: RouteContext, sessions: SessionManager, targets: T
     const matched = await matchCapabilities(request.capabilities, visibleTargets(context, targets));
     try {
       const owner = context.grant ? { grantId: context.grant.id, label: context.grant.label } : undefined;
-      const session = await sessions.create(matched.target, matched.hostInfo, matched.clickMode, matched.launchMode, owner);
+      const session = await sessions.create(
+        matched.target,
+        matched.hostInfo,
+        matched.clickMode,
+        matched.launchMode,
+        owner,
+        matched.inputMode,
+      );
       return {
         sessionId: session.id,
         capabilities: createReturnedCapabilities(matched, matched.hostInfo, session.timeouts),
@@ -390,12 +414,16 @@ async function route(context: RouteContext, sessions: SessionManager, targets: T
     if (method === 'POST') {
       const { actions, nextState } = parseActionSequences(requireObject(body, 'actions request').actions, session.inputState);
       const resolvedActions = await resolveActionOrigins(actions, session, sessions);
+      const mechanisms = actionMechanisms(resolvedActions);
+      for (const mechanism of mechanisms) {
+        assertInputAllowed(session, mechanism, 'Performing input actions');
+      }
       await sessions.runInputCommand(async () => {
         sessions.assertMutable(session);
         session.inputState = nextState;
         try {
           await mutationCommand(sessions, session, 'Performing input actions', (signal) =>
-            session.target.host.performActions(resolvedActions, signal),
+            deliverInput(session, mechanisms, () => session.target.host.performActions(resolvedActions, signal)),
           );
         } catch (error) {
           await mutationCommand(
@@ -433,6 +461,9 @@ async function route(context: RouteContext, sessions: SessionManager, targets: T
     );
   }
   if (command[0] === 'furn') {
+    if (method === 'GET' && command[1] === 'input' && command.length === 2) {
+      return describeSessionInput(session);
+    }
     if (method === 'GET' && command[1] === 'tree' && command.length === 2) {
       const snapshots = await hostCommand(session, 'Reading the compact accessibility tree', (signal) =>
         session.target.host.tree(session.currentWindowId, signal),
@@ -729,6 +760,9 @@ async function handleElementCommand(
     if (!requireSupported(snapshot.enabled, 'enabled') || !requireSupported(snapshot.visible, 'visible')) {
       throw new WebDriverError('element not interactable', `Element "${record.id}" cannot be clicked.`);
     }
+    const mechanism = clickMechanism(session.clickMode);
+    // Checked before the window is activated, so a refused click changes nothing.
+    assertInputAllowed(session, mechanism, `Clicking element "${record.id}"`);
     await sessions.runInputCommand(async () => {
       if (session.clickMode !== 'accessibility') {
         await mutationCommand(sessions, session, `Activating window "${snapshot.windowId}"`, (signal) =>
@@ -749,14 +783,18 @@ async function handleElementCommand(
         }
       }
       await mutationCommand(sessions, session, `Clicking element "${record.id}"`, (signal) =>
-        session.target.host.click(record.nativeId, session.clickMode, signal),
+        deliverInput(session, [mechanism], () => session.target.host.click(record.nativeId, session.clickMode, signal)),
       );
     });
     return null;
   }
   if (method === 'POST' && operation[0] === 'clear') {
+    const description = `Clearing element "${record.id}"`;
+    const requested = strictClearMechanism(session, description);
     await sessions.runInputCommand(() =>
-      mutationCommand(sessions, session, `Clearing element "${record.id}"`, (signal) => session.target.host.clear(record.nativeId, signal)),
+      mutationCommand(sessions, session, description, (signal) =>
+        deliverClear(session, requested, description, (mechanism) => session.target.host.clear(record.nativeId, signal, mechanism)),
+      ),
     );
     return null;
   }
@@ -771,13 +809,17 @@ async function handleElementCommand(
     if (text === undefined) {
       throw invalidArgument('Send Keys requires a string "text" or string-array "value".');
     }
+    assertInputAllowed(session, 'keyboard', `Sending keys to element "${record.id}"`);
     await sessions.runInputCommand(() =>
       mutationCommand(sessions, session, `Sending keys to element "${record.id}"`, (signal) =>
-        session.target.host.sendKeys(record.nativeId, text, signal),
+        deliverInput(session, ['keyboard'], () => session.target.host.sendKeys(record.nativeId, text, signal)),
       ),
     );
     return null;
   }
+  if (method === 'POST' && operation[0] === 'furn' && operation[1] === 'accessibility-action' && operation.length === 2) {
+    return performNamedAccessibilityAction(body, record, session, sessions);
+  }
   if (method === 'GET' && operation[0] === 'screenshot') {
     const image = await hostCommand(session, `Capturing element "${record.id}"`, (signal) =>
       session.target.host.captureElement(record.nativeId, signal),
@@ -788,6 +830,53 @@ async function handleElementCommand(
   throw new WebDriverError('unknown command', `Unknown element command "${operation.join('/')}".`);
 }
 
+/**
+ * Performs the one accessibility action an element publishes under a name, such as a custom `Toggle`. The action is
+ * listed and performed in the same input turn, and a name the element publishes twice names neither action.
+ */
+async function performNamedAccessibilityAction(
+  body: unknown,
+  record: ElementRecord,
+  session: DesktopSession,
+  sessions: SessionManager,
+): Promise<null> {
+  const request = requireObject(body, 'accessibility action request');
+  if (typeof request.name !== 'string' || request.name.length === 0) {
+    throw invalidArgument('An accessibility action request requires a non-empty string "name".');
+  }
+  const name = request.name;
+  const host = session.target.host;
+  const list = host.listAccessibilityActions?.bind(host);
+  const perform = host.performAccessibilityAction?.bind(host);
+  if (!list || !perform || session.hostInfo.features.performAccessibilityAction !== true) {
+    throw new WebDriverError('unsupported operation', `Target "${session.target.id}" does not perform accessibility actions.`);
+  }
+  const description = `Performing an accessibility action on element "${record.id}"`;
+  assertInputAllowed(session, 'accessibility-action', description);
+  await sessions.runInputCommand(async () => {
+    const actions: NativeAccessibilityAction[] = await hostCommand(
+      session,
+      `Listing the accessibility actions of element "${record.id}"`,
+      (signal) => list(record.nativeId, signal),
+    );
+    const matches = actions.filter((action) => action.name === name);
+    if (matches.length !== 1) {
+      throw new WebDriverError(
+        'element not interactable',
+        matches.length === 0
+          ? `Element "${record.id}" publishes no accessibility action by that name.`
+          : `Element "${record.id}" publishes ${matches.length} accessibility actions by that name, so the name names none of them.`,
+        { reason: matches.length === 0 ? 'action-not-published' : 'action-not-unique' },
+      );
+    }
+    const [{ key }] = matches;
+    await mutationCommand(sessions, session, description, (signal) =>
+      deliverInput(session, ['accessibility-action'], () => perform(record.nativeId, key, signal)),
+    );
+  });
+  return null;
+}
+
 async function isElementOrDescendant(session: DesktopSession, targetNativeId: string, hit: NativeElementSnapshot): Promise<boolean> {
   let current: NativeElementSnapshot | undefined = hit;
   for (let depth = 0; current && depth < 100; depth += 1) {
diff --git a/packages/agentic/desktop-driver/src/server/desktopDriver.test.ts b/packages/agentic/desktop-driver/src/server/desktopDriver.test.ts
index 66e56de0f4..24d7c35068 100644
--- a/packages/agentic/desktop-driver/src/server/desktopDriver.test.ts
+++ b/packages/agentic/desktop-driver/src/server/desktopDriver.test.ts
@@ -245,6 +245,7 @@ describe('Desktop Driver W3C remote end', () => {
 
   test.each([
     ['furn:clickMode', 'not-a-click-mode'],
+    ['furn:inputMode', 'strict'],
     ['furn:launchMode', 'not-a-launch-mode'],
   ])('rejects invalid %s before probing the target', async (capability, value) => {
     const harness = await createDesktopDriverTestHarness();
diff --git a/packages/agentic/desktop-driver/src/server/operations.test.ts b/packages/agentic/desktop-driver/src/server/operations.test.ts
index 5a514e5381..e308562b87 100644
--- a/packages/agentic/desktop-driver/src/server/operations.test.ts
+++ b/packages/agentic/desktop-driver/src/server/operations.test.ts
@@ -505,7 +505,7 @@ describe('Desktop Driver agent operations', () => {
         await expect(session.act({ action: 'type', text: 'secret words', ...field })).resolves.toMatchObject({
           result: { mechanism: 'keyboard' },
         });
-        await expect(session.act({ action: 'clear', ...field })).resolves.toMatchObject({ result: { mechanism: 'provider' } });
+        await expect(session.act({ action: 'clear', ...field })).resolves.toMatchObject({ result: { mechanism: 'accessibility' } });
 
         const dispatched = harness.host.actions.map(({ elementId, ...action }) =>
           // The fake issues a fresh record id, such as `save~2`, each time an element is observed again.
@@ -517,7 +517,7 @@ describe('Desktop Driver agent operations', () => {
             { elementId: 'agree', mode: 'physical', type: 'click' },
             { elementId: 'save', mode: 'accessibility', type: 'click' },
             { elementId: 'field', text: 'secret words', type: 'send-keys' },
-            { elementId: 'field', type: 'clear' },
+            { elementId: 'field', mechanism: 'semantic', type: 'clear' },
           ]),
         );
         const journal = await session.journal();
@@ -525,7 +525,7 @@ describe('Desktop Driver agent operations', () => {
           { effect: 'mutate', outcome: 'ok', summary: { action: 'click', mechanism: 'physical-pointer' } },
           { summary: { action: 'activate', mechanism: 'accessibility' } },
           { summary: { action: 'type', mechanism: 'keyboard' } },
-          { summary: { action: 'clear', mechanism: 'provider' } },
+          { summary: { action: 'clear', mechanism: 'accessibility' } },
         ]);
         expect(JSON.stringify(journal.result)).not.toContain('secret words');
       });
diff --git a/packages/agentic/desktop-driver/src/server/sessionInput.test.ts b/packages/agentic/desktop-driver/src/server/sessionInput.test.ts
new file mode 100644
index 0000000000..e61a024cb8
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/server/sessionInput.test.ts
@@ -0,0 +1,272 @@
+import { createDesktopDriverClient } from '../client/DesktopDriverClient.js';
+import type { DesktopSessionClient } from '../client/DesktopDriverClient.js';
+import { compareDesktopInputReceipts, validateDesktopCaseOptions } from '../authoring/input.js';
+import type { DesktopInputMode } from '../authoring/input.js';
+import type { FakeDesktopHostOptions } from '../hosts/fake/FakeDesktopHost.js';
+import type { WebDriverActionSequence } from '../protocol/types.js';
+import { createDesktopDriverTestHarness } from '../testing/protocolHarness.js';
+import type { DesktopDriverTestHarness } from '../testing/protocolHarness.js';
+
+type Fixture = { harness: DesktopDriverTestHarness; session: DesktopSessionClient };
+
+const element = (id: string, y: number, extra: Record<string, unknown> = {}) => ({
+  automationId: id,
+  id,
+  name: id,
+  parentId: 'root',
+  rect: { height: 30, width: 100, x: 10, y },
+  role: 'button',
+  scope: 'application' as const,
+  windowId: 'main',
+  ...extra,
+});
+
+const windows: FakeDesktopHostOptions['windows'] = [
+  {
+    elements: [
+      { id: 'root', name: 'Form', rect: { height: 600, width: 800, x: 0, y: 0 }, role: 'window', scope: 'application', windowId: 'main' },
+      element('save', 10),
+      element('field', 50, { role: 'textbox', value: 'draft' }),
+      element('label', 90, { role: 'text' }),
+      element('stepper', 130, { accessibilityActions: ['Increment', 'Decrement', 'Reset', 'Reset'] }),
+    ],
+    id: 'main',
+    title: 'Input fixture',
+  },
+];
+
+const allFeatures = { accessibilityActions: true, boundedObservation: true, performAccessibilityAction: true };
+
+async function withSession(
+  inputMode: DesktopInputMode | undefined,
+  body: (fixture: Fixture) => Promise<void>,
+  options: FakeDesktopHostOptions = {},
+): Promise<void> {
+  const harness = await createDesktopDriverTestHarness({ windows, ...options, features: { ...allFeatures, ...options.features } });
+  try {
+    const session = await createDesktopDriverClient({ url: harness.server.url }).newSession({
+      alwaysMatch: { platformName: 'windows', 'furn:target': harness.target.id, ...(inputMode ? { 'furn:inputMode': inputMode } : {}) },
+    });
+    await body({ harness, session });
+    await session.delete();
+  } finally {
+    await harness.close();
+  }
+}
+
+const refused = (reason: 'input-policy' | 'input-unsupported', mechanism: string) => ({
+  code: 'unsupported operation',
+  data: expect.objectContaining({ mechanism, reason }),
+});
+
+const pointerDown: WebDriverActionSequence[] = [{ actions: [{ button: 0, type: 'pointerDown' }], id: 'mouse', type: 'pointer' }];
+const keyDown: WebDriverActionSequence[] = [{ actions: [{ type: 'keyDown', value: 'a' }], id: 'keys', type: 'key' }];
+const scroll: WebDriverActionSequence[] = [
+  { actions: [{ deltaX: 0, deltaY: 10, type: 'scroll', x: 0, y: 0 }], id: 'wheel', type: 'wheel' },
+];
+
+describe('Desktop Driver session input policy', () => {
+  test('defaults to compatibility, and reports the mode it enforces', async () => {
+    await withSession(undefined, async ({ session }) => {
+      expect(session.capabilities['furn:inputMode']).toBe('compatibility');
+      await expect(session.getInput()).resolves.toEqual({ mode: 'compatibility', receipts: {} });
+    });
+    await withSession('accessible', async ({ session }) => {
+      expect(session.capabilities).toMatchObject({ 'furn:clickMode': 'accessibility', 'furn:inputMode': 'accessible' });
+    });
+    await withSession('physical', async ({ session }) => {
+      expect(session.capabilities).toMatchObject({ 'furn:clickMode': 'physical', 'furn:inputMode': 'physical' });
+    });
+  });
+
+  test('refuses a click mode that conflicts with a strict input mode', async () => {
+    const harness = await createDesktopDriverTestHarness();
+    try {
+      const client = createDesktopDriverClient({ url: harness.server.url });
+      for (const [inputMode, clickMode] of [
+        ['accessible', 'physical'],
+        ['physical', 'accessibility'],
+      ]) {
+        await expect(
+          client.newSession({
+            alwaysMatch: {
+              platformName: 'windows',
+              'furn:clickMode': clickMode,
+              'furn:inputMode': inputMode,
+              'furn:target': harness.target.id,
+            },
+          }),
+        ).rejects.toMatchObject({ code: 'session not created' });
+      }
+    } finally {
+      await harness.close();
+    }
+  });
+
+  test('an accessible session delivers only semantic input, and dispatches nothing it refuses', async () => {
+    await withSession('accessible', async ({ harness, session }) => {
+      const save = await session.findElement('accessibility id', 'save');
+      const field = await session.findElement('accessibility id', 'field');
+      await save.click();
+      await field.clear();
+      await expect(field.sendKeys('secret')).rejects.toMatchObject(refused('input-policy', 'keyboard'));
+      await expect(session.performActions(pointerDown)).rejects.toMatchObject(refused('input-policy', 'pointer'));
+      await expect(session.performActions(keyDown)).rejects.toMatchObject(refused('input-policy', 'keyboard'));
+      await expect(session.performActions(scroll)).rejects.toMatchObject(refused('input-policy', 'wheel'));
+      // Waiting delivers nothing, so an accessible case may still pause.
+      await session.performActions([{ actions: [{ duration: 0, type: 'pause' }], id: 'idle', type: 'none' }]);
+      await session.performActions([{ actions: [{ duration: 0, type: 'pause' }], id: 'keys', type: 'key' }]);
+
+      expect(harness.host.actions.filter((action) => ['actions', 'clear', 'click', 'send-keys'].includes(action.type as string))).toEqual([
+        { elementId: 'save', mode: 'accessibility', type: 'click' },
+        { elementId: 'field', mechanism: 'semantic', type: 'clear' },
+        expect.objectContaining({ actions: [expect.objectContaining({ id: 'idle' })], type: 'actions' }),
+        expect.objectContaining({ actions: [expect.objectContaining({ id: 'keys' })], type: 'actions' }),
+      ]);
+      await expect(session.getInput()).resolves.toEqual({
+        mode: 'accessible',
+        receipts: { 'accessibility-click': 1, 'semantic-clear': 1 },
+      });
+    });
+  });
+
+  test('an accessible session refuses a clear the target cannot make semantically', async () => {
+    await withSession('accessible', async ({ harness, session }) => {
+      await expect((await session.findElement('accessibility id', 'label')).clear()).rejects.toMatchObject({
+        code: 'element not interactable',
+      });
+      expect(harness.host.actions.filter((action) => action.type === 'clear')).toEqual([]);
+      await expect(session.getInput()).resolves.toEqual({ mode: 'accessible', receipts: {} });
+    });
+    await withSession(
+      'accessible',
+      async ({ harness, session }) => {
+        await expect((await session.findElement('accessibility id', 'field')).clear()).rejects.toMatchObject(
+          refused('input-unsupported', 'semantic-clear'),
+        );
+        expect(harness.host.actions.filter((action) => action.type === 'clear')).toEqual([]);
+      },
+      { features: { strictClear: false } },
+    );
+  });
+
+  test('a physical session clears only with the keyboard, and needs only the keyboard to start', async () => {
+    await withSession(
+      'physical',
+      async ({ harness, session }) => {
+        const field = await session.findElement('accessibility id', 'field');
+        await field.clear();
+        await field.sendKeys('typed');
+        await expect((await session.findElement('accessibility id', 'save')).click()).rejects.toMatchObject(
+          refused('input-unsupported', 'physical-click'),
+        );
+        expect(harness.host.actions.filter((action) => action.type === 'clear' || action.type === 'click')).toEqual([
+          { elementId: 'field', mechanism: 'keyboard', type: 'clear' },
+        ]);
+        await expect(session.getInput()).resolves.toEqual({ mode: 'physical', receipts: { keyboard: 2 } });
+      },
+      { features: { accessibilityClick: false, physicalClick: false } },
+    );
+  });
+
+  test('fails a strict clear that the host made another way, after recording what it delivered', async () => {
+    await withSession('physical', async ({ harness, session }) => {
+      Object.assign(harness.host, { clear: async () => 'semantic' });
+      await expect((await session.findElement('accessibility id', 'field')).clear()).rejects.toMatchObject({
+        code: 'unknown error',
+        data: expect.objectContaining({ reason: 'input-mechanism-mismatch' }),
+      });
+      await expect(session.getInput()).resolves.toEqual({ mode: 'physical', receipts: { 'semantic-clear': 1 } });
+    });
+  });
+
+  test('counts a delivery unless its failure proves nothing was dispatched, and attributes what compatibility clears', async () => {
+    await withSession(undefined, async ({ harness, session }) => {
+      const save = await session.findElement('accessibility id', 'save');
+      harness.host.injectFault('click', { effect: 'none', mode: 'reject' });
+      await expect(save.click()).rejects.toBeDefined();
+      harness.host.injectFault('click', { effect: 'applied', mode: 'reject' });
+      await expect(save.click()).rejects.toBeDefined();
+      await save.click();
+      const field = await session.findElement('accessibility id', 'field');
+      await field.clear();
+      Object.assign(harness.host, { clear: async () => undefined });
+      await field.clear();
+      await expect(session.getInput()).resolves.toEqual({
+        mode: 'compatibility',
+        receipts: { 'physical-click': 2, 'semantic-clear': 1, 'unattributed-clear': 1 },
+      });
+    });
+  });
+
+  test('performs exactly one published accessibility action by name', async () => {
+    await withSession('accessible', async ({ harness, session }) => {
+      const stepper = await session.findElement('accessibility id', 'stepper');
+      await stepper.performAccessibilityAction('Increment');
+      await expect(stepper.performAccessibilityAction('Toggle')).rejects.toMatchObject({
+        code: 'element not interactable',
+        data: expect.objectContaining({ reason: 'action-not-published' }),
+      });
+      await expect(stepper.performAccessibilityAction('Reset')).rejects.toMatchObject({
+        code: 'element not interactable',
+        data: expect.objectContaining({ reason: 'action-not-unique' }),
+      });
+      await expect(stepper.performAccessibilityAction('')).rejects.toMatchObject({ code: 'invalid argument' });
+      expect(harness.host.actions.filter((action) => action.type === 'accessibility-action')).toEqual([
+        { elementId: 'stepper', name: 'Increment', type: 'accessibility-action' },
+      ]);
+      await expect(session.getInput()).resolves.toEqual({ mode: 'accessible', receipts: { 'accessibility-action': 1 } });
+    });
+    await withSession(
+      'accessible',
+      async ({ session }) => {
+        await expect(
+          (await session.findElement('accessibility id', 'stepper')).performAccessibilityAction('Increment'),
+        ).rejects.toMatchObject({
+          code: 'unsupported operation',
+        });
+      },
+      { features: { performAccessibilityAction: false } },
+    );
+  });
+
+  test('a physical session also delivers the accessible transports a mixed case declares, and receipts account for each', async () => {
+    await withSession('physical', async ({ session }) => {
+      await (await session.findElement('accessibility id', 'field')).sendKeys('typed');
+      await (await session.findElement('accessibility id', 'stepper')).performAccessibilityAction('Increment');
+      const { receipts } = await session.getInput();
+
+      expect(receipts).toEqual({ 'accessibility-action': 1, keyboard: 1 });
+      const mixed = validateDesktopCaseOptions({ input: 'physical', requires: ['keyboard', 'perform-accessibility-action'] });
+      expect(compareDesktopInputReceipts(mixed, receipts, 'physical')).toEqual({ undeclared: [], unused: [] });
+      expect(compareDesktopInputReceipts(validateDesktopCaseOptions({ requires: ['keyboard'] }), receipts, 'physical').undeclared).toEqual([
+        'accessibility-action',
+      ]);
+    });
+  });
+
+  test('agent operations in an accessible session never type or move the pointer', async () => {
+    await withSession('accessible', async ({ harness, session }) => {
+      await expect(session.act({ action: 'click', find: { automationId: 'save' } })).rejects.toMatchObject({
+        code: 'unsupported operation',
+      });
+      await expect(session.act({ action: 'type', find: { automationId: 'field' }, text: 'secret' })).rejects.toMatchObject({
+        code: 'unsupported operation',
+      });
+      await expect(session.act({ action: 'activate', find: { automationId: 'save' } })).resolves.toMatchObject({
+        result: { mechanism: 'accessibility' },
+      });
+      await expect(session.act({ action: 'clear', find: { automationId: 'field' } })).resolves.toMatchObject({
+        result: { mechanism: 'accessibility' },
+      });
+      await expect(session.act({ action: 'perform', find: { automationId: 'stepper' }, name: 'Increment' })).resolves.toBeDefined();
+      expect(
+        harness.host.actions.some((action) => action.type === 'send-keys' || (action.type === 'click' && action.mode === 'physical')),
+      ).toBe(false);
+      await expect(session.getInput()).resolves.toEqual({
+        mode: 'accessible',
+        receipts: { 'accessibility-action': 1, 'accessibility-click': 1, 'semantic-clear': 1 },
+      });
+    });
+  });
+});
diff --git a/packages/agentic/desktop-driver/src/server/sessionInput.ts b/packages/agentic/desktop-driver/src/server/sessionInput.ts
new file mode 100644
index 0000000000..1a606c4e64
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/server/sessionInput.ts
@@ -0,0 +1,155 @@
+import { desktopInputMechanisms, desktopInputModeAllows } from '../authoring/input.js';
+import type { DesktopInputMechanism, DesktopSessionInput } from '../authoring/input.js';
+import type { DesktopClearMechanism, DesktopHostFeatures, NativeActionSequence } from '../host/types.js';
+import { WebDriverError } from '../protocol/errors.js';
+import { attachFailureEffect, readFailureEffect } from '../protocol/settlement.js';
+import type { DesktopClickMode } from '../protocol/types.js';
+import type { DesktopSession } from './SessionManager.js';
+
+/** The host feature a strict session needs before it delivers each mechanism. */
+const mechanismFeature: Readonly<Record<DesktopInputMechanism, keyof DesktopHostFeatures | undefined>> = {
+  'accessibility-action': 'performAccessibilityAction',
+  'accessibility-click': 'accessibilityClick',
+  keyboard: 'keyboard',
+  'physical-click': 'physicalClick',
+  pointer: 'physicalClick',
+  'semantic-clear': 'strictClear',
+  'unattributed-clear': undefined,
+  wheel: 'wheel',
+};
+
+/** What `GET /session/:id/furn/input` reports. */
+export function describeSessionInput(session: DesktopSession): DesktopSessionInput {
+  const receipts: Partial<Record<DesktopInputMechanism, number>> = {};
+  for (const mechanism of desktopInputMechanisms) {
+    const count = session.inputReceipts.get(mechanism);
+    if (count) receipts[mechanism] = count;
+  }
+  return { mode: session.inputMode, receipts };
+}
+
+export function clickMechanism(mode: DesktopClickMode): DesktopInputMechanism {
+  return mode === 'accessibility' ? 'accessibility-click' : 'physical-click';
+}
+
+/**
+ * The mechanisms a sequence of actions delivers. A source that only pauses delivers nothing, so a strict session may
+ * still wait with one; a pointer that moves without pressing still moves the real pointer.
+ */
+export function actionMechanisms(sequences: readonly NativeActionSequence[]): DesktopInputMechanism[] {
+  const mechanisms = new Set<DesktopInputMechanism>();
+  for (const sequence of sequences) {
+    if (!sequence.actions.some((action) => action.type !== 'pause')) continue;
+    if (sequence.type === 'key') mechanisms.add('keyboard');
+    else if (sequence.type === 'pointer') mechanisms.add('pointer');
+    else if (sequence.type === 'wheel') mechanisms.add('wheel');
+  }
+  return [...mechanisms];
+}
+
+/**
+ * Refuses input a strict session's policy or host cannot deliver, before anything is dispatched, so the refusal is a
+ * settled rejection. A compatibility session leaves the decision to the host, as it always has.
+ */
+export function assertInputAllowed(session: DesktopSession, mechanism: DesktopInputMechanism, description: string): void {
+  const mode = session.inputMode;
+  if (mode === 'compatibility') return;
+  if (!desktopInputModeAllows(mode, mechanism)) {
+    throw refuse(`${description} would deliver ${mechanism} input, which a session with input mode "${mode}" never delivers.`, {
+      inputMode: mode,
+      mechanism,
+      reason: 'input-policy',
+    });
+  }
+  const feature = mechanismFeature[mechanism];
+  if (feature && session.hostInfo.features[feature] !== true) {
+    throw refuse(`${description} would deliver ${mechanism} input, which target "${session.target.id}" does not deliver.`, {
+      inputMode: mode,
+      mechanism,
+      reason: 'input-unsupported',
+    });
+  }
+}
+
+/** The clear mechanism a strict session requires, after checking the host can clear with only that mechanism. */
+export function strictClearMechanism(session: DesktopSession, description: string): DesktopClearMechanism | undefined {
+  const mode = session.inputMode;
+  if (mode === 'compatibility') return undefined;
+  const mechanism: DesktopClearMechanism = mode === 'accessible' ? 'semantic' : 'keyboard';
+  assertInputAllowed(session, mechanism === 'semantic' ? 'semantic-clear' : 'keyboard', description);
+  if (session.hostInfo.features.strictClear !== true) {
+    throw refuse(`${description} needs a ${mechanism} clear, but target "${session.target.id}" cannot clear with only one mechanism.`, {
+      inputMode: mode,
+      mechanism: mechanism === 'semantic' ? 'semantic-clear' : 'keyboard',
+      reason: 'input-unsupported',
+    });
+  }
+  return mechanism;
+}
+
+/**
+ * Dispatches one delivery of input and records its receipt. A failure counts unless it proves nothing was dispatched,
+ * because a delivery whose outcome was not observed may still have reached the application.
+ */
+export async function deliverInput<T>(
+  session: DesktopSession,
+  mechanisms: readonly DesktopInputMechanism[],
+  dispatch: () => Promise<T>,
+): Promise<T> {
+  try {
+    const result = await dispatch();
+    recordInput(session, mechanisms);
+    return result;
+  } catch (error) {
+    if (readFailureEffect(error) !== 'none') recordInput(session, mechanisms);
+    throw error;
+  }
+}
+
+/**
+ * Clears and records how. A strict session asks for one mechanism and fails a host that used another or would not say,
+ * after recording what was delivered. A compatibility session records what the host reports, or an unattributed clear.
+ */
+export async function deliverClear(
+  session: DesktopSession,
+  requested: DesktopClearMechanism | undefined,
+  description: string,
+  dispatch: (mechanism: DesktopClearMechanism | undefined) => Promise<DesktopClearMechanism | void>,
+): Promise<DesktopClearMechanism | undefined> {
+  let used: DesktopClearMechanism | void;
+  try {
+    used = await dispatch(requested);
+  } catch (error) {
+    if (readFailureEffect(error) !== 'none') recordInput(session, [clearReceipt(requested)]);
+    throw error;
+  }
+  recordInput(session, [clearReceipt(used || undefined)]);
+  if (requested && used !== requested) {
+    throw attachFailureEffect(
+      new WebDriverError(
+        'unknown error',
+        `${description} asked for a ${requested} clear, and the host cleared ${used ? `with the ${used} mechanism` : 'without saying how'}.`,
+        {
+          reason: 'input-mechanism-mismatch',
+        },
+      ),
+      'applied',
+    );
+  }
+  return used || undefined;
+}
+
+function clearReceipt(mechanism: DesktopClearMechanism | undefined): DesktopInputMechanism {
+  return mechanism === 'semantic' ? 'semantic-clear' : mechanism === 'keyboard' ? 'keyboard' : 'unattributed-clear';
+}
+
+function recordInput(session: DesktopSession, mechanisms: readonly DesktopInputMechanism[]): void {
+  for (const mechanism of mechanisms) {
+    session.inputReceipts.set(mechanism, (session.inputReceipts.get(mechanism) ?? 0) + 1);
+  }
+}
+
+function refuse(message: string, data: Record<string, unknown>): Error {
+  const error = new WebDriverError('unsupported operation', message, data);
+  return attachFailureEffect(error, 'none');
+}
diff --git a/packages/agentic/desktop-driver/src/server/sessionOperations.ts b/packages/agentic/desktop-driver/src/server/sessionOperations.ts
index 8f35d36e50..c42b07bc7b 100644
--- a/packages/agentic/desktop-driver/src/server/sessionOperations.ts
+++ b/packages/agentic/desktop-driver/src/server/sessionOperations.ts
@@ -6,6 +6,7 @@ import { safeToken } from '../operations/text.js';
 import { HostUnsupportedError, WebDriverError } from '../protocol/errors.js';
 import { withCommandTimeout } from '../protocol/timeouts.js';
 import type { DesktopSession, SessionManager } from './SessionManager.js';
+import { assertInputAllowed, clickMechanism, deliverClear, deliverInput, strictClearMechanism } from './sessionInput.js';
 import { createOperationStories } from './sessionStories.js';
 
 export type SessionOperationOptions = {
@@ -40,12 +41,22 @@ export function createOperationRuntime(
   const listAccessibilityActions = nativeHost.listAccessibilityActions?.bind(nativeHost);
   const performAccessibilityAction = nativeHost.performAccessibilityAction?.bind(nativeHost);
   const features = session.hostInfo.features;
+  // An accessible session offers no operation that types or moves the pointer, so `act` refuses them before it proves
+  // anything; the host below enforces the policy again when input is dispatched.
+  const accessible = session.inputMode === 'accessible';
   const host: OperationHost = {
     activate: (windowId, signal) => nativeHost.activate(windowId, signal),
     captureElement: (nativeId, signal) => nativeHost.captureElement(nativeId, signal),
     captureWindow: (windowId, signal) => nativeHost.captureWindow(windowId, signal),
-    clear: (nativeId, signal) => nativeHost.clear(nativeId, signal),
-    click: (nativeId, mode, signal) => nativeHost.click(nativeId, mode, signal),
+    async clear(nativeId, signal) {
+      const requested = strictClearMechanism(session, 'Clearing an element');
+      return deliverClear(session, requested, 'Clearing an element', (mechanism) => nativeHost.clear(nativeId, signal, mechanism));
+    },
+    async click(nativeId, mode, signal) {
+      const mechanism = clickMechanism(mode);
+      assertInputAllowed(session, mechanism, 'Clicking an element');
+      return deliverInput(session, [mechanism], () => nativeHost.click(nativeId, mode, signal));
+    },
     hitTest: (windowId, x, y, signal) => nativeHost.hitTest(windowId, x, y, signal),
     listAccessibilityActions(nativeId, signal) {
       if (!listAccessibilityActions) {
@@ -65,13 +76,17 @@ export function createOperationRuntime(
       }
       return releaseElements(nativeIds, signal);
     },
-    performAccessibilityAction(nativeId, key, signal) {
+    async performAccessibilityAction(nativeId, key, signal) {
       if (!performAccessibilityAction) {
         throw new HostUnsupportedError(`Target "${session.target.id}" does not perform accessibility actions.`);
       }
-      return performAccessibilityAction(nativeId, key, signal);
+      assertInputAllowed(session, 'accessibility-action', 'Performing an accessibility action');
+      return deliverInput(session, ['accessibility-action'], () => performAccessibilityAction(nativeId, key, signal));
+    },
+    async sendKeys(nativeId, text, signal) {
+      assertInputAllowed(session, 'keyboard', 'Typing into an element');
+      return deliverInput(session, ['keyboard'], () => nativeHost.sendKeys(nativeId, text, signal));
     },
-    sendKeys: (nativeId, text, signal) => nativeHost.sendKeys(nativeId, text, signal),
     snapshot: (nativeId, signal) => nativeHost.snapshot(nativeId, signal),
     ...(subscribe ? { subscribe } : {}),
   };
@@ -87,8 +102,8 @@ export function createOperationRuntime(
       accessibilityClick: features.accessibilityClick,
       boundedObservation: features.boundedObservation === true && !!observe && !!releaseElements,
       elementCapture: features.elementScreenshot,
-      keyboard: features.keyboard,
-      physicalClick: features.physicalClick,
+      keyboard: features.keyboard && !accessible,
+      physicalClick: features.physicalClick && !accessible,
       stories: !!session.target.storyOrchestrator,
       windowCapture: features.screenshot,
     },
diff --git a/packages/agentic/desktop-driver/src/testing/scriptedNativeHelper.ts b/packages/agentic/desktop-driver/src/testing/scriptedNativeHelper.ts
new file mode 100644
index 0000000000..0e83534932
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/testing/scriptedNativeHelper.ts
@@ -0,0 +1,72 @@
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+
+import { encodeJsonFrame, NativeFrameDecoder } from '../hosts/native/framing.js';
+import type { NativeHostJsonMessage } from '../native/types.js';
+
+export type ScriptedNativeRequest = Extract<NativeHostJsonMessage, { type: 'request' }>;
+export type ScriptedNativeSend = (message: NativeHostJsonMessage) => void;
+
+class ScriptedNativeChild extends EventEmitter {
+  readonly stdin = new PassThrough();
+  readonly stdout = new PassThrough();
+  readonly stderr = new PassThrough();
+  exitCode: number | null = null;
+  signalCode: NodeJS.Signals | null = null;
+
+  kill(): boolean {
+    this.finish();
+    return true;
+  }
+
+  finish(): void {
+    this.exitCode = 0;
+    setImmediate(() => {
+      this.emit('exit', 0, null);
+      this.emit('close', 0, null);
+    });
+  }
+}
+
+/**
+ * Scripts the next native helper a host spawns. The helper says hello with `features`, answers each request through
+ * `handler`, and acknowledges `dispose` and exits. Pass the test's mocked `spawn`; the returned list collects requests.
+ */
+export function scriptNativeHelper(
+  spawn: { mockImplementationOnce(implementation: () => unknown): unknown },
+  handler: (message: ScriptedNativeRequest, send: ScriptedNativeSend) => void,
+  features: readonly string[] = [],
+): ScriptedNativeRequest[] {
+  const child = new ScriptedNativeChild();
+  const decoder = new NativeFrameDecoder();
+  const received: ScriptedNativeRequest[] = [];
+  const send: ScriptedNativeSend = (message) => void child.stdout.write(encodeJsonFrame(message));
+  child.stdin.on('data', (chunk: Buffer) => decoder.write(chunk));
+  decoder.on('json', (message) => {
+    if (message.type !== 'request') {
+      return;
+    }
+    if (message.command === 'dispose') {
+      send({ id: message.id, result: {}, type: 'response' });
+      child.finish();
+      return;
+    }
+    received.push(message);
+    handler(message, send);
+  });
+  spawn.mockImplementationOnce(() => {
+    setImmediate(() =>
+      send({
+        architecture: 'arm64',
+        buildId: 'build',
+        features: [...features],
+        protocol: { major: 1, minor: 0 },
+        provider: 'macos',
+        sourceDigest: 'source',
+        type: 'hello',
+      }),
+    );
+    return child;
+  });
+  return received;
+}
diff --git a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.test.ts b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.test.ts
index 6bf0af6b64..60db490590 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.test.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.test.ts
@@ -106,6 +106,26 @@ describe('sanctioned WebdriverIO API', () => {
       fs.rmSync(artifactsRoot, { force: true, recursive: true });
     }
   }, 60_000);
+
+  test('opens a session with an input mode, and performs a named accessibility action through an element command', async () => {
+    const harness = await createDesktopDriverTestHarness({ features: { accessibilityActions: true, performAccessibilityAction: true } });
+    harness.host.setElementActions('button', ['Increment', 'Decrement']);
+    try {
+      const response = await runContract(harness.server.url, harness.target.id, os.tmpdir(), 'input.contract.cjs');
+      expect(response).toEqual({
+        attachedInputMode: 'accessible',
+        input: { mode: 'accessible', receipts: { 'accessibility-action': 1, 'semantic-clear': 1 } },
+        inputMode: 'accessible',
+        typed: expect.stringContaining('never delivers'),
+      });
+      expect(harness.host.actions).toContainEqual({ elementId: 'button', name: 'Increment', type: 'accessibility-action' });
+      expect(harness.host.actions).toContainEqual({ elementId: 'input', type: 'clear', mechanism: 'semantic' });
+      expect(harness.host.actions.some((action) => action.type === 'send-keys')).toBe(false);
+      expect(harness.host.actions.filter((action) => action.type === 'clear')).toHaveLength(1);
+    } finally {
+      await harness.close();
+    }
+  }, 60_000);
 });
 
 function runContract(
diff --git a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
index 731532b6fd..dc8e7e257f 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
@@ -2,11 +2,12 @@ import { inspect } from 'node:util';
 
 import { attach, remote } from 'webdriverio';
 
+import type { DesktopInputMode, DesktopSessionInput } from '../authoring/input.js';
 import type { DesktopStoryRunResult, DesktopStoryTestResult } from '../authoring/results.js';
 import type { DesktopStoryExpectation } from '../authoring/storyTests.js';
 import type { DesktopHostFeatures } from '../host/types.js';
 import { ArtifactManager } from '../artifacts/ArtifactManager.js';
-import { createDesktopDriverClient, DesktopSessionClient } from '../client/DesktopDriverClient.js';
+import { createDesktopDriverClient, DesktopElementClient, DesktopSessionClient } from '../client/DesktopDriverClient.js';
 import type { DesktopClickMode, DesktopPlatformName } from '../protocol/types.js';
 import { assertDesktopExpectation, runDesktopStoryTests } from '../runner/StoryTestRunner.js';
 import type { DesktopStoryTestSelection } from '../runner/StoryTestRunner.js';
@@ -19,18 +20,29 @@ declare global {
       'furn:clickMode'?: 'accessibility' | 'auto' | 'physical';
       'furn:endpoint'?: 'macos' | 'win32' | 'windows';
       'furn:features'?: Readonly<DesktopHostFeatures>;
+      'furn:inputMode'?: 'accessible' | 'compatibility' | 'physical';
       'furn:launchMode'?: 'attach' | 'launch';
       'furn:storybook'?: boolean;
       'furn:target'?: string;
     }
 
     interface Browser {
+      /** The session's input policy and the input it has delivered so far, by mechanism. */
+      desktopInput(): Promise<DesktopSessionInput>;
       desktopListStories(): Promise<DesktopStoryManifest>;
       desktopOpenStory(storyId: string, runId?: string): Promise<StoryReadyResult>;
       desktopResetStory(storyId: string, runId?: string): Promise<StoryReadyResult>;
       desktopExpect(expectation: DesktopStoryExpectation): Promise<void>;
       desktopRunStoryTests(options?: DesktopWebdriverRunOptions): Promise<DesktopStoryRunResult>;
     }
+
+    interface Element {
+      /**
+       * Performs the one accessibility action the element publishes under this name, such as `increment`, without
+       * moving the pointer or pressing a key. Declare `perform-accessibility-action` in a case that calls it.
+       */
+      desktopPerformAccessibilityAction(name: string): Promise<void>;
+    }
   }
 }
 
@@ -38,6 +50,8 @@ export type DesktopWebdriverOptions = {
   clickMode?: DesktopClickMode;
   /** Supervisor-provided credential. Never put it in capabilities, command lines, or logs. */
   grant?: string;
+  /** The input the session may deliver. A strict mode pins the click mode. Defaults to `compatibility`. */
+  inputMode?: DesktopInputMode;
   launchMode?: 'attach' | 'launch';
   logLevel?: 'debug' | 'error' | 'info' | 'silent' | 'trace' | 'warn';
   platformName: DesktopPlatformName;
@@ -84,6 +98,11 @@ export class DesktopWebdriverSession {
     return assertDesktopExpectation(this.session, expectation);
   }
 
+  /** The session's input policy and what it has delivered so far. */
+  input(): Promise<DesktopSessionInput> {
+    return this.session.getInput();
+  }
+
   async runStoryTests(options: DesktopWebdriverRunOptions = {}): Promise<DesktopStoryRunResult> {
     const manifest = await this.session.getStoryManifest();
     const endpoint = this.session.capabilities['furn:endpoint'];
@@ -122,6 +141,7 @@ export async function connectDesktopWebdriver(options: DesktopWebdriverOptions):
     },
     {
       'furn:clickMode': options.clickMode ?? 'auto',
+      ...(options.inputMode === undefined ? {} : { 'furn:inputMode': options.inputMode }),
       'furn:launchMode': options.launchMode ?? 'launch',
       'furn:target': options.targetId,
     },
@@ -235,7 +255,28 @@ export function installDesktopWebdriverCommands(
       },
       { attachToElement: true },
     );
+    browser.overwriteCommand(
+      'setValue',
+      async function (this: WebdriverIO.Element, originalCommand, value: string | number) {
+        const inputMode = boundSessions.get(browser)!.session.capabilities['furn:inputMode'];
+        if (inputMode === 'accessible') {
+          throw new Error(`setValue would deliver keyboard input, which a session with input mode "${inputMode}" never delivers.`);
+        }
+        return originalCommand(value);
+      },
+      { attachToElement: true },
+    );
+    browser.addCommand(
+      'desktopPerformAccessibilityAction',
+      async function (this: WebdriverIO.Element, name: string) {
+        const id = await nativeElementId(this);
+        if (!id) throw new Error('The element was not found, so it has no accessibility action to perform.');
+        await new DesktopElementClient(boundSessions.get(browser)!.session, id).performAccessibilityAction(name);
+      },
+      { attachToElement: true },
+    );
     browser.addCommand('desktopExpect', (expectation: DesktopStoryExpectation) => boundSessions.get(browser)!.expect(expectation));
+    browser.addCommand('desktopInput', () => boundSessions.get(browser)!.input());
     installedBrowsers.add(browser);
   }
   if (browser.capabilities['furn:storybook'] && !installedStoryBrowsers.has(browser)) {
diff --git a/packages/agentic/desktop-driver/src/wdio/input.contract.cjs b/packages/agentic/desktop-driver/src/wdio/input.contract.cjs
new file mode 100644
index 0000000000..0bcd2caccc
--- /dev/null
+++ b/packages/agentic/desktop-driver/src/wdio/input.contract.cjs
@@ -0,0 +1,34 @@
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+async function main() {
+  const moduleUrl = pathToFileURL(path.resolve(__dirname, '..', '..', 'lib', 'wdio', 'index.js')).href;
+  const { attachDesktopWebdriver, connectDesktopWebdriver } = await import(moduleUrl);
+  const [url, targetId] = process.argv.slice(2);
+  const desktop = await connectDesktopWebdriver({ inputMode: 'accessible', platformName: 'windows', targetId, url });
+  try {
+    const worker = await attachDesktopWebdriver({ url, sessionId: desktop.browser.sessionId, capabilities: desktop.browser.capabilities });
+    await (await worker.browser.$('~button-primary')).desktopPerformAccessibilityAction('Increment');
+    const input = await worker.browser.$('~input-name');
+    await input.clearValue();
+    const typed = await input.setValue('text').then(
+      () => 'typed',
+      (error) => error.message,
+    );
+    process.stdout.write(
+      JSON.stringify({
+        attachedInputMode: worker.browser.capabilities['furn:inputMode'],
+        input: await worker.browser.desktopInput(),
+        inputMode: desktop.browser.capabilities['furn:inputMode'],
+        typed,
+      }),
+    );
+  } finally {
+    await desktop.delete();
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(error.stack ?? error.message);
+  process.exitCode = 1;
+});
diff --git a/packages/agentic/desktop-test/references/commands.md b/packages/agentic/desktop-test/references/commands.md
index 817553b4bc..abaa38af42 100644
--- a/packages/agentic/desktop-test/references/commands.md
+++ b/packages/agentic/desktop-test/references/commands.md
@@ -64,8 +64,9 @@ rerunning `prep`. See [platform setup](platforms.md).
 `test --input accessible|physical` runs one input lane. `DESKTOP_INPUT` supplies
 the lane when the flag is absent, and an empty or unknown value is an error. The
 `accessible` lane starts the native host with keyboard, physical click, and wheel
-disabled and runs the tests that need no physical input; the `physical` lane
-runs tests that need it plus those that need neither. Tests declare which with
+disabled and requests a matching session policy; the `physical` lane requests a
+physical session policy and runs tests that need physical input plus those that
+need neither. Tests declare which with
 the [`./jasmine` helpers](wdio-suites.md#declare-input-and-scope-in-jasmine-specs).
 A lane requires a Jasmine WDIO suite (or the Storybook suite, whose integration
 applies the lane itself) and rejects `--list`, which resolves spec files without
@@ -75,7 +76,8 @@ lane run is judged.
 
 An imported integration that serves its own driver receives the lane and owns
 masking that driver. A host supplied through `hostFactory` is not masked by the
-harness, so the suite verifies the mask before running anything.
+harness, so the suite verifies the mask before running anything. The strict
+session policy independently refuses input outside the selected lane.
 
 The Storybook `csf-wdio` suite does not support generic `--list`. Discover story
 IDs with the Storybook integration's manifest/CLI, then select authored tests
diff --git a/packages/agentic/desktop-test/references/reporting.md b/packages/agentic/desktop-test/references/reporting.md
index ad7b0176ae..1c0c7f64f1 100644
--- a/packages/agentic/desktop-test/references/reporting.md
+++ b/packages/agentic/desktop-test/references/reporting.md
@@ -78,9 +78,16 @@ holds every selected test to its declared outcome. `run.json` carries the lane a
 - `masking` (accessible only): `host-masked` when this command started the host
   with keyboard, physical click, and wheel disabled, or `verified-masked` when it
   attached to a host and verified that mask before running anything.
-- `policyEnforced`: always `false`. The report records what was requested and how
-  the host was masked; it never claims what input a test delivered, so a physical
-  lane is labelled a pilot.
+- `policyEnforced`: `true` when each worker session confirms its requested
+  `furn:inputMode`; older reports may record `false`. The session refuses input
+  outside the lane before dispatch. `masking` is an additional host-level
+  safeguard, not the policy enforcement mechanism.
+
+Each executed test attempt may include `input` in `run.json`: `receipts` counts
+the mechanisms the session delivered, `undeclared` lists mechanisms the case
+did not declare and therefore failed on, and `unused` lists declared input
+requirements not exercised. These receipts describe deliveries, not whether an
+application changed state or whether a platform/lane is qualified.
 
 Tests that a lane, a `platforms` list, or a `scope` leaves out are not tests, so
 they are never reported as skipped. A producer announces them in `selection`
@@ -105,12 +112,12 @@ A lane run promised to execute its whole selection, so its verdict is stricter:
 its existing verdict.
 
 The plain and GitHub summaries show the lane and exclusions on one line, such as
-`Selection: input accessible (host-masked) from --input; excluded 4 by platform, 0 by scope, 12 by input`.
+`Selection: input accessible (policy-enforced, host-masked) from --input; excluded 4 by platform, 0 by scope, 12 by input`.
 The JUnit file records the lane as the properties `desktop.input`,
 `desktop.input.label`, and `desktop.input.source`, the exclusions as
 `desktop.excluded.platform`, `desktop.excluded.scope`, and `desktop.excluded.input`,
-and `desktop.declaredUnsupported` and `desktop.quarantined` when present. The label
-is `accessible (host-masked)`, `accessible (verified-masked)`, or `physical pilot`.
+and `desktop.declaredUnsupported` and `desktop.quarantined` when present. The label includes `policy-enforced` when the session confirmed that mode;
+`physical pilot` still does not claim qualification.
 
 A delegated command, which inherits its parent's collector, sends its exclusions to
 the parent but not its lane, so the parent's `run.json` has no `lane`. The command
diff --git a/packages/agentic/desktop-test/references/wdio-suites.md b/packages/agentic/desktop-test/references/wdio-suites.md
index fa80879ec3..d169d5c40f 100644
--- a/packages/agentic/desktop-test/references/wdio-suites.md
+++ b/packages/agentic/desktop-test/references/wdio-suites.md
@@ -93,8 +93,10 @@ meet is excluded the same way and reported unsupported.
   click in the physical lane. A `click` requirement follows it. Without a lane the
   session uses `auto`, which lets the host choose.
 - **Untrustworthy selections fail closed.** A malformed selection, an unverifiable
-  Jasmine environment, or an accessible lane on a host that does not report keyboard,
-  physical click, and wheel disabled disables every test and fails the run.
+  Jasmine environment, or a worker session that does not confirm the requested
+  `furn:inputMode` disables every test and fails the run. An accessible lane also
+  requires its host to report keyboard, physical click, and wheel disabled; the
+  supervisor applies these masks to its own native host.
 - **A bad declaration never throws.** Jasmine only warns when a spec file fails to
   load, so a throw would silently drop every test after it. An invalid declaration
   registers a failing test that reports the problem.
@@ -103,5 +105,6 @@ meet is excluded the same way and reported unsupported.
 - `desktopIt` takes no timeout argument; the suite's `timeoutMs` applies.
 
 The input-call lint of Storybook cases does not apply here. Page objects and helpers
-hide the input a test sends, so the accessible lane's host mask is the safeguard that
-fails a test that reaches for physical input.
+hide the input a test sends, so the host mask and session policy reject
+undeclared physical input. The reporter records mechanism receipts and fails a
+declared case if it delivered input outside its `requires`.
diff --git a/packages/agentic/desktop-test/src/cli.ts b/packages/agentic/desktop-test/src/cli.ts
index 83e746f174..659800eb62 100644
--- a/packages/agentic/desktop-test/src/cli.ts
+++ b/packages/agentic/desktop-test/src/cli.ts
@@ -175,7 +175,8 @@ export async function runDesktopTestCli(argv = process.argv): Promise<void> {
       kind: action === 'test' ? 'tests' : 'lifecycle',
       optional: suite?.kind === 'wdio' && suite.optional,
       context: { endpoint: target.endpoint, renderer: target.host.renderer },
-      ...(requestedLane ? { lane: createDesktopInputLane(requestedLane.input, requestedLane.source) } : {}),
+      // The supervisor starts the driver, and starts it masked for an accessible lane.
+      ...(requestedLane ? { lane: createDesktopInputLane(requestedLane.input, requestedLane.source, 'host-masked') } : {}),
       reporterMode,
       eventLevel,
       suppressFinalOutput: action === 'serve' ? () => ready : false,
diff --git a/packages/agentic/desktop-test/src/contracts.contract.cjs b/packages/agentic/desktop-test/src/contracts.contract.cjs
index e6203aa2e7..e00218fbf8 100644
--- a/packages/agentic/desktop-test/src/contracts.contract.cjs
+++ b/packages/agentic/desktop-test/src/contracts.contract.cjs
@@ -1748,18 +1748,18 @@ async function main() {
         input: 'accessible',
         source: 'option',
         masking: 'host-masked',
-        policyEnforced: false,
+        policyEnforced: true,
       });
       ran(invoke(['test', '--suite', 'csf'], { DESKTOP_INPUT: 'physical' }), 'physical', {
         input: 'physical',
         source: 'environment',
-        policyEnforced: false,
+        policyEnforced: true,
       });
       ran(invoke(['test', '--suite', 'csf', '--input', 'accessible'], { DESKTOP_INPUT: 'physical' }), 'accessible', {
         input: 'accessible',
         source: 'option',
         masking: 'host-masked',
-        policyEnforced: false,
+        policyEnforced: true,
       });
       const unlaned = invoke(['test', '--suite', 'csf']);
       assert.equal(unlaned.status, 0, unlaned.diagnostics);
@@ -1789,7 +1789,14 @@ async function main() {
       const { FakeDesktopHost } = await import('@fluentui-react-native/desktop-driver/testing');
       const laneMode = mode.startsWith('lane-');
       const retried = mode === 'retry' || mode === 'lane-physical';
-      const lane = laneMode ? createDesktopInputLane(mode === 'lane-physical' ? 'physical' : 'accessible', 'option') : undefined;
+      // Like the CLI, the fixture starts the host itself, masked for the accessible lane.
+      const lane = laneMode
+        ? createDesktopInputLane(
+            mode === 'lane-physical' ? 'physical' : 'accessible',
+            'option',
+            mode === 'lane-accessible' ? 'host-masked' : undefined,
+          )
+        : undefined;
       // The lane fixtures import the Jasmine adapter by file URL from the environment, so no value is spliced into source.
       if (laneMode) process.env.DESKTOP_JASMINE_URL = lib('jasmine/index.js');
       const run = reporter({ context: { endpoint: 'win32', renderer: 'paper' }, ...(lane ? { lane } : {}) });
@@ -1844,6 +1851,7 @@ async function main() {
           "  desktopIt('runs when nothing is declared', () => {});",
           "  desktopIt('clicks as the lane does', { requires: ['click'] }, async () => { await (await browser.$('~button-primary')).click(); });",
           "  desktopIt('clicks accessibly', { requires: ['accessibility-click'] }, async () => { await (await browser.$('~button-primary')).click(); });",
+          "  desktopIt('clicks without declaring it', async () => { await (await browser.$('~button-primary')).click(); });",
           "  desktopIt('physical only', { requires: ['keyboard'] }, mustNotRun('an input-excluded case'));",
           "  desktopIt('needs what the host lacks', { requires: ['accessibility-actions'] }, mustNotRun('a case the host cannot support'));",
           '});',
@@ -1983,18 +1991,24 @@ async function main() {
         }
       } else if (mode === 'lane-accessible') {
         const text = JSON.stringify(result);
-        // The host cannot support one case. A lane run holds that against the run instead of quietly skipping it.
-        assert(failure && /incomplete/.test(failure.message), `${failure?.stack}\n${text}\n${err.text()}`);
-        assert.notEqual(result.status, 'passed', text);
+        // One case delivered input it never declared, and the host cannot support another, which a lane run also holds
+        // against the run instead of quietly skipping it.
+        assert(failure, `${text}\n${err.text()}`);
+        assert.equal(result.status, 'failed', text);
         assert.equal(launches, 1);
         assert.equal(result.counts.passed, 3, text);
-        assert.equal(result.counts.failed, 0, text);
+        // The policy allowed the click, and its receipt failed the case that never declared it.
+        assert.equal(result.counts.failed, 1, text);
+        const undeclared = attemptOf(result, 'clicks without declaring it');
+        assert.deepEqual(undeclared.input, { receipts: { 'accessibility-click': 1 }, undeclared: ['accessibility-click'] }, text);
+        assert.match(undeclared.failure.error.message, /delivered input it does not declare: accessibility-click/, text);
+        assert.deepEqual(attemptOf(result, 'clicks as the lane does').input, { receipts: { 'accessibility-click': 1 } }, text);
         assert.equal(result.counts.unsupported, 1, text);
         assert.equal(result.counts.declaredUnsupported, 0, text);
         assert.deepEqual(result.selection.excluded, { platform: 0, scope: 0, input: 1 }, text);
-        assert.deepEqual(result.lane, { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false });
+        assert.deepEqual(result.lane, { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: true });
         const clicks = host.actions.filter((action) => action.type === 'click');
-        assert(clicks.length === 2 && clicks.every((action) => action.mode === 'accessibility'), JSON.stringify(host.actions));
+        assert(clicks.length === 3 && clicks.every((action) => action.mode === 'accessibility'), JSON.stringify(host.actions));
       } else {
         assert.equal(failure, undefined, `${failure?.stack}\n${err.text()}\n${out.text()}`);
         assert.equal(result.status, 'passed', JSON.stringify(result));
@@ -2011,7 +2025,9 @@ async function main() {
           assert.equal(result.counts.declaredUnsupported, 1, text);
           // Both attempts announced the same exclusions, and a retried group still counts them once.
           assert.deepEqual(result.selection.excluded, { platform: 2, scope: 1, input: 1 }, text);
-          assert.deepEqual(result.lane, { input: 'physical', source: 'option', policyEnforced: false });
+          assert.deepEqual(result.lane, { input: 'physical', source: 'option', policyEnforced: true });
+          assert.deepEqual(attemptOf(result, 'clicks as the lane does').input, { receipts: { 'physical-click': 1 } }, text);
+          assert.deepEqual(attemptOf(result, 'needs the keyboard').input, { receipts: {}, unused: ['keyboard'] }, text);
           const clicks = host.actions.filter((action) => action.type === 'click');
           assert(clicks.length > 0 && clicks.every((action) => action.mode === 'physical'), JSON.stringify(host.actions));
         }
@@ -2025,6 +2041,13 @@ async function main() {
   }
 }
 
+/** The last attempt of the one test whose title ends with `title`. */
+function attemptOf(result, title) {
+  const matches = result.tests.filter((test) => test.title.endsWith(title));
+  assert.equal(matches.length, 1, `expected one test titled "${title}"\n${JSON.stringify(result.tests)}`);
+  return matches[0].attempts.at(-1);
+}
+
 main().catch((error) => {
   process.stderr.write(error.stack ?? String(error));
   process.exitCode = 1;
diff --git a/packages/agentic/desktop-test/src/jasmine/adapter.test.ts b/packages/agentic/desktop-test/src/jasmine/adapter.test.ts
index 5b0764a76c..5a9ca56b4e 100644
--- a/packages/agentic/desktop-test/src/jasmine/adapter.test.ts
+++ b/packages/agentic/desktop-test/src/jasmine/adapter.test.ts
@@ -206,3 +206,66 @@ describe('desktopDescribe', () => {
     expect(registered.filter(({ kind }) => kind === 'it' || kind === 'xit').map(({ kind }) => kind)).toEqual(['it']);
   });
 });
+
+describe('desktopIt input attribution', () => {
+  function attributed(lane?: 'accessible' | 'physical') {
+    const registry = createDesktopJasmineRegistry(laneEnvironment(lane));
+    const jasmine = fakeJasmine();
+    const session = { receipts: { keyboard: 3 } as Record<string, number> | undefined };
+    const deliver = (mechanism: string, count = 1) => {
+      session.receipts = { ...session.receipts, [mechanism]: (session.receipts?.[mechanism] ?? 0) + count };
+    };
+    const { desktopIt } = createDesktopJasmine(jasmine.api, registry, async () => session.receipts);
+    const run = (name: string, context: object = {}) => jasmine.registered.find((spec) => spec.name === name)!.body!.call(context);
+    return { registry, session, deliver, desktopIt, run };
+  }
+
+  test('records only what the body delivered, and the declared input it never used', async () => {
+    const { deliver, desktopIt, registry, run } = attributed('physical');
+    desktopIt('types', { requires: ['keyboard', 'physical-click'] }, () => deliver('keyboard', 2));
+
+    await run('types');
+
+    expect(registry.entries.get('typesspec0')).toMatchObject({ input: { receipts: { keyboard: 2 }, unused: ['physical-click'] } });
+  });
+
+  test('fails a body that delivered input nothing declares, once it has run', async () => {
+    const { deliver, desktopIt, registry, run } = attributed();
+    desktopIt('sneaks', async () => deliver('wheel'));
+
+    await expect(run('sneaks')).rejects.toThrow(/The test delivered input it does not declare: wheel \(declare wheel\)\./);
+    expect(registry.entries.get('sneaksspec0')).toMatchObject({ input: { receipts: { wheel: 1 }, undeclared: ['wheel'] } });
+  });
+
+  test('a failed body keeps its own error and its receipts, and reports nothing unused', async () => {
+    const { deliver, desktopIt, registry, run } = attributed('physical');
+    desktopIt('breaks', { requires: ['keyboard', 'wheel'] }, async () => {
+      deliver('keyboard');
+      throw new Error('assertion');
+    });
+
+    await expect(run('breaks')).rejects.toThrow('assertion');
+    expect(registry.entries.get('breaksspec0')).toMatchObject({ input: { receipts: { keyboard: 1 } } });
+    expect(registry.entries.get('breaksspec0')).not.toHaveProperty('input.unused');
+  });
+
+  test('outside a lane, a click declaration accounts for whichever click the host chose', async () => {
+    const { deliver, desktopIt, run } = attributed();
+    desktopIt('clicks', { requires: ['click'] }, () => deliver('physical-click'));
+
+    await expect(run('clicks')).resolves.toBeUndefined();
+  });
+
+  test('runs the body as it is, with its context, when the session reports no receipts', async () => {
+    const { desktopIt, registry, run, session } = attributed();
+    session.receipts = undefined;
+    const context = { shared: true };
+    desktopIt('plain', function (this: unknown) {
+      expect(this).toBe(context);
+    });
+
+    await run('plain', context);
+
+    expect(registry.entries.get('plainspec0')).not.toHaveProperty('input');
+  });
+});
diff --git a/packages/agentic/desktop-test/src/jasmine/adapter.ts b/packages/agentic/desktop-test/src/jasmine/adapter.ts
index 9139684e15..1762fe0473 100644
--- a/packages/agentic/desktop-test/src/jasmine/adapter.ts
+++ b/packages/agentic/desktop-test/src/jasmine/adapter.ts
@@ -1,13 +1,18 @@
 import {
+  compareDesktopInputReceipts,
   decideDesktopCase,
+  describeUndeclaredDesktopInput,
   mergeDesktopCaseOptions,
+  resolveDesktopClickMode,
+  subtractDesktopInputReceipts,
   validateDesktopCaseOptions,
   validateDesktopGroupOptions,
 } from '@fluentui-react-native/desktop-driver/authoring';
-import type { DesktopCaseOptions, ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopCaseOptions, DesktopInputReceipts, ResolvedDesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
 import { desktopSpecIdentifier } from './registry.js';
 import type { DesktopJasmineRegistry, DesktopSpecEntry } from './registry.js';
 
+/** WDIO calls a spec body without Jasmine's `done`, so a body finishes by returning, or by settling the promise it returns. */
 export type DesktopSpecBody = (done: (error?: unknown) => void) => unknown;
 export type DesktopGroupBody = (this: unknown) => void;
 /** A group scopes the cases inside it. A gap describes one case, so a group cannot declare one. */
@@ -20,13 +25,21 @@ export type DesktopJasmineApi = {
   xit(name: string): unknown;
 };
 
+/** Reads the receipts of the session the specs drive, or nothing when the session cannot report them. */
+export type DesktopInputReader = () => Promise<DesktopInputReceipts | undefined>;
+
+type RunEntry = Extract<DesktopSpecEntry, { kind: 'run' }>;
+
 /**
  * Declares tests with their input modality and the places they run, and registers them with Jasmine.
  *
  * `desktopIt` and `desktopDescribe` never throw for a bad declaration: Jasmine only warns when a spec file fails to load,
  * so a throw would silently drop every test after it. A bad declaration becomes a failing spec that reports the problem.
+ *
+ * With `readInput`, each executed body is attributed: the input its session delivered while the body ran is compared with
+ * the declaration, and a mechanism nothing declares fails the test.
  */
-export function createDesktopJasmine(api: DesktopJasmineApi, registry: DesktopJasmineRegistry) {
+export function createDesktopJasmine(api: DesktopJasmineApi, registry: DesktopJasmineRegistry, readInput?: DesktopInputReader) {
   function record(spec: unknown, name: string, entry: DesktopSpecEntry): void {
     const identifier = desktopSpecIdentifier(spec as { description?: unknown; id?: unknown } | undefined);
     if (identifier === undefined) {
@@ -46,6 +59,35 @@ export function createDesktopJasmine(api: DesktopJasmineApi, registry: DesktopJa
     );
   }
 
+  function attributed(body: DesktopSpecBody, entry: RunEntry, read: DesktopInputReader): DesktopSpecBody {
+    return async function (this: unknown, ...args: unknown[]) {
+      delete entry.input;
+      const before = await read();
+      if (!before) return body.apply(this, args as Parameters<DesktopSpecBody>);
+      let failure: { error: unknown } | undefined;
+      try {
+        await body.apply(this, args as Parameters<DesktopSpecBody>);
+      } catch (error) {
+        failure = { error };
+      }
+      try {
+        const after = await read();
+        if (after) {
+          const receipts = subtractDesktopInputReceipts(after, before);
+          // The session's click mode is the lane's, so a click the host chose is judged the way it was delivered.
+          const clickMode = resolveDesktopClickMode(undefined, 'auto', registry.selection?.lane);
+          const { undeclared, unused } = compareDesktopInputReceipts(entry.descriptor, receipts, clickMode);
+          entry.input = { receipts, ...(undeclared.length ? { undeclared } : {}), ...(!failure && unused.length ? { unused } : {}) };
+        }
+      } catch (error) {
+        // A failed test keeps its own error; the receipts were only evidence for it.
+        if (!failure) throw error;
+      }
+      if (failure) throw failure.error;
+      if (entry.input?.undeclared) throw new Error(describeUndeclaredDesktopInput(entry.input.undeclared));
+    };
+  }
+
   function desktopIt(name: string, optionsOrBody: DesktopCaseOptions | DesktopSpecBody, maybeBody?: DesktopSpecBody): void {
     const hasOptions = typeof optionsOrBody !== 'function';
     const body = hasOptions ? maybeBody : optionsOrBody;
@@ -64,7 +106,8 @@ export function createDesktopJasmine(api: DesktopJasmineApi, registry: DesktopJa
       return;
     }
     if (decision.kind === 'run') {
-      record(api.it(name, body), name, { kind: 'run', descriptor });
+      const entry: RunEntry = { kind: 'run', descriptor };
+      record(api.it(name, readInput ? attributed(body, entry, readInput) : body), name, entry);
       return;
     }
     // A placeholder keeps the spec out of Jasmine's hooks and body without reporting it as a skipped test.
diff --git a/packages/agentic/desktop-test/src/jasmine/index.ts b/packages/agentic/desktop-test/src/jasmine/index.ts
index b602b7c452..4fcb7ffdf9 100644
--- a/packages/agentic/desktop-test/src/jasmine/index.ts
+++ b/packages/agentic/desktop-test/src/jasmine/index.ts
@@ -1,7 +1,7 @@
 import { createDesktopJasmine } from './adapter.js';
-import type { DesktopGroupBody, DesktopGroupOptions, DesktopJasmineApi, DesktopSpecBody } from './adapter.js';
+import type { DesktopGroupBody, DesktopGroupOptions, DesktopInputReader, DesktopJasmineApi, DesktopSpecBody } from './adapter.js';
 import { desktopJasmineRegistry } from './registry.js';
-import type { DesktopCaseOptions } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopCaseOptions, DesktopSessionInput } from '@fluentui-react-native/desktop-driver/authoring';
 
 export type {
   DesktopCaseOptions,
@@ -18,7 +18,12 @@ const jasmineApi: DesktopJasmineApi = {
   it: (name, body) => globals().it(name, body),
   xit: (name) => globals().xit(name),
 };
-const adapter = () => createDesktopJasmine(jasmineApi, desktopJasmineRegistry());
+// The desktop commands are installed on the session before any spec runs, so a body is attributed whenever they exist.
+const readInput: DesktopInputReader = async () => {
+  const browser = (globalThis as { browser?: { desktopInput?: () => Promise<DesktopSessionInput> } }).browser;
+  return browser?.desktopInput ? (await browser.desktopInput()).receipts : undefined;
+};
+const adapter = () => createDesktopJasmine(jasmineApi, desktopJasmineRegistry(), readInput);
 
 /**
  * Declares a Jasmine test with the input it needs and where it runs. The descriptor decides whether the test is part of a
diff --git a/packages/agentic/desktop-test/src/jasmine/registry.ts b/packages/agentic/desktop-test/src/jasmine/registry.ts
index d927d700f1..1a66b45978 100644
--- a/packages/agentic/desktop-test/src/jasmine/registry.ts
+++ b/packages/agentic/desktop-test/src/jasmine/registry.ts
@@ -4,14 +4,17 @@ import type {
   DesktopRequirement,
   ResolvedDesktopCaseOptions,
 } from '@fluentui-react-native/desktop-driver/authoring';
-import type { SelectionExclusions } from '../reporting/protocol.js';
+import type { SelectionExclusions, TestInputReport } from '../reporting/protocol.js';
 import { desktopTestSelectionEnvironment, parseDesktopTestSelection } from './selection.js';
 import type { DesktopTestSelection } from './selection.js';
 
 /** What the adapter decided for a spec it registered. */
 export type DesktopSpecEntry =
-  /** Executes, unless a preflight found that the host cannot meet what it requires. */
-  | { kind: 'run'; descriptor: ResolvedDesktopCaseOptions; missing?: readonly DesktopRequirement[] }
+  /**
+   * Executes, unless a preflight found that the host cannot meet what it requires. `input` is what its body delivered,
+   * once it ran in a session that reports receipts.
+   */
+  | { kind: 'run'; descriptor: ResolvedDesktopCaseOptions; missing?: readonly DesktopRequirement[]; input?: TestInputReport }
   /** Registered as a placeholder that never runs and is counted, not reported as a test. */
   | { kind: 'excluded'; reason: DesktopExclusionReason }
   /** Registered as a placeholder that is reported as unsupported, with the reason its author gave. */
diff --git a/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts b/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
index 85c105ec72..750ddb4cff 100644
--- a/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
+++ b/packages/agentic/desktop-test/src/jasmine/specSelection.test.ts
@@ -70,7 +70,7 @@ describe('selectDesktopSpecs preflight', () => {
     desktopIt('needs click', { requires: ['physical-click'] }, body);
     desktopIt('needs nothing', body);
 
-    selectDesktopSpecs(registry, environment, { keyboard: false, physicalClick: true });
+    selectDesktopSpecs(registry, environment, { keyboard: false, physicalClick: true }, 'physical');
 
     expect([runs('needs keyboard'), runs('needs click'), runs('needs nothing')]).toEqual([false, true, true]);
     expect(registry.entries.get('needs keyboardspec0')).toMatchObject({ kind: 'run', missing: ['keyboard'] });
@@ -83,7 +83,7 @@ describe('selectDesktopSpecs preflight', () => {
     desktopIt('needs keyboard', { requires: ['keyboard'] }, body);
     desktopIt('kept', body);
 
-    selectDesktopSpecs(registry, environment, { keyboard: false });
+    selectDesktopSpecs(registry, environment, { keyboard: false }, 'physical');
 
     expect([runs('user filtered'), runs('needs keyboard'), runs('kept')]).toEqual([false, false, true]);
   });
@@ -92,7 +92,7 @@ describe('selectDesktopSpecs preflight', () => {
     const { configure, desktopIt, environment, registry } = setup('physical');
     desktopIt('needs keyboard', { requires: ['keyboard'] }, body);
 
-    selectDesktopSpecs(registry, environment, { keyboard: true });
+    selectDesktopSpecs(registry, environment, { keyboard: true }, 'physical');
 
     expect(configure).not.toHaveBeenCalled();
   });
@@ -100,12 +100,12 @@ describe('selectDesktopSpecs preflight', () => {
   test('judges a click requirement by what the lane clicks with', () => {
     const physical = setup('physical');
     physical.desktopIt('clicks', { requires: ['click'] }, body);
-    selectDesktopSpecs(physical.registry, physical.environment, { physicalClick: false, accessibilityClick: true });
+    selectDesktopSpecs(physical.registry, physical.environment, { physicalClick: false, accessibilityClick: true }, 'physical');
     expect(physical.runs('clicks')).toBe(false);
 
     const accessible = setup('accessible');
     accessible.desktopIt('clicks', { requires: ['click'] }, body);
-    selectDesktopSpecs(accessible.registry, accessible.environment, { ...masked, accessibilityClick: true });
+    selectDesktopSpecs(accessible.registry, accessible.environment, { ...masked, accessibilityClick: true }, 'accessible');
     expect(accessible.runs('clicks')).toBe(true);
   });
 });
@@ -115,24 +115,39 @@ describe('selectDesktopSpecs fail-closed checks', () => {
     const { desktopIt, environment, registry, runs } = setup('accessible');
     desktopIt('fine', body);
 
-    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true, physicalClick: false })).toThrow(
+    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true, physicalClick: false }, 'accessible')).toThrow(
       'The accessible input lane needs a host that reports keyboard, wheel disabled, and this one does not.',
     );
     expect(registry.blocked).toBe(true);
     expect(runs('fine')).toBe(false);
   });
 
+  test('a lane whose session did not confirm its input policy disables every spec and says why', () => {
+    const { desktopIt, environment, registry, runs } = setup('accessible');
+    desktopIt('fine', body);
+
+    expect(() => selectDesktopSpecs(registry, environment, masked, 'compatibility')).toThrow(
+      'The accessible input lane needs a session that enforces the accessible input policy, and the driver reported compatibility.',
+    );
+    expect(registry.blocked).toBe(true);
+    expect(runs('fine')).toBe(false);
+    expect(() => selectDesktopSpecs(setup('physical').registry, environment, {})).toThrow(
+      /physical input policy, and the driver reported none\./,
+    );
+  });
+
   test('an absent feature report counts as unmasked', () => {
-    const { environment, registry } = setup('accessible');
+    const { desktopIt, environment, registry } = setup('accessible');
+    desktopIt('fine', body);
 
-    expect(() => selectDesktopSpecs(registry, environment, undefined)).toThrow(/keyboard, physicalClick, wheel disabled/);
+    expect(() => selectDesktopSpecs(registry, environment, undefined, 'accessible')).toThrow(/keyboard, physicalClick, wheel disabled/);
   });
 
   test('an accessible lane on a masked host runs', () => {
     const { desktopIt, environment, registry, runs } = setup('accessible');
     desktopIt('fine', body);
 
-    selectDesktopSpecs(registry, environment, masked);
+    selectDesktopSpecs(registry, environment, masked, 'accessible');
 
     expect(registry.blocked).toBe(false);
     expect(runs('fine')).toBe(true);
@@ -142,7 +157,7 @@ describe('selectDesktopSpecs fail-closed checks', () => {
     const { desktopIt, environment, registry } = setup('physical');
     desktopIt('fine', body);
 
-    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true })).not.toThrow();
+    expect(() => selectDesktopSpecs(registry, environment, { keyboard: true }, 'physical')).not.toThrow();
   });
 
   test('a lane refuses specs that were not declared with desktopIt, however many', () => {
@@ -152,7 +167,7 @@ describe('selectDesktopSpecs fail-closed checks', () => {
       for (let index = 0; index < 12; index++) api.it(`spec ${index}`, body);
     });
 
-    expect(() => selectDesktopSpecs(registry, environment, {})).toThrow(
+    expect(() => selectDesktopSpecs(registry, environment, {}, 'physical')).toThrow(
       /12 specs were not declared with desktopIt or desktopDescribe: "legacy spec 0", .*"legacy spec 9" and 2 more\./,
     );
     expect(registry.blocked).toBe(true);
@@ -177,7 +192,7 @@ describe('selectDesktopSpecs fail-closed checks', () => {
     const { environment, registry } = setup('accessible');
     registry.errors.push('Jasmine did not identify the spec registered for "ghost", so its selection cannot be verified.');
 
-    expect(() => selectDesktopSpecs(registry, environment, {})).toThrow(/ghost[\s\S]*accessible input lane/);
+    expect(() => selectDesktopSpecs(registry, environment, {}, 'accessible')).toThrow(/ghost[\s\S]*accessible input lane/);
     expect(registry.blocked).toBe(true);
   });
 });
diff --git a/packages/agentic/desktop-test/src/jasmine/specSelection.ts b/packages/agentic/desktop-test/src/jasmine/specSelection.ts
index ac3c059544..9d0a945a03 100644
--- a/packages/agentic/desktop-test/src/jasmine/specSelection.ts
+++ b/packages/agentic/desktop-test/src/jasmine/specSelection.ts
@@ -34,9 +34,16 @@ export function selectDesktopSpecs(
   registry: DesktopJasmineRegistry,
   environment: DesktopJasmineEnvironment | undefined,
   features: unknown,
+  inputMode?: unknown,
 ): void {
   const lane = registry.selection?.lane;
   const problems = [...registry.errors];
+  // The driver refuses what the lane's policy forbids only when the session confirmed that policy.
+  if (lane && inputMode !== lane) {
+    problems.push(
+      `The ${lane} input lane needs a session that enforces the ${lane} input policy, and the driver reported ${typeof inputMode === 'string' ? inputMode : 'none'}.`,
+    );
+  }
   if (lane === 'accessible') {
     const unmasked = unmaskedAccessibleFeatures(features);
     if (unmasked.length > 0) {
diff --git a/packages/agentic/desktop-test/src/reporting/collector.test.ts b/packages/agentic/desktop-test/src/reporting/collector.test.ts
index 3e811e66e6..93a7940295 100644
--- a/packages/agentic/desktop-test/src/reporting/collector.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/collector.test.ts
@@ -8,7 +8,7 @@ import { DesktopRunReporter } from './collector.js';
 import type { DesktopInputLaneReport } from './results.js';
 
 describe('desktop run reporter input lanes', () => {
-  const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false };
+  const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: true };
   let artifactsRoot: string;
 
   beforeEach(() => {
@@ -104,7 +104,9 @@ describe('desktop run reporter input lanes', () => {
 
     expect(result.status).toBe('incomplete');
     expect(output()).toContain('2 unsupported (1 declared, 0 quarantined)');
-    expect(output()).toContain('[desktop] input accessible (host-masked) from --input; excluded 0 by platform, 0 by scope, 3 by input');
+    expect(output()).toContain(
+      '[desktop] input accessible (policy-enforced, host-masked) from --input; excluded 0 by platform, 0 by scope, 3 by input',
+    );
   });
 
   test('the same unsupported case does not fail a compatibility run', async () => {
diff --git a/packages/agentic/desktop-test/src/reporting/collector.ts b/packages/agentic/desktop-test/src/reporting/collector.ts
index d8ea65525e..719a281cc6 100644
--- a/packages/agentic/desktop-test/src/reporting/collector.ts
+++ b/packages/agentic/desktop-test/src/reporting/collector.ts
@@ -397,6 +397,9 @@ export class DesktopRunReporter {
         this.logger.log(
           `${prefix} ${event.payload.status.toUpperCase()} ${event.payload.title}${event.payload.reason ? `: ${event.payload.reason}` : ''}`,
         );
+        // Reported, never failed: a declaration may cover a path this attempt did not take.
+        if (event.payload.input?.unused)
+          this.logger.log(`${prefix} declared input this attempt did not deliver: ${event.payload.input.unused.join(', ')}`);
         if (failure && firstFailure) this.logger.error(`${prefix} ${errorDiagnostic(failure.error)}`);
         break;
       case 'artifact':
diff --git a/packages/agentic/desktop-test/src/reporting/index.ts b/packages/agentic/desktop-test/src/reporting/index.ts
index 16383d62c2..4765f332aa 100644
--- a/packages/agentic/desktop-test/src/reporting/index.ts
+++ b/packages/agentic/desktop-test/src/reporting/index.ts
@@ -13,6 +13,7 @@ export type {
   ReportFailure,
   SelectionExclusions,
   TestGap,
+  TestInputReport,
   TestStatus,
 } from './protocol.js';
 export type { DesktopEventRecord } from './structured.js';
@@ -31,6 +32,7 @@ export {
   summarizeDesktopRun,
 } from './results.js';
 export type {
+  DesktopInputLaneMasking,
   DesktopInputLaneReport,
   DesktopInputLaneSource,
   DesktopRunResult,
diff --git a/packages/agentic/desktop-test/src/reporting/lane.test.ts b/packages/agentic/desktop-test/src/reporting/lane.test.ts
index f10c320dd9..9c312ff764 100644
--- a/packages/agentic/desktop-test/src/reporting/lane.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/lane.test.ts
@@ -18,17 +18,18 @@ describe('requested desktop input lane', () => {
 });
 
 describe('createDesktopInputLane', () => {
-  test('an accessible lane says how it was masked, and neither lane claims enforcement yet', () => {
-    expect(createDesktopInputLane('accessible', 'option')).toEqual({
+  test('every lane is policy-enforced, and only an accessible lane records host masks', () => {
+    expect(createDesktopInputLane('accessible', 'option', 'host-masked')).toEqual({
       input: 'accessible',
       source: 'option',
       masking: 'host-masked',
-      policyEnforced: false,
+      policyEnforced: true,
     });
-    expect(createDesktopInputLane('accessible', 'driver', 'verified-masked')).toMatchObject({
-      masking: 'verified-masked',
-      source: 'driver',
+    expect(createDesktopInputLane('accessible', 'driver')).toEqual({ input: 'accessible', source: 'driver', policyEnforced: true });
+    expect(createDesktopInputLane('physical', 'environment', 'host-masked')).toEqual({
+      input: 'physical',
+      source: 'environment',
+      policyEnforced: true,
     });
-    expect(createDesktopInputLane('physical', 'environment')).toEqual({ input: 'physical', source: 'environment', policyEnforced: false });
   });
 });
diff --git a/packages/agentic/desktop-test/src/reporting/lane.ts b/packages/agentic/desktop-test/src/reporting/lane.ts
index 49064f01e2..968c713059 100644
--- a/packages/agentic/desktop-test/src/reporting/lane.ts
+++ b/packages/agentic/desktop-test/src/reporting/lane.ts
@@ -25,13 +25,16 @@ export function requestedDesktopInputLane(request: { flag?: string; environment?
 }
 
 /**
- * How an accessible lane was masked. `host-masked` means this command started the host with keyboard, physical click and
- * wheel disabled. `verified-masked` means it attached to a host and checked the mask before running anything.
+ * The lane a run holds its tests to. Every runner verifies that each session confirmed the lane's `furn:inputMode` and
+ * stops otherwise, so a lane is always policy-enforced. Pass `host-masked` when this command also started the host with
+ * keyboard, physical click and wheel disabled for an accessible lane.
  */
 export function createDesktopInputLane(
   input: DesktopInputLaneName,
   source: DesktopInputLaneSource,
-  masking: 'host-masked' | 'verified-masked' = 'host-masked',
+  masking?: 'host-masked',
 ): DesktopInputLaneReport {
-  return input === 'physical' ? { input, source, policyEnforced: false } : { input, source, masking, policyEnforced: false };
+  return input === 'physical'
+    ? { input, source, policyEnforced: true }
+    : { input, source, ...(masking ? { masking } : {}), policyEnforced: true };
 }
diff --git a/packages/agentic/desktop-test/src/reporting/protocol.test.ts b/packages/agentic/desktop-test/src/reporting/protocol.test.ts
index 2462042655..315aa96b2f 100644
--- a/packages/agentic/desktop-test/src/reporting/protocol.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/protocol.test.ts
@@ -28,6 +28,34 @@ describe('declared gaps and selection events', () => {
     expect(() => validateDesktopEvent(event('test-result', { ...result, status: 'unsupported', gap: 'flaky' }))).toThrow();
   });
 
+  test('accepts delivered input, and undeclared input only on a failed result', () => {
+    const receipts = { 'accessibility-click': 1, keyboard: 2 };
+    const failed = {
+      ...result,
+      status: 'failed',
+      failure: { failureId: 'failure', kind: 'test', error: { name: 'Error', message: 'Undeclared input.' } },
+    };
+    expect(() => validateDesktopEvent(event('test-result', { ...result, status: 'passed', input: { receipts } }))).not.toThrow();
+    expect(() =>
+      validateDesktopEvent(event('test-result', { ...result, status: 'passed', input: { receipts, unused: ['wheel'] } })),
+    ).not.toThrow();
+    expect(() => validateDesktopEvent(event('test-result', { ...failed, input: { receipts, undeclared: ['keyboard'] } }))).not.toThrow();
+    expect(() =>
+      validateDesktopEvent(event('test-result', { ...result, status: 'passed', input: { receipts, undeclared: ['keyboard'] } })),
+    ).toThrow('must fail');
+  });
+
+  test.each([
+    ['an unknown mechanism', { receipts: { typing: 1 } }],
+    ['a negative count', { receipts: { keyboard: -1 } }],
+    ['an empty undeclared list', { receipts: {}, undeclared: [] }],
+    ['an unknown requirement', { receipts: {}, unused: ['typing'] }],
+    ['an unknown field', { receipts: {}, typed: 'secret' }],
+  ])('rejects input with %s', (_name, input) => {
+    // A passed result needs nothing else, so the input is what fails it.
+    expect(() => validateDesktopEvent(event('test-result', { ...result, status: 'passed', input }))).toThrow();
+  });
+
   test('accepts exactly the three non-negative integer exclusion counts', () => {
     expect(() => validateDesktopEvent(event('selection', { excluded: { platform: 1, scope: 0, input: 12 } }))).not.toThrow();
   });
diff --git a/packages/agentic/desktop-test/src/reporting/protocol.ts b/packages/agentic/desktop-test/src/reporting/protocol.ts
index 524c10f50b..14b2754831 100644
--- a/packages/agentic/desktop-test/src/reporting/protocol.ts
+++ b/packages/agentic/desktop-test/src/reporting/protocol.ts
@@ -1,4 +1,6 @@
 import { randomUUID } from 'node:crypto';
+import { desktopInputMechanisms, desktopRequirements, validateDesktopInputReceipts } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopInputMechanism, DesktopInputReceipts, DesktopRequirement } from '@fluentui-react-native/desktop-driver/authoring';
 
 export type FailureKind = 'test' | 'infrastructure' | 'cleanup' | 'evidence' | 'reporting';
 export type ReportError = { name: string; message: string; stack?: string; cause?: ReportError; errors?: ReportError[] };
@@ -21,6 +23,15 @@ export const testGaps: readonly TestGap[] = ['unsupported', 'quarantine'];
 /** Cases a producer removed from its selection before any session existed, by the reason they were removed. */
 export type SelectionExclusions = { platform: number; scope: number; input: number };
 export const selectionExclusionReasons: readonly (keyof SelectionExclusions)[] = ['platform', 'scope', 'input'];
+/**
+ * The input one test attempt delivered, read from its session's receipts, and how it compares with the declaration.
+ * `undeclared` mechanisms failed the attempt; `unused` declarations are reported only.
+ */
+export type TestInputReport = {
+  receipts: DesktopInputReceipts;
+  undeclared?: DesktopInputMechanism[];
+  unused?: DesktopRequirement[];
+};
 export type EventContext = {
   endpoint?: 'macos' | 'windows' | 'win32';
   renderer?: 'fabric' | 'paper';
@@ -50,6 +61,7 @@ export type EventData =
         durationMs: number;
         reason?: string;
         gap?: TestGap;
+        input?: TestInputReport;
         failure?: ReportFailure;
       };
     }
@@ -82,7 +94,7 @@ const payloadFields = {
   diagnostic: ['level', 'message', 'failure'],
   output: ['stream', 'text'],
   'test-start': ['testId', 'title', 'attempt'],
-  'test-result': ['testId', 'title', 'attempt', 'status', 'durationMs', 'reason', 'gap', 'failure'],
+  'test-result': ['testId', 'title', 'attempt', 'status', 'durationMs', 'reason', 'gap', 'input', 'failure'],
   selection: ['excluded', 'key'],
   artifact: ['path', 'description'],
   'producer-finished': ['status'],
@@ -191,6 +203,11 @@ export function validateDesktopEvent(value: unknown): asserts value is DesktopEv
           member(payload.gap, testGaps);
           if (payload.status !== 'unsupported') throw new TypeError('A declared gap is only valid on an unsupported test result.');
         }
+        if (payload.input !== undefined) {
+          validateTestInputReport(payload.input);
+          if (payload.input.undeclared?.length && payload.status !== 'failed')
+            throw new TypeError('A test that delivered undeclared input must fail.');
+        }
         if (payload.failure !== undefined) validateFailure(payload.failure);
       }
       break;
@@ -268,6 +285,22 @@ function validateFailure(value: unknown): asserts value is ReportFailure {
   checkError(failure.error, 0);
 }
 
+/** Checks the input an attempt reported, in an event or a persisted run, so a malformed one is never shown as evidence. */
+export function validateTestInputReport(value: unknown): asserts value is TestInputReport {
+  const input = record(value, 'input');
+  exactKeys(input, ['receipts', 'undeclared', 'unused']);
+  validateDesktopInputReceipts(input.receipts, 'input.receipts');
+  for (const [field, values] of [
+    ['undeclared', desktopInputMechanisms],
+    ['unused', desktopRequirements],
+  ] as const) {
+    const list = input[field];
+    if (list === undefined) continue;
+    if (!Array.isArray(list) || list.length === 0) throw new TypeError(`input.${field} must be a nonempty array.`);
+    for (const item of list) member(item, values);
+  }
+}
+
 function record(value: unknown, label: string): Record<string, unknown> {
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
   return value as Record<string, unknown>;
diff --git a/packages/agentic/desktop-test/src/reporting/results.test.ts b/packages/agentic/desktop-test/src/reporting/results.test.ts
index 82208acd89..7953183e5d 100644
--- a/packages/agentic/desktop-test/src/reporting/results.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/results.test.ts
@@ -11,7 +11,7 @@ import {
 } from './results.js';
 import type { DesktopInputLaneReport, DesktopRunResult, DesktopTestResult } from './results.js';
 
-const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false };
+const accessible: DesktopInputLaneReport = { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: true };
 
 function outcome(
   status: DesktopTestResult['status'],
@@ -120,14 +120,21 @@ describe('input lane and exclusion reporting', () => {
 
   test('names the lane, its source and each exclusion on one line', () => {
     expect(describeDesktopSelection(result())).toBe(
-      'input accessible (host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input',
+      'input accessible (policy-enforced, host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input',
     );
-    expect(describeDesktopSelection({ lane: { input: 'physical', source: 'environment', policyEnforced: false } })).toBe(
-      'input physical pilot from DESKTOP_INPUT',
+    expect(describeDesktopSelection({ lane: { input: 'physical', source: 'environment', policyEnforced: true } })).toBe(
+      'input physical pilot (policy-enforced) from DESKTOP_INPUT',
     );
+    expect(describeDesktopSelection({ lane: { input: 'accessible', source: 'driver', policyEnforced: true } })).toBe(
+      'input accessible (policy-enforced) from the driver instance',
+    );
+    // A report written before enforcement still reads as what it was.
     expect(
       describeDesktopSelection({ lane: { input: 'accessible', source: 'driver', masking: 'verified-masked', policyEnforced: false } }),
     ).toBe('input accessible (verified-masked) from the driver instance');
+    expect(describeDesktopSelection({ lane: { input: 'physical', source: 'environment', policyEnforced: false } })).toBe(
+      'input physical pilot from DESKTOP_INPUT',
+    );
     expect(describeDesktopSelection({})).toBeUndefined();
   });
 
@@ -139,7 +146,7 @@ describe('input lane and exclusion reporting', () => {
     const xml = renderJUnit(result());
 
     expect(xml).toContain('<property name="desktop.input" value="accessible"/>');
-    expect(xml).toContain('<property name="desktop.input.label" value="accessible (host-masked)"/>');
+    expect(xml).toContain('<property name="desktop.input.label" value="accessible (policy-enforced, host-masked)"/>');
     expect(xml).toContain('<property name="desktop.input.source" value="option"/>');
     expect(xml).toContain('<property name="desktop.excluded.platform" value="2"/>');
     expect(xml).toContain('<property name="desktop.excluded.input" value="7"/>');
@@ -155,7 +162,9 @@ describe('input lane and exclusion reporting', () => {
   test('the Markdown summary leads with the selection and splits unsupported counts', () => {
     const markdown = renderRunSummary(result());
 
-    expect(markdown).toContain('Selection: input accessible (host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input.');
+    expect(markdown).toContain(
+      'Selection: input accessible (policy-enforced, host-masked) from --input; excluded 2 by platform, 1 by scope, 7 by input.',
+    );
     expect(markdown).toContain('2 unsupported (1 declared, 1 quarantined)');
     expect(markdown).toContain('declared unsupported: Not executed.');
   });
diff --git a/packages/agentic/desktop-test/src/reporting/results.ts b/packages/agentic/desktop-test/src/reporting/results.ts
index 02fa673fe8..684a0d6ffc 100644
--- a/packages/agentic/desktop-test/src/reporting/results.ts
+++ b/packages/agentic/desktop-test/src/reporting/results.ts
@@ -1,6 +1,6 @@
 import path from 'node:path';
 
-import type { EventContext, ReportFailure, SelectionExclusions, TestGap, TestStatus } from './protocol.js';
+import type { EventContext, ReportFailure, SelectionExclusions, TestGap, TestInputReport, TestStatus } from './protocol.js';
 
 export type DesktopTestAttempt = {
   attempt: number;
@@ -9,19 +9,24 @@ export type DesktopTestAttempt = {
   reason?: string;
   /** Present only on an `unsupported` attempt the producer declared in advance, never on a missing requirement. */
   gap?: TestGap;
+  /** The input the attempt's session delivered, when the producer read its receipts. */
+  input?: TestInputReport;
   failure?: ReportFailure;
   context?: EventContext;
 };
 /**
- * The input lane a run was asked to execute. It records the request and how the host was masked; it never claims what
- * input a session delivered or enforced, hence the literal `policyEnforced: false`.
+ * The input lane a run was asked to execute: the request, where it came from, and how it was held. `policyEnforced` means
+ * every session confirmed the lane's `furn:inputMode`, so the driver refused input outside the lane; runs recorded before
+ * the driver enforced a policy carry `false`. `masking` names host masks that also applied. Neither qualifies a lane.
  */
 export const desktopInputLaneSources = ['option', 'environment', 'driver'] as const;
 /** `driver` means the lane was read from the attached driver instance's manifest instead of being requested here. */
 export type DesktopInputLaneSource = (typeof desktopInputLaneSources)[number];
+/** `host-masked`: this command started the host with the lane's masks. `verified-masked`: a pre-enforcement run checked them. */
+export type DesktopInputLaneMasking = 'host-masked' | 'verified-masked';
 export type DesktopInputLaneReport =
-  | { input: 'accessible'; source: DesktopInputLaneSource; masking: 'host-masked' | 'verified-masked'; policyEnforced: false }
-  | { input: 'physical'; source: DesktopInputLaneSource; policyEnforced: false };
+  | { input: 'accessible'; source: DesktopInputLaneSource; masking?: DesktopInputLaneMasking; policyEnforced: boolean }
+  | { input: 'physical'; source: DesktopInputLaneSource; policyEnforced: boolean };
 export type DesktopSelectionReport = { excluded: SelectionExclusions };
 export type DesktopTestResult = {
   testId: string;
@@ -285,9 +290,14 @@ function describeReason(attempt: Pick<DesktopTestAttempt, 'gap' | 'reason'>): st
   return attempt.gap ? `${gapLabels[attempt.gap]}: ${reason}` : reason;
 }
 
-/** `accessible (host-masked)`, `accessible (verified-masked)` or `physical pilot`; never a claim of enforced input. */
+/** Names the enforced input policy and any extra host mask; physical remains a pilot, not a qualification claim. */
 export function describeDesktopInputLane(lane: DesktopInputLaneReport): string {
-  return lane.input === 'physical' ? 'physical pilot' : `accessible (${lane.masking})`;
+  const held = [
+    ...(lane.policyEnforced ? ['policy-enforced'] : []),
+    ...(lane.input === 'accessible' && lane.masking ? [lane.masking] : []),
+  ];
+  const name = lane.input === 'physical' ? 'physical pilot' : 'accessible';
+  return held.length ? `${name} (${held.join(', ')})` : name;
 }
 
 function describeLaneSource(lane: DesktopInputLaneReport): string {
diff --git a/packages/agentic/desktop-test/src/reporting/runQueries.test.ts b/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
index b04dad2753..6933f3b2f3 100644
--- a/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
+++ b/packages/agentic/desktop-test/src/reporting/runQueries.test.ts
@@ -333,7 +333,8 @@ describe('persisted desktop run queries', () => {
   });
 
   describe('input lane runs', () => {
-    const lane = { input: 'accessible', source: 'environment', masking: 'verified-masked', policyEnforced: false } as const;
+    const lane = { input: 'accessible', source: 'environment', policyEnforced: true } as const;
+    const receipts = { 'accessibility-click': 2 };
     let laneReporter: DesktopRunReporter;
     let laneClient: DesktopRunQueryClient;
 
@@ -348,7 +349,10 @@ describe('persisted desktop run queries', () => {
       service.registerRun({ runId: laneReporter.runId, root: laneReporter.root, expiresAt: Date.now() + 60_000 });
       laneClient = service.connect(service.issueGrant({ runIds: [laneReporter.runId], expiresAt: Date.now() + 60_000 }));
       laneReporter.emit({ kind: 'selection', payload: { excluded: { platform: 1, scope: 2, input: 3 } } });
-      laneReporter.emit({ kind: 'test-result', payload: { testId: 'ok', title: 'ok', attempt: 0, status: 'passed', durationMs: 1 } });
+      laneReporter.emit({
+        kind: 'test-result',
+        payload: { testId: 'ok', title: 'ok', attempt: 0, status: 'passed', durationMs: 1, input: { receipts, unused: ['keyboard'] } },
+      });
       laneReporter.emit({
         kind: 'test-result',
         payload: { testId: 'gap', title: 'gap', attempt: 0, status: 'unsupported', durationMs: 0, reason: 'Declared.', gap: 'quarantine' },
@@ -377,6 +381,8 @@ describe('persisted desktop run queries', () => {
           { title: 'gap', status: 'unsupported', gap: 'quarantine', message: 'Declared.' },
         ],
       });
+      const persisted = JSON.parse(fs.readFileSync(path.join(laneReporter.root, 'run.json'), 'utf8')) as DesktopRunResult;
+      expect(persisted.tests[0].attempts[0].input).toEqual({ receipts, unused: ['keyboard'] });
     });
 
     test('a declared gap edited out of the retained report no longer reads as a passing lane', async () => {
@@ -405,8 +411,23 @@ describe('persisted desktop run queries', () => {
     });
 
     test.each([
-      ['a lane that claims enforcement', (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, policyEnforced: true } })],
-      ['a physical lane with masking', (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, input: 'physical' } })],
+      [
+        'an accessible lane with neither masks nor enforcement',
+        (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, policyEnforced: false } }),
+      ],
+      [
+        'a physical lane with masking',
+        (result: DesktopRunResult) => Object.assign(result, { lane: { ...lane, input: 'physical', masking: 'host-masked' } }),
+      ],
+      [
+        'undeclared input on a passed attempt',
+        (result: DesktopRunResult) =>
+          Object.assign(result.tests[0].attempts[0], { input: { receipts, undeclared: ['accessibility-click'] } }),
+      ],
+      [
+        'an unknown input field',
+        (result: DesktopRunResult) => Object.assign(result.tests[0].attempts[0], { input: { receipts, extra: 1 } }),
+      ],
       [
         'a negative exclusion count',
         (result: DesktopRunResult) => Object.assign(result, { selection: { excluded: { platform: -1, scope: 0, input: 0 } } }),
diff --git a/packages/agentic/desktop-test/src/reporting/runQueries.ts b/packages/agentic/desktop-test/src/reporting/runQueries.ts
index 1f6843a2be..12a5f8d679 100644
--- a/packages/agentic/desktop-test/src/reporting/runQueries.ts
+++ b/packages/agentic/desktop-test/src/reporting/runQueries.ts
@@ -4,8 +4,15 @@ import { createHash, randomUUID } from 'node:crypto';
 import { isNativeError } from 'node:util/types';
 
 import { desktopArtifactPath } from './collector.js';
-import { DesktopReportedError, reportStatuses, redactDesktopSecrets, selectionExclusionReasons, testGaps } from './protocol.js';
-import type { SelectionExclusions, TestGap, TestStatus } from './protocol.js';
+import {
+  DesktopReportedError,
+  reportStatuses,
+  redactDesktopSecrets,
+  selectionExclusionReasons,
+  testGaps,
+  validateTestInputReport,
+} from './protocol.js';
+import type { SelectionExclusions, TestGap, TestInputReport, TestStatus } from './protocol.js';
 import { desktopInputLaneSources, summarizeDesktopRun } from './results.js';
 import type { DesktopInputLaneReport, DesktopRunResult, DesktopSelectionReport } from './results.js';
 
@@ -363,12 +370,19 @@ function parseResult(text: string, runId: string): DesktopRunResult & { terminal
       const gap = attempt.gap;
       if (gap !== undefined && (!testGaps.includes(gap as TestGap) || attempt.status !== 'unsupported'))
         throw new TypeError('Invalid persisted desktop test gap.');
+      let input: TestInputReport | undefined;
+      if (attempt.input !== undefined) {
+        validateTestInputReport(attempt.input);
+        if (attempt.input.undeclared && attempt.status !== 'failed') throw new TypeError('Invalid persisted desktop test input.');
+        input = attempt.input;
+      }
       return {
         attempt: attempt.attempt,
         durationMs: attempt.durationMs,
         status: attempt.status,
         ...(typeof reason === 'string' ? { reason } : {}),
         ...(gap !== undefined ? { gap: gap as TestGap } : {}),
+        ...(input !== undefined ? { input } : {}),
         ...(attempt.failure !== undefined ? { failure: new DesktopReportedError(attempt.failure).failure } : {}),
       };
     });
@@ -416,10 +430,13 @@ function laneField(value: unknown): DesktopInputLaneReport | undefined {
   if (value === undefined) return undefined;
   const lane = record(value);
   const source = desktopInputLaneSources.find((candidate) => candidate === lane.source);
-  if (lane.policyEnforced !== false || source === undefined) throw new TypeError('Invalid persisted desktop input lane.');
-  if (lane.input === 'physical' && lane.masking === undefined) return { input: 'physical', source, policyEnforced: false };
+  const policyEnforced = lane.policyEnforced;
+  if (typeof policyEnforced !== 'boolean' || source === undefined) throw new TypeError('Invalid persisted desktop input lane.');
+  if (lane.input === 'physical' && lane.masking === undefined) return { input: 'physical', source, policyEnforced };
+  // A run recorded before the driver enforced a policy always named its masking, because the masks alone held its lane.
+  if (lane.input === 'accessible' && lane.masking === undefined && policyEnforced) return { input: 'accessible', source, policyEnforced };
   if (lane.input === 'accessible' && (lane.masking === 'host-masked' || lane.masking === 'verified-masked'))
-    return { input: 'accessible', source, masking: lane.masking, policyEnforced: false };
+    return { input: 'accessible', source, masking: lane.masking, policyEnforced };
   throw new TypeError('Invalid persisted desktop input lane.');
 }
 
diff --git a/packages/agentic/desktop-test/src/wdio/configuration.ts b/packages/agentic/desktop-test/src/wdio/configuration.ts
index f16768c542..b52c13597a 100644
--- a/packages/agentic/desktop-test/src/wdio/configuration.ts
+++ b/packages/agentic/desktop-test/src/wdio/configuration.ts
@@ -95,6 +95,8 @@ export async function createDesktopWdioConfiguration(settings: DesktopWdioSettin
         'furn:target': settings.targetId,
         'furn:launchMode': settings.ownership === 'external' ? 'attach' : 'launch',
         'furn:clickMode': resolveDesktopClickMode(undefined, 'auto', selection?.lane),
+        // A lane's session refuses input its lane never delivers; without one, every mechanism stays available.
+        'furn:inputMode': selection?.lane ?? 'compatibility',
       },
     ],
     beforeSession: async (...args: unknown[]) => {
@@ -105,7 +107,12 @@ export async function createDesktopWdioConfiguration(settings: DesktopWdioSettin
       installDesktopWebdriverCommands(browser, settings.url);
       // Before the application is touched: a lane that cannot vouch for its tests must stop here.
       if (settings.framework === 'jasmine') {
-        selectDesktopSpecs(desktopJasmineRegistry(), currentDesktopJasmineEnvironment(), browser.capabilities['furn:features']);
+        selectDesktopSpecs(
+          desktopJasmineRegistry(),
+          currentDesktopJasmineEnvironment(),
+          browser.capabilities['furn:features'],
+          browser.capabilities['furn:inputMode'],
+        );
       }
       if ((await browser.getWindowHandles()).length === 0) throw new Error('Native application did not expose a window.');
       if (readiness?.testId) {
diff --git a/packages/agentic/desktop-test/src/wdio/reporter.ts b/packages/agentic/desktop-test/src/wdio/reporter.ts
index 7379061b54..bef914a414 100644
--- a/packages/agentic/desktop-test/src/wdio/reporter.ts
+++ b/packages/agentic/desktop-test/src/wdio/reporter.ts
@@ -116,6 +116,8 @@ export default class DesktopWdioReporter extends WDIOReporter {
     const gap = notExecuted && entry?.kind === 'gap' ? entry.gap : undefined;
     const missing = notExecuted && entry?.kind === 'run' ? entry.missing : undefined;
     const status = gap || missing?.length ? 'unsupported' : test.state === 'pending' ? 'skipped' : test.state;
+    // A body that called pending() also delivered input, but only an executed test is judged by it.
+    const input = entry?.kind === 'run' && (status === 'passed' || status === 'failed') ? entry.input : undefined;
     this.report(
       {
         kind: 'test-result',
@@ -127,6 +129,7 @@ export default class DesktopWdioReporter extends WDIOReporter {
           durationMs: test.duration,
           ...(gap ? { gap: gap.kind, reason: gap.reason } : {}),
           ...(missing?.length ? { reason: `Missing desktop requirements: ${missing.join(', ')}.` } : {}),
+          ...(input ? { input } : {}),
           ...(status === 'skipped' ? { reason: test.pendingReason || 'Skipped by the test framework.' } : {}),
           ...(status === 'failed'
             ? { failure: this.failure(`${key}/failure`, test.error ?? new AggregateError(test.errors ?? [], 'WDIO test failed.'), 'test') }
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
index ae64781038..6952c743b1 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -1,8 +1,9 @@
+const fs = require('node:fs');
 const { isBuiltin, createRequire } = require('node:module');
 const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
-const { transformFromAstSync, traverse, types } = require('@babel/core');
+const { parseSync, transformFromAstSync, traverse, types } = require('@babel/core');
 const transformTypescript = require('@babel/plugin-transform-typescript');
 
 const nodeGlobals = new Set(
@@ -336,28 +337,184 @@ function directInputCall(call) {
   return undefined;
 }
 
-/**
- * Rejects a case that also runs in the accessible input lane but sends physical input itself: the keyboard commands, the value
- * commands that may type, and WebDriver actions with key, pointer or wheel sources. The check reads literals only. Input sent
- * through a helper or an alias is stopped by the accessible lane's host masks when the case runs.
- */
-function rejectDirectInput(callback, { name, input, inputSource }) {
-  if (input === 'physical') return;
+/** The string a literal `import()`, awaited or not, loads; undefined for anything else. */
+function dynamicImportSource(expression) {
+  expression = unwrap(expression);
+  if (expression?.isAwaitExpression()) expression = unwrap(expression.get('argument'));
+  if (expression?.isImportExpression?.()) {
+    const source = expression.get('source');
+    return source.isStringLiteral() ? source.node.value : undefined;
+  }
+  if (!expression?.isCallExpression() || !types.isImport(expression.node.callee) || expression.node.arguments.length !== 1)
+    return undefined;
+  const source = expression.get('arguments.0');
+  return source.isStringLiteral() ? source.node.value : undefined;
+}
+
+const helperExtensions = /\.(?:[cm]?[jt]s)$/;
+
+/** A relative helper module this check can read, or undefined for a package, a builtin or a file it cannot find. */
+function resolveHelper(specifier, fromFile) {
+  if (!specifier.startsWith('.')) return undefined;
+  try {
+    const resolved = createRequire(path.resolve(fromFile)).resolve(specifier);
+    return helperExtensions.test(resolved) ? resolved : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** The module and export a callee names when it is a helper loaded from a relative module, by static or literal dynamic import. */
+function importedHelper(callee, fromFile) {
+  callee = unwrap(callee);
+  if (callee.isIdentifier()) {
+    const binding = callee.scope.getBinding(callee.node.name);
+    if (binding?.path.isImportSpecifier()) {
+      const imported = binding.path.node.imported;
+      const file = resolveHelper(binding.path.parentPath.node.source.value, fromFile);
+      return file && { file, name: types.isIdentifier(imported) ? imported.name : imported.value };
+    }
+    // const { helper } = await import('./helpers.ts');
+    if (!binding?.path.isVariableDeclarator() || !binding.path.get('id').isObjectPattern()) return undefined;
+    const source = dynamicImportSource(binding.path.get('init'));
+    const file = source && resolveHelper(source, fromFile);
+    if (!file) return undefined;
+    for (const property of binding.path.get('id.properties')) {
+      if (!property.isObjectProperty() || property.node.computed) continue;
+      if (types.isIdentifier(property.node.value, { name: callee.node.name })) return { file, name: keyName(property) };
+    }
+    return undefined;
+  }
+  if (!callee.isMemberExpression() && !callee.isOptionalMemberExpression()) return undefined;
+  const name = memberName(callee);
+  const object = unwrap(callee.get('object'));
+  // (await import('./helpers.ts')).helper(), helpers.helper() after `const helpers = await import(...)`, or a namespace import.
+  let source = dynamicImportSource(object);
+  if (source === undefined && object.isIdentifier()) {
+    const binding = object.scope.getBinding(object.node.name);
+    if (binding?.path.isVariableDeclarator() && binding.path.get('id').isIdentifier())
+      source = dynamicImportSource(binding.path.get('init'));
+    else if (binding?.path.isImportNamespaceSpecifier()) source = binding.path.parentPath.node.source.value;
+  }
+  const file = name && source !== undefined ? resolveHelper(source, fromFile) : undefined;
+  return file && { file, name };
+}
+
+/** Reads a helper module once per check: its top-level functions, and the exports that name them. */
+function readHelperModule(file, context) {
+  if (context.modules.has(file)) return context.modules.get(file);
+  let helper = null;
+  try {
+    const ast = parseSync(fs.readFileSync(file, 'utf8'), {
+      babelrc: false,
+      configFile: false,
+      filename: file,
+      sourceType: 'module',
+      parserOpts: { plugins: ['typescript'] },
+    });
+    let program;
+    traverse(ast, {
+      Program(found) {
+        program = found;
+        found.stop();
+      },
+    });
+    helper = { file, program, functions: new Map(), exports: new Map() };
+    for (const statement of program.get('body')) {
+      const exported = statement.isExportNamedDeclaration();
+      const declaration = exported ? statement.get('declaration') : statement;
+      if (declaration.isFunctionDeclaration() && declaration.node.id) {
+        helper.functions.set(declaration.node.id.name, declaration);
+        if (exported) helper.exports.set(declaration.node.id.name, declaration.node.id.name);
+      } else if (declaration.isVariableDeclaration()) {
+        for (const declarator of declaration.get('declarations')) {
+          const init = declarator.node.init ? unwrap(declarator.get('init')) : undefined;
+          if (!declarator.get('id').isIdentifier() || !(init?.isFunctionExpression() || init?.isArrowFunctionExpression())) continue;
+          helper.functions.set(declarator.node.id.name, init);
+          if (exported) helper.exports.set(declarator.node.id.name, declarator.node.id.name);
+        }
+      }
+      if (exported && !statement.node.source) {
+        for (const specifier of statement.get('specifiers')) {
+          if (!specifier.isExportSpecifier()) continue;
+          const exportedName = types.isIdentifier(specifier.node.exported) ? specifier.node.exported.name : specifier.node.exported.value;
+          helper.exports.set(exportedName, specifier.node.local.name);
+        }
+      }
+    }
+  } catch {
+    // A helper this check cannot parse is left to the run-time policy, like any other input it cannot see.
+    helper = null;
+  }
+  context.modules.set(file, helper);
+  return helper;
+}
+
+/** The first physical input a helper function sends, directly or through the helpers it calls. Cycles end at the first visit. */
+function helperFunctionInput(helper, name, context) {
+  const key = `${helper.file}#${name}`;
+  if (!helper.functions.has(name)) return undefined;
+  if (context.functions.has(key)) return context.functions.get(key);
+  context.functions.set(key, undefined);
+  const found = findPhysicalInput(helper.functions.get(name), helper.file, context, helper);
+  context.functions.set(key, found);
+  return found;
+}
+
+/** A call to a helper that sends physical input, as the chain of helpers that leads to the call that sends it. */
+function helperInputCall(call, fromFile, context, helper) {
+  const callee = unwrap(call.get('callee'));
+  let target = importedHelper(callee, fromFile);
+  let local;
+  if (target) {
+    const imported = readHelperModule(target.file, context);
+    local = imported && { helper: imported, name: imported.exports.get(target.name) };
+  } else if (helper && callee.isIdentifier() && helper.functions.has(callee.node.name)) {
+    // Another function in the same helper module, unless a local binding shadows it.
+    if (callee.scope.getBinding(callee.node.name)?.scope !== helper.program.scope) return undefined;
+    target = { name: callee.node.name };
+    local = { helper, name: callee.node.name };
+  }
+  if (!local?.name) return undefined;
+  const found = helperFunctionInput(local.helper, local.name, context);
+  return found && { call: found.call, requires: found.requires, via: [target.name, ...(found.via ?? [])] };
+}
+
+/** The first call under `root` that sends physical input, directly or through a relative helper module. */
+function findPhysicalInput(root, file, context, helper) {
   let finding;
-  callback.traverse({
+  root.traverse({
     'CallExpression|OptionalCallExpression'(call) {
-      const found = finding ? undefined : directInputCall(call);
-      if (found) finding = { ...found, path: call };
+      if (finding) return;
+      const found = directInputCall(call) ?? (file ? helperInputCall(call, file, context, helper) : undefined);
+      if (found) {
+        finding = { ...found, path: call };
+        call.stop();
+      }
     },
   });
+  return finding;
+}
+
+/**
+ * Rejects a case that also runs in the accessible input lane but sends physical input: the keyboard commands, the value
+ * commands that may type, and WebDriver actions with key, pointer or wheel sources, called directly or through a helper
+ * imported from a relative module. The check reads literals only. Input sent through an alias or a package helper is
+ * refused by the accessible lane's input policy when the case runs, and the case's receipts are checked against its
+ * declaration in every lane.
+ */
+function rejectDirectInput(callback, { name, input, inputSource, sourceFile }) {
+  if (input === 'physical') return;
+  const finding = findPhysicalInput(callback, sourceFile, { modules: new Map(), functions: new Map() });
   if (!finding) return;
   const subject = name ? `"${name}"` : 'This case';
   const declared = inputSource === 'declared';
+  const caller = finding.via ? `helper ${finding.via.join(' > ')} calls ${finding.call}` : `calls ${finding.call}`;
   if (finding.requires === undefined) {
     const declaration = declared ? "input: 'physical'" : 'requires for the physical input it sends (keyboard, physical-click or wheel)';
     fail(
       finding.path,
-      `${subject} runs in the accessible input lane, but calls ${finding.call} with an argument this check cannot read. ` +
+      `${subject} runs in the accessible input lane, but ${caller} with an argument this check cannot read. ` +
         `Pass a literal list of input sources, or declare ${declaration}.`,
     );
   }
@@ -365,9 +522,12 @@ function rejectDirectInput(callback, { name, input, inputSource }) {
   const declaration = declared
     ? "input: 'physical'"
     : `requires: [${finding.requires.map((requirement) => `'${requirement}'`).join(', ')}]`;
+  const sender = finding.via
+    ? `helper ${finding.via.join(' > ')} sends physical ${kinds} input with ${finding.call}`
+    : `${finding.call} sends physical ${kinds} input`;
   fail(
     finding.path,
-    `${subject} runs in the accessible input lane, but ${finding.call} sends physical ${kinds} input. ` +
+    `${subject} runs in the accessible input lane, but ${sender}. ` +
       `Declare ${declaration} so it runs only in the physical lane, or remove the call.`,
   );
 }
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
index e620c955b8..d9d464e526 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -18,7 +18,13 @@ declare namespace storyTests {
   function compileWdioTest(callback: Callback['callback'], sourceFile: string, source: string): string;
   function rejectDirectInput(
     callback: Callback['callback'],
-    descriptor: { name?: string; input: 'accessible' | 'physical' | 'both'; inputSource: 'declared' | 'derived' },
+    descriptor: {
+      name?: string;
+      input: 'accessible' | 'physical' | 'both';
+      inputSource: 'declared' | 'derived';
+      /** The story file, so helpers imported from relative modules are followed. */
+      sourceFile?: string;
+    },
   ): void;
 }
 
diff --git a/packages/agentic/storybook-desktop/references/commands.md b/packages/agentic/storybook-desktop/references/commands.md
index a82fa228d0..34ea5326e9 100644
--- a/packages/agentic/storybook-desktop/references/commands.md
+++ b/packages/agentic/storybook-desktop/references/commands.md
@@ -69,9 +69,10 @@ resolved input, target platform, and scope. Without a flag the lane comes from
 `DESKTOP_INPUT`, then from the driver instance a `test` attaches to; none of them
 means compatibility mode, which runs every case as before. `driver --input`
 starts the driver for that lane and records it for subsequent tests against the
-instance. An `accessible` driver masks keyboard, physical click, and wheel, and
-`test --input accessible` verifies the mask before running anything: a driver
-that is not masked fails the run rather than letting a case move the pointer.
+instance. Each test session confirms its strict input policy before running;
+the accessible policy rejects keyboard, pointer, and wheel input before
+dispatch. An accessible driver also masks those host features as defense in
+depth, but a test can attach to an unmasked driver.
 Legacy callback collections are not eligible for input-lane runs. Input lanes
 cannot be combined with an explicit non-`auto` click mode. See
 [story tests](story-tests.md#run-an-input-lane).
diff --git a/packages/agentic/storybook-desktop/references/story-tests.md b/packages/agentic/storybook-desktop/references/story-tests.md
index 438c0e09a7..2f4b5a3025 100644
--- a/packages/agentic/storybook-desktop/references/story-tests.md
+++ b/packages/agentic/storybook-desktop/references/story-tests.md
@@ -180,15 +180,19 @@ non-default `--click-mode`. `test --list` shows, for each story, the cases the
 lane runs with their resolved input, requirements, platforms, and scope, and the
 cases it excludes with the reason; add `--input` to preview a lane.
 
-The accessible lane holds a case to accessible input by masking the host, not by
-trusting the case: the driver reports keyboard, physical click, and wheel as
-unavailable, so a case that tries them fails instead of silently moving the
-pointer. `smoke` and `driver --input accessible` start the driver already
-masked. `test --input accessible` attaches to a running driver and verifies the
-mask from the session's reported features before it runs anything. A driver that
-does not report all three as unavailable stops the run as an infrastructure
-failure rather than running unmasked, so attach the lane to a driver started
-with `driver --input accessible`.
+Each case session confirms its `furn:inputMode` before the callback runs. The
+accessible mode refuses keyboard, pointer, and wheel input before dispatch; the
+physical mode pins clicks to the pointer while allowing accessibility actions.
+`smoke` and `driver --input accessible` also mask the host as defense in depth,
+but `test --input accessible` can safely attach to an unmasked driver because
+the session policy is enforced independently. Before teardown, the runner reads
+the session's delivery receipts and fails a case if it delivered a mechanism
+not covered by its `requires`; unused requirements are reported, not failed.
+
+In an accessible session, `browser.$(...).setValue(...)` is rejected before
+WDIO's client-side clear step, which could otherwise change the field before
+keyboard input is refused. `clearValue()` remains available and uses a semantic
+clear.
 
 A lane that executes no case is not a passing run, and neither is a lane run
 that leaves a case unsupported or skipped without a declared gap. Excluded cases
diff --git a/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts b/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
index 1d9202f145..dd473bf24e 100644
--- a/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/inputLane.test.ts
@@ -37,23 +37,22 @@ describe('command input lane', () => {
     expect(driverInput).not.toHaveBeenCalled();
   });
 
-  test('labels how an accessible lane is masked by who owns the driver, and never a physical lane', () => {
+  test('enforces every lane by policy, and records host masks only where smoke started the driver', () => {
     expect(resolveCommandInputLane({ command: 'smoke', runsTests: true, flag: 'accessible' })).toEqual({
       input: 'accessible',
       source: 'option',
       masking: 'host-masked',
-      policyEnforced: false,
+      policyEnforced: true,
     });
     expect(resolveCommandInputLane({ command: 'test', runsTests: true, flag: 'accessible' })).toEqual({
       input: 'accessible',
       source: 'option',
-      masking: 'verified-masked',
-      policyEnforced: false,
+      policyEnforced: true,
     });
     expect(resolveCommandInputLane({ command: 'smoke', runsTests: true, flag: 'physical' })).toEqual({
       input: 'physical',
       source: 'option',
-      policyEnforced: false,
+      policyEnforced: true,
     });
   });
 
diff --git a/packages/agentic/storybook-desktop/src/cli/inputLane.ts b/packages/agentic/storybook-desktop/src/cli/inputLane.ts
index 8a6e36dd39..7665c5a512 100644
--- a/packages/agentic/storybook-desktop/src/cli/inputLane.ts
+++ b/packages/agentic/storybook-desktop/src/cli/inputLane.ts
@@ -20,12 +20,12 @@ export type CommandInputLaneRequest = {
 /**
  * The lane a `test` or `smoke` run holds its tests to, and where it came from: `--input`, then `DESKTOP_INPUT`, then
  * the driver instance `test` attaches to. No lane is compatibility mode, which keeps the behavior from before lanes.
- * An accessible lane's masking depends on who owns the driver: `smoke` starts it masked, while `test` attaches to one
- * and verifies the mask before it runs anything.
+ * Every session confirms the lane's input policy. `smoke` also starts its driver masked for an accessible lane, while
+ * `test` attaches to whatever driver is running and relies on the policy alone.
  */
 export function resolveCommandInputLane(request: CommandInputLaneRequest): DesktopInputLaneReport | undefined {
   if (!request.runsTests) return undefined;
-  const masking = request.command === 'smoke' ? 'host-masked' : 'verified-masked';
+  const masking = request.command === 'smoke' ? 'host-masked' : undefined;
   const requested = requestedDesktopInputLane({ flag: request.flag, environment: request.environment });
   if (requested) return createDesktopInputLane(requested.input, requested.source, masking);
   const input = request.driverInput?.();
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
index 16766657bb..0d97f22c38 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -1,5 +1,7 @@
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
 import { createRequire } from 'node:module';
+import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import vm from 'node:vm';
@@ -390,6 +392,101 @@ describe('extractWdioTests', () => {
       expect(() => extractWdioTests(desktopCase(body), sourceFile)).not.toThrow();
     });
 
+    describe('through relative helpers', () => {
+      let root: string;
+      let story: string;
+
+      beforeAll(() => {
+        root = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-wdio-helpers-'));
+        story = path.join(root, 'components', 'example.stories.tsx');
+        fs.mkdirSync(path.join(root, 'common'));
+        fs.mkdirSync(path.join(root, 'components'));
+        fs.writeFileSync(
+          path.join(root, 'common', 'focus.wdio.ts'),
+          `import type { Browser } from 'webdriverio';
+          export async function expectFocused(browser: Browser, id: string): Promise<void> { await browser.$(id); }
+          export async function focusByTab(browser: Browser, id: string): Promise<void> {
+            await expectFocused(browser, id);
+            await browser.keys('\\uE004');
+          }
+          export async function tabTwice(browser: Browser): Promise<void> { await focusByTab(browser, 'a'); }
+          export async function perform(browser: Browser, actions: never[]): Promise<void> { await browser.performActions(actions); }
+          export const clickPhysical = async (browser: Browser) => {
+            await browser.performActions([${pointer}]);
+          };
+          async function loop(browser: Browser): Promise<void> { await again(browser); }
+          async function again(browser: Browser): Promise<void> { await loop(browser); }
+          export { loop as cycle };
+          export const label = 'not a function';`,
+        );
+        fs.writeFileSync(
+          path.join(root, 'components', 'menu.wdio.ts'),
+          `export async function openFromKeyboard(context: { browser: unknown }): Promise<void> {
+            const { focusByTab } = await import('../common/focus.wdio.ts');
+            await focusByTab(context.browser as never, 'entry');
+          }
+          export { expectFocused } from '../common/focus.wdio.ts';`,
+        );
+      });
+
+      afterAll(() => fs.rmSync(root, { recursive: true, force: true }));
+
+      test.each([
+        [
+          'a destructured helper',
+          `const { focusByTab } = await import('../common/focus.wdio.ts'); await focusByTab(browser, 'entry');`,
+          /helper focusByTab sends physical keyboard input with browser\.keys.*requires: \['keyboard'\]/,
+        ],
+        [
+          'a helper called on the awaited module',
+          `await (await import('../common/focus.wdio.ts')).clickPhysical(browser);`,
+          /helper clickPhysical sends physical pointer input with performActions.*requires: \['physical-click'\]/,
+        ],
+        [
+          'a helper called on a module binding',
+          `const focus = await import('../common/focus.wdio.ts'); await focus.focusByTab(browser, 'entry');`,
+          /helper focusByTab sends physical keyboard input/,
+        ],
+        [
+          'a helper that calls another helper in its module',
+          `const { tabTwice } = await import('../common/focus.wdio.ts'); await tabTwice(browser);`,
+          /helper tabTwice > focusByTab sends physical keyboard input/,
+        ],
+        [
+          'a helper whose actions it cannot read',
+          `const { perform } = await import('../common/focus.wdio.ts'); await perform(browser, []);`,
+          /helper perform calls performActions with an argument this check cannot read/,
+        ],
+        [
+          'a helper that imports another helper',
+          `const { openFromKeyboard } = await import('./menu.wdio.ts'); await openFromKeyboard(context);`,
+          /helper openFromKeyboard > focusByTab sends physical keyboard input with browser\.keys/,
+        ],
+      ])('rejects %s that sends physical input', (_name, body, message) => {
+        expect(() => extractWdioTests(desktopCase(body), story)).toThrow(message);
+      });
+
+      test.each([
+        [
+          'a helper that sends no input',
+          `const { expectFocused } = await import('../common/focus.wdio.ts'); await expectFocused(browser, 'a');`,
+        ],
+        ['helpers that call each other in a cycle', `const { cycle } = await import('../common/focus.wdio.ts'); await cycle(browser);`],
+        [
+          'a re-exported helper, which the check does not follow',
+          `const { expectFocused } = await import('./menu.wdio.ts'); await expectFocused(browser, 'a');`,
+        ],
+        ['a package helper', `const { join } = await import('node:path'); join('a');`],
+      ])('allows %s', (_name, body) => {
+        expect(() => extractWdioTests(desktopCase(body), story)).not.toThrow();
+      });
+
+      test('allows a helper that sends input in a case that declares it', () => {
+        const body = `const { focusByTab } = await import('../common/focus.wdio.ts'); await focusByTab(browser, 'entry');`;
+        expect(() => extractWdioTests(desktopCase(body, `{ requires: ['keyboard'] }`), story)).not.toThrow();
+      });
+    });
+
     test('does not read legacy callbacks, which declare no input', () => {
       expect(() =>
         extractWdioTests(`export const Example = { wdio: { legacy: async ({ browser }) => { await browser.keys('a'); } } };`, sourceFile),
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
index 4bf2066810..eb18f658fd 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -30,7 +30,7 @@ export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<
                 const compiledCode = compileWdioTest(callback, sourceFile, code);
                 const descriptor = options === undefined ? undefined : validateDesktopCaseOptions(options, `${sourceFile}.wdio`);
                 if (descriptor !== undefined) {
-                  rejectDirectInput(callback, { name, input: descriptor.input, inputSource: descriptor.inputSource });
+                  rejectDirectInput(callback, { name, input: descriptor.input, inputSource: descriptor.inputSource, sourceFile });
                 }
                 return {
                   ...(name === undefined ? {} : { name }),
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
index 524bd88ae3..87c5941294 100644
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -5,14 +5,15 @@ import { pathToFileURL } from 'node:url';
 
 import type { DesktopStoryManifest } from '@fluentui-react-native/desktop-driver';
 import {
+  compareDesktopInputReceipts,
+  describeUndeclaredDesktopInput,
   missingDesktopRequirements,
   resolveDesktopClickMode,
-  unmaskedAccessibleFeatures,
   type DesktopArtifact,
 } from '@fluentui-react-native/desktop-driver/authoring';
 import { ArtifactManager, captureDesktopFailureEvidence } from '@fluentui-react-native/desktop-driver/artifacts';
 import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
-import type { DesktopReportWriter } from '@fluentui-react-native/desktop-test/reporting';
+import type { DesktopReportWriter, TestInputReport } from '@fluentui-react-native/desktop-test/reporting';
 import { DesktopReportedError } from '@fluentui-react-native/desktop-test/reporting';
 
 import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
@@ -40,6 +41,8 @@ export type WdioStoryTestResult = {
   error?: string;
   skipReason?: string;
   gap?: 'unsupported' | 'quarantine';
+  /** The input the case's session delivered, judged against its declaration when it has one. */
+  input?: TestInputReport;
   evidenceErrors?: string[];
   artifacts?: readonly DesktopArtifact[];
 };
@@ -78,15 +81,34 @@ class MissingRequirementsError extends Error {
   }
 }
 
-/** The driver cannot show it disabled physical input, so an accessible lane could not keep its guarantee. */
-class UnmaskedLaneError extends Error {
-  constructor(unmasked: readonly string[]) {
+/** The session did not confirm the input policy it was created with, so no case it runs can be held to that policy. */
+class InputPolicyError extends Error {
+  constructor(requested: string, confirmed: unknown) {
     super(
-      `The accessible input lane needs a driver that reports ${unmasked.join(', ')} disabled, and this one does not. Start it with "driver --input accessible".`,
+      `The driver did not confirm the ${requested} input policy (it reported ${typeof confirmed === 'string' ? confirmed : 'none'}). Restart "storybook driver" from this version of storybook-desktop.`,
     );
   }
 }
 
+/** The case delivered input its declaration does not account for. */
+class UndeclaredInputError extends Error {}
+
+/**
+ * Reads what the case's session delivered and judges it against the declaration; a legacy callback declares nothing to
+ * judge. Only a case that ran to completion reports declarations it did not use, since one that stopped early could not.
+ */
+async function readDeliveredInput(
+  desktop: Awaited<ReturnType<typeof connectDesktopWebdriver>>,
+  descriptor: Parameters<typeof compareDesktopInputReceipts>[0],
+  clickMode: ReturnType<typeof resolveDesktopClickMode>,
+  completed: boolean,
+): Promise<TestInputReport> {
+  const { receipts } = await desktop.input();
+  if (!descriptor) return { receipts };
+  const { undeclared, unused } = compareDesktopInputReceipts(descriptor, receipts, clickMode);
+  return { receipts, ...(undeclared.length ? { undeclared } : {}), ...(completed && unused.length ? { unused } : {}) };
+}
+
 export async function runWdioStoryTests(
   options: RunWdioStoryTestsOptions,
   runner?: DesktopCommandRunner,
@@ -194,9 +216,11 @@ export async function runWdioStoryTests(
         continue;
       }
       const clickMode = resolveDesktopClickMode(descriptor, settings.clickMode, settings.input);
+      const inputMode = settings.input ?? 'compatibility';
       // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
       const desktop = await connectDesktopWebdriver({
         clickMode,
+        inputMode,
         launchMode: 'attach',
         platformName: options.platform === 'macos' ? 'macos' : 'windows',
         targetId: options.targetId,
@@ -209,12 +233,11 @@ export async function runWdioStoryTests(
         if (live.endpoint !== options.platform || live.platformManifestDigest !== options.manifest.platformManifestDigest) {
           throw new Error('The running Storybook manifest is stale or targets a different platform. Restart storybook driver and the app.');
         }
-        if (settings.input === 'accessible') {
-          // A driver that cannot report its physical input disabled fails closed rather than silently running unmasked.
-          phase = 'lane verification';
-          const unmasked = unmaskedAccessibleFeatures(desktop.browser.capabilities['furn:features']);
-          if (unmasked.length) throw new UnmaskedLaneError(unmasked);
-        }
+        // The driver refuses input outside the policy before dispatch, so a lane holds even on a host with no masks. A
+        // driver that does not confirm the policy fails closed rather than running cases it cannot hold or attribute.
+        phase = 'input policy verification';
+        const confirmed = desktop.browser.capabilities['furn:inputMode'];
+        if (confirmed !== inputMode) throw new InputPolicyError(inputMode, confirmed);
         const missing = missingDesktopRequirements(descriptor, desktop.browser.capabilities['furn:features'], clickMode);
         if (missing.length) throw new MissingRequirementsError(missing);
         phase = 'navigation';
@@ -268,12 +291,23 @@ export async function runWdioStoryTests(
         if (outcome.status === 'skipped') {
           result.skipReason = outcome.skipReason;
         }
+        // Read before teardown: the receipts belong to the session and end with it.
+        phase = 'input verification';
+        result.input = await readDeliveredInput(desktop, descriptor, clickMode, outcome.status === 'passed');
+        if (result.input.undeclared) throw new UndeclaredInputError(describeUndeclaredDesktopInput(result.input.undeclared));
       } catch (error) {
         if (error instanceof MissingRequirementsError) {
           result.status = 'unsupported';
           result.skipReason = error.message;
-        } else if (error instanceof UnmaskedLaneError) {
+        } else if (error instanceof InputPolicyError) {
           failure = error;
+        } else if (error instanceof UndeclaredInputError) {
+          // The case ran as written, so there is no application state to capture; the declaration is what is wrong.
+          failure = error;
+          result.status = 'failed';
+          executionFailures.push(error);
+          result.error = error.message;
+          writeDesktopStorybookFailure(`wdio "${displayName}" during ${phase}`, error, options.errorOutput);
         } else {
           failure = error;
           executionFailures.push(error);
@@ -297,6 +331,8 @@ export async function runWdioStoryTests(
             options.report?.fail(new Error(evidenceError), 'evidence', testId);
             writeDesktopStorybookFailure(`evidence for "${displayName}"`, evidenceError, options.errorOutput);
           }
+          // What a failed case delivered attributes the failure. A session that cannot answer leaves it unknown.
+          if (phase === 'execution') result.input = await readDeliveredInput(desktop, descriptor, clickMode, false).catch(() => undefined);
         }
       }
       phase = 'session cleanup';
@@ -310,8 +346,8 @@ export async function runWdioStoryTests(
         );
       }
       // Every case would fail the same way, so stop here and let the run report it once, against this case.
-      if (failure instanceof UnmaskedLaneError) {
-        phase = 'lane verification';
+      if (failure instanceof InputPolicyError) {
+        phase = 'input policy verification';
         throw failure;
       }
       result.durationMs = Date.now() - started;
@@ -326,6 +362,7 @@ export async function runWdioStoryTests(
             status: result.status,
             durationMs: result.durationMs,
             ...(['skipped', 'unsupported'].includes(result.status) ? { reason: result.skipReason } : {}),
+            ...(result.input ? { input: result.input } : {}),
             ...(failure !== undefined ? { failure: options.report.failure(failure, 'test') } : {}),
           },
         },
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index 3736a9666e..1110dec188 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -1,5 +1,7 @@
+const assert = require('node:assert/strict');
 const { spawn } = require('node:child_process');
 const fs = require('node:fs');
+const http = require('node:http');
 const os = require('node:os');
 const path = require('node:path');
 const { pathToFileURL } = require('node:url');
@@ -100,6 +102,22 @@ async function main() {
         await expect(await browser.$('~button-primary')).toBeEnabled();
       }),
     ]};
+    export const Receipts = { wdio: [
+      desktopIt('declared click', { requires: ['click'] }, async ({ browser }) => {
+        await (await browser.$('~button-primary')).click();
+      }),
+      desktopIt('undeclared click', async ({ browser }) => {
+        await (await browser.$('~button-primary')).click();
+      }),
+      desktopIt('unused keyboard', { requires: ['keyboard'] }, async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      }),
+      // An alias hides the keyboard from the authoring check, so only the run-time policy and receipts can catch it.
+      desktopIt('typing', { requires: ['click'] }, async ({ browser }) => {
+        const driver = browser;
+        await driver.keys(['Tab']);
+      }),
+    ]};
   `,
   );
   const storyPackage = { name: 'inline-fixture', root, manifest: { name: 'inline-fixture' }, storyPatterns: ['*.stories.ts'] };
@@ -339,22 +357,55 @@ async function main() {
       await restrictedButtonHarness.close();
     }
     const laneResults = (results) => results.map(({ testName, status }) => ({ testName, status }));
-    // The accessible lane trusts the driver's own report, so a driver that does not show physical input disabled fails closed.
-    const unmaskedReport = new DesktopRunReporter({
+    // The driver enforces the lane's policy itself, so an accessible lane holds on a driver with physical input enabled.
+    const unmaskedLane = laneResults(await run('lane', { input: 'accessible' }));
+    // A driver that does not confirm the policy fails closed: it could neither hold the lane nor attribute its input.
+    const unconfirmedProxy = await createUnconfirmingProxy(harness.server.url);
+    const unconfirmedReport = new DesktopRunReporter({
       artifactsRoot: path.join(root, 'lane-reports'),
-      lane: { input: 'accessible', source: 'option', masking: 'host-masked', policyEnforced: false },
+      lane: { input: 'accessible', source: 'option', policyEnforced: true },
       summary: false,
     });
-    let unmaskedLane;
+    let unconfirmedLane;
     try {
-      await run('lane', { input: 'accessible', report: unmaskedReport });
-      throw new Error('An accessible lane must not run against a driver that reports physical input enabled.');
+      await run('lane', { input: 'accessible', report: unconfirmedReport, url: unconfirmedProxy.url });
+      throw new Error('An accessible lane must not run against a driver that does not confirm its input policy.');
     } catch (error) {
       if (!(error instanceof Error) || !(error instanceof WdioStoryTestRunError) || !('results' in error) || !Array.isArray(error.results))
         throw error;
-      unmaskedLane = { results: laneResults(error.results), message: error.message };
+      unconfirmedLane = { results: laneResults(error.results), message: error.message };
+    } finally {
+      await unconfirmedProxy.close();
     }
-    const unmaskedLaneResult = await unmaskedReport.finish();
+    const unconfirmedLaneResult = await unconfirmedReport.finish();
+    // Receipts hold every declared case to what it says, in compatibility mode as in a lane, and the report keeps them.
+    const receiptResults = async (input) => {
+      const report = new DesktopRunReporter({
+        artifactsRoot: path.join(root, 'receipt-reports'),
+        ...(input ? { lane: { input, source: 'option', policyEnforced: true } } : {}),
+        summary: false,
+      });
+      let results;
+      try {
+        await run('receipts', { report, ...(input ? { input } : {}) });
+        throw new Error('Expected undeclared input to fail.');
+      } catch (error) {
+        if (
+          !(error instanceof Error) ||
+          !(error instanceof WdioStoryTestRunError) ||
+          !('results' in error) ||
+          !Array.isArray(error.results)
+        )
+          throw error;
+        results = error.results;
+      }
+      const reported = await report.finish();
+      return results.map(({ testName, status, input: delivered, error }) => {
+        assert.deepEqual(reported.tests.find(({ title }) => title.endsWith(` / ${testName}`))?.attempts[0].input, delivered);
+        return { testName, status, input: delivered, ...(error ? { error } : {}) };
+      });
+    };
+    const receipts = { compatibility: await receiptResults(), accessible: await receiptResults('accessible') };
     const maskedHarness = await createDesktopDriverStoryHarness(manifest, {
       features: { keyboard: false, physicalClick: false, wheel: false },
     });
@@ -394,14 +445,16 @@ async function main() {
             accessible: accessibleLane,
             physical: physicalLane,
             compatibility: compatibilityLane,
-            unmasked: {
-              ...unmaskedLane,
-              status: unmaskedLaneResult.status,
-              failed: unmaskedLaneResult.counts.failed,
-              excluded: unmaskedLaneResult.selection?.excluded,
-              reported: unmaskedLaneResult.failures.map(({ error }) => error.message),
+            unmasked: unmaskedLane,
+            unconfirmed: {
+              ...unconfirmedLane,
+              status: unconfirmedLaneResult.status,
+              failed: unconfirmedLaneResult.counts.failed,
+              excluded: unconfirmedLaneResult.selection?.excluded,
+              reported: unconfirmedLaneResult.failures.map(({ error }) => error.message),
             },
           },
+          receipts,
           platforms,
           namedFailureResults: namedFailureResults.map(({ testName, status }) => ({ testName, status })),
           namedTimeout,
@@ -418,6 +471,39 @@ async function main() {
   }
 }
 
+/** Forwards to a driver but drops the input policy from each new session, as a driver from before enforcement would. */
+async function createUnconfirmingProxy(url) {
+  const server = http.createServer(async (request, response) => {
+    const chunks = [];
+    for await (const chunk of request) chunks.push(chunk);
+    const body = Buffer.concat(chunks);
+    const reply = await fetch(new URL(request.url, url), {
+      method: request.method,
+      headers: { 'content-type': 'application/json' },
+      ...(body.length ? { body } : {}),
+    });
+    let text = await reply.text();
+    if (request.method === 'POST' && request.url === '/session' && reply.ok) {
+      const created = JSON.parse(text);
+      delete created.value.capabilities['furn:inputMode'];
+      text = JSON.stringify(created);
+    }
+    response.writeHead(reply.status, { 'content-type': 'application/json' });
+    response.end(text);
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(undefined)));
+  const { port } = /** @type {import('node:net').AddressInfo} */ (server.address());
+  return {
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- test proxy only binds to loopback
+    url: `http://127.0.0.1:${port}`,
+    close: () =>
+      new Promise((resolve) => {
+        server.closeAllConnections();
+        server.close(resolve);
+      }),
+  };
+}
+
 /** @returns {Promise<{code: number | null, stdout: string, stderr: string}>} */
 function runSmokeControl(packageRoot, cwd, manifestPath) {
   return new Promise((resolve, reject) => {
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index dc74dfdf44..0365095295 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -23,7 +23,7 @@ test('executes isolated inline code and releases sessions after assertion failur
           !diagnostics.includes('wdio "fixture-button--fail" during execution') ||
           !diagnostics.includes('wdio "fixture-button--navigation-failure" during navigation') ||
           !diagnostics.includes('Storybook context did not settle.') ||
-          !diagnostics.includes('wdio "fixture-button--lane / accessible only" during lane verification') ||
+          !diagnostics.includes('wdio "fixture-button--lane / accessible only" during input policy verification') ||
           diagnostics.includes('Navigation refused before dispatch') ||
           output.includes('[storybook] OK wdio "fixture-button--exit-zero"')
         ) {
@@ -79,15 +79,54 @@ test('executes isolated inline code and releases sessions after assertion failur
         { testName: 'either lane', status: 'passed' },
         { testName: 'physical only', status: 'unsupported' },
       ],
-      // A driver that does not report physical input disabled stops the lane at its first case, reported once.
-      unmasked: {
+      // The driver holds the policy, so an accessible lane runs on a driver with physical input enabled.
+      unmasked: [
+        { testName: 'accessible only', status: 'passed' },
+        { testName: 'either lane', status: 'passed' },
+      ],
+      // A driver that does not confirm the policy stops the lane at its first case, reported once.
+      unconfirmed: {
         results: [{ testName: 'accessible only', status: 'failed' }],
         status: 'failed',
         failed: 1,
         excluded: { platform: 0, scope: 0, input: 1 },
-        reported: [expect.stringContaining('driver --input accessible')],
+        reported: [expect.stringContaining('did not confirm the accessible input policy (it reported none)')],
       },
     },
+    receipts: {
+      // Compatibility mode delivers what the host has, and still holds each declared case to its declaration.
+      compatibility: [
+        { testName: 'declared click', status: 'passed', input: { receipts: { 'physical-click': 1 } } },
+        {
+          testName: 'undeclared click',
+          status: 'failed',
+          input: { receipts: { 'physical-click': 1 }, undeclared: ['physical-click'] },
+          error: 'The test delivered input it does not declare: physical-click (declare physical-click or click).',
+        },
+        { testName: 'unused keyboard', status: 'passed', input: { receipts: {}, unused: ['keyboard'] } },
+        {
+          testName: 'typing',
+          status: 'failed',
+          input: { receipts: { keyboard: 1 }, undeclared: ['keyboard'] },
+          error: 'The test delivered input it does not declare: keyboard (declare keyboard).',
+        },
+      ],
+      // The accessible lane clicks semantically and refuses typing before it is delivered, so nothing is attributed to it.
+      accessible: [
+        { testName: 'declared click', status: 'passed', input: { receipts: { 'accessibility-click': 1 } } },
+        {
+          testName: 'undeclared click',
+          status: 'failed',
+          input: { receipts: { 'accessibility-click': 1 }, undeclared: ['accessibility-click'] },
+        },
+        {
+          testName: 'typing',
+          status: 'failed',
+          input: { receipts: {} },
+          error: expect.stringContaining('never delivers'),
+        },
+      ],
+    },
     platforms: Object.fromEntries(
       ['macos', 'windows', 'win32'].map((platform) => [
         platform,

From e93f977fc11d1538228b12e0a4c07976baf89f7f Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Sun, 8 Nov 2026 01:20:16 -0800
Subject: [PATCH 5/6] Isolate mocked native input tests from CI host masks

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../src/hosts/native/NativeDesktopHost.input.test.ts       | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
index c765306f35..dcc214dc20 100644
--- a/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
+++ b/packages/agentic/desktop-driver/src/hosts/native/NativeDesktopHost.input.test.ts
@@ -3,7 +3,7 @@ import type { NativeDriverArtifact } from '../../native/types';
 import { readFailureEffect } from '../../protocol/settlement';
 import { scriptNativeHelper } from '../../testing/scriptedNativeHelper';
 import type { ScriptedNativeRequest } from '../../testing/scriptedNativeHelper';
-import { NativeDesktopHost } from './NativeDesktopHost';
+import { FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES, NativeDesktopHost } from './NativeDesktopHost';
 import type { NativeDisabledInputFeature } from './NativeDesktopHost';
 
 const mockSpawn = jest.fn();
@@ -65,9 +65,14 @@ async function probedHost(strictClear: boolean, disabledInputFeatures: readonly
 
 describe('NativeDesktopHost input delivery', () => {
   beforeEach(() => {
+    jest.replaceProperty(process, 'env', { ...process.env, [FURN_DESKTOP_DRIVER_DISABLED_INPUT_FEATURES]: '' });
     mockSpawn.mockReset();
   });
 
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   test('asks a strict helper for the mechanism, and returns the one it used', async () => {
     const { host, received } = await probedHost(true);
 

From 7475d87c17bef2ad25bf98fa0452ffc6d81fd962 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Sun, 8 Nov 2026 01:48:40 -0800
Subject: [PATCH 6/6] Pin the test proxy to its loopback driver

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../src/testing/wdioRunner.contract.cjs       | 51 ++++++++++++++++---
 1 file changed, 44 insertions(+), 7 deletions(-)

diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index 1110dec188..44dd1bbb3c 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -368,6 +368,21 @@ async function main() {
     });
     let unconfirmedLane;
     try {
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- rejected request targets use loopback only
+      for (const requestTarget of ['http://127.0.0.1:1/session', '//127.0.0.1:1/session']) {
+        const status = await new Promise((resolve, reject) => {
+          const request = http.request(
+            { hostname: '127.0.0.1', port: new URL(unconfirmedProxy.url).port, path: requestTarget },
+            (response) => {
+              response.resume();
+              resolve(response.statusCode);
+            },
+          );
+          request.once('error', reject);
+          request.end();
+        });
+        assert.equal(status, 400);
+      }
       await run('lane', { input: 'accessible', report: unconfirmedReport, url: unconfirmedProxy.url });
       throw new Error('An accessible lane must not run against a driver that does not confirm its input policy.');
     } catch (error) {
@@ -473,22 +488,44 @@ async function main() {
 
 /** Forwards to a driver but drops the input policy from each new session, as a driver from before enforcement would. */
 async function createUnconfirmingProxy(url) {
+  const upstream = new URL(url);
+  if (upstream.protocol !== 'http:' || upstream.hostname !== '127.0.0.1') {
+    throw new Error('The test proxy requires a loopback HTTP driver.');
+  }
   const server = http.createServer(async (request, response) => {
+    if (!request.url?.startsWith('/') || request.url.startsWith('//')) {
+      request.resume();
+      response.writeHead(400);
+      response.end();
+      return;
+    }
     const chunks = [];
     for await (const chunk of request) chunks.push(chunk);
     const body = Buffer.concat(chunks);
-    const reply = await fetch(new URL(request.url, url), {
-      method: request.method,
-      headers: { 'content-type': 'application/json' },
-      ...(body.length ? { body } : {}),
+    const reply = await new Promise((resolve, reject) => {
+      const forwarded = http.request(
+        {
+          hostname: '127.0.0.1',
+          port: upstream.port,
+          path: request.url,
+          method: request.method,
+          headers: { 'content-type': 'application/json' },
+        },
+        resolve,
+      );
+      forwarded.once('error', reject);
+      forwarded.end(body);
     });
-    let text = await reply.text();
-    if (request.method === 'POST' && request.url === '/session' && reply.ok) {
+    const replyChunks = [];
+    for await (const chunk of reply) replyChunks.push(chunk);
+    let text = Buffer.concat(replyChunks).toString('utf8');
+    const status = reply.statusCode ?? 502;
+    if (request.method === 'POST' && request.url === '/session' && status >= 200 && status < 300) {
       const created = JSON.parse(text);
       delete created.value.capabilities['furn:inputMode'];
       text = JSON.stringify(created);
     }
-    response.writeHead(reply.status, { 'content-type': 'application/json' });
+    response.writeHead(status, { 'content-type': 'application/json' });
     response.end(text);
   });
   await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(undefined)));