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/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/.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/.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/.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/.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/.github/skills/agentic-component-authoring/references/tests-and-stories.md b/.github/skills/agentic-component-authoring/references/tests-and-stories.md
index 3c1069e2d4..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,37 +113,48 @@ 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.
+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.
 
 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/.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 366136cdab..5fcb1dd14e 100644
--- a/apps/storybook/AGENTS.md
+++ b/apps/storybook/AGENTS.md
@@ -45,11 +45,24 @@ 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.
+- 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
+  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 929e5af860..6daefd57ca 100644
--- a/apps/storybook/README.md
+++ b/apps/storybook/README.md
@@ -26,6 +26,26 @@ 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 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--*'`.
+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).
+`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
 
 ```
@@ -305,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 f9c54bc42a..27d9228d5f 100644
--- a/apps/storybook/agent-map.yaml
+++ b/apps/storybook/agent-map.yaml
@@ -26,6 +26,16 @@ 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 or named callback collections in CSF3 stories
+    config: storybook.config.mts wdio settings
+    lifecycle: attached-session-per-test-with-isolated-node-worker
+    context_platform: macos-or-windows-or-win32-target-endpoint
+    test_filter: --test <name-glob>
+    smoke_mode: stories-and-tests
+    execution: navigate-and-remount-then-run-tests-grouped-by-story
 
 agent_commands:
   generate_manifest: yarn storybook manifest --<platform>
@@ -81,6 +91,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/AGENTS.md b/packages/agentic/components/AGENTS.md
index ec8dde4746..545ba889d8 100644
--- a/packages/agentic/components/AGENTS.md
+++ b/packages/agentic/components/AGENTS.md
@@ -9,9 +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.
+- 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
@@ -42,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/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..2d9ecfba42 100644
--- a/packages/agentic/components/src/components/AGENTS.md
+++ b/packages/agentic/components/src/components/AGENTS.md
@@ -55,10 +55,12 @@ 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.
+- 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 ea49a1937d..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,7 @@ 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';
 import type { ButtonAppearance, ButtonShape, ButtonSize } from './button.types';
@@ -12,11 +12,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>
 );
@@ -74,43 +83,34 @@ 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'],
-  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/);
+    },
   },
 };
 
@@ -243,19 +243,42 @@ export const Selected: Story = {
 };
 
 export const ExternallyDrivenSelection: Story = {
+  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 = () => {
       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}
             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..57091f2220 100644
--- a/packages/agentic/desktop-driver/references/test-integration.md
+++ b/packages/agentic/desktop-driver/references/test-integration.md
@@ -50,6 +50,28 @@ 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.
+The supervisor retains ownership and must call `delete()` after the worker
+exits, including on assertion failures, timeouts, or crashes.
+
+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.
+
 ## Author portable story plans
 
 Plans are static JSON under `parameters.desktopDriver`. Import only their types
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/storybook.ts b/packages/agentic/desktop-driver/src/storybook.ts
index df5296751b..4946ad486e 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; 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 c845bf6965..c968cda505 100644
--- a/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
+++ b/packages/agentic/desktop-driver/src/wdio/DesktopWebdriver.ts
@@ -1,7 +1,8 @@
-import { remote } from 'webdriverio';
+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 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;
     }
