@tantawowa/hosanna-tools 3.8.0 → 3.10.0

package/README.md

@@ -2,7 +2,7 @@
 
 ## Documentation
 
-- **[MCP debugger & UI tests](src/support-tools/mcp-server/README.md)** — `hst mcp:start`, all MCP tools, commands by use case, examples, `hst test:ui` / `hst test:record`.
+- **[MCP debugger](src/support-tools/mcp-server/README.md)** — `hst mcp:start`, debugger tools, commands by use case, examples, and RASP certification capture.
 - **[docs/README.md](docs/README.md)** — index of docs in this repo (MCP + source-map note).
 - **hosanna-ui** (separate repo): `docs/README.md` for agentic debugging and links back to this README.
 
@@ -94,7 +94,7 @@ Common build-script replacements:
 | `npx hst secrets:check` | `await secrets.check({ cwd: process.cwd() })` |
 | `npx hst env check` | `await env.check({ cwd: process.cwd() })` |
 
-Long-running APIs such as `dev.run`, `debugger.start`, `mcp.start`, `test.record`, and RASP capture-style workflows keep the same operational behavior as the corresponding CLI commands: they start services, attach to debuggers, or wait for user/session activity. `mcp.start`, `dev.run`, and `test.ui` are wired for programmatic no-exit behavior through the top-level API.
+Long-running APIs such as `dev.run`, `debugger.start`, `mcp.start`, and RASP-owned certification capture workflows keep the same operational behavior as the corresponding CLI commands: they start services, attach to debuggers, or wait for user/session activity. `mcp.start` and `dev.run` are wired for programmatic no-exit behavior through the top-level API.
 
 # Getting started
 
@@ -189,7 +189,7 @@ Hosanna Tools is a comprehensive CLI toolset for the Hosanna framework that prov
 The CLI commands are organized into logical groups using colon-separated namespacing:
 
 ### Development Commands
-- `run` - Canonical cross-platform app launcher. Requires `--platform` and supports web, Roku, iOS, Apple TV, Android, and Android TV launch targets.
+- `run` - Canonical cross-platform app launcher. Bare interactive runs show one destination picker; explicit platform options support web, Roku, iOS, Apple TV, Android, and Android TV launch targets.
 - `target:list` - List launch targets for humans or agents, including web emulators, sims, and physical devices.
 - `dev:start` - Run dev processes: vite, generator watch, and optional debugger
 - `debugger:start` - Start the command debugger WebSocket proxy (only one debugger is needed for multiple apps; if the port is already in use, a friendly message is shown instead of crashing)
@@ -197,6 +197,8 @@ The CLI commands are organized into logical groups using colon-separated namespa
 Examples:
 
 ```bash
+hst run
+hst run --last
 hst run --platform web
 hst run --platform roku --target emulator
 hst run --platform ios --target emulator
@@ -218,7 +220,9 @@ hst target:list --platform apple-tv --target sim --json
 hst target:list --form-factor tv --json
 ```
 
-`hst run` is platform-explicit by design, so non-interactive agents do not guess between iOS, Apple TV, Android, Android TV, Roku, or web. `--target emulator` starts or reuses the shared Vite/debugger dev services for any platform and opens a profiled DOM runtime URL for interactive runs; use `--device <preset-id>` to override defaults such as `iphone-15`, `pixel-8`, `apple-tv-4k`, `android-tv-1080p`, or `rokufhd`, and use `--no-open` for server-only launches. `--target sim` launches the vendor virtual device for platforms that have one: Apple Simulator for iOS and Apple TV, Android Emulator for Android and Android TV. `--target device` launches or deploys to physical local hardware. `web` and `browser` remain accepted aliases for the web emulator; `simulator` and `simulated` remain accepted aliases for `sim`; `emulated` remains an accepted alias for the web emulator. Device/sim runs record the target and refuse to overwrite a recorded session or safe-to-kill occupied resource in non-interactive mode unless `--replace` is passed. Preferred run defaults live in `.hosanna-tools/run.json`, and preferred devices live in `.hosanna-tools/devices.json` or `~/.hosanna-tools/devices.json`. Legacy `.hs-devices.json` files are still read for compatibility.
+Bare `hst run` in an interactive terminal discovers runnable web previews, vendor simulators, and online physical devices, then presents one flat destination picker. The last selection is placed first, so pressing Enter repeats it; `hst run --last` skips discovery and immediately uses that remembered destination. The selection is stored in the user-level `~/.hosanna-tools/run.json`, preserving existing defaults. Explicit commands remain deterministic, and non-interactive runs never open the picker.
+
+`--target emulator` starts or reuses the shared Vite/debugger dev services for any platform and opens a profiled DOM runtime URL for interactive runs; use `--device <preset-id>` to override defaults such as `iphone-15`, `pixel-8`, `apple-tv-4k`, `android-tv-1080p`, or `rokufhd`, and use `--no-open` for server-only launches. `--target sim` launches the vendor virtual device for platforms that have one: Apple Simulator for iOS and Apple TV, Android Emulator for Android and Android TV. `--target device` launches or deploys to physical local hardware. `web` and `browser` remain accepted aliases for the web emulator; `simulator` and `simulated` remain accepted aliases for `sim`; `emulated` remains an accepted alias for the web emulator. Device/sim runs record the target and refuse to overwrite a recorded session or safe-to-kill occupied resource in non-interactive mode unless `--replace` is passed. Preferred run defaults live in `.hosanna-tools/run.json`, and preferred devices live in `.hosanna-tools/devices.json` or `~/.hosanna-tools/devices.json`. Legacy `.hs-devices.json` files are still read for compatibility.
 
 ### Roku Commands (`roku:*`) - Roku Deployment & Packaging
 - `roku:run` - Deploy a Roku app to a device (supports .zip file or folder)
