From c0b0f06a2590a65405673dffdeb624460133f448 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Mon, 14 Sep 2026 10:11:50 -0700
Subject: [PATCH 1/5] initial wdio test implementation

---
 .changeset/inline-wdio-story-tests.md         |   7 +
 .../references/tests-and-stories.md           |  12 +
 apps/storybook/AGENTS.md                      |   5 +
 apps/storybook/README.md                      |  11 +
 apps/storybook/agent-map.yaml                 |   6 +
 packages/agentic/components/AGENTS.md         |   4 +
 packages/agentic/components/package.json      |   6 +-
 .../components/src/components/AGENTS.md       |   3 +
 .../src/components/button/button.stories.tsx  |  23 +-
 packages/agentic/components/tsconfig.json     |   3 +
 .../agentic/components/tsconfig.stories.json  |  19 ++
 .../references/test-integration.md            |  12 +
 .../agentic/desktop-driver/src/storybook.ts   |   1 +
 .../src/wdio/DesktopWebdriver.ts              |  44 ++-
 .../agentic/desktop-driver/src/wdio/index.ts  |   4 +-
 .../src/wdio/wdioRunner.contract.cjs          |   9 +-
 packages/agentic/storybook-desktop/README.md  |  91 ++++++
 .../storybook-desktop/config/babel.cjs        |   3 +-
 .../config/transform-story-tests.cjs          | 261 ++++++++++++++++++
 .../config/transform-story-tests.d.cts        |  15 +
 .../agentic/storybook-desktop/package.json    |  10 +-
 .../src/cli/DesktopStorybookCli.test.ts       |  45 +++
 .../src/cli/DesktopStorybookCli.ts            |  74 +++++
 .../storybook-desktop/src/cli/README.md       |   7 +
 .../src/cli/createDesktopStorybookCommand.ts  |  30 ++
 .../storybook-desktop/src/cli/index.ts        |   1 +
 .../storybook-desktop/src/config/index.ts     |   1 +
 .../src/config/makeDesktopStorybookConfig.ts  |  10 +
 .../src/config/transformStoryTests.test.ts    |  93 +++++++
 .../storybook-desktop/src/config/wdio.test.ts |  27 ++
 .../storybook-desktop/src/config/wdio.ts      |  30 ++
 .../src/driver/storyManifest.test.ts          |  58 ++++
 .../src/driver/storyManifest.ts               |   8 +
 .../src/testing/extractWdioTests.test.ts      | 218 +++++++++++++++
 .../src/testing/extractWdioTests.ts           |  35 +++
 .../storybook-desktop/src/testing/index.ts    |   1 +
 .../src/testing/runWdioTests.ts               | 245 ++++++++++++++++
 .../storybook-desktop/src/testing/types.ts    |  15 +
 .../src/testing/wdio.types.test.ts            |  37 +++
 .../src/testing/wdioRunner.contract.cjs       | 126 +++++++++
 .../src/testing/wdioRunner.test.ts            |  36 +++
 .../storybook-desktop/src/testing/worker.ts   |  37 +++
 yarn.lock                                     |   6 +
 43 files changed, 1673 insertions(+), 16 deletions(-)
 create mode 100644 .changeset/inline-wdio-story-tests.md
 create mode 100644 packages/agentic/components/tsconfig.stories.json
 create mode 100644 packages/agentic/storybook-desktop/config/transform-story-tests.cjs
 create mode 100644 packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
 create mode 100644 packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/config/wdio.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/config/wdio.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/index.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/types.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
 create mode 100644 packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/testing/worker.ts

diff --git a/.changeset/inline-wdio-story-tests.md b/.changeset/inline-wdio-story-tests.md
new file mode 100644
index 0000000000..42ba5ee87e
--- /dev/null
+++ b/.changeset/inline-wdio-story-tests.md
@@ -0,0 +1,7 @@
+---
+"@fluentui-react-native/storybook-desktop": minor
+"@fluentui-react-native/desktop-driver": minor
+"@fluentui-react-native/components": patch
+---
+
+Add opt-in executable WebdriverIO callbacks in React Native stories, Storybook-owned test configuration, isolated Node execution, and Button examples.
diff --git a/.github/skills/agentic-component-authoring/references/tests-and-stories.md b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
index 3c1069e2d4..092259fbbb 100644
--- a/.github/skills/agentic-component-authoring/references/tests-and-stories.md
+++ b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
@@ -145,6 +145,18 @@ use role, accessible name, state, and value assertions to verify the public
 accessibility contract. Button, Checkbox, and Input defaults are the canonical
 initial examples.
 
+For executable Node tests, Button also demonstrates a top-level `wdio`
+callback typed with `WdioStory` from
+`@fluentui-react-native/storybook-desktop/testing`. Wrap `StoryObj` in `WdioStory`
+and import the type only. The callback receives `browser`, `expect`, `desktop`,
+`signal`, and `skip`; it cannot capture story-module bindings. Node-compatible
+helpers may be dynamically imported inside the callback. The shared Babel
+configuration strips test bodies before Metro resolves dependencies.
+Run these with `yarn storybook test --<platform>`, independently of the static
+plan runner. See the [executable test contract](../../../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
+The components package's `test:stories` project checks the experimental
+Button stories without emitting them into the component library.
+
 Button uses focused appearance, size, shape, icon, selection, disabled, and constrained-content stories. Icon uses a
 source and size overview plus focused font, image, SVG, size, color, and accessibility stories.
 
diff --git a/apps/storybook/AGENTS.md b/apps/storybook/AGENTS.md
index 366136cdab..69f4fc2a12 100644
--- a/apps/storybook/AGENTS.md
+++ b/apps/storybook/AGENTS.md
@@ -48,6 +48,11 @@ Read [`agent-map.yaml`](agent-map.yaml) first for the compact architecture, look
 - Authored tests belong in component story `parameters.desktopDriver`, not in
   this app. The app owns identity, package discovery, platform exclusions, and
   generated manifests.
+- Executable tests may instead use a top-level component story `wdio`
+  callback, run with `yarn storybook test --<platform>`. Defaults belong in
+  `storybook.config.mts` under `wdio`; the shared Babel config removes
+  callbacks from native bundles. Keep this opt-in runner separate from the
+  static-plan smoke gate.
 - Keep `storybook-desktop.generated`, reports, trees, screenshots, and run
   manifests ignored. Never patch generated runtime identity or story manifests.
 - Treat the exact-platform and portable-plan digests as contracts. A dynamic or
diff --git a/apps/storybook/README.md b/apps/storybook/README.md
index 929e5af860..1a97c1060a 100644
--- a/apps/storybook/README.md
+++ b/apps/storybook/README.md
@@ -26,6 +26,17 @@ app-owned, while the platform-neutral UI, configuration helpers, and `storybook-
 from the shared package. The app exposes only the shared CLI entry points; native lifecycle scripts
 remain package-owned.
 
+Button also experiments with executable `wdio` callbacks directly in its
+stories. Run `yarn storybook test --macos --list` to discover them. With
+`yarn storybook driver --macos` running and the app launched via
+`yarn storybook run --macos`, run
+`yarn storybook test --macos --story 'components-button--*'`.
+The shared runner extracts the callbacks for Node, injects WebdriverIO and
+native assertions, and leaves test dependencies out of Metro. Optional runner
+defaults belong under `wdio` in `storybook.config.mts`; no separate test config
+is needed. See the [authoring contract](../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
+This command is separate from the existing static-plan smoke gate.
+
 ## Layout
 
 ```
diff --git a/apps/storybook/agent-map.yaml b/apps/storybook/agent-map.yaml
index f9c54bc42a..1a84ccc1f3 100644
--- a/apps/storybook/agent-map.yaml
+++ b/apps/storybook/agent-map.yaml
@@ -26,6 +26,12 @@ services:
   instance:
     command: yarn storybook instance --<platform>
     policy: use-reported-ports-and-target-id
+  executable_tests:
+    command: yarn storybook test --<platform>
+    discovery: yarn storybook test --<platform> --list
+    authoring: top-level wdio callbacks in CSF3 stories
+    config: storybook.config.mts wdio settings
+    lifecycle: attached-session-per-story-with-isolated-node-worker
 
 agent_commands:
   generate_manifest: yarn storybook manifest --<platform>
diff --git a/packages/agentic/components/AGENTS.md b/packages/agentic/components/AGENTS.md
index ec8dde4746..ebb72b8898 100644
--- a/packages/agentic/components/AGENTS.md
+++ b/packages/agentic/components/AGENTS.md
@@ -12,6 +12,10 @@ invariants; detailed authoring recipes live in the
 - Portable desktop story tests are static `parameters.desktopDriver` plans.
   Use the public authoring types, stable `testID` selectors, declarative
   capability requirements, and no platform branches or executable callbacks.
+- Executable tests are a separate opt-in top-level `wdio` callback, typed
+  with `WdioStory` from `storybook-desktop/testing` using `import type`.
+  Keep callbacks self-contained; dynamically import Node helpers inside
+  them so the shared Babel transform can exclude them from native bundles.
 - Storybook application, native project, Metro, bundle, or CocoaPods work follows the
   [Storybook instructions](../../../apps/storybook/AGENTS.md) and the `agentic-storybook-development` skill.
 - Native React Native Windows Fabric component work follows the
diff --git a/packages/agentic/components/package.json b/packages/agentic/components/package.json
index 089a38cac4..f8ef186834 100644
--- a/packages/agentic/components/package.json
+++ b/packages/agentic/components/package.json
@@ -35,7 +35,8 @@
     "format": "fluentui-scripts format",
     "lint": "fluentui-scripts lint",
     "report:spec-source-drift": "node ./scripts/spec-contracts/report-spec-source-drift.cjs",
-    "test": "node ./scripts/spec-contracts/check-spec-contracts.cjs && fluentui-scripts jest",
+    "test": "node ./scripts/spec-contracts/check-spec-contracts.cjs && yarn test:stories && fluentui-scripts jest",
+    "test:stories": "tsc -p tsconfig.stories.json",
     "update-snapshots": "fluentui-scripts jest -u"
   },
   "dependencies": {
@@ -48,12 +49,14 @@
     "@fluentui-react-native/desktop-driver": "workspace:*",
     "@fluentui-react-native/focus-zone": "workspace:*",
     "@fluentui-react-native/scripts": "workspace:*",
+    "@fluentui-react-native/storybook-desktop": "workspace:*",
     "@office-iss/react-native-win32": "^0.81.0",
     "@react-native-community/cli": "^20.0.0",
     "@react-native-community/cli-platform-android": "^20.0.0",
     "@react-native-community/cli-platform-ios": "^20.0.0",
     "@react-native/babel-preset": "^0.81.0",
     "@react-native/metro-config": "^0.81.0",
+    "@storybook/react-native": "^10.4.7",
     "@testing-library/react-native": "catalog:",
     "@types/react": "~19.1.4",
     "react": "19.1.4",
@@ -61,6 +64,7 @@
     "react-native-macos": "^0.81.0",
     "react-native-svg": "^15.12.1",
     "react-native-windows": "^0.81.0",
+    "storybook": "^10.4.0",
     "test-renderer": "catalog:"
   },
   "peerDependencies": {
diff --git a/packages/agentic/components/src/components/AGENTS.md b/packages/agentic/components/src/components/AGENTS.md
index 104b6aa11d..96703f1a42 100644
--- a/packages/agentic/components/src/components/AGENTS.md
+++ b/packages/agentic/components/src/components/AGENTS.md
@@ -59,6 +59,9 @@ audit.
   satisfying `DesktopStoryTests`. Use one stable `testID` per interacted
   element, declare capabilities, and assert public native semantics rather than
   implementation structure.
+- For imperative tests, use the separate top-level `wdio` callback contract
+  demonstrated by Button and run it through `storybook test`. Do not put
+  functions in static plans or import Node helpers at story-module scope.
 
 ## Focused references
 
diff --git a/packages/agentic/components/src/components/button/button.stories.tsx b/packages/agentic/components/src/components/button/button.stories.tsx
index ea49a1937d..9bf94a220a 100644
--- a/packages/agentic/components/src/components/button/button.stories.tsx
+++ b/packages/agentic/components/src/components/button/button.stories.tsx
@@ -5,6 +5,7 @@ import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
 import type { DesktopStoryTests } from '@fluentui-react-native/desktop-driver/authoring';
+import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Button } from './button';
 import type { ButtonAppearance, ButtonShape, ButtonSize } from './button.types';
@@ -74,10 +75,17 @@ const meta: Meta<typeof Button> = {
 
 export default meta;
 
-type Story = StoryObj<typeof Button>;
+type Story = WdioStory<StoryObj<typeof Button>>;
 
 export const Default: Story = {
   tags: ['desktop-e2e'],
+  wdio: 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');
+  },
   parameters: {
     desktopDriver: {
       version: 1,
@@ -243,6 +251,16 @@ export const Selected: Story = {
 };
 
 export const ExternallyDrivenSelection: Story = {
+  wdio: async ({ browser, desktop, expect }) => {
+    const favorite = await browser.$('~agentic-storybook-button-favorite');
+    const reset = await browser.$('~agentic-storybook-button-reset');
+    await expect(favorite).toBeEnabled();
+    await desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: false });
+    await favorite.click();
+    await desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: true });
+    await reset.click();
+    await desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: false });
+  },
   render: () => {
     const ToggleGroup = () => {
       const [selected, setSelected] = useState(false);
@@ -254,8 +272,9 @@ export const ExternallyDrivenSelection: Story = {
             onPress={() => setSelected(!selected)}
             selected={selected}
             selectedIcon={filledStarIcon}
+            testID="agentic-storybook-button-favorite"
           />
-          <Button appearance="subtle" content="Reset" onPress={() => setSelected(false)} />
+          <Button appearance="subtle" content="Reset" onPress={() => setSelected(false)} testID="agentic-storybook-button-reset" />
         </StoryGroup>
       );
     };
diff --git a/packages/agentic/components/tsconfig.json b/packages/agentic/components/tsconfig.json
index eb91f24143..2f0d8779c3 100644
--- a/packages/agentic/components/tsconfig.json
+++ b/packages/agentic/components/tsconfig.json
@@ -18,6 +18,9 @@
     {
       "path": "../desktop-driver/tsconfig.json"
     },
+    {
+      "path": "../storybook-desktop/tsconfig.json"
+    },
     {
       "path": "../../components/FocusZone/tsconfig.json"
     },
diff --git a/packages/agentic/components/tsconfig.stories.json b/packages/agentic/components/tsconfig.stories.json
new file mode 100644
index 0000000000..c47daa43d5
--- /dev/null
+++ b/packages/agentic/components/tsconfig.stories.json
@@ -0,0 +1,19 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "noImplicitAny": true,
+    "noEmit": true,
+    "tsBuildInfoFile": ".cache/tsconfig.stories.tsbuildinfo"
+  },
+  "include": ["src/components/button/button.stories.tsx"],
+  "exclude": [],
+  "references": [
+    {
+      "path": "./tsconfig.json"
+    },
+    {
+      "path": "../storybook-desktop/tsconfig.json"
+    }
+  ]
+}
diff --git a/packages/agentic/desktop-driver/references/test-integration.md b/packages/agentic/desktop-driver/references/test-integration.md
index 48d209578d..78a179aed0 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -50,6 +50,18 @@ The runner resets the preview for each test, filters and shards a stable
 `storyId/testId` ordering, checks required capabilities, and classifies
 assertion, timeout, cancellation, skip, and infrastructure outcomes.
 