@@ -42,6 +44,13 @@ export type DesktopWebdriverRunOptions = {
   artifactsRoot?: string;
   selection?: DesktopStoryTestSelection;
   signal?: AbortSignal;
+  onTestResult?: (result: Readonly<DesktopStoryTestResult>) => void | Promise<void>;
+};
+
+export type DesktopWebdriverAttachment = {
+  capabilities: NonNullable<Parameters<typeof attach>[0]['capabilities']>;
+  sessionId: string;
+  url: string;
 };
 
 export class DesktopWebdriverSession {
@@ -85,6 +94,7 @@ export class DesktopWebdriverSession {
       ...(options.artifactsRoot ? { artifacts: new ArtifactManager(options.artifactsRoot) } : {}),
       endpoint,
       manifest,
+      onTestResult: options.onTestResult,
       platformName,
       selection: options.selection,
       session: this.session,
@@ -99,7 +109,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 +121,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..6ff6fb9c94 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.
@@ -144,12 +149,156 @@ 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
+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
 static `desktopDriver` literal and supports TypeScript `satisfies`; dynamic
 values fail with source context instead of being omitted.
 
-Run the resulting plans through the consuming app's Desktop Driver CLI:
+### Executable tests inside stories
+
+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';
+import type { WdioStory } from '@fluentui-react-native/storybook-desktop/testing';
+
+type Story = WdioStory<StoryObj<typeof Button>>;
+
+export const Default: Story = {
+  args: { testID: 'save-button' },
+  wdio: {
+    'is enabled': async ({ browser, expect }) => {
+      await expect(await browser.$('~save-button')).toBeEnabled();
+    },
+    'supports 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
+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--*'
+yarn storybook test --macos --story 'components-button--*' --test '*activation*'
+```
+
+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--*', test: '*activation*', tag: 'my-test-tag'
+  },
+});
+```
+
+`--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,
+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 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. 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` 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 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`.
+
+For legacy JSON plans only, use the consuming app's Desktop Driver CLI:
 
 ```sh
 yarn desktop-driver stories list \
@@ -172,8 +321,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
@@ -224,6 +374,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/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/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/config/transform-story-tests.cjs b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
new file mode 100644
index 0000000000..aac57cf91a
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.cjs
@@ -0,0 +1,284 @@
+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;
+}
+
+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 = [];
+  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 value = unwrap(member.get('value'));
+      test = { callbacks: collectCallbacks(value), property: member, value };
+    }
+    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 { 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();
+    },
+  },
+});
+
+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..8444ed0b64
--- /dev/null
+++ b/packages/agentic/storybook-desktop/config/transform-story-tests.d.cts
@@ -0,0 +1,20 @@
+import type { NodePath, PluginObj, types } from '@babel/core';
+
+declare function storyTests(): PluginObj;
+
+declare namespace storyTests {
+  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: Callback['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..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,102 @@ 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() };
+    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() };
+    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 });
@@ -433,10 +529,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(
@@ -459,6 +558,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 2143e5a59f..871be532cf 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,9 +32,11 @@ 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 { matchesWdioTest, runWdioStoryTests, selectWdioStories } from '../testing/runWdioTests.js';
+import { resolveWdioOptions, type DesktopStorybookWdioOptions } from '../config/wdio.js';
 
 type ResolvedDesktopStorybookInstance = DesktopStorybookInstance & {
   driverManifestPath?: string;
@@ -54,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;
@@ -65,6 +70,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;
@@ -74,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;
@@ -85,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;
@@ -135,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(
         {
@@ -147,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.');
     }
   }
 
@@ -163,6 +196,79 @@ 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, wdio }) => ({
+            id,
+            sourcePath,
+            ...(wdio?.testNames ? { tests: wdio.testNames.filter((name) => matchesWdioTest(name, settings.test)) } : {}),
+          })),
+          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, errorOutput: this.errorOutput },
+      this.runner,
+    );
+    this.output.write(
+      `Ran ${results.length} executable wdio tests (${results.filter(({ status }) => status === 'passed').length} passed, ` +
+        `${results.filter(({ status }) => status === 'skipped').length} skipped).\n`,
+    );
+  }
+
+  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(
@@ -304,9 +410,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`);
@@ -321,7 +430,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);
         }
@@ -443,7 +552,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;
@@ -452,7 +562,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`);
   }
@@ -545,6 +655,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 671b237e51..72d112a054 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                                                                                   |
@@ -68,6 +75,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 +122,16 @@ 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.
+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:
 
 ```sh
@@ -127,7 +145,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 21a9ff54af..21de734d72 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';
@@ -33,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 = () =>
@@ -47,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,
@@ -58,6 +62,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 +72,36 @@ 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('--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 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);
+  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,
+      test: flags.test,
+      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/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 bd9b0beca0..4956c38801 100644
--- a/packages/agentic/storybook-desktop/src/cli/index.ts
+++ b/packages/agentic/storybook-desktop/src/cli/index.ts
@@ -9,10 +9,12 @@ export {
   type DesktopStorybookCliOptions,
   type DesktopStorybookPrepOptions,
   type DesktopStorybookServerOptions,
+  type DesktopStorybookTestOptions,
 } from './DesktopStorybookCli.js';
 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..55a071853f 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.test.ts
@@ -1,113 +1,242 @@
+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 { WdioStoryTestRunError } 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('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);
+    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..a4ad6839e6 100644
--- a/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
+++ b/packages/agentic/storybook-desktop/src/cli/smokeTests.ts
@@ -1,26 +1,155 @@
+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, WdioStoryTestRunError, 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);
+          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;
+        }
+      }
+    } 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 +159,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 +194,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/config/index.ts b/packages/agentic/storybook-desktop/src/config/index.ts
index 2727544faf..86fb2804f9 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.ts';
diff --git a/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts b/packages/agentic/storybook-desktop/src/config/makeDesktopStorybookConfig.ts
index 504f168ac0..72488d4476 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.ts';
 
 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/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' },
+  });
+});
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..9aceedaba9
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/transformStoryTests.test.ts
@@ -0,0 +1,108 @@
+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.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');
+    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..7e7b4102dd
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/config/wdio.ts
@@ -0,0 +1,31 @@
+import type { DesktopWebdriverOptions } from '@fluentui-react-native/desktop-driver/wdio';
+
+export type DesktopStorybookWdioOptions = {
+  clickMode?: DesktopWebdriverOptions['clickMode'];
+  reporter?: 'spec' | 'tap' | 'dot';
+  story?: string;
+  tag?: string;
+  test?: 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', '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.`);
+    }
+  }
+  return Object.freeze({ ...options, timeoutMs, reporter, clickMode });
+}
diff --git a/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts b/packages/agentic/storybook-desktop/src/driver/StorybookChannelOrchestrator.test.ts
index 19d61ab562..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,153 @@ 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();
+    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.authenticate();
+    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.authenticate();
+
+    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.authenticate();
+    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 })),
@@ -125,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;
 