@@ -269,6 +273,8 @@ Supported inputs include `file/line: pkg:/components/source_0.brs(7475)`, `at ..
 ### Build Config Commands (`build-config`) - Runtime Configuration
 - `build-config:resolve` - Resolve `build-config/base.json`, env/platform overlays, secrets, and optional developer profiles into the canonical runtime `build-config.json`
 
+Production JavaScript bundles strip `console.*` calls by default. Configure this through the normal overlay chain with `build.stripLogs`: set it to `false` in `build-config/prod.json` to retain production logs, or in `build-config/prod.apple.json` / `build-config/prod.web.json` for a platform-only exception. Non-production environments keep logs unless their overlay explicitly enables stripping. Apple `prod` builds use Xcode `Release`; other environments continue to use `Debug`.
+
 Native builds can resolve config immediately before the platform build:
 
 ```bash
@@ -380,9 +386,95 @@ silently break an install.
 
 **Cursor and MCP:** Cursor does not magically attach to a terminal `hst mcp:start`. Add Hosanna as a Command MCP server (project **`.cursor/mcp.json`** or **Cursor Settings → MCP → Add Custom MCP**) so Cursor spawns **`hosanna-mcp`** over stdio. Start the command debugger/app explicitly with `hst run --platform web --target web`, `hst run --platform ios --target web`, `hst run --platform android-tv --target web`, or `hst run --platform roku --target device`.
 