+An external supervisor can share an existing session with an isolated Node
+worker using `attachDesktopWebdriver({ url, sessionId, capabilities })`.
+This registers the same custom commands without creating a second session.
+The supervisor retains ownership and must call `delete()` after the worker
+exits, including on assertion failures, timeouts, or crashes.
+
+Storybook's experimental top-level `wdio` story callbacks use this pattern
+with Node's built-in test runner. Extraction, native-bundle stripping, runner
+configuration, and source freshness belong to
+[`storybook-desktop`](../../storybook-desktop/README.md#executable-tests-inside-stories),
+not this Storybook-independent package. Static plans below are unchanged.
+
 ## Author portable story plans
 
 Plans are static JSON under `parameters.desktopDriver`. Import only their types
diff --git a/packages/agentic/desktop-driver/src/storybook.ts b/packages/agentic/desktop-driver/src/storybook.ts
index df5296751b..91cc246a27 100644
--- a/packages/agentic/desktop-driver/src/storybook.ts
+++ b/packages/agentic/desktop-driver/src/storybook.ts
@@ -9,6 +9,7 @@ export type DesktopStoryManifestEntry = {
   tags: readonly string[];
   title: string;
   tests?: DesktopStoryTests;
+  wdio?: { digest: string; exportName: string };
 };
 
 export type DesktopStoryManifest = {
diff --git a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
index c845bf6965..e7e7c9a72e 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
@@ -1,4 +1,4 @@
-import { remote } from 'webdriverio';
+import { attach, remote } from 'webdriverio';
 
 import type { DesktopStoryRunResult } from '../authoring/results.js';
 import type { DesktopStoryExpectation } from '../authoring/storyTests.js';
@@ -44,6 +44,12 @@ export type DesktopWebdriverRunOptions = {
   signal?: AbortSignal;
 };
 
+export type DesktopWebdriverAttachment = {
+  capabilities: NonNullable<Parameters<typeof attach>[0]['capabilities']>;
+  sessionId: string;
+  url: string;
+};
+
 export class DesktopWebdriverSession {
   readonly browser: WebdriverIO.Browser;
   readonly session: DesktopSessionClient;
@@ -99,7 +105,6 @@ export class DesktopWebdriverSession {
 }
 
 export async function connectDesktopWebdriver(options: DesktopWebdriverOptions): Promise<DesktopWebdriverSession> {
-  const url = new URL(options.url);
   const capabilities = Object.assign(
     {
       browserName: 'furn-native-desktop',
@@ -112,14 +117,39 @@ export async function connectDesktopWebdriver(options: DesktopWebdriverOptions):
     },
   );
   const browser = await remote({
+    ...connectionOptions(options.url),
     capabilities,
-    hostname: url.hostname,
     logLevel: options.logLevel ?? 'silent',
-    path: url.pathname === '/' ? '/' : url.pathname,
-    port: Number(url.port),
-    protocol: url.protocol.replace(':', '') as 'http' | 'https',
   });
-  const client = createDesktopDriverClient({ url: options.url });
+  return bindDesktopCommands(browser, options.url);
+}
+
+/** The caller retains ownership of the existing session and must delete it after the worker exits. */
+export async function attachDesktopWebdriver(options: DesktopWebdriverAttachment): Promise<DesktopWebdriverSession> {
+  const browser = await attach({
+    ...connectionOptions(options.url),
+    capabilities: options.capabilities,
+    sessionId: options.sessionId,
+    options: { logLevel: 'silent' },
+  });
+  return bindDesktopCommands(browser, options.url);
+}
+
+function connectionOptions(address: string) {
+  const url = new URL(address);
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new TypeError('Desktop WebDriver requires an HTTP or HTTPS URL.');
+  }
+  return {
+    hostname: url.hostname,
+    path: url.pathname,
+    port: Number(url.port || (url.protocol === 'https:' ? 443 : 80)),
+    protocol: url.protocol === 'https:' ? ('https' as const) : ('http' as const),
+  };
+}
+
+function bindDesktopCommands(browser: WebdriverIO.Browser, url: string): DesktopWebdriverSession {
+  const client = createDesktopDriverClient({ url });
   const session = new DesktopSessionClient(client, browser.sessionId, Object.fromEntries(Object.entries(browser.capabilities)));
   const desktop = new DesktopWebdriverSession(browser, session);
 
diff --git a/packages/agentic/desktop-driver/src/wdio/index.ts b/packages/agentic/desktop-driver/src/wdio/index.ts
index a520c7eda5..db6ac1b5a0 100644
--- a/packages/agentic/desktop-driver/src/wdio/index.ts
+++ b/packages/agentic/desktop-driver/src/wdio/index.ts
@@ -1,2 +1,2 @@
-export { connectDesktopWebdriver, DesktopWebdriverSession } from './DesktopWebdriver.js';
-export type { DesktopWebdriverOptions, DesktopWebdriverRunOptions } from './DesktopWebdriver.js';
+export { attachDesktopWebdriver, connectDesktopWebdriver, DesktopWebdriverSession } from './DesktopWebdriver.js';
+export type { DesktopWebdriverAttachment, DesktopWebdriverOptions, DesktopWebdriverRunOptions } from './DesktopWebdriver.js';
diff --git a/packages/agentic/desktop-driver/src/wdio/wdioRunner.contract.cjs b/packages/agentic/desktop-driver/src/wdio/wdioRunner.contract.cjs
index 22c14b9010..b7b4129442 100644
--- a/packages/agentic/desktop-driver/src/wdio/wdioRunner.contract.cjs
+++ b/packages/agentic/desktop-driver/src/wdio/wdioRunner.contract.cjs
@@ -3,7 +3,7 @@ const { pathToFileURL } = require('node:url');
 
 async function main() {
   const moduleUrl = pathToFileURL(path.resolve(__dirname, '..', '..', 'lib', 'wdio', 'index.js')).href;
-  const { connectDesktopWebdriver } = await import(moduleUrl);
+  const { attachDesktopWebdriver, connectDesktopWebdriver } = await import(moduleUrl);
   const [url, targetId, artifactsRoot] = process.argv.slice(2);
   const desktop = await connectDesktopWebdriver({
     platformName: 'windows',
@@ -11,7 +11,12 @@ async function main() {
     url,
   });
   try {
-    const manifest = await desktop.browser.desktopListStories();
+    const worker = await attachDesktopWebdriver({
+      url,
+      sessionId: desktop.browser.sessionId,
+      capabilities: desktop.browser.capabilities,
+    });
+    const manifest = await worker.browser.desktopListStories();
     await desktop.browser.desktopExpect({
       state: 'enabled',
       target: { testId: 'button-primary' },
diff --git a/packages/agentic/storybook-desktop/README.md b/packages/agentic/storybook-desktop/README.md
index 7442d85b3f..72ad8cc27b 100644
--- a/packages/agentic/storybook-desktop/README.md
+++ b/packages/agentic/storybook-desktop/README.md
@@ -149,6 +149,97 @@ Input provide the initial examples. Plan extraction evaluates only the inline
 static `desktopDriver` literal and supports TypeScript `satisfies`; dynamic
 values fail with source context instead of being omitted.
 
+### Executable tests inside stories
+
+For imperative tests, add a top-level `wdio` callback to a CSF3 story. This is
+an opt-in companion to static `parameters.desktopDriver` plans, not a React
+Native implementation of the web `play` function:
+
+```tsx
+import type { StoryObj } from '@storybook/react-native';
+import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
+
+type Story = WdioStory<StoryObj<typeof Button>>;
+
+export const Default: Story = {
+  wdio: async ({ browser, expect }) => {
+    const button = await browser.$('~save-button');
+    await expect(button).toBeEnabled();
+    await button.click();
+  },
+};
+```
+
+`browser` is the real WebdriverIO browser, `expect` is `expect-webdriverio`,
+and `desktop` exposes the existing typed native assertions and story commands.
+`signal` allows cooperative cancellation; `skip(reason)` records an explicit
+skip (return from the callback after calling it). Native selectors and
+supported WebDriver operations apply; there is no DOM or JavaScript execution
+inside the app.
+
+Callbacks are extracted without importing React Native in Node. They must be
+inline functions with no closures over the story module's imports, helpers,
+args, or render state. Declare test-local values inside the callback. Import
+Node-compatible helpers with a literal `await import('node:assert/strict')`,
+`await import('./test-helper.js')`, or package specifier **inside** the
+callback; these resolve from the original story file. Unsupported expressions
+fail extraction with source context rather than disappearing.
+
+The shared Babel config removes these callbacks before Metro resolves their
+dependencies, on all three desktop endpoints. Import `WdioStory` with
+`import type`, never import Node test libraries at story-module scope, and use
+`createDesktopStorybookBabelConfig` in the app. Ordinary on-device story
+rendering and controls remain unchanged.
+
+Run the experiment from the consuming app:
+
+```sh
+yarn storybook test --macos --list
+# Terminal 1: keep the driver supervisor running.
+yarn storybook driver --macos
+# Terminal 2: launch the native app, then run the inline tests.
+yarn storybook run --macos
+yarn storybook test --macos --story 'components-button--*'
+```
+
+Defaults come from `storybook.config.mts`; no Mocha, Jest, or WDIO config file
+is needed:
+
+```ts
+export default makeDesktopStorybookConfig({
+  // ...app identity and story discovery...
+  wdio: {
+    timeoutMs: 30_000,
+    reporter: 'spec', // spec, tap, or dot
+    clickMode: 'auto',
+    // Optional: story: 'components-button--*', tag: 'my-test-tag'
+  },
+});
+```
+
+CLI filters, `--timeout-ms`, `--reporter`, and `--click-mode` override those
+defaults. By default `test` uses the saved driver's actual port and target,
+including port-probing adjustments. `--url` and `--target` together select an
+externally managed driver. On macOS the command refreshes an exact,
+nonce-bound lease for the isolated app identity. Windows and Win32 require
+the trusted lifecycle owner to provide the existing application lease;
+the test runner does not attach by an ambiguous process name or title.
+
+Node's built-in test runner executes each story in a separate process. The
+supervisor owns one attached WebDriver session at a time, authenticates the
+live manifest, resets the preview before each callback, and deletes the
+session after success, failure, timeout, or worker exit. The app and driver
+remain running. Failed callbacks exit nonzero; no matches is an error.
+Reports and best-effort failure source/tree evidence live in
+`artifacts/<platform>/wdio`. Generated executable files are removed after the
+run. Callback digests participate in manifest freshness checks: restart the
+driver and reload the app after editing tests.
+
+Button's `Default` demonstrates assertions and Node-only imports;
+`ExternallyDrivenSelection` verifies actual activation and caller-owned state
+updates. This experiment is invoked by `storybook test`; existing
+`stories-and-tests` smoke runs continue to execute the static plans only.
+
 Run the resulting plans through the consuming app's Desktop Driver CLI:
 
 ```sh
diff --git a/packages/agentic/storybook-desktop/config/babel.cjs b/packages/agentic/storybook-desktop/config/babel.cjs
index 5a09af866e..5f85f55d40 100644
--- a/packages/agentic/storybook-desktop/config/babel.cjs
+++ b/packages/agentic/storybook-desktop/config/babel.cjs
@@ -1,11 +1,12 @@
 const transformWin32UnicodeRegex = require.resolve('./transform-win32-unicode-regex.cjs');
+const transformStoryTests = require.resolve('./transform-story-tests.cjs');
 
 function createDesktopStorybookBabelConfig(api) {
   const platform = api.caller((caller) => caller?.platform);
 
   return {
     presets: ['module:@react-native/babel-preset'],
-    plugins: platform === 'win32' ? [transformWin32UnicodeRegex] : [],
+    plugins: [transformStoryTests, ...(platform === 'win32' ? [transformWin32UnicodeRegex] : [])],
   };
 }
 
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
new file mode 100644
index 0000000000..c815145dd3
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -0,0 +1,261 @@
+const { isBuiltin, createRequire } = require('node:module');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const { transformFromAstSync, traverse, types } = require('@babel/core');
+const transformTypescript = require('@babel/plugin-transform-typescript');
+
+const nodeGlobals = new Set(
+  `AbortController AbortSignal AggregateError Array ArrayBuffer Atomics BigInt BigInt64Array BigUint64Array
+  Blob Boolean BroadcastChannel Buffer ByteLengthQueuingStrategy CompressionStream CountQueuingStrategy
+  Crypto CryptoKey CustomEvent DOMException DataView Date DecompressionStream Error EvalError Event EventTarget
+  File FinalizationRegistry Float16Array Float32Array Float64Array FormData Function Headers Infinity Int8Array
+  Int16Array Int32Array Intl JSON Map Math MessageChannel MessageEvent MessagePort NaN Navigator Number Object
+  Performance PerformanceEntry PerformanceMark PerformanceMeasure PerformanceObserver PerformanceResourceTiming
+  Promise Proxy RangeError ReadableByteStreamController ReadableStream ReadableStreamBYOBReader
+  ReadableStreamBYOBRequest ReadableStreamDefaultController ReadableStreamDefaultReader ReferenceError Reflect
+  RegExp Request Response Set SharedArrayBuffer String SubtleCrypto Symbol SyntaxError TextDecoder TextDecoderStream
+  TextEncoder TextEncoderStream TransformStream TransformStreamDefaultController TypeError URIError URL URLPattern
+  URLSearchParams Uint8Array Uint8ClampedArray Uint16Array Uint32Array WeakMap WeakRef WeakSet WebAssembly WebSocket
+  WritableStream WritableStreamDefaultController WritableStreamDefaultWriter atob btoa clearImmediate clearInterval
+  clearTimeout console crypto decodeURI decodeURIComponent encodeURI encodeURIComponent escape fetch global globalThis
+  isFinite isNaN navigator parseFloat parseInt performance process queueMicrotask setImmediate setInterval setTimeout
+  structuredClone undefined unescape`.split(/\s+/),
+);
+
+function unwrap(expression) {
+  while (
+    expression &&
+    ['TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression', 'TSTypeAssertion', 'ParenthesizedExpression'].includes(
+      expression.node.type,
+    )
+  ) {
+    expression = expression.get('expression');
+  }
+  return expression;
+}
+
+function keyName(member) {
+  const key = member.node.key ?? member.node.property;
+  return types.isIdentifier(key) ? key.name : types.isStringLiteral(key) ? key.value : undefined;
+}
+
+function fail(location, message) {
+  throw location.buildCodeFrameError(`Story wdio: ${message}`);
+}
+
+function resolveInitializer(value, seen = new Set(), bindings = new Set()) {
+  value = unwrap(value);
+  if (value?.isIdentifier()) {
+    const binding = value.scope.getBinding(value.node.name);
+    if (binding?.path.isVariableDeclarator() && !seen.has(binding)) {
+      seen.add(binding);
+      bindings.add(binding);
+      return resolveInitializer(binding.path.get('init'), seen, bindings);
+    }
+  }
+  return value;
+}
+
+/** Shared by the Node extractor and Metro; inspect only named CSF story objects. */
+function collectWdioTests(program) {
+  const exports = [];
+  const storyBindings = new Set();
+  const tests = new Map();
+  for (const statement of program.get('body')) {
+    if (statement.isExportDefaultDeclaration()) {
+      const value = resolveInitializer(statement.get('declaration'));
+      const test = value?.isObjectExpression() && value.get('properties').find((member) => keyName(member) === 'wdio');
+      if (test) fail(test, 'callbacks belong on named CSF3 story exports, not the default meta export.');
+    }
+    if (!statement.isExportNamedDeclaration() || statement.node.exportKind === 'type') continue;
+    const declaration = statement.get('declaration');
+    if (declaration?.isVariableDeclaration()) {
+      for (const variable of declaration.get('declarations')) {
+        if (!variable.get('id').isIdentifier()) continue;
+        storyBindings.add(variable.scope.getBinding(variable.node.id.name));
+        exports.push([variable.node.id.name, variable.get('init')]);
+      }
+    }
+    if (!statement.node.source) {
+      for (const specifier of statement.get('specifiers')) {
+        if (!specifier.isExportSpecifier() || specifier.node.exportKind === 'type') continue;
+        storyBindings.add(specifier.scope.getBinding(specifier.node.local.name));
+        exports.push([specifier.node.exported.name ?? specifier.node.exported.value, specifier.get('local')]);
+      }
+    }
+  }
+  for (const [exportName, initializer] of exports) {
+    const object = resolveInitializer(initializer, new Set(), storyBindings);
+    if (!object?.node) continue;
+    if (!object.isObjectExpression()) {
+      if (object.isFunction()) continue;
+      object.traverse({
+        Function(inner) {
+          inner.skip();
+        },
+        'ObjectProperty|ObjectMethod'(member) {
+          if (keyName(member) === 'wdio') fail(member, `"${exportName}" must be a directly exported CSF3 object literal.`);
+        },
+      });
+      continue;
+    }
+    let test;
+    for (const member of object.get('properties')) {
+      if (member.isSpreadElement()) fail(member, `"${exportName}" uses a spread that could hide or override wdio.`);
+      if (member.node.computed) fail(member, `"${exportName}" uses a computed property that could hide or override wdio.`);
+      if (keyName(member) !== 'wdio') continue;
+      if (test) fail(member, `"${exportName}" has duplicate wdio properties.`);
+      if (!member.isObjectProperty()) fail(member, `"${exportName}".wdio must be an inline function value, not a method or accessor.`);
+      const callback = unwrap(member.get('value'));
+      if ((!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) || callback.node.generator) {
+        fail(member, `"${exportName}".wdio must be an inline, non-generator function.`);
+      }
+      test = { callback, property: member };
+    }
+    if (test) {
+      const declaration = object.findParent((parent) => parent.isVariableDeclarator());
+      const binding = declaration?.get('id').isIdentifier() && declaration.scope.getBinding(declaration.node.id.name);
+      if (binding && !binding.constant) fail(object, `"${exportName}" is reassigned; wdio requires an immutable story declaration.`);
+      tests.set(exportName, test);
+    }
+  }
+  program.traverse({
+    AssignmentExpression(assignment) {
+      const target = assignment.get('left');
+      if (
+        target.isMemberExpression() &&
+        target.get('object').isIdentifier() &&
+        storyBindings.has(target.scope.getBinding(target.node.object.name)) &&
+        (target.node.computed || keyName(target) === 'wdio')
+      ) {
+        fail(target, 'assign wdio inside the exported CSF3 object, not through a later property assignment.');
+      }
+    },
+    CallExpression(call) {
+      const callee = call.get('callee');
+      const target = call.get('arguments.0');
+      if (
+        callee.isMemberExpression() &&
+        callee.get('object').isIdentifier({ name: 'Object' }) &&
+        ['assign', 'defineProperty', 'defineProperties'].includes(keyName(callee)) &&
+        target?.isIdentifier() &&
+        storyBindings.has(target.scope.getBinding(target.node.name))
+      ) {
+        fail(call, 'Object mutations could hide or override wdio; author properties inside the exported CSF3 object.');
+      }
+    },
+  });
+  return tests;
+}
+
+function compileWdioTest(callback, sourceFile, source) {
+  const file = types.file(types.program([types.expressionStatement(types.cloneNode(callback.node, true))]));
+  const result = transformFromAstSync(file, source, {
+    ast: true,
+    babelrc: false,
+    code: false,
+    configFile: false,
+    filename: sourceFile,
+    plugins: [[transformTypescript, { allowDeclareFields: true, onlyRemoveTypeImports: true, isTSX: true }]],
+  });
+  const requireFromSource = createRequire(path.resolve(sourceFile));
+  function checkReference(reference, name) {
+    if (reference.scope.getBinding(name)) return;
+    if (name === 'arguments' && reference.findParent((parent) => parent.isFunction() && !parent.isArrowFunctionExpression())) return;
+    if (callback.scope.getBinding(name)) {
+      fail(
+        reference,
+        `"${name}" closes over a story-module binding. Declare it inside wdio or use a literal import() inside the callback.`,
+      );
+    }
+    if (!nodeGlobals.has(name)) fail(reference, `"${name}" is not a callback-local binding or supported Node global.`);
+  }
+  function rewriteImport(importPath, argument) {
+    if (!argument?.isStringLiteral()) fail(importPath, 'import() requires one literal string specifier.');
+    const specifier = argument.node.value;
+    if (/^(?:react-native(?:$|[/-])|@office-iss\/react-native-win32(?:$|\/))/.test(specifier)) {
+      fail(importPath, 'React Native modules cannot be imported by a Node wdio callback.');
+    }
+    let resolved;
+    try {
+      resolved = isBuiltin(specifier)
+        ? specifier.startsWith('node:')
+          ? specifier
+          : `node:${specifier}`
+        : pathToFileURL(requireFromSource.resolve(specifier)).href;
+    } catch (error) {
+      fail(importPath, `cannot resolve import "${specifier}" from ${sourceFile}: ${error.message}`);
+    }
+    if (/\.[jt]sx(?:$|[?#])/.test(resolved)) fail(importPath, 'import() helpers must be Node-loadable modules, not JSX/TSX files.');
+    argument.replaceWith(types.stringLiteral(resolved));
+  }
+  traverse(result.ast, {
+    ReferencedIdentifier(reference) {
+      checkReference(reference, reference.node.name);
+    },
+    AssignmentExpression(assignment) {
+      for (const name of Object.keys(types.getBindingIdentifiers(assignment.node.left))) checkReference(assignment, name);
+    },
+    UpdateExpression(update) {
+      if (types.isIdentifier(update.node.argument)) checkReference(update, update.node.argument.name);
+    },
+    'ForInStatement|ForOfStatement'(loop) {
+      if (!types.isVariableDeclaration(loop.node.left)) {
+        for (const name of Object.keys(types.getBindingIdentifiers(loop.node.left))) checkReference(loop, name);
+      }
+    },
+    'JSXElement|JSXFragment'(jsx) {
+      fail(jsx, 'JSX belongs in the native render module, not a Node wdio callback.');
+    },
+    ThisExpression(reference) {
+      for (let child = reference, parent = child.parentPath; parent; child = parent, parent = parent.parentPath) {
+        if (parent.isFunction() && !parent.isArrowFunctionExpression() && !(parent.isMethod() && child.key === 'key')) return;
+        if (
+          parent.isStaticBlock() ||
+          ((parent.isClassProperty() || parent.isClassPrivateProperty() || parent.isClassAccessorProperty()) && child.key === 'value')
+        ) {
+          return;
+        }
+      }
+      fail(reference, '"ThisExpression" closes over the story module rather than callback-local state.');
+    },
+    MetaProperty(reference) {
+      if (reference.node.meta.name === 'new') return;
+      fail(reference, `"${reference.node.type}" is not supported in an isolated wdio callback.`);
+    },
+    CallExpression(call) {
+      if (!types.isImport(call.node.callee)) return;
+      if (call.node.arguments.length !== 1) fail(call, 'import() requires one literal string specifier.');
+      rewriteImport(call, call.get('arguments.0'));
+    },
+    ImportExpression(importPath) {
+      if (importPath.node.options) fail(importPath, 'import() options are not supported.');
+      rewriteImport(importPath, importPath.get('source'));
+    },
+  });
+  const generated = transformFromAstSync(result.ast, source, {
+    babelrc: false,
+    configFile: false,
+    filename: sourceFile,
+    comments: false,
+  }).code;
+  // The expression statement's parentheses are significant for named function expressions.
+  return generated.replace(/;\s*$/, '');
+}
+
+module.exports = () => ({
+  name: 'transform-story-tests',
+  visitor: {
+    Program(program, state) {
+      const filename = state.filename ?? state.file.opts.filename;
+      if (!filename || !/\.stories\.tsx?$/.test(filename)) return;
+      const tests = collectWdioTests(program);
+      for (const { callback } of tests.values()) compileWdioTest(callback, filename, state.file.code);
+      for (const { property } of tests.values()) if (!property.removed) property.remove();
+    },
+  },
+});
+
+module.exports.collectWdioTests = collectWdioTests;
+module.exports.compileWdioTest = compileWdioTest;
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
new file mode 100644
index 0000000000..5eecf35e0c
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -0,0 +1,15 @@
+import type { NodePath, PluginObj, types } from '@babel/core';
+
+declare function storyTests(): PluginObj;
+
+declare namespace storyTests {
+  type StoryTest = {
+    callback: NodePath<types.FunctionExpression | types.ArrowFunctionExpression>;
+    property: NodePath<types.ObjectProperty>;
+  };
+
+  function collectWdioTests(program: NodePath<types.Program>): ReadonlyMap<string, StoryTest>;
+  function compileWdioTest(callback: StoryTest['callback'], sourceFile: string, source: string): string;
+}
+
+export = storyTests;
diff --git a/packages/agentic/storybook-desktop/package.json b/packages/agentic/storybook-desktop/package.json
index c38d9c331a..17223d24cb 100644
--- a/packages/agentic/storybook-desktop/package.json
+++ b/packages/agentic/storybook-desktop/package.json
@@ -35,6 +35,11 @@
       "import": "./lib/driver/index.js",
       "default": "./src/driver/index.ts"
     },
+    "./testing": {
+      "types": "./lib/testing/index.d.ts",
+      "import": "./lib/testing/index.js",
+      "default": "./src/testing/index.ts"
+    },
     "./cli": {
       "types": "./lib/cli/index.d.ts",
       "import": "./lib/cli/index.js",
@@ -51,13 +56,16 @@
     "test": "fluentui-scripts jest"
   },
   "dependencies": {
+    "@babel/core": "catalog:",
+    "@babel/plugin-transform-typescript": "catalog:",
     "@fluentui-react-native/desktop-driver": "workspace:*",
     "@rnx-kit/tools-react-native": "catalog:",
+    "@wdio/logger": "catalog:",
     "commander": "^14.0.2",
+    "expect-webdriverio": "catalog:",
     "regexpu-core": "^6.3.1"
   },
   "devDependencies": {
-    "@babel/core": "catalog:",
     "@fluentui-react-native/scripts": "workspace:*",
     "@react-native/babel-preset": "^0.81.0"
   },
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
index ae4d0203fd..2ca48d10c5 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
@@ -133,6 +133,51 @@ function makeConfig(platformOptions = {}) {
 }
 
 describe('DesktopStorybookCli', () => {
+  test('discovers executable callbacks with config filters and no native connection', async () => {
+    const runner = new RecordingRunner();
+    const output = { write: jest.fn() };
+    const config = makeDesktopStorybookConfig({
+      projectRoot: storybookRoot,
+      storyPackages: [],
+      wdio: { tag: 'inline' },
+    });
+    const createStoryManifest = async () => ({
+      endpoint: 'macos' as const,
+      schemaVersion: 1 as const,
+      platformManifestDigest: 'digest',
+      portablePlanDigest: 'portable',
+      entries: [
+        {
+          id: 'button--default',
+          name: 'Default',
+          title: 'Button',
+          sourcePath: 'button.stories.tsx',
+          packageName: 'fixture',
+          tags: ['inline'],
+          wdio: { digest: 'callback', exportName: 'Default' },
+        },
+        {
+          id: 'button--other',
+          name: 'Other',
+          title: 'Button',
+          sourcePath: 'button.stories.tsx',
+          packageName: 'fixture',
+          tags: [],
+          wdio: { digest: 'other', exportName: 'Other' },
+        },
+      ],
+    });
+    const command = createDesktopStorybookCommand({ config, runner, createStoryManifest, output });
+    await command.parseAsync(['node', 'storybook', 'test', '--macos', '--list']);
+    expect(JSON.parse(output.write.mock.calls[0][0])).toEqual([{ id: 'button--default', sourcePath: 'button.stories.tsx' }]);
+    expect(runner.foreground).toEqual([]);
+
+    const cli = new DesktopStorybookCli(config, { runner, createStoryManifest, output });
+    await expect(cli.test('macos', { list: true, story: 'missing--*' })).rejects.toThrow('No executable');
+    await expect(cli.test('macos', { url: 'https://127.0.0.1:1234' })).rejects.toThrow('Pass --url and --target together');
+    await expect(cli.test('macos', { timeoutMs: 0 })).rejects.toThrow('wdio.timeoutMs');
+  });
+
   test('starts the config-owned server with platform and connection options', async () => {
     const runner = new RecordingRunner();
     const cli = new DesktopStorybookCli(makeConfig(), { ...nativeDriverTestOptions, runner });
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
index 2143e5a59f..05e1243b49 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
@@ -34,6 +34,8 @@ import {
 import { NodeDesktopCommandRunner } from './commandRunner.js';
 import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopCommand } from './commandRunner.js';
 import { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } from './smokeTests.js';
+import { runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
+import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
 
 type ResolvedDesktopStorybookInstance = DesktopStorybookInstance & {
   driverManifestPath?: string;
@@ -65,6 +67,12 @@ export type DesktopStorybookServerOptions = {
   port?: number;
 };
 
+export type DesktopStorybookTestOptions = DesktopStorybookWdioOptions & {
+  list?: boolean;
+  url?: string;
+  target?: string;
+};
+
 export class DesktopStorybookCli {
   readonly config: DesktopStorybookConfig;
   readonly instance: DesktopStorybookInstance;
@@ -163,6 +171,72 @@ export class DesktopStorybookCli {
     return resolvedOutput;
   }
 
+  async test(platform: Platforms, options: DesktopStorybookTestOptions = {}): Promise<void> {
+    const settings = resolveWdioOptions({
+      ...this.config.wdio,
+      ...Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined)),
+    });
+    const manifest = await this.createStoryManifest(this.config, platform);
+    const selected = selectWdioStories(manifest, settings);
+    if (selected.length === 0) {
+      throw new Error('No executable wdio story tests matched the requested selection.');
+    }
+    if (options.list) {
+      this.output.write(
+        `${JSON.stringify(
+          selected.map(({ id, sourcePath }) => ({ id, sourcePath })),
+          null,
+          2,
+        )}\n`,
+      );
+      return;
+    }
+    const 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,
+      );
+    }
+    const results = await runWdioStoryTests({ ...settings, ...connection, config: this.config, manifest, platform }, this.runner);
+    this.output.write(
+      `Ran ${results.length} executable wdio stories (${results.filter(({ status }) => status === 'passed').length} passed, ` +
+        `${results.filter(({ status }) => status === 'skipped').length} skipped).\n`,
+    );
+  }
+
+  private testConnection(platform: Platforms, options: DesktopStorybookTestOptions): { 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.');
+      }
+      return { targetId: options.target, url: options.url };
+    }
+    const manifestPath = path.join(this.config.projectRoot, 'storybook-desktop.generated', `driver-manifest.${platform}.json`);
+    if (!fs.existsSync(manifestPath)) {
+      throw new Error(`Start storybook driver --${platform} and launch the app before running storybook test.`);
+    }
+    const manifest: unknown = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    if (
+      typeof manifest !== 'object' ||
+      manifest === null ||
+      !('endpoint' in manifest) ||
+      manifest.endpoint !== platform ||
+      !('instanceId' in manifest) ||
+      manifest.instanceId !== this.instance.id ||
+      !('driverPort' in manifest) ||
+      typeof manifest.driverPort !== 'number' ||
+      !Number.isInteger(manifest.driverPort) ||
+      manifest.driverPort < 1 ||
+      manifest.driverPort > 65535 ||
+      !('targetId' in manifest) ||
+      manifest.targetId !== `${this.config.appName}-${platform}`.toLowerCase()
+    ) {
+      throw new Error(`Invalid Storybook driver instance at ${manifestPath}; restart storybook driver --${platform}.`);
+    }
+    return { targetId: manifest.targetId, url: loopbackUrl(manifest.driverPort) };
+  }
+
   printInstance(platform: Platforms): void {
     this.output.write(
       `${JSON.stringify(
diff --git a/packages/agentic/storybook-desktop/src/cli/README.md b/packages/agentic/storybook-desktop/src/cli/README.md
index 671b237e51..55359a1b83 100644
--- a/packages/agentic/storybook-desktop/src/cli/README.md
+++ b/packages/agentic/storybook-desktop/src/cli/README.md
@@ -68,6 +68,7 @@ root filename.
 | `bundle`       | Generate the selected story catalog and produce its release JavaScript bundle through `rnx-cli`. |
 | `build`        | Build the selected native project without launching it.                                          |
 | `run`          | Build and launch the selected native app or configured prebuilt host.                            |
+| `test`         | Run inline `wdio` callbacks against a running driver/app, or discover them with `--list`.        |
 | `smoke`        | Own the server, Metro, app launch, all-story traversal, optional authored tests, and cleanup.    |
 
 The TypeScript API exposes the same operations through
@@ -114,6 +115,12 @@ Metro process is required.
 
 ## End-to-end tests
 
+Use `yarn storybook test --macos --story 'components-button--*'` for executable
+story callbacks. It uses the app's `wdio` settings in `storybook.config.mts`
+and Node's built-in test runner, not a separate WDIO configuration. Start
+`storybook driver` and launch the app first; `--list` needs neither.
+See [inline test authoring and lifecycle requirements](../../README.md#executable-tests-inside-stories).
+
 Use `smoke` for the standard renderability gate:
 
 ```sh
diff --git a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
index 21a9ff54af..51de9dc698 100644
--- a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
+++ b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
@@ -8,6 +8,7 @@ import type {
   DesktopStorybookCliOptions,
   DesktopStorybookPrepOptions,
   DesktopStorybookServerOptions,
+  DesktopStorybookTestOptions,
 } from './DesktopStorybookCli.js';
 import { DesktopStorybookCli } from './DesktopStorybookCli.js';
 import { loadDesktopStorybookConfig } from './loadConfig.js';
@@ -58,6 +59,7 @@ export function createDesktopStorybookCommand(options: CreateDesktopStorybookCom
   addDriverCommand(program, getApi);
   addManifestCommand(program, getApi);
   addInstanceCommand(program, getApi);
+  addTestCommand(program, getApi);
   addPrepCommand(program, getApi);
   addActionCommand(program, 'bundle', 'Generate stories and create the platform JavaScript bundle.', getApi);
   addActionCommand(program, 'run', 'Build and launch the native Storybook app.', getApi);
@@ -67,6 +69,34 @@ export function createDesktopStorybookCommand(options: CreateDesktopStorybookCom
   return program;
 }
 
+function addTestCommand(program: Command, getApi: () => Promise<DesktopStorybookCli>): void {
+  const command = program
+    .command('test')
+    .description('Run executable wdio story callbacks against the running Storybook app.')
+    .option('--list', 'list selected executable stories without connecting')
+    .option('--story <glob>', 'filter Storybook IDs')
+    .option('--tag <tag>', 'filter story tags')
+    .option('--url <url>', 'Desktop Driver URL (requires --target)')
+    .option('--target <id>', 'registered target ID (requires --url)')
+    .option('--timeout-ms <milliseconds>', 'timeout per executable story', Number)
+    .addOption(new Option('--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) => {
+    const api = await getApi();
+    await api.test(resolvePlatform(flags, api), {
+      clickMode: flags.clickMode,
+      list: flags.list,
+      reporter: flags.reporter,
+      story: flags.story,
+      tag: flags.tag,
+      target: flags.target,
+      timeoutMs: flags.timeoutMs,
+      url: flags.url,
+    });
+  });
+}
+
 function addPrepCommand(program: Command, getApi: () => Promise<DesktopStorybookCli>): void {
   const command = program
     .command('prep')
diff --git a/packages/agentic/storybook-desktop/src/cli/index.ts b/packages/agentic/storybook-desktop/src/cli/index.ts
index bd9b0beca0..62e120c6f5 100644
--- a/packages/agentic/storybook-desktop/src/cli/index.ts
+++ b/packages/agentic/storybook-desktop/src/cli/index.ts
@@ -9,6 +9,7 @@ export {
   type DesktopStorybookCliOptions,
   type DesktopStorybookPrepOptions,
   type DesktopStorybookServerOptions,
+  type DesktopStorybookTestOptions,
 } from './DesktopStorybookCli.js';
 export {
   NodeDesktopCommandRunner,
diff --git a/packages/agentic/storybook-desktop/src/config/index.ts b/packages/agentic/storybook-desktop/src/config/index.ts
index 2727544faf..93b3b5a034 100644
--- a/packages/agentic/storybook-desktop/src/config/index.ts
+++ b/packages/agentic/storybook-desktop/src/config/index.ts
@@ -40,3 +40,4 @@ export type {
 } from './makeDesktopStorybookConfig.ts';
 export { FURN_STORYBOOK_PLATFORM, getAllPlatforms, getPlatform, isPlatform, setPlatform } from './platforms.ts';
 export type { Platforms } from './platforms.ts';
+export type { DesktopStorybookWdioOptions } from './wdio.js';
diff --git a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
index 504f168ac0..c79e06550f 100644
--- a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
+++ b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
@@ -15,6 +15,7 @@ import type {
 } from './commands.ts';
 import { getAllPlatforms, getPlatform, isPlatform } from './platforms.ts';
 import type { Platforms } from './platforms.ts';
+import { resolveWdioOptions, type DesktopStorybookWdioOptions } from './wdio.js';
 
 const defaultStoryPatterns = ['src/**/*.stories.?(ts|tsx)'] as const;
 const defaultDeviceAddons = ['@storybook/addon-ondevice-controls', '@storybook/addon-ondevice-actions'] as const;
@@ -113,6 +114,9 @@ export type DesktopStorybookConfigOptions = StorySettings & {
    * Native project, command, and smoke-test settings for each desktop platform.
    */
   platformOptions?: DesktopPlatformOptionsMap;
+
+  /** Defaults for executable story callbacks, run by `storybook-desktop test`. */
+  wdio?: DesktopStorybookWdioOptions;
 };
 
 export type ResolvedPackage = {
@@ -158,6 +162,10 @@ export class DesktopStorybookConfig {
     return getPlatform();
   }
 
+  get wdio(): ReturnType<typeof resolveWdioOptions> {
+    return resolveWdioOptions(this.config.wdio);
+  }
+
   get platforms(): readonly Platforms[] {
     return this.config.platforms ?? getAllPlatforms(this.projectRoot);
   }
@@ -503,6 +511,7 @@ function defaultSmokeOptions(config: DesktopStorybookConfig, platform: Platforms
 }
 
 function normalizeConfig(config: DesktopStorybookConfigOptions, projectRoot: string): DesktopStorybookConfigOptions {
+  const wdio = resolveWdioOptions(config.wdio);
   validatePlatforms(config.platforms, 'config');
   validatePlatformSettings(config.platformSettings, 'config');
   validateDesktopPlatformOptions(config.platformOptions);
@@ -534,6 +543,7 @@ function normalizeConfig(config: DesktopStorybookConfigOptions, projectRoot: str
 
   return {
     ...config,
+    wdio,
     ...normalizeStorySettings(config),
     storyPackages: normalizedStoryPackages,
     deviceAddons: config.deviceAddons ? [...config.deviceAddons] : undefined,
diff --git a/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
new file mode 100644
index 0000000000..e825d160d7
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
@@ -0,0 +1,93 @@
+import path from 'node:path';
+
+import { transformSync } from '@babel/core';
+
+const { createDesktopStorybookBabelConfig } = require('../../config/babel.cjs');
+
+function transform(code: string, platform = 'macos', filename = 'button.stories.tsx') {
+  return transformSync(code, {
+    ...createDesktopStorybookBabelConfig({ caller: (select: (caller: { platform: string }) => string) => select({ platform }) }),
+    babelrc: false,
+    configFile: false,
+    filename: path.join(__dirname, filename),
+  })!.code!;
+}
+
+describe('native Storybook test stripping', () => {
+  test.each(['macos', 'windows', 'win32'])(
+    'strips only top-level story callbacks before native imports are collected on %s',
+    (platform) => {
+      const output = transform(
+        `
+      import { View } from 'react-native';
+      import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
+      export default { title: 'Button', component: View };
+      export const Example: WdioStory = {
+        args: { wdio: 'keep-arg' },
+        parameters: { wdio: () => 'keep-parameter' },
+        render: () => <View testID="keep-render" />,
+        wdio: async ({ browser }: Context): Promise<void> => {
+          const assert = await import('node:assert');
+          const helper = await import('@babel/core');
+          const button: unknown = await browser.$('~button');
+          assert.ok(button);
+          console.log(helper.version);
+        },
+      } satisfies WdioStory;
+      `,
+        platform,
+      );
+      expect(output).not.toMatch(/node:assert|@babel\/core|storybook-desktop\/testing|Context|Promise<void>/);
+      expect(output).toContain('react-native');
+      expect(output).toContain('keep-render');
+      expect(output).toContain('keep-arg');
+      expect(output).toContain('keep-parameter');
+      expect(output).not.toContain('~button');
+    },
+  );
+
+  test('preserves ordinary render code and nested wdio objects', () => {
+    const story = `
+      import { View } from 'react-native';
+      export default { component: View };
+      export const Example = { render: () => <View testID="button" />, args: { wdio: 'arg' } CALLBACK };
+    `;
+    expect(transform(story.replace('CALLBACK', ', wdio: () => console.log(process.version)'))).toBe(
+      transform(story.replace('CALLBACK', '')),
+    );
+  });
+
+  test('leaves non-story files untouched', () => {
+    const output = transform(`export const configuration = { wdio: () => 'not-a-story' };`, 'macos', 'configuration.ts');
+    expect(output).toContain('wdio');
+    expect(output).toContain('not-a-story');
+  });
+
+  test('strips local object exports and multiple aliases without double-removing a property', () => {
+    const output = transform(`const local = { wdio: () => console.log('remove-me'), args: {} }; export { local as One, local as Two };`);
+    expect(output).not.toContain('remove-me');
+    expect(output).not.toContain('wdio');
+    expect(output).toContain('One');
+    expect(output).toContain('Two');
+  });
+
+  test.each([
+    [`export const Example = { wdio: importedCallback };`, /inline/],
+    [`export const Example = { ...shared };`, /spread/],
+    [`export const Example = { ['wdio']: () => {} };`, /computed/],
+    [`export const Example = { wdio: () => {}, wdio: () => {} };`, /duplicate/],
+    [`export const Example = { wdio: async ({ browser }) => import(browser.name) };`, /literal string/],
+    [`import { helper } from 'render-helper'; export const Example = { wdio: () => helper() };`, /story-module binding/],
+    [`export const Example = { wdio: () => <View /> };`, /JSX/],
+  ])('fails closed for unsupported native authoring', (source, message) => {
+    expect(() => transform(source)).toThrow(message);
+    expect(() => transform(source)).toThrow(/button\.stories\.tsx/);
+  });
+
+  test('retains Win32 Unicode regex compatibility without applying it to macOS', () => {
+    const source = `export const Example = { render: () => new RegExp('\\\\p{Letter}', 'u').test('a'), wdio: () => console.log('remove') };`;
+    expect(transform(source, 'macos')).toContain('p{Letter}');
+    expect(transform(source, 'win32')).not.toContain('p{Letter}');
+    expect(transform(source, 'win32')).not.toContain('remove');
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.test.ts b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
new file mode 100644
index 0000000000..dd816c2bfc
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/wdio.test.ts
@@ -0,0 +1,27 @@
+import { makeDesktopStorybookConfig } from './makeDesktopStorybookConfig.js';
+import { resolveWdioOptions } from './wdio.js';
+
+describe('Storybook-owned wdio configuration', () => {
+  test('provides defaults and snapshots caller settings', () => {
+    expect(resolveWdioOptions()).toEqual({ timeoutMs: 30_000, reporter: 'spec', clickMode: 'auto' });
+    const wdio = { timeoutMs: 2000, story: 'components-button--*', tag: 'native' };
+    const config = makeDesktopStorybookConfig({ wdio });
+    wdio.timeoutMs = 1;
+    expect(config.wdio).toEqual({
+      timeoutMs: 2000,
+      story: 'components-button--*',
+      tag: 'native',
+      reporter: 'spec',
+      clickMode: 'auto',
+    });
+  });
+
+  test.each([0, -1, NaN, Infinity, 1.5, 2_147_483_648])('rejects invalid timeout %s', (timeoutMs) => {
+    expect(() => makeDesktopStorybookConfig({ wdio: { timeoutMs } })).toThrow('wdio.timeoutMs');
+  });
+
+  test('rejects empty filters', () => {
+    expect(() => resolveWdioOptions({ story: '' })).toThrow('wdio.story');
+    expect(() => resolveWdioOptions({ tag: ' ' })).toThrow('wdio.tag');
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.ts b/packages/agentic/storybook-desktop/src/config/wdio.ts
new file mode 100644
index 0000000000..97ba92c671
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/wdio.ts
@@ -0,0 +1,30 @@
+import type { DesktopWebdriverOptions } from '@fluentui-react-native/desktop-driver/wdio';
+
+export type DesktopStorybookWdioOptions = {
+  clickMode?: DesktopWebdriverOptions['clickMode'];
+  reporter?: 'spec' | 'tap' | 'dot';
+  story?: string;
+  tag?: string;
+  timeoutMs?: number;
+};
+
+export function resolveWdioOptions(
+  options: DesktopStorybookWdioOptions = {},
+): Readonly<Required<Pick<DesktopStorybookWdioOptions, 'timeoutMs' | 'reporter' | 'clickMode'>> & DesktopStorybookWdioOptions> {
+  const { timeoutMs = 30_000, reporter = 'spec', clickMode = 'auto' } = options;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647) {
+    throw new TypeError('wdio.timeoutMs must be a positive 32-bit integer.');
+  }
+  if (!['spec', 'tap', 'dot'].includes(reporter)) {
+    throw new TypeError('wdio.reporter must be spec, tap, or dot.');
+  }
+  if (!['auto', 'accessibility', 'physical'].includes(clickMode)) {
+    throw new TypeError('wdio.clickMode must be auto, accessibility, or physical.');
+  }
+  for (const key of ['story', 'tag'] as const) {
+    if (options[key] !== undefined && (typeof options[key] !== 'string' || !options[key].trim())) {
+      throw new TypeError(`wdio.${key} must be a non-empty string.`);
+    }
+  }
+  return Object.freeze({ ...options, timeoutMs, reporter, clickMode });
+}
diff --git a/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts b/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
index b75f4f9a41..13e9f8b576 100644
--- a/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
 import path from 'node:path';
 
 import type { DesktopStorybookConfig, ResolvedStoryPackage } from '../config/makeDesktopStorybookConfig.js';
@@ -20,6 +22,62 @@ function fixtureConfig() {
 }
 
 describe('createDesktopStoryManifest', () => {
+  test('records executable digests without code and preserves existing static and portable digests', async () => {
+    const story = {
+      id: 'components-fixturebutton--default',
+      name: 'Default',
+      parameters: {
+        desktopDriver: {
+          version: 1,
+          tests: [{ id: 'static', steps: [{ action: 'click', target: { testId: 'button' } }] }],
+        },
+      },
+    };
+    const tools = {
+      loadCsf: () => ({
+        parse: () => ({ _stories: { Default: story }, stories: [story], meta: { title: 'Components/FixtureButton' } }),
+      }),
+    };
+    async function manifestForSource(source: string) {
+      const read = jest.spyOn(fs, 'readFileSync').mockReturnValueOnce(source);
+      try {
+        return await createDesktopStoryManifest(fixtureConfig(), 'windows', tools);
+      } finally {
+        read.mockRestore();
+      }
+    }
+    const before = await manifestForSource(`export const Default = {};`);
+    const first = await manifestForSource(`export const Default = { wdio: () => console.log('first-test') };`);
+    const changed = await manifestForSource(`export const Default = { wdio: () => console.log('changed-test') };`);
+    expect(before.entries[0]).not.toHaveProperty('wdio');
+    expect(before.platformManifestDigest).toBe(
+      createHash('sha256')
+        .update(JSON.stringify({ endpoint: 'windows', entries: before.entries }))
+        .digest('hex'),
+    );
+    expect(first.entries[0].wdio).toEqual({ digest: expect.stringMatching(/^[a-f0-9]{64}$/), exportName: 'Default' });
+    expect(JSON.stringify(first)).not.toMatch(/console\.log|first-test/);
+    expect(first.entries[0].tests).toEqual(before.entries[0].tests);
+    expect(first.portablePlanDigest).toBe(before.portablePlanDigest);
+    expect(changed.portablePlanDigest).toBe(before.portablePlanDigest);
+    expect(first.platformManifestDigest).not.toBe(before.platformManifestDigest);
+    expect(changed.platformManifestDigest).not.toBe(first.platformManifestDigest);
+    expect(changed.entries[0].wdio!.digest).not.toBe(first.entries[0].wdio!.digest);
+  });
+
+  test('fails instead of silently dropping callbacks from excluded or unrecognized story exports', async () => {
+    const read = jest.spyOn(fs, 'readFileSync').mockReturnValueOnce(`export const Excluded = { wdio: () => {} };`);
+    try {
+      await expect(
+        createDesktopStoryManifest(fixtureConfig(), 'windows', {
+          loadCsf: () => ({ parse: () => ({ _stories: {}, stories: [], meta: { title: 'Components/FixtureButton' } }) }),
+        }),
+      ).rejects.toThrow(/button\.stories\.ts.*"Excluded" is not a recognized story export/);
+    } finally {
+      read.mockRestore();
+    }
+  });
+
   test('extracts serializable plans and creates stable platform and portable digests', async () => {
     const tools = {
       loadCsf: () => ({
diff --git a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
index f7a62bb78b..9c8c8c2746 100644
--- a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
@@ -9,6 +9,7 @@ import type { DesktopStoryManifest, DesktopStoryManifestEntry, DesktopStoryTests
 
 import type { DesktopStorybookConfig, ResolvedStoryPackage } from '../config/makeDesktopStorybookConfig.js';
 import type { Platforms } from '../config/platforms.js';
+import { extractWdioTests } from '../testing/extractWdioTests.js';
 
 type StaticStory = {
   id: string;
@@ -76,6 +77,12 @@ export async function createDesktopStoryManifest(
         throw new Error(`Failed to statically parse Storybook file ${sourceFile}: ${(error as Error).message}`, { cause: error });
       }
       const stories = csf._stories ? Object.entries(csf._stories) : csf.stories.map((story) => [story.name ?? story.id, story] as const);
+      const wdioTests = extractWdioTests(code, sourceFile);
+      for (const exportName of wdioTests.keys()) {
+        if (!stories.some(([name]) => name === exportName)) {
+          throw new Error(`Story wdio in ${sourceFile}: "${exportName}" is not a recognized story export.`);
+        }
+      }
       for (const [exportName, staticStory] of stories) {
         const tests = readDesktopStoryTests(
           extractDesktopStoryTests(csf._storyAnnotations?.[exportName]?.parameters, sourceFile, staticStory.id) ??
@@ -91,6 +98,7 @@ export async function createDesktopStoryManifest(
           tags: [...new Set([...(csf.meta?.tags ?? []), ...(staticStory.tags ?? []), 'story'])].sort(),
           title: csf.meta?.title ?? staticStory.id.split('--')[0],
           ...(tests ? { tests } : {}),
+          ...(wdioTests.has(exportName) ? { wdio: { digest: wdioTests.get(exportName)!.digest, exportName } } : {}),
         });
       }
 
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
new file mode 100644
index 0000000000..c46216715a
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -0,0 +1,218 @@
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+
+import { extractWdioTests } from './extractWdioTests.js';
+
+const sourceFile = path.resolve(__dirname, 'fixture.stories.tsx');
+
+describe('extractWdioTests', () => {
+  test('extracts a standalone typed callback without loading the native story module', async () => {
+    const tests = extractWdioTests(
+      `
+      import { NativeComponent } from 'react-native-module-that-must-not-load';
+      import type { Story, TestContext } from 'types-that-must-not-load';
+      throw new Error('the render module must never execute');
+      export default { component: NativeComponent };
+      export const Example: Story = {
+        render: () => <NativeComponent />,
+        wdio: (async ({ browser }: TestContext): Promise<void> => {
+          const selector: string = '~example';
+          const local = async (value: string) => browser.$(value);
+          await (await local(selector)).click();
+        }) satisfies TestContext['callback'],
+      } satisfies Story;
+      `,
+      sourceFile,
+    );
+    expect([...tests.keys()]).toEqual(['Example']);
+    const { code, digest } = tests.get('Example')!;
+    expect(code).not.toMatch(/TestContext|Promise<void>|: string|NativeComponent/);
+    expect(digest).toMatch(/^[a-f0-9]{64}$/);
+    const click = jest.fn();
+    const select = jest.fn().mockResolvedValue({ click });
+    await vm.runInNewContext(`(${code})`)({ browser: { $: select } });
+    expect(select).toHaveBeenCalledWith('~example');
+    expect(click).toHaveBeenCalledTimes(1);
+  });
+
+  test('supports satisfies, assertions, local declarations, and named export aliases', () => {
+    const tests = extractWdioTests(
+      `
+      const local: Story = ({
+        wdio: function check({ expect }: Context) {
+          type Value = { count: number };
+          const value: Value = { count: 1 };
+          class Counter { value = value; }
+          const nested = () => new Counter().value.count;
+          expect(nested()).toBe(1);
+        },
+      } as Story)!;
+      export { local as Renamed };
+      `,
+      sourceFile,
+    );
+    expect([...tests.keys()]).toEqual(['Renamed']);
+    expect(tests.get('Renamed')!.code).toContain('function check');
+    expect(() => vm.runInNewContext(`(${tests.get('Renamed')!.code})`)).not.toThrow();
+  });
+
+  test('resolves literal helper imports from the original file and normalizes Node builtins', () => {
+    const { code } = extractWdioTests(
+      `export const Example = { wdio: async () => {
+        const assert = await import('assert/strict');
+        const { types } = await import('@babel/core');
+        await import('./types.ts');
+        assert.ok(types.isIdentifier(types.identifier('example')));
+      } };`,
+      sourceFile,
+    ).get('Example')!;
+    const requireFromSource = createRequire(sourceFile);
+    expect(code).toContain('node:assert/strict');
+    expect(code).toContain(pathToFileURL(requireFromSource.resolve('@babel/core')).href);
+    expect(code).toContain(pathToFileURL(requireFromSource.resolve('./types.ts')).href);
+  });
+
+  test('runs extracted builtin and bare helper imports in an isolated Node module', () => {
+    const { code } = extractWdioTests(
+      `export const Example = { wdio: async () => {
+        const assert = await import('node:assert/strict');
+        const { types } = await import('@babel/core');
+        assert.ok(types.isIdentifier(types.identifier('example')));
+      } };`,
+      sourceFile,
+    ).get('Example')!;
+    const result = spawnSync(process.execPath, ['--input-type=module', '--eval', `await (${code})({});`], { encoding: 'utf8' });
+    expect(result.stderr).toBe('');
+    expect(result.status).toBe(0);
+  });
+
+  test('allows Node globals and nested callback-local closures', () => {
+    expect(() =>
+      extractWdioTests(
+        `const value = 'outside';
+        export const Example = { wdio: async ({ expect }) => {
+          const value = Buffer.from('inside');
+          const local = () => value.toString();
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          console.log(process.version, globalThis, new URL('https://example.com'));
+          expect(local()).toBe('inside');
+        } };`,
+        sourceFile,
+      ),
+    ).not.toThrow();
+  });
+
+  test('allows locally bound this, arguments, super, and new.target', async () => {
+    const { code } = extractWdioTests(
+      `export const Example = { wdio: function () {
+        class Base { value = 1; }
+        class Local extends Base {
+          constructor() { super(); this.value++; }
+          read() { return (() => this.value)(); }
+        }
+        function constructorTarget() { return new.target; }
+        function first() { return arguments[0]; }
+        return first(new Local().read()) + (new constructorTarget() === constructorTarget ? 1 : 0);
+      } };`,
+      sourceFile,
+    ).get('Example')!;
+    expect(await vm.runInNewContext(`(${code})`)()).toBe(3);
+  });
+
+  test.each([
+    ['an imported closure', `import { helper } from './render';`, `async () => helper()`, /helper.*story-module binding/],
+    ['a module constant', `const selector = '~button';`, `async ({ browser }) => browser.$(selector)`, /selector.*story-module binding/],
+    ['a shadowed global', `const process = { version: 1 };`, `() => process.version`, /process.*story-module binding/],
+    ['an unknown global', '', `() => window.location`, /window.*Node global/],
+    ['require', '', `() => require('node:fs')`, /require.*Node global/],
+    ['an unbound assignment', '', `() => { missing = 1; }`, /missing.*Node global/],
+    ['an unbound destructuring assignment', '', `() => { ({ value: missing } = {}); }`, /missing.*Node global/],
+    ['an unbound update', '', `() => missing++`, /missing.*Node global/],
+    ['an unbound for-of variable', '', `() => { for (missing of []) {} }`, /missing.*Node global/],
+    ['JSX', '', `() => <View />`, /JSX/],
+    ['JSX fragments', '', `() => <></>`, /JSX/],
+    ['lexical this', '', `() => this.value`, /ThisExpression/],
+    ['lexical this in a class base', '', `() => { class Local extends this.Base {} return Local; }`, /ThisExpression/],
+    ['lexical this in a computed class method', '', `() => { class Local { [this.key]() {} } return Local; }`, /ThisExpression/],
+    ['lexical this in a computed object method', '', `() => ({ [this.key]() {} })`, /ThisExpression/],
+    ['module location', '', `() => import.meta.url`, /MetaProperty/],
+    ['lexical arguments', '', `() => arguments[0]`, /arguments.*Node global/],
+    ['a dynamic import', '', `async ({ browser }) => import(browser.name)`, /literal string/],
+    ['a template import', '', 'async () => import(`node:fs`)', /literal string/],
+    ['an unresolved import', '', `async () => import('missing-wdio-helper-package')`, /cannot resolve import/],
+    ['a native import', '', `async () => import('react-native')`, /React Native/],
+    ['a Windows native import', '', `async () => import('react-native-windows')`, /React Native/],
+  ])('rejects %s with source context', (_name, prefix, callback, message) => {
+    const source = `${prefix}\nexport const Example = {\n  wdio: ${callback},\n};`;
+    let error: Error | undefined;
+    try {
+      extractWdioTests(source, sourceFile);
+    } catch (caught) {
+      error = caught as Error;
+    }
+    expect(error?.message).toMatch(message);
+    expect(error?.message).toContain(sourceFile);
+    expect(error?.message).toContain('3 |');
+  });
+
+  test.each([
+    [`{ wdio: callback }`, /inline/],
+    [`{ wdio: makeCallback() }`, /inline/],
+    [`{ wdio: true }`, /inline/],
+    [`{ wdio: () => {}, wdio: () => {} }`, /duplicate/],
+    [`{ wdio: () => {}, 'wdio': () => {} }`, /duplicate/],
+    [`{ async wdio() {} }`, /method or accessor/],
+    [`{ get wdio() { return () => {}; } }`, /method or accessor/],
+    [`{ wdio: function* () {} }`, /non-generator/],
+    [`{ ...shared, wdio: () => {} }`, /spread/],
+    [`{ wdio: () => {}, ...shared }`, /spread/],
+    [`{ ...shared }`, /spread/],
+    [`{ ['wdio']: () => {} }`, /computed/],
+    [`{ [key]: () => {} }`, /computed/],
+    [`makeStory({ wdio: () => {} })`, /object literal/],
+  ])('rejects unsupported authoring %s', (story, message) => {
+    expect(() => extractWdioTests(`export const Example = ${story};`, sourceFile)).toThrow(message);
+  });
+
+  test('rejects later callback assignments and callbacks on the default meta', () => {
+    expect(() => extractWdioTests(`export const Example = {}; Example.wdio = () => {};`, sourceFile)).toThrow(/property assignment/);
+    expect(() => extractWdioTests(`export default { wdio: () => {} };`, sourceFile)).toThrow(/default meta/);
+    expect(() =>
+      extractWdioTests(`const local = {}; const alias = local; export { alias as Example }; local.wdio = () => {};`, sourceFile),
+    ).toThrow(/property assignment/);
+    expect(() => extractWdioTests(`export let Example = { wdio: () => {} }; Example = {};`, sourceFile)).toThrow(/reassigned/);
+    expect(() => extractWdioTests(`export const Example = {}; Object.assign(Example, { wdio: () => {} });`, sourceFile)).toThrow(
+      /Object mutations/,
+    );
+  });
+
+  test('does not extract nested unrelated properties', () => {
+    expect(
+      extractWdioTests(
+        `export const Example = { args: { wdio: 'arg' }, parameters: { wdio: () => 'parameter' }, render: () => ({ wdio: 'render' }) };`,
+        sourceFile,
+      ).size,
+    ).toBe(0);
+    expect(
+      extractWdioTests(
+        `export const Example = () => {
+          const Example = { wdio: 'unrelated' };
+          Example.wdio = 'keep';
+          return Example;
+        };`,
+        sourceFile,
+      ).size,
+    ).toBe(0);
+  });
+
+  test('digests track callback source but not render-only changes', () => {
+    const source = `export const Example = { args: { count: 1 }, wdio: () => console.log('test') };`;
+    const digest = (code: string) => extractWdioTests(code, sourceFile).get('Example')!.digest;
+    expect(digest(source.replace('count: 1', 'count: 2'))).toBe(digest(source));
+    expect(digest(source.replace("'test'", "'changed'"))).not.toBe(digest(source));
+    expect(digest(source.replace('console.log', '/* source change */ console.log'))).not.toBe(digest(source));
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
new file mode 100644
index 0000000000..44e899208e
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -0,0 +1,35 @@
+import { createHash } from 'node:crypto';
+
+import { transformSync, type NodePath, type types } from '@babel/core';
+
+import storyTests from '../../config/transform-story-tests.cjs';
+
+const { collectWdioTests, compileWdioTest } = storyTests;
+
+export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<string, { code: string; digest: string }> {
+  const tests = new Map<string, { code: string; digest: string }>();
+  transformSync(code, {
+    babelrc: false,
+    code: false,
+    configFile: false,
+    filename: sourceFile,
+    parserOpts: { plugins: ['typescript', 'jsx'] },
+    plugins: [
+      () => ({
+        visitor: {
+          Program(program: NodePath<types.Program>) {
+            for (const [exportName, { callback }] of collectWdioTests(program)) {
+              const compiled = compileWdioTest(callback, sourceFile, code);
+              const source = code.slice(callback.node.start!, callback.node.end!);
+              tests.set(exportName, {
+                code: compiled,
+                digest: createHash('sha256').update(source).update('\0').update(compiled).digest('hex'),
+              });
+            }
+          },
+        },
+      }),
+    ],
+  });
+  return tests;
+}
diff --git a/packages/agentic/storybook-desktop/src/testing/index.ts b/packages/agentic/storybook-desktop/src/testing/index.ts
new file mode 100644
index 0000000000..994006b4d1
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/index.ts
@@ -0,0 +1 @@
+export type { WdioStory, WdioStoryContext } from './types.js';
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
new file mode 100644
index 0000000000..7bca0eb9bc
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -0,0 +1,245 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type { DesktopStoryManifest, DesktopStoryManifestEntry } from '@fluentui-react-native/desktop-driver';
+import { ArtifactManager } from '@fluentui-react-native/desktop-driver/artifacts';
+import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
+import type { DesktopWebdriverSession } from '@fluentui-react-native/desktop-driver/wdio';
+
+import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
+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 type { WdioWorkerOptions } from './worker.js';
+
+export type WdioStoryTestResult = {
+  storyId: string;
+  status: 'passed' | 'failed' | 'skipped';
+  durationMs: number;
+  error?: string;
+  skipReason?: string;
+  evidenceErrors?: string[];
+};
+
+export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
+  config: DesktopStorybookConfig;
+  manifest: DesktopStoryManifest;
+  platform: Platforms;
+  targetId: string;
+  url: string;
+  artifactsRoot?: string;
+};
+
+export function selectWdioStories(
+  manifest: DesktopStoryManifest,
+  options: DesktopStorybookWdioOptions,
+): 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))
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export async function runWdioStoryTests(
+  options: RunWdioStoryTestsOptions,
+  runner: DesktopCommandRunner = new NodeDesktopCommandRunner(),
+): Promise<readonly WdioStoryTestResult[]> {
+  const settings = resolveWdioOptions(options);
+  const stories = selectWdioStories(options.manifest, settings);
+  if (stories.length === 0) {
+    throw new Error('No executable wdio story tests matched the requested selection.');
+  }
+  const cases = stories.map((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.`);
+    }
+    return { entry, code: extracted.code };
+  });
+  const artifacts = new ArtifactManager(
+    options.artifactsRoot ?? path.join(options.config.projectRoot, 'artifacts', options.platform, 'wdio'),
+  );
+  const generatedRoot = path.join(options.config.projectRoot, 'storybook-desktop.generated', 'wdio');
+  fs.mkdirSync(generatedRoot, { recursive: true });
+  const directory = fs.mkdtempSync(path.join(generatedRoot, 'run-'));
+  const workerUrl = pathToFileURL(
+    path.join(options.config.resolvePackage('@fluentui-react-native/storybook-desktop').root, 'lib', 'testing', 'worker.js'),
+  ).href;
+  const results: WdioStoryTestResult[] = [];
+  let infrastructureFailure: unknown;
+  try {
+    for (const [index, { entry, code }] of cases.entries()) {
+      const started = Date.now();
+      // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
+      const desktop = await connectDesktopWebdriver({
+        clickMode: settings.clickMode,
+        launchMode: 'attach',
+        platformName: options.platform === 'macos' ? 'macos' : 'windows',
+        targetId: options.targetId,
+        url: options.url,
+      });
+      const result: WdioStoryTestResult = { storyId: entry.id, status: 'failed', durationMs: 0 };
+      let failure: unknown;
+      try {
+        const live = await desktop.listStories();
+        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.');
+        }
+        await desktop.resetStory(entry.id);
+        const resultPath = path.join(directory, `${index}.json`);
+        const workerOptions: WdioWorkerOptions = {
+          attachment: {
+            capabilities: desktop.browser.capabilities,
+            sessionId: desktop.browser.sessionId,
+            url: options.url,
+          },
+          resultPath,
+          storyId: entry.id,
+          timeoutMs: settings.timeoutMs,
+        };
+        const specPath = path.join(directory, `${index}.test.mjs`);
+        fs.writeFileSync(
+          specPath,
+          `import { registerWdioStoryTest } from ${JSON.stringify(workerUrl)};\n` +
+            `registerWdioStoryTest(${JSON.stringify(workerOptions)}, (${code}));\n`,
+          { mode: 0o600 },
+        );
+        await runWorker(
+          runner,
+          {
+            command: process.execPath,
+            args: [
+              '--test',
+              '--test-concurrency=1',
+              '--test-force-exit',
+              `--test-timeout=${Math.min(settings.timeoutMs + 5000, 2_147_483_647)}`,
+              `--test-reporter=${settings.reporter}`,
+              specPath,
+            ],
+            cwd: options.config.projectRoot,
+            env: {},
+          },
+          Math.min(settings.timeoutMs + 5000, 2_147_483_647),
+        );
+        const outcome: unknown = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
+        if (!isWorkerResult(outcome)) {
+          throw new Error(`The wdio worker for ${entry.id} exited without a valid result.`);
+        }
+        result.status = outcome.status;
+        if (outcome.status === 'skipped') {
+          result.skipReason = outcome.skipReason;
+        }
+      } catch (error) {
+        failure = error;
+        result.error = errorMessage(error);
+        result.evidenceErrors = await captureFailure(desktop, artifacts, entry.id);
+      }
+      try {
+        await desktop.delete();
+      } catch (cleanupError) {
+        throw new AggregateError(
+          failure === undefined ? [cleanupError] : [failure, cleanupError],
+          `Could not release the wdio session for ${entry.id}; stopping before another test starts.`,
+        );
+      }
+      result.durationMs = Date.now() - started;
+      results.push(result);
+    }
+  } catch (error) {
+    infrastructureFailure = error;
+  }
+  const failures: unknown[] = infrastructureFailure === undefined ? [] : [infrastructureFailure];
+  if (results.some(({ status }) => status === 'failed')) {
+    failures.push(
+      new Error(
+        `Executable wdio stories failed: ${results
+          .filter(({ status }) => status === 'failed')
+          .map(({ storyId }) => storyId)
+          .join(', ')}. ` + `See ${path.join(artifacts.root, 'run.json')}.`,
+      ),
+    );
+  }
+  try {
+    artifacts.writeMetadata('run', {
+      endpoint: options.platform,
+      platformManifestDigest: options.manifest.platformManifestDigest,
+      status: failures.length ? 'failed' : 'passed',
+      ...(infrastructureFailure === undefined ? {} : { error: errorMessage(infrastructureFailure) }),
+      tests: results,
+    });
+  } catch (error) {
+    failures.push(error);
+  }
+  try {
+    fs.rmSync(directory, { recursive: true, force: true });
+  } catch (error) {
+    failures.push(error);
+  }
+  if (failures.length === 1) {
+    throw failures[0];
+  }
+  if (failures.length > 1) {
+    throw new AggregateError(failures, 'Executable wdio tests and evidence/cleanup failed.');
+  }
+  return results;
+}
+
+function isWorkerResult(value: unknown): value is { status: 'passed' } | { status: 'skipped'; skipReason: string } {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'status' in value &&
+    (value.status === 'passed' || (value.status === 'skipped' && 'skipReason' in value && typeof value.skipReason === 'string'))
+  );
+}
+
+async function captureFailure(desktop: DesktopWebdriverSession, artifacts: ArtifactManager, storyId: string): Promise<string[]> {
+  const errors: string[] = [];
+  for (const capture of [
+    async () => artifacts.writeSource(storyId, 'failure-source', await desktop.session.getPageSource()),
+    async () => artifacts.writeTree(storyId, 'failure-tree', await desktop.session.getTree()),
+  ]) {
+    try {
+      await capture();
+    } catch (error) {
+      errors.push(errorMessage(error));
+    }
+  }
+  return errors;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function runWorker(runner: DesktopCommandRunner, command: PreparedDesktopCommand, timeoutMs: number): Promise<void> {
+  const worker = runner.start(command);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let failure: unknown;
+  try {
+    const exitCode = await Promise.race([
+      worker.completed,
+      new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`Executable wdio worker exceeded its ${timeoutMs}ms process deadline.`)), timeoutMs);
+      }),
+    ]);
+    if (exitCode !== 0) {
+      throw new Error(`Executable wdio worker exited with code ${exitCode}; see the test reporter for assertion details.`);
+    }
+  } catch (error) {
+    failure = error;
+  } finally {
+    clearTimeout(timer);
+  }
+  try {
+    await worker.stop();
+  } catch (error) {
+    throw new AggregateError(failure === undefined ? [error] : [failure, error], 'Could not stop the owned wdio worker.');
+  }
+  if (failure !== undefined) {
+    throw failure;
+  }
+}
diff --git a/packages/agentic/storybook-desktop/src/testing/types.ts b/packages/agentic/storybook-desktop/src/testing/types.ts
new file mode 100644
index 0000000000..0479288ad4
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/types.ts
@@ -0,0 +1,15 @@
+import type { DesktopWebdriverSession } from '@fluentui-react-native/desktop-driver/wdio';
+import type { expect } from 'expect-webdriverio';
+
+export type WdioStoryContext = {
+  browser: DesktopWebdriverSession['browser'];
+  desktop: DesktopWebdriverSession;
+  expect: typeof expect;
+  signal: AbortSignal;
+  skip(reason: string): void;
+};
+
+/** Wrap StoryObj, importing this type only; callbacks execute in Node, not React Native. */
+export type WdioStory<TStory = object> = Omit<TStory, 'wdio'> & {
+  wdio?: (context: WdioStoryContext) => void | Promise<void>;
+};
diff --git a/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts b/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
new file mode 100644
index 0000000000..1bea9c710e
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
@@ -0,0 +1,37 @@
+import type { WdioStory } from './index.js';
+
+const story: WdioStory = {
+  wdio: async ({ browser, desktop, expect, signal, skip }) => {
+    signal.throwIfAborted();
+    const button = await browser.$('~button');
+    await expect(button).toBeEnabled();
+    await desktop.expect({ state: 'enabled', target: { testId: 'button' }, value: true });
+    if (await button.isSelected()) {
+      skip('This scenario needs an unselected button.');
+    }
+    // @ts-expect-error Native state names remain checked.
+    await desktop.expect({ state: 'invented', target: { testId: 'button' }, value: true });
+    // @ts-expect-error Browser methods are WebdriverIO methods, not arbitrary properties.
+    await browser.inventedCommand();
+  },
+};
+
+const wrapped: WdioStory<{ args: { disabled: boolean }; wdio?: unknown }> = {
+  args: { disabled: false },
+  wdio: async ({ browser }) => {
+    await browser.$('~button');
+    // @ts-expect-error Wrapping existing story annotations retains the WebdriverIO callback type.
+    await browser.inventedCommand();
+  },
+};
+
+const invalidArgs: WdioStory<{ args: { disabled: boolean } }> = {
+  // @ts-expect-error Wrapping a story preserves its argument contract.
+  args: { disabled: 'false' },
+};
+
+test('exposes a type-only inline callback contract', () => {
+  expect(typeof story.wdio).toBe('function');
+  expect(typeof wrapped.wdio).toBe('function');
+  expect(invalidArgs.args).toBeDefined();
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
new file mode 100644
index 0000000000..aa498190ad
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -0,0 +1,126 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+async function main() {
+  const packageRoot = path.resolve(__dirname, '..', '..');
+  const projectRoot = path.resolve(packageRoot, '..', '..', '..', 'apps', 'storybook');
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-inline-wdio-'));
+  const [
+    { createDesktopStoryManifest },
+    { runWdioStoryTests },
+    { createDesktopDriverStoryHarness, createFakeStoryWindows },
+    { makeDesktopStorybookConfig },
+  ] = await Promise.all([
+    import(pathToFileURL(path.join(packageRoot, 'lib/driver/storyManifest.js')).href),
+    import(pathToFileURL(path.join(packageRoot, 'lib/testing/runWdioTests.js')).href),
+    import('@fluentui-react-native/desktop-driver/testing'),
+    import(pathToFileURL(path.join(packageRoot, 'lib/config/index.js')).href),
+  ]);
+  fs.writeFileSync(
+    path.join(root, 'fixture.stories.ts'),
+    `
+    import 'react-native-must-never-load-in-node';
+    export default { title: 'Fixture/Button' };
+    export const Pass = { wdio: async ({ browser, expect, desktop }) => {
+      const { strictEqual } = await import('node:assert');
+      const button = await browser.$('~button-primary');
+      await expect(button).toBeEnabled();
+      strictEqual(await button.getTagName(), 'button');
+      await button.click();
+      await desktop.expect({ state: 'focused', target: { testId: 'button-primary' }, value: true });
+    }};
+    export const Skip = { wdio: ({ skip }) => { skip('Explicit capability reason'); }};
+    export const Fail = { wdio: async () => {
+      const { strictEqual } = await import('node:assert');
+      strictEqual(1, 2, 'intentional inline assertion');
+    }};
+    export const Timeout = { wdio: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10_000));
+    }};
+    export const Spin = { wdio: () => { while (true) {} }};
+    export const Crash = { wdio: () => { process.exit(2); }};
+    export const ExitZero = { wdio: () => { process.exit(0); }};
+  `,
+  );
+  const storyPackage = { name: 'inline-fixture', root, manifest: { name: 'inline-fixture' }, storyPatterns: ['*.stories.ts'] };
+  const manifest = await createDesktopStoryManifest({ projectRoot, getStoryPackages: () => [storyPackage] }, 'windows');
+  const harness = await createDesktopDriverStoryHarness(manifest);
+  const config = {
+    projectRoot: root,
+    resolvePackage: (name) => ({ root: name === 'inline-fixture' ? root : packageRoot }),
+  };
+  const run = (story, overrides = {}) =>
+    runWdioStoryTests({
+      config,
+      manifest,
+      platform: 'windows',
+      targetId: harness.target.id,
+      url: harness.server.url,
+      story: `fixture-button--${story}`,
+      timeoutMs: 2000,
+      ...overrides,
+    });
+  try {
+    const passed = await run('pass');
+    const skipped = await run('skip');
+    const failures = [];
+    for (const story of ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale']) {
+      let rejected = false;
+      try {
+        await run(
+          story === 'stale' ? 'pass' : story,
+          story === 'stale' ? { manifest: { ...manifest, platformManifestDigest: 'stale' } } : {},
+        );
+      } catch (error) {
+        rejected = true;
+        if (!(error instanceof Error) || !error.message.includes('Executable wdio stories failed')) throw error;
+        failures.push(story);
+      }
+      if (!rejected) throw new Error(`Expected ${story} to fail.`);
+      const report = JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/wdio/run.json'), 'utf8'));
+      if (report.tests[0].status !== 'failed') throw new Error(`${story} was not persisted as failed.`);
+    }
+    const repeated = await run('pass');
+    const buttonConfig = makeDesktopStorybookConfig({ projectRoot, storyPackages: ['@fluentui-react-native/components'] });
+    const buttonManifest = await createDesktopStoryManifest(buttonConfig, 'windows');
+    const buttonHarness = await createDesktopDriverStoryHarness(buttonManifest, { windows: createFakeStoryWindows(buttonManifest) });
+    let button;
+    try {
+      button = await runWdioStoryTests({
+        config: { projectRoot: root, resolvePackage: (name) => buttonConfig.resolvePackage(name) },
+        manifest: buttonManifest,
+        platform: 'windows',
+        targetId: buttonHarness.target.id,
+        url: buttonHarness.server.url,
+        story: 'components-button--default',
+        timeoutMs: 5000,
+      });
+    } finally {
+      await buttonHarness.close();
+    }
+    process.stdout.write(
+      '\nWDIO_RESULT ' +
+        JSON.stringify({
+          passed: passed.map(({ storyId }) => storyId),
+          skipped: skipped.filter(({ status }) => status === 'skipped').map(({ storyId }) => storyId),
+          repeated: repeated.map(({ storyId }) => storyId),
+          button: button.map(({ storyId }) => storyId),
+          failures,
+          attachedOnly: harness.host.actions
+            .filter(({ type }) => type === 'close-application')
+            .every(({ ownership }) => ownership === 'attached'),
+          generatedFiles: fs.readdirSync(path.join(root, 'storybook-desktop.generated/wdio')),
+        }),
+    );
+  } finally {
+    await harness.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(error.stack ?? error.message);
+  process.exitCode = 1;
+});
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
new file mode 100644
index 0000000000..4ee1bd897a
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+test('executes isolated inline code and releases sessions after assertion failures, timeouts, and crashes', async () => {
+  const result = await new Promise<Record<string, unknown>>((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, 'wdioRunner.contract.cjs')], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const stdout: Buffer[] = [];
+    const stderr: Buffer[] = [];
+    child.stdout.on('data', (chunk: Buffer) => stdout.push(chunk));
+    child.stderr.on('data', (chunk: Buffer) => stderr.push(chunk));
+    child.once('error', reject);
+    child.once('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(Buffer.concat(stderr).toString('utf8') || `Inline test contract exited with ${code}.`));
+      } else {
+        const output = Buffer.concat(stdout).toString('utf8');
+        if (!output.includes('intentional inline assertion')) {
+          reject(new Error('Assertion diagnostics were lost.'));
+        } else {
+          resolve(JSON.parse(output.split('\nWDIO_RESULT ')[1]));
+        }
+      }
+    });
+  });
+  expect(result).toMatchObject({
+    passed: ['fixture-button--pass'],
+    skipped: ['fixture-button--skip'],
+    failures: ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale'],
+    repeated: ['fixture-button--pass'],
+    button: ['components-button--default'],
+    generatedFiles: [],
+    attachedOnly: true,
+  });
+}, 60_000);
diff --git a/packages/agentic/storybook-desktop/src/testing/worker.ts b/packages/agentic/storybook-desktop/src/testing/worker.ts
new file mode 100644
index 0000000000..82a23b069a
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/worker.ts
@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import { test } from 'node:test';
+
+import { attachDesktopWebdriver, type DesktopWebdriverAttachment } from '@fluentui-react-native/desktop-driver/wdio';
+import { expect } from 'expect-webdriverio';
+
+import type { WdioStory } from './types.js';
+
+export type WdioWorkerOptions = {
+  attachment: DesktopWebdriverAttachment;
+  resultPath: string;
+  storyId: string;
+  timeoutMs: number;
+};
+
+export function registerWdioStoryTest(options: WdioWorkerOptions, callback: NonNullable<WdioStory['wdio']>): void {
+  test(options.storyId, { timeout: options.timeoutMs }, async (context) => {
+    const desktop = await attachDesktopWebdriver(options.attachment);
+    context.signal.throwIfAborted();
+    let skipReason: string | undefined;
+    await callback({
+      browser: desktop.browser,
+      desktop,
+      expect,
+      signal: context.signal,
+      skip: (reason) => {
+        if (!reason?.trim()) {
+          throw new TypeError('Skipping a wdio story requires a reason.');
+        }
+        skipReason = reason;
+        context.skip(reason);
+      },
+    });
+    context.signal.throwIfAborted();
+    fs.writeFileSync(options.resultPath, JSON.stringify(skipReason ? { status: 'skipped', skipReason } : { status: 'passed' }));
+  });
+}
diff --git a/yarn.lock b/yarn.lock
index dc4d3b9e9b..da84163ad7 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3028,12 +3028,14 @@ __metadata:
     "@fluentui-react-native/focus-zone": "workspace:*"
     "@fluentui-react-native/framework-base": "workspace:*"
     "@fluentui-react-native/scripts": "workspace:*"