@@ -170,7 +309,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,
@@ -178,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',
@@ -212,13 +344,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 +367,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(),
@@ -244,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 552b33019d..52be51a550 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,8 +46,10 @@ 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 readonly initializedClients = new WeakSet<ChannelClient>();
   private bridgeConnected = false;
   private bridgeClient?: ChannelClient;
   private currentStory: StoryReadyResult | null = null;
@@ -56,11 +60,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 +82,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 });
@@ -120,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: [] }));
@@ -136,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;
     }
@@ -164,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/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/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 b75f4f9a41..2497d6b682 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,68 @@ 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') };`);
+    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')
+        .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);
+    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 () => {
+    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..c1f0a039f8 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,7 +77,15 @@ 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 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,
@@ -91,6 +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 } : {}),
+          ...(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
new file mode 100644
index 0000000000..f73abf0e39
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.test.ts
@@ -0,0 +1,257 @@
+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 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(
+      `
+      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 { 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();
+    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')!.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', () => {
+    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')!.tests[0];
+    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')!.tests[0];
+    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')!.tests[0];
+    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..493d5239bf
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/extractWdioTests.ts
@@ -0,0 +1,47 @@
+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 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,
+    configFile: false,
+    filename: sourceFile,
+    parserOpts: { plugins: ['typescript', 'jsx'] },
+    plugins: [
+      () => ({
+        visitor: {
+          Program(program: NodePath<types.Program>) {
+            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, {
+                tests: compiled,
+                digest: createHash('sha256')
+                  .update(source)
+                  .update('\0')
+                  .update(value.isObjectExpression() ? JSON.stringify(compiled) : compiled[0].code)
+                  .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..e5df94e7d3
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/index.ts
@@ -0,0 +1 @@
+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
new file mode 100644
index 0000000000..35fbbc90c4
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/runWdioTests.ts
@@ -0,0 +1,334 @@
+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';
+
+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';
+import { formatDesktopStorybookError, writeDesktopStorybookFailure, type DesktopStorybookErrorOutput } from '../../config/diagnostics.cjs';
+
+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 & {
+  config: DesktopStorybookConfig;
+  manifest: DesktopStoryManifest;
+  platform: Platforms;
+  targetId: string;
+  url: string;
+  artifactsRoot?: string;
+  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,
+): readonly DesktopStoryManifestEntry[] {
+  return manifest.entries
+    .filter((entry) => entry.wdio && (!options.story || path.matchesGlob(entry.id, options.story)))
+    .filter((entry) => !options.tag || entry.tags.includes(options.tag))
+    .filter((entry) => (entry.wdio?.testNames ?? ['default']).some((name) => matchesWdioTest(name, options.test)))
+    .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.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 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'),
+  );
+  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;
+  let activeStory: string | undefined;
+  let phase = 'setup';
+  let activeResult: WdioStoryTestResult | undefined;
+  let activeStarted = 0;
+  try {
+    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,
+        launchMode: 'attach',
+        platformName: options.platform === 'macos' ? 'macos' : 'windows',
+        targetId: options.targetId,
+        url: options.url,
+      });
+      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.');
+        }
+        phase = 'navigation';
+        await desktop.openStory(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,
+          platform: options.platform,
+          testName,
+          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 },
+        );
+        phase = 'execution';
+        const outcome = await runWorker(
+          runner,
+          {
+            command: process.execPath,
+            label: `wdio "${displayName}"`,
+            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),
+          resultPath,
+          displayName,
+        );
+        result.status = outcome.status;
+        if (outcome.status === 'skipped') {
+          result.skipReason = outcome.skipReason;
+        }
+      } catch (error) {
+        failure = error;
+        result.error = formatDesktopStorybookError(error);
+        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 "${displayName}"`, evidenceError, options.errorOutput);
+        }
+      }
+      phase = 'session cleanup';
+      try {
+        await desktop.delete();
+      } catch (cleanupError) {
+        throw new AggregateError(
+          failure === undefined ? [cleanupError] : [failure, cleanupError],
+          `Could not release the wdio session for ${displayName}; stopping before another test starts.`,
+        );
+      }
+      result.durationMs = Date.now() - started;
+      results.push(result);
+    }
+  } 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];
+  if (results.some(({ status }) => status === 'failed')) {
+    failures.push(
+      new Error(
+        `Executable wdio stories failed: ${results
+          .filter(({ status }) => status === 'failed')
+          .map(({ storyId, testName }) => (testName === undefined ? storyId : `${storyId} / ${testName}`))
+          .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);
+    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) throw new WdioStoryTestRunError(results, failures);
+  return results;
+}
+
+type WorkerResult = { status: 'passed' } | { status: 'skipped'; skipReason: string };
+
+function isWorkerResult(value: unknown): value is WorkerResult {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'status' in value &&
+    (value.status === 'passed' || (value.status === 'skipped' && 'skipReason' in value && typeof value.skipReason === '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 {
+      captured.push(await capture());
+    } catch (error) {
+      errors.push(errorMessage(error));
+    }
+  }
+  return { artifacts: captured, errors };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+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,
+      new Promise<never>((_resolve, reject) => {
+        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 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({ 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/types.ts b/packages/agentic/storybook-desktop/src/testing/types.ts
new file mode 100644
index 0000000000..8077303d07
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/types.ts
@@ -0,0 +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?: 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
new file mode 100644
index 0000000000..10a341502e
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdio.types.test.ts
@@ -0,0 +1,60 @@
+import type { WdioStory, WdioStoryContext } 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 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 }) => {
+    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(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
new file mode 100644
index 0000000000..38b2bb840b
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.contract.cjs
@@ -0,0 +1,353 @@
+const { spawn } = require('node:child_process');
+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, WdioStoryTestRunError },
+    { 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 = {
+      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 () => {
+      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); }};
+    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'] };
+  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 }),
+  };
+  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 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;
+      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');
+    const skipped = await run('skip');
+    const failures = [];
+    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' } } : { reporter: 'dot' },
+        );
+      } 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.`);
+      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 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({
+        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();
+    }
+    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({
+          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(({ 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')
+            .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 });
+  }
+}
+
+/** @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
new file mode 100644
index 0000000000..699fec34dc
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/wdioRunner.test.ts
@@ -0,0 +1,78 @@
+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')], {
+      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');
+        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]));
+        }
+      }
+    });
+  });
+  expect(result).toMatchObject({
+    passed: ['fixture-button--pass'],
+    skipped: ['fixture-button--skip'],
+    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: [
+      { 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,
+  });
+}, 120_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..6b70623684
--- /dev/null
+++ b/packages/agentic/storybook-desktop/src/testing/worker.ts
@@ -0,0 +1,68 @@
+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 { DesktopEndpoint } from '@fluentui-react-native/desktop-driver';
+
+import type { WdioStoryTest } from './types.js';
+import { formatDesktopStorybookError, writeDesktopStorybookFailure } from '../../config/diagnostics.cjs';
+
+export type WdioWorkerOptions = {
+  attachment: DesktopWebdriverAttachment;
+  resultPath: string;
+  storyId: string;
+  timeoutMs: number;
+  platform: DesktopEndpoint;
+  testName?: string;
+};
+
+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);
+      try {
+        fs.writeFileSync(options.resultPath, JSON.stringify({ status: 'failed', error: diagnostic }));
+        recorded = true;
+      } catch (writeError) {
+        writeDesktopStorybookFailure(`wdio "${name}"`, error);
+        throw new AggregateError([error, writeError], 'Could not persist the worker failure diagnostic.');
+      }
+    };
+    context.after(() => {
+      if (!recorded && context.signal.aborted) {
+        recordFailure(context.signal.reason);
+      }
+    });
+    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()) {
+            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;
+    }
+  });
+}
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