-### UI Test Commands (`test:*`) - UI Test Automation
-- `test:ui` - Replay UI test recordings against a running Hosanna app
-- `test:record` - Interactively record a UI test by navigating the app
+### Deterministic UI testing
+
+Applications own regular Vitest suites. Global setup comes from `@tantawowa/hosanna-tools/testing/vitest`; worker fixtures and matchers come from `@tantawowa/hosanna-tools/testing/vitest/fixture`; shared lifecycle, types, and helpers come from `@tantawowa/hosanna-tools/testing`. There is no HST test CLI or recording/replay format.
+
+Add `createHosannaReporter(config)` from `@tantawowa/hosanna-tools/testing/vitest/reporter` to the application's Vitest reporters. Every run then writes a self-contained JSON and HTML report under `test-results/<testRunId>/`, updates `test-results/latest.json` and `test-results/latest.html`, and includes every Vitest result plus any named visual proofs captured by the tests.
+
+Browser targets can also record the complete owned browser session as WebM:
+
+```ts
+defineHosannaTestConfig({
+  // ...
+  video: true,
+  // Or: video: { size: { width: 1280, height: 720 } },
+});
+```
+
+The finalized recording is written to
+`test-results/<testRunId>/<platform>-web/run.webm` and embedded in the HTML
+report. Recording is opt-in in the shared tools and ignored for device and
+simulator targets. It records browser video only, without audio. This is a
+review artifact, not a replay format or executable test source.
+
+```ts
+import { defineConfig } from 'vitest/config';
+import { createHosannaReporter } from '@tantawowa/hosanna-tools/testing/vitest/reporter';
+import hosannaTestConfig from './integration/hosanna-test.config';
+
+export default defineConfig({
+  reporters: ['default', createHosannaReporter(hosannaTestConfig)],
+});
+```
+
+Use `hs.proof.capture(...)` at meaningful acceptance moments. A proof contains the target screenshot and the inspected screen/focus/control state used to understand it; hierarchy and scoped logs are optional. Proofs are evidence in the report, not an assertion by themselves:
+
+```ts
+const poster = hs.image.inCollectionCell({
+  collectionId: 'collectionView',
+  rowSettingsKey: 'rows.regular',
+  cellIndex: 0,
+  imageId: 'poster',
+});
+await poster.waitForLoaded({ requireBitmapSize: true });
+await expect(poster).toBeLoadedImage({ requireBitmapSize: true });
+
+await hs.proof.capture('programme-focused', {
+  controls: {
+    programmeCard: hs.control.byId('programmeCard'),
+  },
+  images: { poster },
+  includeLogs: true,
+});
+```
+
+Image readiness requires a non-empty URI, `loadStatus: "ready"`, positive rendered dimensions, and positive decoded bitmap dimensions by default. Explicit `loadWidth`/`loadHeight` assertions remain available for controls that request a fixed decode size; zero is valid when the runtime decodes at the source size. `hs.image.byId(...)`, `hs.image.within(...)`, and semantic `hs.image.inCollectionCell(...)` locators work across browser, Roku, and later native drivers.
+
+Screenshots and proofs wait for the command-plane hierarchy and focus to remain stable for 300ms by default, then allow a short platform render-settle window. Consecutive screenshots are also spaced automatically. Override this only for known platform behaviour through the test config's `screenshot` settings or per-capture options; failure diagnostics bypass the stable-frame wait so they can still capture broken states.
+
+Custom test ports must be unique. Keep the Vite and browser CDP ports outside the debugger's dynamic app allocation range; the launcher validates this before starting any processes and reports the conflicting range.
+
+Keep structural and state assertions as the default correctness checks. Use `hs.screenshot.match(...)` only for an explicit visual regression whose target-specific baseline and tolerance are intentionally maintained. Failure diagnostics and proof artifacts are separated below `test-results/<testRunId>/<platform>-<target>/`.
+
+`buildConfig` supplies a non-secret overlay that is merged last for the owned test launch. It may be a target-aware factory, so browser emulation can enable deterministic mocks while a physical Roku keeps its real platform services. The launcher and resolver both reject test overlays for `prod`:
+
+```ts
+defineHosannaTestConfig({
+  // ...
+  environment: 'test',
+  buildConfig: ({ platform, target }) => ({
+    remoteDebug: { isEnabled: true },
+    ...(target === 'web'
+      ? { channelStore: { testMode: { enabled: true } } }
+      : {}),
+  }),
+});
+```
+
+Use `createHosannaTestTarget(config)` with Vitest's standard conditional APIs. Selectors accept one platform or a set, and distinguish browser, simulator, and physical-device targets:
+
+```ts
+const target = createHosannaTestTarget(config);
+
+test.runIf(target.matches({ platform: 'roku', target: 'device' }))('Roku only', async ({ hs }) => {});
+test.runIf(target.matches({ platform: ['ios', 'android'], target: 'sim' }))('mobile simulators', async ({ hs }) => {});
+test.runIf(target.matches({ target: 'web' }))('all browser flavours', async ({ hs }) => {});
+```
+
+Browser Channel Store emulation supports per-test `success`, `cancelled`, and `failed` outcomes when `channelStore.testMode.enabled` is present in the test overlay. Set it from a named precondition with `hs.mocks.channelStore.setPurchaseOutcome(...)`. This API refuses physical-device targets. Roku purchase tests use Roku Pay [billing testing](https://developer.roku.com/dev/docs/billing-testing), a linked [Roku test user](https://developer.roku.com/dev/docs/test-users), and real Channel Store/OS purchase screens; keep them opt-in and serial.
+
+For Roku device suites, the launcher builds and deploys before the test launch, then relaunches through ECP with the exact test run ID and a debugger address reachable from the device. Configure the device IP and developer password in the application test config/environment. `HS_TEST_DEBUG_HOST` overrides automatic LAN address selection when needed. Physical Roku input, held keys, deep links, screenshots, and logs use their device transports; the committed Vitest source remains the same API used by browser tests.
 
 ## Usage Examples
 
@@ -439,16 +531,15 @@ hst env prepare-gitignore      # Update .gitignore
 hst debugger:start               # Start debug proxy (required)
 hst mcp:start                    # Start MCP server for Cursor/Claude
 
-# UI test automation
-hst test:record --name "My test"  # Record UI test interactively
-hst test:ui                       # Replay all recordings
-hst test:ui --suite regression.json  # Run test suite
-hst test:ui --json --report-dir ./reports  # CI mode with reports
+# Application-owned UI tests
+npm run test:ui
+npm run test:ui -- auth/login.test.ts
+HS_TEST_PLATFORM=roku HS_TEST_TARGET=device npm run test:ui
 ```
 
-## MCP Debugging & UI Test Automation
+## MCP Debugging & Deterministic UI Tests
 
-Hosanna Tools includes a powerful MCP (Model Context Protocol) server for AI-assisted debugging and a UI test automation framework.
+Hosanna Tools includes an MCP server for interactive AI-assisted debugging. Deterministic UI tests run in an application's Vitest process and use the separate `@tantawowa/hosanna-tools/testing` export; MCP is only an authoring aid.
 
 ### Cursor Settings → MCP (Hosanna debugger)
 
@@ -501,7 +592,7 @@ After saving, enable the server in the MCP list. **`hst mcp:start`** is still us
 ### Quick Start
 
 ```bash
-# 1. Start the debug proxy (required for both MCP and test automation)
+# 1. Start the debug proxy for an interactive MCP debugging session
 hst debugger:start
 
 # 2. Start your Hosanna app with remote debugging enabled
@@ -509,11 +600,8 @@ hst debugger:start
 # 3. For AI debugging (Cursor, Claude Code):
 #    Add MCP server (see "Cursor Settings → MCP" above) or hst mcp:start in a terminal
 
-# 4. For UI test recording:
-hst test:record --name "My test flow"
-
-# 5. For UI test replay:
-hst test:ui
+# 4. Run committed deterministic tests from the application repository:
+npm run test:ui
 ```
 
 ### See also

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "buildDate": "2026-07-15T14:04:49+00:00",
-  "buildDateISO": "2026-07-15T14:04:49.432Z",
+  "buildDate": "2026-07-17T08:17:53+00:00",
+  "buildDateISO": "2026-07-17T08:17:53.381Z",
   "timeZone": "UTC",
-  "gitHash": "ab10627"
+  "gitHash": "10849ea"
 }

package/dist/cli.js

@@ -144,10 +144,33 @@ async function runRunPlanCommand(command, args) {
         const executor = await Promise.resolve().then(() => __importStar(require('./run/executor.js')));
         const positionalArgv = rawCommandPositionals(command);
         const format = (args.json || args.format === 'json') ? 'json' : 'text';
+        let flags = runPlanFlagsFromCliArgs(args, format);
+        let chosenDestination;
+        const hasExplicitDestination = positionalArgv.length > 0 ||
+            rawHasFlag('platform') || rawHasFlag('target') || rawHasFlag('device');
+        if (command === 'run' && args.last) {
+            if (hasExplicitDestination) {
+                throw new Error('--last cannot be combined with an explicit platform, target, or device.');
+            }
+            const picker = await Promise.resolve().then(() => __importStar(require('./run/destination-picker.js')));
+            chosenDestination = picker.requireLastRunDestination(process.cwd());
+            flags = Object.assign(Object.assign({}, flags), runDestinationFlags(chosenDestination));
+        }
+        else if (command === 'run' &&
+            !hasExplicitDestination &&
+            !flags.nonInteractive &&
+            !args['dry-run'] &&
+            format === 'text' &&
+            process.stdin.isTTY &&
+            process.stdout.isTTY) {
+            const picker = await Promise.resolve().then(() => __importStar(require('./run/destination-picker.js')));
+            chosenDestination = await picker.chooseRunDestination({ cwd: process.cwd(), env: process.env });
+            flags = Object.assign(Object.assign({}, flags), runDestinationFlags(chosenDestination));
+        }
         const planInput = {
             cwd: process.cwd(),
             argv: positionalArgv,
-            flags: runPlanFlagsFromCliArgs(args, format),
+            flags,
             env: process.env,
         };
         const plan = command === 'build'
@@ -162,6 +185,18 @@ async function runRunPlanCommand(command, args) {
             }
             process.exit(0);
         }
+        if (command === 'run' && !flags.nonInteractive && process.stdin.isTTY) {
+            const destination = chosenDestination !== null && chosenDestination !== void 0 ? chosenDestination : rememberedExplicitDestination(plan, hasExplicitDestination);
+            if (destination) {
+                try {
+                    const config = await Promise.resolve().then(() => __importStar(require('./run/run-config.js')));
+                    config.saveLastRunDestination({ cwd: process.cwd(), destination });
+                }
+                catch (err) {
+                    console.warn(`Unable to remember the run destination: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
         const result = await executor.executeRunPlan(plan);
         if (format === 'json') {
             console.info(JSON.stringify(result, null, 2));
@@ -179,6 +214,21 @@ async function runRunPlanCommand(command, args) {
         process.exit(1);
     }
 }
+function runDestinationFlags(destination) {
+    return {
+        platform: destination.platform,
+        target: destination.target,
+        device: destination.device,
+    };
+}
+function rememberedExplicitDestination(plan, hasExplicitDestination) {
+    if (!hasExplicitDestination)
+        return undefined;
+    const target = plan.resolved.target === 'emulator' ? 'web' : plan.resolved.target;
+    if (target !== 'web' && !plan.resolved.deviceSelector)
+        return undefined;
+    return Object.assign({ platform: plan.resolved.platform, target }, (plan.resolved.deviceSelector ? { device: plan.resolved.deviceSelector } : {}));
+}
 const NATIVE_PLATFORM_CHOICES = ['apple', 'ios', 'apple-tv', 'android', 'android-tv', 'all'];
 function nativeInputFromArgs(args) {
     return {
@@ -250,7 +300,7 @@ catch (err) {
 // Let yargs handle all commands including env
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .version(`${buildVersion}\n  git: ${buildGitHash}\n  built: ${buildDate}`)
-    .usage('$0 [command] [options]', `Hosanna Tools CLI\nVersion: ${buildVersion}\nBuild Date: ${buildDate}\n\nCommand Groups:\n  compiler:*    Compiler lifecycle (install, status, list)\n  config        hosanna.json management (wizard, show, set)\n  env           Environment checks and repair (check, fix, prepare-gitignore)\n  dev:*         Local development execution\n  debugger:*    Command debugger control\n  mcp:*         Hosanna MCP server control\n  build         Cross-platform build orchestration\n  run           Cross-platform launch orchestration\n  native:*      Native platform bootstrap and validation\n  target:*      Run target discovery and inventory\n  roku:*        Roku deployment, commands & packaging (run, command, package, map-stack)\n  device:*      Device discovery and run workflows\n  generate:*    Code and asset generation\n  sdk:*         Hosanna SDK/framework installation\n  build-config:* Build/runtime configuration resolution\n  ci:*          Continuous integration helpers\n  framework:*   Framework distribution helpers\n  license:*     Hosanna framework licensing\n  secrets:*     Portable .secrets files\n  test:*        UI testing\n  rasp:*        RASP cert scripts`)
+    .usage('$0 [command] [options]', `Hosanna Tools CLI\nVersion: ${buildVersion}\nBuild Date: ${buildDate}\n\nCommand Groups:\n  compiler:*    Compiler lifecycle (install, status, list)\n  config        hosanna.json management (wizard, show, set)\n  env           Environment checks and repair (check, fix, prepare-gitignore)\n  dev:*         Local development execution\n  debugger:*    Command debugger control\n  mcp:*         Hosanna MCP server control\n  build         Cross-platform build orchestration\n  run           Cross-platform launch orchestration\n  native:*      Native platform bootstrap and validation\n  target:*      Run target discovery and inventory\n  roku:*        Roku deployment, commands & packaging (run, command, package, map-stack)\n  device:*      Device discovery and run workflows\n  generate:*    Code and asset generation\n  sdk:*         Hosanna SDK/framework installation\n  build-config:* Build/runtime configuration resolution\n  ci:*          Continuous integration helpers\n  framework:*   Framework distribution helpers\n  license:*     Hosanna framework licensing\n  secrets:*     Portable .secrets files\n  rasp:*        RASP cert scripts`)
     .option('verbose', {
     type: 'boolean',
     default: false,
@@ -1662,7 +1712,7 @@ catch (err) {
     .parserConfiguration({ 'boolean-negation': false, 'populate--': true })
     .positional('platform', {
     type: 'string',
-    describe: 'Launch platform. Defaults from flags, env, .hosanna-tools/run.json, then web.',
+    describe: 'Launch platform. Bare interactive runs show a destination picker; non-interactive runs default to web.',
 })
     .positional('env', {
     type: 'string',
@@ -1714,6 +1764,7 @@ catch (err) {
     .option('open', { type: 'boolean', describe: 'Open the web runtime URL in the default browser; defaults to interactive runs only' })
     .option('no-open', { type: 'boolean', default: false, describe: 'Do not open the default browser for web runtime launches' })
     .option('non-interactive', { type: 'boolean', default: false, describe: 'Fail instead of prompting when a decision is needed' })
+    .option('last', { type: 'boolean', default: false, describe: 'Immediately reuse the last destination selected by an interactive run' })
     .option('json', { type: 'boolean', default: false, describe: 'Print run result as JSON when the command returns' })
     .option('dry-run', { type: 'boolean', default: false, describe: 'Print the resolved RunPlan without executing it' })
     .option('format', { type: 'string', choices: ['text', 'json'], default: 'text', describe: 'Output format for --dry-run and run result' })
@@ -1734,6 +1785,8 @@ catch (err) {
     .option('logs', { type: 'boolean', default: false, describe: 'Enable verbose deploy logging where supported' })
     .option('applySourceMapToPaths', { type: 'boolean', default: true, describe: 'Resolve Roku stack trace paths with source maps during log streaming' })
     .example('$0 run --platform web', 'Start/reuse web dev services for this app')
+    .example('$0 run', 'Choose once from all available web, simulator, and physical-device destinations')
+    .example('$0 run --last', 'Immediately run on the last selected destination')
     .example('$0 run --platform roku --target emulator', 'Start/reuse the Roku TV web emulator')
     .example('$0 run --platform ios --target emulator', 'Start/reuse the iPhone-shaped web emulator profile')
     .example('$0 run --platform android --target emulator --device pixel-8', 'Start/reuse the Android-shaped web emulator profile')
@@ -2003,121 +2056,13 @@ catch (err) {
         appName: args.appName,
     });
 })
-    .command('test:ui [recordings..]', 'Replay UI test recordings against a running Hosanna app and exit with pass/fail. ' +
-    'Requires a running debug proxy (hst debugger:start) and a connected app.', yargs => yargs
-    .positional('recordings', {
-    describe: 'Recording IDs to replay (omit to run all)',
-    type: 'string',
-    array: true,
-})
-    .option('suite', {
-    type: 'string',
-    describe: 'Path to a test-suite.json file (relative to recordings dir or absolute)',
-})
-    .option('appId', {
-    type: 'string',
-    describe: 'Target app ID (defaults to the one stored in each recording)',
-})
-    .option('managementPort', { type: 'number', default: 59150, describe: 'Debug proxy management port' })
-    .option('managementHost', { type: 'string', default: 'localhost', describe: 'Debug proxy host' })
-    .option('extensionPort', { type: 'number', default: 59153, describe: 'Debug proxy extension WebSocket port' })
-    .option('stop-on-failure', { type: 'boolean', default: true, describe: 'Stop each recording on first step failure' })
-    .option('step-delay-ms', { type: 'number', default: 500, describe: 'Delay after each action (ms)' })
-    .option('focus-assert-retry-ms', {
-    type: 'number',
-    default: 300,
-    describe: 'Delay (ms) between focus polls after a mismatch (0 = no polling)',
-})
-    .option('focus-assert-max-retries', {
-    type: 'number',
-    default: 12,
-    describe: 'Max extra GetFocusedView polls per step (skeleton/load); 0 = single read only',
-})
-    .option('screenshot-settle-ms', { type: 'number', default: 400, describe: 'Extra delay before screenshot capture (ms)' })
-    .option('compare-screenshots', { type: 'boolean', default: true, describe: 'Enable visual regression comparison' })
-    .option('screenshot-threshold', { type: 'number', default: 0.15, describe: 'Pixel diff tolerance (0-1)' })
-    .option('screenshot-fail-percent', { type: 'number', default: 2.0, describe: 'Max allowed diff % before failure' })
-    .option('roku-ip', { type: 'string', describe: 'Roku device IP (env: HOSANNA_ROKU_DEVICE_IP)' })
-    .option('roku-password', { type: 'string', describe: 'Roku dev password (env: HOSANNA_ROKU_DEV_PASSWORD)' })
-    .option('json', { type: 'boolean', default: false, describe: 'Output results as JSON only' })
-    .option('report-dir', { type: 'string', describe: 'Directory for HTML + JUnit XML reports' })
-    .option('update-baselines', { type: 'boolean', default: false, describe: 'Re-capture baseline screenshots without asserting (replays actions only)' })
-    .option('coverage', { type: 'boolean', default: false, describe: 'Analyze recordings and print navigation coverage (no running app needed)' }), async (args) => {
-    if (args.verbose) {
-        process.env.HOSANNA_VERBOSE = '1';
-    }
-    const { runTestUI } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-runner.js')));
-    await runTestUI({
-        recordings: args.recordings,
-        suite: args.suite,
-        appId: args.appId,
-        managementPort: args.managementPort,
-        managementHost: args.managementHost,
-        extensionPort: args.extensionPort,
-        stopOnFailure: args.stopOnFailure,
-        stepDelayMs: args.stepDelayMs,
-        focusAssertRetryMs: args.focusAssertRetryMs,
-        focusAssertMaxRetries: args.focusAssertMaxRetries,
-        screenshotSettleMs: args.screenshotSettleMs,
-        compareScreenshots: args.compareScreenshots,
-        screenshotThreshold: args.screenshotThreshold,
-        screenshotFailPercent: args.screenshotFailPercent,
-        rokuIp: args.rokuIp,
-        rokuPassword: args.rokuPassword,
-        json: args.json,
-        verbose: args.verbose,
-        reportDir: args.reportDir,
-        updateBaselines: args.updateBaselines,
-        coverage: args.coverage,
-    });
-})
-    .command('test:record', 'Interactively record a UI test by navigating the app. ' +
-    'Key events from the running app are captured via the debug proxy.', yargs => yargs
-    .option('name', {
-    type: 'string',
-    demandOption: true,
-    describe: 'Name for this test recording',
-})
-    .option('description', {
-    type: 'string',
-    describe: 'Optional description of what this test covers',
-})
-    .option('appId', {
-    type: 'string',
-    describe: 'Target app ID (defaults to first connected app)',
-})
-    .option('managementPort', { type: 'number', default: 59150, describe: 'Debug proxy management port' })
-    .option('managementHost', { type: 'string', default: 'localhost', describe: 'Debug proxy host' })
-    .option('extensionPort', { type: 'number', default: 59153, describe: 'Debug proxy extension WebSocket port' })
-    .option('roku-ip', { type: 'string', describe: 'Roku device IP for screenshots (env: HOSANNA_ROKU_DEVICE_IP)' })
-    .option('roku-password', { type: 'string', describe: 'Roku dev password for screenshots (env: HOSANNA_ROKU_DEV_PASSWORD)' })
-    .option('screenshot-on-select', { type: 'boolean', default: true, describe: 'Auto-capture screenshot on Select key press' })
-    .example('$0 test:record --name "Home screen navigation"', 'Record key presses while navigating')
-    .example('$0 test:record --name "Details test" --roku-ip 192.168.1.10', 'Record with Roku screenshot support'), async (args) => {
-    if (args.verbose) {
-        process.env.HOSANNA_VERBOSE = '1';
-    }
-    const { runTestRecord } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-recorder.js')));
-    await runTestRecord({
-        name: args.name,
-        description: args.description,
-        appId: args.appId,
-        managementPort: args.managementPort,
-        managementHost: args.managementHost,
-        extensionPort: args.extensionPort,
-        rokuIp: args.rokuIp,
-        rokuPassword: args.rokuPassword,
-        screenshotOnSelect: args.screenshotOnSelect,
-        verbose: args.verbose,
-    });
-})
-    .command('rasp:export <recordingId> <name>', 'Convert a saved test recording into a Roku Automation Scripting Platform (RASP) ' +
+    .command('rasp:export <captureId> <name>', 'Convert a saved RASP input capture into a Roku Automation Scripting Platform (RASP) ' +
     'YAML script suitable for Roku certification testing. Output goes to ' +
     'rasp-scripts/<name>.rasp in the current project by default.', yargs => yargs
-    .positional('recordingId', {
+    .positional('captureId', {
     type: 'string',
     demandOption: true,
-    describe: 'ID of the saved recording (filename without .json), e.g. "signin_1736888000000"',
+    describe: 'ID of the saved capture (filename without .json), e.g. "signin_1736888000000"',
 })
     .positional('name', {
     type: 'string',
@@ -2127,11 +2072,11 @@ catch (err) {
     .option('out', {
     type: 'string',
     alias: 'o',
-    describe: 'Override the output path. Default: rasp-scripts/<name>.rasp next to recordings dir.',
+    describe: 'Override the output path. Default: rasp-scripts/<name>.rasp next to the capture directory.',
 })
     .option('channel-name', {
     type: 'string',
-    describe: 'Channel name for the launch step (overrides recording.debugContext.channel.name).',
+    describe: 'Channel name for the launch step (overrides capture.debugContext.channel.name).',
 })
     .option('channel-mode', {
     type: 'string',
@@ -2189,7 +2134,7 @@ catch (err) {
     describe: 'Master gate for credential auto-injection. When true (default), the exporter ' +
         'watches for OK presses landing on a TextInputView classified as email or password ' +
         '(via inputType / secureMode or field id) and injects the matching half of the RFI credential flow. ' +
-        'Use --no-useWithRfi to disable injection entirely (recording flows through verbatim).',
+        'Use --no-useWithRfi to disable injection entirely (capture flows through verbatim).',
 })
     .option('login-text', {
     type: 'string',
@@ -2224,8 +2169,8 @@ catch (err) {
     }
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { getRecordingsDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/test-runner.js')));
-    const { exportRaspFromRecording, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
+    const { getRaspCapturesDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-input-capture.js')));
+    const { exportRaspFromCapture, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
     // Parses a minimal RASP YAML fragment containing only `- press: <key>` and
     // `- text: <value>` ops (with `LOGIN` / `PASSWORD` reserved tokens). Comments
     // (#…) and blank lines are allowed. Anything else throws.
@@ -2252,16 +2197,16 @@ catch (err) {
         }
         return ops;
     };
-    const recordingId = args.recordingId;
+    const captureId = args.captureId;
     const scriptName = args.name.replace(/[^a-zA-Z0-9_-]/g, '_');
-    const recordingsDir = getRecordingsDir();
-    const recordingPath = path.join(recordingsDir, `${recordingId}.json`);
-    let recording;
+    const capturesDir = getRaspCapturesDir();
+    const capturePath = path.join(capturesDir, `${captureId}.json`);
+    let capture;
     try {
-        recording = JSON.parse(fs.readFileSync(recordingPath, 'utf-8'));
+        capture = JSON.parse(fs.readFileSync(capturePath, 'utf-8'));
     }
     catch (_c) {
-        console.error(`Recording "${recordingId}" not found in ${recordingsDir}.`);
+        console.error(`RASP capture "${captureId}" not found in ${capturesDir}.`);
         process.exit(1);
     }
     // Parse repeatable --text-field flags into a map.
@@ -2279,7 +2224,7 @@ catch (err) {
     const credentialFlow = credentialFlowPath
         ? parseCredentialFlowFile(credentialFlowPath)
         : undefined;
-    const result = exportRaspFromRecording(recording, {
+    const result = exportRaspFromCapture(capture, {
         channelName: args.channelName,
         channelMode: args.channelMode,
         contentId: args.contentId,
@@ -2304,7 +2249,7 @@ catch (err) {
         process.stdout.write(result.yaml);
     }
     console.error(`✅ Wrote ${outPath}`);
-    console.error(`   ${result.stats.recordedSteps} recorded steps → ${result.stats.raspOps} RASP ops` +
+    console.error(`   ${result.stats.capturedSteps} captured steps → ${result.stats.raspOps} RASP ops` +
         ` (auto-pauses: ${result.stats.autoPausesInserted}, text injections: ${result.stats.textInjections}` +
         `, keyboard steps dropped: ${result.stats.keyboardStepsDropped}, verify ops: ${result.stats.verifyOpsEmitted})`);
     for (const d of result.rfiDetections) {
@@ -2327,7 +2272,7 @@ catch (err) {
     }
 })
     .command('rasp:capture <name>', 'Record a UI session and export it directly to a RASP script in one step. ' +
-    'Navigate the app, press Ctrl+C to stop — the recording is saved and the RASP script is written automatically.', yargs => yargs
+    'Navigate the app, press Ctrl+C to stop — the capture is saved and the RASP script is written automatically.', yargs => yargs
     .positional('name', {
     type: 'string',
     demandOption: true,
@@ -2412,10 +2357,10 @@ catch (err) {
     default: false,
     describe: 'Print the YAML to stdout after writing.',
 })
-    .option('keep-recording', {
+    .option('keep-capture', {
     type: 'boolean',
     default: false,
-    describe: 'Keep the temporary test-recordings JSON/screenshots after the RASP script is written.',
+    describe: 'Keep the temporary RASP capture JSON/screenshots after the script is written.',
 })
     .example('$0 rasp:capture login --channel-name "Criterion"', 'Record and export to rasp-scripts/login.rasp')
     .example('$0 rasp:capture login --channel-name "Criterion" --login-text "user@example.com" --password-text "MyPass1!"', 'Default credential flow with custom text')
@@ -2423,13 +2368,13 @@ catch (err) {
     var _a, _b;
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { cleanupSavedRecordingArtifacts, runTestRecord } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-recorder.js')));
-    const { getRecordingsDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/test-runner.js')));
-    const { exportRaspFromRecording, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
+    const { cleanupRaspCaptureArtifacts, runRaspCapture } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-capture.js')));
+    const { getRaspCapturesDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-input-capture.js')));
+    const { exportRaspFromCapture, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
     const scriptName = args.name.replace(/[^a-zA-Z0-9_-]/g, '_');
     const raspScriptsDir = path.join(process.cwd(), 'rasp-scripts');
     const outPath = (_a = args.out) !== null && _a !== void 0 ? _a : path.join(raspScriptsDir, `${scriptName}.rasp`);
-    const recordingsDir = getRecordingsDir();
+    const capturesDir = getRaspCapturesDir();
     const textFields = {};
     const tfArgs = (_b = args['text-field']) !== null && _b !== void 0 ? _b : [];
     for (const tf of tfArgs) {
@@ -2467,7 +2412,7 @@ catch (err) {
     const credentialFlow = credentialFlowPath
         ? parseCredentialFlowFile(credentialFlowPath)
         : undefined;
-    await runTestRecord({
+    await runRaspCapture({
         name: args.name,
         appId: args.appId,
         managementPort: args.managementPort,
@@ -2475,8 +2420,8 @@ catch (err) {
         extensionPort: args.extensionPort,
         rokuIp: args.rokuIp,
         rokuPassword: args.rokuPassword,
-        onSaved: async (recordingId, recording) => {
-            const result = exportRaspFromRecording(recording, {
+        onSaved: async (captureId, capture) => {
+            const result = exportRaspFromCapture(capture, {
                 channelName: args.channelName,
                 channelMode: args.channelMode,
                 contentId: args.contentId,
@@ -2495,7 +2440,7 @@ catch (err) {
             if (args.print)
                 process.stdout.write(result.yaml);
             console.log(`✅ RASP script written: ${outPath}`);
-            console.log(`   ${result.stats.recordedSteps} steps → ${result.stats.raspOps} RASP ops` +
+            console.log(`   ${result.stats.capturedSteps} steps → ${result.stats.raspOps} RASP ops` +
                 ` (pauses: ${result.stats.autoPausesInserted}, text injections: ${result.stats.textInjections})`);
             for (const d of result.rfiDetections) {
                 const icon = d.type === 'login' ? '📧' : '🔑';
@@ -2514,15 +2459,15 @@ catch (err) {
                 console.error(`   Script has validation errors — review before submitting to Roku cert.`);
                 process.exitCode = 1;
             }
-            if (!args.keepRecording) {
+            if (!args.keepCapture) {
                 try {
-                    const cleanup = cleanupSavedRecordingArtifacts(recordingsDir, recordingId);
+                    const cleanup = cleanupRaspCaptureArtifacts(capturesDir, captureId);
                     if (cleanup.jsonDeleted || cleanup.artifactDirDeleted) {
-                        console.log(`🧹 Cleaned up temporary recording: ${recordingId}`);
+                        console.log(`🧹 Cleaned up temporary capture: ${captureId}`);
                     }
                 }
                 catch (err) {
-                    console.warn(`⚠  RASP script was written, but temporary recording cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+                    console.warn(`⚠  RASP script was written, but temporary capture cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
         },