+    "@fluentui-react-native/storybook-desktop": "workspace:*"
     "@office-iss/react-native-win32": "npm:^0.81.0"
     "@react-native-community/cli": "npm:^20.0.0"
     "@react-native-community/cli-platform-android": "npm:^20.0.0"
     "@react-native-community/cli-platform-ios": "npm:^20.0.0"
     "@react-native/babel-preset": "npm:^0.81.0"
     "@react-native/metro-config": "npm:^0.81.0"
+    "@storybook/react-native": "npm:^10.4.7"
     "@testing-library/react-native": "catalog:"
     "@types/react": "npm:~19.1.4"
     react: "npm:19.1.4"
@@ -3041,6 +3043,7 @@ __metadata:
     react-native-macos: "npm:^0.81.0"
     react-native-svg: "npm:^15.12.1"
     react-native-windows: "npm:^0.81.0"
+    storybook: "npm:^10.4.0"
     test-renderer: "catalog:"
   peerDependencies:
     "@office-iss/react-native-win32": ^0.81.0
@@ -5081,11 +5084,14 @@ __metadata:
   resolution: "@fluentui-react-native/storybook-desktop@workspace:packages/agentic/storybook-desktop"
   dependencies:
     "@babel/core": "catalog:"
+    "@babel/plugin-transform-typescript": "catalog:"
     "@fluentui-react-native/desktop-driver": "workspace:*"
     "@fluentui-react-native/scripts": "workspace:*"
     "@react-native/babel-preset": "npm:^0.81.0"
     "@rnx-kit/tools-react-native": "catalog:"
+    "@wdio/logger": "catalog:"
     commander: "npm:^14.0.2"
+    expect-webdriverio: "catalog:"
     regexpu-core: "npm:^6.3.1"
   bin:
     storybook-desktop: ./config/cli.cjs

From 8912d01073957b2acf3b089d6db00b6ea4b9205d Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Mon, 14 Sep 2026 12:50:59 -0700
Subject: [PATCH 2/5] improve diagnostics and test ordering

---
 .changeset/desktop-pipeline-logging.md        |   6 +
 .changeset/story-grouped-desktop-tests.md     |   6 +
 .../references/tests-and-stories.md           |   5 +-
 .github/workflows/pr.yml                      |   3 +
 apps/storybook/AGENTS.md                      |  10 +-
 apps/storybook/README.md                      |   9 +-
 apps/storybook/agent-map.yaml                 |   4 +
 .../src/components/button/button.stories.tsx  |  24 +-
 .../references/test-integration.md            |   6 +
 .../src/runner/StoryTestRunner.test.ts        |  39 +++
 .../src/runner/StoryTestRunner.ts             |  26 +-
 .../src/wdio/DesktopWebdriver.ts              |   4 +-
 packages/agentic/storybook-desktop/README.md  |  57 +++-
 .../agentic/storybook-desktop/config/cli.cjs  |   4 +-
 .../storybook-desktop/config/diagnostics.cjs  |  13 +
 .../config/diagnostics.d.cts                  |   4 +
 .../storybook-desktop/config/server-cli.cjs   |   4 +-
 .../config/server-runner.cjs                  |   3 +-
 .../config/storybook-control.cjs              |  18 +-
 .../src/cli/DesktopStorybookCli.test.ts       |  34 ++-
 .../src/cli/DesktopStorybookCli.ts            |  51 +++-
 .../storybook-desktop/src/cli/README.md       |  11 +-
 .../src/cli/commandRunner.test.ts             | 122 +++++++++
 .../src/cli/commandRunner.ts                  | 187 +++++++++++--
 .../src/cli/createDesktopStorybookCommand.ts  |   5 +-
 .../src/cli/diagnostics.test.ts               |  75 +++++
 .../storybook-desktop/src/cli/index.ts        |   1 +
 .../src/cli/smokeTests.test.ts                | 257 +++++++++++++-----
 .../storybook-desktop/src/cli/smokeTests.ts   | 185 +++++++++++--
 .../StorybookChannelOrchestrator.test.ts      | 123 ++++++++-
 .../driver/StorybookChannelOrchestrator.ts    |  49 ++--
 .../src/driver/driverManifest.test.ts         |   3 +-
 .../src/driver/driverManifest.ts              |   3 +
 .../src/testing/runWdioTests.ts               |  66 ++++-
 .../src/testing/wdioRunner.contract.cjs       | 111 +++++++-
 .../src/testing/wdioRunner.test.ts            |  20 +-
 .../storybook-desktop/src/testing/worker.ts   |  57 ++--
 37 files changed, 1375 insertions(+), 230 deletions(-)
 create mode 100644 .changeset/desktop-pipeline-logging.md
 create mode 100644 .changeset/story-grouped-desktop-tests.md
 create mode 100644 packages/agentic/storybook-desktop/config/diagnostics.cjs
 create mode 100644 packages/agentic/storybook-desktop/config/diagnostics.d.cts
 create mode 100644 packages/agentic/storybook-desktop/src/cli/commandRunner.test.ts
 create mode 100644 packages/agentic/storybook-desktop/src/cli/diagnostics.test.ts

diff --git a/.changeset/desktop-pipeline-logging.md b/.changeset/desktop-pipeline-logging.md
new file mode 100644
index 0000000000..9d80c73842
--- /dev/null
+++ b/.changeset/desktop-pipeline-logging.md
@@ -0,0 +1,6 @@
+---
+"@fluentui-react-native/storybook-desktop": patch
+"@fluentui-react-native/desktop-driver": patch
+---
+
+Capture ordered per-command stdout/stderr logs, replay full output on failure or in verbose mode, and report contextual story navigation and test failures with nested causes.
diff --git a/.changeset/story-grouped-desktop-tests.md b/.changeset/story-grouped-desktop-tests.md
new file mode 100644
index 0000000000..aa77328e62
--- /dev/null
+++ b/.changeset/story-grouped-desktop-tests.md
@@ -0,0 +1,6 @@
+---
+"@fluentui-react-native/storybook-desktop": patch
+"@fluentui-react-native/components": patch
+---
+
+Navigate to each test's story before execution, bound navigation waits, and group static plans and inline WebdriverIO callbacks by story in desktop smoke tests.
diff --git a/.github/skills/agentic-component-authoring/references/tests-and-stories.md b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
index 092259fbbb..dbdc822af8 100644
--- a/.github/skills/agentic-component-authoring/references/tests-and-stories.md
+++ b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
@@ -152,8 +152,9 @@ and import the type only. The callback receives `browser`, `expect`, `desktop`,
 `signal`, and `skip`; it cannot capture story-module bindings. Node-compatible
 helpers may be dynamically imported inside the callback. The shared Babel
 configuration strips test bodies before Metro resolves dependencies.
-Run these with `yarn storybook test --<platform>`, independently of the static
-plan runner. See the [executable test contract](../../../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
+Run these with `yarn storybook test --<platform>`. The `stories-and-tests`
+smoke mode also runs them alongside static plans, grouped by story with
+explicit navigation before execution. See the [executable test contract](../../../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
 The components package's `test:stories` project checks the experimental
 Button stories without emitting them into the component library.
 
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 831b08bbd5..71b03096ae 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -235,6 +235,7 @@ jobs:
           name: Storybook_macos_Dump
           path: |
             apps/storybook/artifacts/macos
+            apps/storybook/artifacts/storybook-commands
             ${{ steps.desktop-driver.outputs.doctor-path }}
 
   ios:
@@ -409,6 +410,7 @@ jobs:
           name: Storybook_windows_Dump
           path: |
             apps/storybook/artifacts/windows
+            apps/storybook/artifacts/storybook-commands
             ${{ steps.desktop-driver.outputs.doctor-path }}
             ${{ steps.desktop-driver.outputs.cache-root }}/v1/artifacts/**/build.log
             ${{ steps.desktop-driver.outputs.cache-root }}/v1/diagnostics/**
@@ -500,6 +502,7 @@ jobs:
           name: Storybook_win32_Dump
           path: |
             apps/storybook/artifacts/win32
+            apps/storybook/artifacts/storybook-commands
             ${{ steps.desktop-driver.outputs.doctor-path }}
             ${{ steps.desktop-driver.outputs.cache-root }}/v1/artifacts/**/build.log
             ${{ steps.desktop-driver.outputs.cache-root }}/v1/diagnostics/**
diff --git a/apps/storybook/AGENTS.md b/apps/storybook/AGENTS.md
index 69f4fc2a12..016962e639 100644
--- a/apps/storybook/AGENTS.md
+++ b/apps/storybook/AGENTS.md
@@ -51,10 +51,16 @@ Read [`agent-map.yaml`](agent-map.yaml) first for the compact architecture, look
 - Executable tests may instead use a top-level component story `wdio`
   callback, run with `yarn storybook test --<platform>`. Defaults belong in
   `storybook.config.mts` under `wdio`; the shared Babel config removes
-  callbacks from native bundles. Keep this opt-in runner separate from the
-  static-plan smoke gate.
+  callbacks from native bundles. `stories-and-tests` smoke mode runs configured
+  callbacks together with static plans, grouped by story. Always navigate to
+  the requested story and await correlated readiness before executing tests.
 - Keep `storybook-desktop.generated`, reports, trees, screenshots, and run
   manifests ignored. Never patch generated runtime identity or story manifests.
+- Shared command logs merge stdout/stderr in write order under
+  `artifacts/storybook-commands`. Failed commands replay the complete log;
+  `--verbose` also replays successful commands. Preserve labeled stderr
+  diagnostics and nested failure causes rather than replacing them with
+  exit-code-only summaries.
 - Treat the exact-platform and portable-plan digests as contracts. A dynamic or
   invalid plan must fail generation rather than disappear from the manifest.
 - Preserve nonce-authenticated runtime hello/readiness/error messages and
diff --git a/apps/storybook/README.md b/apps/storybook/README.md
index 1a97c1060a..2378e6c3e3 100644
--- a/apps/storybook/README.md
+++ b/apps/storybook/README.md
@@ -35,7 +35,14 @@ The shared runner extracts the callbacks for Node, injects WebdriverIO and
 native assertions, and leaves test dependencies out of Metro. Optional runner
 defaults belong under `wdio` in `storybook.config.mts`; no separate test config
 is needed. See the [authoring contract](../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
-This command is separate from the existing static-plan smoke gate.
+`stories-and-tests` smoke mode also runs these callbacks, grouped with each
+story's static plans. Both paths select the correct page before executing tests.
+
+Commands retain merged stdout/stderr logs under `artifacts/storybook-commands`.
+Successful commands emit short summaries; failures replay their complete log
+and print contextual story/test diagnostics. Use
+`yarn storybook --verbose smoke --macos --mode stories-and-tests` to include
+successful-command output as well. No shell redirection is required.
 
 ## Layout
 
diff --git a/apps/storybook/agent-map.yaml b/apps/storybook/agent-map.yaml
index 1a84ccc1f3..878820a532 100644
--- a/apps/storybook/agent-map.yaml
+++ b/apps/storybook/agent-map.yaml
@@ -32,6 +32,8 @@ services:
     authoring: top-level wdio callbacks in CSF3 stories
     config: storybook.config.mts wdio settings
     lifecycle: attached-session-per-story-with-isolated-node-worker
+    smoke_mode: stories-and-tests
+    execution: navigate-and-remount-then-run-tests-grouped-by-story
 
 agent_commands:
   generate_manifest: yarn storybook manifest --<platform>
@@ -87,6 +89,8 @@ validation:
     lifecycle: yarn storybook smoke --<platform> --mode stories-and-tests
 
 output_hygiene:
+  - Commands retain merged stdout/stderr logs under artifacts/storybook-commands; failures replay grouped output.
+  - Use --verbose to replay successful-command logs; files update continuously while commands run.
   - Use structured CLI output instead of logging raw channel events.
   - Search large native build logs for errors and final status instead of reading them in full.
   - Keep warning suppression exact; console diagnostics remain available even when LogBox hides a warning.
diff --git a/packages/agentic/components/src/components/button/button.stories.tsx b/packages/agentic/components/src/components/button/button.stories.tsx
index 9bf94a220a..0bbce32c5f 100644
--- a/packages/agentic/components/src/components/button/button.stories.tsx
+++ b/packages/agentic/components/src/components/button/button.stories.tsx
@@ -13,11 +13,20 @@ import type { ButtonAppearance, ButtonShape, ButtonSize } from './button.types';
 type StoryGroupProps = {
   children: ReactNode;
   label: string;
+  labelTestID?: string;
 };
 
-const StoryGroup = ({ children, label }: StoryGroupProps) => (
+const StoryGroup = ({ children, label, labelTestID }: StoryGroupProps) => (
   <View style={styles.group}>
-    <Text style={styles.label}>{label}</Text>
+    {labelTestID ? (
+      <View accessible accessibilityLabel={label} accessibilityRole="text" testID={labelTestID}>
+        <Text accessible={false} style={styles.label}>
+          {label}
+        </Text>
+      </View>
+    ) : (
+      <Text style={styles.label}>{label}</Text>
+    )}
     <View style={styles.row}>{children}</View>
   </View>
 );
@@ -251,21 +260,22 @@ export const Selected: Story = {
 };
 
 export const ExternallyDrivenSelection: Story = {
-  wdio: async ({ browser, desktop, expect }) => {
+  wdio: 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 desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: false });
+    await expect(status).toHaveText('Not selected');
     await favorite.click();
-    await desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: true });
+    await expect(status).toHaveText('Selected');
     await reset.click();
-    await desktop.expect({ state: 'checked', target: { testId: 'agentic-storybook-button-favorite' }, value: false });
+    await expect(status).toHaveText('Not selected');
   },
   render: () => {
     const ToggleGroup = () => {
       const [selected, setSelected] = useState(false);
       return (
-        <StoryGroup label={selected ? 'Selected' : 'Not selected'}>
+        <StoryGroup label={selected ? 'Selected' : 'Not selected'} labelTestID="agentic-storybook-button-selection-state">
           <Button
             content="Favorite"
             icon={regularStarIcon}
diff --git a/packages/agentic/desktop-driver/references/test-integration.md b/packages/agentic/desktop-driver/references/test-integration.md
index 78a179aed0..23ab4d9e1b 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -50,6 +50,12 @@ The runner resets the preview for each test, filters and shards a stable
 `storyId/testId` ordering, checks required capabilities, and classifies
 assertion, timeout, cancellation, skip, and infrastructure outcomes.
 
+Pass `onTestResult(result)` to `runStoryTests` or `runDesktopStoryTests` to
+receive each settled test result before the next test starts. This supports
+immediate pipeline diagnostics without parsing the final artifact report.
+The callback receives a read-only result and is awaited; serializable authored plans and
+result formats remain unchanged.
+
 An external supervisor can share an existing session with an isolated Node
 worker using `attachDesktopWebdriver({ url, sessionId, capabilities })`.
 This registers the same custom commands without creating a second session.
diff --git a/packages/agentic/desktop-driver/src/runner/StoryTestRunner.test.ts b/packages/agentic/desktop-driver/src/runner/StoryTestRunner.test.ts
index 57d355630b..cf57ef5034 100644
--- a/packages/agentic/desktop-driver/src/runner/StoryTestRunner.test.ts
+++ b/packages/agentic/desktop-driver/src/runner/StoryTestRunner.test.ts
@@ -36,6 +36,45 @@ const passingPlan: DesktopStoryTests = {
 };
 
 describe('runDesktopStoryTests', () => {
+  test('reports each settled result before navigating to the next test', async () => {
+    const manifest = makeManifest({
+      version: 1,
+      tests: [
+        { id: 'a-fails', steps: [{ expect: { state: 'role', target: { testId: 'button-primary' }, value: 'checkbox' } }] },
+        { id: 'b-passes', steps: [{ action: 'note', message: 'passed' }] },
+      ],
+    });
+    const harness = await createDesktopDriverStoryHarness(manifest);
+    const events: string[] = [];
+    const select = harness.storyOrchestrator!.selectStory.bind(harness.storyOrchestrator);
+    jest.spyOn(harness.storyOrchestrator!, 'selectStory').mockImplementation(async (request) => {
+      events.push(`select:${request.runId}`);
+      return select(request);
+    });
+    try {
+      const session = await createDesktopDriverClient({ url: harness.server.url }).newSession({
+        alwaysMatch: { platformName: 'windows', 'furn:target': harness.target.id },
+      });
+      const result = await runDesktopStoryTests({
+        endpoint: 'windows',
+        manifest,
+        platformName: 'windows',
+        runId: 'logging',
+        session,
+        targetId: harness.target.id,
+        onTestResult: async (test) => {
+          await Promise.resolve();
+          events.push(`result:${test.testId}:${test.status}`);
+        },
+      });
+      expect(events).toEqual(['select:logging-1', 'result:a-fails:failed', 'select:logging-2', 'result:b-passes:passed']);
+      expect(result.status).toBe('failed');
+      await session.delete();
+    } finally {
+      await harness.close();
+    }
+  });
+
   test('runs a portable plan and writes a stable evidence report', async () => {
     const manifest = makeManifest(passingPlan);
     const harness = await createDesktopDriverStoryHarness(manifest);
diff --git a/packages/agentic/desktop-driver/src/runner/StoryTestRunner.ts b/packages/agentic/desktop-driver/src/runner/StoryTestRunner.ts
index 4ba432b2b0..62fecdc562 100644
--- a/packages/agentic/desktop-driver/src/runner/StoryTestRunner.ts
+++ b/packages/agentic/desktop-driver/src/runner/StoryTestRunner.ts
@@ -39,6 +39,7 @@ export type DesktopStoryTestRunnerOptions = {
   session: DesktopSessionClient;
   signal?: AbortSignal;
   targetId: string;
+  onTestResult?: (result: Readonly<DesktopStoryTestResult>) => void | Promise<void>;
 };
 
 type SelectedTest = {
@@ -56,6 +57,7 @@ export async function runDesktopStoryTests({
   session,
   signal,
   targetId,
+  onTestResult,
 }: DesktopStoryTestRunnerOptions): Promise<DesktopStoryRunResult> {
   const startedAt = new Date();
   const selected = selectDesktopStoryTests(manifest, endpoint, selection);
@@ -71,19 +73,17 @@ export async function runDesktopStoryTests({
   });
 
   for (const [index, item] of selected.entries()) {
-    if (signal?.aborted) {
-      results.push(cancelledResult(item, 'Run cancelled before the test started.'));
-      continue;
-    }
-    results.push(
-      await runTest({
-        artifacts,
-        item,
-        runId: `${runId}-${index + 1}`,
-        session,
-        signal,
-      }),
-    );
+    const result = signal?.aborted
+      ? cancelledResult(item, 'Run cancelled before the test started.')
+      : await runTest({
+          artifacts,
+          item,
+          runId: `${runId}-${index + 1}`,
+          session,
+          signal,
+        });
+    results.push(result);
+    await onTestResult?.(result);
   }
 
   const result: DesktopStoryRunResult = {
diff --git a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
index e7e7c9a72e..3ecf3d0bbe 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
@@ -1,6 +1,6 @@
 import { attach, remote } from 'webdriverio';
 
-import type { DesktopStoryRunResult } from '../authoring/results.js';
+import type { DesktopStoryRunResult, DesktopStoryTestResult } from '../authoring/results.js';
 import type { DesktopStoryExpectation } from '../authoring/storyTests.js';
 import { ArtifactManager } from '../artifacts/ArtifactManager.js';
 import { createDesktopDriverClient, DesktopSessionClient } from '../client/DesktopDriverClient.js';
@@ -42,6 +42,7 @@ export type DesktopWebdriverRunOptions = {
   artifactsRoot?: string;
   selection?: DesktopStoryTestSelection;
   signal?: AbortSignal;
+  onTestResult?: (result: Readonly<DesktopStoryTestResult>) => void | Promise<void>;
 };
 
 export type DesktopWebdriverAttachment = {
@@ -91,6 +92,7 @@ export class DesktopWebdriverSession {
       ...(options.artifactsRoot ? { artifacts: new ArtifactManager(options.artifactsRoot) } : {}),
       endpoint,
       manifest,
+      onTestResult: options.onTestResult,
       platformName,
       selection: options.selection,
       session: this.session,
diff --git a/packages/agentic/storybook-desktop/README.md b/packages/agentic/storybook-desktop/README.md
index 72ad8cc27b..b3cf003603 100644
--- a/packages/agentic/storybook-desktop/README.md
+++ b/packages/agentic/storybook-desktop/README.md
@@ -227,7 +227,7 @@ the test runner does not attach by an ambiguous process name or title.
 
 Node's built-in test runner executes each story in a separate process. The
 supervisor owns one attached WebDriver session at a time, authenticates the
-live manifest, resets the preview before each callback, and deletes the
+live manifest, navigates to and remounts the correct story before each callback, and deletes the
 session after success, failure, timeout, or worker exit. The app and driver
 remain running. Failed callbacks exit nonzero; no matches is an error.
 Reports and best-effort failure source/tree evidence live in
@@ -237,8 +237,15 @@ driver and reload the app after editing tests.
 
 Button's `Default` demonstrates assertions and Node-only imports;
 `ExternallyDrivenSelection` verifies actual activation and caller-owned state
-updates. This experiment is invoked by `storybook test`; existing
-`stories-and-tests` smoke runs continue to execute the static plans only.
+updates through the visible status label, since macOS does not expose
+`checked` on the native button role. Run callbacks directly with `storybook test`, or include them in
+`storybook smoke --<platform> --mode stories-and-tests`. Smoke groups tests by
+story ID, runs that story's `desktop-e2e` plans and configured `wdio` callback,
+then advances to the next story. Non-default stories are included. Every test
+gets a fresh preview; the currently selected sidebar page is not a prerequisite.
+The aggregate smoke report contains static results in `tests` and executable
+results in `wdio`. Per-story executable reports are under
+`artifacts/<platform>/desktop-driver/wdio`.
 
 Run the resulting plans through the consuming app's Desktop Driver CLI:
 
@@ -263,8 +270,9 @@ builds the generated app, registers and launches its Debug package, starts the c
 the processes it recorded. `createWin32SmokeCommand` bundles and launches the configured REX host, verifies the shared
 desktop chrome, resize handles, and addon surface through the configured test-ID prefix, traverses every story, and
 performs the same ownership-safe cleanup. `--mode stories` is the default renderability gate;
-`--mode stories-and-tests` performs the same complete traversal and then runs every `desktop-e2e` authored plan through
-the native provider. Storybook owns app launch and supplies an exact
+`--mode stories-and-tests` performs the same complete traversal and then runs
+`desktop-e2e` plans and configured executable callbacks, grouped by story,
+through the native provider. Storybook owns app launch and supplies an exact
 nonce-bound process lease; WebDriver attaches and preserves the app until the
 Storybook lifecycle performs final cleanup.
 The reusable macOS lifecycle resolves the launched app by its isolated bundle
@@ -315,6 +323,45 @@ Command runners are injectable through the constructor for higher-level automati
 `/config` subpath. `server()` runs the foreground server until it is stopped, so supervisors should invoke it as a
 dedicated task rather than await it before another operation.
 
+### Command logs and pipeline failures
+
+The shared command runner writes stdout and stderr continuously to a single
+log file per command under `artifacts/storybook-commands` in that command's
+working directory. Both streams share one descriptor, preserving their write
+order without holding an entire build log in memory.
+
+Normal output contains a start record with the log path and a short completion
+summary. A failed command replays its complete combined log between labeled
+`BEGIN`/`END` records, then reports failure on stderr. Replay groups are
+serialized so concurrently completing commands do not mix their output.
+Owned background services also replay their logs when smoke fails.
+
+Use the global `--verbose` option to replay successful-command logs as well:
+
+```sh
+yarn storybook --verbose test --macos --story 'components-button--*'
+yarn storybook --verbose smoke --macos --mode stories-and-tests
+```
+
+Console replay is grouped at command completion; the files update while
+commands are running, so ongoing logs are available without shell redirection.
+The verbose setting is inherited by package-owned Windows and Win32 lifecycle
+subprocesses.
+
+Failures also emit explicit `[storybook] FAIL` diagnostics identifying the
+story, test, failed step when available, and execution phase. Static test
+failures are reported as each test settles, before the next test starts.
+Inline callback diagnostics are retained independently of the Node reporter,
+including with `dot`; CLI boundaries preserve nested causes and aggregate
+errors. A failed test cannot be hidden by a successful worker exit or by a
+secondary evidence/cleanup failure.
+
+Archive the command logs alongside the per-platform test artifacts in CI.
+Logs can contain application output and test data; apply the same access and
+retention policy as other test evidence. Programmatic callers can inject
+`output` and `errorOutput` streams and set `verbose` on `DesktopStorybookCli`
+or `NodeDesktopCommandRunner`.
+
 The app integrates its generated Storybook view with the shared runtime:
 
 ```tsx
diff --git a/packages/agentic/storybook-desktop/config/cli.cjs b/packages/agentic/storybook-desktop/config/cli.cjs
index 4b2300d901..1e7fea7cc0 100644
--- a/packages/agentic/storybook-desktop/config/cli.cjs
+++ b/packages/agentic/storybook-desktop/config/cli.cjs
@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
+const { writeDesktopStorybookFailure } = require('./diagnostics.cjs');
+
 import('../lib/cli/index.js')
   .then(({ runDesktopStorybookCli }) => runDesktopStorybookCli())
   .catch((error) => {
-    process.stderr.write(`${error.message}\n`);
+    writeDesktopStorybookFailure('CLI', error);
     process.exitCode = 1;
   });
diff --git a/packages/agentic/storybook-desktop/config/diagnostics.cjs b/packages/agentic/storybook-desktop/config/diagnostics.cjs
new file mode 100644
index 0000000000..c887db2728
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/diagnostics.cjs
@@ -0,0 +1,13 @@
+const { inspect } = require('node:util');
+
+function formatDesktopStorybookError(error) {
+  return typeof error === 'string'
+    ? error
+    : inspect(error, { colors: false, customInspect: false, depth: null, maxArrayLength: null, maxStringLength: null });
+}
+
+function writeDesktopStorybookFailure(context, error, output = process.stderr) {
+  output.write(`[storybook] FAIL ${context}\n${formatDesktopStorybookError(error)}\n`);
+}
+
+module.exports = { formatDesktopStorybookError, writeDesktopStorybookFailure };
diff --git a/packages/agentic/storybook-desktop/config/diagnostics.d.cts b/packages/agentic/storybook-desktop/config/diagnostics.d.cts
new file mode 100644
index 0000000000..413d98e0db
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/diagnostics.d.cts
@@ -0,0 +1,4 @@
+export type DesktopStorybookErrorOutput = Pick<NodeJS.WriteStream, 'write'>;
+
+export function formatDesktopStorybookError(error: unknown): string;
+export function writeDesktopStorybookFailure(context: string, error: unknown, output?: DesktopStorybookErrorOutput): void;
diff --git a/packages/agentic/storybook-desktop/config/server-cli.cjs b/packages/agentic/storybook-desktop/config/server-cli.cjs
index b987e4a30c..d2ebfcaf8e 100644
--- a/packages/agentic/storybook-desktop/config/server-cli.cjs
+++ b/packages/agentic/storybook-desktop/config/server-cli.cjs
@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 
+const { writeDesktopStorybookFailure } = require('./diagnostics.cjs');
+
 import('../lib/cli/index.js')
   .then(({ runDesktopStorybookCli }) => runDesktopStorybookCli([process.argv[0], process.argv[1], 'server', ...process.argv.slice(2)]))
   .catch((error) => {
-    process.stderr.write(`${error.message}\n`);
+    writeDesktopStorybookFailure('server CLI', error);
     process.exitCode = 1;
   });
diff --git a/packages/agentic/storybook-desktop/config/server-runner.cjs b/packages/agentic/storybook-desktop/config/server-runner.cjs
index 20a8466ec8..b71da3eca5 100644
--- a/packages/agentic/storybook-desktop/config/server-runner.cjs
+++ b/packages/agentic/storybook-desktop/config/server-runner.cjs
@@ -3,11 +3,12 @@
 const path = require('node:path');
 
 const { startDesktopStorybookServer } = require('./server.cjs');
+const { writeDesktopStorybookFailure } = require('./diagnostics.cjs');
 
 startDesktopStorybookServer({
   configPath: path.resolve(process.env.STORYBOOK_CONFIG_PATH || '.rnstorybook'),
   projectRoot: path.resolve(process.env.STORYBOOK_PROJECT_ROOT || '.'),
 }).catch((error) => {
-  process.stderr.write(`${error.stack || error.message}\n`);
+  writeDesktopStorybookFailure('server', error);
   process.exitCode = 1;
 });
diff --git a/packages/agentic/storybook-desktop/config/storybook-control.cjs b/packages/agentic/storybook-desktop/config/storybook-control.cjs
index 0ecc27c7ee..927f49c515 100644
--- a/packages/agentic/storybook-desktop/config/storybook-control.cjs
+++ b/packages/agentic/storybook-desktop/config/storybook-control.cjs
@@ -1,6 +1,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { pathToFileURL } = require('node:url');
+const { formatDesktopStorybookError, writeDesktopStorybookFailure } = require('./diagnostics.cjs');
 
 const host = process.env.STORYBOOK_WS_HOST || '127.0.0.1';
 const port = Number(process.env.STORYBOOK_WS_PORT) || 7007;
@@ -69,8 +70,8 @@ async function smoke() {
         }
         process.stdout.write(`rendered ${id}\n`);
       } catch (error) {
-        failures.push({ id, error: error.message });
-        process.stderr.write(`failed ${id}: ${error.message}\n`);
+        failures.push({ id, error: formatDesktopStorybookError(error) });
+        writeDesktopStorybookFailure(`navigation "${id}"`, error);
         if (failFast) {
           break;
         }
@@ -78,7 +79,7 @@ async function smoke() {
     }
 
     if (failures.length > 0) {
-      throw new Error(`${failures.length} of ${entries.length} stories failed to render`);
+      throw new Error(`${failures.length} of ${entries.length} stories failed to render: ${failures.map(({ id }) => id).join(', ')}`);
     }
     process.stdout.write(`Rendered ${entries.length} stories.\n`);
   }
@@ -98,24 +99,29 @@ async function runAuthoredTests() {
     manifest.schemaVersion !== 2 ||
     !['macos', 'win32', 'windows'].includes(manifest.endpoint) ||
     !Number.isInteger(manifest.driverPort) ||
-    typeof manifest.targetId !== 'string'
+    typeof manifest.targetId !== 'string' ||
+    manifest.storyManifest?.schemaVersion !== 1 ||
+    !Array.isArray(manifest.storyManifest.entries)
   ) {
     throw new Error(`Invalid Desktop Driver manifest at ${manifestPath}.`);
   }
 
   const smokeTestsUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'cli', 'smokeTests.js')).href;
+  const configUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'config', 'index.js')).href;
   const { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } = await import(smokeTestsUrl);
+  const { makeDesktopStorybookConfig } = await import(configUrl);
   const result = await runDesktopStorybookSmokeTests({
+    config: makeDesktopStorybookConfig({ projectRoot: process.cwd(), wdio: manifest.wdio }),
     // 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,
     platform: manifest.endpoint,
-    projectRoot: process.cwd(),
     targetId: manifest.targetId,
   });
   process.stdout.write(`${formatDesktopStorybookSmokeTestSummary(result)}\n`);
 }
 
 smoke().catch((error) => {
-  process.stderr.write(`${error.message}\n`);
+  writeDesktopStorybookFailure('smoke', error);
   process.exitCode = 1;
 });
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
index 2ca48d10c5..d91bdfceb2 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
@@ -133,6 +133,28 @@ function makeConfig(platformOptions = {}) {
 }
 
 describe('DesktopStorybookCli', () => {
+  test('prints story navigation failures before throwing the smoke summary', async () => {
+    const runner = new RecordingRunner();
+    const errorOutput = { write: jest.fn() };
+    const fetch: typeof globalThis.fetch = async (input) => {
+      const url = String(input);
+      if (url.includes('select-story-sync')) {
+        return new Response(JSON.stringify({ error: 'render failed while mounting the preview' }), { status: 500 });
+      }
+      return new Response(JSON.stringify({ entries: { broken: { id: 'components-button--broken', type: 'story' } } }));
+    };
+    const cli = new DesktopStorybookCli(
+      makeConfig({
+        macos: { run: { command: 'launch-storybook' }, smoke: { stop: { command: 'stop-storybook' }, startupTimeoutMs: 100 } },
+      }),
+      { ...nativeDriverTestOptions, runner, fetch, errorOutput, output: { write: () => true }, isPortAvailable: async () => true },
+    );
+    await expect(cli.smoke('macos')).rejects.toThrow('components-button--broken');
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('[storybook] FAIL navigation "components-button--broken"'));
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('render failed while mounting the preview'));
+    expect(runner.stopped).toBe(2);
+  });
+
   test('discovers executable callbacks with config filters and no native connection', async () => {
     const runner = new RecordingRunner();
     const output = { write: jest.fn() };
@@ -478,10 +500,13 @@ describe('DesktopStorybookCli', () => {
       120_000,
     );
     expect(runSmokeTests).toHaveBeenCalledWith({
+      config: cli.config,
+      commandRunner: runner,
+      errorOutput: process.stderr,
       // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- the test exercises the loopback Desktop Driver
       driverUrl: `http://127.0.0.1:${cli.instance.driverPort}`,
+      manifest: await createEmptyStoryManifest(cli.config, 'macos'),
       platform: 'macos',
-      projectRoot: storybookRoot,
       targetId: 'agenticstorybook-macos',
     });
     expect(fetch.mock.calls.map(([input]) => input.toString())).toContain(
@@ -504,6 +529,13 @@ describe('DesktopStorybookCli', () => {
 });
 
 describe('createDesktopStorybookCommand', () => {
+  test('forwards verbose logging through nested lifecycle commands', async () => {
+    const runner = new RecordingRunner();
+    const command = createDesktopStorybookCommand({ config: makeConfig(), runner });
+    await command.parseAsync(['node', 'storybook', '--verbose', 'bundle', '--macos']);
+    expect(runner.foreground.every(({ env }) => env.STORYBOOK_VERBOSE === '1')).toBe(true);
+  });
+
   test.each(['windows', 'win32'] as const)('builds the %s native helper without running app preparation', async (platform) => {
     const runner = new RecordingRunner();
     const buildNativeDriver = jest.fn(async () => nativeDriverArtifact);
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
index 05e1243b49..47a7e106f3 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import { createServer } from 'node:net';
 import path from 'node:path';
 
+import { writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 import {
   buildNativeDesktopDriver,
   resolveNativeDesktopDriver,
@@ -31,7 +32,7 @@ import {
   writeDesktopStorybookDriverManifest,
   writeDesktopStoryManifest,
 } from '../driver/index.js';
-import { NodeDesktopCommandRunner } from './commandRunner.js';
+import { NodeDesktopCommandRunner, STORYBOOK_VERBOSE } from './commandRunner.js';
 import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopCommand } from './commandRunner.js';
 import { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } from './smokeTests.js';
 import { runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
@@ -56,6 +57,8 @@ export type DesktopStorybookCliOptions = {
   runner?: DesktopCommandRunner;
   fetch?: typeof globalThis.fetch;
   output?: Pick<NodeJS.WriteStream, 'write'>;
+  errorOutput?: DesktopStorybookErrorOutput;
+  verbose?: boolean;
   isPortAvailable?: (port: number) => Promise<boolean>;
   runSmokeTests?: typeof runDesktopStorybookSmokeTests;
   resolveNativeDriver?: typeof resolveNativeDesktopDriver;
@@ -82,6 +85,8 @@ export class DesktopStorybookCli {
   private readonly createStoryManifest: typeof createDesktopStoryManifest;
   private readonly fetch: typeof globalThis.fetch;
   private readonly output: Pick<NodeJS.WriteStream, 'write'>;
+  private readonly errorOutput: DesktopStorybookErrorOutput;
+  private readonly verbose: boolean;
   private readonly isPortAvailable: (port: number) => Promise<boolean>;
   private readonly runSmokeTests: typeof runDesktopStorybookSmokeTests;
   private readonly resolveNativeDriver: typeof resolveNativeDesktopDriver;
@@ -93,11 +98,19 @@ export class DesktopStorybookCli {
       projectRoot: config.projectRoot,
       bundleIdentifierPrefix: config.macosBundleIdentifier,
     });
-    this.runner = options.runner ?? new NodeDesktopCommandRunner();
+    this.runner =
+      options.runner ??
+      new NodeDesktopCommandRunner({
+        output: options.output,
+        errorOutput: options.errorOutput,
+        verbose: options.verbose,
+      });
     this.buildNativeDriver = options.buildNativeDriver ?? buildNativeDesktopDriver;
     this.createStoryManifest = options.createStoryManifest ?? createDesktopStoryManifest;
     this.fetch = options.fetch ?? globalThis.fetch;
     this.output = options.output ?? process.stdout;
+    this.errorOutput = options.errorOutput ?? process.stderr;
+    this.verbose = options.verbose ?? process.env[STORYBOOK_VERBOSE] === '1';
     this.isPortAvailable = options.isPortAvailable ?? isLoopbackPortAvailable;
     this.runSmokeTests = options.runSmokeTests ?? runDesktopStorybookSmokeTests;
     this.resolveNativeDriver = options.resolveNativeDriver ?? resolveNativeDesktopDriver;
@@ -143,6 +156,7 @@ export class DesktopStorybookCli {
     resolvedInstance.driverManifestPath = await this.writeDriverManifest(platform, resolvedInstance, nativeDriver);
     this.output.write(`Storybook instance ${resolvedInstance.id}: channel=${storybookPort}, metro=${metroPort}, driver=${driverPort}\n`);
     const metro = this.runner.start(this.prepareCommand(defaultMetroCommand(resolvedInstance), platform, resolvedInstance));
+    const failures: unknown[] = [];
     try {
       await this.executePlan(
         {
@@ -155,8 +169,19 @@ export class DesktopStorybookCli {
         platform,
         resolvedInstance,
       );
-    } finally {
-      await metro.stop();
+    } catch (error) {
+      failures.push(error);
+    }
+    try {
+      await metro.stop({ failed: failures.length > 0 });
+    } catch (error) {
+      failures.push(error);
+    }
+    if (failures.length === 1) {
+      throw failures[0];
+    }
+    if (failures.length > 1) {
+      throw new AggregateError(failures, 'Storybook driver execution and cleanup failed.');
     }
   }
 
@@ -198,7 +223,10 @@ export class DesktopStorybookCli {
         settings.timeoutMs,
       );
     }
-    const results = await runWdioStoryTests({ ...settings, ...connection, config: this.config, manifest, platform }, this.runner);
+    const results = await runWdioStoryTests(
+      { ...settings, ...connection, config: this.config, manifest, platform, errorOutput: this.errorOutput },
+      this.runner,
+    );
     this.output.write(
       `Ran ${results.length} executable wdio stories (${results.filter(({ status }) => status === 'passed').length} passed, ` +
         `${results.filter(({ status }) => status === 'skipped').length} skipped).\n`,
@@ -378,9 +406,12 @@ export class DesktopStorybookCli {
       await this.renderEveryStory(serverUrl, smoke.settleMs ?? 0, smoke.startupTimeoutMs);
       if (mode === 'stories-and-tests') {
         const result = await this.runSmokeTests({
+          config: this.config,
+          commandRunner: this.runner,
+          errorOutput: this.errorOutput,
           driverUrl: loopbackUrl(instance.driverPort),
+          manifest: await this.createStoryManifest(this.config, platform),
           platform,
-          projectRoot: this.config.projectRoot,
           targetId: `${this.config.appName}-${platform}`.toLowerCase(),
         });
         this.output.write(`${formatDesktopStorybookSmokeTestSummary(result)}\n`);
@@ -395,7 +426,7 @@ export class DesktopStorybookCli {
       }
       for (const backgroundCommand of backgroundCommands.reverse()) {
         try {
-          await backgroundCommand.stop();
+          await backgroundCommand.stop({ failed: primaryFailure !== undefined });
         } catch (error) {
           failures.push(error);
         }
@@ -517,7 +548,8 @@ export class DesktopStorybookCli {
         }
         this.output.write(`rendered ${id}\n`);
       } catch (error) {
-        failures.push(new Error(`${id}: ${(error as Error).message}`));
+        writeDesktopStorybookFailure(`navigation "${id}"`, error, this.errorOutput);
+        failures.push(new Error(`Story "${id}" failed to render: ${errorMessage(error)}`, { cause: error }));
         consecutiveFailures += 1;
         if (entryIndex === 0 || consecutiveFailures >= 3) {
           break;
@@ -526,7 +558,7 @@ export class DesktopStorybookCli {
     }
 
     if (failures.length > 0) {
-      throw new AggregateError(failures, `${failures.length} stories failed to render.`);
+      throw new AggregateError(failures, `${failures.length} stories failed to render:\n${failures.map(errorMessage).join('\n')}`);
     }
     this.output.write(`Rendered ${entries.length} stories.\n`);
   }
@@ -619,6 +651,7 @@ export class DesktopStorybookCli {
       env: {
         ...command.env,
         [FURN_STORYBOOK_PLATFORM]: platform,
+        [STORYBOOK_VERBOSE]: this.verbose ? '1' : '0',
         ...(instance
           ? {
               [FURN_STORYBOOK_INSTANCE_ID]: instance.id,
diff --git a/packages/agentic/storybook-desktop/src/cli/README.md b/packages/agentic/storybook-desktop/src/cli/README.md
index 55359a1b83..84e5cbc66c 100644
--- a/packages/agentic/storybook-desktop/src/cli/README.md
+++ b/packages/agentic/storybook-desktop/src/cli/README.md
@@ -58,6 +58,13 @@ the syntax appropriate for that environment. A `--config <path>` option may be
 placed before the subcommand when the configuration does not use a standard
 root filename.
 
+Use `--verbose` before the subcommand to replay complete output from
+successful commands. By default, command output is captured continuously in
+`artifacts/storybook-commands`; failures replay the ordered stdout/stderr log,
+and successful commands emit short summaries. Navigation and test failures
+also emit labeled stderr diagnostics with story/test IDs and underlying
+causes. See [pipeline logging](../../README.md#command-logs-and-pipeline-failures).
+
 ## Command responsibilities
 
 | Command        | Responsibility                                                                                   |
@@ -134,7 +141,9 @@ yarn storybook smoke --win32 --mode stories-and-tests
 
 `stories` is the default and traverses the complete indexed catalog.
 `stories-and-tests` performs the same traversal and then runs the
-component-authored `desktop-e2e` plans against the native provider. The
+component-authored `desktop-e2e` plans and configured `wdio` callbacks against
+the native provider. Tests are grouped by story ID, including non-default
+stories, and explicitly navigate to their page before running. The
 render-only `stories` mode neither resolves a helper nor starts WebDriver.
 Both modes are preferable to a shell
 chain because they own the exact server, Metro, app identity, traversal, test
diff --git a/packages/agentic/storybook-desktop/src/cli/commandRunner.test.ts b/packages/agentic/storybook-desktop/src/cli/commandRunner.test.ts
new file mode 100644
index 0000000000..bf0879a0bc
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/cli/commandRunner.test.ts
@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Writable } from 'node:stream';
+
+import { NodeDesktopCommandRunner, type PreparedDesktopCommand } from './commandRunner.js';
+
+function capture() {
+  const chunks: Buffer[] = [];
+  return {
+    write: jest.fn((chunk: string | Uint8Array) => {
+      chunks.push(Buffer.from(chunk));
+      return true;
+    }),
+    text: () => Buffer.concat(chunks).toString('utf8'),
+  };
+}
+
+describe('ordered command output', () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'storybook-command-output-'));
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  function command(source: string, label = 'fixture command'): PreparedDesktopCommand {
+    return { command: process.execPath, args: ['-e', source], cwd: root, env: {}, label };
+  }
+  const mixedOutput = "process.stdout.write('out-1\\n'); process.stderr.write('err-1\\n'); process.stdout.write('out-2\\n');";
+
+  test('writes both streams continuously to one log and suppresses successful command output', async () => {
+    const output = capture();
+    const errorOutput = capture();
+    const runner = new NodeDesktopCommandRunner({ output, errorOutput, verbose: false });
+    await runner.run(command(mixedOutput));
+    const directory = path.join(root, 'artifacts/storybook-commands');
+    const files = fs.readdirSync(directory);
+    expect(files).toHaveLength(1);
+    expect(fs.readFileSync(path.join(directory, files[0]), 'utf8')).toContain('out-1\nerr-1\nout-2\n');
+    expect(output.text()).toContain('[storybook] OK fixture command');
+    expect(output.text()).not.toContain('out-1\n');
+    expect(errorOutput.text()).toBe('');
+  });
+
+  test('replays the complete ordered log to stderr on failure exactly once', async () => {
+    const output = capture();
+    const errorOutput = capture();
+    const runner = new NodeDesktopCommandRunner({ output, errorOutput, verbose: false });
+    await expect(runner.run(command(`${mixedOutput} process.exitCode = 7;`))).rejects.toThrow('exited with code 7');
+    expect(errorOutput.text()).toContain('out-1\nerr-1\nout-2\n');
+    expect(errorOutput.text()).toContain('[storybook] FAIL fixture command (exit 7; log:');
+    expect(errorOutput.text().match(/\[storybook\] BEGIN/g)).toHaveLength(1);
+    expect(output.text()).not.toContain('[storybook] OK');
+  });
+
+  test('verbose mode replays successful command output', async () => {
+    const output = capture();
+    const runner = new NodeDesktopCommandRunner({ output, errorOutput: capture(), verbose: true });
+    await runner.run(command(mixedOutput));
+    expect(output.text()).toContain('out-1\nerr-1\nout-2\n');
+    expect(output.text()).toContain('[storybook] BEGIN fixture command');
+    expect(output.text()).toContain('[storybook] END fixture command');
+    expect(output.text()).toContain('[storybook] OK fixture command');
+  });
+
+  test('retains live logs and replays them when an owner stops a command after failure', async () => {
+    const output = capture();
+    const errorOutput = capture();
+    const runner = new NodeDesktopCommandRunner({ output, errorOutput, verbose: false });
+    const running = runner.start(command("process.stdout.write('live-log\\n'); setInterval(() => {}, 1000);"));
+    try {
+      const deadline = Date.now() + 5000;
+      while (!fs.readFileSync(running.logPath!, 'utf8').includes('\nlive-log\n')) {
+        if (Date.now() > deadline) throw new Error('The running command did not write its live output.');
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      expect(output.text()).not.toContain('live-log\n');
+      await running.stop({ failed: true });
+      expect(errorOutput.text()).toContain('\nlive-log\n');
+      expect(errorOutput.text()).toContain('[storybook] FAIL fixture command (stopped; log:');
+    } finally {
+      await running.stop();
+    }
+  });
+
+  test('does not interleave replay groups from concurrent commands', async () => {
+    const chunks: Buffer[] = [];
+    const errorOutput = new Writable({
+      highWaterMark: 1,
+      write(chunk, _encoding, callback) {
+        setTimeout(() => {
+          chunks.push(Buffer.from(chunk));
+          callback();
+        }, 1);
+      },
+    });
+    const runner = new NodeDesktopCommandRunner({ output: capture(), errorOutput, verbose: false });
+    await Promise.allSettled([
+      runner.run(command("process.stdout.write('first-out\\n'); process.stderr.write('first-err\\n'); process.exitCode=1;", 'first')),
+      runner.run(command("process.stdout.write('second-out\\n'); process.stderr.write('second-err\\n'); process.exitCode=1;", 'second')),
+    ]);
+    const log = Buffer.concat(chunks).toString('utf8');
+    for (const [label, other] of [
+      ['first', 'second'],
+      ['second', 'first'],
+    ]) {
+      const group = log.slice(log.indexOf(`[storybook] BEGIN ${label}\n`), log.indexOf(`[storybook] END ${label}\n`));
+      expect(group).toContain(`${label}-out\n${label}-err\n`);
+      expect(group).not.toContain(`${other}-out\n`);
+    }
+    errorOutput.destroy();
+  });
+
+  test('reports process startup errors and keeps the command log', async () => {
+    const errorOutput = capture();
+    const runner = new NodeDesktopCommandRunner({ output: capture(), errorOutput, verbose: false });
+    await expect(runner.run({ ...command(''), command: path.join(root, 'missing-executable') })).rejects.toThrow();
+    expect(errorOutput.text()).toContain('[storybook] FAIL fixture command');
+    expect(errorOutput.text()).toMatch(/ENOENT|not recognized|cannot find/i);
+    expect(fs.readdirSync(path.join(root, 'artifacts/storybook-commands'))).toHaveLength(1);
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/cli/commandRunner.ts b/packages/agentic/storybook-desktop/src/cli/commandRunner.ts
index 4a4a4d0cdc..78c27ad004 100644
--- a/packages/agentic/storybook-desktop/src/cli/commandRunner.ts
+++ b/packages/agentic/storybook-desktop/src/cli/commandRunner.ts
@@ -1,17 +1,33 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import fs from 'node:fs';
 import path from 'node:path';
+import { Writable } from 'node:stream';
 
 import type { DesktopCommand } from '../config/commands.js';
+import { formatDesktopStorybookError, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
+
+export const STORYBOOK_VERBOSE = 'STORYBOOK_VERBOSE';
 
 export type PreparedDesktopCommand = DesktopCommand & {
   args: readonly string[];
   cwd: string;
   env: Readonly<Record<string, string>>;
+  label?: string;
 };
 
 export type RunningDesktopCommand = {
   completed: Promise<number>;
-  stop(): Promise<void>;
+  logPath?: string;
+  stop(options?: { failed?: boolean }): Promise<void>;
+};
+
+export type NodeDesktopCommandRunnerOptions = {
+  errorOutput?: DesktopStorybookErrorOutput;
+  logDirectory?: string;
+  output?: Pick<NodeJS.WriteStream, 'write'>;
+  verbose?: boolean;
 };
 
 export interface DesktopCommandRunner {
@@ -20,39 +36,149 @@ export interface DesktopCommandRunner {
 }
 
 export class NodeDesktopCommandRunner implements DesktopCommandRunner {
+  private readonly output: Pick<NodeJS.WriteStream, 'write'>;
+  private readonly errorOutput: DesktopStorybookErrorOutput;
+  private readonly verbose: boolean;
+  private readonly logDirectory?: string;
+  private reportQueue = Promise.resolve();
+
+  constructor(options: NodeDesktopCommandRunnerOptions = {}) {
+    this.output = options.output ?? process.stdout;
+    this.errorOutput = options.errorOutput ?? process.stderr;
+    this.verbose = options.verbose ?? process.env[STORYBOOK_VERBOSE] === '1';
+    this.logDirectory = options.logDirectory;
+  }
+
   async run(command: PreparedDesktopCommand): Promise<void> {
-    const child = spawnCommand(command, false);
-    const exitCode = await completed(child);
-    if (exitCode !== 0) {
-      throw new Error(formatCommandFailure(command, exitCode));
+    const running = this.launch(command, false);
+    let failure: unknown;
+    try {
+      const exitCode = await running.completed;
+      if (exitCode !== 0) {
+        throw new Error(`${formatCommandFailure(command, exitCode)} Log: ${running.logPath}`);
+      }
+    } catch (error) {
+      failure = error;
+    }
+    try {
+      await running.stop({ failed: failure !== undefined });
+    } catch (error) {
+      throw new AggregateError(failure === undefined ? [error] : [failure, error], 'Command execution or log reporting failed.');
+    }
+    if (failure !== undefined) {
+      throw failure;
     }
   }
 
   start(command: PreparedDesktopCommand): RunningDesktopCommand {
-    const child = spawnCommand(command, true);
+    return this.launch(command, true);
+  }
+
+  private launch(command: PreparedDesktopCommand, background: boolean): RunningDesktopCommand {
+    const directory = this.logDirectory ?? path.join(command.cwd, 'artifacts', 'storybook-commands');
+    fs.mkdirSync(directory, { recursive: true });
+    const logPath = path.join(directory, `${new Date().toISOString().replaceAll(':', '-')}-${randomUUID()}.log`);
+    const label = command.label ?? [command.command, ...command.args].join(' ');
+    const descriptor = fs.openSync(logPath, 'ax', 0o600);
+    let child: ReturnType<typeof spawn>;
+    try {
+      fs.writeSync(descriptor, `$ ${[command.command, ...command.args].map((argument) => JSON.stringify(argument)).join(' ')}\n`);
+      // A shared descriptor preserves stdout/stderr write order without buffering a whole command in memory.
+      child = spawnCommand(command, background, descriptor);
+    } finally {
+      fs.closeSync(descriptor);
+    }
     const completion = completed(child);
-    let stopped = false;
+    let stopRequested = false;
+    let stopPromise: Promise<void> | undefined;
+    let exitError: unknown;
+    let reportedFailure = false;
+    const reports: Promise<void>[] = [];
+    const enqueue = (action: () => Promise<void> | void) => {
+      const report = this.reportQueue.then(action);
+      this.reportQueue = report.catch(() => undefined);
+      reports.push(report);
+    };
+    enqueue(() => writeOutput(this.output, `[storybook] START ${label} (log: ${logPath})\n`));
+
+    const report = (failed: boolean, status: string) => {
+      if (reportedFailure) {
+        return;
+      }
+      reportedFailure = failed;
+      enqueue(async () => {
+        const output = failed ? this.errorOutput : this.output;
+        if (failed || this.verbose) {
+          await writeOutput(output, `[storybook] BEGIN ${label}\n`);
+          await replayCommandLog(logPath, output);
+          await writeOutput(output, `\n[storybook] END ${label}\n`);
+        }
+        await writeOutput(output, `[storybook] ${failed ? 'FAIL' : 'OK'} ${label} (${status}; log: ${logPath})\n`);
+        if (exitError !== undefined) {
+          await writeOutput(output, `${formatDesktopStorybookError(exitError)}\n`);
+        }
+      });
+    };
+    void completion.then(
+      (code) => {
+        if (!stopRequested && code !== 0) {
+          report(true, child.signalCode ? `signal ${child.signalCode}` : `exit ${code}`);
+        }
+      },
+      (error) => {
+        exitError = error;
+        report(true, 'could not start');
+      },
+    );
 
     return {
       completed: completion,
-      async stop() {
-        if (stopped || child.exitCode !== null || child.signalCode !== null) {
-          return;
-        }
-        stopped = true;
-        await stopChildProcess(child.pid, completion);
+      logPath,
+      stop(options = {}) {
+        stopPromise ??= (async () => {
+          stopRequested = true;
+          const running = exitError === undefined && child.exitCode === null && child.signalCode === null;
+          try {
+            if (running) {
+              await stopChildProcess(child.pid, completion, logPath);
+            }
+          } catch (error) {
+            exitError = error;
+            report(true, 'could not stop');
+            await Promise.all(reports);
+            throw error;
+          }
+          report(
+            Boolean(options.failed || exitError !== undefined || (!running && child.exitCode !== 0)),
+            running ? 'stopped' : child.signalCode ? `signal ${child.signalCode}` : `exit ${child.exitCode}`,
+          );
+          await Promise.all(reports);
+        })();
+        return stopPromise;
       },
     };
   }
 }
 
-function spawnCommand(command: PreparedDesktopCommand, background: boolean) {
+async function replayCommandLog(logPath: string, output: Pick<NodeJS.WriteStream, 'write'>): Promise<void> {
+  for await (const chunk of fs.createReadStream(logPath)) {
+    await writeOutput(output, chunk);
+  }
+}
+
+async function writeOutput(output: Pick<NodeJS.WriteStream, 'write'>, chunk: string | Uint8Array): Promise<void> {
+  if (!output.write(chunk) && output instanceof Writable) {
+    await once(output, 'drain');
+  }
+}
+
+function spawnCommand(command: PreparedDesktopCommand, background: boolean, descriptor?: number) {
   return spawn(command.command, [...command.args], {
     cwd: command.cwd,
     detached: background && process.platform !== 'win32',
     env: { ...process.env, ...command.env },
     shell: requiresWindowsShell(command.command),
-    stdio: 'inherit',
+    stdio: descriptor === undefined ? 'inherit' : ['inherit', descriptor, descriptor],
   });
 }
 
@@ -72,13 +198,13 @@ function completed(child: ReturnType<typeof spawn>): Promise<number> {
   });
 }
 
-async function stopChildProcess(pid: number | undefined, completion: Promise<number>): Promise<void> {
+async function stopChildProcess(pid: number | undefined, completion: Promise<number>, logPath: string): Promise<void> {
   if (!pid) {
     return;
   }
 
   if (process.platform === 'win32') {
-    await stopWindowsProcessTree(pid);
+    await stopWindowsProcessTree(pid, logPath);
     await completion;
     return;
   }
@@ -91,7 +217,18 @@ async function stopChildProcess(pid: number | undefined, completion: Promise<num
     }
   }
 
-  const stopped = await Promise.race([completion.then(() => true), delay(5000).then(() => false)]);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let stopped: boolean;
+  try {
+    stopped = await Promise.race([
+      completion.then(() => true),
+      new Promise<boolean>((resolve) => {
+        timer = setTimeout(() => resolve(false), 5000);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
   if (!stopped) {
     try {
       process.kill(-pid, 'SIGKILL');
@@ -104,14 +241,20 @@ async function stopChildProcess(pid: number | undefined, completion: Promise<num
   }
 }
 
-async function stopWindowsProcessTree(pid: number): Promise<void> {
+async function stopWindowsProcessTree(pid: number, logPath: string): Promise<void> {
   const command: PreparedDesktopCommand = {
     command: process.env.ComSpec ?? 'cmd.exe',
     args: ['/d', '/s', '/c', `taskkill /PID ${pid} /T /F`],
     cwd: path.parse(process.cwd()).root,
     env: {},
   };
-  const child = spawnCommand(command, false);
+  const descriptor = fs.openSync(logPath, 'a');
+  let child: ReturnType<typeof spawn>;
+  try {
+    child = spawnCommand(command, false, descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
   const exitCode = await completed(child);
   if (exitCode !== 0) {
     throw new Error(`Could not stop owned process tree ${pid}.`);
@@ -121,7 +264,3 @@ async function stopWindowsProcessTree(pid: number): Promise<void> {
 function formatCommandFailure(command: PreparedDesktopCommand, exitCode: number): string {
   return `Command "${[command.command, ...command.args].join(' ')}" exited with code ${exitCode}.`;
 }
-
-function delay(milliseconds: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
diff --git a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
index 51de9dc698..511b91055a 100644
--- a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
+++ b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
@@ -34,7 +34,8 @@ export function createDesktopStorybookCommand(options: CreateDesktopStorybookCom
   const program = new Command()
     .name('storybook-desktop')
     .description('Serve, prepare, bundle, build, run, and smoke test a React Native desktop Storybook app.')
-    .option('-c, --config <path>', 'path to storybook.config.ts');
+    .option('-c, --config <path>', 'path to storybook.config.ts')
+    .option('-v, --verbose', 'replay full captured output for successful commands as well as failures');
   let apiPromise: Promise<DesktopStorybookCli> | undefined;
 
   const getApi = () =>
@@ -48,6 +49,8 @@ export function createDesktopStorybookCommand(options: CreateDesktopStorybookCom
           createStoryManifest: options.createStoryManifest,
           fetch: options.fetch,
           output: options.output,
+          errorOutput: options.errorOutput,
+          verbose: program.opts<{ verbose?: boolean }>().verbose ?? options.verbose,
           isPortAvailable: options.isPortAvailable,
           runSmokeTests: options.runSmokeTests,
           resolveNativeDriver: options.resolveNativeDriver,
diff --git a/packages/agentic/storybook-desktop/src/cli/diagnostics.test.ts b/packages/agentic/storybook-desktop/src/cli/diagnostics.test.ts
new file mode 100644
index 0000000000..36dccd1360
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/cli/diagnostics.test.ts
@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { formatDesktopStorybookError, writeDesktopStorybookFailure } from '../../config/diagnostics.cjs';
+
+describe('pipeline failure diagnostics', () => {
+  test('preserves aggregate errors, nested causes, stacks and non-Error throws without truncation', () => {
+    const error = new AggregateError(
+      [
+        new Error('story navigation failed', { cause: new Error('preview did not mount') }),
+        ...Array.from({ length: 120 }, (_, index) => new Error(`failed-test-${index}`)),
+      ],
+      'Smoke failed',
+    );
+    const diagnostic = formatDesktopStorybookError(error);
+    expect(diagnostic).toContain('Smoke failed');
+    expect(diagnostic).toContain('story navigation failed');
+    expect(diagnostic).toContain('preview did not mount');
+    expect(diagnostic).toContain('failed-test-119');
+    expect(diagnostic).toContain('diagnostics.test');
+    expect(diagnostic).not.toContain('\u001b[');
+    expect(formatDesktopStorybookError('plain failure')).toBe('plain failure');
+    const circular = new Error('circular');
+    circular.cause = circular;
+    expect(formatDesktopStorybookError(circular)).toContain('Circular');
+  });
+
+  test('labels failure output with the story and phase', () => {
+    const output = { write: jest.fn() };
+    writeDesktopStorybookFailure('navigation "components-button--default"', new Error('render failed'), output);
+    expect(output.write).toHaveBeenCalledWith(expect.stringContaining('[storybook] FAIL navigation "components-button--default"'));
+    expect(output.write).toHaveBeenCalledWith(expect.stringContaining('render failed'));
+  });
+
+  test.each(['cli.cjs', 'server-cli.cjs'])('%s prints nested failures to stderr and exits nonzero', async (entrypoint) => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'storybook-cli-errors-'));
+    const configPath = path.join(root, 'storybook.config.mjs');
+    fs.writeFileSync(
+      configPath,
+      `
+      throw new AggregateError([
+        new Error('components-button--default navigation failed', { cause: new Error('preview did not mount') }),
+        new Error('session cleanup failed'),
+      ], 'Smoke failed');
+    `,
+    );
+    try {
+      const response = await new Promise<{ code: number | null; stdout: string; stderr: string }>((resolve, reject) => {
+        const args = ['--config', configPath, ...(entrypoint === 'cli.cjs' ? ['test', '--macos', '--list'] : ['--macos'])];
+        const child = spawn(process.execPath, [path.resolve(__dirname, '../../config', entrypoint), ...args], {
+          cwd: root,
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdout: Buffer[] = [];
+        const stderr: Buffer[] = [];
+        child.stdout.on('data', (chunk: Buffer) => stdout.push(chunk));
+        child.stderr.on('data', (chunk: Buffer) => stderr.push(chunk));
+        child.once('error', reject);
+        child.once('close', (code) =>
+          resolve({ code, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') }),
+        );
+      });
+      expect(response.code).toBe(1);
+      expect(response.stdout).toBe('');
+      expect(response.stderr).toContain('[storybook] FAIL');
+      expect(response.stderr).toContain('components-button--default navigation failed');
+      expect(response.stderr).toContain('preview did not mount');
+      expect(response.stderr).toContain('session cleanup failed');
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/agentic/storybook-desktop/src/cli/index.ts b/packages/agentic/storybook-desktop/src/cli/index.ts
index 62e120c6f5..4956c38801 100644
--- a/packages/agentic/storybook-desktop/src/cli/index.ts
+++ b/packages/agentic/storybook-desktop/src/cli/index.ts
@@ -14,6 +14,7 @@ export {
 export {
   NodeDesktopCommandRunner,
   type DesktopCommandRunner,
+  type NodeDesktopCommandRunnerOptions,
   type PreparedDesktopCommand,
   type RunningDesktopCommand,
 } from './commandRunner.js';
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
index b6ac58f0fc..3c39a2fe58 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
@@ -1,113 +1,226 @@
+import fs from 'node:fs';
+import os from 'node:os';
 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 { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests, type DesktopStorybookSmokeConnector } from './smokeTests';
+import { makeDesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
+import type { runWdioStoryTests } from '../testing/runWdioTests.js';
+import {
+  formatDesktopStorybookSmokeTestSummary,
+  runDesktopStorybookSmokeTests,
+  type DesktopStorybookSmokeConnector,
+  type DesktopStorybookSmokeTestOptions,
+} from './smokeTests.js';
 
-const passedResult: DesktopStoryRunResult = {
+const buttonId = 'components-button--default';
+const inputId = 'components-input--typing';
+
+function story(id: string, wdio = false): DesktopStoryManifestEntry {
+  return {
+    id,
+    name: id,
+    title: 'Components',
+    sourcePath: `${id}.stories.ts`,
+    packageName: 'fixture',
+    tags: ['desktop-e2e'],
+    tests: { version: 1, tests: [{ id: 'verify', steps: [{ action: 'wait', target: { testId: id } }] }] },
+    ...(wdio ? { wdio: { exportName: 'Default', digest: 'callback' } } : {}),
+  };
+}
+
+const manifest: DesktopStoryManifest = {
   endpoint: 'windows',
-  finishedAt: '2026-08-30T08:00:01.000Z',
-  manifest: {
-    platform: 'windows-digest',
-    portable: 'portable-digest',
-  },
-  platformName: 'windows',
-  runId: 'smoke-run',
+  entries: [story(buttonId)],
+  platformManifestDigest: 'windows-digest',
+  portablePlanDigest: 'portable-digest',
   schemaVersion: 1,
-  startedAt: '2026-08-30T08:00:00.000Z',
-  status: 'passed',
-  targetId: 'storybook-windows',
-  tests: [
-    {
-      artifacts: [],
-      durationMs: 10,
-      status: 'passed',
-      steps: [],
-      storyId: 'components-button--default',
-      testId: 'pointer-focus',
-      title: 'Pointer focus',
-    },
-    {
-      artifacts: [],
-      durationMs: 0,
-      skipReason: 'Unsupported capabilities: focus',
-      status: 'skipped',
-      steps: [],
-      storyId: 'components-button--default',
-      testId: 'keyboard-focus',
-      title: 'Keyboard focus',
-    },
-  ],
 };
 
+function planResult(storyId = buttonId): DesktopStoryRunResult {
+  return {
+    endpoint: 'windows',
+    finishedAt: '2026-08-30T08:00:01.000Z',
+    manifest: { platform: 'windows-digest', portable: 'portable-digest' },
+    platformName: 'windows',
+    runId: 'smoke-run',
+    schemaVersion: 1,
+    startedAt: '2026-08-30T08:00:00.000Z',
+    status: 'passed',
+    targetId: 'storybook-windows',
+    tests: [{ artifacts: [], durationMs: 10, status: 'passed', steps: [], storyId, testId: 'verify', title: 'Verify' }],
+  };
+}
+
 describe('runDesktopStorybookSmokeTests', () => {
-  test('runs desktop-e2e plans under the platform artifact root and closes the session', async () => {
-    const runStoryTests = jest.fn(async () => passedResult);
+  let root: string;
+  let options: DesktopStorybookSmokeTestOptions;
+  let errorOutput: { write: jest.Mock };
+  beforeEach(() => {
+    root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'storybook-smoke-tests-')));
+    errorOutput = { write: jest.fn() };
+    options = {
+      errorOutput,
+      config: makeDesktopStorybookConfig({ projectRoot: root }),
+      driverUrl: 'https://localhost:4444',
+      manifest,
+      platform: 'windows',
+      targetId: 'storybook-windows',
+    };
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  test('runs a story-specific plan selection, closes the session, and persists the combined report', async () => {
+    const runStoryTests = jest.fn(async () => planResult());
     const deleteSession = jest.fn(async () => undefined);
     const connect: DesktopStorybookSmokeConnector = jest.fn(async () => ({
       delete: deleteSession,
+      listStories: async () => manifest,
       runStoryTests,
     }));
-
-    const result = await runDesktopStorybookSmokeTests(
-      {
-        // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- test-only loopback service
-        driverUrl: 'http://127.0.0.1:4444',
-        platform: 'windows',
-        projectRoot: 'C:\\repo\\storybook',
-        targetId: 'storybook-windows',
-      },
-      connect,
-    );
-
+    const result = await runDesktopStorybookSmokeTests(options, connect);
     expect(connect).toHaveBeenCalledWith({
       launchMode: 'attach',
       platformName: 'windows',
       targetId: 'storybook-windows',
-      // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- test-only loopback service
-      url: 'http://127.0.0.1:4444',
+      url: options.driverUrl,
     });
     expect(runStoryTests).toHaveBeenCalledWith({
-      artifactsRoot: path.join('C:\\repo\\storybook', 'artifacts', 'windows', 'desktop-driver'),
-      selection: {
-        story: 'components-*--default',
-        tag: 'desktop-e2e',
-      },
+      artifactsRoot: path.join(root, 'artifacts', 'windows', 'desktop-driver'),
+      selection: { story: buttonId, tag: 'desktop-e2e' },
+      onTestResult: expect.any(Function),
     });
     expect(deleteSession).toHaveBeenCalledTimes(1);
-    expect(result).toBe(passedResult);
-    expect(formatDesktopStorybookSmokeTestSummary(result)).toBe('Ran 2 desktop story tests (1 passed, 1 skipped).');
+    expect(result.tests).toEqual(planResult().tests);
+    expect(formatDesktopStorybookSmokeTestSummary(result)).toBe('Ran 1 desktop story tests (1 passed, 0 skipped).');
+    expect(JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/desktop-driver/run.json'), 'utf8'))).toMatchObject({
+      status: 'passed',
+      tests: [{ storyId: buttonId }],
+    });
+  });
+
+  test('groups static plans and inline callbacks by page, including non-default stories', async () => {
+    const events: string[] = [];
+    options.manifest = { ...manifest, entries: [story(inputId, true), story(buttonId, true)] };
+    options.config = makeDesktopStorybookConfig({ projectRoot: root, wdio: { timeoutMs: 1234, reporter: 'tap' } });
+    const connect: DesktopStorybookSmokeConnector = async () => {
+      let page: string | undefined;
+      return {
+        listStories: async () => options.manifest,
+        runStoryTests: async ({ selection } = {}) => {
+          page = selection?.story;
+          events.push(`plans:${page}`);
+          return planResult(page);
+        },
+        delete: async () => {
+          events.push(`close:${page}`);
+        },
+      };
+    };
+    const runWdio: jest.MockedFunction<typeof runWdioStoryTests> = jest.fn(async ({ story }) => {
+      events.push(`wdio:${story}`);
+      return [{ storyId: story!, status: 'passed' as const, durationMs: 1 }];
+    });
+    const result = await runDesktopStorybookSmokeTests(options, connect, runWdio);
+    expect(events).toEqual([
+      `plans:${buttonId}`,
+      `close:${buttonId}`,
+      `wdio:${buttonId}`,
+      `plans:${inputId}`,
+      `close:${inputId}`,
+      `wdio:${inputId}`,
+    ]);
+    expect(runWdio).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ story: buttonId, timeoutMs: 1234, reporter: 'tap', errorOutput }),
+      undefined,
+    );
+    expect(result.tests.map(({ storyId }) => storyId)).toEqual([buttonId, inputId]);
+    expect(result.wdio?.map(({ storyId }) => storyId)).toEqual([buttonId, inputId]);
+    expect(formatDesktopStorybookSmokeTestSummary(result)).toBe('Ran 4 desktop story tests (4 passed, 0 skipped).');
+  });
+
+  test('runs inline-only stories and respects configured callback filters', async () => {
+    options.manifest = {
+      ...manifest,
+      entries: [buttonId, inputId].map((id) => ({ ...story(id, true), tests: undefined })),
+    };
+    options.config = makeDesktopStorybookConfig({ projectRoot: root, wdio: { story: inputId } });
+    const connect = jest.fn();
+    const runWdio: jest.MockedFunction<typeof runWdioStoryTests> = jest.fn(async ({ story }) => [
+      { storyId: story!, status: 'skipped' as const, durationMs: 0, skipReason: 'Capability unavailable' },
+    ]);
+    const result = await runDesktopStorybookSmokeTests(options, connect, runWdio);
+    expect(connect).not.toHaveBeenCalled();
+    expect(runWdio).toHaveBeenCalledTimes(1);
+    expect(result.wdio).toMatchObject([{ storyId: inputId, status: 'skipped' }]);
+    expect(formatDesktopStorybookSmokeTestSummary(result)).toBe('Ran 1 desktop story tests (0 passed, 1 skipped).');
   });
 
-  test('fails the smoke run after preserving a failed result and closing the session', async () => {
+  test('fails after persisting failed plan results and closing the session', async () => {
+    const result = planResult();
     const failedResult: DesktopStoryRunResult = {
-      ...passedResult,
+      ...result,
       status: 'failed',
       tests: [
         {
-          ...passedResult.tests[0],
+          ...result.tests[0],
           status: 'timed-out',
+          error: 'Timed out waiting for checkbox state',
+          steps: [{ artifacts: [], durationMs: 10, index: 2, status: 'failed', error: 'Timed out waiting for checkbox state' }],
         },
       ],
     };
     const deleteSession = jest.fn(async () => undefined);
     const connect: DesktopStorybookSmokeConnector = async () => ({
       delete: deleteSession,
-      runStoryTests: async () => failedResult,
+      listStories: async () => manifest,
+      runStoryTests: async (runOptions) => {
+        runOptions?.onTestResult?.(failedResult.tests[0]);
+        expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining(`test "${buttonId}/verify" (timed-out, step 3)`));
+        return failedResult;
+      },
     });
+    await expect(runDesktopStorybookSmokeTests(options, connect)).rejects.toThrow(`${buttonId}/verify (timed-out)`);
+    expect(deleteSession).toHaveBeenCalledTimes(1);
+    expect(errorOutput.write).toHaveBeenCalledTimes(1);
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('Timed out waiting for checkbox state'));
+    expect(JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/desktop-driver/run.json'), 'utf8')).status).toBe('failed');
+  });
 
-    await expect(
-      runDesktopStorybookSmokeTests(
-        {
-          // eslint-disable-next-line @microsoft/sdl/no-insecure-url -- test-only loopback service
-          driverUrl: 'http://127.0.0.1:4444',
-          platform: 'windows',
-          projectRoot: 'C:\\repo\\storybook',
-          targetId: 'storybook-windows',
-        },
-        connect,
-      ),
-    ).rejects.toThrow('components-button--default/pointer-focus (timed-out)');
+  test('keeps callback failures in the smoke report and stops before another page', async () => {
+    options.manifest = { ...manifest, entries: [buttonId, inputId].map((id) => ({ ...story(id, true), tests: undefined })) };
+    const runWdio = jest.fn(async () => {
+      throw new Error('callback failed');
+    });
+    await expect(runDesktopStorybookSmokeTests(options, jest.fn(), runWdio)).rejects.toThrow('callback failed');
+    expect(runWdio).toHaveBeenCalledTimes(1);
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining(`smoke story "${buttonId}"`));
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('callback failed'));
+    expect(JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/desktop-driver/run.json'), 'utf8'))).toMatchObject({
+      status: 'failed',
+      wdio: [{ storyId: buttonId, status: 'failed', error: 'callback failed' }],
+    });
+  });
+
+  test('rejects stale manifests before plans execute and still closes the session', async () => {
+    const runStoryTests = jest.fn();
+    const deleteSession = jest.fn(async () => undefined);
+    const connect: DesktopStorybookSmokeConnector = async () => ({
+      delete: deleteSession,
+      listStories: async () => ({ ...manifest, platformManifestDigest: 'stale' }),
+      runStoryTests,
+    });
+    await expect(runDesktopStorybookSmokeTests(options, connect)).rejects.toThrow('stale');
+    expect(runStoryTests).not.toHaveBeenCalled();
     expect(deleteSession).toHaveBeenCalledTimes(1);
   });
+
+  test('does not connect when no authored tests match', async () => {
+    options.manifest = { ...manifest, entries: [] };
+    const connect = jest.fn();
+    await expect(runDesktopStorybookSmokeTests(options, connect)).rejects.toThrow('No desktop story tests');
+    expect(connect).not.toHaveBeenCalled();
+  });
 });
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
index 34fb63ad5a..1192f30cff 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
@@ -1,26 +1,151 @@
+import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 
-import type { DesktopStoryRunResult } from '@fluentui-react-native/desktop-driver/authoring';
+import type { DesktopStoryManifest } from '@fluentui-react-native/desktop-driver';
+import type { DesktopStoryRunResult, DesktopStoryTestResult } from '@fluentui-react-native/desktop-driver/authoring';
+import { ArtifactManager } from '@fluentui-react-native/desktop-driver/artifacts';
+import { selectDesktopStoryTests } from '@fluentui-react-native/desktop-driver/runner';
 import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopWebdriverOptions, DesktopWebdriverSession } from '@fluentui-react-native/desktop-driver/wdio';
 
+import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { Platforms } from '../config/platforms.js';
+import { runWdioStoryTests, selectWdioStories, type WdioStoryTestResult } from '../testing/runWdioTests.js';
+import { writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
+import type { DesktopCommandRunner } from './commandRunner.js';
 
-type DesktopStorybookSmokeSession = Pick<DesktopWebdriverSession, 'delete' | 'runStoryTests'>;
+type DesktopStorybookSmokeSession = Pick<DesktopWebdriverSession, 'delete' | 'listStories' | 'runStoryTests'>;
 
 export type DesktopStorybookSmokeConnector = (options: DesktopWebdriverOptions) => Promise<DesktopStorybookSmokeSession>;
 
 export type DesktopStorybookSmokeTestOptions = {
   artifactsRoot?: string;
+  config: DesktopStorybookConfig;
   driverUrl: string;
+  manifest: DesktopStoryManifest;
   platform: Platforms;
-  projectRoot: string;
   targetId: string;
+  errorOutput?: DesktopStorybookErrorOutput;
+  commandRunner?: DesktopCommandRunner;
+};
+
+export type DesktopStorybookSmokeTestResult = DesktopStoryRunResult & {
+  wdio?: readonly WdioStoryTestResult[];
 };
 
 export async function runDesktopStorybookSmokeTests(
   options: DesktopStorybookSmokeTestOptions,
   connect: DesktopStorybookSmokeConnector = connectDesktopWebdriver,
+  runWdio: typeof runWdioStoryTests = runWdioStoryTests,
+): Promise<DesktopStorybookSmokeTestResult> {
+  const { config, manifest, platform } = options;
+  if (manifest.endpoint !== platform) {
+    throw new Error('The smoke test manifest targets a different platform.');
+  }
+  const planStoryIds = new Set(selectDesktopStoryTests(manifest, platform, { tag: 'desktop-e2e' }).map(({ entry }) => entry.id));
+  const wdioStoryIds = new Set(selectWdioStories(manifest, config.wdio).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.');
+  }
+  const artifacts = new ArtifactManager(options.artifactsRoot ?? path.join(config.projectRoot, 'artifacts', platform, 'desktop-driver'));
+  const startedAt = new Date().toISOString();
+  const tests: DesktopStoryTestResult[] = [];
+  const wdio: WdioStoryTestResult[] = [];
+  const failures: unknown[] = [];
+
+  for (const storyId of storyIds) {
+    try {
+      if (planStoryIds.has(storyId)) {
+        const plans = await runStoryPlans(options, storyId, artifacts.root, connect);
+        tests.push(...plans.tests);
+        if (plans.status !== 'passed' && plans.tests.every(({ status }) => status === 'passed' || status === 'skipped')) {
+          throw new Error(`The static test runner failed for "${storyId}" without failed test details.`);
+        }
+      }
+      if (wdioStoryIds.has(storyId)) {
+        const started = Date.now();
+        try {
+          wdio.push(
+            ...(await runWdio(
+              {
+                ...config.wdio,
+                artifactsRoot: path.join(artifacts.root, 'wdio', `story-${encodeURIComponent(storyId)}`),
+                config,
+                manifest,
+                platform,
+                story: storyId,
+                targetId: options.targetId,
+                url: options.driverUrl,
+                errorOutput: options.errorOutput,
+              },
+              options.commandRunner,
+            )),
+          );
+        } catch (error) {
+          writeDesktopStorybookFailure(`smoke story "${storyId}"`, error, options.errorOutput);
+          wdio.push({ storyId, status: 'failed', durationMs: Date.now() - started, error: errorMessage(error) });
+          throw error;
+        }
+      }
+    } catch (error) {
+      failures.push(new Error(`Smoke tests for "${storyId}" failed: ${errorMessage(error)}`, { cause: error }));
+      break;
+    }
+  }
+
+  const failedTests = tests.filter(({ status }) => status !== 'passed' && status !== 'skipped');
+  if (failedTests.length) {
+    failures.push(
+      new Error(
+        `${failedTests.length} of ${tests.length} desktop story tests failed: ${failedTests
+          .map(({ status, storyId, testId }) => `${storyId}/${testId} (${status})`)
+          .join(', ')}`,
+      ),
+    );
+  }
+  if (wdio.some(({ status }) => status === 'failed') && failures.length === 0) {
+    for (const test of wdio.filter(({ status }) => status === 'failed')) {
+      writeDesktopStorybookFailure(`wdio "${test.storyId}"`, test.error ?? 'No failure details were returned.', options.errorOutput);
+    }
+    failures.push(new Error('Executable smoke tests reported failures.'));
+  }
+  const result: DesktopStorybookSmokeTestResult = {
+    endpoint: platform,
+    finishedAt: new Date().toISOString(),
+    manifest: { platform: manifest.platformManifestDigest, portable: manifest.portablePlanDigest },
+    platformName: platform === 'macos' ? 'macos' : 'windows',
+    runId: randomUUID(),
+    schemaVersion: 1,
+    startedAt,
+    status: failures.length ? 'failed' : 'passed',
+    targetId: options.targetId,
+    tests,
+    wdio,
+  };
+  try {
+    artifacts.writeMetadata('run', {
+      ...result,
+      ...(failures.length ? { errors: failures.map(errorMessage) } : {}),
+    });
+  } catch (error) {
+    failures.push(error);
+    writeDesktopStorybookFailure('writing the smoke report', error, options.errorOutput);
+  }
+  if (failures.length === 1) {
+    throw failures[0];
+  }
+  if (failures.length > 1) {
+    throw new AggregateError(failures, `Desktop smoke tests failed: ${failures.map(errorMessage).join('; ')}`);
+  }
+  return result;
+}
+
+async function runStoryPlans(
+  options: DesktopStorybookSmokeTestOptions,
+  storyId: string,
+  artifactsRoot: string,
+  connect: DesktopStorybookSmokeConnector,
 ): Promise<DesktopStoryRunResult> {
   const desktop = await connect({
     launchMode: 'attach',
@@ -30,19 +155,33 @@ export async function runDesktopStorybookSmokeTests(
   });
   let result: DesktopStoryRunResult | undefined;
   let runFailure: unknown;
-
   try {
-    result = await desktop.runStoryTests({
-      artifactsRoot: options.artifactsRoot ?? path.join(options.projectRoot, 'artifacts', options.platform, 'desktop-driver'),
-      selection: {
-        story: 'components-*--default',
-        tag: 'desktop-e2e',
-      },
-    });
+    const live = await desktop.listStories();
+    if (live.endpoint !== options.platform || live.platformManifestDigest !== options.manifest.platformManifestDigest) {
+      throw new Error('The running Storybook manifest is stale or targets a different platform.');
+    }
+    const reported = new Set<string>();
+    const onTestResult = (test: Readonly<DesktopStoryTestResult>) => {
+      if (test.status === 'passed' || test.status === 'skipped') {
+        return;
+      }
+      reported.add(`${test.storyId}/${test.testId}`);
+      const step = test.steps.find(({ status }) => status === 'failed');
+      writeDesktopStorybookFailure(
+        `test "${test.storyId}/${test.testId}" (${test.status}${step ? `, step ${step.index + 1}` : ''})`,
+        test.error ?? step?.error ?? 'No failure details were returned.',
+        options.errorOutput,
+      );
+    };
+    result = await desktop.runStoryTests({ artifactsRoot, selection: { story: storyId, tag: 'desktop-e2e' }, onTestResult });
+    for (const test of result.tests) {
+      if (!reported.has(`${test.storyId}/${test.testId}`)) {
+        onTestResult(test);
+      }
+    }
   } catch (error) {
     runFailure = error;
   }
-
   try {
     await desktop.delete();
   } catch (error) {
@@ -51,26 +190,22 @@ export async function runDesktopStorybookSmokeTests(
     }
     throw error;
   }
-
   if (runFailure !== undefined) {
     throw runFailure;
   }
   if (!result) {
     throw new Error('Desktop story tests completed without a result.');
   }
-  if (result.status !== 'passed') {
-    const failedTests = result.tests.filter(({ status }) => status !== 'passed' && status !== 'skipped');
-    throw new Error(
-      `${failedTests.length} of ${result.tests.length} desktop story tests failed: ${failedTests
-        .map(({ status, storyId, testId }) => `${storyId}/${testId} (${status})`)
-        .join(', ')}`,
-    );
-  }
   return result;
 }
 
-export function formatDesktopStorybookSmokeTestSummary(result: DesktopStoryRunResult): string {
-  const passed = result.tests.filter(({ status }) => status === 'passed').length;
-  const skipped = result.tests.filter(({ status }) => status === 'skipped').length;
-  return `Ran ${result.tests.length} desktop story tests (${passed} passed, ${skipped} skipped).`;
+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).`;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
diff --git a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
index 19d61ab562..630a4c97f8 100644
--- a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
@@ -113,11 +113,123 @@ const driverManifest: DesktopStorybookDriverManifest = {
 };
 
 describe('StorybookChannelOrchestrator', () => {
+  const errorOutput = { write: jest.fn() };
+  const createOrchestrator = (options: ConstructorParameters<typeof StorybookChannelOrchestrator>[0]) =>
+    new StorybookChannelOrchestrator({ ...options, errorOutput });
+  beforeEach(() => errorOutput.write.mockClear());
+
+  test('reports the requested story, run and HTTP failure details to the server error output', async () => {
+    const channelServer = new FakeChannelServer();
+    const client = new FakeChannelClient();
+    channelServer.connect(client);
+    const orchestrator = createOrchestrator({
+      channelServer,
+      driverManifest,
+      serverUrl: 'https://localhost',
+      timeoutMs: 100,
+      fetch: jest.fn(async () => new Response('preview module failed to load', { status: 500 })),
+    });
+    client.receive('furn:desktop:hello', {
+      endpoint: 'windows',
+      instanceId: 'instance',
+      nonce: 'nonce',
+      platformManifestDigest: 'platform-digest',
+      targetId: 'agenticstorybook-windows',
+      version: 1,
+    });
+    await expect(
+      orchestrator.selectStory({ requestId: 'failure', runId: 'pipeline-run', storyId: 'components-button--default' }),
+    ).rejects.toThrow('preview module failed to load');
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('navigation "components-button--default" (run pipeline-run)'));
+    expect(errorOutput.write).toHaveBeenCalledWith(expect.stringContaining('status 500: preview module failed to load'));
+  });
+
+  test('reset navigates from a different page, including after manual navigation away from the last prepared story', async () => {
+    const channelServer = new FakeChannelServer();
+    const client = new FakeChannelClient();
+    channelServer.connect(client);
+    let page = 'unrelated--story';
+    let generation = 0;
+    const fetch = jest.fn(async (url: Parameters<typeof globalThis.fetch>[0]) => {
+      page = decodeURIComponent(String(url).split('/').at(-1)!);
+      const request = JSON.parse(client.sent.at(-1)!).args[0];
+      client.receive('furn:desktop:story-ready', {
+        ...request,
+        storyId: page,
+        previewGeneration: ++generation,
+        portablePlanDigest: 'portable-digest',
+      });
+      return new Response('{}');
+    });
+    const orchestrator = createOrchestrator({
+      channelServer,
+      driverManifest,
+      fetch,
+      serverUrl: 'https://localhost',
+      timeoutMs: 100,
+    });
+    client.receive('furn:desktop:hello', {
+      endpoint: 'windows',
+      instanceId: 'instance',
+      nonce: 'nonce',
+      platformManifestDigest: 'platform-digest',
+      targetId: 'agenticstorybook-windows',
+      version: 1,
+    });
+
+    await expect(
+      orchestrator.resetStory({ requestId: 'first', runId: 'first', storyId: 'components-button--default' }),
+    ).resolves.toMatchObject({ storyId: 'components-button--default', previewGeneration: 1 });
+    expect(page).toBe('components-button--default');
+    page = 'manually-selected--story';
+    await expect(
+      orchestrator.resetStory({ requestId: 'second', runId: 'second', storyId: 'components-button--default' }),
+    ).resolves.toMatchObject({ storyId: 'components-button--default', previewGeneration: 2 });
+    expect(page).toBe('components-button--default');
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  test('bounds navigation even when the runtime is ready but the HTTP selection request never completes', async () => {
+    const channelServer = new FakeChannelServer();
+    const client = new FakeChannelClient();
+    channelServer.connect(client);
+    let signal: AbortSignal | null | undefined;
+    const fetch = jest.fn((_url: Parameters<typeof globalThis.fetch>[0], options?: RequestInit) => {
+      signal = options?.signal;
+      const request = JSON.parse(client.sent.at(-1)!).args[0];
+      client.receive('furn:desktop:story-ready', {
+        ...request,
+        portablePlanDigest: 'portable-digest',
+        previewGeneration: 1,
+      });
+      return new Promise<Response>(() => {});
+    });
+    const orchestrator = createOrchestrator({
+      channelServer,
+      driverManifest,
+      fetch,
+      serverUrl: 'https://localhost',
+      timeoutMs: 10,
+    });
+    client.receive('furn:desktop:hello', {
+      endpoint: 'windows',
+      instanceId: 'instance',
+      nonce: 'nonce',
+      platformManifestDigest: 'platform-digest',
+      targetId: 'agenticstorybook-windows',
+      version: 1,
+    });
+    await expect(orchestrator.selectStory({ requestId: 'request', runId: 'run', storyId: 'components-button--default' })).rejects.toThrow(
+      'Timed out navigating',
+    );
+    expect(signal?.aborted).toBe(true);
+  });
+
   test('authenticates the runtime and correlates selection readiness', async () => {
     const channelServer = new FakeChannelServer();
     const client = new FakeChannelClient();
     channelServer.connect(client);
-    const orchestrator = new StorybookChannelOrchestrator({
+    const orchestrator = createOrchestrator({
       channelServer,
       driverManifest,
       fetch: jest.fn(async () => new Response('{}', { status: 408 })),
@@ -170,7 +282,7 @@ describe('StorybookChannelOrchestrator', () => {
     channelServer.connect(unauthenticatedClient);
     let finishFetch: ((response: Response) => void) | undefined;
     const fetch = jest.fn(() => new Promise<Response>((resolve) => (finishFetch = resolve)));
-    const orchestrator = new StorybookChannelOrchestrator({
+    const orchestrator = createOrchestrator({
       channelServer,
       driverManifest,
       fetch,
@@ -212,13 +324,12 @@ describe('StorybookChannelOrchestrator', () => {
     await Promise.resolve();
     expect(settled).toBe(false);
     client.receive('furn:desktop:story-error', errorPayload);
-    finishFetch?.(new Response('{}'));
-
     await expect(selection).rejects.toThrow('render failed');
+    finishFetch?.(new Response('{}'));
   });
 
   test('rejects stories outside the exact platform manifest', async () => {
-    const orchestrator = new StorybookChannelOrchestrator({
+    const orchestrator = createOrchestrator({
       channelServer: new FakeChannelServer(),
       driverManifest,
       fetch: jest.fn(),
@@ -236,7 +347,7 @@ describe('StorybookChannelOrchestrator', () => {
     const channelServer = new FakeChannelServer();
     const client = new FakeChannelClient();
     channelServer.connect(client);
-    const orchestrator = new StorybookChannelOrchestrator({
+    const orchestrator = createOrchestrator({
       channelServer,
       driverManifest,
       fetch: jest.fn(),
diff --git a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
index 552b33019d..9fd59b89a9 100644
--- a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
+++ b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
@@ -6,6 +6,7 @@ import type {
 } from '@fluentui-react-native/desktop-driver';
 
 import type { DesktopStorybookDriverManifest } from './driverManifest.js';
+import { writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 
 type ChannelMessage = {
   args?: unknown[];
@@ -30,6 +31,7 @@ export type StorybookChannelOrchestratorOptions = {
   fetch?: typeof globalThis.fetch;
   serverUrl: string;
   timeoutMs?: number;
+  errorOutput?: DesktopStorybookErrorOutput;
 };
 
 type PendingSelection = {
@@ -44,6 +46,7 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
   private readonly fetch: typeof globalThis.fetch;
   private readonly serverUrl: string;
   private readonly timeoutMs: number;
+  private readonly errorOutput: DesktopStorybookErrorOutput;
   private readonly pending = new Map<string, PendingSelection>();
   private readonly bridgeWaiters = new Set<() => void>();
   private bridgeConnected = false;
@@ -56,11 +59,13 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
     fetch = globalThis.fetch,
     serverUrl,
     timeoutMs = 30_000,
+    errorOutput = process.stderr,
   }: StorybookChannelOrchestratorOptions) {
     this.driverManifest = driverManifest;
     this.fetch = fetch;
     this.serverUrl = serverUrl.replace(/\/$/, '');
     this.timeoutMs = timeoutMs;
+    this.errorOutput = errorOutput;
     channelServer.on('connection', (client) => this.attachClient(client));
     for (const client of channelServer.clients) {
       this.attachClient(client);
@@ -76,39 +81,49 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
   }
 
   async selectStory(request: StorySelectionRequest): Promise<StoryReadyResult> {
-    this.requireStory(request.storyId);
-    await this.waitForBridge();
-    const ready = this.waitForReady(request);
-    void ready.catch(() => undefined);
-    this.broadcast('furn:desktop:prepare-story', request);
     try {
-      const response = await this.fetch(`${this.serverUrl}/select-story-sync/${encodeURIComponent(request.storyId)}`, {
-        method: 'POST',
-      });
-      if (!response.ok && response.status !== 408) {
-        throw new Error(`Storybook failed to select "${request.storyId}" with status ${response.status}.`);
-      }
-      return await ready;
+      return await this.selectAndPrepareStory(request);
     } catch (error) {
-      this.cancelPending(request.requestId);
+      writeDesktopStorybookFailure(`navigation "${request.storyId}" (run ${request.runId})`, error, this.errorOutput);
       throw error;
     }
   }
 
-  async resetStory(request: StorySelectionRequest): Promise<StoryReadyResult> {
+  private async selectAndPrepareStory(request: StorySelectionRequest): Promise<StoryReadyResult> {
     this.requireStory(request.storyId);
     await this.waitForBridge();
     const ready = this.waitForReady(request);
     void ready.catch(() => undefined);
+    const controller = new AbortController();
+    let timer: ReturnType<typeof setTimeout> | undefined;
     try {
       this.broadcast('furn:desktop:prepare-story', request);
-      return ready;
-    } catch (error) {
+      const navigation = this.fetch(`${this.serverUrl}/select-story-sync/${encodeURIComponent(request.storyId)}`, {
+        method: 'POST',
+        signal: controller.signal,
+      }).then(async (response) => {
+        if (!response.ok && response.status !== 408) {
+          const detail = await response.text();
+          throw new Error(`Storybook failed to select "${request.storyId}" with status ${response.status}${detail ? `: ${detail}` : '.'}`);
+        }
+      });
+      return await Promise.race([
+        Promise.all([navigation, ready]).then(([, result]) => result),
+        new Promise<never>((_resolve, reject) => {
+          timer = setTimeout(() => reject(new Error(`Timed out navigating to Storybook story "${request.storyId}".`)), this.timeoutMs);
+        }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+      controller.abort();
       this.cancelPending(request.requestId);
-      throw error;
     }
   }
 
+  resetStory(request: StorySelectionRequest): Promise<StoryReadyResult> {
+    return this.selectStory(request);
+  }
+
   async updateArgs(storyId: string, args: Readonly<Record<string, unknown>>): Promise<void> {
     this.requireStory(storyId);
     this.broadcast('updateStoryArgs', { storyId, updatedArgs: args });
diff --git a/packages/agentic/storybook-desktop/src/driver/driverManifest.test.ts b/packages/agentic/storybook-desktop/src/driver/driverManifest.test.ts
index ba4eb8735e..f437166030 100644
--- a/packages/agentic/storybook-desktop/src/driver/driverManifest.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/driverManifest.test.ts
@@ -37,7 +37,7 @@ const nativeDriver: NativeDriverArtifact = {
 
 describe('Desktop Storybook driver manifest', () => {
   test('records native helper and nonce-bound application identity', () => {
-    const config = makeDesktopStorybookConfig({ projectRoot: storybookRoot });
+    const config = makeDesktopStorybookConfig({ projectRoot: storybookRoot, wdio: { timeoutMs: 12_345, tag: 'smoke', reporter: 'tap' } });
     const instance = createDesktopStorybookInstance({
       bundleIdentifierPrefix: config.macosBundleIdentifier,
       projectRoot: config.projectRoot,
@@ -59,6 +59,7 @@ describe('Desktop Storybook driver manifest', () => {
       },
       nativeDriver,
       schemaVersion: 2,
+      wdio: { timeoutMs: 12_345, tag: 'smoke', reporter: 'tap' },
     });
 
     const macosManifest = createDesktopStorybookDriverManifest({
diff --git a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
index ae1aae0771..0f7b2af9dd 100644
--- a/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/driverManifest.ts
@@ -7,6 +7,7 @@ import type { DesktopStoryManifest, NativeDesktopApplicationDescriptor, NativeDr
 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';
 
 export type DesktopStorybookDriverManifest = {
   application: NativeDesktopApplicationDescriptor & {
@@ -29,6 +30,7 @@ export type DesktopStorybookDriverManifest = {
   storybookPort: number;
   targetId: string;
   testIDPrefix: string;
+  wdio?: DesktopStorybookWdioOptions;
 };
 
 export type CreateDesktopStorybookDriverManifestOptions = {
@@ -76,6 +78,7 @@ export function createDesktopStorybookDriverManifest({
     storybookPort: instance.storybookPort,
     targetId: `${config.appName}-${platform}`.toLowerCase(),
     testIDPrefix: config.testIDPrefix,
+    wdio: config.wdio,
   });
 }
 
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
index 7bca0eb9bc..ba5145c37e 100644
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -13,6 +13,7 @@ import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/
 import { NodeDesktopCommandRunner, type DesktopCommandRunner, type PreparedDesktopCommand } from '../cli/commandRunner.js';
 import { extractWdioTests } from './extractWdioTests.js';
 import type { WdioWorkerOptions } from './worker.js';
+import { formatDesktopStorybookError, writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 
 export type WdioStoryTestResult = {
   storyId: string;
@@ -30,6 +31,7 @@ export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
   targetId: string;
   url: string;
   artifactsRoot?: string;
+  errorOutput?: DesktopStorybookErrorOutput;
 };
 
 export function selectWdioStories(
@@ -70,8 +72,12 @@ export async function runWdioStoryTests(
   ).href;
   const results: WdioStoryTestResult[] = [];
   let infrastructureFailure: unknown;
+  let activeStory: string | undefined;
+  let phase = 'setup';
   try {
     for (const [index, { entry, code }] of cases.entries()) {
+      activeStory = entry.id;
+      phase = 'connection';
       const started = Date.now();
       // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
       const desktop = await connectDesktopWebdriver({
@@ -84,11 +90,13 @@ export async function runWdioStoryTests(
       const result: WdioStoryTestResult = { storyId: entry.id, status: 'failed', durationMs: 0 };
       let failure: unknown;
       try {
+        phase = 'manifest verification';
         const live = await desktop.listStories();
         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.');
         }
-        await desktop.resetStory(entry.id);
+        phase = 'navigation';
+        await desktop.openStory(entry.id);
         const resultPath = path.join(directory, `${index}.json`);
         const workerOptions: WdioWorkerOptions = {
           attachment: {
@@ -107,10 +115,12 @@ export async function runWdioStoryTests(
             `registerWdioStoryTest(${JSON.stringify(workerOptions)}, (${code}));\n`,
           { mode: 0o600 },
         );
-        await runWorker(
+        phase = 'execution';
+        const outcome = await runWorker(
           runner,
           {
             command: process.execPath,
+            label: `wdio "${entry.id}"`,
             args: [
               '--test',
               '--test-concurrency=1',
@@ -123,20 +133,23 @@ export async function runWdioStoryTests(
             env: {},
           },
           Math.min(settings.timeoutMs + 5000, 2_147_483_647),
+          resultPath,
+          entry.id,
         );
-        const outcome: unknown = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
-        if (!isWorkerResult(outcome)) {
-          throw new Error(`The wdio worker for ${entry.id} exited without a valid result.`);
-        }
         result.status = outcome.status;
         if (outcome.status === 'skipped') {
           result.skipReason = outcome.skipReason;
         }
       } catch (error) {
         failure = error;
-        result.error = errorMessage(error);
+        result.error = formatDesktopStorybookError(error);
+        writeDesktopStorybookFailure(`wdio "${entry.id}" during ${phase}`, error, options.errorOutput);
         result.evidenceErrors = await captureFailure(desktop, artifacts, entry.id);
+        for (const evidenceError of result.evidenceErrors) {
+          writeDesktopStorybookFailure(`evidence for "${entry.id}"`, evidenceError, options.errorOutput);
+        }
       }
+      phase = 'session cleanup';
       try {
         await desktop.delete();
       } catch (cleanupError) {
@@ -150,6 +163,7 @@ export async function runWdioStoryTests(
     }
   } catch (error) {
     infrastructureFailure = error;
+    writeDesktopStorybookFailure(`wdio "${activeStory ?? 'run'}" during ${phase}`, error, options.errorOutput);
   }
   const failures: unknown[] = infrastructureFailure === undefined ? [] : [infrastructureFailure];
   if (results.some(({ status }) => status === 'failed')) {
@@ -172,11 +186,13 @@ export async function runWdioStoryTests(
     });
   } catch (error) {
     failures.push(error);
+    writeDesktopStorybookFailure('writing the wdio report', error, options.errorOutput);
   }
   try {
     fs.rmSync(directory, { recursive: true, force: true });
   } catch (error) {
     failures.push(error);
+    writeDesktopStorybookFailure('cleaning generated wdio files', error, options.errorOutput);
   }
   if (failures.length === 1) {
     throw failures[0];
@@ -187,7 +203,9 @@ export async function runWdioStoryTests(
   return results;
 }
 
-function isWorkerResult(value: unknown): value is { status: 'passed' } | { status: 'skipped'; skipReason: string } {
+type WorkerResult = { status: 'passed' } | { status: 'skipped'; skipReason: string };
+
+function isWorkerResult(value: unknown): value is WorkerResult {
   return (
     typeof value === 'object' &&
     value !== null &&
@@ -215,10 +233,17 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-async function runWorker(runner: DesktopCommandRunner, command: PreparedDesktopCommand, timeoutMs: number): Promise<void> {
+async function runWorker(
+  runner: DesktopCommandRunner,
+  command: PreparedDesktopCommand,
+  timeoutMs: number,
+  resultPath: string,
+  storyId: string,
+): Promise<WorkerResult> {
   const worker = runner.start(command);
   let timer: ReturnType<typeof setTimeout> | undefined;
   let failure: unknown;
+  let result: WorkerResult | undefined;
   try {
     const exitCode = await Promise.race([
       worker.completed,
@@ -226,20 +251,39 @@ async function runWorker(runner: DesktopCommandRunner, command: PreparedDesktopC
         timer = setTimeout(() => reject(new Error(`Executable wdio worker exceeded its ${timeoutMs}ms process deadline.`)), timeoutMs);
       }),
     ]);
+    const outcome: unknown = fs.existsSync(resultPath) ? JSON.parse(fs.readFileSync(resultPath, 'utf8')) : undefined;
+    if (
+      typeof outcome === 'object' &&
+      outcome !== null &&
+      'status' in outcome &&
+      outcome.status === 'failed' &&
+      'error' in outcome &&
+      typeof outcome.error === 'string'
+    ) {
+      throw new Error(`Executable wdio callback "${storyId}" failed:\n${outcome.error}`);
+    }
     if (exitCode !== 0) {
-      throw new Error(`Executable wdio worker exited with code ${exitCode}; see the test reporter for assertion details.`);
+      throw new Error(`Executable wdio worker for "${storyId}" exited with code ${exitCode}.`);
+    }
+    if (!isWorkerResult(outcome)) {
+      throw new Error(`The wdio worker for "${storyId}" exited without a valid result.`);
     }
+    result = outcome;
   } catch (error) {
     failure = error;
   } finally {
     clearTimeout(timer);
   }
   try {
-    await worker.stop();
+    await worker.stop({ failed: failure !== undefined });
   } catch (error) {
     throw new AggregateError(failure === undefined ? [error] : [failure, error], 'Could not stop the owned wdio worker.');
   }
   if (failure !== undefined) {
     throw failure;
   }
+  if (!result) {
+    throw new Error(`The wdio worker for "${storyId}" completed without a result.`);
+  }
+  return result;
 }
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index aa498190ad..e3c3a4af04 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -1,3 +1,4 @@
+const { spawn } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -23,13 +24,27 @@ async function main() {
     `
     import 'react-native-must-never-load-in-node';
     export default { title: 'Fixture/Button' };
-    export const Pass = { wdio: async ({ browser, expect, desktop }) => {
+    export const Pass = {
+      tags: ['grouped', 'desktop-e2e'],
+      parameters: { desktopDriver: { version: 1, tests: [{
+        id: 'enabled', steps: [{ expect: { state: 'enabled', target: { testId: 'button-primary' }, value: true } }],
+      }] } },
+      wdio: async ({ browser, expect, desktop }) => {
       const { strictEqual } = await import('node:assert');
       const button = await browser.$('~button-primary');
       await expect(button).toBeEnabled();
       strictEqual(await button.getTagName(), 'button');
       await button.click();
       await desktop.expect({ state: 'focused', target: { testId: 'button-primary' }, value: true });
+      strictEqual((await desktop.session.getCurrentStory()).storyId, 'fixture-button--pass');
+    }};
+    export const Second = {
+      tags: ['grouped', 'desktop-e2e'],
+      parameters: { desktopDriver: { version: 1, tests: [{
+        id: 'enabled', steps: [{ expect: { state: 'enabled', target: { testId: 'button-primary' }, value: true } }],
+      }] } },
+      wdio: async ({ desktop, expect }) => {
+      expect((await desktop.session.getCurrentStory()).storyId).toBe('fixture-button--second');
     }};
     export const Skip = { wdio: ({ skip }) => { skip('Explicit capability reason'); }};
     export const Fail = { wdio: async () => {
@@ -42,11 +57,28 @@ async function main() {
     export const Spin = { wdio: () => { while (true) {} }};
     export const Crash = { wdio: () => { process.exit(2); }};
     export const ExitZero = { wdio: () => { process.exit(0); }};
+    export const NavigationFailure = { wdio: () => { throw new Error('must not execute without navigation'); }};
   `,
   );
   const storyPackage = { name: 'inline-fixture', root, manifest: { name: 'inline-fixture' }, storyPatterns: ['*.stories.ts'] };
   const manifest = await createDesktopStoryManifest({ projectRoot, getStoryPackages: () => [storyPackage] }, 'windows');
   const harness = await createDesktopDriverStoryHarness(manifest);
+  const selections = [];
+  const selectStory = harness.storyOrchestrator.selectStory.bind(harness.storyOrchestrator);
+  harness.storyOrchestrator.selectStory = async (request) => {
+    if (request.storyId === 'fixture-button--navigation-failure') {
+      throw new Error('Navigation failed: preview did not mount');
+    }
+    selections.push(request.storyId);
+    return selectStory(request);
+  };
+  const resetStory = harness.storyOrchestrator.resetStory.bind(harness.storyOrchestrator);
+  harness.storyOrchestrator.resetStory = async (request) => {
+    if ((await harness.storyOrchestrator.getCurrentStory())?.storyId !== request.storyId) {
+      throw new Error('A preview-only reset cannot navigate to another story.');
+    }
+    return resetStory(request);
+  };
   const config = {
     projectRoot: root,
     resolvePackage: (name) => ({ root: name === 'inline-fixture' ? root : packageRoot }),
@@ -66,12 +98,12 @@ async function main() {
     const passed = await run('pass');
     const skipped = await run('skip');
     const failures = [];
-    for (const story of ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale']) {
+    for (const story of ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale', 'navigation-failure']) {
       let rejected = false;
       try {
         await run(
           story === 'stale' ? 'pass' : story,
-          story === 'stale' ? { manifest: { ...manifest, platformManifestDigest: 'stale' } } : {},
+          story === 'stale' ? { manifest: { ...manifest, platformManifestDigest: 'stale' } } : { reporter: 'dot' },
         );
       } catch (error) {
         rejected = true;
@@ -81,8 +113,58 @@ async function main() {
       if (!rejected) throw new Error(`Expected ${story} to fail.`);
       const report = JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/wdio/run.json'), 'utf8'));
       if (report.tests[0].status !== 'failed') throw new Error(`${story} was not persisted as failed.`);
+      if (story === 'fail' && !report.tests[0].error.includes('intentional inline assertion')) {
+        throw new Error('Compact reporter lost the worker assertion diagnostic.');
+      }
     }
     const repeated = await run('pass');
+    await selectStory({ requestId: 'wrong-page', runId: 'wrong-page', storyId: 'fixture-button--fail' });
+    selections.length = 0;
+    const grouped = await run('*', { tag: 'grouped' });
+    const groupedSelections = [...selections];
+    fs.writeFileSync(
+      path.join(root, 'package.json'),
+      JSON.stringify({ name: 'inline-fixture', exports: { './package.json': './package.json' } }),
+    );
+    fs.mkdirSync(path.join(root, 'node_modules/@fluentui-react-native'), { recursive: true });
+    fs.symlinkSync(
+      packageRoot,
+      path.join(root, 'node_modules/@fluentui-react-native/storybook-desktop'),
+      process.platform === 'win32' ? 'junction' : 'dir',
+    );
+    const smokeManifestPath = path.join(root, 'driver-manifest.json');
+    fs.writeFileSync(
+      smokeManifestPath,
+      JSON.stringify({
+        schemaVersion: 2,
+        endpoint: 'windows',
+        driverPort: Number(new URL(harness.server.url).port),
+        targetId: harness.target.id,
+        storyManifest: manifest,
+        wdio: { tag: 'grouped', reporter: 'tap', timeoutMs: 2000 },
+      }),
+    );
+    await selectStory({ requestId: 'smoke-wrong-page', runId: 'smoke-wrong-page', storyId: 'fixture-button--fail' });
+    selections.length = 0;
+    const control = await runSmokeControl(packageRoot, root, smokeManifestPath);
+    if (control.code !== 0) throw new Error(control.stderr || control.stdout || `Smoke control exited with ${control.code}.`);
+    const smokeReport = JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/desktop-driver/run.json'), 'utf8'));
+    const smoke = {
+      plans: smokeReport.tests.map(({ storyId }) => storyId),
+      callbacks: smokeReport.wdio.map(({ storyId }) => storyId),
+      selections: [...selections],
+      status: smokeReport.status,
+    };
+    const failureManifest = JSON.parse(fs.readFileSync(smokeManifestPath, 'utf8'));
+    failureManifest.wdio = { story: 'fixture-button--fail', reporter: 'dot', timeoutMs: 2000 };
+    fs.writeFileSync(smokeManifestPath, JSON.stringify(failureManifest));
+    const failedControl = await runSmokeControl(packageRoot, root, smokeManifestPath);
+    const smokeFailureLogged =
+      failedControl.code === 1 &&
+      failedControl.stderr.includes('[storybook] FAIL smoke') &&
+      failedControl.stderr.includes('fixture-button--fail') &&
+      failedControl.stderr.includes('intentional inline assertion');
+    if (!smokeFailureLogged) throw new Error(`Smoke control lost the callback failure: ${failedControl.stderr}`);
     const buttonConfig = makeDesktopStorybookConfig({ projectRoot, storyPackages: ['@fluentui-react-native/components'] });
     const buttonManifest = await createDesktopStoryManifest(buttonConfig, 'windows');
     const buttonHarness = await createDesktopDriverStoryHarness(buttonManifest, { windows: createFakeStoryWindows(buttonManifest) });
@@ -106,6 +188,10 @@ async function main() {
           passed: passed.map(({ storyId }) => storyId),
           skipped: skipped.filter(({ status }) => status === 'skipped').map(({ storyId }) => storyId),
           repeated: repeated.map(({ storyId }) => storyId),
+          grouped: grouped.map(({ storyId }) => storyId),
+          groupedSelections,
+          smoke,
+          smokeFailureLogged,
           button: button.map(({ storyId }) => storyId),
           failures,
           attachedOnly: harness.host.actions
@@ -120,6 +206,25 @@ async function main() {
   }
 }
 
+/** @returns {Promise<{code: number | null, stdout: string, stderr: string}>} */
+function runSmokeControl(packageRoot, cwd, manifestPath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(packageRoot, 'config/storybook-control.cjs'), '--phase', 'tests'], {
+      cwd,
+      env: { ...process.env, STORYBOOK_DRIVER_MANIFEST: manifestPath, STORYBOOK_SMOKE_MODE: 'stories-and-tests' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on('data', (chunk) => stdout.push(chunk));
+    child.stderr.on('data', (chunk) => stderr.push(chunk));
+    child.once('error', reject);
+    child.once('close', (code) =>
+      resolve({ code, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') }),
+    );
+  });
+}
+
 main().catch((error) => {
   process.stderr.write(error.stack ?? error.message);
   process.exitCode = 1;
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index 4ee1bd897a..be6c52179f 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -16,7 +16,14 @@ test('executes isolated inline code and releases sessions after assertion failur
         reject(new Error(Buffer.concat(stderr).toString('utf8') || `Inline test contract exited with ${code}.`));
       } else {
         const output = Buffer.concat(stdout).toString('utf8');
-        if (!output.includes('intentional inline assertion')) {
+        const diagnostics = Buffer.concat(stderr).toString('utf8');
+        if (
+          !diagnostics.includes('intentional inline assertion') ||
+          !diagnostics.includes('wdio "fixture-button--fail" during execution') ||
+          !diagnostics.includes('wdio "fixture-button--navigation-failure" during navigation') ||
+          !diagnostics.includes('Navigation failed: preview did not mount') ||
+          output.includes('[storybook] OK wdio "fixture-button--exit-zero"')
+        ) {
           reject(new Error('Assertion diagnostics were lost.'));
         } else {
           resolve(JSON.parse(output.split('\nWDIO_RESULT ')[1]));
@@ -27,8 +34,17 @@ test('executes isolated inline code and releases sessions after assertion failur
   expect(result).toMatchObject({
     passed: ['fixture-button--pass'],
     skipped: ['fixture-button--skip'],
-    failures: ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale'],
+    failures: ['fail', 'timeout', 'spin', 'crash', 'exit-zero', 'stale', 'navigation-failure'],
     repeated: ['fixture-button--pass'],
+    grouped: ['fixture-button--pass', 'fixture-button--second'],
+    groupedSelections: ['fixture-button--pass', 'fixture-button--second'],
+    smoke: {
+      plans: ['fixture-button--pass', 'fixture-button--second'],
+      callbacks: ['fixture-button--pass', 'fixture-button--second'],
+      selections: ['fixture-button--pass', 'fixture-button--pass', 'fixture-button--second', 'fixture-button--second'],
+      status: 'passed',
+    },
+    smokeFailureLogged: true,
     button: ['components-button--default'],
     generatedFiles: [],
     attachedOnly: true,
diff --git a/packages/agentic/storybook-desktop/src/testing/worker.ts b/packages/agentic/storybook-desktop/src/testing/worker.ts
index 82a23b069a..9eb058eb01 100644
--- a/packages/agentic/storybook-desktop/src/testing/worker.ts
+++ b/packages/agentic/storybook-desktop/src/testing/worker.ts
@@ -5,6 +5,7 @@ import { attachDesktopWebdriver, type DesktopWebdriverAttachment } from '@fluent
 import { expect } from 'expect-webdriverio';
 
 import type { WdioStory } from './types.js';
+import { formatDesktopStorybookError, writeDesktopStorybookFailure } from '../../config/diagnostics.cjs';
 
 export type WdioWorkerOptions = {
   attachment: DesktopWebdriverAttachment;
@@ -15,23 +16,45 @@ export type WdioWorkerOptions = {
 
 export function registerWdioStoryTest(options: WdioWorkerOptions, callback: NonNullable<WdioStory['wdio']>): void {
   test(options.storyId, { timeout: options.timeoutMs }, async (context) => {
-    const desktop = await attachDesktopWebdriver(options.attachment);
-    context.signal.throwIfAborted();
-    let skipReason: string | undefined;
-    await callback({
-      browser: desktop.browser,
-      desktop,
-      expect,
-      signal: context.signal,
-      skip: (reason) => {
-        if (!reason?.trim()) {
-          throw new TypeError('Skipping a wdio story requires a reason.');
-        }
-        skipReason = reason;
-        context.skip(reason);
-      },
+    let recorded = false;
+    const recordFailure = (error: unknown) => {
+      const diagnostic = formatDesktopStorybookError(error);
+      try {
+        fs.writeFileSync(options.resultPath, JSON.stringify({ status: 'failed', error: diagnostic }));
+        recorded = true;
+      } catch (writeError) {
+        writeDesktopStorybookFailure(`wdio "${options.storyId}"`, error);
+        throw new AggregateError([error, writeError], 'Could not persist the worker failure diagnostic.');
+      }
+    };
+    context.after(() => {
+      if (!recorded && context.signal.aborted) {
+        recordFailure(context.signal.reason);
+      }
     });
-    context.signal.throwIfAborted();
-    fs.writeFileSync(options.resultPath, JSON.stringify(skipReason ? { status: 'skipped', skipReason } : { status: 'passed' }));
+    try {
+      const desktop = await attachDesktopWebdriver(options.attachment);
+      context.signal.throwIfAborted();
+      let skipReason: string | undefined;
+      await callback({
+        browser: desktop.browser,
+        desktop,
+        expect,
+        signal: context.signal,
+        skip: (reason) => {
+          if (!reason?.trim()) {
+            throw new TypeError('Skipping a wdio story requires a reason.');
+          }
+          skipReason = reason;
+          context.skip(reason);
+        },
+      });
+      context.signal.throwIfAborted();
+      fs.writeFileSync(options.resultPath, JSON.stringify(skipReason ? { status: 'skipped', skipReason } : { status: 'passed' }));
+      recorded = true;
+    } catch (error) {
+      recordFailure(error);
+      throw error;
+    }
   });
 }

From 9f442bfcead9578e39bbdf95600a78e995e11b9c Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Mon, 14 Sep 2026 15:26:35 -0700
Subject: [PATCH 3/5] support multiple texts per story

---
 .changeset/named-platform-wdio-tests.md       |   7 +
 .../references/tests-and-stories.md           |  68 +++++-----
 apps/storybook/AGENTS.md                      |  12 +-
 apps/storybook/README.md                      |  13 +-
 apps/storybook/agent-map.yaml                 |   6 +-
 packages/agentic/components/AGENTS.md         |  14 +-
 .../components/src/components/AGENTS.md       |  11 +-
 .../src/components/button/button.stories.tsx  |  96 +++++++-------
 .../references/test-integration.md            |   8 +-
 .../agentic/desktop-driver/src/storybook.ts   |   2 +-
 .../src/wdio/DesktopWebdriver.ts              |   2 +
 packages/agentic/storybook-desktop/README.md  |  71 +++++++---
 .../config/transform-story-tests.cjs          |  35 ++++-
 .../config/transform-story-tests.d.cts        |   9 +-
 .../src/cli/DesktopStorybookCli.test.ts       |  29 ++++
 .../src/cli/DesktopStorybookCli.ts            |  10 +-
 .../storybook-desktop/src/cli/README.md       |   4 +
 .../src/cli/createDesktopStorybookCommand.ts  |   4 +-
 .../src/cli/smokeTests.test.ts                |  16 +++
 .../storybook-desktop/src/cli/smokeTests.ts   |   8 +-
 .../src/config/transformStoryTests.test.ts    |  15 +++
 .../storybook-desktop/src/config/wdio.ts      |   3 +-
 .../src/driver/representativePlans.test.ts    |   5 +-
 .../src/driver/storyManifest.test.ts          |   6 +
 .../src/driver/storyManifest.ts               |   4 +-
 .../src/testing/extractWdioTests.test.ts      |  51 ++++++-
 .../src/testing/extractWdioTests.ts           |  26 +++-
 .../storybook-desktop/src/testing/index.ts    |   2 +-
 .../src/testing/runWdioTests.ts               |  87 +++++++++---
 .../storybook-desktop/src/testing/types.ts    |   7 +-
 .../src/testing/wdio.types.test.ts            |  25 +++-
 .../src/testing/wdioRunner.contract.cjs       | 125 +++++++++++++++++-
 .../src/testing/wdioRunner.test.ts            |  27 +++-
 .../storybook-desktop/src/testing/worker.ts   |  16 ++-
 34 files changed, 631 insertions(+), 193 deletions(-)
 create mode 100644 .changeset/named-platform-wdio-tests.md

diff --git a/.changeset/named-platform-wdio-tests.md b/.changeset/named-platform-wdio-tests.md
new file mode 100644
index 0000000000..14c5c1f39f
--- /dev/null
+++ b/.changeset/named-platform-wdio-tests.md
@@ -0,0 +1,7 @@
+---
+"@fluentui-react-native/storybook-desktop": minor
+"@fluentui-react-native/desktop-driver": patch
+"@fluentui-react-native/components": patch
+---
+
+Add named, individually isolated WDIO story tests with target-platform context and test-name filtering. Migrate Button's declarative desktop-driver plans to executable WebdriverIO callbacks.
diff --git a/.github/skills/agentic-component-authoring/references/tests-and-stories.md b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
index dbdc822af8..5b1fff7e90 100644
--- a/.github/skills/agentic-component-authoring/references/tests-and-stories.md
+++ b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
@@ -113,48 +113,46 @@ layout order, or native class names. Keep the initial args deterministic and
 add identifiers only to the small smoke set that agents and CI actively
 validate.
 
-Portable desktop automation is authored inline under
-`parameters.desktopDriver` and typed with `DesktopStoryTests` from
-`@fluentui-react-native/desktop-driver/authoring`:
+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`):
 
 ```tsx
 export const Default: Story = {
-  tags: ['desktop-e2e'],
-  parameters: {
-    desktopDriver: {
-      version: 1,
-      tests: [
-        {
-          id: 'enabled-button',
-          steps: [
-            { action: 'wait', target: { testId: 'story-button' } },
-            { expect: { state: 'enabled', target: { testId: 'story-button' }, value: true } },
-          ],
-        },
-      ],
-    } satisfies DesktopStoryTests,
+  wdio: {
+    'is enabled': async ({ browser, expect }) => {
+      await expect(await browser.$('~story-button')).toBeEnabled();
+    },
   },
 };
 ```
 
-Keep the plan a static JSON literal. Storybook extracts it without importing
-the React Native module, so variables, functions, spreads, computed properties,
-and runtime platform branches are rejected. Express real differences with
-`platforms`, `requires`, and explicit skip results. Use `testID` for actions;
-use role, accessible name, state, and value assertions to verify the public
-accessibility contract. Button, Checkbox, and Input defaults are the canonical
-initial examples.
-
-For executable Node tests, Button also demonstrates a top-level `wdio`
-callback typed with `WdioStory` from
-`@fluentui-react-native/storybook-desktop/testing`. Wrap `StoryObj` in `WdioStory`
-and import the type only. The callback receives `browser`, `expect`, `desktop`,
-`signal`, and `skip`; it cannot capture story-module bindings. Node-compatible
-helpers may be dynamically imported inside the callback. The shared Babel
-configuration strips test bodies before Metro resolves dependencies.
-Run these with `yarn storybook test --<platform>`. The `stories-and-tests`
-smoke mode also runs them alongside static plans, grouped by story with
-explicit navigation before execution. See the [executable test contract](../../../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
+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']`.
+
+Button is the proof of concept and no longer uses custom `desktopDriver`
+plans. Keep names static and callbacks self-contained. Node helpers may be
+dynamically imported inside each callback, but callbacks cannot capture
+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`
+smoke mode runs these functions alongside remaining legacy plans, grouped by
+story. See the [executable test contract](../../../../packages/agentic/storybook-desktop/README.md#executable-tests-inside-stories).
+
+Legacy Checkbox and Input tests still use static JSON
+`parameters.desktopDriver` plans typed with `DesktopStoryTests` from
+`@fluentui-react-native/desktop-driver/authoring`. Keep those plans static and
+use declarative `platforms` and `requires` until they are migrated; do not add
+functions or dynamic values to the old format.
+
 The components package's `test:stories` project checks the experimental
 Button stories without emitting them into the component library.
 
diff --git a/apps/storybook/AGENTS.md b/apps/storybook/AGENTS.md
index 016962e639..5fcb1dd14e 100644
--- a/apps/storybook/AGENTS.md
+++ b/apps/storybook/AGENTS.md
@@ -45,11 +45,13 @@ Read [`agent-map.yaml`](agent-map.yaml) first for the compact architecture, look
   commands against that listener.
 - macOS, Windows, and Win32 use their source-built native helpers. Keep the
   deterministic fake provider limited to package contract tests.
-- Authored tests belong in component story `parameters.desktopDriver`, not in
-  this app. The app owns identity, package discovery, platform exclusions, and
-  generated manifests.
-- Executable tests may instead use a top-level component story `wdio`
-  callback, run with `yarn storybook test --<platform>`. Defaults belong in
+- Author new tests as component story `wdio` functions or named function
+  collections, not app-local test scripts. Button demonstrates migration from
+  the legacy `parameters.desktopDriver` plans, which remain supported.
+  The app owns identity, package discovery, platform exclusions, and manifests.
+- Run executable tests with `yarn storybook test --<platform>` and optionally
+  `--test <name-glob>`. Callbacks receive the target endpoint as `platform`;
+  each named case gets an isolated worker/session and fresh preview. Defaults belong in
   `storybook.config.mts` under `wdio`; the shared Babel config removes
   callbacks from native bundles. `stories-and-tests` smoke mode runs configured
   callbacks together with static plans, grouped by story. Always navigate to
diff --git a/apps/storybook/README.md b/apps/storybook/README.md
index 2378e6c3e3..6daefd57ca 100644
--- a/apps/storybook/README.md
+++ b/apps/storybook/README.md
@@ -26,8 +26,10 @@ app-owned, while the platform-neutral UI, configuration helpers, and `storybook-
 from the shared package. The app exposes only the shared CLI entry points; native lifecycle scripts
 remain package-owned.
 
-Button also experiments with executable `wdio` callbacks directly in its
-stories. Run `yarn storybook test --macos --list` to discover them. With
+Button demonstrates named executable `wdio` tests instead of custom
+`desktopDriver` plans. Each callback receives the target `platform` and its
+own fresh preview/session/worker. Run `yarn storybook test --macos --list` to
+discover the case names, or use `--test <name-glob>` to filter them. With
 `yarn storybook driver --macos` running and the app launched via
 `yarn storybook run --macos`, run
 `yarn storybook test --macos --story 'components-button--*'`.
@@ -323,7 +325,8 @@ Run it alongside `yarn start` and `yarn storybook run --macos|--windows`. The on
 ## Writing stories
 
 Follow the package-level story authoring instructions in `../../packages/agentic/components/AGENTS.md`. Add a
-`*.stories.tsx` file next to its component; standalone native package story globs are listed explicitly in `src/main.ts`.
+`*.stories.tsx` file next to its component; package discovery belongs in `storybook.config.mts`, adapted by `src/main.ts`.
 See `../../packages/agentic/components/src/components/button/button.stories.tsx` for the canonical higher-order component example.
-Portable tests are static `parameters.desktopDriver` data with stable `testID`
-selectors; Button, Checkbox, and Input demonstrate the initial contract.
+Prefer named `wdio` functions with stable `testID` selectors and injected
+`platform` context, as demonstrated by Button. Checkbox and Input retain the
+legacy static `parameters.desktopDriver` format during migration.
diff --git a/apps/storybook/agent-map.yaml b/apps/storybook/agent-map.yaml
index 878820a532..27d9228d5f 100644
--- a/apps/storybook/agent-map.yaml
+++ b/apps/storybook/agent-map.yaml
@@ -29,9 +29,11 @@ services:
   executable_tests:
     command: yarn storybook test --<platform>
     discovery: yarn storybook test --<platform> --list
-    authoring: top-level wdio callbacks in CSF3 stories
+    authoring: top-level wdio callbacks or named callback collections in CSF3 stories
     config: storybook.config.mts wdio settings
-    lifecycle: attached-session-per-story-with-isolated-node-worker
+    lifecycle: attached-session-per-test-with-isolated-node-worker
+    context_platform: macos-or-windows-or-win32-target-endpoint
+    test_filter: --test <name-glob>
     smoke_mode: stories-and-tests
     execution: navigate-and-remount-then-run-tests-grouped-by-story
 
diff --git a/packages/agentic/components/AGENTS.md b/packages/agentic/components/AGENTS.md
index ebb72b8898..545ba889d8 100644
--- a/packages/agentic/components/AGENTS.md
+++ b/packages/agentic/components/AGENTS.md
@@ -9,13 +9,17 @@ invariants; detailed authoring recipes live in the
 - Higher-order components live in `src/components`; read `src/components/AGENTS.md`.
 - Primitive components live in `src/primitives`; read `src/primitives/AGENTS.md`.
 - Story files are library source and follow the tests and stories reference.
-- Portable desktop story tests are static `parameters.desktopDriver` plans.
-  Use the public authoring types, stable `testID` selectors, declarative
-  capability requirements, and no platform branches or executable callbacks.
-- Executable tests are a separate opt-in top-level `wdio` callback, typed
+- Prefer executable tests under top-level `wdio`, as one callback or a map
+  of named callbacks. Button is the migration proof of concept; legacy
+  `parameters.desktopDriver` plans remain supported for other components.
+  Use stable `testID` selectors and the injected target `platform` for real
+  platform differences, with explicit skips for unsupported capabilities.
+- Executable tests are typed
   with `WdioStory` from `storybook-desktop/testing` using `import type`.
   Keep callbacks self-contained; dynamically import Node helpers inside
   them so the shared Babel transform can exclude them from native bundles.
+  Each named case gets a fresh story, session, and worker; do not share native
+  element handles or depend on previous cases.
 - Storybook application, native project, Metro, bundle, or CocoaPods work follows the
   [Storybook instructions](../../../apps/storybook/AGENTS.md) and the `agentic-storybook-development` skill.
 - Native React Native Windows Fabric component work follows the
@@ -46,7 +50,7 @@ invariants; detailed authoring recipes live in the
 - Export higher-order components and public types explicitly from `src/index.ts`; export primitives and their public types
   explicitly from `src/primitives/index.ts`. Never use wildcard exports.
 - Colocate runtime tests, type tests, and Storybook stories with the implementation.
-- Keep desktop story plans inline and statically extractable; do not hide them
+- Keep legacy desktop story plans inline and statically extractable; do not hide them
   behind variables, spreads, functions, or computed values.
 - Use package scripts for format, lint, build, tests, and snapshots.
 - Do not copy web-only APIs, CSS behavior, or DOM assumptions into React Native.
diff --git a/packages/agentic/components/src/components/AGENTS.md b/packages/agentic/components/src/components/AGENTS.md
index 96703f1a42..2d9ecfba42 100644
--- a/packages/agentic/components/src/components/AGENTS.md
+++ b/packages/agentic/components/src/components/AGENTS.md
@@ -55,12 +55,11 @@ audit.
   layout.
 - Test both paths of a self-driving axis, and test that an externally driven `selected` does not change on press.
 - Keep a self-driving controlled prop out of story `args`, and keep an identity-changing axis out of story controls.
-- Author desktop automation under `parameters.desktopDriver` as static data
-  satisfying `DesktopStoryTests`. Use one stable `testID` per interacted
-  element, declare capabilities, and assert public native semantics rather than
-  implementation structure.
-- For imperative tests, use the separate top-level `wdio` callback contract
-  demonstrated by Button and run it through `storybook test`. Do not put
+- Prefer top-level `wdio` functions or named function collections demonstrated
+  by Button. Use the injected `platform`, explicit capability skips, stable
+  `testID` selectors, and public native semantics. The story supplies the suite
+  scope and each named case is isolated. Run with `storybook test`.
+- Legacy `parameters.desktopDriver` plans remain supported. Do not put
   functions in static plans or import Node helpers at story-module scope.
 
 ## Focused references
diff --git a/packages/agentic/components/src/components/button/button.stories.tsx b/packages/agentic/components/src/components/button/button.stories.tsx
index 0bbce32c5f..8eca72f44b 100644
--- a/packages/agentic/components/src/components/button/button.stories.tsx
+++ b/packages/agentic/components/src/components/button/button.stories.tsx
@@ -4,7 +4,6 @@ import type { ReactNode } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
 
 import type { Meta, StoryObj } from '@storybook/react-native';
-import type { DesktopStoryTests } from '@fluentui-react-native/desktop-driver/authoring';
 import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
 
 import { Button } from './button';
@@ -88,46 +87,30 @@ type Story = WdioStory<StoryObj<typeof Button>>;
 
 export const Default: Story = {
   tags: ['desktop-e2e'],
-  wdio: 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');
-  },
-  parameters: {
-    desktopDriver: {
-      version: 1,
-      tests: [
-        {
-          id: 'pointer-focus',
-          platforms: ['windows', 'win32'],
-          title: 'Responds to activation and receives focus',
-          requires: ['element-screenshot', 'focus', 'physical-click'],
-          steps: [
-            { action: 'wait', target: { testId: 'agentic-storybook-button' } },
-            { expect: { state: 'role', target: { testId: 'agentic-storybook-button' }, value: 'button' } },
-            { expect: { state: 'enabled', target: { testId: 'agentic-storybook-button' }, value: true } },
-            { action: 'click', target: { testId: 'agentic-storybook-button' } },
-            { expect: { state: 'focused', target: { testId: 'agentic-storybook-button' }, value: true } },
-            { action: 'screenshot', name: 'button-focused', target: { testId: 'agentic-storybook-button' } },
-          ],
-        },
-        {
-          id: 'pointer-activation',
-          platforms: ['macos'],
-          title: 'Accepts native pointer activation',
-          requires: ['element-screenshot', 'physical-click'],
-          steps: [
-            { action: 'wait', target: { testId: 'agentic-storybook-button' } },
-            { expect: { state: 'role', target: { testId: 'agentic-storybook-button' }, value: 'button' } },
-            { expect: { state: 'enabled', target: { testId: 'agentic-storybook-button' }, value: true } },
-            { action: 'click', target: { testId: 'agentic-storybook-button' } },
-            { action: 'screenshot', name: 'button-after-click', target: { testId: 'agentic-storybook-button' } },
-          ],
-        },
-      ],
-    } satisfies DesktopStoryTests,
+  wdio: {
+    '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 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();
+      if (platform === 'windows' || platform === 'win32') {
+        await browser.waitUntil(async () => (await button.getProperty('focused')) === true, {
+          timeoutMsg: 'The activated button did not receive keyboard focus.',
+        });
+      }
+      expect(await browser.takeElementScreenshot(await button.elementId)).toMatch(/^iVBORw0KGgo/);
+    },
   },
 };
 
@@ -260,16 +243,27 @@ export const Selected: Story = {
 };
 
 export const ExternallyDrivenSelection: Story = {
-  wdio: 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');
-    await favorite.click();
-    await expect(status).toHaveText('Selected');
-    await reset.click();
-    await expect(status).toHaveText('Not selected');
+  wdio: {
+    '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, 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;
+      }
+      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');
+      await favorite.click();
+      await expect(status).toHaveText('Selected');
+      await reset.click();
+      await expect(status).toHaveText('Not selected');
+    },
   },
   render: () => {
     const ToggleGroup = () => {
diff --git a/packages/agentic/desktop-driver/references/test-integration.md b/packages/agentic/desktop-driver/references/test-integration.md
index 23ab4d9e1b..57091f2220 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -62,8 +62,12 @@ This registers the same custom commands without creating a second session.
 The supervisor retains ownership and must call `delete()` after the worker
 exits, including on assertion failures, timeouts, or crashes.
 
-Storybook's experimental top-level `wdio` story callbacks use this pattern
-with Node's built-in test runner. Extraction, native-bundle stripping, runner
+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
 [`storybook-desktop`](../../storybook-desktop/README.md#executable-tests-inside-stories),
 not this Storybook-independent package. Static plans below are unchanged.
diff --git a/packages/agentic/desktop-driver/src/storybook.ts b/packages/agentic/desktop-driver/src/storybook.ts
index 91cc246a27..4946ad486e 100644
--- a/packages/agentic/desktop-driver/src/storybook.ts
+++ b/packages/agentic/desktop-driver/src/storybook.ts
@@ -9,7 +9,7 @@ export type DesktopStoryManifestEntry = {
   tags: readonly string[];
   title: string;
   tests?: DesktopStoryTests;
-  wdio?: { digest: string; exportName: string };
+  wdio?: { digest: string; exportName: string; testNames?: readonly string[] };
 };
 
 export type DesktopStoryManifest = {
diff --git a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
index 3ecf3d0bbe..c968cda505 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
@@ -2,6 +2,7 @@ import { attach, remote } from 'webdriverio';
 
 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 type { DesktopClickMode, DesktopPlatformName } from '../protocol/types.js';
@@ -15,6 +16,7 @@ declare global {
     interface Capabilities {
       'furn:clickMode'?: 'accessibility' | 'auto' | 'physical';
       'furn:endpoint'?: 'macos' | 'win32' | 'windows';
+      'furn:features'?: Readonly<DesktopHostFeatures>;
       'furn:launchMode'?: 'attach' | 'launch';
       'furn:target'?: string;
     }
diff --git a/packages/agentic/storybook-desktop/README.md b/packages/agentic/storybook-desktop/README.md
index b3cf003603..80d94261a8 100644
--- a/packages/agentic/storybook-desktop/README.md
+++ b/packages/agentic/storybook-desktop/README.md
@@ -144,16 +144,17 @@ Driver listener on separate loopback ports in one Node process. It resolves the
 verified native helper before starting Metro and registers a process-backed
 target. The deterministic fake host remains test-only.
 
-Component authors tag portable plans with `desktop-e2e`. Button, Checkbox, and
-Input provide the initial examples. Plan extraction evaluates only the inline
+New component tests should use executable WDIO functions. Legacy Checkbox and
+Input plans remain supported during migration and use the `desktop-e2e` tag.
+Plan extraction evaluates only the inline
 static `desktopDriver` literal and supports TypeScript `satisfies`; dynamic
 values fail with source context instead of being omitted.
 
 ### Executable tests inside stories
 
-For imperative tests, add a top-level `wdio` callback to a CSF3 story. This is
-an opt-in companion to static `parameters.desktopDriver` plans, not a React
-Native implementation of the web `play` function:
+Add a top-level `wdio` property to a CSF3 story. The story is the suite
+(`describe`), and named functions are its test cases (`it`). Test bodies use
+WebdriverIO directly rather than a custom action/expectation JSON format:
 
 ```tsx
 import type { StoryObj } from '@storybook/react-native';
@@ -162,21 +163,50 @@ import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing
 type Story = WdioStory<StoryObj<typeof Button>>;
 
 export const Default: Story = {
-  wdio: async ({ browser, expect }) => {
-    const button = await browser.$('~save-button');
-    await expect(button).toBeEnabled();
-    await button.click();
+  args: { testID: 'save-button' },
+  wdio: {
+    'is enabled': async ({ browser, expect }) => {
+      await expect(await browser.$('~save-button')).toBeEnabled();
+    },
+    'supports native activation': async ({ browser, platform, skip }) => {
+      const features = browser.capabilities['furn:features'];
+      if (!features?.physicalClick) {
+        skip('Physical pointer input is unavailable.');
+        return;
+      }
+      const button = await browser.$('~save-button');
+      await button.click();
+      if (platform !== 'macos' && features.focus) {
+        await browser.waitUntil(async () => (await button.getProperty('focused')) === true);
+      }
+    },
   },
 };
 ```
 
 `browser` is the real WebdriverIO browser, `expect` is `expect-webdriverio`,
 and `desktop` exposes the existing typed native assertions and story commands.
+`platform` is the **target endpoint**, typed as `'macos' | 'windows' | 'win32'`;
+it is not `process.platform`. Win32 stays distinct even though its WebDriver
+`platformName` is `windows`. Native feature flags are typed under
+`browser.capabilities['furn:features']`.
 `signal` allows cooperative cancellation; `skip(reason)` records an explicit
 skip (return from the callback after calling it). Native selectors and
 supported WebDriver operations apply; there is no DOM or JavaScript execution
 inside the app.
 
+The original `wdio: async (context) => { ... }` form remains supported. It is
+one test, called `default` for filtering. Named collections must be non-empty,
+with unique literal names and inline function values; spreads, computed
+names, methods, nested suites, and dynamic test registration are rejected.
+This is intentionally a lightweight story-as-suite pattern, not injected
+Mocha/Jest `describe`/`it` globals. Names can be discovered without executing
+test code, and each case retains its own process and native session.
+
+Use `getProperty()` to read a native element property before asserting it;
+Jest's ordinary `toHaveProperty()` matcher inspects the JavaScript object,
+not the native control.
+
 Callbacks are extracted without importing React Native in Node. They must be
 inline functions with no closures over the story module's imports, helpers,
 args, or render state. Declare test-local values inside the callback. Import
@@ -200,6 +230,7 @@ yarn storybook driver --macos
 # Terminal 2: launch the native app, then run the inline tests.
 yarn storybook run --macos
 yarn storybook test --macos --story 'components-button--*'
+yarn storybook test --macos --story 'components-button--*' --test '*activation*'
 ```
 
 Defaults come from `storybook.config.mts`; no Mocha, Jest, or WDIO config file
@@ -212,12 +243,13 @@ export default makeDesktopStorybookConfig({
     timeoutMs: 30_000,
     reporter: 'spec', // spec, tap, or dot
     clickMode: 'auto',
-    // Optional: story: 'components-button--*', tag: 'my-test-tag'
+    // Optional: story: 'components-button--*', test: '*activation*', tag: 'my-test-tag'
   },
 });
 ```
 
-CLI filters, `--timeout-ms`, `--reporter`, and `--click-mode` override those
+`--list` includes named cases and respects `--test` filtering. CLI filters,
+`--timeout-ms`, `--reporter`, and `--click-mode` override those
 defaults. By default `test` uses the saved driver's actual port and target,
 including port-probing adjustments. `--url` and `--target` together select an
 externally managed driver. On macOS the command refreshes an exact,
@@ -225,29 +257,36 @@ nonce-bound lease for the isolated app identity. Windows and Win32 require
 the trusted lifecycle owner to provide the existing application lease;
 the test runner does not attach by an ambiguous process name or title.
 
-Node's built-in test runner executes each story in a separate process. The
+Node's built-in test runner executes **each test** in a separate process. The
 supervisor owns one attached WebDriver session at a time, authenticates the
 live manifest, navigates to and remounts the correct story before each callback, and deletes the
 session after success, failure, timeout, or worker exit. The app and driver
 remain running. Failed callbacks exit nonzero; no matches is an error.
+Named cases run in declaration order, grouped by story. The timeout applies
+per case, not to the entire suite. Assertion failures and timeouts do not
+prevent other independent cases in that story from running; connection or
+session-cleanup failures stop execution. Do not share element handles or
+assume state survives between cases.
 Reports and best-effort failure source/tree evidence live in
 `artifacts/<platform>/wdio`. Generated executable files are removed after the
-run. Callback digests participate in manifest freshness checks: restart the
+run. Named results include `testName`, and failure evidence uses distinct
+paths for each case. Callback digests participate in manifest freshness checks: restart the
 driver and reload the app after editing tests.
 
-Button's `Default` demonstrates assertions and Node-only imports;
+Button's `Default` replaces its legacy plans with named WDIO tests for
+semantics, platform-specific focus, pointer activation, and PNG capture.
 `ExternallyDrivenSelection` verifies actual activation and caller-owned state
 updates through the visible status label, since macOS does not expose
 `checked` on the native button role. Run callbacks directly with `storybook test`, or include them in
 `storybook smoke --<platform> --mode stories-and-tests`. Smoke groups tests by
-story ID, runs that story's `desktop-e2e` plans and configured `wdio` callback,
+story ID, runs that story's remaining legacy `desktop-e2e` plans and selected `wdio` cases,
 then advances to the next story. Non-default stories are included. Every test
 gets a fresh preview; the currently selected sidebar page is not a prerequisite.
 The aggregate smoke report contains static results in `tests` and executable
 results in `wdio`. Per-story executable reports are under
 `artifacts/<platform>/desktop-driver/wdio`.
 
-Run the resulting plans through the consuming app's Desktop Driver CLI:
+For legacy JSON plans only, use the consuming app's Desktop Driver CLI:
 
 ```sh
 yarn desktop-driver stories list \
diff --git a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
index c815145dd3..aac57cf91a 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -57,6 +57,30 @@ function resolveInitializer(value, seen = new Set(), bindings = new Set()) {
   return value;
 }
 
+function collectCallbacks(value) {
+  const requireCallback = (callback) => {
+    if ((!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) || callback.node.generator) {
+      fail(callback, 'each test must be an inline, non-generator function.');
+    }
+    return callback;
+  };
+  if (!value.isObjectExpression()) return [{ callback: requireCallback(value) }];
+  const callbacks = [];
+  const names = new Set();
+  for (const member of value.get('properties')) {
+    if (!member.isObjectProperty() || member.node.computed) {
+      fail(member, 'named tests require static properties, not spreads, computed keys, methods or accessors.');
+    }
+    const name = keyName(member);
+    if (!name || !name.trim()) fail(member, 'named tests require a non-empty name.');
+    if (names.has(name)) fail(member, `duplicate test name "${name}".`);
+    names.add(name);
+    callbacks.push({ name, callback: requireCallback(unwrap(member.get('value'))) });
+  }
+  if (!callbacks.length) fail(value, 'a named test collection must contain at least one test.');
+  return callbacks;
+}
+
 /** Shared by the Node extractor and Metro; inspect only named CSF story objects. */
 function collectWdioTests(program) {
   const exports = [];
@@ -107,11 +131,8 @@ function collectWdioTests(program) {
       if (keyName(member) !== 'wdio') continue;
       if (test) fail(member, `"${exportName}" has duplicate wdio properties.`);
       if (!member.isObjectProperty()) fail(member, `"${exportName}".wdio must be an inline function value, not a method or accessor.`);
-      const callback = unwrap(member.get('value'));
-      if ((!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) || callback.node.generator) {
-        fail(member, `"${exportName}".wdio must be an inline, non-generator function.`);
-      }
-      test = { callback, property: member };
+      const value = unwrap(member.get('value'));
+      test = { callbacks: collectCallbacks(value), property: member, value };
     }
     if (test) {
       const declaration = object.findParent((parent) => parent.isVariableDeclarator());
@@ -251,7 +272,9 @@ module.exports = () => ({
       const filename = state.filename ?? state.file.opts.filename;
       if (!filename || !/\.stories\.tsx?$/.test(filename)) return;
       const tests = collectWdioTests(program);
-      for (const { callback } of tests.values()) compileWdioTest(callback, filename, state.file.code);
+      for (const { callbacks } of tests.values()) {
+        for (const { callback } of callbacks) compileWdioTest(callback, filename, state.file.code);
+      }
       for (const { property } of tests.values()) if (!property.removed) property.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 5eecf35e0c..8444ed0b64 100644
--- a/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -3,13 +3,18 @@ import type { NodePath, PluginObj, types } from '@babel/core';
 declare function storyTests(): PluginObj;
 
 declare namespace storyTests {
-  type StoryTest = {
+  type Callback = {
+    name?: string;
     callback: NodePath<types.FunctionExpression | types.ArrowFunctionExpression>;
+  };
+  type StoryTest = {
+    callbacks: readonly Callback[];
     property: NodePath<types.ObjectProperty>;
+    value: NodePath<types.FunctionExpression | types.ArrowFunctionExpression | types.ObjectExpression>;
   };
 
   function collectWdioTests(program: NodePath<types.Program>): ReadonlyMap<string, StoryTest>;
-  function compileWdioTest(callback: StoryTest['callback'], sourceFile: string, source: string): string;
+  function compileWdioTest(callback: Callback['callback'], sourceFile: string, source: string): string;
 }
 
 export = storyTests;
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
index d91bdfceb2..25a73a4a9e 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.test.ts
@@ -133,6 +133,35 @@ function makeConfig(platformOptions = {}) {
 }
 
 describe('DesktopStorybookCli', () => {
+  test('discovers and filters named callbacks without connecting to an app', async () => {
+    const output = { write: jest.fn() };
+    const config = makeDesktopStorybookConfig({ projectRoot: storybookRoot, wdio: { test: 'semantics' } });
+    const createStoryManifest = async () => ({
+      endpoint: 'macos' as const,
+      schemaVersion: 1 as const,
+      platformManifestDigest: 'digest',
+      portablePlanDigest: 'portable',
+      entries: [
+        {
+          id: 'button--default',
+          name: 'Default',
+          title: 'Button',
+          sourcePath: 'button.stories.tsx',
+          packageName: 'fixture',
+          tags: [],
+          wdio: { exportName: 'Default', digest: 'callback', testNames: ['semantics', 'native activation'] },
+        },
+      ],
+    });
+    const command = createDesktopStorybookCommand({ config, createStoryManifest, output });
+    await command.parseAsync(['node', 'storybook', 'test', '--macos', '--list', '--test', '*activation*']);
+    expect(JSON.parse(output.write.mock.calls[0][0])).toEqual([
+      { id: 'button--default', sourcePath: 'button.stories.tsx', tests: ['native activation'] },
+    ]);
+    const cli = new DesktopStorybookCli(config, { createStoryManifest, output });
+    await expect(cli.test('macos', { list: true, test: 'missing' })).rejects.toThrow('No executable');
+  });
+
   test('prints story navigation failures before throwing the smoke summary', async () => {
     const runner = new RecordingRunner();
     const errorOutput = { write: jest.fn() };
diff --git a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
index 47a7e106f3..871be532cf 100644
--- a/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
+++ b/packages/agentic/storybook-desktop/src/cli/DesktopStorybookCli.ts
@@ -35,7 +35,7 @@ import {
 import { NodeDesktopCommandRunner, STORYBOOK_VERBOSE } from './commandRunner.js';
 import type { DesktopCommandRunner, PreparedDesktopCommand, RunningDesktopCommand } from './commandRunner.js';
 import { formatDesktopStorybookSmokeTestSummary, runDesktopStorybookSmokeTests } from './smokeTests.js';
-import { runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
+import { matchesWdioTest, runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
 import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
 
 type ResolvedDesktopStorybookInstance = DesktopStorybookInstance & {
@@ -209,7 +209,11 @@ export class DesktopStorybookCli {
     if (options.list) {
       this.output.write(
         `${JSON.stringify(
-          selected.map(({ id, sourcePath }) => ({ id, sourcePath })),
+          selected.map(({ id, sourcePath, wdio }) => ({
+            id,
+            sourcePath,
+            ...(wdio?.testNames ? { tests: wdio.testNames.filter((name) => matchesWdioTest(name, settings.test)) } : {}),
+          })),
           null,
           2,
         )}\n`,
@@ -228,7 +232,7 @@ export class DesktopStorybookCli {
       this.runner,
     );
     this.output.write(
-      `Ran ${results.length} executable wdio stories (${results.filter(({ status }) => status === 'passed').length} passed, ` +
+      `Ran ${results.length} executable wdio tests (${results.filter(({ status }) => status === 'passed').length} passed, ` +
         `${results.filter(({ status }) => status === 'skipped').length} skipped).\n`,
     );
   }
diff --git a/packages/agentic/storybook-desktop/src/cli/README.md b/packages/agentic/storybook-desktop/src/cli/README.md
index 84e5cbc66c..72d112a054 100644
--- a/packages/agentic/storybook-desktop/src/cli/README.md
+++ b/packages/agentic/storybook-desktop/src/cli/README.md
@@ -126,6 +126,10 @@ Use `yarn storybook test --macos --story 'components-button--*'` for executable
 story callbacks. It uses the app's `wdio` settings in `storybook.config.mts`
 and Node's built-in test runner, not a separate WDIO configuration. Start
 `storybook driver` and launch the app first; `--list` needs neither.
+For multiple cases, use a named function collection under the story's `wdio`
+key. `--list` includes names and `--test <name-glob>` filters them. The story
+is the suite scope; each case receives the target `platform` and runs in its
+own worker/session with an independent timeout.
 See [inline test authoring and lifecycle requirements](../../README.md#executable-tests-inside-stories).
 
 Use `smoke` for the standard renderability gate:
diff --git a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
index 511b91055a..21de734d72 100644
--- a/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
+++ b/packages/agentic/storybook-desktop/src/cli/createDesktopStorybookCommand.ts
@@ -78,10 +78,11 @@ function addTestCommand(program: Command, getApi: () => Promise<DesktopStorybook
     .description('Run executable wdio story callbacks against the running Storybook app.')
     .option('--list', 'list selected executable stories without connecting')
     .option('--story <glob>', 'filter Storybook IDs')
+    .option('--test <glob>', 'filter named wdio tests; single callbacks use the name default')
     .option('--tag <tag>', 'filter story tags')
     .option('--url <url>', 'Desktop Driver URL (requires --target)')
     .option('--target <id>', 'registered target ID (requires --url)')
-    .option('--timeout-ms <milliseconds>', 'timeout per executable story', Number)
+    .option('--timeout-ms <milliseconds>', 'timeout per executable test', Number)
     .addOption(new Option('--reporter <reporter>', 'Node test reporter').choices(['spec', 'tap', 'dot']))
     .addOption(new Option('--click-mode <mode>', 'native click semantics').choices(['auto', 'physical', 'accessibility']));
   addPlatformOptions(command);
@@ -93,6 +94,7 @@ function addTestCommand(program: Command, getApi: () => Promise<DesktopStorybook
       reporter: flags.reporter,
       story: flags.story,
       tag: flags.tag,
+      test: flags.test,
       target: flags.target,
       timeoutMs: flags.timeoutMs,
       url: flags.url,
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
index 3c39a2fe58..55a071853f 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
@@ -7,6 +7,7 @@ import type { DesktopStoryRunResult } from '@fluentui-react-native/desktop-drive
 
 import { makeDesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { runWdioStoryTests } from '../testing/runWdioTests.js';
+import { WdioStoryTestRunError } from '../testing/runWdioTests.js';
 import {
   formatDesktopStorybookSmokeTestSummary,
   runDesktopStorybookSmokeTests,
@@ -204,6 +205,21 @@ describe('runDesktopStorybookSmokeTests', () => {
     });
   });
 
+  test('preserves individual named case results when a callback collection fails', async () => {
+    options.manifest = { ...manifest, entries: [{ ...story(buttonId, true), tests: undefined }] };
+    const results = [
+      { storyId: buttonId, testName: 'first', status: 'passed' as const, durationMs: 1 },
+      { storyId: buttonId, testName: 'second', status: 'failed' as const, durationMs: 1, error: 'named assertion' },
+    ];
+    const runWdio = jest.fn(async () => {
+      throw new WdioStoryTestRunError(results, [new Error('named assertion')]);
+    });
+    await expect(runDesktopStorybookSmokeTests(options, jest.fn(), runWdio)).rejects.toThrow('named assertion');
+    expect(JSON.parse(fs.readFileSync(path.join(root, 'artifacts/windows/desktop-driver/run.json'), 'utf8'))).toMatchObject({
+      status: 'failed',
+      wdio: results,
+    });
+  });
   test('rejects stale manifests before plans execute and still closes the session', async () => {
     const runStoryTests = jest.fn();
     const deleteSession = jest.fn(async () => undefined);
diff --git a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
index 1192f30cff..a4ad6839e6 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
@@ -10,7 +10,7 @@ import type { DesktopWebdriverOptions, DesktopWebdriverSession } from '@fluentui
 
 import type { DesktopStorybookConfig } from '../config/makeDesktopStorybookConfig.js';
 import type { Platforms } from '../config/platforms.js';
-import { runWdioStoryTests, selectWdioStories, type WdioStoryTestResult } from '../testing/runWdioTests.js';
+import { runWdioStoryTests, selectWdioStories, WdioStoryTestRunError, type WdioStoryTestResult } from '../testing/runWdioTests.js';
 import { writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
 import type { DesktopCommandRunner } from './commandRunner.js';
 
@@ -84,7 +84,11 @@ export async function runDesktopStorybookSmokeTests(
           );
         } catch (error) {
           writeDesktopStorybookFailure(`smoke story "${storyId}"`, error, options.errorOutput);
-          wdio.push({ storyId, status: 'failed', durationMs: Date.now() - started, error: errorMessage(error) });
+          if (error instanceof WdioStoryTestRunError && error.results.length) {
+            wdio.push(...error.results);
+          } else {
+            wdio.push({ storyId, status: 'failed', durationMs: Date.now() - started, error: errorMessage(error) });
+          }
           throw error;
         }
       }
diff --git a/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
index e825d160d7..9aceedaba9 100644
--- a/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
@@ -57,6 +57,21 @@ describe('native Storybook test stripping', () => {
     );
   });
 
+  test.each(['macos', 'windows', 'win32'])('strips every named test and its Node dependencies on %s', (platform) => {
+    const output = transform(
+      `
+      import { View } from 'react-native';
+      export const Example = { render: () => <View testID="keep-native" />, wdio: {
+        'first test': async ({ platform }) => { const assert = await import('node:assert'); assert.ok(platform); },
+        'second test': async () => { await import('node:fs'); },
+      } };
+    `,
+      platform,
+    );
+    expect(output).toContain('keep-native');
+    expect(output).not.toMatch(/first test|second test|node:assert|node:fs|wdio/);
+  });
+
   test('leaves non-story files untouched', () => {
     const output = transform(`export const configuration = { wdio: () => 'not-a-story' };`, 'macos', 'configuration.ts');
     expect(output).toContain('wdio');
diff --git a/packages/agentic/storybook-desktop/src/config/wdio.ts b/packages/agentic/storybook-desktop/src/config/wdio.ts
index 97ba92c671..7e7b4102dd 100644
--- a/packages/agentic/storybook-desktop/src/config/wdio.ts
+++ b/packages/agentic/storybook-desktop/src/config/wdio.ts
@@ -5,6 +5,7 @@ export type DesktopStorybookWdioOptions = {
   reporter?: 'spec' | 'tap' | 'dot';
   story?: string;
   tag?: string;
+  test?: string;
   timeoutMs?: number;
 };
 
@@ -21,7 +22,7 @@ export function resolveWdioOptions(
   if (!['auto', 'accessibility', 'physical'].includes(clickMode)) {
     throw new TypeError('wdio.clickMode must be auto, accessibility, or physical.');
   }
-  for (const key of ['story', 'tag'] as const) {
+  for (const key of ['story', 'tag', 'test'] as const) {
     if (options[key] !== undefined && (typeof options[key] !== 'string' || !options[key].trim())) {
       throw new TypeError(`wdio.${key} must be a non-empty string.`);
     }
diff --git a/packages/agentic/storybook-desktop/src/driver/representativePlans.test.ts b/packages/agentic/storybook-desktop/src/driver/representativePlans.test.ts
index e04c4bddb9..d0bf0b233c 100644
--- a/packages/agentic/storybook-desktop/src/driver/representativePlans.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/representativePlans.test.ts
@@ -6,20 +6,18 @@ import path from 'node:path';
 jest.setTimeout(30_000);
 
 describe('representative desktop story plans', () => {
-  test('extracts and runs the applicable Button, Checkbox, and Input plans through WebdriverIO', async () => {
+  test('keeps the legacy Checkbox and Input plans running through WebdriverIO during migration', async () => {
     const artifactsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'representative-story-plans-'));
     try {
       const response = await runContract(artifactsRoot);
       expect(response).toMatchObject({
         planned: [
-          { id: 'components-button--default', tests: ['pointer-focus', 'pointer-activation'] },
           { id: 'components-checkbox--default', tests: ['toggles-checked-state'] },
           { id: 'components-input--default', tests: ['types-and-clears'] },
         ],
         result: {
           status: 'passed',
           tests: [
-            { status: 'passed', testId: 'pointer-focus' },
             { status: 'passed', testId: 'toggles-checked-state' },
             { status: 'passed', testId: 'types-and-clears' },
           ],
@@ -27,7 +25,6 @@ describe('representative desktop story plans', () => {
         repeated: {
           status: 'passed',
           tests: [
-            { status: 'passed', testId: 'pointer-focus' },
             { status: 'passed', testId: 'toggles-checked-state' },
             { status: 'passed', testId: 'types-and-clears' },
           ],
diff --git a/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts b/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
index 13e9f8b576..2497d6b682 100644
--- a/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/storyManifest.test.ts
@@ -49,6 +49,9 @@ describe('createDesktopStoryManifest', () => {
     const before = await manifestForSource(`export const Default = {};`);
     const first = await manifestForSource(`export const Default = { wdio: () => console.log('first-test') };`);
     const changed = await manifestForSource(`export const Default = { wdio: () => console.log('changed-test') };`);
+    const named = await manifestForSource(`export const Default = { wdio: {
+      'first case': () => console.log('hidden-body'), 'second case': () => {},
+    } };`);
     expect(before.entries[0]).not.toHaveProperty('wdio');
     expect(before.platformManifestDigest).toBe(
       createHash('sha256')
@@ -63,6 +66,9 @@ describe('createDesktopStoryManifest', () => {
     expect(first.platformManifestDigest).not.toBe(before.platformManifestDigest);
     expect(changed.platformManifestDigest).not.toBe(first.platformManifestDigest);
     expect(changed.entries[0].wdio!.digest).not.toBe(first.entries[0].wdio!.digest);
+    expect(named.entries[0].wdio).toMatchObject({ exportName: 'Default', testNames: ['first case', 'second case'] });
+    expect(named.portablePlanDigest).toBe(before.portablePlanDigest);
+    expect(JSON.stringify(named)).not.toContain('hidden-body');
   });
 
   test('fails instead of silently dropping callbacks from excluded or unrecognized story exports', async () => {
diff --git a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
index 9c8c8c2746..c1f0a039f8 100644
--- a/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
+++ b/packages/agentic/storybook-desktop/src/driver/storyManifest.ts
@@ -84,6 +84,8 @@ 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 tests = readDesktopStoryTests(
           extractDesktopStoryTests(csf._storyAnnotations?.[exportName]?.parameters, sourceFile, staticStory.id) ??
             staticStory.parameters?.desktopDriver,
@@ -98,7 +100,7 @@ export async function createDesktopStoryManifest(
           tags: [...new Set([...(csf.meta?.tags ?? []), ...(staticStory.tags ?? []), 'story'])].sort(),
           title: csf.meta?.title ?? staticStory.id.split('--')[0],
           ...(tests ? { tests } : {}),
-          ...(wdioTests.has(exportName) ? { wdio: { digest: wdioTests.get(exportName)!.digest, exportName } } : {}),
+          ...(wdio ? { wdio: { digest: wdio.digest, exportName, ...(testNames?.length ? { testNames } : {}) } } : {}),
         });
       }
 
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
index c46216715a..f73abf0e39 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -9,6 +9,43 @@ import { extractWdioTests } from './extractWdioTests.js';
 const sourceFile = path.resolve(__dirname, 'fixture.stories.tsx');
 
 describe('extractWdioTests', () => {
+  test('extracts named test functions in declaration order with independent local scopes', async () => {
+    const result = extractWdioTests(
+      `
+      import Native from 'react-native-not-loaded';
+      export const Example = { render: () => <Native />, wdio: {
+        'first case': async ({ expect, platform }) => { expect(platform).toBe('win32'); },
+        'second case': async ({ browser }) => { await browser.$('~button'); },
+      } };
+    `,
+      sourceFile,
+    ).get('Example')!;
+    expect(result.tests.map(({ name }) => name)).toEqual(['first case', 'second case']);
+    const assertion = jest.fn();
+    await vm.runInNewContext(`(${result.tests[0].code})`)({ platform: 'win32', expect: () => ({ toBe: assertion }) });
+    expect(assertion).toHaveBeenCalledWith('win32');
+    expect(() => extractWdioTests(`const shared = 1; export const Example = { wdio: { named: () => shared } };`, sourceFile)).toThrow(
+      /story-module binding/,
+    );
+    const source = `export const Example = { wdio: { first: () => {}, second: () => {} } };`;
+    expect(extractWdioTests(source, sourceFile).get('Example')!.digest).not.toBe(
+      extractWdioTests(source.replace('second:', 'renamed:'), sourceFile).get('Example')!.digest,
+    );
+  });
+
+  test.each([
+    ['{}', /at least one/],
+    ["{ '': () => {} }", /non-empty/],
+    ['{ a: () => {}, a: () => {} }', /duplicate test name/],
+    ['{ ...shared }', /static properties/],
+    ["{ ['name']: () => {} }", /static properties/],
+    ['{ named() {} }', /static properties/],
+    ['{ named: helper }', /inline/],
+    ['{ named: { nested: () => {} } }', /inline/],
+  ])('rejects invalid named collections %s', (value, message) => {
+    expect(() => extractWdioTests(`export const Example = { wdio: ${value} };`, sourceFile)).toThrow(message);
+  });
+
   test('extracts a standalone typed callback without loading the native story module', async () => {
     const tests = extractWdioTests(
       `
@@ -28,7 +65,9 @@ describe('extractWdioTests', () => {
       sourceFile,
     );
     expect([...tests.keys()]).toEqual(['Example']);
-    const { code, digest } = tests.get('Example')!;
+    const { tests: callbacks, digest } = tests.get('Example')!;
+    expect(callbacks).toHaveLength(1);
+    const { code } = callbacks[0];
     expect(code).not.toMatch(/TestContext|Promise<void>|: string|NativeComponent/);
     expect(digest).toMatch(/^[a-f0-9]{64}$/);
     const click = jest.fn();
@@ -55,8 +94,8 @@ describe('extractWdioTests', () => {
       sourceFile,
     );
     expect([...tests.keys()]).toEqual(['Renamed']);
-    expect(tests.get('Renamed')!.code).toContain('function check');
-    expect(() => vm.runInNewContext(`(${tests.get('Renamed')!.code})`)).not.toThrow();
+    expect(tests.get('Renamed')!.tests[0].code).toContain('function check');
+    expect(() => vm.runInNewContext(`(${tests.get('Renamed')!.tests[0].code})`)).not.toThrow();
   });
 
   test('resolves literal helper imports from the original file and normalizes Node builtins', () => {
@@ -68,7 +107,7 @@ describe('extractWdioTests', () => {
         assert.ok(types.isIdentifier(types.identifier('example')));
       } };`,
       sourceFile,
-    ).get('Example')!;
+    ).get('Example')!.tests[0];
     const requireFromSource = createRequire(sourceFile);
     expect(code).toContain('node:assert/strict');
     expect(code).toContain(pathToFileURL(requireFromSource.resolve('@babel/core')).href);
@@ -83,7 +122,7 @@ describe('extractWdioTests', () => {
         assert.ok(types.isIdentifier(types.identifier('example')));
       } };`,
       sourceFile,
-    ).get('Example')!;
+    ).get('Example')!.tests[0];
     const result = spawnSync(process.execPath, ['--input-type=module', '--eval', `await (${code})({});`], { encoding: 'utf8' });
     expect(result.stderr).toBe('');
     expect(result.status).toBe(0);
@@ -118,7 +157,7 @@ describe('extractWdioTests', () => {
         return first(new Local().read()) + (new constructorTarget() === constructorTarget ? 1 : 0);
       } };`,
       sourceFile,
-    ).get('Example')!;
+    ).get('Example')!.tests[0];
     expect(await vm.runInNewContext(`(${code})`)()).toBe(3);
   });
 
diff --git a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
index 44e899208e..493d5239bf 100644
--- a/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -6,8 +6,13 @@ import storyTests from '../../config/transform-story-tests.cjs';
 
 const { collectWdioTests, compileWdioTest } = storyTests;
 
-export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<string, { code: string; digest: string }> {
-  const tests = new Map<string, { code: string; digest: string }>();
+export type ExtractedWdioStory = {
+  digest: string;
+  tests: readonly { name?: string; code: string }[];
+};
+
+export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<string, ExtractedWdioStory> {
+  const tests = new Map<string, ExtractedWdioStory>();
   transformSync(code, {
     babelrc: false,
     code: false,
@@ -18,12 +23,19 @@ export function extractWdioTests(code: string, sourceFile: string): ReadonlyMap<
       () => ({
         visitor: {
           Program(program: NodePath<types.Program>) {
-            for (const [exportName, { callback }] of collectWdioTests(program)) {
-              const compiled = compileWdioTest(callback, sourceFile, code);
-              const source = code.slice(callback.node.start!, callback.node.end!);
+            for (const [exportName, { callbacks, value }] of collectWdioTests(program)) {
+              const compiled = callbacks.map(({ callback, name }) => ({
+                ...(name === undefined ? {} : { name }),
+                code: compileWdioTest(callback, sourceFile, code),
+              }));
+              const source = code.slice(value.node.start!, value.node.end!);
               tests.set(exportName, {
-                code: compiled,
-                digest: createHash('sha256').update(source).update('\0').update(compiled).digest('hex'),
+                tests: compiled,
+                digest: createHash('sha256')
+                  .update(source)
+                  .update('\0')
+                  .update(value.isObjectExpression() ? JSON.stringify(compiled) : compiled[0].code)
+                  .digest('hex'),
               });
             }
           },
diff --git a/packages/agentic/storybook-desktop/src/testing/index.ts b/packages/agentic/storybook-desktop/src/testing/index.ts
index 994006b4d1..e5df94e7d3 100644
--- a/packages/agentic/storybook-desktop/src/testing/index.ts
+++ b/packages/agentic/storybook-desktop/src/testing/index.ts
@@ -1 +1 @@
-export type { WdioStory, WdioStoryContext } from './types.js';
+export type { WdioStory, WdioStoryContext, WdioStoryTest, WdioStoryTests } from './types.js';
diff --git a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
index ba5145c37e..35fbbc90c4 100644
--- a/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -1,8 +1,10 @@
 import fs from 'node:fs';
+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 type { DesktopArtifact } from '@fluentui-react-native/desktop-driver/authoring';
 import { ArtifactManager } from '@fluentui-react-native/desktop-driver/artifacts';
 import { connectDesktopWebdriver } from '@fluentui-react-native/desktop-driver/wdio';
 import type { DesktopWebdriverSession } from '@fluentui-react-native/desktop-driver/wdio';
@@ -17,11 +19,13 @@ import { formatDesktopStorybookError, writeDesktopStorybookFailure, type Desktop
 
 export type WdioStoryTestResult = {
   storyId: string;
+  testName?: string;
   status: 'passed' | 'failed' | 'skipped';
   durationMs: number;
   error?: string;
   skipReason?: string;
   evidenceErrors?: string[];
+  artifacts?: readonly DesktopArtifact[];
 };
 
 export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
@@ -34,6 +38,17 @@ export type RunWdioStoryTestsOptions = DesktopStorybookWdioOptions & {
   errorOutput?: DesktopStorybookErrorOutput;
 };
 
+export class WdioStoryTestRunError extends Error {
+  readonly results: readonly WdioStoryTestResult[];
+
+  constructor(results: readonly WdioStoryTestResult[], failures: readonly unknown[]) {
+    const cause = failures.length === 1 ? failures[0] : new AggregateError(failures, 'Executable wdio tests and evidence/cleanup failed.');
+    super(errorMessage(cause), { cause });
+    this.name = 'WdioStoryTestRunError';
+    this.results = [...results];
+  }
+}
+
 export function selectWdioStories(
   manifest: DesktopStoryManifest,
   options: DesktopStorybookWdioOptions,
@@ -41,6 +56,7 @@ export function selectWdioStories(
   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)))
     .sort((left, right) => left.id.localeCompare(right.id));
 }
 
@@ -53,14 +69,17 @@ export async function runWdioStoryTests(
   if (stories.length === 0) {
     throw new Error('No executable wdio story tests matched the requested selection.');
   }
-  const cases = stories.map((entry) => {
+  const cases = 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.`);
     }
-    return { entry, code: extracted.code };
+    return extracted.tests
+      .filter(({ name }) => matchesWdioTest(name ?? 'default', settings.test))
+      .map(({ name, code }) => ({ entry, code, testName: name }));
   });
+  if (cases.length === 0) throw new Error('No executable wdio tests matched the requested selection.');
   const artifacts = new ArtifactManager(
     options.artifactsRoot ?? path.join(options.config.projectRoot, 'artifacts', options.platform, 'wdio'),
   );
@@ -74,11 +93,24 @@ export async function runWdioStoryTests(
   let infrastructureFailure: unknown;
   let activeStory: string | undefined;
   let phase = 'setup';
+  let activeResult: WdioStoryTestResult | undefined;
+  let activeStarted = 0;
   try {
-    for (const [index, { entry, code }] of cases.entries()) {
-      activeStory = entry.id;
+    for (const [index, { entry, code, testName }] of cases.entries()) {
+      const displayName = testName === undefined ? entry.id : `${entry.id} / ${testName}`;
+      const artifactId =
+        testName === undefined ? entry.id : `${entry.id}-${createHash('sha256').update(testName).digest('hex').slice(0, 16)}`;
+      activeStory = displayName;
       phase = 'connection';
       const started = Date.now();
+      activeStarted = started;
+      const result: WdioStoryTestResult = {
+        storyId: entry.id,
+        ...(testName === undefined ? {} : { testName }),
+        status: 'failed',
+        durationMs: 0,
+      };
+      activeResult = result;
       // The supervisor owns the session, so even a crashed or timed-out Node worker cannot strand it.
       const desktop = await connectDesktopWebdriver({
         clickMode: settings.clickMode,
@@ -87,7 +119,6 @@ export async function runWdioStoryTests(
         targetId: options.targetId,
         url: options.url,
       });
-      const result: WdioStoryTestResult = { storyId: entry.id, status: 'failed', durationMs: 0 };
       let failure: unknown;
       try {
         phase = 'manifest verification';
@@ -106,6 +137,8 @@ export async function runWdioStoryTests(
           },
           resultPath,
           storyId: entry.id,
+          platform: options.platform,
+          testName,
           timeoutMs: settings.timeoutMs,
         };
         const specPath = path.join(directory, `${index}.test.mjs`);
@@ -120,7 +153,7 @@ export async function runWdioStoryTests(
           runner,
           {
             command: process.execPath,
-            label: `wdio "${entry.id}"`,
+            label: `wdio "${displayName}"`,
             args: [
               '--test',
               '--test-concurrency=1',
@@ -134,7 +167,7 @@ export async function runWdioStoryTests(
           },
           Math.min(settings.timeoutMs + 5000, 2_147_483_647),
           resultPath,
-          entry.id,
+          displayName,
         );
         result.status = outcome.status;
         if (outcome.status === 'skipped') {
@@ -143,10 +176,12 @@ export async function runWdioStoryTests(
       } catch (error) {
         failure = error;
         result.error = formatDesktopStorybookError(error);
-        writeDesktopStorybookFailure(`wdio "${entry.id}" during ${phase}`, error, options.errorOutput);
-        result.evidenceErrors = await captureFailure(desktop, artifacts, entry.id);
+        writeDesktopStorybookFailure(`wdio "${displayName}" during ${phase}`, error, options.errorOutput);
+        const evidence = await captureFailure(desktop, artifacts, artifactId);
+        result.artifacts = evidence.artifacts;
+        result.evidenceErrors = evidence.errors;
         for (const evidenceError of result.evidenceErrors) {
-          writeDesktopStorybookFailure(`evidence for "${entry.id}"`, evidenceError, options.errorOutput);
+          writeDesktopStorybookFailure(`evidence for "${displayName}"`, evidenceError, options.errorOutput);
         }
       }
       phase = 'session cleanup';
@@ -155,7 +190,7 @@ export async function runWdioStoryTests(
       } catch (cleanupError) {
         throw new AggregateError(
           failure === undefined ? [cleanupError] : [failure, cleanupError],
-          `Could not release the wdio session for ${entry.id}; stopping before another test starts.`,
+          `Could not release the wdio session for ${displayName}; stopping before another test starts.`,
         );
       }
       result.durationMs = Date.now() - started;
@@ -163,6 +198,12 @@ export async function runWdioStoryTests(
     }
   } catch (error) {
     infrastructureFailure = error;
+    if (activeResult && !results.includes(activeResult)) {
+      activeResult.status = 'failed';
+      activeResult.error = formatDesktopStorybookError(error);
+      activeResult.durationMs = Date.now() - activeStarted;
+      results.push(activeResult);
+    }
     writeDesktopStorybookFailure(`wdio "${activeStory ?? 'run'}" during ${phase}`, error, options.errorOutput);
   }
   const failures: unknown[] = infrastructureFailure === undefined ? [] : [infrastructureFailure];
@@ -171,7 +212,7 @@ export async function runWdioStoryTests(
       new Error(
         `Executable wdio stories failed: ${results
           .filter(({ status }) => status === 'failed')
-          .map(({ storyId }) => storyId)
+          .map(({ storyId, testName }) => (testName === undefined ? storyId : `${storyId} / ${testName}`))
           .join(', ')}. ` + `See ${path.join(artifacts.root, 'run.json')}.`,
       ),
     );
@@ -194,12 +235,7 @@ export async function runWdioStoryTests(
     failures.push(error);
     writeDesktopStorybookFailure('cleaning generated wdio files', error, options.errorOutput);
   }
-  if (failures.length === 1) {
-    throw failures[0];
-  }
-  if (failures.length > 1) {
-    throw new AggregateError(failures, 'Executable wdio tests and evidence/cleanup failed.');
-  }
+  if (failures.length) throw new WdioStoryTestRunError(results, failures);
   return results;
 }
 
@@ -214,19 +250,28 @@ function isWorkerResult(value: unknown): value is WorkerResult {
   );
 }
 
-async function captureFailure(desktop: DesktopWebdriverSession, artifacts: ArtifactManager, storyId: string): Promise<string[]> {
+export function matchesWdioTest(name: string, pattern?: string): boolean {
+  return pattern === undefined || path.matchesGlob(name, pattern);
+}
+
+async function captureFailure(
+  desktop: DesktopWebdriverSession,
+  artifacts: ArtifactManager,
+  storyId: string,
+): Promise<{ artifacts: DesktopArtifact[]; errors: string[] }> {
   const errors: string[] = [];
+  const captured: DesktopArtifact[] = [];
   for (const capture of [
     async () => artifacts.writeSource(storyId, 'failure-source', await desktop.session.getPageSource()),
     async () => artifacts.writeTree(storyId, 'failure-tree', await desktop.session.getTree()),
   ]) {
     try {
-      await capture();
+      captured.push(await capture());
     } catch (error) {
       errors.push(errorMessage(error));
     }
   }
-  return errors;
+  return { artifacts: captured, errors };
 }
 
 function errorMessage(error: unknown): string {
diff --git a/packages/agentic/storybook-desktop/src/testing/types.ts b/packages/agentic/storybook-desktop/src/testing/types.ts
index 0479288ad4..8077303d07 100644
--- a/packages/agentic/storybook-desktop/src/testing/types.ts
+++ b/packages/agentic/storybook-desktop/src/testing/types.ts
@@ -1,15 +1,20 @@
 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';
 
 export type WdioStoryContext = {
   browser: DesktopWebdriverSession['browser'];
   desktop: DesktopWebdriverSession;
   expect: typeof expect;
+  platform: DesktopEndpoint;
   signal: AbortSignal;
   skip(reason: string): void;
 };
 
+export type WdioStoryTest = (context: WdioStoryContext) => void | Promise<void>;
+export type WdioStoryTests = Readonly<Record<string, WdioStoryTest>>;
+
 /** Wrap StoryObj, importing this type only; callbacks execute in Node, not React Native. */
 export type WdioStory<TStory = object> = Omit<TStory, 'wdio'> & {
-  wdio?: (context: WdioStoryContext) => void | Promise<void>;
+  wdio?: 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 1bea9c710e..10a341502e 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 } from './index.js';
+import type { WdioStory, WdioStoryContext } from './index.js';
 
 const story: WdioStory = {
   wdio: async ({ browser, desktop, expect, signal, skip }) => {
@@ -16,6 +16,28 @@ const story: WdioStory = {
   },
 };
 
+const named: WdioStory = {
+  wdio: {
+    'platform-aware test': async ({ browser, expect, platform, skip }) => {
+      const endpoint: 'macos' | 'windows' | 'win32' = platform;
+      const features = browser.capabilities['furn:features'];
+      if (features) {
+        // @ts-expect-error Native feature flags remain booleans rather than untyped vendor data.
+        const invalidFeature: string = features.physicalClick;
+        expect(invalidFeature).toBeDefined();
+      }
+      if (endpoint === 'win32') {
+        skip('Paper-only example');
+        return;
+      }
+      await expect(await browser.$('~button')).toBeEnabled();
+      // @ts-expect-error The platform is a desktop endpoint, not an arbitrary OS.
+      const invalidPlatform: WdioStoryContext['platform'] = 'android';
+      expect(invalidPlatform).toBeDefined();
+    },
+  },
+};
+
 const wrapped: WdioStory<{ args: { disabled: boolean }; wdio?: unknown }> = {
   args: { disabled: false },
   wdio: async ({ browser }) => {
@@ -33,5 +55,6 @@ const invalidArgs: WdioStory<{ args: { disabled: boolean } }> = {
 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(invalidArgs.args).toBeDefined();
 });
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index e3c3a4af04..5b88b128a5 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -10,7 +10,7 @@ async function main() {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'furn-inline-wdio-'));
   const [
     { createDesktopStoryManifest },
-    { runWdioStoryTests },
+    { runWdioStoryTests, WdioStoryTestRunError },
     { createDesktopDriverStoryHarness, createFakeStoryWindows },
     { makeDesktopStorybookConfig },
   ] = await Promise.all([
@@ -58,6 +58,34 @@ async function main() {
     export const Crash = { wdio: () => { process.exit(2); }};
     export const ExitZero = { wdio: () => { process.exit(0); }};
     export const NavigationFailure = { wdio: () => { throw new Error('must not execute without navigation'); }};
+    export const Named = { wdio: {
+      'mutates state': async ({ browser, desktop, expect, platform }) => {
+        expect(platform).toBe(desktop.session.capabilities['furn:endpoint']);
+        expect(['windows', 'win32', 'macos']).toContain(platform);
+        if (platform === 'win32') expect(desktop.session.capabilities.platformName).toBe('windows');
+        const button = await browser.$('~button-primary');
+        expect(await button.getProperty('focused')).toBe(false);
+        await button.click();
+        expect(await button.getProperty('focused')).toBe(true);
+      },
+      'starts fresh': async ({ browser, desktop, expect, platform }) => {
+        expect(platform).toBe(desktop.session.capabilities['furn:endpoint']);
+        expect(await (await browser.$('~button-primary')).getProperty('focused')).toBe(false);
+      },
+    }};
+    export const NamedFailures = { wdio: {
+      'a b': () => { throw new Error('first named failure'); },
+      'a-b': () => { throw new Error('second named failure'); },
+      'recovers': async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      },
+    }};
+    export const NamedTimeout = { wdio: {
+      'times out': async () => { await new Promise((resolve) => setTimeout(resolve, 10_000)); },
+      'runs afterward': async ({ browser, expect }) => {
+        await expect(await browser.$('~button-primary')).toBeEnabled();
+      },
+    }};
   `,
   );
   const storyPackage = { name: 'inline-fixture', root, manifest: { name: 'inline-fixture' }, storyPatterns: ['*.stories.ts'] };
@@ -95,6 +123,58 @@ async function main() {
       ...overrides,
     });
   try {
+    const platforms = {};
+    for (const platform of ['macos', 'windows', 'win32']) {
+      const platformManifest = await createDesktopStoryManifest({ projectRoot, getStoryPackages: () => [storyPackage] }, platform);
+      const platformHarness = await createDesktopDriverStoryHarness(platformManifest);
+      try {
+        const results = await runWdioStoryTests({
+          config,
+          manifest: platformManifest,
+          platform,
+          targetId: platformHarness.target.id,
+          url: platformHarness.server.url,
+          story: 'fixture-button--named',
+          timeoutMs: 2000,
+        });
+        platforms[platform] = results.map(({ testName, status }) => ({ testName, status }));
+      } finally {
+        await platformHarness.close();
+      }
+    }
+    let namedFailureResults;
+    try {
+      await run('named-failures');
+      throw new Error('Expected named failures.');
+    } catch (error) {
+      if (
+        !(error instanceof Error) ||
+        !(error instanceof WdioStoryTestRunError) ||
+        !('results' in error) ||
+        !Array.isArray(error.results)
+      ) {
+        throw error;
+      }
+      namedFailureResults = error.results;
+    }
+    if (namedFailureResults.map(({ status }) => status).join(',') !== 'failed,failed,passed') {
+      throw new Error('Named test failure prevented independent cases from running.');
+    }
+    const evidencePaths = namedFailureResults.flatMap(({ artifacts }) => (artifacts ?? []).map(({ path }) => path));
+    if (evidencePaths.length !== 4 || new Set(evidencePaths).size !== 4) {
+      throw new Error('Named failure evidence collided.');
+    }
+    const filtered = await run('named', { test: '*fresh' });
+    if (filtered.length !== 1 || filtered[0].testName !== 'starts fresh') throw new Error('Named test filtering failed.');
+    let namedTimeout;
+    try {
+      await run('named-timeout');
+      throw new Error('Expected named timeout.');
+    } catch (error) {
+      if (!(error instanceof Error) || !(error instanceof WdioStoryTestRunError) || !('results' in error) || !Array.isArray(error.results))
+        throw error;
+      namedTimeout = error.results.map(({ testName, status }) => ({ testName, status }));
+    }
     const passed = await run('pass');
     const skipped = await run('skip');
     const failures = [];
@@ -167,7 +247,24 @@ async function main() {
     if (!smokeFailureLogged) throw new Error(`Smoke control lost the callback failure: ${failedControl.stderr}`);
     const buttonConfig = makeDesktopStorybookConfig({ projectRoot, storyPackages: ['@fluentui-react-native/components'] });
     const buttonManifest = await createDesktopStoryManifest(buttonConfig, 'windows');
-    const buttonHarness = await createDesktopDriverStoryHarness(buttonManifest, { windows: createFakeStoryWindows(buttonManifest) });
+    const buttonWindows = createFakeStoryWindows(buttonManifest);
+    buttonWindows[0] = {
+      ...buttonWindows[0],
+      elements: [
+        ...buttonWindows[0].elements,
+        {
+          id: 'wdio-button',
+          automationId: 'agentic-storybook-button',
+          name: 'Button',
+          role: 'button',
+          scope: 'preview',
+          parentId: 'story-root',
+          windowId: buttonWindows[0].id,
+          rect: { x: 10, y: 10, width: 120, height: 40 },
+        },
+      ],
+    };
+    const buttonHarness = await createDesktopDriverStoryHarness(buttonManifest, { windows: buttonWindows });
     let button;
     try {
       button = await runWdioStoryTests({
@@ -182,6 +279,24 @@ async function main() {
     } finally {
       await buttonHarness.close();
     }
+    const restrictedButtonHarness = await createDesktopDriverStoryHarness(buttonManifest, {
+      windows: buttonWindows,
+      features: { physicalClick: false },
+    });
+    let restrictedButton;
+    try {
+      restrictedButton = await runWdioStoryTests({
+        config: { projectRoot: root, resolvePackage: (name) => buttonConfig.resolvePackage(name) },
+        manifest: buttonManifest,
+        platform: 'windows',
+        targetId: restrictedButtonHarness.target.id,
+        url: restrictedButtonHarness.server.url,
+        story: 'components-button--default',
+        timeoutMs: 5000,
+      });
+    } finally {
+      await restrictedButtonHarness.close();
+    }
     process.stdout.write(
       '\nWDIO_RESULT ' +
         JSON.stringify({
@@ -192,7 +307,11 @@ async function main() {
           groupedSelections,
           smoke,
           smokeFailureLogged,
-          button: button.map(({ storyId }) => storyId),
+          button: button.map(({ testName, status }) => ({ testName, status })),
+          restrictedButton: restrictedButton.map(({ testName, status }) => ({ testName, status })),
+          platforms,
+          namedFailureResults: namedFailureResults.map(({ testName, status }) => ({ testName, status })),
+          namedTimeout,
           failures,
           attachedOnly: harness.host.actions
             .filter(({ type }) => type === 'close-application')
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index be6c52179f..c9e6e82115 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -45,7 +45,32 @@ test('executes isolated inline code and releases sessions after assertion failur
       status: 'passed',
     },
     smokeFailureLogged: true,
-    button: ['components-button--default'],
+    button: [
+      { testName: 'exposes enabled button semantics', status: 'passed' },
+      { testName: 'supports native pointer activation', status: 'passed' },
+    ],
+    restrictedButton: [
+      { testName: 'exposes enabled button semantics', status: 'passed' },
+      { testName: 'supports native pointer activation', status: 'skipped' },
+    ],
+    platforms: Object.fromEntries(
+      ['macos', 'windows', 'win32'].map((platform) => [
+        platform,
+        [
+          { testName: 'mutates state', status: 'passed' },
+          { testName: 'starts fresh', status: 'passed' },
+        ],
+      ]),
+    ),
+    namedFailureResults: [
+      { testName: 'a b', status: 'failed' },
+      { testName: 'a-b', status: 'failed' },
+      { testName: 'recovers', status: 'passed' },
+    ],
+    namedTimeout: [
+      { testName: 'times out', status: 'failed' },
+      { testName: 'runs afterward', status: 'passed' },
+    ],
     generatedFiles: [],
     attachedOnly: true,
   });
diff --git a/packages/agentic/storybook-desktop/src/testing/worker.ts b/packages/agentic/storybook-desktop/src/testing/worker.ts
index 9eb058eb01..6b70623684 100644
--- a/packages/agentic/storybook-desktop/src/testing/worker.ts
+++ b/packages/agentic/storybook-desktop/src/testing/worker.ts
@@ -3,8 +3,9 @@ import { test } from 'node:test';
 
 import { attachDesktopWebdriver, type DesktopWebdriverAttachment } from '@fluentui-react-native/desktop-driver/wdio';
 import { expect } from 'expect-webdriverio';
+import type { DesktopEndpoint } from '@fluentui-react-native/desktop-driver';
 
-import type { WdioStory } from './types.js';
+import type { WdioStoryTest } from './types.js';
 import { formatDesktopStorybookError, writeDesktopStorybookFailure } from '../../config/diagnostics.cjs';
 
 export type WdioWorkerOptions = {
@@ -12,10 +13,13 @@ export type WdioWorkerOptions = {
   resultPath: string;
   storyId: string;
   timeoutMs: number;
+  platform: DesktopEndpoint;
+  testName?: string;
 };
 
-export function registerWdioStoryTest(options: WdioWorkerOptions, callback: NonNullable<WdioStory['wdio']>): void {
-  test(options.storyId, { timeout: options.timeoutMs }, async (context) => {
+export function registerWdioStoryTest(options: WdioWorkerOptions, callback: WdioStoryTest): void {
+  const name = options.testName === undefined ? options.storyId : `${options.storyId} / ${options.testName}`;
+  test(name, { timeout: options.timeoutMs }, async (context) => {
     let recorded = false;
     const recordFailure = (error: unknown) => {
       const diagnostic = formatDesktopStorybookError(error);
@@ -23,7 +27,7 @@ export function registerWdioStoryTest(options: WdioWorkerOptions, callback: NonN
         fs.writeFileSync(options.resultPath, JSON.stringify({ status: 'failed', error: diagnostic }));
         recorded = true;
       } catch (writeError) {
-        writeDesktopStorybookFailure(`wdio "${options.storyId}"`, error);
+        writeDesktopStorybookFailure(`wdio "${name}"`, error);
         throw new AggregateError([error, writeError], 'Could not persist the worker failure diagnostic.');
       }
     };
@@ -34,12 +38,16 @@ export function registerWdioStoryTest(options: WdioWorkerOptions, callback: NonN
     });
     try {
       const desktop = await attachDesktopWebdriver(options.attachment);
+      if (!['macos', 'windows', 'win32'].includes(options.platform) || desktop.session.capabilities['furn:endpoint'] !== options.platform) {
+        throw new Error('The wdio worker platform does not match the attached desktop endpoint.');
+      }
       context.signal.throwIfAborted();
       let skipReason: string | undefined;
       await callback({
         browser: desktop.browser,
         desktop,
         expect,
+        platform: options.platform,
         signal: context.signal,
         skip: (reason) => {
           if (!reason?.trim()) {

From 201c3f99cfba2643ed7e96bdbeb90411ef3655a5 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo360@gmail.com>
Date: Mon, 14 Sep 2026 15:41:32 -0700
Subject: [PATCH 4/5] Fix Storybook source config loading during prebuild

Use explicit TypeScript imports in the prebuild config graph and cover Storybook's CommonJS source fallback.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .changeset/storybook-source-config-import.md  |  5 +++
 packages/agentic/storybook-desktop/README.md  |  5 +++
 .../storybook-desktop/src/config/index.ts     |  2 +-
 .../src/config/makeDesktopStorybookConfig.ts  |  2 +-
 .../src/config/sourceConfig.test.ts           | 44 +++++++++++++++++++
 5 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/storybook-source-config-import.md
 create mode 100644 packages/agentic/storybook-desktop/src/config/sourceConfig.test.ts

diff --git a/.changeset/storybook-source-config-import.md b/.changeset/storybook-source-config-import.md
new file mode 100644
index 0000000000..4bf44a84d8
--- /dev/null
+++ b/.changeset/storybook-source-config-import.md
@@ -0,0 +1,5 @@
+---
+"@fluentui-react-native/storybook-desktop": patch
+---
+
+Fix loading WDIO settings from Storybook's source-config fallback before compiled JavaScript exists.
diff --git a/packages/agentic/storybook-desktop/README.md b/packages/agentic/storybook-desktop/README.md
index 80d94261a8..433b74f853 100644
--- a/packages/agentic/storybook-desktop/README.md
+++ b/packages/agentic/storybook-desktop/README.md
@@ -93,6 +93,11 @@ The returned `DesktopStorybookConfig` resolves package roots lazily and exposes
 orchestration. A config-level `testIDPrefix` remains available as an explicit override for consumers that do not store
 Storybook identity in `app.json`.
 
+The `src/config` import graph must also load before the TypeScript build:
+Storybook's prebuild loader falls back to CommonJS-transpiled source when
+`lib` is absent. Use explicit `.ts` extensions for relative imports in that
+graph; `rewriteRelativeImportExtensions` converts them to `.js` in build output.
+
 ## CLI and API
 
 The `storybook-desktop` binary loads `storybook.config.ts`, `.mts`, `.js`, `.mjs`, or `.cjs` from the current package.
diff --git a/packages/agentic/storybook-desktop/src/config/index.ts b/packages/agentic/storybook-desktop/src/config/index.ts
index 93b3b5a034..86fb2804f9 100644
--- a/packages/agentic/storybook-desktop/src/config/index.ts
+++ b/packages/agentic/storybook-desktop/src/config/index.ts
@@ -40,4 +40,4 @@ export type {
 } from './makeDesktopStorybookConfig.ts';
 export { FURN_STORYBOOK_PLATFORM, getAllPlatforms, getPlatform, isPlatform, setPlatform } from './platforms.ts';
 export type { Platforms } from './platforms.ts';
-export type { DesktopStorybookWdioOptions } from './wdio.js';
+export type { DesktopStorybookWdioOptions } from './wdio.ts';
diff --git a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
index c79e06550f..72488d4476 100644
--- a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
+++ b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
@@ -15,7 +15,7 @@ import type {
 } from './commands.ts';
 import { getAllPlatforms, getPlatform, isPlatform } from './platforms.ts';
 import type { Platforms } from './platforms.ts';
-import { resolveWdioOptions, type DesktopStorybookWdioOptions } from './wdio.js';
+import { resolveWdioOptions, type DesktopStorybookWdioOptions } from './wdio.ts';
 
 const defaultStoryPatterns = ['src/**/*.stories.?(ts|tsx)'] as const;
 const defaultDeviceAddons = ['@storybook/addon-ondevice-controls', '@storybook/addon-ondevice-actions'] as const;
diff --git a/packages/agentic/storybook-desktop/src/config/sourceConfig.test.ts b/packages/agentic/storybook-desktop/src/config/sourceConfig.test.ts
new file mode 100644
index 0000000000..4e1859c455
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/sourceConfig.test.ts
@@ -0,0 +1,44 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+
+test('loads the source config through the CommonJS prebuild fallback without emitted JavaScript', () => {
+  const projectRoot = path.resolve(__dirname, '../../../../../apps/storybook');
+  const result = spawnSync(
+    process.execPath,
+    [
+      '-e',
+      `
+    const { createRequire } = require('node:module');
+    const path = require('node:path');
+    const projectRoot = process.argv[1];
+    const requireFromProject = createRequire(path.join(projectRoot, 'package.json'));
+    const requireFromStorybook = createRequire(requireFromProject.resolve('@storybook/react-native'));
+    requireFromStorybook('esbuild-register/dist/node').register({
+      target: 'node22',
+      format: 'cjs',
+      hookIgnoreNodeModules: true,
+    });
+    const entry = requireFromProject.resolve('@fluentui-react-native/storybook-desktop/config');
+    const { makeDesktopStorybookConfig } = requireFromProject('@fluentui-react-native/storybook-desktop/config');
+    const config = makeDesktopStorybookConfig({
+      projectRoot,
+      platforms: ['macos'],
+      storyPackages: ['@fluentui-react-native/components'],
+      wdio: { test: '*activation*' },
+    });
+    process.stdout.write(JSON.stringify({ entry, stories: config.getStorybookConfig('macos').stories, wdio: config.wdio }));
+  `,
+      projectRoot,
+    ],
+    { cwd: projectRoot, encoding: 'utf8', timeout: 10_000 },
+  );
+
+  if (result.status !== 0) {
+    throw new Error(result.stderr || result.error?.message || `Source config loader exited with ${result.status}.`);
+  }
+  expect(JSON.parse(result.stdout)).toMatchObject({
+    entry: path.resolve(__dirname, 'index.ts'),
+    stories: ['../../../packages/agentic/components/src/**/*.stories.?(ts|tsx)'],
+    wdio: { test: '*activation*', timeoutMs: 30_000, reporter: 'spec', clickMode: 'auto' },
+  });
+});

From adc4888b2f27f954a0cf46af6d948f44689a10a8 Mon Sep 17 00:00:00 2001
From: Jason Morse <jasonmo@microsoft.com>
Date: Mon, 14 Sep 2026 17:35:22 -0700
Subject: [PATCH 5/5] Fix Storybook CI startup readiness and contract timeout

Wait for the authenticated runtime's initial preview render before sending navigation commands, including after app restart. Preserve correlated readiness and native story-root verification. Give the multi-worker WDIO contract an aggregate CI budget and retain timeout-recovery diagnostics.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .changeset/storybook-ci-readiness.md          |   5 +
 packages/agentic/storybook-desktop/README.md  |   7 ++
 .../StorybookChannelOrchestrator.test.ts      | 109 ++++++++++--------
 .../driver/StorybookChannelOrchestrator.ts    |  16 +++
 .../src/testing/wdioRunner.contract.cjs       |   3 +
 .../src/testing/wdioRunner.test.ts            |   3 +-
 6 files changed, 94 insertions(+), 49 deletions(-)
 create mode 100644 .changeset/storybook-ci-readiness.md

diff --git a/.changeset/storybook-ci-readiness.md b/.changeset/storybook-ci-readiness.md
new file mode 100644
index 0000000000..6aada88542
--- /dev/null
+++ b/.changeset/storybook-ci-readiness.md
@@ -0,0 +1,5 @@
+---
+'@fluentui-react-native/storybook-desktop': patch
+---
+
+Wait for the authenticated Storybook preview to initialize before navigating after app startup or restart. Allow the aggregate WDIO subprocess contract enough CI time without relaxing individual callback deadlines.
diff --git a/packages/agentic/storybook-desktop/README.md b/packages/agentic/storybook-desktop/README.md
index 433b74f853..6ff6fb9c94 100644
--- a/packages/agentic/storybook-desktop/README.md
+++ b/packages/agentic/storybook-desktop/README.md
@@ -149,6 +149,13 @@ Driver listener on separate loopback ports in one Node process. It resolves the
 verified native helper before starting Metro and registers a process-backed
 target. The deterministic fake host remains test-only.
 
+Navigation waits for both an authenticated runtime hello and the first
+`storyRendered` event from that same connection. The hello alone can arrive
+before Storybook installs its navigation handlers, particularly after a native
+app restart. This initial render only gates startup: each requested story must
+still acknowledge the matching request/run and pass native story-root
+verification before its tests execute.
+
 New component tests should use executable WDIO functions. Legacy Checkbox and
 Input plans remain supported during migration and use the `desktop-e2e` tag.
 Plan extraction evaluates only the inline
diff --git a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
index 630a4c97f8..411963f731 100644
--- a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
+++ b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
@@ -36,6 +36,11 @@ class FakeChannelClient {
       listener();
     }
   }
+
+  authenticate(): void {
+    this.receive('storyRendered', 'components-button--default');
+    this.receive('furn:desktop:hello', runtimeHello);
+  }
 }
 
 class FakeChannelServer implements StorybookChannelServer {
@@ -112,12 +117,61 @@ const driverManifest: DesktopStorybookDriverManifest = {
   testIDPrefix: 'agentic-storybook',
 };
 
+const runtimeHello = {
+  endpoint: 'windows',
+  instanceId: 'instance',
+  nonce: 'nonce',
+  platformManifestDigest: 'platform-digest',
+  targetId: 'agenticstorybook-windows',
+  version: 1,
+};
+
 describe('StorybookChannelOrchestrator', () => {
   const errorOutput = { write: jest.fn() };
   const createOrchestrator = (options: ConstructorParameters<typeof StorybookChannelOrchestrator>[0]) =>
     new StorybookChannelOrchestrator({ ...options, errorOutput });
   beforeEach(() => errorOutput.write.mockClear());
 
+  test('waits for the authenticated preview to initialize before navigating, including after an app restart', async () => {
+    const channelServer = new FakeChannelServer();
+    const client = new FakeChannelClient();
+    const unrelatedClient = new FakeChannelClient();
+    channelServer.connect(client);
+    channelServer.connect(unrelatedClient);
+    const fetch = jest.fn(async () => new Response('{}'));
+    const orchestrator = createOrchestrator({
+      channelServer,
+      driverManifest,
+      fetch,
+      serverUrl: 'https://localhost',
+      timeoutMs: 1000,
+    });
+
+    for (const [index, runtime] of [client, new FakeChannelClient()].entries()) {
+      if (index > 0) {
+        client.close();
+        channelServer.connect(runtime);
+      }
+      runtime.receive('furn:desktop:hello', runtimeHello);
+      const request = { requestId: `request-${index}`, runId: `run-${index}`, storyId: 'components-button--default' };
+      const selection = orchestrator.selectStory(request);
+      unrelatedClient.receive('storyRendered', request.storyId);
+      await Promise.resolve();
+      expect(fetch).toHaveBeenCalledTimes(index);
+      expect(runtime.sent.some((message) => JSON.parse(message).type === 'furn:desktop:prepare-story')).toBe(false);
+
+      runtime.receive('storyRendered', request.storyId);
+      await Promise.resolve();
+      expect(fetch).toHaveBeenCalledTimes(index + 1);
+      runtime.receive('furn:desktop:story-ready', {
+        ...request,
+        portablePlanDigest: 'portable-digest',
+        previewGeneration: 1,
+      });
+      await expect(selection).resolves.toMatchObject({ runId: request.runId });
+    }
+  });
+
   test('reports the requested story, run and HTTP failure details to the server error output', async () => {
     const channelServer = new FakeChannelServer();
     const client = new FakeChannelClient();
@@ -129,14 +183,8 @@ describe('StorybookChannelOrchestrator', () => {
       timeoutMs: 100,
       fetch: jest.fn(async () => new Response('preview module failed to load', { status: 500 })),
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+
+    client.authenticate();
     await expect(
       orchestrator.selectStory({ requestId: 'failure', runId: 'pipeline-run', storyId: 'components-button--default' }),
     ).rejects.toThrow('preview module failed to load');
@@ -168,14 +216,7 @@ describe('StorybookChannelOrchestrator', () => {
       serverUrl: 'https://localhost',
       timeoutMs: 100,
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+    client.authenticate();
 
     await expect(
       orchestrator.resetStory({ requestId: 'first', runId: 'first', storyId: 'components-button--default' }),
@@ -211,14 +252,7 @@ describe('StorybookChannelOrchestrator', () => {
       serverUrl: 'https://localhost',
       timeoutMs: 10,
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+    client.authenticate();
     await expect(orchestrator.selectStory({ requestId: 'request', runId: 'run', storyId: 'components-button--default' })).rejects.toThrow(
       'Timed out navigating',
     );
@@ -237,14 +271,7 @@ describe('StorybookChannelOrchestrator', () => {
       serverUrl: 'http://127.0.0.1:7007',
       timeoutMs: 1000,
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+    client.authenticate();
     expect(JSON.parse(client.sent[0])).toEqual({ type: 'furn:desktop:request-hello', args: [] });
     client.sent.length = 0;
 
@@ -290,14 +317,7 @@ describe('StorybookChannelOrchestrator', () => {
       serverUrl: 'http://127.0.0.1:7007',
       timeoutMs: 1000,
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+    client.authenticate();
 
     const selection = orchestrator.selectStory({
       requestId: 'request-error',
@@ -355,14 +375,7 @@ describe('StorybookChannelOrchestrator', () => {
       serverUrl: 'http://127.0.0.1:7007',
       timeoutMs: 10,
     });
-    client.receive('furn:desktop:hello', {
-      endpoint: 'windows',
-      instanceId: 'instance',
-      nonce: 'nonce',
-      platformManifestDigest: 'platform-digest',
-      targetId: 'agenticstorybook-windows',
-      version: 1,
-    });
+    client.authenticate();
     client.readyState = 3;
 
     await expect(
diff --git a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
index 9fd59b89a9..52be51a550 100644
--- a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
+++ b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.ts
@@ -49,6 +49,7 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
   private readonly errorOutput: DesktopStorybookErrorOutput;
   private readonly pending = new Map<string, PendingSelection>();
   private readonly bridgeWaiters = new Set<() => void>();
+  private readonly initializedClients = new WeakSet<ChannelClient>();
   private bridgeConnected = false;
   private bridgeClient?: ChannelClient;
   private currentStory: StoryReadyResult | null = null;
@@ -135,7 +136,9 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
       if (this.bridgeClient === client) {
         this.bridgeClient = undefined;
         this.bridgeConnected = false;
+        this.currentStory = null;
       }
+      this.initializedClients.delete(client);
     });
     if (client.readyState === 1) {
       client.send(JSON.stringify({ type: 'furn:desktop:request-hello', args: [] }));
@@ -151,6 +154,11 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
       return;
     }
     const payload = message.args?.[0];
+    if (message.type === 'storyRendered' && typeof payload === 'string') {
+      this.initializedClients.add(client);
+      this.resolveBridgeWaiters(client);
+      return;
+    }
     if (!payload || typeof payload !== 'object') {
       return;
     }
@@ -179,6 +187,14 @@ export class StorybookChannelOrchestrator implements StoryOrchestrator {
       return;
     }
     this.bridgeClient = client;
+    this.resolveBridgeWaiters(client);
+  }
+
+  private resolveBridgeWaiters(client: ChannelClient): void {
+    // The bridge can authenticate before Storybook installs its navigation handlers.
+    if (client !== this.bridgeClient || !this.initializedClients.has(client)) {
+      return;
+    }
     this.bridgeConnected = true;
     for (const resolve of this.bridgeWaiters) {
       resolve();
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
index 5b88b128a5..38b2bb840b 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -173,6 +173,9 @@ async function main() {
     } catch (error) {
       if (!(error instanceof Error) || !(error instanceof WdioStoryTestRunError) || !('results' in error) || !Array.isArray(error.results))
         throw error;
+      if (error.results.map(({ status }) => status).join(',') !== 'failed,passed') {
+        throw new Error(`Named timeout recovery failed: ${JSON.stringify(error.results)}`, { cause: error });
+      }
       namedTimeout = error.results.map(({ testName, status }) => ({ testName, status }));
     }
     const passed = await run('pass');
diff --git a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
index c9e6e82115..699fec34dc 100644
--- a/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 
+// This aggregate contract starts dozens of Node workers, including intentional timeouts.
 test('executes isolated inline code and releases sessions after assertion failures, timeouts, and crashes', async () => {
   const result = await new Promise<Record<string, unknown>>((resolve, reject) => {
     const child = spawn(process.execPath, [path.join(__dirname, 'wdioRunner.contract.cjs')], {
@@ -74,4 +75,4 @@ test('executes isolated inline code and releases sessions after assertion failur
     generatedFiles: [],
     attachedOnly: true,
   });
-}, 60_000);
+}, 120_000);