diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index 4a82d2f2..2c37b3b2 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -50,7 +50,6 @@ body:
         - CLI
         - Control Plane UI
         - Runs / reports / evidence
-        - Playground
         - Providers
         - Harness SDK / existing drivers
         - Documentation / build / tooling
diff --git a/.github/skills/frontend-architecture/references/design-rules.md b/.github/skills/frontend-architecture/references/design-rules.md
index 3a6f4576..6b1fee50 100644
--- a/.github/skills/frontend-architecture/references/design-rules.md
+++ b/.github/skills/frontend-architecture/references/design-rules.md
@@ -12,7 +12,7 @@ Before choosing a visual direction, identify:
 - Existing visual and interaction conventions that must remain coherent.
 - Real content, data density, and exceptional states.
 
-For operational tools such as the FSQ Playground, prefer a quiet, work-focused interface optimized for scanning, comparison, repeated action, and clear status. Do not turn an application workspace into a marketing page.
+For operational tools such as the FSQ Control Plane, prefer a quiet, work-focused interface optimized for scanning, comparison, repeated action, and clear status. Do not turn an application workspace into a marketing page.
 
 ## Design Before Implementation
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4a3490d5..54eb16e7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,7 +54,6 @@ jobs:
 
           generated = (
               Path("fsq_agent/adapters/control_plane/static"),
-              Path("fsq_agent/adapters/control_plane/playground/static"),
               Path("fsq_agent/resources"),
           )
           present = [str(path) for path in generated if path.exists()]
@@ -110,7 +109,6 @@ jobs:
 
           generated = (
               Path("fsq_agent/adapters/control_plane/static"),
-              Path("fsq_agent/adapters/control_plane/playground/static"),
               Path("fsq_agent/resources"),
           )
           present = [str(path) for path in generated if path.exists()]
@@ -229,13 +227,10 @@ jobs:
 
           required_prefixes = (
               "fsq_agent/adapters/control_plane/static/",
-              "fsq_agent/adapters/control_plane/playground/static/",
           )
           required_files = (
               "fsq_agent/adapters/control_plane/static/control-plane/index.html",
               "fsq_agent/adapters/control_plane/static/entry-assets.json",
-              "fsq_agent/adapters/control_plane/playground/static/playground/index.html",
-              "fsq_agent/adapters/control_plane/playground/static/entry-assets.json",
               "fsq_agent/resources/config.android.yaml",
               "fsq_agent/resources/config.web.yaml",
               "fsq_agent/resources/config.windows.yaml",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c9adb6fe..f96c8908 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,10 @@ All notable changes are documented here. FSQ follows Semantic Versioning after p
 
 - Initial open-source release preparation.
 
+### Removed
+
+- Removed the legacy Playground browser application, standalone HTTP server, Python APIs, and packaged frontend assets. Use `fsq ui` for the supported Control Plane browser workflows; raw YAML dynamic execution, lifecycle-hook editing, completed-Run loading, and automatic Goal Case publication are not carried forward.
+
 ## [0.1.0] - Unreleased
 
 ### Added
diff --git a/ROADMAP.md b/ROADMAP.md
index f6af3b59..19d32933 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -16,7 +16,7 @@ This roadmap communicates direction rather than a release commitment. Scope and
 
 Make the repository trustworthy and practical for external contributors.
 
-- Establish CI for linting, tests, package builds, and Playground builds.
+- Establish CI for linting, tests, package builds, and Control Plane builds.
 - Complete contributor-facing Issue and pull request workflows.
 - Improve installation, quick-start, architecture, and troubleshooting documentation.
 - Define the changelog, semantic versioning, and automated release process.
@@ -48,7 +48,7 @@ Target a five-minute path from installation to a first successful automation run
 - Publish preconfigured Web and Android container images.
 - Add Codespaces or equivalent cloud development setup.
 - Add environment diagnostics and harness scaffolding commands.
-- Improve interactive recording and Playground workflows.
+- Improve interactive recording and Control Plane workflows.
 
 ## 2027 Q1-Q2: Ecosystem
 
@@ -57,7 +57,7 @@ Make FSQ useful as both a tool and a platform.
 - Publish an official GitHub Action and CI integration guidance.
 - Build a curated registry of reusable FSQ cases and skills.
 - Add a compatibility matrix generated from tests and run evidence.
-- Expand Playground into a case authoring and contribution workflow.
+- Expand Control Plane into a case authoring and contribution workflow.
 - Provide an embeddable Python SDK and progress toward a stable 1.0 release.
 - Explore a VS Code extension for YAML authoring, evidence inspection, and run management.
 
diff --git a/SPEC.md b/SPEC.md
index 14e837ad..7e22e906 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -30,7 +30,7 @@ The public Case workflows are `fsq case create` and `fsq case test`. Case creati
 
 ## Recorded Case Artifacts
 
-AI-participating Case operations may record a replayable trace as a Run-local candidate `*.fsq.yaml`. The agent persists normalized capability events and Execution coordinates conversion of replayable non-observation results according to `ReplayPolicy` metadata. Generated Goal Cases use the originating Run id as `name` and the normalized Goal as `description`, identically for valid and draft recordings across entry workflows. Generated Cases never mutate source Cases, and secrets are never persisted. Publication into `cases.dir` is selected by the entry workflow: CLI Goal-based Case creation and Playground Goal execution automatically publish validated recordings under the Run id, while Control Plane Explore keeps the recording Run-local until the user explicitly saves it under a chosen Case name. Suggestion-enabled existing-Case testing never publishes into `cases.dir`.
+AI-participating Case operations may record a replayable trace as a Run-local candidate `*.fsq.yaml`. The agent persists normalized capability events and Execution coordinates conversion of replayable non-observation results according to `ReplayPolicy` metadata. Generated Goal Cases use the originating Run id as `name` and the normalized Goal as `description`, identically for valid and draft recordings across entry workflows. Generated Cases never mutate source Cases, and secrets are never persisted. CLI Goal-based Case creation automatically publishes validated recordings under the Run id, while Control Plane Explore keeps the recording Run-local until the user explicitly saves it under a chosen Case name. Suggestion-enabled existing-Case testing never publishes into `cases.dir`.
 
 Recorded strict cases may contain runtime-secret text input references using `textType: runtimeSecret` and `waitMs` replay aliases. Strict execution bootstraps the active platform capability registry before YAML parsing, treats missing `textType` on text-entry commands as literal text for case compatibility, resolves runtime-secret text values in memory before external text-entry actions begin, and resolves `waitMs` through the registry to the inherited `wait_ms` CommonTool capability.
 
@@ -70,7 +70,7 @@ Every new Run has a versioned `run.json` inside its direct platform Run director
 
 Shared platform rules:
 
-- `harness.platform` selects exactly one active platform for normal dynamic, strict, and playground execution.
+- `harness.platform` selects exactly one active platform for normal dynamic and strict execution.
 - Public CLI entry points select the active platform with `--platform android|web|windows|macos` where platform context is needed; config loading maps that platform id to the corresponding repository-owned `config.<platform>.yaml` preset before validation. Public CLI commands do not expose workspace selection and use the exact registered current directory with canonical `.fsq` platform configuration. Provider configuration is separate from `fsq init`.
 - Entry layers build a platform-selected capability registry: inherited CommonTool capabilities plus only the active platform's PlatformTool capabilities.
 - `StepRunner`, `StepSequenceRunner`, evidence, recording, report generation, and FSQ parsing stay platform-neutral and consume capability metadata rather than platform action-name branches.
@@ -90,7 +90,7 @@ Web platform block:
 - Platform id: `web`.
 - Backend: `playwright`.
 - Runtime settings include browser channel, environment-backed browser executable path, headless mode, optional base URL, and optional viewport fields when specified by module specs.
-- Browser lifecycle is explicit through `start_browser`/`startBrowser` and `close_browser`/`closeBrowser`. Runtime, CLI, FSQ parsing, StepRunner, StepSequenceRunner, and playground entry paths must not auto-inject lifecycle commands or launch a browser as a driver-construction side effect.
+- Browser lifecycle is explicit through `start_browser`/`startBrowser` and `close_browser`/`closeBrowser`. Runtime, CLI, Control Plane, FSQ parsing, StepRunner, and StepSequenceRunner must not auto-inject lifecycle commands or launch a browser as a driver-construction side effect.
 - `startBrowser` is idempotent and reuses the active browser/page when one is already started. `closeBrowser` is idempotent, closes the active browser/page when present, resets driver-owned state, and permits a later `startBrowser` in the same task.
 - Web page-dependent actions, including `navigateTo`, require an active browser/page and must fail clearly when invoked before `startBrowser`; `navigateTo` must not implicitly start the browser.
 - Explicit observation capability: `ui_snapshot` with alias `uiSnapshot`; Web must not expose Android `ui_tree`/`uiTree` naming. Automatic runner evidence captures `screenshot` plus normalized `ui_snapshot` using Web page/accessibility snapshot content.
@@ -148,21 +148,20 @@ Loader diagnostics such as missing optional skills or missing optional knowledge
 | agent | fsq_agent/agent/SPEC.md | Orchestrates dynamic goal/reference execution through OpenAI Agents SDK, AgentTool exposure, active-platform capability exposure, verification, replayable event metadata, and report generation. |
 | execution | fsq_agent/execution/SPEC.md | Coordinates transport-neutral dynamic and deterministic runs, Case lifecycle ordering, cancellation/teardown, and Run-local candidate Case recording. |
 | application | fsq_agent/application/SPEC.md | Provides transport-neutral Workspace, Case, Run, Provider, and Environment operations through resource-owned modules, with shared Request, Result, Event, and Error contracts organized under `application/contracts`. |
-| adapters | fsq_agent/adapters/SPEC.md | Owns CLI, Control Plane, Playground, and coding-agent external protocol adaptation while depending inward on Application and public runtime contracts. |
+| adapters | fsq_agent/adapters/SPEC.md | Owns CLI, Control Plane, and coding-agent external protocol adaptation while depending inward on Application and public runtime contracts. |
 | adapters.coding_agent | fsq_agent/adapters/coding_agent/SPEC.md | Implements Agent runtime protocols through OpenAI Agents SDK tool, session, stream, and result adaptation. |
-| playground | fsq_agent/playground/SPEC.md | Serves the local browser playground for active-platform runtime status, Android session setup where applicable, dynamic goal/raw-case execution, strict YAML execution, loading existing run results, screenshots, replay video preview, and report lookup. |
 | control_plane | fsq_agent/control_plane/SPEC.md | Adapts Application operations to local HTTP/SSE/static delivery, cancellation transport, and browser evidence projection. |
 | cli | fsq_agent/cli/SPEC.md | Adapts the public `fsq` command tree to Application operations with human, JSON, and JSONL output and stable exit categories. |
 | frontend | frontend/SPEC.md | Owns the repository npm/Vite workspace, browser dependency and build policy, generated-asset boundary, and navigation to independently owned frontend application modules. |
 
 ## Frontend Build Boundary
 
-- The repository root npm project owns browser-source dependency resolution and Vite compilation for repository web pages. It uses one lock file and a multi-page Vite configuration so independently owned page entries build to distinct output paths.
-- `frontend/SPEC.md` owns the frontend workspace contract and links to child application specs without repeating their behavior. `frontend/playground/SPEC.md` and `frontend/control-plane/SPEC.md` own their authored browser applications; the corresponding Python modules own HTTP contracts and production static serving.
-- New frontend application modules use Vite, React, and TypeScript/TSX unless their confirmed module SPEC records a concrete exception. The current `frontend/playground` module is a documented Vite-built vanilla JavaScript application and remains governed by its current module SPEC.
+- The repository root npm project owns browser-source dependency resolution and Vite compilation for repository web pages. It uses one lock file and a multi-page Vite configuration for the Control Plane entry.
+- `frontend/SPEC.md` owns the frontend workspace contract and links to `frontend/control-plane/SPEC.md` without repeating application behavior; the corresponding Python module owns HTTP contracts and production static serving.
+- New frontend application modules use Vite, React, and TypeScript/TSX unless their confirmed module SPEC records a concrete exception.
 - `ts-ebml` is an exact npm dependency consumed through an ES module import. Third-party browser bundles and Vite-generated assets are not tracked in Git.
-- Vite-generated Playground and Control Plane assets live with their canonical owners under `fsq_agent/adapters/control_plane/playground/static` and `fsq_agent/adapters/control_plane/static`. Their HTML entry points, JavaScript, CSS, entry-asset manifests, and referenced generated assets are included in both wheel and source distribution. Release builds run the npm build before Python distribution construction. An installed distribution is self-contained and does not require Node.js or network access to serve these frontends at runtime.
-- Frontend development may use the Vite development server with API and streaming requests proxied to the corresponding Python server. Production and installed-wheel usage serve each generated entry and its APIs from its owning Python process.
+- Vite-generated Control Plane assets live under `fsq_agent/adapters/control_plane/static`. Its HTML entry point, JavaScript, CSS, entry-asset manifest, and referenced generated assets are included in both wheel and source distribution. Release builds run the npm build before Python distribution construction. An installed distribution is self-contained and does not require Node.js or network access to serve the frontend at runtime.
+- Frontend development may use the Vite development server with API and streaming requests proxied to the Control Plane Python server. Production and installed-wheel usage serve the generated entry and its APIs from one Python process.
 
 ## Architecture Diagram
 
@@ -173,12 +172,9 @@ flowchart TD
     CLI --> Application[application]
     CLI --> ControlPlane
     ControlPlane --> Application
-    ControlPlane --> Playground[adapters/control_plane/playground]
     ControlPlane --> Execution[execution]
     CLI --> CodingAgent[adapters/coding_agent]
     ControlPlane --> CodingAgent
-    Playground --> Execution
-    Playground --> CodingAgent
     Application --> Agent[agent]
     Application --> Execution
     Application --> Core[core]
@@ -229,11 +225,7 @@ flowchart TD
     Capabilities[capabilities] --> Models
     Core --> Capabilities
     Core -->|PlatformRuntimeService compatibility export| Environments
-    Frontend[frontend] --> FrontendPlayground[frontend/playground]
     Frontend --> FrontendControlPlane[frontend/control-plane]
-    FrontendPlayground --> Playground
-    FrontendPlayground --> StaticAssets[generated static assets]
-    Playground --> StaticAssets
     FrontendControlPlane --> ControlPlane
     FrontendControlPlane --> ControlPlaneStatic[generated Control Plane static assets]
     ControlPlane --> ControlPlaneStatic
@@ -255,10 +247,10 @@ flowchart TD
 - Internal Python implementation files are prefixed with `_`.
 - Shared data structures and exceptions live only in the `models` module. Capability declaration decorators, catalog-backed platform validation, and decorated-method discovery live only in the `capabilities` module.
 - Module imports must follow the DAG in the architecture diagram.
-- Transport implementation and package data live under `adapters`. The installed scripts target `fsq_agent.adapters.cli:main`. Legacy `fsq_agent.cli`, `fsq_agent.control_plane`, and `fsq_agent.playground` packages preserve only their documented public entry symbols as compatibility exports; old private transport submodule paths are unsupported and absent.
+- Transport implementation and package data live under `adapters`. The installed scripts target `fsq_agent.adapters.cli:main`. Legacy `fsq_agent.cli` and `fsq_agent.control_plane` packages preserve only their documented public entry symbols as compatibility exports; old private transport submodule paths are unsupported and absent.
 - Package-root execution helpers and old Agent SDK implementation paths are absent. Repository code imports canonical `execution`, `adapters.coding_agent`, `case_dsl`, Drivers, Harnesses, Environments, and public Core subpackages directly.
-- Package-private composition helpers at the `fsq_agent` package root may compose public module APIs for shared entry-layer capability bootstrap, registry-metadata-based provider requirement detection, strict lifecycle orchestration, and dynamic-run recording used by CLI, Playground, and Control Plane. Provider requirement detection compares the active platform registry with and without provider-backed capabilities and resolves executable steps through the registry snapshot rather than branching on action names. These helpers must remain private, must not expose public module contracts, and must not be imported by `models`, `capabilities`, `tools`, `fsq`, `core`, `providers`, or `report`.
-- `capabilities` may import `models` only among project modules. It must not import `tools`, `core`, `agent`, `cli`, `fsq`, `providers`, `report`, `playground`, SDK objects, concrete drivers, or backend runtime types.
+- Package-private composition helpers at the `fsq_agent` package root may compose public module APIs for shared entry-layer capability bootstrap, registry-metadata-based provider requirement detection, strict lifecycle orchestration, and dynamic-run recording used by CLI and Control Plane. Provider requirement detection compares the active platform registry with and without provider-backed capabilities and resolves executable steps through the registry snapshot rather than branching on action names. These helpers must remain private, must not expose public module contracts, and must not be imported by `models`, `capabilities`, `tools`, `fsq`, `core`, `providers`, or `report`.
+- `capabilities` may import `models` only among project modules. It must not import `tools`, `core`, `agent`, `cli`, `fsq`, `providers`, `report`, SDK objects, concrete drivers, or backend runtime types.
 - Provider construction lives in `providers`; `core` must use provider-neutral protocols and must not import provider/runtime modules.
 - Dynamic-only local helper utilities live as AgentTools in `tools`; recordable CommonTool and PlatformTool capabilities live in `core`, with CommonTool bodies in platform tool providers and backend PlatformTool bodies on concrete drivers. CommonTools and PlatformTools declare executable metadata through `capabilities`. All recordable capabilities must be registered before strict YAML parsing or SDK capability exposure, and platform registries must contain only inherited CommonTools plus the active platform's PlatformTools. AgentTools must not be registered for strict replay.
 - Replay, sensitivity, evidence, and tool-origin behavior must come from capability metadata and normalized `StepRunner` results, not hard-coded tool-name sets.
@@ -268,6 +260,6 @@ flowchart TD
 
 - Use the lowest architecture level that keeps the module clear, testable, and changeable.
 - `models`, `capabilities`, `tools`, `case_dsl`, `report`, `knowledge`, `skills`, `config`, `providers`, and `observation` default to Level 2 Simple Package unless a module SPEC records a stronger need.
-- `core`, `agent`, `execution`, `application`, `adapters`, `cli`, `playground`, and `control_plane` use Level 3 because they coordinate execution flows, external SDKs, harnesses, providers, persistence, shared application operations, or transport entry points.
+- `core`, `agent`, `execution`, `application`, `adapters`, `cli`, and `control_plane` use Level 3 because they coordinate execution flows, external SDKs, harnesses, providers, persistence, shared application operations, or transport entry points.
 - Public APIs must be exported from module `__init__.py` files, and internal implementation modules must remain private across module boundaries. Modules that have adopted the stricter public API boundary must not export concrete implementation-selection classes, helper functions, decorators, or discovery utilities unless their module SPEC records an explicit exception. Public factories should own construction/selection of private implementations when a caller only needs a protocol or service contract.
 - Do not introduce Repository, Unit of Work, Clean Architecture, or DDD patterns unless a confirmed SPEC records the concrete reason.
diff --git a/docs/assets/fsq-agent-exploration-flow.mmd b/docs/assets/fsq-agent-exploration-flow.mmd
index f3e20ed5..33454e73 100644
--- a/docs/assets/fsq-agent-exploration-flow.mmd
+++ b/docs/assets/fsq-agent-exploration-flow.mmd
@@ -1,6 +1,6 @@
 sequenceDiagram
     participant User as User / Team
-    participant Entry as CLI / API / Playground
+    participant Entry as CLI / API / Control Plane
     participant Planner as Model-Agnostic Planner
     participant Model as Model Provider
     participant K as Knowledge System
diff --git a/docs/assets/fsq-agent-module-map.mmd b/docs/assets/fsq-agent-module-map.mmd
index b637b981..3641b543 100644
--- a/docs/assets/fsq-agent-module-map.mmd
+++ b/docs/assets/fsq-agent-module-map.mmd
@@ -1,7 +1,7 @@
 flowchart LR
     subgraph Entry[Entry Modules]
         CLI[CLI / API]
-        PLAY[Playground / Debug UI]
+        UI[Control Plane]
     end
 
     subgraph Testcase[Testcase Modules]
@@ -35,7 +35,7 @@ flowchart LR
 
     CLI --> FSQYAML
     CLI --> GOAL
-    PLAY --> DEBUG
+    UI --> DEBUG
     FSQYAML --> NORMALIZER --> RUNNER --> ACTIONIR
     GOAL --> PLANNER
     MODEL <--> PLANNER
diff --git a/docs/fsq-agent-architecture-deep-dive.md b/docs/fsq-agent-architecture-deep-dive.md
index 965385a7..be8789fb 100644
--- a/docs/fsq-agent-architecture-deep-dive.md
+++ b/docs/fsq-agent-architecture-deep-dive.md
@@ -91,7 +91,7 @@ Midscene uses a similar layered shape: entry integrations such as CLI, Playwrigh
 flowchart LR
     subgraph Entry[Entry Modules]
         CLI[CLI / API]
-        PLAY[Playground / Debug UI]
+        UI[Control Plane]
     end
 
     subgraph Testcase[Testcase Modules]
@@ -125,7 +125,7 @@ flowchart LR
 
     CLI --> FSQYAML
     CLI --> GOAL
-    PLAY --> DEBUG
+    UI --> DEBUG
     FSQYAML --> NORMALIZER --> RUNNER --> ACTIONIR
     GOAL --> PLANNER
     MODEL <--> PLANNER
@@ -188,7 +188,7 @@ The regression flow must not depend on a planner model. This is the main differe
 ```mermaid
 sequenceDiagram
     participant User as User / Team
-    participant Entry as CLI / API / Playground
+    participant Entry as CLI / API / Control Plane
     participant Planner as Model-Agnostic Planner
     participant Model as Model Provider
     participant K as Knowledge System
diff --git a/docs/release-acceptance-checklist.md b/docs/release-acceptance-checklist.md
index a5c1c66d..ca5e1342 100644
--- a/docs/release-acceptance-checklist.md
+++ b/docs/release-acceptance-checklist.md
@@ -43,7 +43,7 @@ The release workflow runs the equivalent automated gate before publication, incl
 The CI package job is the executable contract for archive inspection. Confirm that it checks:
 
 - exactly one wheel and one sdist;
-- Control Plane and Playground HTML, JavaScript, CSS, and `entry-assets.json` in both archives;
+- Control Plane HTML, JavaScript, CSS, and `entry-assets.json` in both archives;
 - repository platform presets, default prompt templates, and configured skills in both archives;
 - default dependencies for uiautomator2, Playwright, pywinauto, Pillow, and Appium Python Client;
 - no platform extras;
diff --git a/docs/step-runner-architecture.md b/docs/step-runner-architecture.md
index 79a426c0..a80adb07 100644
--- a/docs/step-runner-architecture.md
+++ b/docs/step-runner-architecture.md
@@ -423,7 +423,7 @@ Planner output / FSQ step
   terminal progress
   debug timeline
   json report
-  live playground
+  Control Plane live timeline
   CI reporter
 
   这比让 Runner 直接 import 所有模块干净得多。
diff --git a/frontend/SPEC.md b/frontend/SPEC.md
index 15866349..1f6a55b7 100644
--- a/frontend/SPEC.md
+++ b/frontend/SPEC.md
@@ -11,15 +11,14 @@ This parent module does not own child application behavior or Python HTTP/runtim
 - The root `package.json` and `package-lock.json` own exact npm dependencies and the single lock-file dependency graph.
 - Supported Node.js versions are `^20.19.0 || >=22.12.0`.
 - Vite is the frontend development and production build tool.
-- `ts-ebml` is the current browser runtime dependency used by the Playground and Control Plane child modules for seekable WebM replay generation.
+- `ts-ebml` is the current browser runtime dependency used by the Control Plane child module for seekable WebM replay generation.
 - `react-markdown` is the current browser runtime dependency used by the Control Plane child module for safe Markdown preview without raw HTML support.
-- The workspace consumes Python Playground and Control Plane HTTP origins only through Vite development proxy configuration and browser HTTP requests. Frontend source does not import Python modules.
+- The workspace consumes the Python Control Plane HTTP origin only through Vite development proxy configuration and browser HTTP requests. Frontend source does not import Python modules.
 
 ## Public Interface
 
-- `npm run dev` starts the Vite development server for frontend entries and proxies configured Playground API paths to `FSQ_PLAYGROUND_API_ORIGIN`, defaulting to `http://127.0.0.1:8878`.
-- `npm run build` compiles all configured page entries through the untracked `.frontend-dist` staging directory and distributes each entry into its owning Python package static directory.
-- `frontend/playground/SPEC.md` defines the Playground browser application's public behavior and source boundary.
+- `npm run dev` starts the Vite development server for the Control Plane entry and proxies `/api/control-plane` to `FSQ_CONTROL_PLANE_API_ORIGIN`, defaulting to `http://127.0.0.1:8879`.
+- `npm run build` compiles the configured Control Plane page entry through the untracked `.frontend-dist` staging directory and distributes it into its owning Python package static directory.
 - `frontend/control-plane/SPEC.md` defines the Control Plane browser application's public behavior and source boundary.
 
 ## Internal Structure
@@ -27,10 +26,8 @@ This parent module does not own child application behavior or Python HTTP/runtim
 - `../package.json`: Root npm metadata, scripts, Node.js compatibility, and exact direct dependency versions.
 - `../package-lock.json`: Complete locked npm dependency graph.
 - `../vite.config.js`: Multi-page entry configuration, development API proxying, and production output mapping.
-- `playground/`: Independently specified Playground browser application.
 - `control-plane/`: Independently specified Control Plane browser application.
 - `../.frontend-dist/`: Untracked temporary Vite build staging.
-- `../fsq_agent/adapters/control_plane/playground/static/`: Untracked generated Playground build output consumed by canonical Python packaging and production static serving; it is not authored frontend source.
 - `../fsq_agent/adapters/control_plane/static/`: Untracked generated Control Plane build output consumed by canonical Python packaging and production static serving; it is not authored frontend source.
 
 ## Frontend Architecture
diff --git a/frontend/control-plane/SPEC.md b/frontend/control-plane/SPEC.md
index 361dee21..d9c3f9a8 100644
--- a/frontend/control-plane/SPEC.md
+++ b/frontend/control-plane/SPEC.md
@@ -17,7 +17,7 @@ The entry does not own backend validation, Provider/workspace persistence or aut
 - `react-markdown` renders workspace Markdown previews with raw HTML disabled and no raw-HTML plugin.
 - `/api/control-plane/*` is the only backend contract consumed by this entry.
 
-The entry must not import Playground source, Python-generated static assets, backend implementation files, or another frontend entry's private code. It does not introduce Redux, React Query, a client router, Tailwind, CSS-in-JS, or a component framework.
+The entry must not import Python-generated static assets, backend implementation files, or another frontend entry's private code. It does not introduce Redux, React Query, a client router, Tailwind, CSS-in-JS, or a component framework.
 
 ## Public Behavior
 
@@ -220,7 +220,7 @@ Current Devices ownership:
 - `src/features/devices/components/ScreenView.tsx`, `UiSnapshotView.tsx`, and `RunLogsView.tsx`: current/selected-step evidence presentation; Logs owns structured-row message disclosure, sticky-table semantics, and log scroll following.
 - `src/features/devices/components/ReplayVideoView.tsx`: terminal replay resolution, generation state, stored-video playback, and browser-resource cleanup.
 - `src/features/devices/components/StepEvidenceView.tsx`: selected-step screenshot comparison and UI-snapshot diff presentation.
-- `src/features/devices/replay/`: frame timing, Canvas/MediaRecorder capture, seekable WebM conversion, and diff helpers that remain independent from Playground source.
+- `src/features/devices/replay/`: frame timing, Canvas/MediaRecorder capture, seekable WebM conversion, and diff helpers.
 - `src/features/devices/hooks/useDeviceWorkspace.ts`: page state, one-time launch-intent validation/consumption, and discovery/run commands.
 - `src/features/devices/hooks/useRunStream.ts`: sequence, SSE reconnect, and snapshot fallback.
 - `src/styles/`: entry tokens and Devices-specific styles that do not override shell structure.
@@ -264,7 +264,7 @@ The application owns the Config request used to derive Overview's read-only safe
 - Development requests under `/api/control-plane` proxy to the local Control Plane Python server and preserve unbuffered SSE.
 - Production output is generated under `fsq_agent/adapters/control_plane/static`, remains untracked, and is included in the Python wheel beside the canonical Control Plane adapter.
 - Installed-wheel use serves the generated entry and API from one Python process and requires no Node.js/network access.
-- Static route fallback is limited to the Control Plane entry and never falls back to Playground.
+- Static route fallback is limited to the Control Plane entry.
 - The root package manifest and lock file own all frontend dependencies. No nested package project or second lock file exists.
 
 ## Error Handling
@@ -303,7 +303,7 @@ Empty states direct the user to create/select a workspace, add a configured plat
 - Config tests cover malformed-response rejection, loading/empty/configured/unavailable states, complete Azure save and key visibility, dirty-state discard behavior, provider replacement preservation, immediate GitHub device-flow start, authorization/model-discovery polling, no-default model selection, offered-model save eligibility, discovery error/empty retry, save success/failure, expiration/cancel cleanup, saved-only Test connection eligibility/results, dialog keyboard/focus behavior, and secret-safe presentation.
 - Devices tests cover shared workspace selection, ordinary entry with no implicit platform selection, available Workspace replay-intent platform/mode/case initialization, active-task precedence, missing/unavailable platform fallback, missing/non-selectable case fallback, valid configured-platform options, compound stale-request protection, derived start eligibility, workspace/platform Explore/Strict payloads, active workspace/platform/target locks, flat sequence-ordered timeline events, one-line overflow disclosure, active-run-only Jump visibility, exact bottom scrolling, immediate Jump dismissal/focus transfer, terminal Action selection, selected-step artifact states, screenshot comparison, UI Tree diff, replay generation/reuse/error cleanup, range-video playback, timeline/cancel/terminal/new-run behavior, stream resume/fallback, sticky Logs structure, per-row full event disclosure, tabs, accessible names, live announcements, and focus behavior.
 - Browser verification covers Overview default with separate global AI and current-Workspace regions, safe Workspace identity, three-step flow, no selected Workspace, only-unavailable platforms, Provider configured/unconfigured/error states, desktop and narrow keyboard order, and navigation into Config, Workspace, and Devices; expanded Workspace group with path-free entries; multi-platform create, compact banner, configuration tabs, add/edit, and file-browser workflows; record-new-case navigation with workspace preservation and no platform; eligible top-level/nested FSQ replay navigation with explicit workspace/platform/Strict/case initialization and no automatic start; ineligible-file metadata without replay; stale-case empty selection; Markdown preview; selected-Workspace desktop title alignment and compact Configure presentation, edge-to-edge geometry, fixed structural dimensions, independent desktop scrolling, and omitted controls at 1440×900 and 1024×768; selected-Workspace stacked title and content flow without overlap or page-level horizontal overflow at 390×844; Devices workspace/platform selection plus viewport containment and independent scrolling at 1440×900 and 1280×720; keyboard-only navigation/disclosures/tree/tabs, Action selection, Show run replay, and immediate Jump dismissal; secret cleanup/visibility; long-path/content wrapping; Before/After comparison with original image edges; UI Tree diff including XML structured rendering; generated-video playback/seeking; constrained screenshot/replay media; sticky Logs; all four platform forms/readiness presentations; and at least one available platform's Explore/Strict progress, evidence, cancellation, and terminal behavior. Layout changes require reviewed desktop and narrow screenshots plus a clean browser console.
-- Build/package verification proves both Vite entries are generated, existing Playground remains functional, and an isolated wheel starts Control Plane without Node.js.
+- Build/package verification proves the Control Plane Vite entry is generated and an isolated wheel starts Control Plane without Node.js.
 
 ## Current Invariants
 
@@ -325,4 +325,3 @@ Empty states direct the user to create/select a workspace, add a configured plat
 - Compound workspace-platform request generations prevent stale responses from changing the selected context.
 - Terminal selected-Action evidence loading is non-destructive: changing Action selection does not clear the current selected-Action Screen/UI Tree presentation before the next Action's artifacts resolve, and stale artifact reads cannot replace the current selection.
 - No large evidence bytes are carried in SSE.
-- Existing Playground source and behavior remain independent.
diff --git a/frontend/playground/SPEC.md b/frontend/playground/SPEC.md
deleted file mode 100644
index 9ff04e4f..00000000
--- a/frontend/playground/SPEC.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Module: frontend/playground
-
-## Purpose
-
-Own the authored browser application for the local FSQ-Agent Playground. The application presents runtime status for the server's fixed CLI-selected workspace/platform, platform session setup where applicable, dynamic and strict execution controls, YAML views and lifecycle editing, progress, screenshots, replay video, reports, existing-run loading, and completed-step artifacts.
-
-This module owns browser-local state, rendering, interaction, and browser-side replay generation. It consumes the HTTP contracts owned by `fsq_agent/playground/SPEC.md` and does not own Python execution, filesystem safety, route semantics, production static serving, or wheel packaging.
-
-## Dependencies
-
-- Parent workspace: Uses the npm, Vite, lock-file, and generated-asset contracts in `frontend/SPEC.md`.
-- Python Playground API: Consumes the documented JSON, Server-Sent Events, screenshot, replay, report, YAML, and step-artifact endpoints without importing Python modules.
-- `ts-ebml`: Imported as an ES module for browser-side seekable WebM generation.
-- Browser platform APIs: Uses `fetch`, `EventSource`, DOM events, media elements, local storage, blobs, Canvas 2D with `captureStream`, `MediaRecorder`, `Image`, and `FileReader`.
-
-## Public Interface
-
-- Source entry: `index.html` loads `playground.js` as an ES module and `playground.css` as the authored stylesheet.
-- Run modes: Goal, YAML, and Strict YAML preserve their corresponding server execution semantics.
-- Runtime context: Displays server-provided workspace/platform metadata where supplied and does not offer workspace or platform switching.
-- Workspace views: Source YAML, Generated YAML, Progress, Preview, and Report expose mode-appropriate state without changing execution semantics.
-- Session controls: Android session setup is visible only when the active platform requires it.
-- Existing-run loading: Goal mode can load one server-validated completed run from the fixed selected platform run root and reuse the normal Progress, Report, replay, generated-YAML, and step-artifact surfaces.
-- Input lifecycle editing: Source YAML exposes case-level `onCaseStart` and `onCaseComplete` action drafts while metadata and case steps remain read-only.
-- Artifact navigation: Completed Strict Input and Generated YAML step cards can select step artifacts in Preview; selecting the case title returns to replay preview.
-
-The browser consumes endpoint contracts from `fsq_agent/playground/SPEC.md`. Endpoint validation, response safety, execution ordering, path resolution, and persistence semantics remain owned by that Python module.
-
-## Data And State Flow
-
-- A centralized browser state tracks the active request, run mode, per-mode view snapshots, progress sequence, selected artifacts, lifecycle drafts, replay generation, finalization, and loaded-run state.
-- Each run mode preserves its own YAML content and active view, Progress history, active Preview/Report tab, report content, replay state, and step-artifact preview when the user switches modes. Transient YAML-region and Progress-item selection styling is cleared when a mode is restored.
-- Live progress prefers Server-Sent Events and falls back to sequence-based polling; events append without rebuilding prior history.
-- Execution completion resolves the run id, report, generated YAML, replay frames/video, and step-artifact availability independently so one unavailable surface does not invalidate the others.
-- Lifecycle edits remain browser-local drafts until Save sends structured hooks with the source revision. Discard restores the last server snapshot.
-- Browser replay generation converts persisted screenshot frames to WebM, uploads the result through the server contract, and then uses the stored range-capable video for playback and seeking.
-
-## Internal Structure
-
-- `index.html`: Semantic application shell, controls, tabs, panels, media surfaces, accessible names, and the browser entry declaration.
-- `playground.js`: Current application controller, API client, centralized state, rendering, execution/progress coordination, YAML presentation, artifact views, panel resizing, replay generation, and event wiring.
-- `lifecycle-editor-model.js`: Pure clone, add, update, delete, reorder, and validation operations for lifecycle action drafts.
-- `playground.css`: Workspace layout, responsive behavior, visual states, focus treatment, artifact comparison, YAML presentation, and editor styling.
-
-## Frontend Architecture
-
-- Architecture level: Legacy stateful single-page application, documented as an exception to the normalized React application levels.
-- Runtime boundary: Browser-only authored source compiled by Vite.
-- State boundary: `playground.js` owns centralized mutable application and per-mode state; `lifecycle-editor-model.js` owns pure lifecycle draft operations.
-- Integration boundary: A shared browser API helper and `EventSource` calls consume only the Python Playground transport surface.
-- Dependency direction: `playground.js` may import `lifecycle-editor-model.js` and `ts-ebml`; authored frontend source does not import generated assets or Python modules.
-- Current framework: Vanilla JavaScript, HTML, and CSS. React and TypeScript/TSX are not current dependencies or source formats for this module.
-
-## Error Handling
-
-- Failed JSON requests surface the server's concise `error` value when present and otherwise show the HTTP status.
-- Status, YAML, load-run, report, replay, and artifact failures stay local to their relevant surface when the rest of the completed run remains usable.
-- Starting execution or changing/reloading the YAML path while lifecycle drafts are dirty requires Save or Discard; Clear discards the draft.
-- Client lifecycle validation appears when Save is attempted. Empty action values and unsupported action types are rejected before the request.
-- Lifecycle revision conflicts require the source to be reloaded and do not silently overwrite disk changes.
-- Controls that can conflict with execution, completion/replay finalization, or an active save are disabled and guarded in event handlers.
-- A run with no persisted progress, generated YAML, replay, report, or artifacts presents a concise empty or unavailable state rather than synthetic content.
-
-## Verification Scope
-
-- Verification covers mode switching, per-mode state preservation, execution and cancellation controls, SSE-to-polling progress behavior, lifecycle draft editing, existing-run loading, report and YAML presentation, replay generation/playback, and step-artifact navigation.
-- Browser-source verification covers labeled native controls, keyboard-operated main workspace panel resizing and form submission, main-control focus treatment, and non-overlapping narrow-viewport behavior. It does not represent pointer-only artifact navigation or artifact-region resizers as keyboard-operable.
-- Integration verification covers the documented JSON and SSE endpoints, binary replay upload/playback, HTTP range seeking, safe generated-YAML rendering, and the distinction between dynamic raw YAML and strict execution.
-- Build verification uses the parent workspace's locked install and Vite build and confirms no committed vendor bundle or global EBML dependency is required.
-
-## Current Invariants
-
-### Progress And Workspace State
-
-- The desktop UI uses a persisted resizable two-column workspace: mode-specific YAML/Progress views on the left and Preview/Report on the right. Starting execution clears the Preview surface but preserves the active Preview/Report tab until later artifact or replay navigation selects Preview; progress continues independently.
-- Left-side tab availability and defaults follow run mode: Goal exposes Progress and Generated YAML, YAML exposes Progress, Source YAML, and Generated YAML, and Strict YAML exposes Source YAML and Progress. Each mode preserves its own view state, and generated recording content does not force tab selection.
-- Strict execution uses server-provided current-step metadata for Source YAML highlighting without synthesizing tool-call events from core lifecycle events. Dynamic YAML does not mutate Input step state. Run-mode and artifact navigation changes are blocked while execution or replay finalization is active.
-- Generated YAML and loaded-run YAML remain read-only structured presentations and do not render lifecycle editor sections. Ordinary command cards render under a `Case steps` heading. Live Source YAML renders case-level `onCaseStart` before Case steps and `onCaseComplete` after them. Only lifecycle action rows are editable; metadata and Case steps remain read-only.
-- Input lifecycle drafts contain flat ordered `Before case` and `After case` action lists. `runCase` and `runShell` may repeat. Save and Discard are document-level controls; Save validates dirty drafts when invoked, and Discard restores the last server snapshot.
-- Saving lifecycle drafts sends structured hook data plus the loaded source revision. Empty lifecycle sections remove their keys. Unedited files are never rewritten by the browser.
-- Load Run expands an inline run-directory form in Goal mode. A successful load creates a completed-run view without an active request and independently loads persisted Progress, Report, replay, Generated YAML, and step-artifact availability through existing endpoints.
-- Failed existing-run validation preserves the displayed result and reports the error in the inline form. Cancel preserves the result and collapses the form. Clear removes loaded-run state and restores the empty workspace.
-
-### Preview And Artifacts
-
-- Completed runs use persisted screenshots as replay-video input and show available replay video in Preview with native playback and seeking controls. Replay generation is automatic rather than a separate user command.
-- Completed Strict Source YAML and Generated YAML step cards open their artifacts in Preview; dynamic Source YAML cards do not.
-- Screenshots precede structured artifacts, absent artifact kinds do not create empty regions, and selecting the case title restores the completed replay-video view.
-- Before/After screenshots default to a centered, complete side-by-side comparison on a neutral backdrop. Screenshot and UI snapshot regions resize independently and use scrolling for overflow.
-- Before/after normalized `ui_snapshot` artifacts may render as a read-only full-content diff with line-level and paired inline change highlighting. Explicit Android `uiTree` and Web/desktop `uiSnapshot` artifacts remain supported.
-- The named main workspace panel separator supports keyboard resizing. Artifact-region height resizers and artifact selection from Progress or structured YAML are current pointer-only legacy interactions.
-- Lifecycle editing uses compact, unnested action rows with an action menu, single-line value, and icon controls with tooltips and accessible labels. Controls remain usable without overlap in the resizable desktop layout and narrow viewport.
-
-### Ownership And Distribution
-
-- Authored browser source and browser dependencies are owned by the frontend workspace; generated bundles are untracked package data.
-- The Python Playground server owns all endpoint semantics and production static serving. Browser code treats server responses as transport contracts and does not reproduce server validation or filesystem policy.
-- Workspace/platform selection belongs to CLI startup; browser code neither infers nor changes it.
-- The module remains vanilla JavaScript until a confirmed module SPEC changes its framework and source-language contract.
\ No newline at end of file
diff --git a/frontend/playground/index.html b/frontend/playground/index.html
deleted file mode 100644
index 9961fdee..00000000
--- a/frontend/playground/index.html
+++ /dev/null
@@ -1,109 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>FSQ-Agent Playground</title>
-    <link rel="stylesheet" href="./playground.css" />
-  </head>
-  <body>
-    <div id="toast" class="toast" role="status" aria-live="polite" hidden></div>
-    <main class="shell">
-      <section class="panel control-panel">
-        <header class="topbar">
-          <div>
-            <h1>FSQ-Agent Playground</h1>
-            <p id="server-status" class="status-pill status-connecting">Connecting...</p>
-          </div>
-          <button id="refresh" class="secondary-button" type="button">Clear</button>
-        </header>
-
-        <section id="execution-section" class="section execution-section">
-          <div class="section-heading-row">
-            <h2>Execution</h2>
-            <button id="load-run-toggle" class="secondary-button load-run-toggle" type="button" aria-expanded="false" aria-controls="load-run-form">Load Run</button>
-          </div>
-          <div id="load-run-form" class="load-run-form" hidden>
-            <input id="load-run-path" type="text" placeholder="Run ID or run directory path..." aria-label="Existing run directory" />
-            <div class="load-run-actions">
-              <button id="load-run-submit" class="primary" type="button">Load</button>
-              <button id="load-run-cancel" class="secondary-button" type="button">Cancel</button>
-            </div>
-            <p id="load-run-status" class="yaml-status" aria-live="polite" hidden></p>
-          </div>
-          <div class="yaml-tabs" role="tablist" aria-label="YAML views">
-            <button id="yaml-input-tab" class="yaml-tab-button active" type="button" role="tab" aria-selected="true" aria-controls="yaml-input-pane">Source YAML</button>
-            <button id="yaml-recorded-tab" class="yaml-tab-button" type="button" role="tab" aria-selected="false" aria-controls="yaml-recorded-pane">Generated YAML</button>
-            <button id="yaml-progress-tab" class="yaml-tab-button" type="button" role="tab" aria-selected="false" aria-controls="progress-pane">Progress</button>
-          </div>
-          <div id="yaml-input-pane" class="yaml-pane" role="tabpanel" aria-labelledby="yaml-input-tab">
-            <p id="yaml-input-status" class="yaml-status">No YAML loaded.</p>
-            <div id="yaml-lifecycle-toolbar" class="yaml-lifecycle-toolbar" hidden>
-              <span id="yaml-lifecycle-dirty" class="yaml-lifecycle-dirty" hidden>Unsaved lifecycle changes</span>
-              <div class="yaml-lifecycle-toolbar-actions">
-                <button id="yaml-lifecycle-save" class="primary" type="button" disabled>Save</button>
-                <button id="yaml-lifecycle-discard" class="secondary-button" type="button" disabled>Discard</button>
-              </div>
-            </div>
-            <div id="yaml-input-viewer" class="yaml-viewer" aria-live="polite"></div>
-          </div>
-          <div id="yaml-recorded-pane" class="yaml-pane" role="tabpanel" aria-labelledby="yaml-recorded-tab" hidden>
-            <p id="yaml-recorded-status" class="yaml-status">No generated YAML yet.</p>
-            <div id="yaml-recorded-viewer" class="yaml-viewer" aria-live="polite"></div>
-          </div>
-          <section id="progress-pane" class="yaml-pane progress-pane" role="tabpanel" aria-labelledby="yaml-progress-tab" hidden>
-            <div id="progress-run-id" class="progress-run-id" hidden></div>
-            <div id="progress" class="progress-log"></div>
-          </section>
-        </section>
-
-        <section id="session-section" class="section" hidden>
-          <h2>Session</h2>
-          <div class="session-row">
-            <select id="device-select" aria-label="ADB device"></select>
-          </div>
-          <p id="session-message" class="muted"></p>
-        </section>
-
-        <section class="section run-section">
-          <h2>Run</h2>
-          <div class="run-mode-row" role="radiogroup" aria-label="Run mode">
-            <label><input type="radio" name="run-mode" value="goal" checked /> Goal</label>
-            <label><input type="radio" name="run-mode" value="yaml" /> YAML</label>
-            <label><input type="radio" name="run-mode" value="strict-yaml" /> Strict YAML</label>
-          </div>
-          <div class="run-input-row">
-            <textarea id="goal" rows="5" placeholder="Describe the task to run..."></textarea>
-            <div id="yaml-path-row" class="yaml-path-row" hidden>
-              <input id="case-yaml" type="text" placeholder="Path to .fsq.yaml..." />
-            </div>
-            <button id="run-selected" type="button" class="primary">Run</button>
-          </div>
-        </section>
-      </section>
-
-      <div id="panel-resizer" class="panel-resizer" role="separator" aria-label="Resize panels" aria-orientation="vertical" aria-valuemin="300" aria-valuemax="720" tabindex="0"></div>
-
-      <section class="panel preview-panel">
-        <header class="preview-header">
-          <div>
-            <div class="preview-tabs" role="tablist" aria-label="Preview and report">
-              <button id="preview-tab" class="tab-button active" type="button" role="tab" aria-selected="true" aria-controls="preview-pane">Preview</button>
-              <button id="report-tab" class="tab-button" type="button" role="tab" aria-selected="false" aria-controls="report-pane">Report</button>
-            </div>
-          </div>
-        </header>
-        <div id="preview-pane" class="tab-pane preview-frame" role="tabpanel" aria-labelledby="preview-tab">
-          <div id="step-artifact-preview" class="step-artifact-preview" hidden></div>
-          <video id="replay-video" controls hidden></video>
-          <img id="screenshot" alt="Android screenshot preview" />
-          <p id="preview-empty">Screenshot preview will appear here.</p>
-        </div>
-        <div id="report-pane" class="tab-pane report-pane" role="tabpanel" aria-labelledby="report-tab" hidden>
-          <div id="report-content" class="report-content">No report yet.</div>
-        </div>
-      </section>
-    </main>
-    <script type="module" src="./playground.js"></script>
-  </body>
-</html>
\ No newline at end of file
diff --git a/frontend/playground/lifecycle-editor-model.js b/frontend/playground/lifecycle-editor-model.js
deleted file mode 100644
index 11ed0232..00000000
--- a/frontend/playground/lifecycle-editor-model.js
+++ /dev/null
@@ -1,66 +0,0 @@
-  function empty() {
-    return { onCaseStart: [], onCaseComplete: [] };
-  }
-
-  function clone(value) {
-    return value ? JSON.parse(JSON.stringify(value)) : empty();
-  }
-
-  function actions(draft, field) {
-    const value = draft || empty();
-    return Array.isArray(value[field]) ? value[field] : [];
-  }
-
-  function change(draft, operation) {
-    const next = clone(draft);
-    operation(next);
-    return next;
-  }
-
-  function addAction(draft, field, action = 'runCase') {
-    return change(draft, (next) => {
-      actions(next, field).push({ action, value: '' });
-    });
-  }
-
-  function updateAction(draft, field, actionIndex, key, value) {
-    return change(draft, (next) => {
-      actions(next, field)[actionIndex][key] = value;
-    });
-  }
-
-  function deleteAction(draft, field, actionIndex) {
-    return change(draft, (next) => actions(next, field).splice(actionIndex, 1));
-  }
-
-  function moveAction(draft, field, actionIndex, delta) {
-    return change(draft, (next) => {
-      const items = actions(next, field);
-      const destination = actionIndex + delta;
-      if (destination < 0 || destination >= items.length) return;
-      [items[actionIndex], items[destination]] = [items[destination], items[actionIndex]];
-    });
-  }
-
-  function validationError(draft) {
-    for (const field of ['onCaseStart', 'onCaseComplete']) {
-      for (const action of actions(draft, field)) {
-        if (!['runCase', 'runShell'].includes(action.action)) return 'Lifecycle action type is invalid.';
-        if (!String(action.value || '').trim()) return 'Lifecycle action values cannot be empty.';
-      }
-    }
-    return '';
-  }
-
-  const LifecycleEditorModel = {
-    empty,
-    clone,
-    actions,
-    addAction,
-    updateAction,
-    deleteAction,
-    moveAction,
-    validationError,
-  };
-
-  export default LifecycleEditorModel;
diff --git a/frontend/playground/playground.css b/frontend/playground/playground.css
deleted file mode 100644
index 3afe780d..00000000
--- a/frontend/playground/playground.css
+++ /dev/null
@@ -1,1719 +0,0 @@
-:root {
-  color-scheme: light dark;
-  font-family: "Segoe UI", Arial, sans-serif;
-  --control-panel-width: clamp(320px, 32vw, 520px);
-  background: #f6f7f9;
-  color: #15171a;
-}
-
-.progress-item-with-artifacts {
-  cursor: pointer;
-}
-
-body {
-  margin: 0;
-  height: 100vh;
-  overflow: hidden;
-}
-
-.toast {
-  position: fixed;
-  top: 18px;
-  right: 18px;
-  z-index: 1000;
-  max-width: min(360px, calc(100vw - 36px));
-  padding: 10px 14px;
-  border: 1px solid #86c89a;
-  border-radius: 6px;
-  background: #f0fdf4;
-  color: #166534;
-  box-shadow: 0 8px 24px rgb(15 23 42 / 18%);
-  font-size: 13px;
-  font-weight: 650;
-}
-
-[hidden] {
-  display: none !important;
-}
-
-button,
-select,
-textarea {
-  font: inherit;
-}
-
-button {
-  border: 1px solid #b8c0cc;
-  border-radius: 6px;
-  background: #ffffff;
-  color: #15171a;
-  padding: 8px 12px;
-  cursor: pointer;
-}
-
-button.primary {
-  background: #0f6cbd;
-  color: #ffffff;
-  border-color: #0f6cbd;
-}
-
-button.secondary-button {
-  min-height: 34px;
-  padding: 6px 10px;
-  background: #f8fafc;
-  color: #334155;
-  border-color: #cbd5e1;
-}
-
-button.secondary-button:hover:not(:disabled) {
-  background: #eef2f7;
-}
-
-#run-selected {
-  min-width: 80px;
-}
-
-button:disabled {
-  opacity: 0.55;
-  cursor: not-allowed;
-}
-
-.shell {
-  display: grid;
-  grid-template-columns: minmax(300px, var(--control-panel-width)) 8px minmax(0, 1fr);
-  gap: 8px;
-  height: 100vh;
-  padding: 12px;
-  box-sizing: border-box;
-  overflow: hidden;
-}
-
-.panel {
-  background: #ffffff;
-  border: 1px solid #d8dee8;
-  border-radius: 8px;
-  min-height: 0;
-  overflow: hidden;
-}
-
-.control-panel {
-  display: flex;
-  flex-direction: column;
-  min-height: 0;
-  overflow: auto;
-}
-
-.panel-resizer {
-  position: relative;
-  align-self: stretch;
-  min-height: 0;
-  border: 0;
-  border-radius: 6px;
-  background: transparent;
-  cursor: col-resize;
-  outline: none;
-}
-
-.panel-resizer::before {
-  content: "";
-  position: absolute;
-  top: 8px;
-  bottom: 8px;
-  left: 50%;
-  width: 2px;
-  border-radius: 999px;
-  background: #d8dee8;
-  transform: translateX(-50%);
-}
-
-.panel-resizer:hover::before,
-.panel-resizer:focus-visible::before,
-.shell.resizing-panels .panel-resizer::before {
-  background: #0f6cbd;
-}
-
-.shell.resizing-panels {
-  cursor: col-resize;
-  user-select: none;
-}
-
-.preview-panel {
-  display: flex;
-  flex-direction: column;
-  height: calc(100vh - 24px);
-  min-height: 0;
-}
-
-.topbar,
-.preview-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 16px;
-  border-bottom: 1px solid #e5e9f0;
-}
-
-.preview-tabs {
-  display: inline-flex;
-  flex-wrap: wrap;
-  gap: 18px;
-  margin-bottom: 6px;
-  border-bottom: 1px solid #d8dee8;
-}
-
-.tab-button {
-  position: relative;
-  min-height: 30px;
-  padding: 0 0 7px;
-  border: 0;
-  border-radius: 0;
-  background: transparent;
-  color: #5c6573;
-  font-weight: 600;
-}
-
-.tab-button.active {
-  background: transparent;
-  color: #0f4c81;
-}
-
-.tab-button.active::after {
-  content: "";
-  position: absolute;
-  left: 0;
-  right: 0;
-  bottom: -1px;
-  height: 3px;
-  border-radius: 999px 999px 0 0;
-  background: #0f6cbd;
-}
-
-.tab-button:hover {
-  color: #0f4c81;
-}
-
-h1,
-h2,
-p {
-  margin: 0;
-}
-
-h1 {
-  font-size: 20px;
-}
-
-.status-pill {
-  display: inline-flex;
-  align-items: center;
-  gap: 7px;
-  min-height: 24px;
-  margin-top: 7px;
-  padding: 3px 10px;
-  border: 1px solid #cbd5e1;
-  border-radius: 999px;
-  background: #f8fafc;
-  color: #475569;
-  font-size: 12px;
-  font-weight: 650;
-  line-height: 1;
-}
-
-.status-pill::before {
-  content: "";
-  width: 7px;
-  height: 7px;
-  border-radius: 999px;
-  background: currentColor;
-}
-
-.status-ready {
-  border-color: #bbf7d0;
-  background: #f0fdf4;
-  color: #15803d;
-}
-
-.status-running {
-  border-color: #bfdbfe;
-  background: #eff6ff;
-  color: #1d4ed8;
-}
-
-.status-connecting {
-  border-color: #fde68a;
-  background: #fffbeb;
-  color: #b45309;
-}
-
-.status-error {
-  border-color: #fecaca;
-  background: #fef2f2;
-  color: #b91c1c;
-}
-
-h2 {
-  font-size: 15px;
-  margin-bottom: 10px;
-}
-
-.section {
-  padding: 16px;
-  border-bottom: 1px solid #edf0f5;
-}
-
-.section-heading-row {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 10px;
-  margin-bottom: 10px;
-}
-
-.section-heading-row h2 {
-  margin-bottom: 0;
-}
-
-.load-run-toggle {
-  min-height: 30px;
-  padding: 5px 10px;
-}
-
-.load-run-form {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
-  align-items: start;
-  gap: 8px;
-}
-
-.load-run-form input {
-  min-width: 0;
-  margin: 0;
-}
-
-.load-run-actions {
-  display: inline-flex;
-  gap: 6px;
-}
-
-.load-run-actions button {
-  min-height: 36px;
-  padding: 7px 11px;
-}
-
-.load-run-form .yaml-status {
-  grid-column: 1 / -1;
-  margin: 0;
-}
-
-@media (max-width: 680px) {
-  .load-run-form {
-    grid-template-columns: minmax(0, 1fr);
-  }
-
-  .load-run-actions {
-    justify-content: flex-end;
-  }
-}
-
-.execution-section {
-  display: flex;
-  flex-direction: column;
-  flex: 1 1 auto;
-  gap: 10px;
-  min-height: 320px;
-}
-
-.yaml-tabs {
-  display: inline-flex;
-  flex-wrap: wrap;
-  gap: 18px;
-  width: fit-content;
-  margin-bottom: 2px;
-  border-bottom: 1px solid #d8dee8;
-}
-
-.yaml-tab-button {
-  position: relative;
-  min-height: 30px;
-  padding: 0 0 7px;
-  border: 0;
-  border-radius: 0;
-  background: transparent;
-  color: #5c6573;
-  font-weight: 600;
-}
-
-.yaml-tab-button.active {
-  color: #0f4c81;
-}
-
-.yaml-tab-button.active::after {
-  content: "";
-  position: absolute;
-  left: 0;
-  right: 0;
-  bottom: -1px;
-  height: 3px;
-  border-radius: 999px 999px 0 0;
-  background: #0f6cbd;
-}
-
-.yaml-tab-button:hover {
-  color: #0f4c81;
-}
-
-.yaml-pane {
-  display: flex;
-  flex: 1 1 auto;
-  flex-direction: column;
-  min-height: 0;
-  overflow: hidden;
-}
-
-.yaml-path-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr);
-  gap: 8px;
-  min-width: 0;
-}
-
-.yaml-path-row input {
-  margin-bottom: 0;
-}
-
-.yaml-status {
-  min-height: 18px;
-  margin: 8px 0;
-  color: #475569;
-  font-size: 12px;
-  overflow-wrap: anywhere;
-}
-
-.yaml-status.yaml-status-error {
-  color: #b91c1c;
-}
-
-.yaml-status.yaml-status-success {
-  color: #15803d;
-}
-
-.yaml-viewer {
-  flex: 1 1 auto;
-  min-height: 150px;
-  overflow: auto;
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  background: #f8fafc;
-  color: #1f2937;
-  font-size: 12px;
-  line-height: 1.45;
-}
-
-.yaml-empty {
-  padding: 12px;
-  color: #64748b;
-}
-
-.yaml-lifecycle-toolbar {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 10px;
-  padding: 8px 10px;
-  border: 1px solid #d8dee8;
-  border-bottom: 0;
-  background: #ffffff;
-}
-
-.yaml-lifecycle-dirty {
-  color: #92400e;
-  font-size: 12px;
-  font-weight: 650;
-}
-
-.yaml-lifecycle-toolbar-actions,
-.yaml-lifecycle-action-controls {
-  display: flex;
-  align-items: center;
-  gap: 5px;
-}
-
-.yaml-lifecycle-toolbar-actions {
-  margin-left: auto;
-}
-
-.yaml-lifecycle-section {
-  scroll-margin-top: 56px;
-  padding: 10px;
-  border-bottom: 1px solid #d8dee8;
-  background: #f8fafc;
-}
-
-.yaml-lifecycle-section[data-lifecycle-field="onCaseComplete"] {
-  border-top: 1px solid #d8dee8;
-}
-
-.yaml-case-steps-section {
-  background: #f8fafc;
-}
-
-.yaml-case-steps-heading {
-  padding: 10px 10px 0;
-}
-
-.yaml-lifecycle-heading,
-.yaml-lifecycle-action-row {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 8px;
-}
-
-.yaml-lifecycle-heading h3 {
-  margin: 0;
-  color: #334155;
-  font-size: 13px;
-  letter-spacing: 0;
-}
-
-.yaml-lifecycle-list {
-  display: grid;
-  gap: 8px;
-  margin-top: 8px;
-}
-
-.yaml-lifecycle-action-row {
-  display: grid;
-  grid-template-columns: auto minmax(92px, 118px) minmax(0, 1fr) auto;
-  align-items: center;
-  gap: 7px;
-  padding: 7px 8px;
-  border: 1px solid #cbd5e1;
-  border-radius: 6px;
-  background: #ffffff;
-}
-
-.yaml-lifecycle-action-row select,
-.yaml-lifecycle-action-row input {
-  height: 32px;
-  min-width: 0;
-  margin: 0;
-  padding: 4px 7px;
-  border: 1px solid #cbd5e1;
-  border-radius: 5px;
-  background: #ffffff;
-  color: #1f2937;
-  font: inherit;
-  line-height: 1.2;
-}
-
-.yaml-lifecycle-icon-button {
-  width: 28px;
-  height: 28px;
-  padding: 0;
-  border: 1px solid #cbd5e1;
-  border-radius: 5px;
-  background: #ffffff;
-  color: #334155;
-  font-size: 16px;
-  line-height: 1;
-}
-
-.yaml-lifecycle-icon-button:hover:not(:disabled) {
-  border-color: #7aa7d9;
-  background: #eaf3ff;
-}
-
-.yaml-lifecycle-icon-button:disabled {
-  opacity: 0.35;
-}
-
-.yaml-lifecycle-empty {
-  padding: 8px 0 0;
-  color: #64748b;
-  font-size: 12px;
-}
-
-@media (max-width: 760px) {
-  .yaml-lifecycle-action-row {
-    grid-template-columns: 1fr;
-  }
-
-  .yaml-lifecycle-action-controls {
-    justify-content: flex-end;
-  }
-}
-
-.yaml-case-summary {
-  border-bottom: 1px solid #e5e9f0;
-  background: #ffffff;
-  cursor: pointer;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.yaml-case-summary:hover {
-  border-bottom-color: #cbdcf0;
-  background: #f1f7ff;
-}
-
-.yaml-case-summary.yaml-region-selected {
-  border-bottom-color: #a9c6e8;
-  background: #eaf3ff;
-  box-shadow: inset 3px 0 0 #93c5fd;
-}
-
-.yaml-case-title-row {
-  position: sticky;
-  top: 0;
-  z-index: 1;
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 7px;
-  padding: 12px;
-  border-bottom: 1px solid #d8e8fb;
-  background: #eef6ff;
-  cursor: pointer;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.yaml-case-summary:hover .yaml-case-title-row,
-.yaml-case-title-row:hover {
-  border-bottom-color: #bdd4ee;
-  background: #e5f1ff;
-}
-
-.yaml-case-summary.yaml-region-selected .yaml-case-title-row,
-.yaml-case-title-row.yaml-region-selected {
-  border-bottom-color: #9fc2ea;
-  background: #d7eaff;
-}
-
-.yaml-case-title {
-  display: -webkit-box;
-  min-width: 0;
-  overflow: hidden;
-  color: #0f4c81;
-  font-size: 15px;
-  font-weight: 750;
-  overflow-wrap: anywhere;
-  -webkit-box-orient: vertical;
-  -webkit-line-clamp: 2;
-  line-clamp: 2;
-}
-
-.yaml-chip {
-  display: inline-flex;
-  align-items: center;
-  min-height: 20px;
-  max-width: 100%;
-  padding: 1px 7px;
-  border: 1px solid #bfdbfe;
-  border-radius: 999px;
-  background: #eff6ff;
-  color: #1d4ed8;
-  font-size: 11px;
-  font-weight: 650;
-  overflow-wrap: anywhere;
-}
-
-.yaml-chip-muted {
-  border-color: #cbd5e1;
-  background: #f8fafc;
-  color: #475569;
-}
-
-.yaml-tags {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 6px;
-  padding: 10px 12px 0;
-}
-
-.yaml-metadata-grid {
-  display: grid;
-  grid-template-columns: 1fr;
-  gap: 6px;
-  padding: 10px 12px 12px;
-}
-
-.yaml-metadata-item {
-  display: grid;
-  grid-template-columns: 78px minmax(0, 1fr);
-  gap: 8px;
-  margin: 0 -6px;
-  padding: 4px 6px;
-  border-radius: 5px;
-  transition: background-color 120ms ease;
-}
-
-.yaml-metadata-item:hover {
-  background: #f1f5f9;
-}
-
-.yaml-metadata-item.yaml-region-selected {
-  background: #e8f1fb;
-}
-
-.yaml-metadata-label {
-  color: #64748b;
-  font-weight: 650;
-}
-
-.yaml-metadata-value {
-  min-width: 0;
-  color: #1f2937;
-  overflow-wrap: anywhere;
-}
-
-.yaml-step-list {
-  display: grid;
-  gap: 8px;
-  padding: 10px;
-}
-
-.yaml-step-card {
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  background: #ffffff;
-  cursor: pointer;
-  overflow: hidden;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.yaml-step-card:hover,
-.yaml-step-card:focus-within {
-  border-color: #93b4d8;
-  background: #eef6ff;
-}
-
-.yaml-step-card.yaml-region-selected {
-  border-color: #7aa7d9;
-  background: #e4f1ff;
-  box-shadow: inset 3px 0 0 #60a5fa;
-}
-
-.yaml-step-card.yaml-step-card-active {
-  border-color: #3b82f6;
-  background: #dbeafe;
-  box-shadow: inset 3px 0 0 #2563eb;
-}
-
-.yaml-step-header {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 7px;
-  padding: 8px 10px;
-  border-bottom: 1px solid #edf0f5;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.yaml-step-card:hover .yaml-step-header,
-.yaml-step-card:focus-within .yaml-step-header {
-  border-bottom-color: #cfe2f7;
-  background: #ddecff;
-}
-
-.yaml-step-card.yaml-region-selected .yaml-step-header {
-  border-bottom-color: #bdd7f3;
-  background: #d7eaff;
-}
-
-.yaml-step-card.yaml-step-card-active .yaml-step-header {
-  border-bottom-color: #93c5fd;
-  background: #bfdbfe;
-}
-
-.yaml-step-index {
-  color: #1d4ed8;
-  font-family: Consolas, monospace;
-  font-size: 13px;
-  font-weight: 700;
-}
-
-.yaml-step-card.yaml-region-selected .yaml-step-index,
-.yaml-step-card.yaml-step-card-active .yaml-step-index {
-  color: #0f3f8a;
-}
-
-.yaml-action-name {
-  display: inline-flex;
-  align-items: center;
-  width: fit-content;
-  max-width: 100%;
-  min-height: 22px;
-  min-width: 0;
-  padding: 2px 8px;
-  border: 1px solid #cbd5e1;
-  border-radius: 6px;
-  background: #f8fafc;
-  color: #0f172a;
-  font-family: Consolas, monospace;
-  font-size: 13px;
-  font-weight: 700;
-  overflow-wrap: anywhere;
-}
-
-.yaml-action-name-setup {
-  border-color: #bbf7d0;
-  background: #f0fdf4;
-  color: #166534;
-}
-
-.yaml-action-name-teardown {
-  border-color: #fecaca;
-  background: #fef2f2;
-  color: #991b1b;
-}
-
-.yaml-action-name-assertion {
-  border-color: #fde68a;
-  background: #fffbeb;
-  color: #92400e;
-}
-
-.yaml-action-name-observation {
-  border-color: #bae6fd;
-  background: #f0f9ff;
-  color: #075985;
-}
-
-.yaml-action-name-action {
-  border-color: #bfdbfe;
-  background: #eff6ff;
-  color: #1e40af;
-}
-
-.yaml-param-list {
-  display: grid;
-  gap: 1px;
-  padding: 8px 10px 10px;
-}
-
-.yaml-param-row {
-  display: grid;
-  grid-template-columns: minmax(72px, 34%) minmax(0, 1fr);
-  gap: 8px;
-  padding: 3px 6px;
-  border-radius: 5px;
-  transition: background-color 120ms ease;
-}
-
-.yaml-param-row:hover {
-  background: #eef4fb;
-}
-
-.yaml-param-row.yaml-region-selected {
-  background: #e4eef9;
-}
-
-.yaml-param-nested {
-  margin-left: 12px;
-  padding-left: 10px;
-  border-left: 2px solid #e2e8f0;
-}
-
-.yaml-param-row-nested {
-  grid-template-columns: minmax(86px, 38%) minmax(0, 1fr);
-}
-
-.yaml-param-row-nested .yaml-param-key {
-  color: #64748b;
-  font-weight: 600;
-}
-
-.yaml-param-key {
-  color: #475569;
-  font-family: Consolas, monospace;
-  font-weight: 650;
-  overflow-wrap: anywhere;
-}
-
-.yaml-param-value {
-  min-width: 0;
-  color: #111827;
-  overflow-wrap: anywhere;
-}
-
-.yaml-param-value-object,
-.yaml-param-value-list {
-  font-family: Consolas, monospace;
-  font-size: 11px;
-}
-
-.yaml-param-value-null {
-  color: #64748b;
-  font-style: italic;
-}
-
-.yaml-param-value-secret {
-  color: #7c2d12;
-  font-family: Consolas, monospace;
-  font-weight: 700;
-}
-
-.session-row {
-  display: grid;
-  grid-template-columns: 1fr;
-  gap: 8px;
-}
-
-select,
-input,
-textarea {
-  width: 100%;
-  box-sizing: border-box;
-  border: 1px solid #b8c0cc;
-  border-radius: 6px;
-  padding: 8px;
-  background: #ffffff;
-  color: #15171a;
-}
-
-input {
-  margin-bottom: 8px;
-}
-
-.run-mode-row {
-  display: flex;
-  gap: 14px;
-  margin-bottom: 10px;
-}
-
-.run-mode-row label {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-}
-
-.run-mode-row input {
-  width: auto;
-  margin: 0;
-}
-
-.run-input-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
-  gap: 8px;
-  align-items: start;
-}
-
-.run-input-row textarea {
-  grid-column: 1 / -1;
-}
-
-.run-input-row .yaml-path-row {
-  grid-column: 1 / -1;
-}
-
-.run-input-row #run-selected {
-  grid-column: 1 / -1;
-  justify-self: end;
-  align-self: start;
-}
-
-textarea {
-  resize: vertical;
-  min-height: 120px;
-  margin-bottom: 8px;
-}
-
-.muted {
-  color: #5c6573;
-  font-size: 13px;
-  margin-top: 8px;
-}
-
-.progress-run-id {
-  flex: 0 0 auto;
-  margin-bottom: 8px;
-  border: 1px solid #b8c0cc;
-  border-radius: 6px;
-  background: #eef6ff;
-  color: #0f4c81;
-  padding: 8px 10px;
-  font-family: Consolas, monospace;
-  font-size: 13px;
-  font-weight: 650;
-  overflow-wrap: anywhere;
-  cursor: pointer;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.progress-run-id:hover,
-.progress-run-id:focus-visible {
-  border-color: #93b4d8;
-  background: #ddecff;
-}
-
-.progress-run-id.progress-run-id-selected {
-  border-color: #7aa7d9;
-  background: #dbeafe;
-  box-shadow: inset 3px 0 0 #60a5fa;
-}
-
-.progress-log {
-  flex: 1;
-  min-height: 0;
-  overflow: auto;
-  background: #f8fafc;
-  color: #1f2937;
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  padding: 10px;
-  font-family: Consolas, monospace;
-  font-size: 13px;
-}
-
-.progress-item {
-  display: grid;
-  grid-template-columns: 42px 14px 1fr;
-  align-items: start;
-  gap: 8px;
-  margin: 0 -6px;
-  padding: 6px;
-  border-bottom: 1px solid #e5e9f0;
-  border-radius: 5px;
-  cursor: pointer;
-  transition: background-color 120ms ease, border-color 120ms ease;
-}
-
-.progress-item:hover,
-.progress-item:focus-visible {
-  background: #eef6ff;
-}
-
-.progress-item.progress-item-selected {
-  background: #e4f1ff;
-  box-shadow: inset 3px 0 0 #60a5fa;
-}
-
-.progress-item.progress-item-active {
-  background: #dbeafe;
-  box-shadow: inset 3px 0 0 #2563eb;
-}
-
-.progress-number {
-  color: #1d4ed8;
-  font-variant-numeric: tabular-nums;
-}
-
-.progress-text {
-  min-width: 0;
-  overflow-wrap: anywhere;
-  display: grid;
-  gap: 3px;
-}
-
-.progress-title-row {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 8px;
-  min-width: 0;
-}
-
-.progress-title {
-  color: #111827;
-  font-weight: 650;
-  min-width: 0;
-  overflow-wrap: anywhere;
-}
-
-.progress-message {
-  color: #4b5563;
-  font-size: 12px;
-  line-height: 1.35;
-}
-
-.progress-tool {
-  display: inline-flex;
-  width: fit-content;
-  max-width: 180px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  padding: 1px 7px;
-  border-radius: 999px;
-  background: #dbeafe;
-  color: #1e40af;
-  font-size: 11px;
-  font-weight: 600;
-}
-
-.progress-status-dot {
-  width: 9px;
-  height: 9px;
-  border-radius: 999px;
-  margin-top: 4px;
-  background: #9ca3af;
-  box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.08);
-}
-
-.progress-status-success {
-  background: #22c55e;
-}
-
-.progress-status-failed {
-  background: #ef4444;
-}
-
-.progress-detail {
-  grid-column: 3;
-  margin: 2px 0 6px;
-}
-
-.progress-detail summary {
-  color: #1e3a8a;
-  cursor: pointer;
-  font-weight: 600;
-  margin-bottom: 4px;
-}
-
-.progress-detail pre {
-  max-height: min(52vh, 520px);
-  overflow: auto;
-  margin: 0;
-  padding: 8px;
-  border: 1px solid #cbd5e1;
-  border-radius: 4px;
-  background: #e2e8f0;
-  color: #111827;
-  white-space: pre-wrap;
-  word-break: break-word;
-}
-
-.preview-frame {
-  position: relative;
-  flex: 1;
-  min-height: 360px;
-  display: grid;
-  place-items: center;
-  background: #f8fafc;
-}
-
-.step-artifact-preview {
-  align-self: stretch;
-  justify-self: stretch;
-  height: 100%;
-  min-height: 0;
-  overflow: auto;
-  box-sizing: border-box;
-  background: #f8fafc;
-  color: #1f2937;
-}
-
-.step-artifact-preview[hidden] {
-  display: none;
-}
-
-.step-artifact-shell {
-  display: flex;
-  flex-direction: column;
-  gap: 12px;
-  box-sizing: border-box;
-  min-height: 100%;
-  padding: 16px;
-}
-
-.step-artifact-title {
-  position: sticky;
-  top: 0;
-  z-index: 2;
-  flex: none;
-  margin: -16px -16px 0;
-  padding: 14px 16px;
-  background: #f8fafc;
-  border-bottom: 1px solid #e2e8f0;
-  color: #0f172a;
-  font-size: 16px;
-  font-weight: 750;
-}
-
-.step-artifact-body {
-  display: flex;
-  flex-direction: column;
-  gap: 24px;
-}
-
-.step-artifact-region {
-  min-height: 120px;
-  overflow: auto;
-  box-sizing: border-box;
-  padding: 12px;
-  border: 1px solid #e2e8f0;
-  border-radius: 8px;
-  background: #ffffff;
-}
-
-.step-artifact-region-screenshots {
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  height: min(80vh, 820px);
-  min-height: 340px;
-  overflow: hidden;
-}
-
-.step-artifact-screenshot-scroll {
-  display: flex;
-  flex: 1;
-  min-height: 0;
-  margin-bottom: 8px;
-  overflow-x: scroll;
-  overflow-y: hidden;
-  scrollbar-gutter: stable;
-}
-
-.step-artifact-screenshot-scroll > .step-artifact-section {
-  flex: 0 0 100%;
-  width: 100%;
-  box-sizing: border-box;
-}
-
-.step-artifact-screenshot-border-resizer {
-  position: absolute;
-  z-index: 3;
-  right: 0;
-  bottom: 0;
-  left: 0;
-  height: 10px;
-  cursor: row-resize;
-}
-
-.step-artifact-screenshot-border-resizer:hover {
-  border-bottom: 2px solid #94a3b8;
-}
-
-.step-artifact-region-screenshots .step-artifact-section {
-  display: flex;
-  flex: 1;
-  min-height: 0;
-  flex-direction: column;
-}
-
-.step-artifact-region-screenshots .step-artifact-screenshot-row {
-  flex: 1;
-  min-height: 0;
-  align-items: stretch;
-  grid-template-rows: minmax(0, 1fr);
-}
-
-.step-artifact-region-screenshots .step-artifact-image-card {
-  display: flex;
-  min-height: 0;
-  flex-direction: column;
-}
-
-.step-artifact-region-screenshots .step-artifact-image-card img {
-  flex: 1;
-  min-height: 0;
-  max-height: 100%;
-  object-fit: contain;
-}
-
-.step-artifact-region-screenshots.step-artifact-region-user-sized .step-artifact-section {
-  flex-basis: auto;
-  width: max-content;
-  min-width: 100%;
-}
-
-.step-artifact-region-screenshots.step-artifact-region-user-sized .step-artifact-screenshot-row {
-  width: max-content;
-  min-width: 100%;
-  justify-content: safe center;
-}
-
-.step-artifact-region-screenshots.step-artifact-region-user-sized .step-artifact-screenshot-row.step-artifact-compare {
-  grid-template-columns: var(--shot-card-width) 42px var(--shot-card-width);
-}
-
-.step-artifact-region-screenshots.step-artifact-region-user-sized .step-artifact-screenshot-row:not(.step-artifact-compare) {
-  grid-template-columns: var(--shot-card-width);
-}
-
-.step-artifact-region-text {
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  height: min(68vh, 620px);
-  min-height: 220px;
-  overflow: hidden;
-}
-
-.step-artifact-region-text > .step-artifact-section {
-  display: flex;
-  flex: 1;
-  min-height: 0;
-  flex-direction: column;
-}
-
-.step-artifact-region-text .step-artifact-diff-card {
-  display: flex;
-  flex: 1;
-  min-height: 0;
-  flex-direction: column;
-}
-
-.step-artifact-region-text .step-artifact-diff-body {
-  flex: 1;
-  min-height: 0;
-  height: auto;
-}
-
-.step-artifact-resizer {
-  flex: none;
-  height: 12px;
-  position: relative;
-  cursor: row-resize;
-}
-
-.step-artifact-resizer::before {
-  content: "";
-  position: absolute;
-  left: 50%;
-  top: 50%;
-  width: 46px;
-  height: 4px;
-  border-radius: 999px;
-  background: #cbd5e1;
-  transform: translate(-50%, -50%);
-}
-
-.step-artifact-resizer:hover::before {
-  background: #94a3b8;
-}
-
-.step-artifact-ui-tree-border-resizer {
-  position: absolute;
-  z-index: 3;
-  top: 0;
-  right: 0;
-  left: 0;
-  height: 10px;
-  cursor: row-resize;
-}
-
-.step-artifact-ui-tree-border-resizer:hover {
-  border-top: 2px solid #94a3b8;
-}
-
-.step-artifact-ui-tree-bottom-border-resizer {
-  position: absolute;
-  z-index: 3;
-  right: 0;
-  bottom: 0;
-  left: 0;
-  height: 10px;
-  cursor: row-resize;
-}
-
-.step-artifact-ui-tree-bottom-border-resizer:hover {
-  border-bottom: 2px solid #94a3b8;
-}
-
-body.step-artifact-resizing {
-  cursor: row-resize;
-  user-select: none;
-}
-
-.step-artifact-subtitle,
-.step-artifact-empty,
-.step-artifact-error {
-  color: #64748b;
-  font-size: 13px;
-}
-
-.step-artifact-error {
-  color: #b91c1c;
-}
-
-.step-artifact-section {
-  display: grid;
-  gap: 10px;
-}
-
-.step-artifact-section-title {
-  color: #334155;
-  font-size: 15px;
-  font-weight: 700;
-}
-
-.step-artifact-screenshot-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr);
-  gap: 10px;
-  align-items: center;
-}
-
-.step-artifact-screenshot-row.step-artifact-compare {
-  grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
-}
-
-.step-artifact-image-card,
-.step-artifact-text-card {
-  min-width: 0;
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  background: #f8fafc;
-  overflow: hidden;
-}
-
-.step-artifact-image-card {
-  margin: 0;
-  background: #eef2f7;
-}
-
-.step-artifact-image-label,
-.step-artifact-text-label {
-  padding: 7px 9px;
-  border-bottom: 1px solid #edf0f5;
-  background: #eef6ff;
-  color: #334155;
-  font-family: "Segoe UI", Arial, sans-serif;
-  font-size: 12px;
-  font-weight: 800;
-}
-
-.step-artifact-image-card img {
-  display: block;
-  width: 100%;
-  max-height: min(42vh, 440px);
-  object-fit: contain;
-  background: #eef2f7;
-}
-
-.step-artifact-connector {
-  position: relative;
-  align-self: center;
-  justify-self: center;
-  width: 42px;
-  height: 18px;
-}
-
-.step-artifact-connector::before {
-  content: "";
-  position: absolute;
-  top: 50%;
-  left: 2px;
-  right: 7px;
-  height: 1px;
-  border-radius: 999px;
-  background: #94a3b8;
-  transform: translateY(-50%);
-}
-
-.step-artifact-connector::after {
-  content: "";
-  position: absolute;
-  top: 50%;
-  right: 3px;
-  width: 8px;
-  height: 8px;
-  border-top: 1.5px solid #64748b;
-  border-right: 1.5px solid #64748b;
-  transform: translateY(-50%) rotate(45deg);
-}
-
-.step-artifact-text-card pre {
-  max-height: min(34vh, 340px);
-  overflow: auto;
-  margin: 0;
-  padding: 12px 14px;
-  border-left: 3px solid #bfdbfe;
-  background: #f8fbff;
-  color: #0f172a;
-  white-space: pre;
-  word-break: normal;
-  font-family: Consolas, monospace;
-  font-size: 12px;
-  line-height: 1.55;
-  tab-size: 2;
-}
-
-.step-artifact-text-card pre.step-artifact-xml {
-  border-left-color: #86efac;
-  background: #f7fdf9;
-  color: #14532d;
-  line-height: 1.5;
-}
-
-.step-artifact-diff-card {
-  min-width: 0;
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  background: #ffffff;
-  overflow: hidden;
-}
-
-.step-artifact-diff-body {
-  display: flex;
-  flex-direction: column;
-  height: min(60vh, 540px);
-  min-height: 200px;
-  overflow: hidden;
-  background: #f8fafc;
-  font-family: Consolas, monospace;
-  font-size: 12px;
-  line-height: 1.5;
-}
-
-.step-artifact-diff-empty {
-  padding: 2px 8px;
-  color: #475569;
-}
-
-.step-artifact-diff-split {
-  display: flex;
-  flex: 1 1 auto;
-  min-width: 0;
-  align-items: stretch;
-}
-
-.step-artifact-diff-scroll {
-  display: flex;
-  align-items: stretch;
-  flex: 1;
-  min-height: 0;
-}
-
-.step-artifact-diff-overview {
-  position: relative;
-  flex: 0 0 14px;
-  border-left: 1px solid #d8dee8;
-  background: #f1f5f9;
-  cursor: pointer;
-}
-
-.step-artifact-diff-overview-marker {
-  position: absolute;
-  left: 2px;
-  right: 2px;
-  min-height: 3px;
-  margin: 0;
-  padding: 0;
-  border: 0;
-  border-radius: 1px;
-  cursor: pointer;
-}
-
-.step-artifact-diff-overview-added {
-  background: #22c55e;
-}
-
-.step-artifact-diff-overview-removed {
-  background: #ef4444;
-}
-
-.step-artifact-diff-pane {
-  flex: 1 1 50%;
-  min-width: 0;
-  min-height: 0;
-  overflow: auto;
-}
-
-.step-artifact-diff-pane + .step-artifact-diff-pane {
-  border-left: 1px solid #d8dee8;
-}
-
-.step-artifact-diff-column {
-  width: max-content;
-  min-width: 100%;
-}
-
-.step-artifact-diff-row {
-  display: flex;
-  white-space: pre;
-}
-
-.step-artifact-diff-headrow {
-  position: sticky;
-  top: 0;
-  z-index: 1;
-}
-
-.step-artifact-diff-number {
-  flex: 0 0 44px;
-  padding: 2px 8px;
-  border-right: 1px solid #e5e9f0;
-  color: #64748b;
-  text-align: right;
-  user-select: none;
-}
-
-.step-artifact-diff-text {
-  flex: 1 0 auto;
-  padding: 2px 8px;
-}
-
-.diff-pane-after .step-artifact-diff-line-added .step-artifact-diff-number,
-.diff-pane-after .step-artifact-diff-line-added .step-artifact-diff-text {
-  background: #dcfce7;
-}
-
-.diff-pane-before .step-artifact-diff-line-removed .step-artifact-diff-number,
-.diff-pane-before .step-artifact-diff-line-removed .step-artifact-diff-text {
-  background: #fee2e2;
-}
-
-.diff-pane-before .step-artifact-diff-line-removed .step-artifact-diff-inline-change {
-  background: #fca5a5;
-}
-
-.diff-pane-after .step-artifact-diff-line-added .step-artifact-diff-inline-change {
-  background: #86efac;
-}
-
-.step-artifact-diff-inline-change {
-  border-radius: 2px;
-  font: inherit;
-}
-
-.step-artifact-diff-line-added {
-  color: #14532d;
-}
-
-.step-artifact-diff-line-removed {
-  color: #7f1d1d;
-}
-
-.step-artifact-diff-line-context {
-  color: #475569;
-}
-
-.step-artifact-diff-line-omitted {
-  color: #64748b;
-  background: #f1f5f9;
-}
-
-.tab-pane {
-  min-height: 0;
-}
-
-.progress-pane {
-  flex: 1;
-  min-height: 0;
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-  box-sizing: border-box;
-  padding: 16px;
-  background: #ffffff;
-}
-
-.execution-section .progress-pane {
-  padding: 0;
-  background: transparent;
-}
-
-.report-pane {
-  flex: 1;
-  overflow: hidden;
-  background: #f8fafc;
-}
-
-.report-content {
-  height: 100%;
-  overflow: auto;
-  box-sizing: border-box;
-  margin: 0;
-  padding: 20px 24px;
-  color: #1f2937;
-  word-break: break-word;
-  font-family: "Segoe UI", Arial, sans-serif;
-  font-size: 14px;
-  line-height: 1.55;
-}
-
-.report-content h1,
-.report-content h2,
-.report-content h3,
-.report-content h4 {
-  color: #0f172a;
-  margin: 16px 0 8px;
-}
-
-.report-content h1 {
-  font-size: 22px;
-}
-
-.report-content h2 {
-  font-size: 18px;
-}
-
-.report-content p {
-  margin: 8px 0;
-}
-
-.report-content ul {
-  margin: 8px 0;
-  padding-left: 22px;
-}
-
-.report-content li {
-  margin: 4px 0;
-}
-
-.report-content code {
-  border-radius: 4px;
-  background: #e2e8f0;
-  color: #0f172a;
-  padding: 1px 5px;
-  font-family: Consolas, monospace;
-  font-size: 13px;
-}
-
-.report-content pre {
-  overflow: auto;
-  border: 1px solid #cbd5e1;
-  border-radius: 6px;
-  background: #eef2f7;
-  padding: 12px;
-}
-
-.report-content pre code {
-  background: transparent;
-  padding: 0;
-}
-
-#screenshot,
-#replay-video {
-  display: none;
-  max-width: 100%;
-  max-height: calc(100vh - 150px);
-  object-fit: contain;
-}
-
-#preview-empty {
-  color: #64748b;
-}
-
-@media (max-width: 900px) {
-  .shell {
-    grid-template-columns: 1fr;
-    height: auto;
-    min-height: 100vh;
-    overflow: visible;
-  }
-
-  body {
-    height: auto;
-    overflow: auto;
-  }
-
-  .panel-resizer {
-    display: none;
-  }
-
-  .preview-panel {
-    min-height: min(680px, 82vh);
-    height: auto;
-  }
-
-  .progress-pane,
-  .report-pane {
-    min-height: min(520px, 68vh);
-  }
-
-}
diff --git a/frontend/playground/playground.js b/frontend/playground/playground.js
deleted file mode 100644
index accc39e4..00000000
--- a/frontend/playground/playground.js
+++ /dev/null
@@ -1,3378 +0,0 @@
-import EBML from 'ts-ebml/dist/EBML.js';
-import LifecycleEditorModel from './lifecycle-editor-model.js';
-
-const { Decoder, Reader, tools: ebmlTools } = EBML;
-
-const state = {
-  currentRequestId: null,
-  progressTimer: null,
-  progressStream: null,
-  progressScrollScheduled: false,
-  replayRequestId: null,
-  previewToken: null,
-  pendingReplayVideoCleanup: null,
-  replayVideoInFlight: false,
-  progressSequence: 0,
-  lastProgressSequence: 0,
-  progressDetailOpenState: new Map(),
-  selectedProgressItem: null,
-  activeProgressItem: null,
-  activeProgressItemClearTimer: null,
-  selectedProgressRunId: false,
-  finishingRun: false,
-  loadedRunId: null,
-  loadedRunAvailability: null,
-  loadRunInFlight: false,
-  activeRunMode: 'goal',
-  modeStates: {
-    goal: createRunModeState(),
-    yaml: createRunModeState(),
-    'strict-yaml': createRunModeState(),
-  },
-  yamlActiveView: 'input',
-  yamlInputContent: '',
-  yamlRecordedContent: '',
-  yamlInputDisplay: null,
-  yamlInputRevision: '',
-  yamlInputEditable: false,
-  yamlLifecycleSnapshot: null,
-  yamlLifecycleDraft: null,
-  yamlLifecycleDirty: false,
-  yamlLifecycleSaving: false,
-  yamlRecordedDisplay: null,
-  yamlInputLastPreviewPath: '',
-  selectedYamlRegion: null,
-  selectedYamlStepCard: null,
-  selectedYamlCaseSummary: null,
-  selectedYamlCaseTitle: null,
-  activeYamlStepCard: null,
-  activeYamlStepClearTimer: null,
-  stepArtifactPreviewActive: false,
-  stepArtifactStepKey: null,
-  currentExecutionMode: null,
-  platformId: null,
-  platformLabel: null,
-  toastTimer: null,
-};
-
-function createRunModeState() {
-  return {
-    caseYamlValue: '',
-    progressHtml: '',
-    progressRunIdText: '',
-    progressRunIdValue: '',
-    progressRunIdHidden: true,
-    progressSequence: 0,
-    lastProgressSequence: 0,
-    progressDetailOpenEntries: [],
-    yamlActiveView: '',
-    yamlInputContent: '',
-    yamlInputDisplay: null,
-    yamlInputRevision: '',
-    yamlInputEditable: false,
-    yamlLifecycleSnapshot: null,
-    yamlLifecycleDraft: null,
-    yamlLifecycleDirty: false,
-    yamlInputLastPreviewPath: '',
-    yamlInputStatusText: '',
-    yamlInputStatusClassName: 'yaml-status yaml-status-neutral',
-    yamlInputStatusHidden: true,
-    yamlInputHtml: '',
-    yamlRecordedContent: '',
-    yamlRecordedDisplay: null,
-    yamlRecordedStatusText: '',
-    yamlRecordedStatusClassName: 'yaml-status yaml-status-neutral',
-    yamlRecordedStatusHidden: true,
-    yamlRecordedHtml: '',
-    rightActiveTab: 'preview',
-    reportHtml: '',
-    replayRequestId: null,
-    previewToken: null,
-    replayVideoSrc: '',
-    replayVideoHidden: true,
-    replayVideoDisplay: 'none',
-    screenshotSrc: '',
-    screenshotDisplay: 'none',
-    previewEmptyText: '',
-    previewEmptyDisplay: '',
-    stepArtifactPreviewActive: false,
-    stepArtifactStepKey: null,
-    stepArtifactHidden: true,
-    stepArtifactNodes: [],
-  };
-}
-
-const REPLAY_FAST_SAME_EVENT_DELAY_MS = 250;
-const REPLAY_FAST_ACTION_DELAY_MS = 900;
-const REPLAY_FAST_MAX_DELAY_MS = 1500;
-const REPLAY_FAST_FALLBACK_DELAY_MS = 500;
-const REPLAY_FAST_FINAL_FRAME_HOLD_MS = 700;
-const REPLAY_FAST_TIME_SCALE = 10;
-const PROGRESS_POLL_INTERVAL_MS = 750;
-const CONTROL_PANEL_WIDTH_STORAGE_KEY = 'fsqPlayground.controlPanelWidth';
-const CONTROL_PANEL_MIN_WIDTH = 300;
-const CONTROL_PANEL_MAX_WIDTH = 720;
-const PREVIEW_PANEL_MIN_WIDTH = 360;
-const YAML_SELECTABLE_REGION_SELECTOR = '.yaml-param-row, .yaml-metadata-item, .yaml-step-card, .yaml-case-title-row, .yaml-case-summary';
-const YAML_STEP_CENTER_TOLERANCE_RATIO = 0.15;
-
-const els = {
-  shell: document.querySelector('.shell'),
-  toast: document.getElementById('toast'),
-  controlPanel: document.querySelector('.control-panel'),
-  panelResizer: document.getElementById('panel-resizer'),
-  status: document.getElementById('server-status'),
-  refresh: document.getElementById('refresh'),
-  sessionSection: document.getElementById('session-section'),
-  deviceSelect: document.getElementById('device-select'),
-  sessionMessage: document.getElementById('session-message'),
-  goal: document.getElementById('goal'),
-  caseYaml: document.getElementById('case-yaml'),
-  yamlPathRow: document.getElementById('yaml-path-row'),
-  executionSection: document.getElementById('execution-section'),
-  loadRunToggle: document.getElementById('load-run-toggle'),
-  loadRunForm: document.getElementById('load-run-form'),
-  loadRunPath: document.getElementById('load-run-path'),
-  loadRunSubmit: document.getElementById('load-run-submit'),
-  loadRunCancel: document.getElementById('load-run-cancel'),
-  loadRunStatus: document.getElementById('load-run-status'),
-  yamlTabs: document.querySelector('.yaml-tabs'),
-  yamlInputTab: document.getElementById('yaml-input-tab'),
-  yamlRecordedTab: document.getElementById('yaml-recorded-tab'),
-  yamlProgressTab: document.getElementById('yaml-progress-tab'),
-  yamlInputPane: document.getElementById('yaml-input-pane'),
-  yamlRecordedPane: document.getElementById('yaml-recorded-pane'),
-  yamlInputStatus: document.getElementById('yaml-input-status'),
-  yamlLifecycleToolbar: document.getElementById('yaml-lifecycle-toolbar'),
-  yamlLifecycleDirty: document.getElementById('yaml-lifecycle-dirty'),
-  yamlLifecycleSave: document.getElementById('yaml-lifecycle-save'),
-  yamlLifecycleDiscard: document.getElementById('yaml-lifecycle-discard'),
-  yamlRecordedStatus: document.getElementById('yaml-recorded-status'),
-  yamlInputViewer: document.getElementById('yaml-input-viewer'),
-  yamlRecordedViewer: document.getElementById('yaml-recorded-viewer'),
-  runSelected: document.getElementById('run-selected'),
-  runModeInputs: Array.from(document.querySelectorAll('input[name="run-mode"]')),
-  progressRunId: document.getElementById('progress-run-id'),
-  progress: document.getElementById('progress'),
-  replayVideo: document.getElementById('replay-video'),
-  screenshot: document.getElementById('screenshot'),
-  previewEmpty: document.getElementById('preview-empty'),
-  previewTab: document.getElementById('preview-tab'),
-  reportTab: document.getElementById('report-tab'),
-  previewPane: document.getElementById('preview-pane'),
-  progressPane: document.getElementById('progress-pane'),
-  reportPane: document.getElementById('report-pane'),
-  reportContent: document.getElementById('report-content'),
-  stepArtifactPreview: document.getElementById('step-artifact-preview'),
-};
-
-async function api(path, options = {}) {
-  const response = await fetch(path, {
-    ...options,
-    headers: {
-      'Content-Type': 'application/json',
-      ...(options.headers || {}),
-    },
-  });
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(data.error || `${response.status} ${response.statusText}`);
-  }
-  return data;
-}
-
-async function refreshAll() {
-  await refreshRuntime();
-  await refreshStatus();
-  if (platformRequiresSession()) {
-    await refreshSetup();
-    const sessionReady = await autoCreateSessionIfPossible({ silent: true });
-    if (sessionReady) await refreshStatus();
-  }
-}
-
-function clearPage() {
-  if (state.currentRequestId) return;
-  stopProgressUpdates();
-  resetRunModeStates();
-  state.replayRequestId = null;
-  state.previewToken = null;
-  state.currentRequestId = null;
-  state.progressSequence = 0;
-  state.lastProgressSequence = 0;
-  state.progressDetailOpenState.clear();
-  state.currentExecutionMode = null;
-  state.finishingRun = false;
-  state.loadedRunId = null;
-  state.loadedRunAvailability = null;
-  clearStepArtifactPreview();
-  resetLoadRunForm({ collapse: true });
-  hideToast();
-
-  els.goal.value = '';
-  els.caseYaml.value = '';
-  clearYamlInput();
-  clearRecordedYaml();
-  clearRunId();
-  clearActiveProgressItem();
-  clearSelectedProgressItem();
-  els.progress.innerHTML = '';
-  els.reportContent.textContent = '';
-  clearPreview();
-  setRunButtonIdle();
-
-  const goalMode = els.runModeInputs.find((input) => input.value === 'goal');
-  if (goalMode) goalMode.checked = true;
-  updateRunMode();
-  showRightTab('preview');
-  refreshStatus();
-}
-
-async function refreshStatus() {
-  try {
-    const status = await api('/status');
-    setServerStatus(status.busy ? 'Running' : 'Ready', status.busy ? 'running' : 'ready');
-    els.deviceSelect.disabled = Boolean(state.currentRequestId || state.finishingRun || status.busy);
-    if (state.currentRequestId) {
-      setRunButtonCancel();
-    } else if (state.finishingRun) {
-      setRunButtonCancel({ disabled: true });
-    } else {
-      setRunButtonIdle({ disabled: Boolean(status.busy) });
-    }
-    setLoadRunControlsDisabled(Boolean(status.busy));
-    if (platformRequiresSession() && status.session?.connected) {
-      els.sessionMessage.textContent = `Connected to ${status.session.displayName || status.session.deviceId}`;
-    } else if (platformRequiresSession()) {
-      els.sessionMessage.textContent = 'No active session.';
-    }
-  } catch (error) {
-    setServerStatus(error.message, 'error');
-  }
-}
-
-function setServerStatus(text, status) {
-  els.status.textContent = text;
-  els.status.className = `status-pill status-${status}`;
-}
-
-async function refreshSetup() {
-  try {
-    const setup = await api('/session/setup');
-    const options = setup.targets || [];
-    els.deviceSelect.innerHTML = '';
-    for (const target of options) {
-      const option = document.createElement('option');
-      option.value = target.id;
-      option.textContent = target.description ? `${target.label} (${target.description})` : target.label;
-      if (target.isDefault || setup.fields?.[0]?.defaultValue === target.id) option.selected = true;
-      els.deviceSelect.appendChild(option);
-    }
-    if (setup.notice) {
-      els.sessionMessage.textContent = `${setup.notice.message}: ${setup.notice.description || ''}`;
-    }
-  } catch (error) {
-    els.sessionMessage.textContent = error.message;
-  }
-}
-
-async function refreshRuntime() {
-  try {
-    const runtime = await api('/runtime-info');
-    state.platformId = runtime.platformId || null;
-    state.platformLabel = runtime.interface?.type || (runtime.platformId ? capitalize(runtime.platformId) : null);
-    updateSessionVisibility();
-    return runtime;
-  } catch (error) {
-    setServerStatus(error.message, 'error');
-    return null;
-  }
-}
-
-function platformRequiresSession() {
-  return state.platformId === 'android';
-}
-
-function updateSessionVisibility() {
-  els.sessionSection.hidden = !platformRequiresSession();
-  if (!platformRequiresSession()) els.sessionMessage.textContent = '';
-}
-
-function capitalize(value) {
-  return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
-}
-
-async function autoCreateSessionIfPossible({ silent = false } = {}) {
-  try {
-    const session = await api('/session');
-    if (session.connected) return true;
-    const result = await api('/session/auto', { method: 'POST', body: JSON.stringify({}) });
-    if (!silent) {
-      els.sessionMessage.textContent = `Connected to ${result.session.displayName || result.session.deviceId}`;
-    } else if (result.session?.connected) {
-      els.sessionMessage.textContent = `Connected to ${result.session.displayName || result.session.deviceId}`;
-    }
-    return true;
-  } catch (error) {
-    els.sessionMessage.textContent = error.message;
-    return false;
-  }
-}
-
-async function ensureSession() {
-  if (!platformRequiresSession()) return true;
-  try {
-    const session = await api('/session');
-    if (session.connected) return true;
-  } catch (error) {
-    els.sessionMessage.textContent = error.message;
-    return false;
-  }
-  if (await autoCreateSessionIfPossible()) return true;
-  if (els.deviceSelect.value) {
-    els.sessionMessage.textContent = 'Automatic session selection is required before running.';
-  }
-  return false;
-}
-
-async function runGoal() {
-  const goal = els.goal.value.trim();
-  if (!goal) return;
-  await startExecution({ goal });
-}
-
-async function runYaml() {
-  const caseYamlPath = els.caseYaml.value.trim();
-  if (!caseYamlPath) return;
-  if (currentRunMode() === 'strict-yaml') {
-    await startExecution({ strictCaseYamlPath: caseYamlPath });
-    return;
-  }
-  await startExecution({ caseYamlPath });
-}
-
-async function runSelected() {
-  if (state.currentRequestId) {
-    await cancelExecution();
-    return;
-  }
-  if (hasUnsavedLifecycleDraft()) {
-    showYamlView('input');
-    setYamlInputStatus('Save or discard lifecycle changes before running.', 'error');
-    return;
-  }
-  if (currentRunMode() === 'yaml' || currentRunMode() === 'strict-yaml') {
-    await runYaml();
-    return;
-  }
-  await runGoal();
-}
-
-function currentRunMode() {
-  return els.runModeInputs.find((input) => input.checked)?.value || 'goal';
-}
-
-function currentModeState(mode = state.activeRunMode) {
-  return state.modeStates[mode] || state.modeStates.goal;
-}
-
-function resetRunModeStates() {
-  state.modeStates = {
-    goal: createRunModeState(),
-    yaml: createRunModeState(),
-    'strict-yaml': createRunModeState(),
-  };
-}
-
-function saveRunModeState(mode = state.activeRunMode) {
-  const modeState = currentModeState(mode);
-  captureProgressDetailState();
-  modeState.caseYamlValue = els.caseYaml.value;
-  modeState.progressHtml = els.progress.innerHTML;
-  modeState.progressRunIdText = els.progressRunId.textContent;
-  modeState.progressRunIdValue = els.progressRunId.dataset.runId || '';
-  modeState.progressRunIdHidden = els.progressRunId.hidden;
-  modeState.progressSequence = state.progressSequence;
-  modeState.lastProgressSequence = state.lastProgressSequence;
-  modeState.progressDetailOpenEntries = Array.from(state.progressDetailOpenState.entries());
-  modeState.yamlActiveView = state.yamlActiveView;
-  modeState.yamlInputContent = state.yamlInputContent;
-  modeState.yamlInputDisplay = state.yamlInputDisplay;
-  modeState.yamlInputRevision = state.yamlInputRevision;
-  modeState.yamlInputEditable = state.yamlInputEditable;
-  modeState.yamlLifecycleSnapshot = cloneLifecycle(state.yamlLifecycleSnapshot);
-  modeState.yamlLifecycleDraft = cloneLifecycle(state.yamlLifecycleDraft);
-  modeState.yamlLifecycleDirty = state.yamlLifecycleDirty;
-  modeState.yamlInputLastPreviewPath = state.yamlInputLastPreviewPath;
-  modeState.yamlInputStatusText = els.yamlInputStatus.textContent;
-  modeState.yamlInputStatusClassName = els.yamlInputStatus.className;
-  modeState.yamlInputStatusHidden = els.yamlInputStatus.hidden;
-  modeState.yamlInputHtml = els.yamlInputViewer.innerHTML;
-  modeState.yamlRecordedContent = state.yamlRecordedContent;
-  modeState.yamlRecordedDisplay = state.yamlRecordedDisplay;
-  modeState.yamlRecordedStatusText = els.yamlRecordedStatus.textContent;
-  modeState.yamlRecordedStatusClassName = els.yamlRecordedStatus.className;
-  modeState.yamlRecordedStatusHidden = els.yamlRecordedStatus.hidden;
-  modeState.yamlRecordedHtml = els.yamlRecordedViewer.innerHTML;
-  modeState.rightActiveTab = els.reportTab.classList.contains('active') ? 'report' : 'preview';
-  modeState.reportHtml = els.reportContent.innerHTML;
-  modeState.replayRequestId = state.replayRequestId;
-  modeState.previewToken = state.previewToken;
-  modeState.replayVideoSrc = els.replayVideo.getAttribute('src') || '';
-  modeState.replayVideoHidden = els.replayVideo.hidden;
-  modeState.replayVideoDisplay = els.replayVideo.style.display;
-  modeState.screenshotSrc = els.screenshot.getAttribute('src') || '';
-  modeState.screenshotDisplay = els.screenshot.style.display;
-  modeState.previewEmptyText = els.previewEmpty.textContent;
-  modeState.previewEmptyDisplay = els.previewEmpty.style.display;
-  modeState.stepArtifactPreviewActive = state.stepArtifactPreviewActive;
-  modeState.stepArtifactStepKey = state.stepArtifactStepKey;
-  modeState.stepArtifactHidden = els.stepArtifactPreview.hidden;
-  modeState.stepArtifactNodes = Array.from(els.stepArtifactPreview.childNodes);
-}
-
-function restoreRunModeState(mode = state.activeRunMode) {
-  const modeState = currentModeState(mode);
-  els.caseYaml.value = modeState.caseYamlValue;
-  els.progress.innerHTML = modeState.progressHtml;
-  els.progressRunId.textContent = modeState.progressRunIdText;
-  if (modeState.progressRunIdValue) {
-    els.progressRunId.dataset.runId = modeState.progressRunIdValue;
-  } else {
-    delete els.progressRunId.dataset.runId;
-  }
-  els.progressRunId.hidden = modeState.progressRunIdHidden;
-  state.progressSequence = modeState.progressSequence;
-  state.lastProgressSequence = modeState.lastProgressSequence;
-  state.progressDetailOpenState = new Map(modeState.progressDetailOpenEntries);
-  state.yamlInputContent = modeState.yamlInputContent;
-  state.yamlInputDisplay = modeState.yamlInputDisplay;
-  state.yamlInputRevision = modeState.yamlInputRevision;
-  state.yamlInputEditable = modeState.yamlInputEditable;
-  state.yamlLifecycleSnapshot = cloneLifecycle(modeState.yamlLifecycleSnapshot);
-  state.yamlLifecycleDraft = cloneLifecycle(modeState.yamlLifecycleDraft);
-  state.yamlLifecycleDirty = modeState.yamlLifecycleDirty;
-  state.yamlInputLastPreviewPath = modeState.yamlInputLastPreviewPath;
-  els.yamlInputStatus.textContent = modeState.yamlInputStatusText;
-  els.yamlInputStatus.className = modeState.yamlInputStatusClassName;
-  els.yamlInputStatus.hidden = modeState.yamlInputStatusHidden;
-  renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'No YAML loaded.', { lifecycleEditor: state.yamlInputEditable });
-  state.yamlRecordedContent = modeState.yamlRecordedContent;
-  state.yamlRecordedDisplay = modeState.yamlRecordedDisplay;
-  els.yamlRecordedStatus.textContent = modeState.yamlRecordedStatusText;
-  els.yamlRecordedStatus.className = modeState.yamlRecordedStatusClassName;
-  els.yamlRecordedStatus.hidden = modeState.yamlRecordedStatusHidden;
-  els.yamlRecordedViewer.innerHTML = modeState.yamlRecordedHtml;
-  state.yamlActiveView = modeState.yamlActiveView || defaultYamlViewForMode(mode);
-  stripTransientModeClasses();
-  bindProgressDetailToggles();
-  clearSelectedYamlRegion();
-  clearActiveYamlStepCard();
-  clearSelectedProgressRunId();
-  clearSelectedProgressItem();
-  clearActiveProgressItem();
-  cancelPendingReplayVideoReadyWait();
-  els.replayVideo.pause();
-  els.reportContent.innerHTML = modeState.reportHtml;
-  state.replayRequestId = modeState.replayRequestId;
-  state.previewToken = modeState.previewToken;
-  if (modeState.replayVideoSrc) {
-    els.replayVideo.src = modeState.replayVideoSrc;
-  } else {
-    els.replayVideo.removeAttribute('src');
-  }
-  els.replayVideo.hidden = modeState.replayVideoHidden;
-  els.replayVideo.style.display = modeState.replayVideoDisplay;
-  if (modeState.screenshotSrc) {
-    els.screenshot.src = modeState.screenshotSrc;
-  } else {
-    els.screenshot.removeAttribute('src');
-  }
-  els.screenshot.style.display = modeState.screenshotDisplay;
-  els.previewEmpty.textContent = modeState.previewEmptyText;
-  els.previewEmpty.style.display = modeState.previewEmptyDisplay;
-  state.stepArtifactPreviewActive = modeState.stepArtifactPreviewActive;
-  state.stepArtifactStepKey = modeState.stepArtifactStepKey;
-  els.stepArtifactPreview.hidden = modeState.stepArtifactHidden;
-  els.stepArtifactPreview.replaceChildren(...modeState.stepArtifactNodes);
-  showRightTab(modeState.rightActiveTab);
-  updateLifecycleToolbar();
-}
-
-function stripTransientModeClasses() {
-  els.yamlInputViewer.querySelectorAll('.yaml-region-selected, .yaml-step-card-active')
-    .forEach((element) => element.classList.remove('yaml-region-selected', 'yaml-step-card-active'));
-  els.yamlRecordedViewer.querySelectorAll('.yaml-region-selected, .yaml-step-card-active')
-    .forEach((element) => element.classList.remove('yaml-region-selected', 'yaml-step-card-active'));
-  els.progress.querySelectorAll('.progress-item-selected, .progress-item-active')
-    .forEach((element) => element.classList.remove('progress-item-selected', 'progress-item-active'));
-}
-
-function bindProgressDetailToggles() {
-  for (const detail of els.progress.querySelectorAll('.progress-detail[data-detail-key]')) {
-    detail.addEventListener('toggle', () => {
-      state.progressDetailOpenState.set(detail.dataset.detailKey, detail.open);
-    });
-  }
-}
-
-function defaultYamlViewForMode(mode) {
-  if (mode === 'strict-yaml') return 'input';
-  return 'progress';
-}
-
-function switchRunMode() {
-  if (state.currentRequestId || state.finishingRun) return;
-  if (state.loadedRunId) {
-    saveRunModeState(state.activeRunMode);
-    const mode = currentRunMode();
-    state.activeRunMode = mode;
-    restoreRunModeState(mode);
-    updateRunMode({ preserveView: true });
-    return;
-  }
-  saveRunModeState(state.activeRunMode);
-  state.activeRunMode = currentRunMode();
-  restoreRunModeState(state.activeRunMode);
-  updateRunMode({ preserveView: true });
-}
-
-function updateRunMode({ preserveView = false } = {}) {
-  const mode = currentRunMode();
-  const hasInputYaml = mode === 'yaml' || mode === 'strict-yaml';
-  const loadRunAvailable = mode === 'goal';
-  els.goal.hidden = hasInputYaml;
-  els.yamlPathRow.hidden = !hasInputYaml;
-  els.loadRunToggle.hidden = !loadRunAvailable;
-  if (!loadRunAvailable && !els.loadRunForm.hidden) resetLoadRunForm({ collapse: true });
-  els.caseYaml.disabled = !hasInputYaml || Boolean(state.currentRequestId);
-  for (const input of els.runModeInputs) input.disabled = Boolean(state.currentRequestId || state.finishingRun);
-  els.executionSection.hidden = false;
-  els.yamlTabs.hidden = false;
-  els.yamlProgressTab.hidden = false;
-  syncYamlTabOrder(mode);
-  const targetView = preserveView ? state.yamlActiveView : defaultYamlViewForMode(mode);
-  if (loadedRunIsActive()) {
-    els.yamlInputTab.hidden = true;
-    els.yamlRecordedTab.hidden = !state.loadedRunAvailability?.recordedYaml;
-    showYamlView(targetView);
-  } else if (mode === 'goal') {
-    els.yamlInputTab.hidden = true;
-    els.yamlRecordedTab.hidden = false;
-    showYamlView(targetView);
-  } else if (mode === 'strict-yaml') {
-    els.yamlInputTab.hidden = false;
-    els.yamlRecordedTab.hidden = true;
-    showYamlView(targetView);
-  } else {
-    els.yamlInputTab.hidden = false;
-    els.yamlRecordedTab.hidden = false;
-    showYamlView(targetView);
-  }
-  if (!state.currentRequestId && !state.finishingRun) setRunButtonIdle();
-  setLoadRunControlsDisabled();
-  updateLifecycleToolbar();
-}
-
-function syncYamlTabOrder(mode) {
-  const tabs = mode === 'goal' || mode === 'yaml'
-    ? [els.yamlProgressTab, els.yamlInputTab, els.yamlRecordedTab]
-    : [els.yamlInputTab, els.yamlRecordedTab, els.yamlProgressTab];
-  for (const tab of tabs) els.yamlTabs.appendChild(tab);
-}
-
-async function startExecution(payload) {
-  if (!(await ensureSession())) return;
-  if (state.loadedRunId) {
-    state.activeRunMode = currentRunMode();
-    restoreRunModeState(state.activeRunMode);
-  }
-  state.loadedRunId = null;
-  state.loadedRunAvailability = null;
-  resetLoadRunForm({ collapse: true });
-  state.activeRunMode = currentRunMode();
-  state.currentExecutionMode = payload.strictCaseYamlPath ? 'strict-yaml' : (payload.caseYamlPath ? 'yaml' : 'goal');
-  state.progressSequence = 0;
-  state.lastProgressSequence = 0;
-  state.progressDetailOpenState.clear();
-  state.replayRequestId = null;
-  clearStepArtifactPreview();
-  clearRecordedYaml();
-  clearRunId();
-  clearActiveProgressItem();
-  clearSelectedProgressItem();
-  els.progress.innerHTML = '';
-  els.reportContent.textContent = 'No report yet.';
-  clearPreview('Loading live preview...');
-  highlightRunStartSummary();
-  els.refresh.disabled = true;
-  els.deviceSelect.disabled = true;
-  try {
-    const result = await api('/execute', { method: 'POST', body: JSON.stringify(payload) });
-    state.currentRequestId = result.requestId;
-    state.finishingRun = false;
-    state.replayRequestId = result.requestId;
-    setRunButtonCancel();
-    updateRunMode();
-    startProgressPolling();
-    await refreshStatus();
-  } catch (error) {
-    state.currentExecutionMode = null;
-    state.finishingRun = false;
-    els.refresh.disabled = false;
-    els.deviceSelect.disabled = false;
-    updateRunMode();
-    appendProgress(`Error: ${error.message}`);
-  }
-}
-
-function highlightRunStartSummary() {
-  if (state.currentExecutionMode !== 'strict-yaml') return;
-  const title = els.yamlInputViewer.querySelector('.yaml-case-title-row');
-  if (title) {
-    selectYamlRegion(title);
-    return;
-  }
-  const summary = els.yamlInputViewer.querySelector('.yaml-case-summary');
-  if (summary) selectYamlRegion(summary);
-}
-
-async function cancelExecution() {
-  const requestId = state.currentRequestId;
-  if (!requestId) return;
-  setRunButtonCancel({ disabled: true });
-  try {
-    const progress = await api(`/cancel/${encodeURIComponent(requestId)}`, { method: 'POST', body: JSON.stringify({}) });
-    stopProgressUpdates();
-    appendProgress('Cancelled by user', null, [], 'failed');
-    state.currentRequestId = null;
-    state.currentExecutionMode = null;
-    state.finishingRun = false;
-    state.replayRequestId = progress.result?.runId || progress.runId || state.replayRequestId;
-    setRunButtonIdle();
-    updateRunMode();
-    await refreshStatus();
-  } catch (error) {
-    appendProgress(`Cancel error: ${error.message}`, null, [], 'failed');
-    setRunButtonCancel();
-  }
-}
-
-function setRunButtonCancel({ disabled = false } = {}) {
-  els.runSelected.textContent = 'Cancel';
-  els.runSelected.classList.remove('primary');
-  els.runSelected.classList.add('secondary-button');
-  els.runSelected.disabled = disabled;
-}
-
-function setRunButtonIdle({ disabled = false } = {}) {
-  els.runSelected.textContent = 'Run';
-  els.runSelected.classList.add('primary');
-  els.runSelected.classList.remove('secondary-button');
-  els.runSelected.disabled = disabled;
-}
-
-function startProgressPolling() {
-  stopProgressUpdates();
-  if (window.EventSource) {
-    const requestId = state.currentRequestId;
-    const stream = new EventSource(`/task-stream/${encodeURIComponent(requestId)}`);
-    state.progressStream = stream;
-    stream.onmessage = (event) => {
-      try {
-        applyProgress(JSON.parse(event.data));
-      } catch (error) {
-        appendProgress(`Progress error: ${error.message}`, null, [], 'failed');
-      }
-    };
-    stream.onerror = () => {
-      if (!state.currentRequestId) return;
-      stopProgressUpdates();
-      state.progressTimer = window.setInterval(refreshProgress, PROGRESS_POLL_INTERVAL_MS);
-    };
-    return;
-  }
-  state.progressTimer = window.setInterval(refreshProgress, PROGRESS_POLL_INTERVAL_MS);
-  refreshProgress();
-}
-
-function stopProgressUpdates() {
-  if (state.progressTimer) {
-    window.clearInterval(state.progressTimer);
-    state.progressTimer = null;
-  }
-  if (state.progressStream) {
-    state.progressStream.close();
-    state.progressStream = null;
-  }
-}
-
-async function refreshProgress() {
-  if (!state.currentRequestId) return;
-  try {
-    await applyProgress(await api(progressPath(state.currentRequestId)));
-  } catch (error) {
-    appendProgress(`Progress error: ${error.message}`, null, [], 'failed');
-  }
-}
-
-async function applyProgress(progress) {
-  if (!state.currentRequestId) return;
-  for (const event of progress.events || []) {
-    if (event.type === 'run_started') setRunId(event.run_id || event.runId);
-    appendProgress(eventLabel(event), event.sequence, eventDetails(event), eventStatus(event), event);
-    updateLastProgressSequence(event.sequence);
-  }
-  if (progress.preview?.token && progress.preview.token !== state.previewToken) {
-    await refreshPreview(progress.requestId, progress.preview.token);
-  }
-  syncYamlStepWithActiveStep(progress.activeStep || null);
-  if (progress.status !== 'running') {
-    stopProgressUpdates();
-    state.currentRequestId = null;
-    state.finishingRun = true;
-    setRunButtonCancel({ disabled: true });
-    updateLifecycleToolbar();
-    scheduleClearActiveYamlStepCard();
-    appendProgress(`Finished: ${progress.status}`, null, [], statusFromValue(progress.status));
-    if (progress.error) appendProgress(`Error: ${progress.error}`, null, [], 'failed');
-    if (progress.result?.runId) {
-      setRunId(progress.result.runId);
-      state.replayRequestId = progress.result.runId;
-      await loadReport(progress.result.runId);
-      await loadRecordedYaml(progress.result.runId, progress.result.recording || null);
-      await refreshPreviewFromReplay(progress.result.runId);
-    }
-    if (progress.result?.runId && state.replayRequestId && progress.status !== 'cancelled') {
-      try {
-        const replay = await loadReplayFrames(state.replayRequestId);
-        appendReplayFramesProgress(replay.frames);
-        appendReplayVideoGeneratingProgress();
-        const replayVideo = await ensureReplayVideoGenerated(state.replayRequestId, replay.frames);
-        if (replayVideo?.videoUrl) {
-          appendProgress('Replay video saved', null, [], 'success');
-          await showReplayVideoPreview(replayVideo.videoUrl);
-          showRightTab('preview');
-        } else {
-          appendProgress(`Replay video was not generated: ${replayVideo?.error || 'unknown error'}`, null, [], 'failed');
-        }
-      } catch (error) {
-        appendProgress(`Replay video was not generated: ${error.message}`, null, [], 'failed');
-      }
-    }
-    scheduleClearActiveProgressItem();
-    clearSelectedYamlRegion();
-    setRunButtonIdle();
-    els.refresh.disabled = false;
-    els.deviceSelect.disabled = false;
-    state.finishingRun = false;
-    state.currentExecutionMode = null;
-    updateRunMode({ preserveView: true });
-    saveRunModeState(state.activeRunMode);
-    await refreshStatus();
-    await refreshRuntime();
-  }
-}
-
-function progressPath(requestId) {
-  const encoded = encodeURIComponent(requestId);
-  if (state.lastProgressSequence <= 0) return `/task-progress/${encoded}`;
-  return `/task-progress/${encoded}?after_sequence=${state.lastProgressSequence}`;
-}
-
-function updateLastProgressSequence(sequence) {
-  if (Number.isInteger(sequence) && sequence > state.lastProgressSequence) {
-    state.lastProgressSequence = sequence;
-  }
-}
-
-async function refreshPreview(requestId, token) {
-  try {
-    const preview = await api(`/preview/${encodeURIComponent(requestId)}`);
-    const src = `data:image/png;base64,${preview.screenshot}`;
-    await preloadImage(src);
-    clearStepArtifactPreview();
-    state.previewToken = token;
-    els.replayVideo.hidden = true;
-    els.replayVideo.style.display = 'none';
-    els.screenshot.src = src;
-    els.screenshot.style.display = 'block';
-    els.previewEmpty.style.display = 'none';
-  } catch {
-    // Preview artifacts are best-effort while strict execution is still writing evidence.
-  }
-}
-
-function setRunId(runId) {
-  if (!runId) return;
-  els.progressRunId.textContent = `Run ID: ${runId}`;
-  els.progressRunId.dataset.runId = runId;
-  els.progressRunId.hidden = false;
-}
-
-function clearRunId() {
-  els.progressRunId.textContent = '';
-  delete els.progressRunId.dataset.runId;
-  els.progressRunId.hidden = true;
-  clearSelectedProgressRunId();
-}
-
-async function loadReport(runId) {
-  try {
-    els.reportContent.textContent = 'Loading report...';
-    const report = await api(`/reports/${encodeURIComponent(runId)}?format=markdown`);
-    els.reportContent.innerHTML = renderMarkdown(report.content || 'Report is empty.');
-  } catch (error) {
-    els.reportContent.textContent = `Unable to load report: ${error.message}`;
-  }
-}
-
-async function loadInputYaml() {
-  const path = els.caseYaml.value.trim();
-  showYamlView('input');
-  if (!path) {
-    clearYamlInput();
-    setYamlInputStatus('YAML path is required.', 'error');
-    return;
-  }
-  if (state.yamlLifecycleDirty) {
-    if (!window.confirm('Discard unsaved lifecycle changes and reload YAML?')) {
-      els.caseYaml.value = state.yamlInputLastPreviewPath;
-      return;
-    }
-  }
-  setYamlInputStatus('Loading YAML...', 'neutral');
-  try {
-    const yaml = await api(`/yaml/input?path=${encodeURIComponent(path)}`);
-    state.yamlInputContent = yaml.content || '';
-    state.yamlInputDisplay = yaml.display || null;
-    state.yamlInputRevision = yaml.revision || '';
-    state.yamlInputEditable = yaml.editable === true;
-    state.yamlLifecycleSnapshot = cloneLifecycle(yaml.display?.lifecycle || emptyLifecycle());
-    state.yamlLifecycleDraft = cloneLifecycle(state.yamlLifecycleSnapshot);
-    state.yamlLifecycleDirty = false;
-    state.yamlInputLastPreviewPath = path;
-    renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'YAML file is empty.', { lifecycleEditor: state.yamlInputEditable });
-    updateLifecycleToolbar();
-    setYamlInputStatus('', 'success');
-  } catch (error) {
-    state.yamlInputContent = '';
-    state.yamlInputDisplay = null;
-    resetLifecycleState();
-    renderYamlEmpty(els.yamlInputViewer, '');
-    setYamlInputStatus(error.message, 'error');
-  }
-}
-
-async function loadRecordedYaml(runId, recording, { existingRun = false } = {}) {
-  if (!existingRun && state.currentExecutionMode === 'strict-yaml') {
-    clearRecordedYaml();
-    updateRunMode();
-    return;
-  }
-  if (!recording) {
-    clearRecordedYaml();
-    return;
-  }
-  setRecordedYamlNoContent('Loading generated YAML...', 'neutral');
-  els.executionSection.hidden = false;
-  try {
-    const yaml = await api(`/yaml/recorded/${encodeURIComponent(runId)}`);
-    state.yamlRecordedContent = yaml.content || '';
-    state.yamlRecordedDisplay = yaml.display || null;
-    if (yaml.content) {
-      renderYamlDisplay(els.yamlRecordedViewer, state.yamlRecordedDisplay, 'Generated YAML is empty.');
-    } else {
-      renderYamlEmpty(els.yamlRecordedViewer, recordingStatusDetails(yaml));
-    }
-    setYamlRecordedStatus('', 'neutral');
-    els.executionSection.hidden = false;
-  } catch (error) {
-    state.yamlRecordedContent = '';
-    state.yamlRecordedDisplay = null;
-    renderYamlEmpty(els.yamlRecordedViewer, error.message);
-    setYamlRecordedStatus(error.message, 'error');
-    els.executionSection.hidden = false;
-  }
-}
-
-function clearYamlInput(message = 'No YAML loaded.') {
-  state.yamlInputContent = '';
-  state.yamlInputDisplay = null;
-  state.yamlInputLastPreviewPath = '';
-  resetLifecycleState();
-  setYamlInputStatus(message === 'No YAML loaded.' ? '' : message, 'neutral');
-  renderYamlEmpty(els.yamlInputViewer, message);
-}
-
-function clearRecordedYaml() {
-  state.yamlRecordedContent = '';
-  state.yamlRecordedDisplay = null;
-  setYamlRecordedStatus('', 'neutral');
-  renderYamlEmpty(els.yamlRecordedViewer, 'No generated YAML yet.');
-}
-
-function toggleLoadRunForm() {
-  if (currentRunMode() !== 'goal' || state.currentRequestId || state.finishingRun || state.loadRunInFlight) return;
-  const opening = els.loadRunForm.hidden;
-  els.loadRunForm.hidden = !opening;
-  els.loadRunToggle.setAttribute('aria-expanded', String(opening));
-  if (opening) {
-    setLoadRunStatus('', 'neutral');
-    els.loadRunPath.focus();
-  }
-}
-
-function resetLoadRunForm({ collapse = false } = {}) {
-  state.loadRunInFlight = false;
-  els.loadRunPath.value = '';
-  setLoadRunStatus('', 'neutral');
-  if (collapse) {
-    els.loadRunForm.hidden = true;
-    els.loadRunToggle.setAttribute('aria-expanded', 'false');
-  }
-  setLoadRunControlsDisabled();
-}
-
-function setLoadRunStatus(message, status = 'neutral') {
-  setYamlStatus(els.loadRunStatus, message, status);
-}
-
-function setLoadRunControlsDisabled(serverBusy = false) {
-  const disabled = Boolean(serverBusy || state.currentRequestId || state.finishingRun || state.loadRunInFlight);
-  els.loadRunToggle.disabled = disabled;
-  els.loadRunPath.disabled = disabled;
-  els.loadRunSubmit.disabled = disabled;
-  els.loadRunCancel.disabled = disabled;
-}
-
-async function loadExistingRun() {
-  if (currentRunMode() !== 'goal' || state.currentRequestId || state.finishingRun || state.loadRunInFlight) return;
-  if (hasUnsavedLifecycleDraft()) {
-    setLoadRunStatus('Save or discard lifecycle changes before loading a run.', 'error');
-    return;
-  }
-  const path = els.loadRunPath.value.trim();
-  if (!path) {
-    setLoadRunStatus('Run directory path is required.', 'error');
-    return;
-  }
-  state.loadRunInFlight = true;
-  setLoadRunStatus('Loading run...', 'neutral');
-  setLoadRunControlsDisabled();
-  try {
-    const result = await api('/runs/load', { method: 'POST', body: JSON.stringify({ path }) });
-    await activateLoadedRun(result.runId, result.availability || {});
-    resetLoadRunForm({ collapse: true });
-  } catch (error) {
-    state.loadRunInFlight = false;
-    setLoadRunStatus(error.message, 'error');
-    setLoadRunControlsDisabled();
-  }
-}
-
-async function activateLoadedRun(runId, availability) {
-  stopProgressUpdates();
-  saveRunModeState(state.activeRunMode);
-  state.loadedRunId = runId;
-  state.loadedRunAvailability = availability;
-  state.replayRequestId = runId;
-  state.previewToken = null;
-  state.currentExecutionMode = null;
-  state.progressSequence = 0;
-  state.lastProgressSequence = 0;
-  state.progressDetailOpenState.clear();
-  clearStepArtifactPreview();
-  clearYamlInput();
-  clearRecordedYaml();
-  clearRunId();
-  clearActiveProgressItem();
-  clearSelectedProgressItem();
-  clearSelectedYamlRegion();
-  els.progress.innerHTML = '';
-  setRunId(runId);
-  await loadExistingRunProgress(runId);
-  updateRunMode({ preserveView: true });
-  showYamlView('progress');
-  if (availability.report) {
-    await loadReport(runId);
-  } else {
-    els.reportContent.textContent = 'No report is available for this run.';
-  }
-  if (availability.recordedYaml) {
-    await loadRecordedYaml(runId, availability.recordedYaml, { existingRun: true });
-  } else {
-    setRecordedYamlNoContent('No generated YAML is available for this run.', 'neutral');
-  }
-  if (availability.replay) {
-    await showCompletedRunReplayPreview(runId);
-  } else {
-    clearPreview('No replay video is available for this run.');
-  }
-  showRightTab('preview');
-  saveRunModeState('goal');
-}
-
-function loadedRunIsActive() {
-  return Boolean(state.loadedRunId && currentRunMode() === 'goal');
-}
-
-async function loadExistingRunProgress(runId) {
-  els.progress.innerHTML = '';
-  state.progressSequence = 0;
-  state.lastProgressSequence = 0;
-  state.progressDetailOpenState.clear();
-  try {
-    const progress = await api(`/runs/${encodeURIComponent(runId)}/progress`);
-    const events = Array.isArray(progress.events) ? progress.events : [];
-    for (const event of events) {
-      appendProgress(eventLabel(event), event.sequence, eventDetails(event), eventStatus(event), event);
-      updateLastProgressSequence(event.sequence);
-    }
-    if (events.length === 0) {
-      els.progress.textContent = 'No persisted progress events are available for this run.';
-    }
-  } catch (error) {
-    els.progress.textContent = `Unable to load progress: ${error.message}`;
-  }
-}
-
-function setRecordedYamlNoContent(message, status = 'neutral') {
-  state.yamlRecordedContent = '';
-  state.yamlRecordedDisplay = null;
-  setYamlRecordedStatus(message, status);
-  renderYamlEmpty(els.yamlRecordedViewer, message);
-}
-
-function setYamlInputStatus(message, status) {
-  setYamlStatus(els.yamlInputStatus, message, status);
-}
-
-function setYamlRecordedStatus(message, status) {
-  setYamlStatus(els.yamlRecordedStatus, message, status);
-}
-
-function setYamlStatus(element, message, status) {
-  element.hidden = !message;
-  element.textContent = message;
-  element.className = `yaml-status yaml-status-${status || 'neutral'}`;
-}
-
-function showYamlView(viewName) {
-  const inputAvailable = !els.yamlInputTab.hidden;
-  const recordedAvailable = !els.yamlRecordedTab.hidden;
-  const progressAvailable = !els.yamlProgressTab.hidden;
-  let selectedView = inputAvailable ? 'input' : (recordedAvailable ? 'recorded' : 'progress');
-  if (viewName === 'recorded' && recordedAvailable) selectedView = 'recorded';
-  if (viewName === 'progress' && progressAvailable) selectedView = 'progress';
-  if (viewName === 'input' && inputAvailable) selectedView = 'input';
-  const showInput = selectedView === 'input';
-  const showRecorded = selectedView === 'recorded';
-  const showProgress = selectedView === 'progress';
-  state.yamlActiveView = selectedView;
-  els.yamlInputPane.hidden = !showInput;
-  els.yamlRecordedPane.hidden = !showRecorded;
-  els.progressPane.hidden = !showProgress;
-  els.yamlInputTab.classList.toggle('active', inputAvailable && showInput);
-  els.yamlRecordedTab.classList.toggle('active', recordedAvailable && showRecorded);
-  els.yamlProgressTab.classList.toggle('active', progressAvailable && showProgress);
-  els.yamlInputTab.setAttribute('aria-selected', String(inputAvailable && showInput));
-  els.yamlRecordedTab.setAttribute('aria-selected', String(recordedAvailable && showRecorded));
-  els.yamlProgressTab.setAttribute('aria-selected', String(progressAvailable && showProgress));
-}
-
-function renderYamlDisplay(root, display, emptyMessage, { lifecycleEditor = false } = {}) {
-  clearSelectedYamlRegion(root);
-  root.innerHTML = '';
-  if (!display) {
-    renderYamlEmpty(root, emptyMessage);
-    return;
-  }
-  const fragment = document.createDocumentFragment();
-  fragment.appendChild(renderYamlCaseTitle(display.metadata || {}));
-  fragment.appendChild(renderYamlCaseSummary(display.metadata || {}));
-  if (lifecycleEditor) fragment.appendChild(renderLifecycleSection('onCaseStart', 'Before case'));
-  fragment.appendChild(renderYamlCaseSteps(display.steps || []));
-  if (lifecycleEditor) fragment.appendChild(renderLifecycleSection('onCaseComplete', 'After case'));
-  root.appendChild(fragment);
-}
-
-function renderYamlCaseSteps(steps) {
-  const section = document.createElement('section');
-  section.className = 'yaml-case-steps-section';
-  const heading = document.createElement('div');
-  heading.className = 'yaml-lifecycle-heading yaml-case-steps-heading';
-  const title = document.createElement('h3');
-  title.textContent = 'Case steps';
-  heading.appendChild(title);
-  section.append(heading, renderYamlSteps(steps));
-  return section;
-}
-
-function emptyLifecycle() {
-  return LifecycleEditorModel.empty();
-}
-
-function cloneLifecycle(value) {
-  return LifecycleEditorModel.clone(value);
-}
-
-function resetLifecycleState() {
-  state.yamlInputRevision = '';
-  state.yamlInputEditable = false;
-  state.yamlLifecycleSnapshot = null;
-  state.yamlLifecycleDraft = null;
-  state.yamlLifecycleDirty = false;
-  state.yamlLifecycleSaving = false;
-  updateLifecycleToolbar();
-}
-
-function lifecycleActions(field) {
-  return LifecycleEditorModel.actions(state.yamlLifecycleDraft, field);
-}
-
-function renderLifecycleSection(field, label) {
-  const section = document.createElement('section');
-  section.className = 'yaml-lifecycle-section';
-  section.dataset.lifecycleField = field;
-  const heading = document.createElement('div');
-  heading.className = 'yaml-lifecycle-heading';
-  const title = document.createElement('h3');
-  title.textContent = label;
-  const add = iconButton('+', `Add ${label} action`, () => addLifecycleAction(field));
-  heading.append(title, add);
-  section.appendChild(heading);
-  const actions = lifecycleActions(field);
-  if (!actions.length) {
-    const empty = document.createElement('div');
-    empty.className = 'yaml-lifecycle-empty';
-    empty.textContent = 'No actions.';
-    section.appendChild(empty);
-    return section;
-  }
-  const list = document.createElement('div');
-  list.className = 'yaml-lifecycle-list';
-  actions.forEach((action, actionIndex) => list.appendChild(renderLifecycleAction(field, action, actionIndex)));
-  section.appendChild(list);
-  return section;
-}
-
-function renderLifecycleAction(field, action, actionIndex) {
-  const row = document.createElement('div');
-  row.className = 'yaml-lifecycle-action-row';
-  const number = document.createElement('span');
-  number.textContent = String(actionIndex + 1).padStart(2, '0');
-  number.className = 'yaml-step-index';
-  const select = document.createElement('select');
-  select.setAttribute('aria-label', 'Lifecycle action type');
-  for (const type of ['runCase', 'runShell']) {
-    const option = document.createElement('option');
-    option.value = type;
-    option.textContent = type;
-    option.selected = action.action === type;
-    select.appendChild(option);
-  }
-  select.addEventListener('change', () => updateLifecycleAction(field, actionIndex, 'action', select.value));
-  const input = document.createElement('input');
-  input.type = 'text';
-  input.value = action.value || '';
-  input.placeholder = action.action === 'runShell' ? 'Shell command...' : 'Case path...';
-  input.setAttribute('aria-label', `${action.action || 'Lifecycle'} value`);
-  input.addEventListener('input', () => updateLifecycleAction(field, actionIndex, 'value', input.value));
-  const controls = document.createElement('div');
-  controls.className = 'yaml-lifecycle-action-controls';
-  controls.append(
-    iconButton('↑', 'Move action up', () => moveLifecycleAction(field, actionIndex, -1), actionIndex === 0),
-    iconButton('↓', 'Move action down', () => moveLifecycleAction(field, actionIndex, 1), actionIndex === lifecycleActions(field).length - 1),
-    iconButton('×', 'Delete action', () => deleteLifecycleAction(field, actionIndex)),
-  );
-  row.append(number, select, input, controls);
-  return row;
-}
-
-function iconButton(symbol, label, handler, disabled = false) {
-  const button = document.createElement('button');
-  button.type = 'button';
-  button.className = 'yaml-lifecycle-icon-button';
-  button.textContent = symbol;
-  button.title = label;
-  button.setAttribute('aria-label', label);
-  button.disabled = disabled;
-  button.addEventListener('click', handler);
-  return button;
-}
-
-function markLifecycleDirty() {
-  state.yamlLifecycleDirty = JSON.stringify(state.yamlLifecycleDraft) !== JSON.stringify(state.yamlLifecycleSnapshot);
-  updateLifecycleToolbar();
-}
-
-function hasUnsavedLifecycleDraft() {
-  if (state.yamlLifecycleDirty) return true;
-  return Object.values(state.modeStates).some((modeState) => modeState.yamlLifecycleDirty);
-}
-
-function rerenderLifecycleEditor() {
-  renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'YAML file is empty.', { lifecycleEditor: true });
-  markLifecycleDirty();
-}
-
-function addLifecycleAction(field, action = 'runCase') {
-  if (lifecycleEditorIsDisabled()) return;
-  state.yamlLifecycleDraft = LifecycleEditorModel.addAction(state.yamlLifecycleDraft, field, action);
-  rerenderLifecycleEditor();
-}
-
-function updateLifecycleAction(field, actionIndex, key, value) {
-  if (lifecycleEditorIsDisabled()) return;
-  state.yamlLifecycleDraft = LifecycleEditorModel.updateAction(
-    state.yamlLifecycleDraft, field, actionIndex, key, value,
-  );
-  if (!lifecycleValidationError()) setYamlInputStatus('', 'neutral');
-  markLifecycleDirty();
-}
-
-function deleteLifecycleAction(field, actionIndex) {
-  if (lifecycleEditorIsDisabled()) return;
-  state.yamlLifecycleDraft = LifecycleEditorModel.deleteAction(
-    state.yamlLifecycleDraft, field, actionIndex,
-  );
-  rerenderLifecycleEditor();
-}
-
-function moveLifecycleAction(field, actionIndex, delta) {
-  if (lifecycleEditorIsDisabled()) return;
-  state.yamlLifecycleDraft = LifecycleEditorModel.moveAction(
-    state.yamlLifecycleDraft, field, actionIndex, delta,
-  );
-  rerenderLifecycleEditor();
-}
-
-function lifecycleValidationError() {
-  return LifecycleEditorModel.validationError(state.yamlLifecycleDraft);
-}
-
-function updateLifecycleToolbar() {
-  if (!els.yamlLifecycleToolbar) return;
-  const available = state.yamlInputEditable && !loadedRunIsActive();
-  const editorDisabled = Boolean(state.currentRequestId || state.finishingRun || state.yamlLifecycleSaving);
-  els.yamlLifecycleToolbar.hidden = !available;
-  els.yamlLifecycleDirty.hidden = !state.yamlLifecycleDirty;
-  els.yamlLifecycleSave.disabled = !available || !state.yamlLifecycleDirty || editorDisabled;
-  els.yamlLifecycleDiscard.disabled = !available || !state.yamlLifecycleDirty || editorDisabled;
-  setLifecycleEditorDisabled(!available || editorDisabled);
-}
-
-function lifecycleEditorIsDisabled() {
-  return Boolean(state.currentRequestId || state.finishingRun || state.yamlLifecycleSaving);
-}
-
-function setLifecycleEditorDisabled(disabled) {
-  for (const control of els.yamlInputViewer.querySelectorAll(
-    '.yaml-lifecycle-section select, .yaml-lifecycle-section input, .yaml-lifecycle-section button',
-  )) {
-    if (disabled) {
-      if (!Object.hasOwn(control.dataset, 'lifecycleWasDisabled')) {
-        control.dataset.lifecycleWasDisabled = String(control.disabled);
-      }
-      control.disabled = true;
-    } else {
-      const wasDisabled = control.dataset.lifecycleWasDisabled === 'true';
-      control.disabled = wasDisabled;
-      delete control.dataset.lifecycleWasDisabled;
-    }
-  }
-}
-
-async function saveLifecycleDraft() {
-  const validationError = lifecycleValidationError();
-  if (validationError) {
-    setYamlInputStatus(validationError, 'error');
-    return;
-  }
-  state.yamlLifecycleSaving = true;
-  updateLifecycleToolbar();
-  setYamlInputStatus('Saving lifecycle hooks...', 'neutral');
-  try {
-    const payload = await api('/yaml/input/lifecycle', {
-      method: 'PUT',
-      body: JSON.stringify({
-        path: state.yamlInputLastPreviewPath,
-        revision: state.yamlInputRevision,
-        onCaseStart: lifecycleActions('onCaseStart').map(({ action, value }) => ({ action, value })),
-        onCaseComplete: lifecycleActions('onCaseComplete').map(({ action, value }) => ({ action, value })),
-      }),
-    });
-    state.yamlInputContent = payload.content || '';
-    state.yamlInputDisplay = payload.display || null;
-    state.yamlInputRevision = payload.revision || '';
-    state.yamlLifecycleSnapshot = cloneLifecycle(payload.display?.lifecycle || emptyLifecycle());
-    state.yamlLifecycleDraft = cloneLifecycle(state.yamlLifecycleSnapshot);
-    state.yamlLifecycleDirty = false;
-    renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'YAML file is empty.', { lifecycleEditor: true });
-    setYamlInputStatus('', 'neutral');
-    showToast('Lifecycle hooks saved.');
-  } catch (error) {
-    setYamlInputStatus(error.message, 'error');
-  } finally {
-    state.yamlLifecycleSaving = false;
-    updateLifecycleToolbar();
-  }
-}
-
-function showToast(message, durationMs = 2000) {
-  if (state.toastTimer) window.clearTimeout(state.toastTimer);
-  els.toast.textContent = message;
-  els.toast.hidden = false;
-  els.toast.classList.add('toast-visible');
-  state.toastTimer = window.setTimeout(() => hideToast(), durationMs);
-}
-
-function hideToast() {
-  if (state.toastTimer) window.clearTimeout(state.toastTimer);
-  state.toastTimer = null;
-  els.toast.classList.remove('toast-visible');
-  els.toast.hidden = true;
-  els.toast.textContent = '';
-}
-
-function discardLifecycleDraft() {
-  state.yamlLifecycleDraft = cloneLifecycle(state.yamlLifecycleSnapshot);
-  state.yamlLifecycleDirty = false;
-  renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'YAML file is empty.', { lifecycleEditor: true });
-  setYamlInputStatus('', 'neutral');
-  updateLifecycleToolbar();
-}
-
-function renderYamlCaseTitle(metadata) {
-  const titleRow = document.createElement('div');
-  titleRow.className = 'yaml-case-title-row';
-  const title = document.createElement('div');
-  title.className = 'yaml-case-title';
-  title.textContent = metadata.title || 'Untitled case';
-  title.title = title.textContent;
-  titleRow.appendChild(title);
-  return titleRow;
-}
-
-function renderYamlCaseSummary(metadata) {
-  const summary = document.createElement('div');
-  summary.className = 'yaml-case-summary';
-
-  if (Array.isArray(metadata.tags) && metadata.tags.length > 0) {
-    const tags = document.createElement('div');
-    tags.className = 'yaml-tags';
-    for (const tag of metadata.tags) {
-      const chip = document.createElement('span');
-      chip.className = 'yaml-chip yaml-chip-muted';
-      chip.textContent = String(tag);
-      tags.appendChild(chip);
-    }
-    summary.appendChild(tags);
-  }
-
-  const fields = Array.isArray(metadata.fields) ? metadata.fields : [];
-  if (fields.length > 0) {
-    const grid = document.createElement('div');
-    grid.className = 'yaml-metadata-grid';
-    for (const field of fields) {
-      const item = document.createElement('div');
-      item.className = 'yaml-metadata-item';
-      const label = document.createElement('span');
-      label.className = 'yaml-metadata-label';
-      label.textContent = field.label || field.key || 'Field';
-      const value = document.createElement('span');
-      value.className = 'yaml-metadata-value';
-      value.textContent = formatYamlValue(field.value);
-      item.appendChild(label);
-      item.appendChild(value);
-      grid.appendChild(item);
-    }
-    summary.appendChild(grid);
-  }
-  return summary;
-}
-
-function renderYamlSteps(steps) {
-  const container = document.createElement('div');
-  container.className = 'yaml-step-list';
-  if (!steps.length) {
-    const empty = document.createElement('div');
-    empty.className = 'yaml-empty';
-    empty.textContent = 'No YAML steps.';
-    container.appendChild(empty);
-    return container;
-  }
-  for (const step of steps) {
-    container.appendChild(renderYamlStep(step));
-  }
-  return container;
-}
-
-function renderYamlStep(step) {
-  const card = document.createElement('div');
-  card.className = 'yaml-step-card';
-  card.dataset.yamlStepIndex = String(step.index || '');
-  if (step.artifactStepId) card.dataset.yamlStepId = String(step.artifactStepId);
-  card.dataset.yamlAction = step.action || 'command';
-  card.dataset.yamlActionKey = normalizeYamlActionName(step.action || 'command');
-  const header = document.createElement('div');
-  header.className = 'yaml-step-header';
-
-  const index = document.createElement('span');
-  index.className = 'yaml-step-index';
-  index.textContent = String(step.index || '?').padStart(2, '0');
-  header.appendChild(index);
-
-  const action = document.createElement('span');
-  const actionKind = step.kind || 'action';
-  action.className = `yaml-action-name yaml-action-name-${actionKind}`;
-  action.textContent = step.action || 'command';
-  action.title = actionKind;
-  header.appendChild(action);
-
-  for (const badge of step.badges || []) {
-    const chip = document.createElement('span');
-    chip.className = 'yaml-chip yaml-chip-muted';
-    chip.textContent = badge.label || String(badge);
-    header.appendChild(chip);
-  }
-
-  card.appendChild(header);
-  if ((step.params || []).length > 0) {
-    card.appendChild(renderYamlParams(step.params || []));
-  }
-  return card;
-}
-
-function renderYamlParams(params) {
-  const list = document.createElement('div');
-  list.className = 'yaml-param-list';
-  for (const param of params) {
-    const row = document.createElement('div');
-    row.className = 'yaml-param-row';
-    const key = document.createElement('span');
-    key.className = 'yaml-param-key';
-    key.textContent = param.key || 'value';
-    const value = document.createElement('span');
-    value.className = `yaml-param-value yaml-param-value-${param.kind || 'scalar'}`;
-    value.textContent = yamlParamDisplayValue(param);
-    row.appendChild(key);
-    row.appendChild(value);
-    list.appendChild(row);
-    if (Array.isArray(param.fields) && param.fields.length > 0) {
-      list.appendChild(renderYamlNestedParams(param.fields));
-    }
-  }
-  return list;
-}
-
-function renderYamlNestedParams(params) {
-  const nested = document.createElement('div');
-  nested.className = 'yaml-param-nested';
-  for (const param of params) {
-    const row = document.createElement('div');
-    row.className = 'yaml-param-row yaml-param-row-nested';
-    const key = document.createElement('span');
-    key.className = 'yaml-param-key';
-    key.textContent = param.key || 'value';
-    const value = document.createElement('span');
-    value.className = `yaml-param-value yaml-param-value-${param.kind || 'scalar'}`;
-    value.textContent = yamlParamDisplayValue(param);
-    row.appendChild(key);
-    row.appendChild(value);
-    nested.appendChild(row);
-    if (Array.isArray(param.fields) && param.fields.length > 0) {
-      nested.appendChild(renderYamlNestedParams(param.fields));
-    }
-  }
-  return nested;
-}
-
-function yamlParamDisplayValue(param) {
-  if (param.kind === 'secret') return `runtimeSecret: ${param.value}`;
-  if ((param.kind === 'object' || param.kind === 'list') && Array.isArray(param.fields)) return '';
-  return formatYamlValue(param.value);
-}
-
-function renderYamlEmpty(root, message) {
-  clearSelectedYamlRegion(root);
-  root.innerHTML = '';
-  if (!message) return;
-  const empty = document.createElement('div');
-  empty.className = 'yaml-empty';
-  empty.textContent = message;
-  root.appendChild(empty);
-}
-
-function formatYamlValue(value) {
-  if (value === null || value === undefined) return '';
-  if (Array.isArray(value)) return value.join(', ');
-  if (typeof value === 'object') return JSON.stringify(value);
-  return String(value);
-}
-
-function normalizeYamlActionName(value) {
-  return String(value || '').replace(/[^a-z0-9]/gi, '').toLowerCase();
-}
-
-function syncYamlStepWithActiveStep(activeStep) {
-  if (state.currentExecutionMode !== 'strict-yaml' || !activeStep) return;
-  const stepIndex = Number(activeStep.stepIndex ?? activeStep.step_index);
-  if (!Number.isInteger(stepIndex) || stepIndex <= 0) return;
-  const stepCard = Array.from(els.yamlInputViewer.querySelectorAll('.yaml-step-card'))
-    .find((card) => Number(card.dataset.yamlStepIndex) === stepIndex);
-  if (!stepCard) return;
-  activateYamlStepCard(stepCard);
-}
-
-function activateYamlStepCard(stepCard) {
-  cancelActiveYamlStepClearTimer();
-  if (state.activeYamlStepCard === stepCard) {
-    centerYamlStepCard(stepCard);
-    return;
-  }
-  clearActiveYamlStepCard();
-  state.activeYamlStepCard = stepCard;
-  stepCard.classList.add('yaml-step-card-active');
-  centerYamlStepCard(stepCard);
-}
-
-function clearActiveYamlStepCard(root = null) {
-  if (!state.activeYamlStepCard) return;
-  if (root && !root.contains(state.activeYamlStepCard)) return;
-  cancelActiveYamlStepClearTimer();
-  state.activeYamlStepCard.classList.remove('yaml-step-card-active');
-  state.activeYamlStepCard = null;
-}
-
-function centerYamlStepCard(stepCard) {
-  const viewer = stepCard.closest('.yaml-viewer');
-  if (!viewer || !stepCard.getClientRects().length) return;
-  const viewerRect = viewer.getBoundingClientRect();
-  const stepRect = stepCard.getBoundingClientRect();
-  const viewerCenter = viewerRect.top + viewerRect.height / 2;
-  const stepCenter = stepRect.top + stepRect.height / 2;
-  const tolerance = Math.max(24, viewerRect.height * YAML_STEP_CENTER_TOLERANCE_RATIO);
-  if (Math.abs(stepCenter - viewerCenter) <= tolerance) return;
-  stepCard.scrollIntoView({ block: 'center', behavior: 'smooth' });
-}
-
-function scheduleClearActiveYamlStepCard(delayMs = 900) {
-  cancelActiveYamlStepClearTimer();
-  state.activeYamlStepClearTimer = window.setTimeout(() => {
-    state.activeYamlStepClearTimer = null;
-    if (!state.activeYamlStepCard) return;
-    state.activeYamlStepCard.classList.remove('yaml-step-card-active');
-    state.activeYamlStepCard = null;
-  }, delayMs);
-}
-
-function cancelActiveYamlStepClearTimer() {
-  if (!state.activeYamlStepClearTimer) return;
-  clearTimeout(state.activeYamlStepClearTimer);
-  state.activeYamlStepClearTimer = null;
-}
-
-function clearSelectedYamlRegion(root = null) {
-  if (root && state.selectedYamlRegion && !root.contains(state.selectedYamlRegion)) return;
-  if (state.selectedYamlRegion) {
-    state.selectedYamlRegion.classList.remove('yaml-region-selected');
-  }
-  if (state.selectedYamlStepCard && state.selectedYamlStepCard !== state.selectedYamlRegion) {
-    state.selectedYamlStepCard.classList.remove('yaml-region-selected');
-  }
-  if (state.selectedYamlCaseSummary && state.selectedYamlCaseSummary !== state.selectedYamlRegion) {
-    state.selectedYamlCaseSummary.classList.remove('yaml-region-selected');
-  }
-  if (state.selectedYamlCaseTitle && state.selectedYamlCaseTitle !== state.selectedYamlRegion) {
-    state.selectedYamlCaseTitle.classList.remove('yaml-region-selected');
-  }
-  state.selectedYamlRegion = null;
-  state.selectedYamlStepCard = null;
-  state.selectedYamlCaseSummary = null;
-  state.selectedYamlCaseTitle = null;
-}
-
-function selectYamlRegion(region) {
-  if (state.selectedYamlRegion === region) return;
-  clearSelectedYamlRegion();
-  const stepCard = region.closest('.yaml-step-card');
-  const caseTitle = region.closest('.yaml-case-title-row');
-  const caseSummary = region.closest('.yaml-case-summary')
-    || (caseTitle?.nextElementSibling?.classList.contains('yaml-case-summary') ? caseTitle.nextElementSibling : null);
-  state.selectedYamlRegion = region;
-  state.selectedYamlStepCard = stepCard;
-  state.selectedYamlCaseSummary = caseSummary;
-  state.selectedYamlCaseTitle = caseTitle || (caseSummary?.previousElementSibling?.classList.contains('yaml-case-title-row') ? caseSummary.previousElementSibling : null);
-  region.classList.add('yaml-region-selected');
-  if (stepCard && stepCard !== region) stepCard.classList.add('yaml-region-selected');
-  if (caseSummary && caseSummary !== region) caseSummary.classList.add('yaml-region-selected');
-  if (state.selectedYamlCaseTitle && state.selectedYamlCaseTitle !== region) state.selectedYamlCaseTitle.classList.add('yaml-region-selected');
-}
-
-function handleYamlRegionClick(event) {
-  const region = event.target.closest(YAML_SELECTABLE_REGION_SELECTOR);
-  if (region && (els.yamlInputViewer.contains(region) || els.yamlRecordedViewer.contains(region))) {
-    if (state.currentRequestId || state.finishingRun) return;
-    selectYamlRegion(region);
-    if (els.yamlInputViewer.contains(region) || els.yamlRecordedViewer.contains(region)) {
-      if (els.yamlInputViewer.contains(region) && currentRunMode() !== 'strict-yaml') return;
-      if ((region.closest('.yaml-case-title-row') || region.closest('.yaml-case-summary')) && !region.closest('.yaml-step-card')) {
-        showCompletedRunReplayPreview();
-      } else {
-        const stepCard = region.closest('.yaml-step-card');
-        if (stepCard) loadStepArtifactsForCard(stepCard);
-      }
-    }
-    return;
-  }
-  if (state.currentRequestId || state.finishingRun) return;
-  clearSelectedYamlRegion();
-}
-
-function completedRunId() {
-  if (loadedRunIsActive()) return state.loadedRunId;
-  return !state.currentRequestId && state.replayRequestId ? state.replayRequestId : '';
-}
-
-async function showCompletedRunReplayPreview(runId = completedRunId()) {
-  if (!runId) return;
-  clearStepArtifactPreview();
-  showRightTab('preview');
-  try {
-    const replayVideo = await ensureReplayVideoGenerated(runId);
-    if (replayVideo?.videoUrl) {
-      await showReplayVideoPreview(replayVideo.videoUrl);
-    } else {
-      clearPreview('No replay video is available for this run.');
-    }
-  } catch (error) {
-    clearPreview(`Replay video could not be loaded: ${error.message}`);
-  }
-}
-
-function handleProgressRunIdClick() {
-  if (state.currentRequestId || state.finishingRun) return;
-  const runId = els.progressRunId.dataset.runId || '';
-  if (!runId) return;
-  clearSelectedProgressItem();
-  selectProgressRunId();
-  showCompletedRunReplayPreview(runId);
-}
-
-function selectProgressRunId() {
-  state.selectedProgressRunId = true;
-  els.progressRunId.classList.add('progress-run-id-selected');
-}
-
-function clearSelectedProgressRunId() {
-  state.selectedProgressRunId = false;
-  els.progressRunId.classList.remove('progress-run-id-selected');
-}
-
-async function loadStepArtifactsForCard(stepCard) {
-  const runId = completedRunId();
-  if (!runId) return;
-  const stepIdentifier = stepCard.dataset.yamlStepId || stepCard.dataset.yamlStepIndex || '';
-  if (!stepIdentifier) return;
-  const previewKey = `${runId}:${stepIdentifier}`;
-  state.stepArtifactPreviewActive = true;
-  state.stepArtifactStepKey = previewKey;
-  showRightTab('preview');
-  const shouldShowLoading = els.stepArtifactPreview.hidden || !els.stepArtifactPreview.hasChildNodes();
-  if (shouldShowLoading) renderStepArtifactLoading(stepCard);
-  try {
-    const payload = await api(`/step-artifacts/${encodeURIComponent(runId)}/${encodeURIComponent(stepIdentifier)}`);
-    if (state.stepArtifactStepKey !== previewKey) return;
-    await preloadStepArtifactScreenshots(payload);
-    if (state.stepArtifactStepKey !== previewKey) return;
-    renderStepArtifactPreview(payload, stepCard);
-  } catch (error) {
-    if (state.stepArtifactStepKey !== previewKey) return;
-    renderStepArtifactError(stepCard, error.message);
-  }
-}
-
-function clearStepArtifactPreview() {
-  state.stepArtifactPreviewActive = false;
-  state.stepArtifactStepKey = null;
-  if (!els.stepArtifactPreview) return;
-  els.stepArtifactPreview.hidden = true;
-  els.stepArtifactPreview.innerHTML = '';
-}
-
-function showStepArtifactContainer() {
-  cancelPendingReplayVideoReadyWait();
-  if (els.replayVideo.src) {
-    els.replayVideo.pause();
-  }
-  els.replayVideo.hidden = true;
-  els.replayVideo.style.display = 'none';
-  els.screenshot.removeAttribute('src');
-  els.screenshot.style.display = 'none';
-  els.previewEmpty.style.display = 'none';
-  els.stepArtifactPreview.hidden = false;
-}
-
-function renderStepArtifactLoading(stepCard) {
-  showStepArtifactContainer();
-  const shell = stepArtifactShell(stepCard, 'Loading artifacts...');
-  els.stepArtifactPreview.replaceChildren(shell);
-}
-
-function renderStepArtifactError(stepCard, message) {
-  showStepArtifactContainer();
-  const shell = stepArtifactShell(stepCard);
-  const error = document.createElement('div');
-  error.className = 'step-artifact-error';
-  error.textContent = message || 'Unable to load step artifacts.';
-  shell.appendChild(error);
-  els.stepArtifactPreview.replaceChildren(shell);
-}
-
-function renderStepArtifactPreview(payload, stepCard) {
-  showStepArtifactContainer();
-  const artifacts = Array.isArray(payload?.artifacts) ? payload.artifacts : [];
-  const shell = stepArtifactShell(stepCard, payload?.message || 'No artifacts for this step yet.');
-  if (artifacts.length > 0) {
-    shell.querySelector('.step-artifact-empty')?.remove();
-    const screenshots = artifacts.filter((artifact) => artifact.kind === 'screenshot' && artifact.contentBase64);
-    const textArtifacts = artifacts.filter((artifact) => artifact.kind !== 'screenshot' && (typeof artifact.content === 'string' || typeof artifact.error === 'string'));
-    const body = document.createElement('div');
-    body.className = 'step-artifact-body';
-    let screenshotRegion = null;
-    if (screenshots.length > 0) {
-      screenshotRegion = wrapStepArtifactRegion(renderStepArtifactScreenshots(screenshots), 'screenshots');
-      body.appendChild(screenshotRegion);
-    }
-    if (textArtifacts.length > 0) {
-      const textRegion = wrapStepArtifactRegion(renderStepArtifactTextArtifacts(textArtifacts), 'text');
-      const diffBody = textRegion.querySelector('.step-artifact-diff-body');
-      if (screenshotRegion) screenshotRegion.appendChild(createScreenshotHeightResizer(screenshotRegion));
-      if (diffBody) textRegion.prepend(createDiffTopResizer(textRegion));
-      if (diffBody) textRegion.appendChild(createDiffHeightResizer(textRegion));
-      body.appendChild(textRegion);
-    }
-    if (body.childElementCount > 0) shell.appendChild(body);
-  }
-  els.stepArtifactPreview.replaceChildren(shell);
-  requestAnimationFrame(() => {
-    for (const region of els.stepArtifactPreview.querySelectorAll('.step-artifact-region-screenshots')) {
-      initializeScreenshotResizeLayout(region);
-    }
-  });
-}
-
-function wrapStepArtifactRegion(section, variant) {
-  const region = document.createElement('div');
-  region.className = `step-artifact-region step-artifact-region-${variant}`;
-  if (variant === 'screenshots') {
-    const scroll = document.createElement('div');
-    scroll.className = 'step-artifact-screenshot-scroll';
-    scroll.appendChild(section);
-    region.appendChild(scroll);
-  } else {
-    region.appendChild(section);
-  }
-  return region;
-}
-
-function initializeScreenshotResizeLayout(region) {
-  if (region.classList.contains('step-artifact-region-user-sized')) return;
-  const card = region.querySelector('.step-artifact-image-card');
-  const cardWidth = card?.getBoundingClientRect().width || 0;
-  if (!cardWidth) return;
-  region.style.setProperty('--shot-card-width', `${Math.round(cardWidth)}px`);
-  region.dataset.shotBaseCardWidth = String(Math.round(cardWidth));
-  region.classList.add('step-artifact-region-user-sized');
-}
-
-function applyScreenshotRegionHeight(region, cardWidth, regionHeight) {
-  region.style.setProperty('--shot-card-width', `${Math.max(140, Math.round(cardWidth))}px`);
-  region.style.height = `${regionHeight}px`;
-}
-
-function createScreenshotHeightResizer(screenshotRegion) {
-  const resizer = document.createElement('div');
-  resizer.className = 'step-artifact-screenshot-border-resizer';
-  resizer.setAttribute('role', 'separator');
-  resizer.setAttribute('aria-orientation', 'horizontal');
-  let startY = 0;
-  let startRegionHeight = 0;
-  let startCardWidth = 0;
-  let baseCardWidth = 0;
-  let startRenderedImageWidth = 0;
-  let imageAspect = 1;
-  const currentCardWidth = () => {
-    const card = screenshotRegion.querySelector('.step-artifact-image-card');
-    return card ? card.getBoundingClientRect().width : 280;
-  };
-  const currentImageAspect = () => {
-    const image = screenshotRegion.querySelector('.step-artifact-image-card img');
-    return image?.naturalWidth && image?.naturalHeight ? image.naturalWidth / image.naturalHeight : 1;
-  };
-  const currentRenderedImageWidth = () => {
-    const image = screenshotRegion.querySelector('.step-artifact-image-card img');
-    if (!image) return startCardWidth;
-    const bounds = image.getBoundingClientRect();
-    return Math.min(bounds.width, bounds.height * imageAspect);
-  };
-  const onMove = (event) => {
-    const delta = event.clientY - startY;
-    const limit = Math.max(2400, window.innerHeight * 2);
-    const nextHeight = Math.min(Math.max(160, startRegionHeight + delta), limit);
-    const appliedDelta = nextHeight - startRegionHeight;
-    const nextImageWidth = startRenderedImageWidth + appliedDelta * imageAspect;
-    const nextCardWidth = Math.max(baseCardWidth, nextImageWidth);
-    applyScreenshotRegionHeight(screenshotRegion, nextCardWidth, nextHeight);
-  };
-  const onUp = (event) => {
-    document.removeEventListener('pointermove', onMove);
-    document.removeEventListener('pointerup', onUp);
-    if (resizer.hasPointerCapture?.(event.pointerId)) resizer.releasePointerCapture(event.pointerId);
-    document.body.classList.remove('step-artifact-resizing');
-  };
-  resizer.addEventListener('pointerdown', (event) => {
-    event.preventDefault();
-    resizer.setPointerCapture?.(event.pointerId);
-    initializeScreenshotResizeLayout(screenshotRegion);
-    startY = event.clientY;
-    startRegionHeight = Math.round(screenshotRegion.getBoundingClientRect().height);
-    startCardWidth = currentCardWidth();
-    baseCardWidth = Number(screenshotRegion.dataset.shotBaseCardWidth) || startCardWidth;
-    imageAspect = currentImageAspect();
-    startRenderedImageWidth = currentRenderedImageWidth();
-    document.body.classList.add('step-artifact-resizing');
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-  return resizer;
-}
-
-function createDiffTopResizer(textRegion) {
-  const resizer = document.createElement('div');
-  resizer.className = 'step-artifact-ui-tree-border-resizer';
-  resizer.setAttribute('role', 'separator');
-  resizer.setAttribute('aria-orientation', 'horizontal');
-  resizer.setAttribute('aria-label', 'Resize UI Tree from top');
-  let startY = 0;
-  let startHeight = 0;
-  let startScrollTop = 0;
-  let preview = null;
-  const onMove = (event) => {
-    const limit = Math.max(2400, window.innerHeight * 2);
-    const nextHeight = Math.min(Math.max(140, startHeight - (event.clientY - startY)), limit);
-    const heightDelta = nextHeight - startHeight;
-    textRegion.style.height = `${nextHeight}px`;
-    if (preview) preview.scrollTop = Math.max(0, startScrollTop + heightDelta);
-  };
-  const onUp = () => {
-    document.removeEventListener('pointermove', onMove);
-    document.removeEventListener('pointerup', onUp);
-    document.body.classList.remove('step-artifact-resizing');
-  };
-  resizer.addEventListener('pointerdown', (event) => {
-    event.preventDefault();
-    startY = event.clientY;
-    startHeight = Math.round(textRegion.getBoundingClientRect().height);
-    preview = textRegion.closest('.step-artifact-preview');
-    startScrollTop = preview?.scrollTop || 0;
-    document.body.classList.add('step-artifact-resizing');
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-  return resizer;
-}
-
-async function preloadStepArtifactScreenshots(payload) {
-  const artifacts = Array.isArray(payload?.artifacts) ? payload.artifacts : [];
-  const sources = artifacts
-    .filter((artifact) => artifact.kind === 'screenshot' && artifact.contentBase64)
-    .map((artifact) => stepArtifactImageSrc(artifact));
-  await Promise.allSettled(sources.map((src) => loadImageElement(src)));
-}
-
-function stepArtifactShell(stepCard, emptyMessage = '') {
-  const shell = document.createElement('div');
-  shell.className = 'step-artifact-shell';
-  const title = document.createElement('div');
-  title.className = 'step-artifact-title';
-  title.textContent = stepArtifactTitle(stepCard);
-  shell.appendChild(title);
-  if (emptyMessage) {
-    const empty = document.createElement('div');
-    empty.className = 'step-artifact-empty';
-    empty.textContent = emptyMessage;
-    shell.appendChild(empty);
-  }
-  return shell;
-}
-
-function stepArtifactTitle(stepCard) {
-  const index = stepCard.dataset.progressSequenceLabel || stepCard.dataset.yamlStepIndex || '?';
-  const action = stepCard.dataset.yamlAction || 'command';
-  const paddedIndex = stepCard.dataset.progressSequenceLabel ? index : String(index).padStart(2, '0');
-  return `${paddedIndex} ${action}`;
-}
-
-function renderStepArtifactScreenshots(screenshots) {
-  const section = document.createElement('section');
-  section.className = 'step-artifact-section';
-  const heading = document.createElement('div');
-  heading.className = 'step-artifact-section-title';
-  heading.textContent = 'Screenshots';
-  section.appendChild(heading);
-  const primary = primaryScreenshotArtifacts(screenshots);
-  const row = document.createElement('div');
-  row.className = `step-artifact-screenshot-row${primary.length === 2 ? ' step-artifact-compare' : ''}`;
-  row.appendChild(renderStepArtifactImage(primary[0]));
-  if (primary.length === 2) {
-    const connector = document.createElement('div');
-    connector.className = 'step-artifact-connector';
-    connector.setAttribute('aria-hidden', 'true');
-    row.appendChild(connector);
-    row.appendChild(renderStepArtifactImage(primary[1]));
-  }
-  section.appendChild(row);
-  return section;
-}
-
-function primaryScreenshotArtifacts(screenshots) {
-  const before = screenshots.find((artifact) => stepArtifactLabel(artifact).toLowerCase().includes('before'));
-  const after = screenshots.find((artifact) => stepArtifactLabel(artifact).toLowerCase().includes('after'));
-  if (before && after && before !== after) return [before, after];
-  if (screenshots.length > 1) return [screenshots[0], screenshots[screenshots.length - 1]];
-  return [screenshots[0]];
-}
-
-function renderStepArtifactImage(artifact) {
-  const card = document.createElement('figure');
-  card.className = 'step-artifact-image-card';
-  const label = document.createElement('figcaption');
-  label.className = 'step-artifact-image-label';
-  label.textContent = stepArtifactLabel(artifact);
-  const image = document.createElement('img');
-  image.alt = label.textContent;
-  image.src = stepArtifactImageSrc(artifact);
-  card.appendChild(label);
-  card.appendChild(image);
-  return card;
-}
-
-function stepArtifactImageSrc(artifact) {
-  return `data:${artifact.mimeType || 'image/png'};base64,${artifact.contentBase64}`;
-}
-
-function renderStepArtifactTextArtifacts(artifacts) {
-  const section = document.createElement('section');
-  section.className = 'step-artifact-section';
-  const heading = document.createElement('div');
-  heading.className = 'step-artifact-section-title';
-  heading.textContent = 'UI Tree';
-  section.appendChild(heading);
-  const uiTreeDiff = renderUiTreeDiffArtifact(artifacts);
-  for (const artifact of artifacts.filter((candidate) => (
-    typeof candidate.error === 'string'
-    && !(uiTreeDiff && OBSERVATION_ARTIFACT_KINDS.includes(candidate.kind))
-  ))) {
-    const card = document.createElement('div');
-    card.className = 'step-artifact-text-card';
-    const label = document.createElement('div');
-    label.className = 'step-artifact-text-label';
-    label.textContent = `${artifact.kind || 'artifact'} · ${stepArtifactLabel(artifact)}`;
-    const error = document.createElement('div');
-    error.className = 'step-artifact-error';
-    error.textContent = artifact.error;
-    card.appendChild(label);
-    card.appendChild(error);
-    section.appendChild(card);
-  }
-  if (uiTreeDiff) section.appendChild(uiTreeDiff);
-  for (const artifact of artifacts) {
-    if ((uiTreeDiff && OBSERVATION_ARTIFACT_KINDS.includes(artifact.kind)) || typeof artifact.error === 'string') continue;
-    const card = document.createElement('div');
-    card.className = 'step-artifact-text-card';
-    const label = document.createElement('div');
-    label.className = 'step-artifact-text-label';
-    label.textContent = `${artifact.kind || 'artifact'} · ${stepArtifactLabel(artifact)}`;
-    const pre = document.createElement('pre');
-    pre.className = isXmlStepArtifact(artifact) ? 'step-artifact-xml' : '';
-    pre.textContent = artifact.content || '';
-    card.appendChild(label);
-    card.appendChild(pre);
-    section.appendChild(card);
-  }
-  return section;
-}
-
-const OBSERVATION_ARTIFACT_KINDS = ['ui_tree', 'ui_snapshot'];
-
-function renderUiTreeDiffArtifact(artifacts) {
-  const uiTrees = artifacts.filter((artifact) => (
-    OBSERVATION_ARTIFACT_KINDS.includes(artifact.kind)
-    && (typeof artifact.content === 'string' || typeof artifact.error === 'string')
-  ));
-  const beforeArtifact = uiTrees.find((artifact) => stepArtifactLabel(artifact) === 'Before');
-  const afterArtifact = uiTrees.find((artifact) => stepArtifactLabel(artifact) === 'After');
-  if (!beforeArtifact && !afterArtifact) return null;
-  const card = document.createElement('div');
-  card.className = 'step-artifact-diff-card';
-  const body = document.createElement('div');
-  body.className = 'step-artifact-diff-body';
-  if (!beforeArtifact || !afterArtifact) {
-    const artifact = beforeArtifact || afterArtifact;
-    const side = beforeArtifact ? 'before' : 'after';
-    const title = beforeArtifact ? 'Before' : 'After';
-    const pane = typeof artifact.error === 'string'
-      ? renderArtifactErrorPane(side, title, artifact)
-      : renderDiffPane(side, title, contextDiffLines(artifact.content || ''));
-    const wrap = document.createElement('div');
-    wrap.className = 'step-artifact-diff-scroll';
-    const split = document.createElement('div');
-    split.className = 'step-artifact-diff-split';
-    split.appendChild(pane);
-    wrap.appendChild(split);
-    body.appendChild(wrap);
-    card.appendChild(body);
-    return card;
-  }
-  const before = beforeArtifact;
-  const after = afterArtifact;
-  const hasError = typeof before.error === 'string' || typeof after.error === 'string';
-  let diff = diffTextLines(before.content || '', after.content || '');
-  const unchanged = diff.length === 0;
-  if (unchanged) diff = contextDiffLines(after.content || before.content || '');
-  else annotateInlineDiff(diff);
-  if (hasError) {
-    const wrap = document.createElement('div');
-    wrap.className = 'step-artifact-diff-scroll';
-    const split = document.createElement('div');
-    split.className = 'step-artifact-diff-split';
-    split.appendChild(renderArtifactErrorPane('before', 'Before', before));
-    split.appendChild(renderArtifactErrorPane('after', 'After', after));
-    wrap.appendChild(split);
-    body.appendChild(wrap);
-  } else if (diff.length === 0) {
-    const empty = document.createElement('div');
-    empty.className = 'step-artifact-diff-empty';
-    empty.textContent = 'No UI tree captured.';
-    body.appendChild(empty);
-  } else {
-    const wrap = document.createElement('div');
-    wrap.className = 'step-artifact-diff-scroll';
-    const split = document.createElement('div');
-    split.className = 'step-artifact-diff-split';
-    const beforePane = renderDiffPane('before', 'Before', diff);
-    const afterPane = renderDiffPane('after', 'After', diff);
-    split.appendChild(beforePane);
-    split.appendChild(afterPane);
-    const panes = [beforePane, afterPane];
-    syncDiffPaneScroll(beforePane, afterPane);
-    wrap.appendChild(split);
-    wrap.appendChild(renderDiffOverview(diff, panes));
-    body.appendChild(wrap);
-  }
-  card.appendChild(body);
-  return card;
-}
-
-function renderArtifactErrorPane(side, title, artifact) {
-  const pane = document.createElement('div');
-  pane.className = `step-artifact-diff-pane diff-pane-${side}`;
-  const content = document.createElement('div');
-  content.className = 'step-artifact-error';
-  content.textContent = artifact.error || 'UI tree is unavailable.';
-  pane.appendChild(renderDiffPaneHeader(title));
-  pane.appendChild(content);
-  return pane;
-}
-
-function createDiffHeightResizer(target) {
-  const resizer = document.createElement('div');
-  resizer.className = 'step-artifact-ui-tree-bottom-border-resizer';
-  resizer.setAttribute('role', 'separator');
-  resizer.setAttribute('aria-orientation', 'horizontal');
-  let startY = 0;
-  let startHeight = 0;
-  const onMove = (event) => {
-    const max = Math.max(2400, window.innerHeight * 2);
-    const next = Math.min(Math.max(140, startHeight + (event.clientY - startY)), max);
-    target.style.height = `${next}px`;
-    resizer.scrollIntoView({ block: 'nearest' });
-  };
-  const onUp = () => {
-    document.removeEventListener('pointermove', onMove);
-    document.removeEventListener('pointerup', onUp);
-    document.body.classList.remove('step-artifact-resizing');
-  };
-  resizer.addEventListener('pointerdown', (event) => {
-    event.preventDefault();
-    startY = event.clientY;
-    startHeight = target.getBoundingClientRect().height;
-    document.body.classList.add('step-artifact-resizing');
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-  });
-  return resizer;
-}
-
-function renderDiffOverview(diff, panes) {
-  const overview = document.createElement('div');
-  overview.className = 'step-artifact-diff-overview';
-  overview.title = 'Diff overview — click to jump';
-  const rowCount = diff.length + 1;
-  diff.forEach((line, index) => {
-    if (line.kind !== 'added' && line.kind !== 'removed') return;
-    const marker = document.createElement('button');
-    marker.type = 'button';
-    marker.className = `step-artifact-diff-overview-marker step-artifact-diff-overview-${line.kind}`;
-    marker.style.top = `${((index + 1) / rowCount) * 100}%`;
-    marker.title = line.kind === 'added' ? 'Added line' : 'Removed line';
-    marker.addEventListener('click', (event) => {
-      event.stopPropagation();
-      scrollDiffToRow(panes, index + 1, rowCount);
-    });
-    overview.appendChild(marker);
-  });
-  overview.addEventListener('click', (event) => {
-    const rect = overview.getBoundingClientRect();
-    const ratio = rect.height ? (event.clientY - rect.top) / rect.height : 0;
-    const pane = panes[0];
-    applyDiffScrollTop(panes, ratio * (pane.scrollHeight - pane.clientHeight));
-  });
-  return overview;
-}
-
-function scrollDiffToRow(panes, row, rowCount) {
-  const pane = panes[0];
-  const target = rowCount ? (row / rowCount) * pane.scrollHeight - pane.clientHeight / 2 : 0;
-  applyDiffScrollTop(panes, target);
-}
-
-function applyDiffScrollTop(panes, value) {
-  const pane = panes[0];
-  const max = Math.max(0, pane.scrollHeight - pane.clientHeight);
-  const clamped = Math.max(0, Math.min(max, value));
-  for (const target of panes) target.scrollTop = clamped;
-}
-
-function renderDiffPane(side, title, diff) {
-  const pane = document.createElement('div');
-  pane.className = `step-artifact-diff-pane diff-pane-${side}`;
-  const column = document.createElement('div');
-  column.className = 'step-artifact-diff-column';
-
-  column.appendChild(renderDiffPaneHeader(title));
-
-  for (const line of diff) {
-    const row = document.createElement('div');
-    row.className = `step-artifact-diff-row step-artifact-diff-line-${line.kind}`;
-    const number = document.createElement('span');
-    number.className = 'step-artifact-diff-number';
-    const text = document.createElement('span');
-    text.className = 'step-artifact-diff-text';
-    if (side === 'before') {
-      number.textContent = line.beforeNumber ? String(line.beforeNumber) : '';
-      appendDiffText(text, line.beforeText || '', line.beforeInline);
-    } else {
-      number.textContent = line.afterNumber ? String(line.afterNumber) : '';
-      appendDiffText(text, line.afterText || '', line.afterInline);
-    }
-    row.appendChild(number);
-    row.appendChild(text);
-    column.appendChild(row);
-  }
-  pane.appendChild(column);
-  return pane;
-}
-
-function renderDiffPaneHeader(title) {
-  const header = document.createElement('div');
-  header.className = 'step-artifact-image-label step-artifact-diff-headrow';
-  header.textContent = title;
-  return header;
-}
-
-function appendDiffText(target, value, inlineChange) {
-  if (!inlineChange) {
-    target.textContent = value;
-    return;
-  }
-  if (inlineChange.prefix) target.appendChild(document.createTextNode(inlineChange.prefix));
-  const changed = document.createElement('span');
-  changed.className = 'step-artifact-diff-inline-change';
-  changed.textContent = inlineChange.changed;
-  target.appendChild(changed);
-  if (inlineChange.suffix) target.appendChild(document.createTextNode(inlineChange.suffix));
-}
-
-function annotateInlineDiff(diff) {
-  let index = 0;
-  while (index < diff.length) {
-    if (diff[index].kind === 'context') {
-      index += 1;
-      continue;
-    }
-    const start = index;
-    while (index < diff.length && diff[index].kind !== 'context') index += 1;
-    annotateInlineChangeBlock(diff.slice(start, index));
-  }
-}
-
-function annotateInlineChangeBlock(block) {
-  const removed = block.filter((line) => line.kind === 'removed');
-  const added = block.filter((line) => line.kind === 'added');
-  const pairCount = Math.min(removed.length, added.length);
-  for (let index = 0; index < pairCount; index += 1) {
-    const beforeText = removed[index].beforeText || '';
-    const afterText = added[index].afterText || '';
-    const changes = inlineTextChanges(beforeText, afterText);
-    removed[index].beforeInline = changes.before;
-    added[index].afterInline = changes.after;
-  }
-}
-
-function inlineTextChanges(beforeText, afterText) {
-  let prefixLength = 0;
-  const maxPrefix = Math.min(beforeText.length, afterText.length);
-  while (prefixLength < maxPrefix && beforeText[prefixLength] === afterText[prefixLength]) prefixLength += 1;
-
-  let suffixLength = 0;
-  const maxSuffix = Math.min(beforeText.length - prefixLength, afterText.length - prefixLength);
-  while (
-    suffixLength < maxSuffix
-    && beforeText[beforeText.length - suffixLength - 1] === afterText[afterText.length - suffixLength - 1]
-  ) {
-    suffixLength += 1;
-  }
-  return {
-    before: inlineTextChange(beforeText, prefixLength, suffixLength),
-    after: inlineTextChange(afterText, prefixLength, suffixLength),
-  };
-}
-
-function inlineTextChange(text, prefixLength, suffixLength) {
-  const changedEnd = suffixLength ? text.length - suffixLength : text.length;
-  return {
-    prefix: text.slice(0, prefixLength),
-    changed: text.slice(prefixLength, changedEnd),
-    suffix: text.slice(changedEnd),
-  };
-}
-
-function syncDiffPaneScroll(first, second) {
-  let syncing = false;
-  const link = (source, target) => {
-    source.addEventListener('scroll', () => {
-      if (syncing) return;
-      syncing = true;
-      target.scrollLeft = source.scrollLeft;
-      target.scrollTop = source.scrollTop;
-      syncing = false;
-    });
-  };
-  link(first, second);
-  link(second, first);
-}
-
-function contextDiffLines(text) {
-  return normalizeDiffLines(text).map((value, index) => ({
-    kind: 'context',
-    beforeNumber: index + 1,
-    beforeText: value,
-    afterNumber: index + 1,
-    afterText: value,
-  }));
-}
-
-function diffTextLines(beforeText, afterText) {
-  const beforeLines = normalizeDiffLines(beforeText);
-  const afterLines = normalizeDiffLines(afterText);
-  if (beforeLines.join('\n') === afterLines.join('\n')) return [];
-  if (beforeLines.length * afterLines.length > 160000) return myersDiffLines(beforeLines, afterLines);
-  const table = Array.from({ length: beforeLines.length + 1 }, () => Array(afterLines.length + 1).fill(0));
-  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
-    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
-      if (beforeLines[beforeIndex] === afterLines[afterIndex]) {
-        table[beforeIndex][afterIndex] = table[beforeIndex + 1][afterIndex + 1] + 1;
-      } else {
-        table[beforeIndex][afterIndex] = Math.max(table[beforeIndex + 1][afterIndex], table[beforeIndex][afterIndex + 1]);
-      }
-    }
-  }
-  const diff = [];
-  let beforeIndex = 0;
-  let afterIndex = 0;
-  let beforeNumber = 1;
-  let afterNumber = 1;
-  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
-    if (beforeLines[beforeIndex] === afterLines[afterIndex]) {
-      diff.push({ kind: 'context', beforeNumber, beforeText: beforeLines[beforeIndex], afterNumber, afterText: afterLines[afterIndex] });
-      beforeIndex += 1;
-      afterIndex += 1;
-      beforeNumber += 1;
-      afterNumber += 1;
-    } else if (table[beforeIndex + 1][afterIndex] >= table[beforeIndex][afterIndex + 1]) {
-      diff.push({ kind: 'removed', beforeNumber, beforeText: beforeLines[beforeIndex] });
-      beforeIndex += 1;
-      beforeNumber += 1;
-    } else {
-      diff.push({ kind: 'added', afterNumber, afterText: afterLines[afterIndex] });
-      afterIndex += 1;
-      afterNumber += 1;
-    }
-  }
-  while (beforeIndex < beforeLines.length) {
-    diff.push({ kind: 'removed', beforeNumber, beforeText: beforeLines[beforeIndex] });
-    beforeIndex += 1;
-    beforeNumber += 1;
-  }
-  while (afterIndex < afterLines.length) {
-    diff.push({ kind: 'added', afterNumber, afterText: afterLines[afterIndex] });
-    afterIndex += 1;
-    afterNumber += 1;
-  }
-  return diff;
-}
-
-function normalizeDiffLines(text) {
-  return String(text || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-}
-
-function myersDiffLines(beforeLines, afterLines) {
-  const beforeLength = beforeLines.length;
-  const afterLength = afterLines.length;
-  const maxDistance = Math.min(beforeLength + afterLength, 1200);
-  const furthest = new Map([[1, 0]]);
-  const trace = [];
-
-  for (let distance = 0; distance <= maxDistance; distance += 1) {
-    trace.push(new Map(furthest));
-    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
-      const down = furthest.get(diagonal + 1) ?? -1;
-      const right = furthest.get(diagonal - 1) ?? -1;
-      let beforeIndex;
-      if (diagonal === -distance || (diagonal !== distance && right < down)) {
-        beforeIndex = Math.max(0, down);
-      } else {
-        beforeIndex = Math.max(0, right + 1);
-      }
-      let afterIndex = beforeIndex - diagonal;
-      while (
-        beforeIndex < beforeLength
-        && afterIndex < afterLength
-        && beforeLines[beforeIndex] === afterLines[afterIndex]
-      ) {
-        beforeIndex += 1;
-        afterIndex += 1;
-      }
-      furthest.set(diagonal, beforeIndex);
-      if (beforeIndex >= beforeLength && afterIndex >= afterLength) {
-        return backtrackMyersDiff(trace, beforeLines, afterLines);
-      }
-    }
-  }
-  return patienceDiffLines(beforeLines, afterLines);
-}
-
-function backtrackMyersDiff(trace, beforeLines, afterLines) {
-  let beforeIndex = beforeLines.length;
-  let afterIndex = afterLines.length;
-  const reversed = [];
-
-  for (let distance = trace.length - 1; distance >= 0; distance -= 1) {
-    const furthest = trace[distance];
-    const diagonal = beforeIndex - afterIndex;
-    const down = furthest.get(diagonal + 1) ?? -1;
-    const right = furthest.get(diagonal - 1) ?? -1;
-    const previousDiagonal = diagonal === -distance || (diagonal !== distance && right < down)
-      ? diagonal + 1
-      : diagonal - 1;
-    const previousBefore = Math.max(0, furthest.get(previousDiagonal) ?? 0);
-    const previousAfter = previousBefore - previousDiagonal;
-
-    while (beforeIndex > previousBefore && afterIndex > previousAfter) {
-      reversed.push({
-        kind: 'context',
-        beforeNumber: beforeIndex,
-        beforeText: beforeLines[beforeIndex - 1],
-        afterNumber: afterIndex,
-        afterText: afterLines[afterIndex - 1],
-      });
-      beforeIndex -= 1;
-      afterIndex -= 1;
-    }
-    if (distance === 0) break;
-    if (beforeIndex === previousBefore) {
-      reversed.push({ kind: 'added', afterNumber: afterIndex, afterText: afterLines[afterIndex - 1] });
-      afterIndex -= 1;
-    } else {
-      reversed.push({ kind: 'removed', beforeNumber: beforeIndex, beforeText: beforeLines[beforeIndex - 1] });
-      beforeIndex -= 1;
-    }
-  }
-  return reversed.reverse();
-}
-
-function patienceDiffLines(beforeLines, afterLines) {
-  const diff = [];
-  appendPatienceRange(diff, beforeLines, afterLines, 0, beforeLines.length, 0, afterLines.length);
-  return diff;
-}
-
-function appendPatienceRange(diff, beforeLines, afterLines, beforeStart, beforeEnd, afterStart, afterEnd) {
-  while (beforeStart < beforeEnd && afterStart < afterEnd && beforeLines[beforeStart] === afterLines[afterStart]) {
-    diff.push({
-      kind: 'context',
-      beforeNumber: beforeStart + 1,
-      beforeText: beforeLines[beforeStart],
-      afterNumber: afterStart + 1,
-      afterText: afterLines[afterStart],
-    });
-    beforeStart += 1;
-    afterStart += 1;
-  }
-
-  let commonSuffix = 0;
-  while (
-    beforeStart < beforeEnd - commonSuffix
-    && afterStart < afterEnd - commonSuffix
-    && beforeLines[beforeEnd - commonSuffix - 1] === afterLines[afterEnd - commonSuffix - 1]
-  ) {
-    commonSuffix += 1;
-  }
-  const beforeMiddleEnd = beforeEnd - commonSuffix;
-  const afterMiddleEnd = afterEnd - commonSuffix;
-  const anchors = patienceAnchors(beforeLines, afterLines, beforeStart, beforeMiddleEnd, afterStart, afterMiddleEnd);
-
-  if (anchors.length === 0) {
-    for (let index = beforeStart; index < beforeMiddleEnd; index += 1) {
-      diff.push({ kind: 'removed', beforeNumber: index + 1, beforeText: beforeLines[index] });
-    }
-    for (let index = afterStart; index < afterMiddleEnd; index += 1) {
-      diff.push({ kind: 'added', afterNumber: index + 1, afterText: afterLines[index] });
-    }
-  } else {
-    let previousBefore = beforeStart;
-    let previousAfter = afterStart;
-    for (const anchor of anchors) {
-      appendPatienceRange(diff, beforeLines, afterLines, previousBefore, anchor.before, previousAfter, anchor.after);
-      diff.push({
-        kind: 'context',
-        beforeNumber: anchor.before + 1,
-        beforeText: beforeLines[anchor.before],
-        afterNumber: anchor.after + 1,
-        afterText: afterLines[anchor.after],
-      });
-      previousBefore = anchor.before + 1;
-      previousAfter = anchor.after + 1;
-    }
-    appendPatienceRange(diff, beforeLines, afterLines, previousBefore, beforeMiddleEnd, previousAfter, afterMiddleEnd);
-  }
-
-  for (let offset = commonSuffix - 1; offset >= 0; offset -= 1) {
-    const beforeIndex = beforeEnd - offset - 1;
-    const afterIndex = afterEnd - offset - 1;
-    diff.push({
-      kind: 'context',
-      beforeNumber: beforeIndex + 1,
-      beforeText: beforeLines[beforeIndex],
-      afterNumber: afterIndex + 1,
-      afterText: afterLines[afterIndex],
-    });
-  }
-}
-
-function patienceAnchors(beforeLines, afterLines, beforeStart, beforeEnd, afterStart, afterEnd) {
-  const beforeOccurrences = uniqueLineOccurrences(beforeLines, beforeStart, beforeEnd);
-  const afterOccurrences = uniqueLineOccurrences(afterLines, afterStart, afterEnd);
-  const candidates = [];
-  for (const [line, beforeOccurrence] of beforeOccurrences) {
-    const afterOccurrence = afterOccurrences.get(line);
-    if (beforeOccurrence.count === 1 && afterOccurrence?.count === 1) {
-      candidates.push({ before: beforeOccurrence.index, after: afterOccurrence.index });
-    }
-  }
-  candidates.sort((left, right) => left.before - right.before);
-  return longestIncreasingAnchorSequence(candidates);
-}
-
-function uniqueLineOccurrences(lines, start, end) {
-  const occurrences = new Map();
-  for (let index = start; index < end; index += 1) {
-    const line = lines[index];
-    const occurrence = occurrences.get(line);
-    if (occurrence) occurrence.count += 1;
-    else occurrences.set(line, { count: 1, index });
-  }
-  return occurrences;
-}
-
-function longestIncreasingAnchorSequence(candidates) {
-  if (candidates.length === 0) return [];
-  const tails = [];
-  const previous = new Array(candidates.length).fill(-1);
-  for (let index = 0; index < candidates.length; index += 1) {
-    let low = 0;
-    let high = tails.length;
-    while (low < high) {
-      const middle = Math.floor((low + high) / 2);
-      if (candidates[tails[middle]].after < candidates[index].after) low = middle + 1;
-      else high = middle;
-    }
-    if (low > 0) previous[index] = tails[low - 1];
-    tails[low] = index;
-  }
-  const sequence = [];
-  let cursor = tails[tails.length - 1];
-  while (cursor >= 0) {
-    sequence.push(candidates[cursor]);
-    cursor = previous[cursor];
-  }
-  return sequence.reverse();
-}
-
-function isXmlStepArtifact(artifact) {
-  const content = String(artifact.content || '').trimStart();
-  const mimeType = String(artifact.mimeType || '').toLowerCase();
-  const path = String(artifact.path || '').toLowerCase();
-  return mimeType.includes('xml') || path.endsWith('.xml') || content.startsWith('<');
-}
-
-function stepArtifactLabel(artifact) {
-  const combined = `${artifact.reason || ''} ${artifact.phase || ''}`.toLowerCase();
-  if (combined.includes('before') || combined.includes('prepare')) return 'Before';
-  if (combined.includes('after') || combined.includes('finalize')) return 'After';
-  if (combined.includes('failure')) return 'Failure';
-  return artifact.phase || artifact.reason || artifact.kind || 'Artifact';
-}
-
-function recordingStatusDetails(recording) {
-  const messages = [];
-  for (const warning of recording.warnings || []) messages.push(`Warning: ${formatProgressValue(warning)}`);
-  for (const error of recording.errors || []) messages.push(`Error: ${formatProgressValue(error)}`);
-  if ((recording.skippedToolCalls || []).length > 0) messages.push(`Skipped tool calls: ${recording.skippedToolCalls.length}`);
-  return messages.join('\n') || 'No generated YAML content.';
-}
-
-function renderMarkdown(markdown) {
-  const lines = String(markdown || '').replace(/\r\n/g, '\n').split('\n');
-  const html = [];
-  let inCode = false;
-  let codeLines = [];
-  let inList = false;
-
-  const closeList = () => {
-    if (inList) {
-      html.push('</ul>');
-      inList = false;
-    }
-  };
-  const flushCode = () => {
-    html.push(`<pre><code>${escapeHtml(codeLines.join('\n'))}</code></pre>`);
-    codeLines = [];
-  };
-
-  for (const line of lines) {
-    if (line.trim().startsWith('```')) {
-      if (inCode) {
-        inCode = false;
-        flushCode();
-      } else {
-        closeList();
-        inCode = true;
-        codeLines = [];
-      }
-      continue;
-    }
-    if (inCode) {
-      codeLines.push(line);
-      continue;
-    }
-
-    const heading = line.match(/^(#{1,4})\s+(.*)$/);
-    if (heading) {
-      closeList();
-      const level = heading[1].length;
-      html.push(`<h${level}>${formatInlineMarkdown(heading[2])}</h${level}>`);
-      continue;
-    }
-
-    const bullet = line.match(/^\s*[-*]\s+(.*)$/);
-    if (bullet) {
-      if (!inList) {
-        html.push('<ul>');
-        inList = true;
-      }
-      html.push(`<li>${formatInlineMarkdown(bullet[1])}</li>`);
-      continue;
-    }
-
-    if (!line.trim()) {
-      closeList();
-      continue;
-    }
-
-    closeList();
-    html.push(`<p>${formatInlineMarkdown(line)}</p>`);
-  }
-  if (inCode) flushCode();
-  closeList();
-  return html.join('\n');
-}
-
-function formatInlineMarkdown(value) {
-  return escapeHtml(value)
-    .replace(/`([^`]+)`/g, '<code>$1</code>')
-    .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
-}
-
-function escapeHtml(value) {
-  return String(value)
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;');
-}
-
-function showRightTab(tabName) {
-  const tabs = [
-    { name: 'preview', button: els.previewTab, pane: els.previewPane },
-    { name: 'report', button: els.reportTab, pane: els.reportPane },
-  ];
-  const selected = tabs.some((tab) => tab.name === tabName) ? tabName : 'preview';
-  for (const tab of tabs) {
-    const active = tab.name === selected;
-    tab.pane.hidden = !active;
-    tab.button.classList.toggle('active', active);
-    tab.button.setAttribute('aria-selected', String(active));
-  }
-}
-
-function appendProgress(content, backendSequence = null, details = [], status = 'neutral', event = null) {
-  const hasBackendSequence = Number.isInteger(backendSequence) && backendSequence >= 0;
-  if (hasBackendSequence) {
-    state.progressSequence = Math.max(state.progressSequence, backendSequence);
-  } else {
-    state.progressSequence += 1;
-  }
-  const item = document.createElement('div');
-  item.className = 'progress-item';
-  item.tabIndex = 0;
-  const sequence = String(hasBackendSequence ? backendSequence : state.progressSequence).padStart(3, '0');
-  item.dataset.progressSequenceLabel = sequence;
-  const stepId = progressEventStepId(event);
-  if (stepId) {
-    item.dataset.yamlStepId = stepId;
-    item.dataset.yamlAction = event?.tool_name || event?.title || event?.type || 'step';
-    item.classList.add('progress-item-with-artifacts');
-  }
-  const number = document.createElement('span');
-  number.className = 'progress-number';
-  number.textContent = `${sequence}.`;
-  const statusDot = document.createElement('span');
-  statusDot.className = `progress-status-dot progress-status-${status}`;
-  statusDot.title = status;
-  const body = document.createElement('span');
-  body.className = 'progress-text';
-  renderProgressText(body, content);
-  item.appendChild(number);
-  item.appendChild(statusDot);
-  item.appendChild(body);
-  const eventKey = hasBackendSequence ? String(backendSequence) : `local-${state.progressSequence}`;
-  for (const detail of details) {
-    item.appendChild(renderProgressDetail(eventKey, detail.label, detail.value));
-  }
-  els.progress.appendChild(item);
-  activateProgressItem(item);
-  scheduleProgressScroll();
-}
-
-function activateProgressItem(item) {
-  cancelActiveProgressItemClearTimer();
-  if (state.activeProgressItem === item) return;
-  clearActiveProgressItem();
-  state.activeProgressItem = item;
-  item.classList.add('progress-item-active');
-}
-
-function clearActiveProgressItem() {
-  if (!state.activeProgressItem) return;
-  cancelActiveProgressItemClearTimer();
-  state.activeProgressItem.classList.remove('progress-item-active');
-  state.activeProgressItem = null;
-}
-
-function scheduleClearActiveProgressItem(delayMs = 900) {
-  cancelActiveProgressItemClearTimer();
-  state.activeProgressItemClearTimer = window.setTimeout(() => {
-    state.activeProgressItemClearTimer = null;
-    if (!state.activeProgressItem) return;
-    state.activeProgressItem.classList.remove('progress-item-active');
-    state.activeProgressItem = null;
-  }, delayMs);
-}
-
-function cancelActiveProgressItemClearTimer() {
-  if (!state.activeProgressItemClearTimer) return;
-  clearTimeout(state.activeProgressItemClearTimer);
-  state.activeProgressItemClearTimer = null;
-}
-
-function clearSelectedProgressItem() {
-  if (!state.selectedProgressItem) return;
-  state.selectedProgressItem.classList.remove('progress-item-selected');
-  state.selectedProgressItem = null;
-}
-
-function selectProgressItem(item) {
-  if (state.selectedProgressItem === item) return;
-  clearSelectedProgressItem();
-  state.selectedProgressItem = item;
-  item.classList.add('progress-item-selected');
-}
-
-function handleProgressItemClick(event) {
-  if (event.target.closest('#progress-run-id')) return;
-  const item = event.target.closest('.progress-item');
-  if (item && els.progress.contains(item)) {
-    if (state.currentRequestId || state.finishingRun) return;
-    clearSelectedProgressRunId();
-    selectProgressItem(item);
-    if (item.dataset.yamlStepId) loadStepArtifactsForCard(item);
-    return;
-  }
-  clearSelectedProgressRunId();
-  clearSelectedProgressItem();
-}
-
-function progressEventStepId(event) {
-  if (!event || typeof event !== 'object') return '';
-  const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
-  const runnerResult = payload.runner_result && typeof payload.runner_result === 'object'
-    ? payload.runner_result
-    : {};
-  for (const candidate of [event.step_id, event.stepId, payload.runner_step_id, payload.step_id, runnerResult.step_id]) {
-    if (typeof candidate === 'string' && candidate.trim()) return candidate.trim();
-  }
-  return '';
-}
-
-function scheduleProgressScroll() {
-  if (state.progressScrollScheduled) return;
-  state.progressScrollScheduled = true;
-  window.requestAnimationFrame(() => {
-    state.progressScrollScheduled = false;
-    els.progress.scrollTop = els.progress.scrollHeight;
-  });
-}
-
-function captureProgressDetailState() {
-  for (const detail of els.progress.querySelectorAll('.progress-detail[data-detail-key]')) {
-    state.progressDetailOpenState.set(detail.dataset.detailKey, detail.open);
-  }
-}
-
-function renderProgressText(root, content) {
-  const normalized = typeof content === 'string' ? { title: content, message: '', toolName: '' } : content;
-  const titleRow = document.createElement('div');
-  titleRow.className = 'progress-title-row';
-
-  const title = document.createElement('span');
-  title.className = 'progress-title';
-  title.textContent = normalized.title || 'Event';
-  titleRow.appendChild(title);
-
-  if (normalized.toolName) {
-    const tool = document.createElement('span');
-    tool.className = 'progress-tool';
-    tool.textContent = normalized.toolName;
-    titleRow.appendChild(tool);
-  }
-
-  root.appendChild(titleRow);
-
-  if (normalized.message) {
-    const message = document.createElement('div');
-    message.className = 'progress-message';
-    message.textContent = normalized.message;
-    root.appendChild(message);
-  }
-}
-
-function eventStatus(event) {
-  if (event.type === 'tool_call_failed' || event.type === 'run_failed') return 'failed';
-  if (event.type === 'run_completed') return statusFromValue(event.payload?.status);
-  const payloadStatus = statusFromValue(event.payload?.status);
-  if (payloadStatus !== 'neutral') return payloadStatus;
-  if (hasDisplayValue(event.payload?.error_message) || hasDisplayValue(event.payload?.failure_category)) {
-    return 'failed';
-  }
-  const output = parseMaybeJson(event.tool_output_preview);
-  const outputStatus = statusFromValue(output?.status ?? output?.result?.status);
-  if (outputStatus !== 'neutral') return outputStatus;
-  if (event.type === 'tool_call_completed') return 'success';
-  return 'neutral';
-}
-
-function statusFromValue(value) {
-  if (typeof value !== 'string') return 'neutral';
-  const normalized = value.toLowerCase();
-  if (['success', 'passed', 'pass', 'completed', 'recorded'].includes(normalized)) return 'success';
-  if (['failed', 'failure', 'error', 'cancelled', 'skipped'].includes(normalized)) return 'failed';
-  return 'neutral';
-}
-
-function parseMaybeJson(value) {
-  if (typeof value !== 'string') return value;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-}
-
-function eventLabel(event) {
-  return {
-    title: event.title || event.type || 'Event',
-    message: event.message || '',
-    toolName: event.tool_name || '',
-  };
-}
-
-function eventDetails(event) {
-  const details = [];
-  if (hasDisplayValue(event.tool_arguments)) {
-    details.push({ label: 'Input', value: event.tool_arguments });
-  }
-  if (hasDisplayValue(event.tool_output_preview)) {
-    details.push({ label: 'Output', value: event.tool_output_preview });
-  }
-  if (hasMeaningfulPayload(event.payload)) {
-    details.push({ label: 'Payload', value: event.payload });
-  }
-  return details;
-}
-
-function renderProgressDetail(eventKey, label, value) {
-  const detailKey = `${eventKey}:${label}`;
-  const detail = document.createElement('details');
-  detail.className = 'progress-detail';
-  detail.dataset.detailKey = detailKey;
-  detail.open = state.progressDetailOpenState.get(detailKey) === true;
-  detail.addEventListener('toggle', () => {
-    state.progressDetailOpenState.set(detailKey, detail.open);
-  });
-  const summary = document.createElement('summary');
-  summary.textContent = label;
-  const pre = document.createElement('pre');
-  pre.textContent = formatProgressValue(value);
-  detail.appendChild(summary);
-  detail.appendChild(pre);
-  return detail;
-}
-
-function formatProgressValue(value) {
-  if (typeof value === 'string') {
-    const trimmed = value.trim();
-    if (!trimmed) return '';
-    try {
-      return JSON.stringify(JSON.parse(trimmed), null, 2);
-    } catch {
-      return trimmed;
-    }
-  }
-  if (value === null || value === undefined) return '';
-  if (typeof value === 'object') return JSON.stringify(value, null, 2);
-  return String(value);
-}
-
-function hasDisplayValue(value) {
-  if (value === null || value === undefined) return false;
-  if (typeof value === 'string') return value.trim().length > 0;
-  return true;
-}
-
-function hasMeaningfulPayload(payload) {
-  if (!payload || typeof payload !== 'object') return false;
-  return Object.entries(payload).some(([, value]) => hasDisplayValue(value));
-}
-
-async function ensureReplayVideoGenerated(requestId, frames = null) {
-  if (!requestId) return { error: 'missing replay request id' };
-  if (state.replayVideoInFlight) return { error: 'replay video generation is already running' };
-  const totalStartedAt = performance.now();
-  state.replayVideoInFlight = true;
-  try {
-    const existing = await loadReplayVideo(requestId);
-    if (existing.available && existing.videoUrl) return { videoUrl: existing.videoUrl, blob: null };
-    const replayFrames = frames || (await loadReplayFrames(requestId)).frames;
-    if (replayFrames.length === 0) return { error: 'no replay frames found' };
-    const generated = await generateReplayVideo(replayFrames);
-    if (!generated || !generated.blob || generated.blob.size === 0) return { error: 'MediaRecorder produced an empty video' };
-    const { blob: videoBlob, durationMs } = generated;
-    const seekable = await makeReplaySeekable(videoBlob, durationMs);
-    const uploadBlob = seekable.blob;
-    if (!seekable.ok) {
-      appendProgress(
-        {
-          title: 'Replay video is not seekable',
-          message: `Failed to rewrite WebM index: ${seekable.error}. Uploading the original recording; playback may not support seeking.`,
-        },
-        null,
-        [],
-        'failed',
-      );
-    }
-    const uploaded = await uploadReplayVideo(requestId, uploadBlob);
-    replayVideoDurationLog('total', totalStartedAt, { frameCount: replayFrames.length, size: uploadBlob.size });
-    return { videoUrl: uploaded.videoUrl, blob: uploadBlob };
-  } catch (error) {
-    console.warn('Unable to generate replay video', error);
-    return { error: error.message || String(error) };
-  } finally {
-    state.replayVideoInFlight = false;
-  }
-}
-
-function replayVideoDurationLog(stage, startedAt, metadata = {}) {
-  console.info('[replay-video] duration', {
-    stage,
-    elapsedMs: Math.round(performance.now() - startedAt),
-    ...metadata,
-  });
-}
-
-function appendReplayVideoGeneratingProgress() {
-  appendProgress(
-    {
-      title: 'Generating replay video...',
-      message: 'Encoding replay frames and saving the video.',
-    },
-    null,
-    [],
-  );
-}
-
-function appendReplayFramesProgress(frames) {
-  appendProgress(
-    {
-      title: 'Replay frames loaded',
-      message: `${frames.length} screenshot${frames.length === 1 ? '' : 's'} will be used for the replay video.`,
-    },
-    null,
-    [{ label: 'Screenshots', value: replayFrameSummaries(frames) }],
-    frames.length > 0 ? 'success' : 'failed',
-  );
-}
-
-function replayFrameSummaries(frames) {
-  return frames.map((frame) => ({
-    index: frame.index ?? null,
-    timestamp: frame.timestamp ?? null,
-    path: frame.path || '',
-  }));
-}
-
-async function loadReplayVideo(requestId) {
-  return api(`/replay-video/${encodeURIComponent(requestId)}`);
-}
-
-async function uploadReplayVideo(requestId, videoBlob) {
-  const videoBase64 = await blobToBase64(videoBlob);
-  return api(`/replay-video/${encodeURIComponent(requestId)}`, {
-    method: 'POST',
-    body: JSON.stringify({ mimeType: 'video/webm', videoBase64 }),
-  });
-}
-
-async function loadReplayFrames(requestId) {
-  const replay = await api(`/replay/${encodeURIComponent(requestId)}`);
-  const frames = (replay.frames || [])
-    .filter((frame) => typeof frame.screenshot === 'string')
-    .map((frame, index) => ({
-      index: Number.isFinite(Number(frame.index)) ? Number(frame.index) : index + 1,
-      timestamp: Number.isFinite(Number(frame.timestamp)) ? Number(frame.timestamp) : null,
-      path: typeof frame.path === 'string' ? frame.path : '',
-      src: `data:image/png;base64,${frame.screenshot}`,
-    }));
-  return { frames };
-}
-
-async function refreshPreviewFromReplay(requestId) {
-  if (!requestId) return;
-  try {
-    const replay = await loadReplayFrames(requestId);
-    const frame = replay.frames[replay.frames.length - 1];
-    if (frame) showReplayFrame(frame);
-  } catch {
-    // The screenshot artifact may have been announced before the replay endpoint can read it.
-  }
-}
-
-function replayFrameDelay(current, next) {
-  if (typeof current.timestamp === 'number' && typeof next.timestamp === 'number') {
-    const rawDelay = Math.max(0, next.timestamp - current.timestamp);
-    if (rawDelay === 0) return REPLAY_FAST_SAME_EVENT_DELAY_MS;
-    return Math.min(
-      REPLAY_FAST_MAX_DELAY_MS,
-      Math.max(REPLAY_FAST_ACTION_DELAY_MS, rawDelay / REPLAY_FAST_TIME_SCALE),
-    );
-  }
-  return REPLAY_FAST_FALLBACK_DELAY_MS;
-}
-
-async function generateReplayVideo(frames) {
-  if (!window.MediaRecorder || frames.length === 0) return null;
-  const mimeType = replayVideoMimeType();
-  if (!mimeType) return null;
-  const canvas = document.createElement('canvas');
-  const context = canvas.getContext('2d');
-  if (!context || !canvas.captureStream) return null;
-  const firstImage = await loadImageElement(frames[0].src);
-  canvas.width = firstImage.naturalWidth || firstImage.width;
-  canvas.height = firstImage.naturalHeight || firstImage.height;
-  context.drawImage(firstImage, 0, 0, canvas.width, canvas.height);
-  console.info('[replay-video] draw screenshot', replayFrameDrawLogEntry(frames[0], 1, replayFrameDisplayDuration(frames, 0)));
-  const chunks = [];
-  const stream = canvas.captureStream(30);
-  const videoTrack = stream.getVideoTracks()[0];
-  const requestCanvasFrame = () => {
-    if (videoTrack && typeof videoTrack.requestFrame === 'function') {
-      videoTrack.requestFrame();
-    }
-  };
-  const recorder = new MediaRecorder(stream, { mimeType });
-  recorder.ondataavailable = (event) => {
-    if (event.data.size > 0) chunks.push(event.data);
-  };
-  recorder.start();
-  const recordingStartedAt = performance.now();
-  const renderStartedAt = recordingStartedAt;
-  requestCanvasFrame();
-  for (let index = 1; index < frames.length; index += 1) {
-    await waitMs(replayFrameDelay(frames[index - 1], frames[index]));
-    const image = await loadImageElement(frames[index].src);
-    context.drawImage(image, 0, 0, canvas.width, canvas.height);
-    console.info('[replay-video] draw screenshot', replayFrameDrawLogEntry(frames[index], index + 1, replayFrameDisplayDuration(frames, index)));
-    requestCanvasFrame();
-  }
-  await waitMs(REPLAY_FAST_FINAL_FRAME_HOLD_MS);
-  requestCanvasFrame();
-  const recordingEndedAt = await new Promise((resolve) => {
-    recorder.onstop = () => {
-      const endedAt = performance.now();
-      replayVideoDurationLog('render and record timeline', renderStartedAt, { chunkCount: chunks.length, frameCount: frames.length });
-      resolve(endedAt);
-    };
-    recorder.stop();
-  });
-  stream.getTracks().forEach((track) => track.stop());
-  const blob = new Blob(chunks, { type: recorder.mimeType || 'video/webm' });
-  return { blob, durationMs: Math.max(0, recordingEndedAt - recordingStartedAt) };
-}
-
-function replayFrameDisplayDuration(frames, index) {
-  const nextFrame = frames[index + 1] || null;
-  return nextFrame ? replayFrameDelay(frames[index], nextFrame) : REPLAY_FAST_FINAL_FRAME_HOLD_MS;
-}
-
-function replayFrameDrawLogEntry(frame, fallbackIndex, durationMs) {
-  return {
-    index: frame?.index ?? fallbackIndex,
-    path: frame?.path || '',
-    durationMs,
-  };
-}
-
-function replayVideoMimeType() {
-  const candidates = ['video/webm;codecs=vp9', 'video/webm;codecs=vp8', 'video/webm'];
-  return candidates.find((mimeType) => MediaRecorder.isTypeSupported(mimeType)) || '';
-}
-
-async function showReplayVideoPreview(videoUrl) {
-  clearStepArtifactPreview();
-  cancelPendingReplayVideoReadyWait();
-  if (els.replayVideo.src !== videoUrl) {
-    els.replayVideo.src = videoUrl;
-  }
-  els.replayVideo.pause();
-  try {
-    els.replayVideo.currentTime = 0;
-  } catch {
-    // Some browsers reject seeking before metadata is available.
-  }
-  await waitForReplayVideoReady();
-  try {
-    els.replayVideo.currentTime = 0;
-  } catch {
-    // Some browsers reject seeking before metadata is available.
-  }
-  els.screenshot.style.display = 'none';
-  els.previewEmpty.style.display = 'none';
-  els.replayVideo.hidden = false;
-  els.replayVideo.style.display = 'block';
-}
-
-function waitForReplayVideoReady() {
-  if (els.replayVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) return Promise.resolve();
-  return new Promise((resolve) => {
-    const complete = () => {
-      cleanup();
-      resolve();
-    };
-    const cleanup = () => {
-      els.replayVideo.removeEventListener('loadeddata', complete);
-      els.replayVideo.removeEventListener('canplay', complete);
-      els.replayVideo.removeEventListener('error', complete);
-      state.pendingReplayVideoCleanup = null;
-    };
-    state.pendingReplayVideoCleanup = cleanup;
-    els.replayVideo.addEventListener('loadeddata', complete, { once: true });
-    els.replayVideo.addEventListener('canplay', complete, { once: true });
-    els.replayVideo.addEventListener('error', complete, { once: true });
-    els.replayVideo.load();
-  });
-}
-
-function cancelPendingReplayVideoReadyWait() {
-  if (!state.pendingReplayVideoCleanup) return;
-  state.pendingReplayVideoCleanup();
-}
-
-async function makeReplaySeekable(blob, durationMsOverride = null) {
-  try {
-    const buffer = await blob.arrayBuffer();
-    const decoder = new Decoder();
-    const reader = new Reader();
-    reader.logging = false;
-    reader.drop_default_duration = false;
-    const elements = decoder.decode(buffer);
-    for (const element of elements) reader.read(element);
-    reader.stop();
-    const readerDuration = Number.isFinite(reader.duration) && reader.duration > 0 ? reader.duration : 0;
-    const overrideDuration = Number.isFinite(durationMsOverride) && durationMsOverride > 0 ? durationMsOverride : 0;
-    const duration = readerDuration || overrideDuration;
-    if (duration <= 0) {
-      return { ok: false, blob, error: 'unable to determine replay duration' };
-    }
-    const readerCues = Array.isArray(reader.cues) ? reader.cues : [];
-    const trackNumber = reader.trackInfo?.trackNumber || 1;
-    const cues = readerCues.length > 0 ? readerCues : buildCuesFromClusters(elements, trackNumber);
-    if (cues.length === 0) {
-      return { ok: false, blob, error: 'no cluster timestamps were found in the recording' };
-    }
-    const metadatas = Array.isArray(reader.metadatas) && reader.metadatas.length > 0 ? reader.metadatas : elements;
-    const refined = ebmlTools.makeMetadataSeekable(metadatas, duration, cues);
-    const body = buffer.slice(reader.metadataSize);
-    return { ok: true, blob: new Blob([refined, body], { type: blob.type || 'video/webm' }) };
-  } catch (error) {
-    return { ok: false, blob, error: error?.message || String(error) };
-  }
-}
-
-function buildCuesFromClusters(elements, trackNumber) {
-  const cues = [];
-  for (let index = 0; index < elements.length; index += 1) {
-    const element = elements[index];
-    if (element?.type !== 'm' || element.name !== 'Cluster' || element.isEnd) continue;
-    const clusterPosition = element.tagStart;
-    if (!Number.isFinite(clusterPosition)) continue;
-    let cueTime = null;
-    for (let lookahead = index + 1; lookahead < elements.length; lookahead += 1) {
-      const child = elements[lookahead];
-      if (child?.type === 'm' && child.name === 'Cluster') break;
-      if ((child?.name === 'Timestamp' || child?.name === 'Timecode') && Number.isFinite(child.value)) {
-        cueTime = child.value;
-        break;
-      }
-    }
-    if (cueTime === null) continue;
-    cues.push({
-      CueTrack: trackNumber,
-      CueClusterPosition: clusterPosition,
-      CueTime: cueTime,
-    });
-  }
-  return cues;
-}
-
-function showReplayFrame(frame) {
-  clearStepArtifactPreview();
-  cancelPendingReplayVideoReadyWait();
-  els.replayVideo.hidden = true;
-  els.replayVideo.style.display = 'none';
-  els.screenshot.src = frame.src;
-  els.screenshot.style.display = 'block';
-  els.previewEmpty.style.display = 'none';
-}
-
-function preloadImage(src) {
-  return loadImageElement(src).then(() => undefined);
-}
-
-function loadImageElement(src) {
-  return new Promise((resolve, reject) => {
-    const image = new Image();
-    image.onload = () => resolve(image);
-    image.onerror = reject;
-    image.src = src;
-  });
-}
-
-function waitMs(durationMs) {
-  return new Promise((resolve) => window.setTimeout(resolve, durationMs));
-}
-
-function blobToBase64(blob) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(String(reader.result).split(',', 2)[1] || '');
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-
-function clearPreview(message = '') {
-  clearStepArtifactPreview();
-  cancelPendingReplayVideoReadyWait();
-  els.previewEmpty.textContent = message;
-  els.previewEmpty.style.display = 'block';
-  if (els.replayVideo.src) {
-    els.replayVideo.pause();
-    els.replayVideo.removeAttribute('src');
-    els.replayVideo.load();
-  }
-  els.replayVideo.hidden = true;
-  els.replayVideo.style.display = 'none';
-  els.screenshot.removeAttribute('src');
-  els.screenshot.style.display = 'none';
-}
-
-function initPanelResizer() {
-  if (!els.shell || !els.controlPanel || !els.panelResizer) return;
-  restoreControlPanelWidth();
-
-  els.panelResizer.addEventListener('pointerdown', (event) => {
-    if (event.button !== 0) return;
-    event.preventDefault();
-    els.panelResizer.setPointerCapture?.(event.pointerId);
-    els.shell.classList.add('resizing-panels');
-
-    const onPointerMove = (moveEvent) => {
-      applyControlPanelWidth(widthFromPointer(moveEvent.clientX));
-    };
-    const onPointerUp = () => {
-      els.shell.classList.remove('resizing-panels');
-      window.removeEventListener('pointermove', onPointerMove);
-      window.removeEventListener('pointerup', onPointerUp);
-      persistControlPanelWidth();
-    };
-
-    window.addEventListener('pointermove', onPointerMove);
-    window.addEventListener('pointerup', onPointerUp, { once: true });
-  });
-
-  els.panelResizer.addEventListener('keydown', (event) => {
-    if (event.key !== 'ArrowLeft' && event.key !== 'ArrowRight') return;
-    event.preventDefault();
-    const delta = (event.shiftKey ? 40 : 16) * (event.key === 'ArrowLeft' ? -1 : 1);
-    applyControlPanelWidth(currentControlPanelWidth() + delta);
-    persistControlPanelWidth();
-  });
-}
-
-function widthFromPointer(clientX) {
-  const shellRect = els.shell.getBoundingClientRect();
-  const shellStyle = window.getComputedStyle(els.shell);
-  const paddingLeft = Number.parseFloat(shellStyle.paddingLeft) || 0;
-  return clientX - shellRect.left - paddingLeft;
-}
-
-function currentControlPanelWidth() {
-  return els.controlPanel.getBoundingClientRect().width;
-}
-
-function applyControlPanelWidth(width) {
-  const clamped = clampControlPanelWidth(width);
-  els.shell.style.setProperty('--control-panel-width', `${Math.round(clamped)}px`);
-  els.panelResizer.setAttribute('aria-valuenow', String(Math.round(clamped)));
-}
-
-function clampControlPanelWidth(width) {
-  const shellStyle = window.getComputedStyle(els.shell);
-  const paddingLeft = Number.parseFloat(shellStyle.paddingLeft) || 0;
-  const paddingRight = Number.parseFloat(shellStyle.paddingRight) || 0;
-  const available = els.shell.clientWidth - paddingLeft - paddingRight;
-  const maxWidth = Math.max(
-    CONTROL_PANEL_MIN_WIDTH,
-    Math.min(CONTROL_PANEL_MAX_WIDTH, available - PREVIEW_PANEL_MIN_WIDTH),
-  );
-  return Math.min(Math.max(width, CONTROL_PANEL_MIN_WIDTH), maxWidth);
-}
-
-function restoreControlPanelWidth() {
-  try {
-    const saved = Number(window.localStorage.getItem(CONTROL_PANEL_WIDTH_STORAGE_KEY));
-    if (Number.isFinite(saved) && saved > 0) applyControlPanelWidth(saved);
-  } catch {
-    // localStorage is optional for the resizer.
-  }
-}
-
-function persistControlPanelWidth() {
-  try {
-    window.localStorage.setItem(CONTROL_PANEL_WIDTH_STORAGE_KEY, String(Math.round(currentControlPanelWidth())));
-  } catch {
-    // localStorage is optional for the resizer.
-  }
-}
-
-els.refresh.addEventListener('click', clearPage);
-els.runSelected.addEventListener('click', runSelected);
-els.loadRunToggle.addEventListener('click', toggleLoadRunForm);
-els.loadRunSubmit.addEventListener('click', loadExistingRun);
-els.loadRunCancel.addEventListener('click', () => resetLoadRunForm({ collapse: true }));
-els.loadRunPath.addEventListener('keydown', (event) => {
-  if (event.key !== 'Enter') return;
-  event.preventDefault();
-  loadExistingRun();
-});
-els.progressRunId.addEventListener('click', handleProgressRunIdClick);
-els.yamlInputTab.addEventListener('click', () => showYamlView('input'));
-els.yamlLifecycleSave.addEventListener('click', saveLifecycleDraft);
-els.yamlLifecycleDiscard.addEventListener('click', discardLifecycleDraft);
-els.yamlRecordedTab.addEventListener('click', () => showYamlView('recorded'));
-els.yamlProgressTab.addEventListener('click', () => showYamlView('progress'));
-document.addEventListener('click', handleYamlRegionClick);
-document.addEventListener('click', handleProgressItemClick);
-els.caseYaml.addEventListener('keydown', (event) => {
-  if (event.key !== 'Enter') return;
-  event.preventDefault();
-  loadInputYaml();
-});
-els.caseYaml.addEventListener('blur', () => {
-  const path = els.caseYaml.value.trim();
-  if (path && path !== state.yamlInputLastPreviewPath) loadInputYaml();
-});
-for (const input of els.runModeInputs) {
-  input.addEventListener('change', () => {
-    switchRunMode();
-    if ((currentRunMode() === 'yaml' || currentRunMode() === 'strict-yaml') && !state.currentRequestId) {
-      els.caseYaml.focus();
-    }
-  });
-}
-els.previewTab.addEventListener('click', () => showRightTab('preview'));
-els.reportTab.addEventListener('click', () => showRightTab('report'));
-clearYamlInput();
-clearRecordedYaml();
-initPanelResizer();
-updateRunMode();
-showRightTab('preview');
-refreshAll();
-
diff --git a/fsq_agent/adapters/SPEC.md b/fsq_agent/adapters/SPEC.md
index acb39789..18d3e690 100644
--- a/fsq_agent/adapters/SPEC.md
+++ b/fsq_agent/adapters/SPEC.md
@@ -2,7 +2,7 @@
 
 ## Purpose
 
-Own external protocol adaptation for the public CLI, local Control Plane, local Playground, and coding-agent runtimes. Adapters decode external inputs, invoke inward public contracts, and project safe output. They do not own Application validation, execution semantics, persistence formats, capability policy, or platform automation.
+Own external protocol adaptation for the public CLI, local Control Plane, and coding-agent runtimes. Adapters decode external inputs, invoke inward public contracts, and project safe output. They do not own Application validation, execution semantics, persistence formats, capability policy, or platform automation.
 
 ## Dependencies
 
@@ -12,17 +12,15 @@ Adapters may import public APIs from `application`, `execution`, `models`, `conf
 
 - `adapters.cli` owns the `fsq` Click command tree and exports `main`.
 - `adapters.control_plane` owns `ControlPlaneServer`, `ControlPlaneServerOptions`, `run_control_plane`, and the documented HTTP/SSE/static API.
-- `adapters.control_plane.playground` owns `PlaygroundServer`, `PlaygroundServerOptions`, `run_playground`, and the documented Playground HTTP/static API.
 - `adapters.coding_agent` owns the OpenAI Agents SDK implementation of public Agent runtime protocols. Its concrete runtime and SDK tool adapters are private; composition roots consume its public runtime factory.
 
-The installed scripts target canonical `fsq_agent.adapters.cli:main`. Existing `fsq_agent.cli`, `fsq_agent.control_plane`, and `fsq_agent.playground` packages remain compatibility entries for documented public symbols only, and each compatibility symbol references the canonical adapter object. Old private transport submodule imports are unsupported and absent.
+The installed scripts target canonical `fsq_agent.adapters.cli:main`. Existing `fsq_agent.cli` and `fsq_agent.control_plane` packages remain compatibility entries for documented public symbols only, and each compatibility symbol references the canonical adapter object. Old private transport submodule imports are unsupported and absent.
 
 ## Internal Structure
 
 - `cli/`: CLI parsing, presentation, output modes, and exit mapping.
 - `control_plane/`: Control Plane HTTP/SSE/static transport, projections, and state.
 - `control_plane/static/`: Generated Control Plane package data.
-- `control_plane/playground/`: Playground HTTP/static transport, independent session/task state, and generated `static/` package data.
 - `coding_agent/`: OpenAI Agents SDK runtime construction, SDK tool/schema conversion, stream-event/result adaptation, and public runtime factory.
 - Adapter-private `_*.py` files are not imported by inward modules.
 
@@ -43,9 +41,8 @@ Adapters map stable inward failures into documented exit codes or safe HTTP/SSE
 
 - Public compatibility packages do not duplicate transport implementations, package data, or mutable state.
 - CLI and Control Plane business operations continue through Application.
-- Control Plane and Playground remain behaviorally and statefully independent.
-- Control Plane and Playground HTML entry points, JavaScript, CSS, `entry-assets.json`, and all referenced generated assets are runtime package data included in both wheel and source distribution, with unchanged serving URLs. Installed `fsq ui` resolves these resources from the installed package without a frontend source tree, Node.js, or runtime asset download.
-- CLI, Control Plane, and Playground use the same public Execution services; adapter-private modules do not implement lifecycle or recording policy.
-- CLI, Control Plane, and Playground composition roots inject the same Coding Agent runtime implementation into SDK-neutral Agent orchestration. Application and inward packages never import `adapters.coding_agent`.
+- Control Plane HTML, JavaScript, CSS, `entry-assets.json`, and all referenced generated assets are runtime package data included in both wheel and source distribution. Installed `fsq ui` resolves these resources from the installed package without a frontend source tree, Node.js, or runtime asset download.
+- CLI and Control Plane use the same public Execution services; adapter-private modules do not implement lifecycle or recording policy.
+- CLI and Control Plane composition roots inject the same Coding Agent runtime implementation into SDK-neutral Agent orchestration. Application and inward packages never import `adapters.coding_agent`.
 - CLI keeps this composition in a private helper rather than in command handlers. The helper may construct `FsqAgent` with the public Coding Agent runtime factory and return the SDK-neutral collaborator expected by Application, but it does not validate requests or own execution policy.
 - Module relocation does not change CLI, HTTP, SSE, frontend, workspace, Case, evidence, report, Provider, or Runs contracts.
diff --git a/fsq_agent/adapters/coding_agent/SPEC.md b/fsq_agent/adapters/coding_agent/SPEC.md
index a48bee69..0e641942 100644
--- a/fsq_agent/adapters/coding_agent/SPEC.md
+++ b/fsq_agent/adapters/coding_agent/SPEC.md
@@ -47,5 +47,5 @@ Missing SDK packages remain runtime configuration errors rather than import-time
 - Main execution, pre-plan, and verification preserve current SDK behavior, model settings, tracing, context trimming, event metadata, and structured output contracts.
 - Capability calls continue through Core `StepRunner`; AgentTool calls continue through Tools-owned behavior.
 - Harness construction remains lazy and browser/application lifecycle remains explicit capability behavior.
-- CLI, Control Plane, and Playground inject the same runtime factory at composition boundaries.
+- CLI and Control Plane inject the same runtime factory at composition boundaries.
 - Relocation does not change CLI, HTTP/SSE, reports, evidence, provider configuration, workspace behavior, or `fsq runs`.
diff --git a/fsq_agent/adapters/control_plane/playground/__init__.py b/fsq_agent/adapters/control_plane/playground/__init__.py
deleted file mode 100644
index 53e3253e..00000000
--- a/fsq_agent/adapters/control_plane/playground/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from fsq_agent.adapters.control_plane.playground._server import PlaygroundServer, PlaygroundServerOptions, run_playground
-
-__all__ = ["PlaygroundServer", "PlaygroundServerOptions", "run_playground"]
diff --git a/fsq_agent/adapters/control_plane/playground/_android.py b/fsq_agent/adapters/control_plane/playground/_android.py
deleted file mode 100644
index 17a92872..00000000
--- a/fsq_agent/adapters/control_plane/playground/_android.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from __future__ import annotations
-
-import base64
-import time
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from fsq_agent.adapters.control_plane.playground._state import PlaygroundSession
-from fsq_agent.core import AndroidDeviceDiscovery, DriverFactory
-
-if TYPE_CHECKING:
-    from fsq_agent.config import Settings
-    from fsq_agent.models import AndroidDevice
-
-
-@dataclass(frozen=True)
-class AndroidTarget:
-    id: str
-    label: str
-    description: str = ""
-    status: str = "device"
-    is_default: bool = False
-
-    def to_json(self) -> dict[str, object]:
-        return {
-            "id": self.id,
-            "label": self.label,
-            "description": self.description,
-            "status": self.status,
-            "isDefault": self.is_default,
-        }
-
-
-def _project_android_targets(devices: list[AndroidDevice]) -> list[AndroidTarget]:
-    targets: list[AndroidTarget] = []
-    for device in devices:
-        if device.state != "device":
-            continue
-        description_parts = [device.metadata.get("model"), device.metadata.get("device"), device.metadata.get("product")]
-        description = " · ".join(value for value in description_parts if value)
-        targets.append(
-            AndroidTarget(
-                id=device.serial,
-                label=device.serial,
-                description=description.replace("_", " ") or device.state,
-                status=device.state,
-                is_default=False,
-            )
-        )
-    if len(targets) == 1:
-        targets[0] = AndroidTarget(
-            id=targets[0].id,
-            label=targets[0].label,
-            description=targets[0].description,
-            status=targets[0].status,
-            is_default=True,
-        )
-    return targets
-
-
-def discover_adb_targets(timeout_seconds: float = 5.0) -> tuple[list[AndroidTarget], str | None]:
-    result = AndroidDeviceDiscovery().discover(timeout_seconds=timeout_seconds)
-    return _project_android_targets(result.devices), result.error_message
-
-
-def build_android_setup_schema(settings: Settings) -> dict[str, object]:
-    targets, error = discover_adb_targets()
-    default_device_id = next((target.id for target in targets if target.is_default), None)
-    _, auto_info = _resolve_auto_session_from_targets(targets, error)
-    return {
-        "title": "FSQ-Agent Android Playground",
-        "description": "Select an available ADB device to run dynamic goals.",
-        "primaryActionLabel": "Create Session",
-        "autoSubmitWhenReady": len(targets) == 1,
-        "notice": {"type": "warning", "message": "Android device discovery failed", "description": error} if error else None,
-        "fields": [
-            {
-                "key": "deviceId",
-                "label": "ADB device",
-                "type": "select",
-                "required": True,
-                "options": [{"label": target.label, "value": target.id, "description": target.description} for target in targets],
-                "defaultValue": default_device_id,
-                "placeholder": "Select a connected Android device",
-            }
-        ],
-        "targets": [target.to_json() for target in targets],
-        "autoCreate": auto_info,
-    }
-
-
-def resolve_auto_session(settings: Settings) -> tuple[PlaygroundSession | None, dict[str, object]]:
-    del settings
-    targets, error = discover_adb_targets()
-    return _resolve_auto_session_from_targets(targets, error)
-
-
-def _resolve_auto_session_from_targets(
-    targets: list[AndroidTarget],
-    error: str | None,
-) -> tuple[PlaygroundSession | None, dict[str, object]]:
-    online_targets = [target for target in targets if target.status == "device"]
-    target_payloads = [target.to_json() for target in targets]
-
-    if len(online_targets) == 1:
-        target = online_targets[0]
-        return _session_from_target(target), {
-            "available": True,
-            "reason": "single_device",
-            "deviceId": target.id,
-            "targets": target_payloads,
-        }
-    if error and not online_targets:
-        return None, {
-            "available": False,
-            "reason": "adb_error",
-            "message": error,
-            "targets": target_payloads,
-        }
-    if not online_targets:
-        return None, {
-            "available": False,
-            "reason": "no_devices",
-            "message": "No online Android devices found.",
-            "targets": target_payloads,
-        }
-    return None, {
-        "available": False,
-        "reason": "multiple_devices",
-        "message": "Multiple Android devices are online. Select one to continue.",
-        "targets": target_payloads,
-    }
-
-
-def _session_from_target(target: AndroidTarget) -> PlaygroundSession:
-    return PlaygroundSession(
-        connected=True,
-        device_id=target.id,
-        display_name=target.label,
-        metadata={"platform": "android", "description": target.description, "status": target.status},
-    )
-
-
-def capture_android_screenshot(settings: Settings, device_id: str | None) -> dict[str, object]:
-    app_id = settings.harness.android.app_id
-    if not app_id:
-        return {"available": False, "error": "The workspace Android target app_id is required for screenshots."}
-    driver = DriverFactory().create_android_driver(
-        settings.harness.android,
-        app_id=app_id,
-        serial=device_id,
-    )
-    screenshot = driver.screenshot()
-    return {
-        "available": True,
-        "screenshot": base64.b64encode(screenshot).decode("ascii"),
-        "timestamp": int(time.time() * 1000),
-    }
diff --git a/fsq_agent/adapters/control_plane/playground/_execution.py b/fsq_agent/adapters/control_plane/playground/_execution.py
deleted file mode 100644
index 1d4c2b46..00000000
--- a/fsq_agent/adapters/control_plane/playground/_execution.py
+++ /dev/null
@@ -1,794 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from __future__ import annotations
-
-import asyncio
-import json
-import re
-import threading
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Never
-
-from pydantic import ValidationError
-
-from fsq_agent._capability_bootstrap import build_capability_registry
-from fsq_agent._workspace_paths import resolve_workspace_cases_path
-from fsq_agent.adapters.coding_agent import create_coding_agent_runtime
-from fsq_agent.agent import FsqAgent
-from fsq_agent.case_dsl import FSQ_CASE_SUFFIX, FsqCaseLoader, FsqExecutableStepAdapter, is_fsq_case_file
-from fsq_agent.config import refresh_provider_settings, validate_runtime_settings, validate_strict_core_settings
-from fsq_agent.core import (
-    ArtifactStore,
-    EvidenceRecorder,
-    HarnessFactory,
-    HarnessInterface,
-    RuntimeSecretStore,
-)
-from fsq_agent.execution import (
-    DynamicExecutionRequest,
-    DynamicExecutionService,
-    LifecycleExecutionRequest,
-    LifecycleExecutionService,
-    RecordingService,
-    RunArtifactIndex,
-    RunResultSummary,
-    RunSource,
-    RunStepCounts,
-    allocate_run,
-    collect_strict_lifecycle_cases,
-    run_strict_lifecycle_case,
-    transition_run,
-)
-from fsq_agent.models import CapabilityRegistrySnapshot, ConfigurationError, ExecutableStep, ReportArtifact, RunEvent, RunnerEvent, Task, TaskResult, VerificationResult
-from fsq_agent.providers import build_ai_assertion_evaluator
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from fsq_agent.adapters.control_plane.playground._state import PlaygroundState
-    from fsq_agent.config import Settings
-
-
-class PlaygroundTaskCancelledError(RuntimeError):
-    pass
-
-
-def refresh_execution_settings(settings: Settings) -> Settings:
-    snapshot = settings.model_copy(deep=True)
-    user_config_root = settings.openai_agents.user_config_root
-    if user_config_root is None:
-        return snapshot
-    return refresh_provider_settings(snapshot, user_config_root)
-
-
-@dataclass
-class PlaygroundExecutionHandle:
-    request_id: str
-    thread: threading.Thread | None = None
-    _lock: threading.Lock = field(default_factory=threading.Lock)
-    _loop: asyncio.AbstractEventLoop | None = None
-    _task: asyncio.Task[None] | None = None
-    _harness: Any | None = None
-    _cancel_requested: bool = False
-
-    def attach(self, loop: asyncio.AbstractEventLoop, task: asyncio.Task[None]) -> None:
-        with self._lock:
-            self._loop = loop
-            self._task = task
-            cancel_requested = self._cancel_requested
-        if cancel_requested:
-            loop.call_soon_threadsafe(task.cancel)
-
-    def cancel(self) -> None:
-        with self._lock:
-            self._cancel_requested = True
-            loop = self._loop
-            task = self._task
-        if loop is not None and task is not None and not task.done():
-            loop.call_soon_threadsafe(task.cancel)
-
-    def bind_harness(self, harness: Any) -> None:
-        with self._lock:
-            self._harness = harness
-
-    def clear_harness(self) -> None:
-        with self._lock:
-            self._harness = None
-
-    def current_harness(self) -> Any | None:
-        with self._lock:
-            return self._harness
-
-
-def start_dynamic_goal_execution(
-    *,
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    goal: str | None = None,
-    case_yaml_path: str | None = None,
-    strict_case_yaml_path: str | None = None,
-    device_id: str | None,
-    record: bool = True,
-    record_on_failure: bool = True,
-) -> PlaygroundExecutionHandle:
-    handle = PlaygroundExecutionHandle(request_id=request_id)
-    thread = threading.Thread(
-        target=_run_dynamic_task_thread,
-        kwargs={
-            "settings": settings,
-            "state": state,
-            "request_id": request_id,
-            "goal": goal,
-            "case_yaml_path": case_yaml_path,
-            "strict_case_yaml_path": strict_case_yaml_path,
-            "device_id": device_id,
-            "record": record,
-            "record_on_failure": record_on_failure,
-            "handle": handle,
-        },
-        name=f"fsq-playground-{request_id}",
-        daemon=True,
-    )
-    handle.thread = thread
-    thread.start()
-    return handle
-
-
-def task_from_goal(goal: str) -> Task:
-    normalized = " ".join(goal.split())
-    slug = re.sub(r"[^a-z0-9]+", "-", normalized.lower()).strip("-") or "playground-goal"
-    return Task(
-        id=slug[:80],
-        name=normalized,
-        description=normalized,
-        planning_reference_kind="goal",
-        planning_reference_text=normalized,
-    )
-
-
-def task_from_case_yaml(path_text: str, settings: Settings) -> Task:
-    source_path, content = _read_case_yaml_text(path_text, settings)
-    display_path = str(source_path)
-    name = f"Case reference: {source_path.name}"
-    description = (
-        "Run this raw FSQ YAML reference through dynamic LLM execution.\n\n"
-        "The playground has not parsed this YAML into strict executable steps. "
-        "Treat the full file content as advisory planning reference material.\n\n"
-        f"Source path: {display_path}\n\n"
-        "Raw file content:\n"
-        f"{content}"
-    )
-    reference_text = f"Source path: {display_path}\n\nRaw file content:\n{content}"
-    slug_source = source_path.name.removesuffix(FSQ_CASE_SUFFIX) or "case-yaml"
-    slug = re.sub(r"[^a-z0-9]+", "-", slug_source.lower()).strip("-") or "case-yaml"
-    return Task(
-        id=slug[:80],
-        name=name,
-        description=description,
-        planning_reference_kind="raw_case",
-        planning_reference_text=reference_text,
-    )
-
-
-def _read_case_yaml_text(path_text: str, settings: Settings) -> tuple[Path, str]:
-    requested = Path(path_text.strip())
-    if not is_fsq_case_file(requested):
-        raise ConfigurationError(f"FSQ case files must use the {FSQ_CASE_SUFFIX} suffix.")
-    resolved = resolve_workspace_cases_path(requested, settings.cases.dir)
-    if resolved.exists() and resolved.is_file():
-        return resolved, resolved.read_text(encoding="utf-8")
-    raise FileNotFoundError(f"Case YAML not found: {path_text}")
-
-
-def _run_dynamic_task(
-    *,
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    goal: str | None,
-    case_yaml_path: str | None,
-    strict_case_yaml_path: str | None,
-    device_id: str | None,
-    record: bool,
-    record_on_failure: bool,
-    handle: PlaygroundExecutionHandle | None = None,
-) -> None:
-    asyncio.run(
-        _run_dynamic_task_async(
-            settings=settings,
-            state=state,
-            request_id=request_id,
-            goal=goal,
-            case_yaml_path=case_yaml_path,
-            strict_case_yaml_path=strict_case_yaml_path,
-            device_id=device_id,
-            record=record,
-            record_on_failure=record_on_failure,
-            handle=handle,
-        )
-    )
-
-
-def _run_dynamic_task_thread(
-    *,
-    handle: PlaygroundExecutionHandle,
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    goal: str | None,
-    case_yaml_path: str | None,
-    strict_case_yaml_path: str | None,
-    device_id: str | None,
-    record: bool,
-    record_on_failure: bool,
-) -> None:
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    task = loop.create_task(
-        _run_dynamic_task_async(
-            settings=settings,
-            state=state,
-            request_id=request_id,
-            goal=goal,
-            case_yaml_path=case_yaml_path,
-            strict_case_yaml_path=strict_case_yaml_path,
-            device_id=device_id,
-            record=record,
-            record_on_failure=record_on_failure,
-            handle=handle,
-        )
-    )
-    handle.attach(loop, task)
-    try:
-        loop.run_until_complete(task)
-    except asyncio.CancelledError:
-        state.request_cancel(request_id)
-    finally:
-        asyncio.set_event_loop(None)
-        loop.close()
-
-
-async def _run_dynamic_task_async(
-    *,
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    goal: str | None,
-    case_yaml_path: str | None,
-    strict_case_yaml_path: str | None,
-    device_id: str | None,
-    record: bool,
-    record_on_failure: bool,
-    handle: PlaygroundExecutionHandle | None,
-) -> None:
-    run_settings = settings.model_copy(deep=True)
-    if device_id and run_settings.harness.platform == "android":
-        run_settings.harness.android.serial = device_id
-    try:
-        _raise_if_cancelled(state, request_id)
-        execution_recordings: list[object] = []
-        if goal:
-            validate_runtime_settings(run_settings)
-            task = task_from_goal(goal)
-            result = await _run_agent_task_async(
-                run_settings,
-                state,
-                request_id,
-                task,
-                handle,
-                record=record,
-                allow_recording_failure=record_on_failure,
-                recording_sink=execution_recordings,
-            )
-        elif case_yaml_path:
-            validate_runtime_settings(run_settings)
-            task = task_from_case_yaml(case_yaml_path, run_settings)
-            result = await _run_agent_task_async(
-                run_settings,
-                state,
-                request_id,
-                task,
-                handle,
-                record=record,
-                allow_recording_failure=record_on_failure,
-                recording_sink=execution_recordings,
-            )
-        elif strict_case_yaml_path:
-            if handle is None:
-                result = await asyncio.to_thread(_run_strict_case_yaml, run_settings, state, request_id, strict_case_yaml_path)
-            else:
-                result = await asyncio.to_thread(_run_strict_case_yaml, run_settings, state, request_id, strict_case_yaml_path, handle)
-        else:
-            _raise_missing_execution_source()
-        if state.is_cancel_requested(request_id):
-            return
-        recording = None
-        if execution_recordings:
-            value = execution_recordings[0]
-            recording = {
-                "status": value.status,
-                "recording_path": str(value.recording_path),
-                "recorded_case_path": str(value.recorded_case_path) if value.recorded_case_path else None,
-                "published_case_path": str(value.published_case_path) if value.published_case_path else None,
-                "command_count": value.command_count,
-                "required_runtime_secret_names": list(value.required_runtime_secret_names),
-                "warnings": list(value.warnings),
-                "skipped_tool_calls": [dict(item) for item in value.skipped_tool_calls],
-                "errors": list(value.errors),
-                "validation_status": value.validation_status,
-                "draft": value.draft,
-            }
-        state.finish_task(request_id, result, recording=recording)
-    except asyncio.CancelledError:
-        state.request_cancel(request_id)
-        raise
-    except PlaygroundTaskCancelledError:
-        state.request_cancel(request_id)
-    # Background task failures must be reflected in playground progress state.
-    except Exception as exc:  # noqa: BLE001
-        state.fail_task(request_id, exc)
-    finally:
-        if handle is not None:
-            handle.clear_harness()
-
-
-def _run_agent_task(settings: Settings, state: PlaygroundState, request_id: str, task: Task) -> TaskResult:
-    return asyncio.run(_run_agent_task_async(settings, state, request_id, task))
-
-
-async def _run_agent_task_async(
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    task: Task,
-    handle: PlaygroundExecutionHandle | None = None,
-    *,
-    record: bool = False,
-    allow_recording_failure: bool = False,
-    recording_sink: list[object] | None = None,
-) -> TaskResult:
-    harness_factory = _preview_harness_factory(settings, handle) if handle is not None and settings.harness.platform in {"web", "windows", "macos"} else None
-    agent = FsqAgent.from_settings(settings, create_coding_agent_runtime, harness_factory=harness_factory)
-    execution = await DynamicExecutionService(agent=agent, recording_service=RecordingService()).execute(
-        DynamicExecutionRequest(
-            task=task,
-            settings=settings,
-            event_sink=_event_sink(state, request_id),
-            record=record,
-            allow_recording_failure=allow_recording_failure,
-            publication_directory=settings.cases.dir,
-            cancellation_check=lambda: _raise_if_cancelled(state, request_id),
-        )
-    )
-    if recording_sink is not None and execution.recording is not None:
-        recording_sink.append(execution.recording)
-    return execution.task_result
-
-
-def _raise_if_cancelled(state: PlaygroundState, request_id: str) -> None:
-    if state.is_cancel_requested(request_id):
-        raise PlaygroundTaskCancelledError("Cancelled by user.")
-
-
-def _raise_missing_execution_source() -> Never:
-    raise ValueError("goal, case_yaml_path, or strict_case_yaml_path is required")
-
-
-def _run_strict_case_yaml(
-    settings: Settings,
-    state: PlaygroundState,
-    request_id: str,
-    path_text: str,
-    handle: PlaygroundExecutionHandle | None = None,
-) -> TaskResult:
-    case_path = _resolve_case_yaml_path(path_text, settings)
-    case = FsqCaseLoader().load_case(case_path)
-    registry = build_capability_registry(platform=settings.harness.platform)
-    registry_snapshot = registry.snapshot()
-    lifecycle_cases = collect_strict_lifecycle_cases(case_path=case_path, case=case, settings=settings)
-    for _lifecycle_path, lifecycle_case in lifecycle_cases:
-        _validate_strict_case_platform(settings, lifecycle_case)
-    requires_ai_assertion = any(_case_requires_ai_assertion(lifecycle_case, registry_snapshot) for _lifecycle_path, lifecycle_case in lifecycle_cases)
-    resolved_steps_by_path = {
-        lifecycle_path.resolve(): _resolve_strict_replay_steps(
-            FsqExecutableStepAdapter(registry_snapshot=registry_snapshot).to_executable_steps(lifecycle_case),
-            settings,
-            registry_snapshot,
-        )
-        for lifecycle_path, lifecycle_case in lifecycle_cases
-    }
-    validate_strict_core_settings(settings, requires_ai_assertion=requires_ai_assertion)
-    workspace_root = settings.workspace.root_dir or Path(settings.output.runs_dir).parent.parent.parent
-    workspace_name = _registered_workspace_name(Path(workspace_root))
-    metadata = allocate_run(
-        workspace=Path(workspace_root),
-        workspace_name=workspace_name,
-        platform=settings.harness.platform,
-        source_id=case.id,
-        mode="strict",
-        source=RunSource(
-            kind="case",
-            case_id=case.id,
-            case_path=str(case_path.relative_to(workspace_root)) if case_path.is_relative_to(workspace_root) else case_path.name,
-        ),
-        platform_runs_dir=Path(settings.output.runs_dir),
-    )
-    run_id = metadata.run_id
-    run_dir = Path(settings.output.runs_dir) / run_id
-    metadata = transition_run(run_dir, metadata, "running")
-    state.add_event(
-        request_id,
-        RunEvent(run_id=run_id, task_id=case.id, type="run_started", title="Strict YAML started", message=str(case_path)),
-    )
-    harness = _build_strict_harness(settings, case, run_dir, requires_ai_assertion)
-    if handle is not None and settings.harness.platform in {"web", "windows", "macos"}:
-        handle.bind_harness(harness)
-    cancellable_harness = _CancellableHarness(harness, state, request_id)
-    recorder = _PlaygroundEvidenceRecorder(run_id=run_id, output_dir=run_dir, state=state, request_id=request_id)
-    try:
-        artifact = (
-            LifecycleExecutionService(runner=run_strict_lifecycle_case)
-            .execute(
-                LifecycleExecutionRequest(
-                    case_path=case_path,
-                    case=case,
-                    settings=settings,
-                    harness=cancellable_harness,
-                    output_dir=run_dir,
-                    run_id=run_id,
-                    registry=registry,
-                    registry_snapshot=registry_snapshot,
-                    post_action_delay_seconds=settings.execution.post_action_delay_seconds,
-                    runtime_secret_store=RuntimeSecretStore.from_settings(settings.runtime_secrets),
-                    recorder=recorder,
-                    resolve_steps=lambda steps, _case: _resolve_strict_replay_steps(steps, settings, registry_snapshot),
-                    resolved_steps_by_path=resolved_steps_by_path,
-                    cases_by_path={lifecycle_path.resolve(): lifecycle_case for lifecycle_path, lifecycle_case in lifecycle_cases},
-                    cancellation_check=lambda: _raise_if_cancelled(state, request_id),
-                )
-            )
-            .report
-        )
-    except BaseException:
-        _best_effort_terminal_run(run_dir, metadata, "cancelled" if state.is_cancel_requested(request_id) else "error")
-        raise
-    status, summary = _strict_report_status(artifact)
-    metadata = transition_run(run_dir, metadata, "finalizing")
-    result_status = "success" if status == "passed" else "failed"
-    transition_run(
-        run_dir,
-        metadata,
-        result_status,
-        result=RunResultSummary(summary=summary, steps=_strict_report_step_counts(artifact)),
-        artifacts=RunArtifactIndex(
-            report=artifact.path.with_suffix(".json").name,
-            report_markdown=artifact.path.name,
-            events="events.jsonl" if (run_dir / "events.jsonl").is_file() else None,
-            evidence_manifest=artifact.evidence_manifest_path.name if artifact.evidence_manifest_path else None,
-        ),
-    )
-    state.add_event(
-        request_id,
-        RunEvent(
-            run_id=run_id,
-            task_id=case.id,
-            type="run_completed",
-            title="Strict YAML completed",
-            message=summary,
-            payload={"status": status, "report_path": str(artifact.path)},
-        ),
-    )
-    return TaskResult(
-        task_id=case.id,
-        status=result_status,
-        steps=[],
-        verification=VerificationResult(status=result_status, summary=summary),
-        report=ReportArtifact(run_id=run_id, path=artifact.path, evidence_manifest_path=artifact.evidence_manifest_path),
-    )
-
-
-class _CancellableHarness:
-    def __init__(self, harness: Any, state: PlaygroundState, request_id: str) -> None:
-        self._harness = harness
-        self._state = state
-        self._request_id = request_id
-
-    def _check_cancelled(self) -> None:
-        _raise_if_cancelled(self._state, self._request_id)
-
-    def get_context(self):
-        self._check_cancelled()
-        return self._harness.get_context()
-
-    def action_space(self):
-        return self._harness.action_space()
-
-    def before_action(self, step: ExecutableStep, context) -> None:
-        self._check_cancelled()
-        return self._harness.before_action(step, context)
-
-    def invoke_action(self, step: ExecutableStep, context):
-        self._check_cancelled()
-        return self._harness.invoke_action(step, context)
-
-    def after_action(self, step: ExecutableStep, context, action_result) -> None:
-        self._check_cancelled()
-        return self._harness.after_action(step, context, action_result)
-
-    def capture_artifact(self, *args, **kwargs):
-        self._check_cancelled()
-        return self._harness.capture_artifact(*args, **kwargs)
-
-    def classify_error(self, error: BaseException, phase, step: ExecutableStep):
-        return self._harness.classify_error(error, phase, step)
-
-
-def _resolve_case_yaml_path(path_text: str, settings: Settings) -> Path:
-    requested = Path(path_text.strip())
-    if not is_fsq_case_file(requested):
-        raise ConfigurationError(f"FSQ case files must use the {FSQ_CASE_SUFFIX} suffix.")
-    resolved = resolve_workspace_cases_path(requested, settings.cases.dir)
-    if resolved.exists() and resolved.is_file():
-        return resolved
-    raise FileNotFoundError(f"Case YAML not found: {path_text}")
-
-
-class _PlaygroundEvidenceRecorder(EvidenceRecorder):
-    def __init__(self, *, run_id: str, output_dir: Path, state: PlaygroundState, request_id: str) -> None:
-        super().__init__(run_id=run_id, output_dir=output_dir)
-        self.state = state
-        self.request_id = request_id
-
-    def record_event(self, event: RunnerEvent) -> None:
-        super().record_event(event)
-        self._record_active_step(event)
-        payload = event.payload or {}
-        if event.event_type != "artifact_captured" or payload.get("kind") != "screenshot":
-            return
-        path = payload.get("path")
-        if not isinstance(path, str):
-            return
-        self.state.set_preview(
-            self.request_id,
-            {
-                "runId": event.run_id,
-                "path": path,
-                "timestamp": event.timestamp.isoformat(),
-                "token": f"{event.run_id}:{path}:{event.timestamp.isoformat()}",
-            },
-        )
-
-    def _record_active_step(self, event: RunnerEvent) -> None:
-        if event.event_type != "step_start" or not event.step_id:
-            return
-        self.state.set_active_step(
-            self.request_id,
-            {
-                "stepId": event.step_id,
-                "stepIndex": _step_index_from_step_id(event.step_id),
-            },
-        )
-
-
-def _step_index_from_step_id(step_id: str) -> int | None:
-    match = re.search(r"-step-(\d+)$", step_id)
-    if match is None:
-        return None
-    return int(match.group(1))
-
-
-def _strict_report_status(artifact: ReportArtifact) -> tuple[str, str]:
-    json_path = artifact.path.with_suffix(".json")
-    # Any unreadable or malformed persisted report intentionally maps to the stable failed summary.
-    try:
-        payload = json.loads(json_path.read_text(encoding="utf-8"))
-        status = str(payload.get("summary", {}).get("status") or "failed")
-        failed_steps = payload.get("summary", {}).get("failed_steps")
-    except (OSError, UnicodeDecodeError, json.JSONDecodeError, AttributeError):
-        return "failed", "Strict YAML run completed but report status could not be read."
-    else:
-        return status, f"Strict YAML {status}; failed_steps={failed_steps}"
-
-
-def _strict_report_step_counts(artifact: ReportArtifact) -> RunStepCounts:
-    try:
-        payload = json.loads(artifact.path.with_suffix(".json").read_text(encoding="utf-8"))
-        summary = payload.get("summary", {})
-        total = int(summary.get("total_steps", 0) or 0)
-        failed = int(summary.get("failed_steps", 0) or 0)
-    except (OSError, UnicodeDecodeError, json.JSONDecodeError, AttributeError, TypeError, ValueError):
-        return RunStepCounts()
-    return RunStepCounts(total=total, passed=max(0, total - failed), failed=failed)
-
-
-def _best_effort_terminal_run(run_dir: Path, metadata, status: str) -> None:
-    try:
-        transition_run(run_dir, metadata, status)
-    except Exception:  # noqa: BLE001, S110 - preserve the original execution failure.
-        pass
-
-
-def _registered_workspace_name(workspace_root: Path) -> str:
-    from fsq_agent.config import list_workspace_registry
-
-    resolved = workspace_root.resolve()
-    entry = next((item for item in list_workspace_registry() if item.root_path.resolve() == resolved), None)
-    return entry.name if entry is not None else workspace_root.name
-
-
-def _case_requires_ai_assertion(case, registry_snapshot: CapabilityRegistrySnapshot | None = None) -> bool:
-    snapshot = registry_snapshot or build_capability_registry(platform=case.config.platform).snapshot()
-    return any(step.action_name == "assert_with_ai" for step in FsqExecutableStepAdapter(registry_snapshot=snapshot).to_executable_steps(case))
-
-
-def _resolve_strict_replay_steps(
-    steps: list[ExecutableStep],
-    settings: Settings,
-    registry_snapshot: CapabilityRegistrySnapshot | None = None,
-) -> list[ExecutableStep]:
-    allowed_names = set(settings.runtime_secrets.allowed_env_names)
-    snapshot = registry_snapshot or build_capability_registry(platform=settings.harness.platform).snapshot()
-    resolved_steps = []
-    for step in steps:
-        _validate_runtime_secret_refs(step.params, allowed_names, step.step_id)
-        _validate_resolved_params(step, step.params, snapshot)
-        resolved_steps.append(step)
-    return resolved_steps
-
-
-def _validate_runtime_secret_refs(value: Any, allowed_names: set[str], step_id: str) -> None:
-    for name in _collect_runtime_secret_refs(value):
-        if name not in allowed_names:
-            raise ValueError(f"Runtime secret name is not allowed for strict replay: {name}")
-
-
-def _collect_runtime_secret_refs(value: Any) -> set[str]:
-    names: set[str] = set()
-    _collect_runtime_secret_refs_into(value, names)
-    return names
-
-
-def _collect_runtime_secret_refs_into(value: Any, names: set[str]) -> None:
-    if isinstance(value, dict):
-        text_type = value.get("textType")
-        text = value.get("text")
-        if text_type == "runtimeSecret" and isinstance(text, str) and text.strip():
-            names.add(text.strip())
-            return
-        for item in value.values():
-            _collect_runtime_secret_refs_into(item, names)
-        return
-    if isinstance(value, list):
-        for item in value:
-            _collect_runtime_secret_refs_into(item, names)
-
-
-def _validate_resolved_params(step: ExecutableStep, params: dict[str, Any], registry_snapshot: CapabilityRegistrySnapshot) -> None:
-    capability = registry_snapshot.resolve(step.action_name)
-    if capability is None:
-        return
-    try:
-        capability.params_model.model_validate(params)
-    except ValidationError as exc:
-        raise ValueError(f"Invalid strict replay command after runtime secret resolution: {step.step_id}") from exc
-
-
-def _validate_strict_case_platform(settings: Settings, case) -> None:
-    if case.config.platform == settings.harness.platform:
-        return
-    raise ValueError(f"Strict case platform {case.config.platform!r} does not match configured harness platform {settings.harness.platform!r}.")
-
-
-def _build_strict_harness(settings: Settings, case, run_dir: Path, requires_ai_assertion: bool) -> Any:
-    app_id = None
-    if settings.harness.platform == "android":
-        app_id = settings.harness.android.app_id or case.config.app_id or ""
-        if not app_id:
-            raise ValueError("Android app id is required for strict YAML runs.")
-    return HarnessFactory().create_harness(
-        platform=settings.harness.platform,
-        harness_settings=settings.harness,
-        artifact_store=ArtifactStore(run_dir=run_dir),
-        ai_assertion_evaluator=build_ai_assertion_evaluator(settings) if requires_ai_assertion else None,
-        runtime_secret_settings=settings.runtime_secrets,
-        app_id=app_id,
-    )
-
-
-def _preview_harness_factory(settings: Settings, handle: PlaygroundExecutionHandle):
-    def factory(run_id: str):
-        if settings.harness.platform == "macos":
-            harness = _build_macos_harness(
-                settings,
-                Path(settings.output.runs_dir) / run_id,
-                requires_ai_assertion=True,
-            )
-        elif settings.harness.platform == "windows":
-            harness = _build_windows_harness(
-                settings,
-                Path(settings.output.runs_dir) / run_id,
-                requires_ai_assertion=True,
-            )
-        else:
-            harness = _build_web_harness(
-                settings,
-                Path(settings.output.runs_dir) / run_id,
-                requires_ai_assertion=True,
-            )
-        handle.bind_harness(harness)
-        return harness
-
-    return factory
-
-
-def _build_web_harness(settings: Settings, run_dir: Path, *, requires_ai_assertion: bool) -> HarnessInterface:
-    return _build_factory_harness(settings, run_dir, requires_ai_assertion=requires_ai_assertion)
-
-
-def _build_windows_harness(settings: Settings, run_dir: Path, *, requires_ai_assertion: bool) -> HarnessInterface:
-    return _build_factory_harness(settings, run_dir, requires_ai_assertion=requires_ai_assertion)
-
-
-def _build_macos_harness(settings: Settings, run_dir: Path, *, requires_ai_assertion: bool) -> HarnessInterface:
-    return _build_factory_harness(settings, run_dir, requires_ai_assertion=requires_ai_assertion)
-
-
-def _build_factory_harness(settings: Settings, run_dir: Path, *, requires_ai_assertion: bool) -> HarnessInterface:
-    return HarnessFactory().create_harness(
-        platform=settings.harness.platform,
-        harness_settings=settings.harness,
-        artifact_store=ArtifactStore(run_dir=run_dir),
-        ai_assertion_evaluator=build_ai_assertion_evaluator(settings) if requires_ai_assertion else None,
-        runtime_secret_settings=settings.runtime_secrets,
-        app_id=settings.harness.android.app_id,
-    )
-
-
-def _event_sink(state: PlaygroundState, request_id: str) -> Callable[[RunEvent], None]:
-    def sink(event: RunEvent) -> None:
-        if state.is_cancel_requested(request_id):
-            return
-        state.add_event(request_id, event)
-        _preview = _preview_from_dynamic_event(event)
-        if _preview is not None:
-            state.set_preview(request_id, _preview)
-
-    return sink
-
-
-def _preview_from_dynamic_event(event: RunEvent) -> dict[str, object] | None:
-    if event.type != "tool_call_completed":
-        return None
-    path = _latest_screenshot_artifact_path(event.payload)
-    if path is None:
-        return None
-    timestamp = event.timestamp.isoformat()
-    return {
-        "runId": event.run_id,
-        "path": path,
-        "timestamp": timestamp,
-        "token": f"{event.run_id}:{path}:{timestamp}",
-    }
-
-
-def _latest_screenshot_artifact_path(payload: dict[str, Any]) -> str | None:
-    artifact_refs = payload.get("artifact_refs")
-    if isinstance(artifact_refs, list):
-        for artifact_ref in reversed(artifact_refs):
-            if not isinstance(artifact_ref, dict) or artifact_ref.get("kind") != "screenshot":
-                continue
-            path = artifact_ref.get("path")
-            if isinstance(path, str) and path:
-                return path
-    artifact_path = payload.get("artifact_path")
-    if isinstance(artifact_path, str) and _looks_like_screenshot_path(artifact_path):
-        return artifact_path
-    return None
-
-
-def _looks_like_screenshot_path(path: str) -> bool:
-    normalized = path.replace("\\", "/").lower()
-    return "/screenshots/" in normalized and normalized.endswith((".png", ".jpg", ".jpeg", ".webp"))
diff --git a/fsq_agent/adapters/control_plane/playground/_server.py b/fsq_agent/adapters/control_plane/playground/_server.py
deleted file mode 100644
index de3db57a..00000000
--- a/fsq_agent/adapters/control_plane/playground/_server.py
+++ /dev/null
@@ -1,1800 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from __future__ import annotations
-
-import base64
-import json
-import mimetypes
-import re
-import shutil
-import time
-import webbrowser
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-from threading import Thread
-from typing import TYPE_CHECKING, Any
-from urllib.parse import parse_qs, unquote, urlparse
-
-import yaml
-
-from fsq_agent._workspace_paths import resolve_workspace_cases_path
-from fsq_agent.adapters.control_plane.playground._android import build_android_setup_schema, capture_android_screenshot, resolve_auto_session
-from fsq_agent.adapters.control_plane.playground._execution import PlaygroundExecutionHandle, refresh_execution_settings, start_dynamic_goal_execution
-from fsq_agent.adapters.control_plane.playground._state import BusyError, PlaygroundState
-from fsq_agent.adapters.control_plane.playground._yaml_lifecycle import (
-    YamlLifecycleConflictError,
-    YamlLifecycleValidationError,
-    YamlLifecycleWriteError,
-    lifecycle_display,
-    save_lifecycle,
-    yaml_revision,
-)
-from fsq_agent.case_dsl import FSQ_CASE_SUFFIX, FsqCaseLoader, is_fsq_case_file
-from fsq_agent.models import ConfigurationError
-from fsq_agent.report import resolve_report_path
-
-if TYPE_CHECKING:
-    from fsq_agent.config import Settings
-
-YAML_DISPLAY_SIZE_LIMIT_BYTES = 512 * 1024
-STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES = 512 * 1024
-_YAML_COMMAND_CONTROL_KEYS = {"optional", "timeout", "timeout_ms", "evidence", "evidencePolicy"}
-_YAML_SETUP_ACTIONS = {"launchApp", "startBrowser"}
-_YAML_TEARDOWN_ACTIONS = {"killApp", "closeBrowser"}
-_YAML_ASSERTION_ACTIONS = {"assert", "assertVisible", "assertNotVisible", "assertText", "assertElementsOrder", "assertWithAI"}
-_YAML_OBSERVATION_ACTIONS = {"takeScreenshot", "startRecording", "stopRecording", "uiSnapshot"}
-_STEP_TEXT_ARTIFACT_KINDS = {"ui_tree", "ui_snapshot"}
-_RUN_RESULT_MARKERS = {
-    "report.md",
-    "report.json",
-    "core-report.md",
-    "core-report.json",
-    "evidence-manifest.json",
-    "events.jsonl",
-    "recording.json",
-    f"recorded{FSQ_CASE_SUFFIX}",
-}
-
-
-class _StepArtifactTextTooLargeError(Exception):
-    def __init__(self, *, size_bytes: int, limit_bytes: int) -> None:
-        super().__init__(f"Step artifact text is too large to display ({size_bytes} bytes).")
-        self.size_bytes = size_bytes
-        self.limit_bytes = limit_bytes
-
-
-def _parse_xml_safely(source: str) -> ET.Element:
-    normalized = source.upper()
-    if "<!DOCTYPE" in normalized or "<!ENTITY" in normalized:
-        raise ET.ParseError("DTD and entity declarations are not allowed.")
-    # DTD and entity declarations are rejected above, preventing attacker-controlled entity expansion.
-    return ET.fromstring(source)  # noqa: S314
-
-
-@dataclass(frozen=True)
-class PlaygroundServerOptions:
-    host: str = "127.0.0.1"
-    port: int = 8765
-    open_browser: bool = True
-    static_path: Path | None = None
-    record: bool = True
-    record_on_failure: bool = True
-
-
-class PlaygroundServer:
-    def __init__(self, settings: Settings, options: PlaygroundServerOptions | None = None) -> None:
-        self.settings = settings
-        self.options = options or PlaygroundServerOptions()
-        self.state = PlaygroundState()
-        self._httpd: _PlaygroundHTTPServer | None = None
-        self._thread: Thread | None = None
-        self._execution_handles: dict[str, PlaygroundExecutionHandle] = {}
-        self._static_root = (self.options.static_path or Path(__file__).parent / "static").resolve()
-
-    @property
-    def url(self) -> str:
-        return f"http://{self.options.host}:{self.port}"
-
-    @property
-    def port(self) -> int:
-        if self._httpd is not None:
-            return int(self._httpd.server_address[1])
-        return self.options.port
-
-    def start(self) -> None:
-        if self._httpd is not None:
-            return
-        if self._static_entry_path() is None:
-            raise FileNotFoundError(f"Playground frontend build not found under {self._static_root}. Run npm ci and npm run build.")
-        self._httpd = _PlaygroundHTTPServer((self.options.host, self.options.port), _RequestHandler, self)
-        self._thread = Thread(target=self._httpd.serve_forever, name="fsq-playground-server", daemon=True)
-        self._thread.start()
-
-    def stop(self) -> None:
-        if self._httpd is None:
-            return
-        self._httpd.shutdown()
-        self._httpd.server_close()
-        if self._thread is not None:
-            self._thread.join(timeout=5)
-        self._httpd = None
-        self._thread = None
-
-    def serve_forever(self) -> None:
-        self.start()
-        try:
-            while True:
-                time.sleep(3600)
-        except KeyboardInterrupt:
-            return
-        finally:
-            self.stop()
-
-    def handle_get(self, path: str, query: dict[str, list[str]]) -> tuple[int, object]:
-        if path == "/status":
-            return 200, self.state.status()
-        if path == "/session":
-            if self.settings.harness.platform != "android":
-                return 200, self._android_unavailable(f"Android session selection is unavailable for the active {self.settings.harness.platform} platform.")
-            return 200, self.state.session.to_json()
-        if path == "/session/setup":
-            if self.settings.harness.platform != "android":
-                return 200, self._android_unavailable(f"Android setup is unavailable for the active {self.settings.harness.platform} platform.")
-            return 200, build_android_setup_schema(self.settings)
-        if path == "/runtime-info":
-            return 200, self._runtime_info()
-        if path == "/yaml/input":
-            return self._yaml_input_response(query)
-        if path.startswith("/yaml/recorded/"):
-            yaml_id = unquote(path.removeprefix("/yaml/recorded/")).strip()
-            return self._yaml_recorded_response(yaml_id)
-        if path.startswith("/runs/") and path.endswith("/progress"):
-            run_id = unquote(path.removeprefix("/runs/").removesuffix("/progress")).strip("/").strip()
-            return self._loaded_run_progress_response(run_id)
-        if path == "/screenshot":
-            if self.settings.harness.platform != "android":
-                return self._web_screenshot_response()
-            if not self.state.session.connected:
-                return 200, {"available": False, "error": "No active session."}
-            try:
-                payload = capture_android_screenshot(self.settings, self.state.session.device_id)
-                if payload.get("available") is True and self.state.current_request_id:
-                    self._record_replay_frame(self.state.current_request_id, payload)
-            except Exception as exc:  # noqa: BLE001 - API returns structured errors.
-                return 500, {"available": False, "error": str(exc) or exc.__class__.__name__}
-            else:
-                return 200, payload
-        if path.startswith("/replay/"):
-            request_id = unquote(path.removeprefix("/replay/")).strip()
-            return self._replay_response(request_id)
-        if path.startswith("/replay-video/"):
-            replay_id = unquote(path.removeprefix("/replay-video/")).strip()
-            return self._replay_video_response(replay_id)
-        if path.startswith("/step-artifacts/"):
-            parts = path.removeprefix("/step-artifacts/").split("/", 1)
-            if len(parts) != 2:
-                return 400, {"available": False, "error": "Step artifact id and step id or index are required."}
-            artifact_id = unquote(parts[0]).strip()
-            step_id_or_index = unquote(parts[1]).strip()
-            return self._step_artifacts_response(artifact_id, step_id_or_index)
-        if path.startswith("/task-progress/"):
-            request_id = unquote(path.removeprefix("/task-progress/")).strip()
-            task = self.state.get_task(request_id, after_sequence=_after_sequence(query))
-            if task is None:
-                return 404, {"error": "Task progress not found."}
-            return 200, task
-        if path.startswith("/preview/"):
-            request_id = unquote(path.removeprefix("/preview/")).strip()
-            return self._preview_response(request_id)
-        if path.startswith("/reports/"):
-            return self._report_response(path, query)
-        return 404, {"error": "Not found."}
-
-    def _preview_response(self, request_id: str) -> tuple[int, object]:
-        task = self.state.get_task(request_id)
-        preview = task.get("preview") if task else None
-        if not isinstance(preview, dict):
-            return 404, {"error": "Preview not found."}
-        run_id = preview.get("runId")
-        path = preview.get("path")
-        if not isinstance(run_id, str) or not isinstance(path, str):
-            return 404, {"error": "Preview not found."}
-        run_dir = Path(self.settings.output.runs_dir) / run_id
-        preview_path = (run_dir / path).resolve()
-        if not _is_relative_to(preview_path, run_dir) or not preview_path.is_file():
-            return 404, {"error": "Preview not found."}
-        return 200, {
-            "requestId": request_id,
-            "runId": run_id,
-            "timestamp": preview.get("timestamp"),
-            "token": preview.get("token"),
-            "screenshot": base64.b64encode(preview_path.read_bytes()).decode("ascii"),
-        }
-
-    def handle_replay_video_file(self, path: str, range_header: str | None = None) -> tuple[int, bytes, str, dict[str, str]]:
-        replay_id = unquote(path.removeprefix("/replay-video-file/")).strip()
-        run_id = self.state.run_id_for_request(replay_id) or replay_id
-        video_path = self._replay_video_path(run_id)
-        if not video_path.exists():
-            payload = {"available": False, "error": "Replay video not found.", "runId": run_id}
-            body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-            return 404, body, "application/json; charset=utf-8", {}
-        total_size = video_path.stat().st_size
-        byte_range = _parse_byte_range(range_header, total_size)
-        if byte_range is None:
-            body = video_path.read_bytes()
-            return 200, body, "video/webm", {"Accept-Ranges": "bytes"}
-        start, end = byte_range
-        with video_path.open("rb") as handle:
-            handle.seek(start)
-            body = handle.read(end - start + 1)
-        headers = {
-            "Accept-Ranges": "bytes",
-            "Content-Range": f"bytes {start}-{end}/{total_size}",
-        }
-        return 206, body, "video/webm", headers
-
-    def handle_post(self, path: str, body: dict[str, object]) -> tuple[int, object]:
-        if path == "/runs/load":
-            return self._load_run_response(body)
-        if path == "/session":
-            if self.settings.harness.platform != "android":
-                return 409, self._android_unavailable(f"Android session selection is unavailable for the active {self.settings.harness.platform} platform.")
-            device_id = body.get("deviceId")
-            if not isinstance(device_id, str) or not device_id.strip():
-                return 400, {"error": "deviceId is required."}
-            try:
-                return 200, {"session": self.state.create_session(device_id), "runtimeInfo": self._runtime_info()}
-            except BusyError as exc:
-                return 409, {"error": str(exc)}
-        if path == "/session/auto":
-            if self.settings.harness.platform != "android":
-                return 409, self._android_unavailable(f"Android auto session selection is unavailable for the active {self.settings.harness.platform} platform.")
-            try:
-                session, info = resolve_auto_session(self.settings)
-                if session is None:
-                    status = 500 if info.get("reason") == "adb_error" else 409
-                    return status, {"error": info.get("message") or "Unable to auto-create Android session.", **info}
-                created = self.state.create_session(session.device_id or "")
-                created["displayName"] = session.display_name
-                created["metadata"] = session.metadata
-                self.state.session.display_name = session.display_name
-                self.state.session.metadata = session.metadata
-                return 200, {"session": created, "runtimeInfo": self._runtime_info(), "autoCreate": info}
-            except BusyError as exc:
-                return 409, {"error": str(exc)}
-        if path == "/execute":
-            goal = body.get("goal")
-            case_yaml_path = body.get("caseYamlPath")
-            strict_case_yaml_path = body.get("strictCaseYamlPath")
-            has_goal = isinstance(goal, str) and bool(goal.strip())
-            has_case_yaml = isinstance(case_yaml_path, str) and bool(case_yaml_path.strip())
-            has_strict_case_yaml = isinstance(strict_case_yaml_path, str) and bool(strict_case_yaml_path.strip())
-            if sum([has_goal, has_case_yaml, has_strict_case_yaml]) != 1:
-                return 400, {"error": "Exactly one of goal, caseYamlPath, or strictCaseYamlPath is required."}
-            if self.settings.harness.platform == "android" and not self.state.session.connected:
-                return 409, {"error": "No active Android session. Create a session before execution."}
-            try:
-                execution_settings = refresh_execution_settings(self.settings)
-            except (ConfigurationError, OSError) as exc:
-                return 400, {"error": str(exc)}
-            if has_goal:
-                task_label = goal.strip()
-            elif has_case_yaml:
-                task_label = f"Case YAML: {case_yaml_path.strip()}"
-            else:
-                task_label = f"Strict YAML: {strict_case_yaml_path.strip()}"
-            try:
-                request_id = self.state.start_task(task_label)
-            except BusyError as exc:
-                return 409, {"error": str(exc)}
-            if has_strict_case_yaml:
-                self._reset_replay_for_known_run(request_id, self._strict_case_run_id(strict_case_yaml_path.strip()))
-            handle = start_dynamic_goal_execution(
-                settings=execution_settings,
-                state=self.state,
-                request_id=request_id,
-                goal=goal.strip() if has_goal else None,
-                case_yaml_path=case_yaml_path.strip() if has_case_yaml else None,
-                strict_case_yaml_path=strict_case_yaml_path.strip() if has_strict_case_yaml else None,
-                device_id=self.state.session.device_id if execution_settings.harness.platform == "android" else None,
-                record=self.options.record,
-                record_on_failure=self.options.record_on_failure,
-            )
-            self._execution_handles[request_id] = handle
-            return 202, {"requestId": request_id}
-        if path.startswith("/replay-video/"):
-            replay_id = unquote(path.removeprefix("/replay-video/")).strip()
-            return self._store_replay_video(replay_id, body)
-        if path.startswith("/cancel/"):
-            request_id = unquote(path.removeprefix("/cancel/")).strip()
-            cancelled = self.state.request_cancel(request_id)
-            if cancelled is None:
-                return 404, {"error": "Task progress not found."}
-            handle = self._execution_handles.pop(request_id, None)
-            if handle is not None:
-                handle.cancel()
-            return 200, cancelled
-        return 404, {"error": "Not found."}
-
-    def handle_put(self, path: str, body: dict[str, object]) -> tuple[int, object]:
-        if path != "/yaml/input/lifecycle":
-            return 404, {"error": "Not found."}
-        if self.state.current_request_id is not None:
-            return 409, {"available": False, "error": "Cannot save YAML while a task is running."}
-        path_text = body.get("path")
-        revision = body.get("revision")
-        if not isinstance(path_text, str) or not path_text.strip():
-            return 400, {"available": False, "error": "path is required."}
-        if not isinstance(revision, str) or not revision:
-            return 400, {"available": False, "error": "revision is required."}
-        try:
-            resolved_path = self._resolve_yaml_input_path(path_text.strip())
-            save_lifecycle(
-                resolved_path,
-                expected_revision=revision,
-                on_case_start=body.get("onCaseStart"),
-                on_case_complete=body.get("onCaseComplete"),
-                size_limit_bytes=YAML_DISPLAY_SIZE_LIMIT_BYTES,
-            )
-            return self._yaml_input_path_response(path_text.strip(), resolved_path)
-        except YamlLifecycleConflictError as exc:
-            return 409, {"available": False, "error": str(exc)}
-        except YamlLifecycleValidationError as exc:
-            status = 413 if "too large" in str(exc).lower() else 400
-            return status, {"available": False, "error": str(exc)}
-        except YamlLifecycleWriteError as exc:
-            return 500, {"available": False, "error": str(exc)}
-        except IsADirectoryError:
-            return 400, {"available": False, "error": f"Case YAML path is a directory: {path_text}"}
-        except FileNotFoundError:
-            return 404, {"available": False, "error": f"Case YAML not found: {path_text}"}
-        except OSError as exc:
-            return 500, {"available": False, "error": str(exc) or exc.__class__.__name__}
-
-    def _load_run_response(self, body: dict[str, object]) -> tuple[int, object]:
-        path_value = body.get("path")
-        if not isinstance(path_value, str) or not path_value.strip():
-            return 400, {"available": False, "error": "Run directory path is required."}
-        runs_root = Path(self.settings.output.runs_dir).resolve()
-        requested = Path(path_value.strip())
-        run_dir = requested.resolve() if requested.is_absolute() else (runs_root / requested).resolve()
-        try:
-            relative = run_dir.relative_to(runs_root)
-        except ValueError:
-            return 400, {"available": False, "error": "Run directory must be inside the configured runs directory."}
-        if len(relative.parts) != 1:
-            return 400, {"available": False, "error": "Run directory must be a direct child of the configured runs directory."}
-        if not run_dir.exists():
-            return 404, {"available": False, "error": f"Run directory not found: {path_value.strip()}"}
-        if not run_dir.is_dir():
-            return 400, {"available": False, "error": "Run path must identify a directory."}
-        if not self._is_recognized_run_dir(run_dir):
-            return 400, {"available": False, "error": "Directory does not contain a recognized run result."}
-        return 200, {
-            "available": True,
-            "runId": relative.name,
-            "availability": self._run_result_availability(run_dir),
-        }
-
-    def _loaded_run_progress_response(self, run_id: str) -> tuple[int, object]:
-        if not run_id:
-            return 400, {"available": False, "error": "Run id is required."}
-        runs_root = Path(self.settings.output.runs_dir).resolve()
-        run_dir = (runs_root / run_id).resolve()
-        try:
-            relative = run_dir.relative_to(runs_root)
-        except ValueError:
-            return 400, {"available": False, "error": "Run id resolves outside the configured runs directory."}
-        if len(relative.parts) != 1:
-            return 400, {"available": False, "error": "Run id must identify a direct child of the configured runs directory."}
-        if not run_dir.exists() or not run_dir.is_dir():
-            return 404, {"available": False, "error": f"Run directory not found: {run_id}"}
-        events_path = run_dir / "events.jsonl"
-        if not events_path.is_file():
-            return 200, {"runId": relative.name, "events": []}
-        try:
-            lines = events_path.read_text(encoding="utf-8").splitlines()
-        except (OSError, UnicodeDecodeError) as exc:
-            return 400, {"available": False, "error": str(exc) or "Unable to read run progress."}
-        events: list[dict[str, object]] = []
-        next_sequence = 0
-        for line in lines:
-            if not line.strip():
-                continue
-            try:
-                event = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if not isinstance(event, dict):
-                continue
-            sequence = event.get("sequence")
-            if isinstance(sequence, int) and not isinstance(sequence, bool) and sequence > 0:
-                next_sequence = max(next_sequence, sequence)
-            else:
-                next_sequence += 1
-                event["sequence"] = next_sequence
-            events.append(event)
-        return 200, {"runId": relative.name, "events": events}
-
-    def _is_recognized_run_dir(self, run_dir: Path) -> bool:
-        if any((run_dir / marker).is_file() for marker in _RUN_RESULT_MARKERS):
-            return True
-        replay_dir = run_dir / "playground-replay"
-        return (replay_dir / "replay-manifest.json").is_file() or (replay_dir / "replay.webm").is_file()
-
-    def _run_result_availability(self, run_dir: Path) -> dict[str, bool]:
-        replay_dir = run_dir / "playground-replay"
-        return {
-            "report": any((run_dir / name).is_file() for name in ("report.md", "report.json", "core-report.md", "core-report.json")),
-            "recordedYaml": (run_dir / "recording.json").is_file() or (run_dir / f"recorded{FSQ_CASE_SUFFIX}").is_file(),
-            "replay": (replay_dir / "replay-manifest.json").is_file() or (replay_dir / "replay.webm").is_file() or self._run_has_screenshot_replay_sources(run_dir),
-            "stepArtifacts": (run_dir / "evidence-manifest.json").is_file() or (run_dir / "events.jsonl").is_file(),
-        }
-
-    def _run_has_screenshot_replay_sources(self, run_dir: Path) -> bool:
-        manifest_path = run_dir / "evidence-manifest.json"
-        if manifest_path.is_file():
-            try:
-                manifest = self._read_evidence_manifest(run_dir)
-            except (OSError, UnicodeDecodeError, json.JSONDecodeError):
-                manifest = None
-            artifacts = manifest.get("artifacts") if isinstance(manifest, dict) else None
-            if isinstance(artifacts, list) and any(isinstance(ref, dict) and self._is_screenshot_artifact_ref(ref) for ref in artifacts):
-                return True
-        events_path = run_dir / "events.jsonl"
-        if not events_path.is_file():
-            return False
-        try:
-            lines = events_path.read_text(encoding="utf-8").splitlines()
-        except (OSError, UnicodeDecodeError):
-            return False
-        for line in lines:
-            try:
-                event = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if not isinstance(event, dict):
-                continue
-            payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-            refs = payload.get("artifact_refs") if isinstance(payload.get("artifact_refs"), list) else []
-            if any(isinstance(ref, dict) and self._is_screenshot_artifact_ref(ref) for ref in refs):
-                return True
-            artifact_path = payload.get("artifact_path")
-            if isinstance(artifact_path, str) and self._is_screenshot_artifact_ref({"path": artifact_path}):
-                return True
-        return False
-
-    def handle_delete(self, path: str) -> tuple[int, object]:
-        if path == "/session":
-            if self.settings.harness.platform != "android":
-                return 409, self._android_unavailable(f"Android session selection is unavailable for the active {self.settings.harness.platform} platform.")
-            try:
-                return 200, {"session": self.state.destroy_session(), "runtimeInfo": self._runtime_info()}
-            except BusyError as exc:
-                return 409, {"error": str(exc)}
-        return 404, {"error": "Not found."}
-
-    def static_response(self, path: str) -> tuple[int, bytes, str]:
-        entry = self._static_entry_path()
-        relative = unquote(path.lstrip("/"))
-        candidate = entry if path in {"/", "/index.html"} else (self._static_root / relative).resolve()
-        if not candidate.is_file() or not _is_relative_to(candidate, self._static_root):
-            candidate = entry
-        if candidate is None or not candidate.is_file() or not _is_relative_to(candidate.resolve(), self._static_root):
-            return 404, b"Not found", "text/plain; charset=utf-8"
-        content_type = mimetypes.guess_type(candidate.name)[0] or "application/octet-stream"
-        if content_type.startswith("text/") or candidate.suffix in {".js", ".css", ".html"}:
-            content_type = f"{content_type}; charset=utf-8"
-        return 200, candidate.read_bytes(), content_type
-
-    def _static_entry_path(self) -> Path | None:
-        for relative in (Path("playground/index.html"), Path("index.html")):
-            candidate = (self._static_root / relative).resolve()
-            if candidate.is_file() and _is_relative_to(candidate, self._static_root):
-                return candidate
-        return None
-
-    def _runtime_info(self) -> dict[str, object]:
-        if self.settings.harness.platform == "web":
-            web = self.settings.harness.web
-            return {
-                "platformId": "web",
-                "title": "FSQ-Agent Web Playground",
-                "interface": {"type": "Web", "description": "FSQ-Agent Web harness"},
-                "preview": {"kind": "screenshot", "screenshotPath": "/screenshot", "live": False},
-                "session": self._android_unavailable("Android session selection is unavailable for the active Web platform."),
-                "metadata": {
-                    "backend": web.backend,
-                    "channel": web.channel,
-                    "browserExecutableConfigured": web.browser_executable_path is not None,
-                    "headless": web.headless,
-                    "baseUrlPresent": bool(web.base_url),
-                    "viewportConfigured": web.viewport_width is not None and web.viewport_height is not None,
-                    "busy": self.state.current_request_id is not None,
-                    "lastRun": self.state.last_run,
-                },
-            }
-        if self.settings.harness.platform == "windows":
-            windows = self.settings.harness.windows
-            return {
-                "platformId": "windows",
-                "title": "FSQ-Agent Windows Playground",
-                "interface": {"type": "Windows", "description": "FSQ-Agent Windows harness"},
-                "preview": {"kind": "screenshot", "screenshotPath": "/screenshot", "live": False},
-                "session": self._android_unavailable("Android session selection is unavailable for the active Windows platform."),
-                "metadata": {
-                    "backend": windows.backend,
-                    "backendKind": windows.backend_kind,
-                    "appPathConfigured": windows.app_path is not None,
-                    "windowTitleRePresent": bool(windows.window_title_re),
-                    "launchArgsCount": len(windows.launch_args),
-                    "busy": self.state.current_request_id is not None,
-                    "lastRun": self.state.last_run,
-                },
-            }
-        if self.settings.harness.platform == "macos":
-            macos = self.settings.harness.macos
-            return {
-                "platformId": "macos",
-                "title": "FSQ-Agent macOS Playground",
-                "interface": {"type": "macOS", "description": "FSQ-Agent Appium Mac2 harness"},
-                "preview": {"kind": "screenshot", "screenshotPath": "/screenshot", "live": False},
-                "session": self._android_unavailable("Android session selection is unavailable for the active macOS platform."),
-                "metadata": {
-                    "backend": macos.backend,
-                    "appiumServerConfigured": macos.appium_server_url is not None,
-                    "bundleIdPresent": macos.bundle_id is not None,
-                    "appPathConfigured": macos.app_path is not None,
-                    "actionTimeoutSeconds": macos.action_timeout_seconds,
-                    "newCommandTimeoutSeconds": macos.new_command_timeout_seconds,
-                    "busy": self.state.current_request_id is not None,
-                    "lastRun": self.state.last_run,
-                },
-            }
-        return {
-            "platformId": "android",
-            "title": "FSQ-Agent Android Playground",
-            "interface": {"type": "Android", "description": "FSQ-Agent Android harness"},
-            "preview": {"kind": "screenshot", "screenshotPath": "/screenshot", "live": False},
-            "session": self.state.session.to_json(),
-            "metadata": {
-                "appIdPresent": bool(self.settings.harness.android.app_id),
-                "selectedDeviceId": self.state.session.device_id,
-                "busy": self.state.current_request_id is not None,
-                "lastRun": self.state.last_run,
-            },
-        }
-
-    def _android_unavailable(self, message: str) -> dict[str, object]:
-        return {
-            "available": False,
-            "platform": self.settings.harness.platform,
-            "connected": False,
-            "message": message,
-        }
-
-    def _web_screenshot_response(self) -> tuple[int, object]:
-        request_id = self.state.current_request_id
-        if not request_id:
-            return 200, {
-                "available": False,
-                "platform": self.settings.harness.platform,
-                "error": f"No active {self.settings.harness.platform} harness execution.",
-            }
-        handle = self._execution_handles.get(request_id)
-        harness = handle.current_harness() if handle is not None else None
-        if harness is None:
-            return 200, {
-                "available": False,
-                "platform": self.settings.harness.platform,
-                "error": f"Live screenshot preview is not available before {self.settings.harness.platform} harness execution.",
-            }
-        try:
-            context = harness.get_context()
-            metadata = getattr(context, "metadata", {})
-            if isinstance(metadata, dict) and metadata.get("browser_started") is False:
-                return 200, {
-                    "available": False,
-                    "platform": self.settings.harness.platform,
-                    "error": "Browser is not started. Call startBrowser before Web page actions.",
-                }
-            if self.settings.harness.platform == "macos" and getattr(context, "session_id", None) is None:
-                return 200, {
-                    "available": False,
-                    "platform": self.settings.harness.platform,
-                    "error": "Appium Mac2 session is not available. Call launchApp before macOS Appium actions.",
-                }
-            screenshot = harness.screenshot()
-            payload = {
-                "available": True,
-                "platform": self.settings.harness.platform,
-                "screenshot": base64.b64encode(screenshot).decode("ascii"),
-                "timestamp": int(time.time() * 1000),
-            }
-            self._record_replay_frame(request_id, payload)
-        except Exception as exc:  # noqa: BLE001 - API returns structured errors.
-            return 500, {"available": False, "platform": self.settings.harness.platform, "error": str(exc) or exc.__class__.__name__}
-        else:
-            return 200, payload
-
-    def _report_response(self, path: str, query: dict[str, list[str]]) -> tuple[int, object]:
-        run_id = unquote(path.removeprefix("/reports/")).strip()
-        report_format = (query.get("format") or ["markdown"])[0]
-        if report_format not in {"markdown", "json"}:
-            return 400, {"error": "format must be markdown or json."}
-        try:
-            report_path = resolve_report_path(self.settings.output.runs_dir, run_id, report_format)  # type: ignore[arg-type]
-            return 200, {"runId": run_id, "format": report_format, "path": str(report_path), "content": report_path.read_text(encoding="utf-8")}
-        except Exception as exc:  # noqa: BLE001 - API returns structured errors.
-            return 404, {"error": str(exc) or exc.__class__.__name__}
-
-    def _yaml_input_response(self, query: dict[str, list[str]]) -> tuple[int, object]:
-        path_text = (query.get("path") or [""])[0].strip()
-        if not path_text:
-            return 400, {"available": False, "error": "path is required."}
-        try:
-            resolved_path = self._resolve_yaml_input_path(path_text)
-            return self._yaml_input_path_response(path_text, resolved_path)
-        except IsADirectoryError:
-            return 400, {"available": False, "error": f"Case YAML path is a directory: {path_text}"}
-        except FileNotFoundError:
-            return 404, {"available": False, "error": f"Case YAML not found: {path_text}"}
-        except UnicodeDecodeError:
-            return 400, {"available": False, "error": f"Case YAML must be UTF-8 text: {path_text}"}
-        except ConfigurationError as exc:
-            return 400, {"available": False, "error": str(exc)}
-        except (TypeError, ValueError) as exc:
-            return 400, {"available": False, "error": str(exc) or "Unable to parse YAML for display."}
-        except OSError as exc:
-            return 400, {"available": False, "error": str(exc) or exc.__class__.__name__}
-
-    def _yaml_input_path_response(self, path_text: str, resolved_path: Path) -> tuple[int, object]:
-        content_bytes = resolved_path.read_bytes()
-        size_bytes = len(content_bytes)
-        if size_bytes > YAML_DISPLAY_SIZE_LIMIT_BYTES:
-            return 413, {
-                "available": False,
-                "error": f"YAML file is too large to display ({size_bytes} bytes).",
-                "limitBytes": YAML_DISPLAY_SIZE_LIMIT_BYTES,
-            }
-        content = content_bytes.decode("utf-8")
-        return 200, {
-            "kind": "input",
-            "path": path_text,
-            "resolvedPath": str(resolved_path),
-            "sizeBytes": size_bytes,
-            "revision": yaml_revision(content_bytes),
-            "editable": True,
-            "display": self._yaml_display_model(content, source_path=path_text),
-            "content": content,
-        }
-
-    def _resolve_yaml_input_path(self, path_text: str) -> Path:
-        requested = Path(path_text.strip())
-        if not is_fsq_case_file(requested):
-            raise ValueError(f"Case YAML files must use the {FSQ_CASE_SUFFIX} suffix.")
-        resolved = resolve_workspace_cases_path(requested, self.settings.cases.dir)
-        if resolved.exists():
-            if resolved.is_dir():
-                raise IsADirectoryError(str(resolved))
-            if resolved.is_file():
-                return resolved
-        raise FileNotFoundError(path_text)
-
-    def _yaml_recorded_response(self, yaml_id: str) -> tuple[int, object]:
-        if not yaml_id:
-            return 404, {"available": False, "error": "Recorded YAML not found."}
-        run_id = self.state.run_id_for_request(yaml_id) or yaml_id
-        runs_dir = Path(self.settings.output.runs_dir).resolve()
-        run_dir = (runs_dir / run_id).resolve()
-        if not _is_relative_to(run_dir, runs_dir) or not run_dir.is_dir():
-            return 404, {"available": False, "error": "Recorded YAML not found.", "runId": run_id}
-        recording_path = run_dir / "recording.json"
-        if not recording_path.exists():
-            return 404, {"available": False, "error": "Recording metadata not found.", "runId": run_id}
-        try:
-            recording = self._read_recording_json(recording_path)
-        except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
-            return 400, {"available": False, "error": str(exc) or "Unable to read recording metadata.", "runId": run_id}
-        if recording is None:
-            return 400, {"available": False, "error": "Recording metadata must be a JSON object.", "runId": run_id}
-        recorded_case_path = self._recorded_case_path(run_dir, recording)
-        if recorded_case_path is None:
-            return 400, {
-                "available": False,
-                "error": f"Recorded case path is outside the run directory or does not identify recorded{FSQ_CASE_SUFFIX}.",
-                "runId": run_id,
-            }
-        try:
-            content = recorded_case_path.read_text(encoding="utf-8") if recorded_case_path.is_file() else None
-        except UnicodeDecodeError:
-            return 400, {"available": False, "error": "Recorded case must be UTF-8 text.", "runId": run_id}
-        except OSError as exc:
-            return 400, {"available": False, "error": str(exc) or exc.__class__.__name__, "runId": run_id}
-        try:
-            display = self._yaml_display_model(content, source_path=str(recorded_case_path), run_dir=run_dir) if content is not None else None
-        except (TypeError, ValueError) as exc:
-            return 400, {"available": False, "error": str(exc) or "Unable to parse recorded YAML for display.", "runId": run_id}
-        return 200, {
-            "kind": "recorded",
-            "runId": run_id,
-            "status": self._recording_value(recording, "status", "missing"),
-            "validationStatus": self._recording_value(recording, "validation_status", "not_run"),
-            "draft": bool(recording.get("draft")) if isinstance(recording, dict) else False,
-            "commandCount": self._recording_int(recording, "command_count"),
-            "recordingPath": str(recording_path) if recording_path.exists() else None,
-            "recordedCasePath": str(recorded_case_path) if recorded_case_path.is_file() else None,
-            "requiredRuntimeSecretNames": self._recording_list(recording, "required_runtime_secret_names"),
-            "warnings": self._recording_list(recording, "warnings"),
-            "skippedToolCalls": self._recording_list(recording, "skipped_tool_calls"),
-            "errors": self._recording_list(recording, "errors"),
-            "display": display,
-            "content": content,
-        }
-
-    def _yaml_display_model(self, content: str, *, source_path: str | None = None, run_dir: Path | None = None) -> dict[str, object]:
-        try:
-            docs = list(yaml.safe_load_all(content))
-        except yaml.YAMLError as exc:
-            raise ValueError(str(exc) or "Unable to parse YAML for display.") from exc
-        metadata_doc = docs[0] if docs and isinstance(docs[0], dict) else {}
-        commands_doc = docs[1] if len(docs) > 1 else []
-        if commands_doc is None:
-            commands_doc = []
-        if not isinstance(commands_doc, list):
-            raise TypeError("FSQ command document must be a YAML list.")
-        artifact_step_ids = self._recorded_artifact_step_ids(run_dir, commands_doc) if run_dir is not None else None
-        return {
-            "metadata": self._yaml_metadata_display(metadata_doc, source_path=source_path),
-            "lifecycle": lifecycle_display(metadata_doc),
-            "steps": [
-                self._yaml_step_display(
-                    command,
-                    index,
-                    artifact_step_id=artifact_step_ids[index - 1] if artifact_step_ids is not None else None,
-                )
-                for index, command in enumerate(commands_doc, start=1)
-            ],
-            "documentCount": len(docs),
-        }
-
-    def _recorded_artifact_step_ids(self, run_dir: Path, commands: list[object]) -> list[str | None] | None:
-        events_path = run_dir / "events.jsonl"
-        if not events_path.exists():
-            return None
-        try:
-            lines = events_path.read_text(encoding="utf-8").splitlines()
-        except (OSError, UnicodeDecodeError):
-            return None
-        replay_events: list[tuple[str, str | None]] = []
-        for line in lines:
-            if not line.strip():
-                continue
-            try:
-                event = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if not isinstance(event, dict) or not self._event_is_recorded_replay_command(event):
-                continue
-            payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-            alias = self._event_replay_policy(payload).get("alias")
-            if isinstance(alias, str):
-                replay_events.append((self._normalized_yaml_action(alias), self._event_step_id(event)))
-        command_actions = [self._normalized_yaml_action(self._yaml_command_action(command)) for command in commands]
-        return self._align_recorded_step_ids(command_actions, replay_events)
-
-    def _align_recorded_step_ids(
-        self,
-        command_actions: list[str],
-        replay_events: list[tuple[str, str | None]],
-    ) -> list[str | None]:
-        event_actions = [action for action, _step_id in replay_events]
-        match_counts = [[0] * (len(event_actions) + 1) for _ in range(len(command_actions) + 1)]
-        for command_index in range(len(command_actions) - 1, -1, -1):
-            for event_index in range(len(event_actions) - 1, -1, -1):
-                if command_actions[command_index] == event_actions[event_index]:
-                    match_counts[command_index][event_index] = 1 + match_counts[command_index + 1][event_index + 1]
-                else:
-                    match_counts[command_index][event_index] = max(
-                        match_counts[command_index + 1][event_index],
-                        match_counts[command_index][event_index + 1],
-                    )
-        step_ids: list[str | None] = [None] * len(command_actions)
-        command_index = 0
-        event_index = 0
-        while command_index < len(command_actions) and event_index < len(event_actions):
-            if command_actions[command_index] == event_actions[event_index] and match_counts[command_index][event_index] == 1 + match_counts[command_index + 1][event_index + 1]:
-                step_ids[command_index] = replay_events[event_index][1]
-                command_index += 1
-                event_index += 1
-            elif match_counts[command_index + 1][event_index] > match_counts[command_index][event_index + 1]:
-                command_index += 1
-            else:
-                event_index += 1
-        return step_ids
-
-    def _yaml_command_action(self, command: object) -> str:
-        if isinstance(command, str):
-            return command
-        if isinstance(command, dict):
-            for key in command:
-                if str(key) not in _YAML_COMMAND_CONTROL_KEYS:
-                    return str(key)
-        return "command"
-
-    def _normalized_yaml_action(self, action: str) -> str:
-        return re.sub(r"[^a-z0-9]", "", action.lower())
-
-    def _event_step_kind(self, event: dict[str, object]) -> str | None:
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        value = payload.get("step_kind")
-        if isinstance(value, str):
-            return value
-        metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
-        kind = metadata.get("step_kind")
-        return kind if isinstance(kind, str) else None
-
-    def _event_step_id(self, event: dict[str, object]) -> str | None:
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        runner_result = payload.get("runner_result") if isinstance(payload.get("runner_result"), dict) else {}
-        for candidate in (payload.get("runner_step_id"), payload.get("step_id"), runner_result.get("step_id")):
-            if isinstance(candidate, str) and candidate:
-                return candidate
-        return None
-
-    def _yaml_metadata_display(self, metadata: dict[object, object], *, source_path: str | None = None) -> dict[str, object]:
-        fields = []
-        for key in ("platform", "schemaVersion", "description"):
-            value = metadata.get(key)
-            if value is not None and value != "" and value != []:
-                fields.append({"key": key, "label": self._yaml_label(key), "value": value})
-        if source_path:
-            fields.append({"key": "path", "label": "Path", "value": source_path})
-        for key in ("appId", "url"):
-            value = metadata.get(key)
-            if value is not None and value != "" and value != []:
-                fields.append({"key": key, "label": self._yaml_label(key), "value": value})
-        tags = metadata.get("tags")
-        return {
-            "title": metadata.get("name") if isinstance(metadata.get("name"), str) else "Untitled case",
-            "platform": metadata.get("platform") if isinstance(metadata.get("platform"), str) else "unknown",
-            "schemaVersion": metadata.get("schemaVersion") if isinstance(metadata.get("schemaVersion"), str) else "unknown",
-            "tags": tags if isinstance(tags, list) else [],
-            "fields": fields,
-        }
-
-    def _yaml_step_display(self, command: object, index: int, *, artifact_step_id: str | None = None) -> dict[str, object]:
-        badges: list[dict[str, object]] = []
-        if isinstance(command, str):
-            action = command
-            payload = None
-        elif isinstance(command, dict):
-            action_items = [(key, value) for key, value in command.items() if str(key) not in _YAML_COMMAND_CONTROL_KEYS]
-            if action_items:
-                action, payload = action_items[0]
-            else:
-                action, payload = "command", command
-            if command.get("optional") is True:
-                badges.append({"label": "optional", "tone": "neutral"})
-            timeout = command.get("timeout") or command.get("timeout_ms")
-            if timeout is not None:
-                badges.append({"label": f"timeout {timeout}", "tone": "neutral"})
-        else:
-            action = "command"
-            payload = command
-        action_text = str(action)
-        return {
-            "index": index,
-            "displayIndex": index,
-            "artifactStepId": artifact_step_id,
-            "action": action_text,
-            "kind": self._yaml_action_kind(action_text),
-            "badges": badges,
-            "params": self._yaml_param_entries(payload),
-        }
-
-    def _yaml_param_entries(self, payload: object) -> list[dict[str, object]]:
-        if payload in (None, {}, []):
-            return []
-        if isinstance(payload, dict):
-            return [{"key": str(key), **self._yaml_display_value(value)} for key, value in payload.items()]
-        return [{"key": "value", **self._yaml_display_value(payload)}]
-
-    def _yaml_display_value(self, value: object) -> dict[str, object]:
-        if isinstance(value, dict):
-            return {
-                "value": "",
-                "kind": "object",
-                "fields": [{"key": str(key), **self._yaml_display_value(child_value)} for key, child_value in value.items()],
-            }
-        if isinstance(value, list):
-            return {
-                "value": "",
-                "kind": "list",
-                "fields": [{"key": str(index + 1), **self._yaml_display_value(child_value)} for index, child_value in enumerate(value)],
-            }
-        if isinstance(value, bool):
-            return {"value": "true" if value else "false", "kind": "boolean"}
-        if value is None:
-            return {"value": "null", "kind": "null"}
-        return {"value": str(value), "kind": "scalar"}
-
-    def _yaml_action_kind(self, action: str) -> str:
-        if action in _YAML_SETUP_ACTIONS:
-            return "setup"
-        if action in _YAML_TEARDOWN_ACTIONS:
-            return "teardown"
-        if action in _YAML_ASSERTION_ACTIONS:
-            return "assertion"
-        if action in _YAML_OBSERVATION_ACTIONS:
-            return "observation"
-        return "action"
-
-    def _yaml_label(self, key: str) -> str:
-        return {
-            "schemaVersion": "Schema",
-            "appId": "App ID",
-        }.get(key, key[:1].upper() + key[1:])
-
-    def _read_recording_json(self, recording_path: Path) -> dict[str, object] | None:
-        if not recording_path.exists():
-            return None
-        payload = json.loads(recording_path.read_text(encoding="utf-8"))
-        return payload if isinstance(payload, dict) else None
-
-    def _recorded_case_path(self, run_dir: Path, recording: dict[str, object] | None) -> Path | None:
-        expected_name = f"recorded{FSQ_CASE_SUFFIX}"
-        raw_path = recording.get("recorded_case_path") if isinstance(recording, dict) else None
-        if isinstance(raw_path, str) and raw_path.strip():
-            candidate = Path(raw_path.strip())
-            if candidate.name != expected_name:
-                return None
-            resolved = candidate.resolve() if candidate.is_absolute() else (run_dir / candidate).resolve()
-        else:
-            resolved = (run_dir / expected_name).resolve()
-        expected = (run_dir / expected_name).resolve()
-        return resolved if resolved == expected and _is_relative_to(resolved, run_dir) else None
-
-    def _recording_value(self, recording: dict[str, object] | None, key: str, default: str) -> str:
-        value = recording.get(key) if isinstance(recording, dict) else None
-        return value if isinstance(value, str) and value else default
-
-    def _recording_int(self, recording: dict[str, object] | None, key: str) -> int:
-        value = recording.get(key) if isinstance(recording, dict) else None
-        return int(value) if isinstance(value, int) else 0
-
-    def _recording_list(self, recording: dict[str, object] | None, key: str) -> list[object]:
-        value = recording.get(key) if isinstance(recording, dict) else None
-        return value if isinstance(value, list) else []
-
-    def _step_artifacts_response(self, artifact_id: str, step_id_or_index: str) -> tuple[int, object]:
-        if not artifact_id or not step_id_or_index:
-            return 400, {"available": False, "error": "Step artifact id and step id or index are required."}
-        run_id = self.state.run_id_for_request(artifact_id) or artifact_id
-        runs_root = Path(self.settings.output.runs_dir).resolve()
-        run_dir = (runs_root / run_id).resolve()
-        if not _is_relative_to(run_dir, runs_root):
-            return 400, {"available": False, "error": "Run id resolves outside the runs directory."}
-        if not run_dir.exists() or not run_dir.is_dir():
-            return 404, {"available": False, "error": f"Run not found: {run_id}", "runId": run_id}
-        selector = self._step_selector(step_id_or_index)
-        if selector is None:
-            return 400, {"available": False, "error": "Step id or 1-based step index is required.", "runId": run_id}
-        try:
-            refs = self._step_artifact_refs(run_dir, selector)
-            artifacts = self._step_artifact_payloads(run_dir, refs)
-        except UnicodeDecodeError:
-            return 400, {"available": False, "error": "Step artifact text must be UTF-8.", "runId": run_id}
-        except ValueError as exc:
-            return 400, {"available": False, "error": str(exc), "runId": run_id}
-        response = {
-            "available": bool(artifacts),
-            "runId": run_id,
-            "stepId": selector.get("step_id"),
-            "stepIndex": selector.get("step_index"),
-            "artifacts": artifacts,
-        }
-        if not artifacts:
-            response["message"] = "No artifacts for this step yet."
-        return 200, response
-
-    def _step_selector(self, step_id_or_index: str) -> dict[str, object] | None:
-        value = step_id_or_index.strip()
-        if not value:
-            return None
-        if value.isdecimal():
-            step_index = int(value)
-            return {"step_index": step_index} if step_index > 0 else None
-        selector: dict[str, object] = {"step_id": value}
-        parsed_index = _step_index_from_step_id(value)
-        if parsed_index is not None:
-            selector["step_index"] = parsed_index
-        return selector
-
-    def _step_artifact_refs(self, run_dir: Path, selector: dict[str, object]) -> list[dict[str, object]]:
-        refs: list[dict[str, object]] = []
-        manifest = self._read_evidence_manifest(run_dir)
-        if manifest is not None:
-            event_metadata = self._artifact_event_metadata(manifest)
-            artifacts = manifest.get("artifacts")
-            if isinstance(artifacts, list):
-                for artifact in artifacts:
-                    if not isinstance(artifact, dict) or not self._artifact_matches_step(artifact, selector):
-                        continue
-                    refs.append(self._artifact_with_event_metadata(artifact, event_metadata))
-        refs.extend(self._step_artifact_refs_from_events(run_dir, selector))
-        return self._dedupe_step_artifact_refs(refs)
-
-    def _read_evidence_manifest(self, run_dir: Path) -> dict[str, object] | None:
-        manifest_path = run_dir / "evidence-manifest.json"
-        if not manifest_path.exists():
-            return None
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-        if not isinstance(manifest, dict):
-            return None
-        bundle = manifest.get("bundle")
-        return bundle if isinstance(bundle, dict) else manifest
-
-    def _artifact_event_metadata(self, manifest: dict[str, object]) -> dict[str, dict[str, object]]:
-        metadata: dict[str, dict[str, object]] = {}
-        events = manifest.get("events")
-        if not isinstance(events, list):
-            return metadata
-        for event in events:
-            if not isinstance(event, dict) or event.get("event_type") != "artifact_captured":
-                continue
-            payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-            path = payload.get("path")
-            if not isinstance(path, str) or not path:
-                continue
-            metadata[path] = {
-                "timestamp": self._timestamp_ms(event.get("timestamp")),
-                "reason": payload.get("reason"),
-                "phase": payload.get("phase") or event.get("phase"),
-            }
-        return metadata
-
-    def _artifact_with_event_metadata(self, artifact: dict[str, object], event_metadata: dict[str, dict[str, object]]) -> dict[str, object]:
-        path = artifact.get("path")
-        metadata = event_metadata.get(path, {}) if isinstance(path, str) else {}
-        merged = dict(artifact)
-        for key in ("timestamp", "reason", "phase"):
-            current = merged.get(key)
-            replacement = metadata.get(key)
-            if (current is None or current == "") and replacement is not None and replacement != "":
-                merged[key] = metadata[key]
-        return merged
-
-    def _step_artifact_refs_from_events(self, run_dir: Path, selector: dict[str, object]) -> list[dict[str, object]]:
-        events_path = run_dir / "events.jsonl"
-        if not events_path.exists():
-            return []
-        refs: list[dict[str, object]] = []
-        for line in events_path.read_text(encoding="utf-8").splitlines():
-            if not line.strip():
-                continue
-            try:
-                event = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if not isinstance(event, dict) or event.get("type") not in {"tool_call_completed", "tool_call_failed"}:
-                continue
-            if not self._event_matches_step(event, selector):
-                continue
-            timestamp = self._timestamp_ms(event.get("timestamp"))
-            payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-            artifact_refs = payload.get("artifact_refs")
-            artifact_ref_paths: set[str] = set()
-            if isinstance(artifact_refs, list):
-                for ref in artifact_refs:
-                    if isinstance(ref, dict):
-                        refs.append({**ref, "timestamp": ref.get("timestamp") or timestamp})
-                        ref_path = ref.get("path")
-                        if isinstance(ref_path, str) and ref_path:
-                            artifact_ref_paths.add(ref_path)
-            artifact_path = payload.get("artifact_path")
-            if isinstance(artifact_path, str) and artifact_path and artifact_path not in artifact_ref_paths:
-                refs.append({"kind": "screenshot", "path": artifact_path, "timestamp": timestamp})
-            inline_ref = self._event_inline_observation_ref(event, timestamp)
-            if inline_ref is not None:
-                refs.append(inline_ref)
-        return refs
-
-    def _event_is_recorded_replay_command(self, event: dict[str, object]) -> bool:
-        if event.get("type") != "tool_call_completed":
-            return False
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        if payload.get("tool_origin") not in {"platform", "harness", "common"}:
-            return False
-        if payload.get("status") not in {"passed", "success", None}:
-            return False
-        replay = self._event_replay_policy(payload)
-        return replay.get("kind") == "fsq_command" and isinstance(replay.get("alias"), str) and bool(replay.get("alias"))
-
-    def _event_replay_policy(self, payload: dict[str, object]) -> dict[str, object]:
-        replay = payload.get("replay")
-        if isinstance(replay, dict):
-            return replay
-        replay_kind = payload.get("replay_kind")
-        if isinstance(replay_kind, str) and replay_kind:
-            return {"kind": "fsq_command", "alias": replay_kind}
-        return {}
-
-    def _event_inline_observation_ref(self, event: dict[str, object], timestamp: int | None) -> dict[str, object] | None:
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        kind = self._event_observation_kind(event)
-        if kind is None:
-            return None
-        content = self._event_harness_output_content(payload, kind)
-        if content is None:
-            return None
-        mime_type = "application/xml" if kind == "ui_tree" and content.lstrip().startswith("<") else "application/json"
-        return {
-            "kind": kind,
-            "content": content,
-            "mime_type": mime_type,
-            "reason": "output",
-            "phase": "invoke",
-            "timestamp": timestamp,
-        }
-
-    def _event_observation_kind(self, event: dict[str, object]) -> str | None:
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        value = payload.get("fsq_action_name") or payload.get("tool_name") or event.get("tool_name")
-        normalized = str(value or "").replace("_", "").lower()
-        if normalized == "uitree":
-            return "ui_tree"
-        if normalized == "uisnapshot":
-            return "ui_snapshot"
-        return None
-
-    def _event_harness_output_content(self, payload: dict[str, object], kind: str) -> str | None:
-        runner_result = payload.get("runner_result") if isinstance(payload.get("runner_result"), dict) else {}
-        phase_reports = runner_result.get("phase_reports") if isinstance(runner_result.get("phase_reports"), list) else []
-        for phase_report in phase_reports:
-            if not isinstance(phase_report, dict):
-                continue
-            metadata = phase_report.get("metadata") if isinstance(phase_report.get("metadata"), dict) else {}
-            output = metadata.get("harness_output")
-            if not isinstance(output, dict):
-                continue
-            if kind == "ui_tree" and isinstance(output.get("xml"), str):
-                return output["xml"]
-            if output:
-                return json.dumps(output, indent=2, ensure_ascii=False)
-        return None
-
-    def _artifact_matches_step(self, artifact: dict[str, object], selector: dict[str, object]) -> bool:
-        selector_step_id = selector.get("step_id")
-        selector_step_index = selector.get("step_index")
-        artifact_step_id = artifact.get("step_id") or artifact.get("stepId")
-        if isinstance(selector_step_id, str) and artifact_step_id == selector_step_id:
-            return True
-        if isinstance(selector_step_index, int):
-            if isinstance(artifact_step_id, str) and _step_index_from_step_id(artifact_step_id) == selector_step_index:
-                return True
-            path = artifact.get("path")
-            if isinstance(path, str) and _step_index_from_step_id(path) == selector_step_index:
-                return True
-        return False
-
-    def _event_matches_step(self, event: dict[str, object], selector: dict[str, object]) -> bool:
-        payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-        runner_result = payload.get("runner_result") if isinstance(payload.get("runner_result"), dict) else {}
-        source_ref = runner_result.get("source_ref") if isinstance(runner_result.get("source_ref"), dict) else {}
-        selector_step_id = selector.get("step_id")
-        selector_step_index = selector.get("step_index")
-        step_ids = [
-            payload.get("step_id"),
-            payload.get("runner_step_id"),
-            runner_result.get("step_id"),
-        ]
-        if isinstance(selector_step_id, str) and selector_step_id in step_ids:
-            return True
-        if isinstance(selector_step_index, int):
-            for step_id in step_ids:
-                if isinstance(step_id, str) and _step_index_from_step_id(step_id) == selector_step_index:
-                    return True
-            source_index = source_ref.get("step_index")
-            if isinstance(source_index, int) and source_index + 1 == selector_step_index:
-                return True
-        return False
-
-    def _dedupe_step_artifact_refs(self, refs: list[dict[str, object]]) -> list[dict[str, object]]:
-        deduped: list[dict[str, object]] = []
-        seen: set[tuple[str, str, str]] = set()
-        for ref in refs:
-            key = (str(ref.get("kind") or ""), str(ref.get("path") or ""), str(ref.get("phase") or ref.get("reason") or ""))
-            if key in seen:
-                continue
-            seen.add(key)
-            deduped.append(ref)
-        return sorted(deduped, key=self._step_artifact_sort_key)
-
-    def _step_artifact_sort_key(self, ref: dict[str, object]) -> tuple[int, int, str]:
-        phase_value = f"{ref.get('reason') or ''} {ref.get('phase') or ''}".lower()
-        if "before" in phase_value or "prepare" in phase_value:
-            phase_order = 0
-        elif "after" in phase_value or "finalize" in phase_value:
-            phase_order = 1
-        elif "failure" in phase_value:
-            phase_order = 2
-        else:
-            phase_order = 3
-        kind_order = 0 if ref.get("kind") == "screenshot" else 1
-        return (kind_order, phase_order, str(ref.get("path") or ""))
-
-    def _step_artifact_payloads(self, run_dir: Path, refs: list[dict[str, object]]) -> list[dict[str, object]]:
-        artifacts: list[dict[str, object]] = []
-        for ref in refs:
-            try:
-                payload = self._step_artifact_payload(run_dir, ref)
-            except _StepArtifactTextTooLargeError as exc:
-                payload = {
-                    "kind": str(ref.get("kind") or ""),
-                    "path": str(ref.get("path") or ""),
-                    "phase": ref.get("phase"),
-                    "reason": ref.get("reason"),
-                    "timestamp": ref.get("timestamp") or self._artifact_timestamp(ref),
-                    "mimeType": ref.get("mime_type") or ref.get("mimeType"),
-                    "error": str(exc),
-                    "sizeBytes": exc.size_bytes,
-                    "limitBytes": exc.limit_bytes,
-                }
-            if payload is not None:
-                artifacts.append(payload)
-        return artifacts
-
-    def _step_artifact_payload(self, run_dir: Path, ref: dict[str, object]) -> dict[str, object] | None:
-        kind = str(ref.get("kind") or "")
-        if kind != "screenshot" and kind not in _STEP_TEXT_ARTIFACT_KINDS:
-            return None
-        inline_content = ref.get("content")
-        if isinstance(inline_content, str):
-            size_bytes = len(inline_content.encode("utf-8"))
-            if size_bytes > STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES:
-                raise _StepArtifactTextTooLargeError(size_bytes=size_bytes, limit_bytes=STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES)
-            content, content_mime_type = self._normalize_step_text_artifact_content(inline_content)
-            return {
-                "kind": kind,
-                "path": str(ref.get("path") or ""),
-                "phase": ref.get("phase"),
-                "reason": ref.get("reason"),
-                "timestamp": ref.get("timestamp") or self._artifact_timestamp(ref),
-                "mimeType": content_mime_type or ref.get("mime_type") or ref.get("mimeType"),
-                "content": content,
-            }
-        artifact_path, relative_path = self._safe_run_artifact_path(run_dir, ref.get("path"))
-        if not artifact_path.exists() or not artifact_path.is_file():
-            return None
-        payload: dict[str, object] = {
-            "kind": kind,
-            "path": relative_path,
-            "phase": ref.get("phase"),
-            "reason": ref.get("reason"),
-            "timestamp": ref.get("timestamp") or self._artifact_timestamp(ref),
-            "mimeType": ref.get("mime_type") or ref.get("mimeType") or mimetypes.guess_type(artifact_path.name)[0],
-        }
-        if kind == "screenshot":
-            payload["contentBase64"] = base64.b64encode(artifact_path.read_bytes()).decode("ascii")
-            return payload
-        size_bytes = artifact_path.stat().st_size
-        if size_bytes > STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES:
-            raise _StepArtifactTextTooLargeError(size_bytes=size_bytes, limit_bytes=STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES)
-        content, content_mime_type = self._step_text_artifact_content(artifact_path)
-        payload["content"] = content
-        if content_mime_type is not None:
-            payload["mimeType"] = content_mime_type
-        return payload
-
-    def _step_text_artifact_content(self, artifact_path: Path) -> tuple[str, str | None]:
-        content = artifact_path.read_text(encoding="utf-8")
-        return self._normalize_step_text_artifact_content(content)
-
-    def _normalize_step_text_artifact_content(self, content: str) -> tuple[str, str | None]:
-        if content.lstrip().startswith("<"):
-            return self._format_xml_for_display(content), "application/xml"
-        try:
-            payload = json.loads(content)
-        except json.JSONDecodeError:
-            return content, None
-        if isinstance(payload, dict):
-            xml = payload.get("xml")
-            if isinstance(xml, str) and xml.strip():
-                return self._format_xml_for_display(xml), "application/xml"
-        return json.dumps(payload, indent=2, ensure_ascii=False), "application/json"
-
-    def _format_xml_for_display(self, xml: str) -> str:
-        try:
-            root = _parse_xml_safely(xml)
-        except ET.ParseError:
-            return xml
-        ET.indent(root, space="  ")
-        return ET.tostring(root, encoding="unicode", short_empty_elements=True)
-
-    def _safe_run_artifact_path(self, run_dir: Path, path_value: object) -> tuple[Path, str]:
-        if not isinstance(path_value, str) or not path_value.strip():
-            raise ValueError("Artifact path is required.")
-        candidate = Path(path_value.strip())
-        resolved = candidate.resolve() if candidate.is_absolute() else (run_dir / candidate).resolve()
-        if not _is_relative_to(resolved, run_dir):
-            raise ValueError("Artifact path resolves outside the run directory.")
-        return resolved, resolved.relative_to(run_dir).as_posix()
-
-    def _record_replay_frame(self, request_id: str, screenshot_payload: dict[str, object]) -> None:
-        screenshot = screenshot_payload.get("screenshot")
-        timestamp = screenshot_payload.get("timestamp")
-        if not isinstance(screenshot, str) or not isinstance(timestamp, int):
-            return
-        run_id = self.state.run_id_for_request(request_id)
-        if not run_id:
-            return
-        replay_dir = self._replay_dir(run_id)
-        self._reset_replay_dir_once(request_id, replay_dir)
-        replay_dir.mkdir(parents=True, exist_ok=True)
-        manifest_path = replay_dir / "replay-manifest.json"
-        manifest = self._read_replay_manifest(manifest_path, request_id, run_id)
-        frames = manifest["frames"]
-        if frames and frames[-1].get("timestamp") == timestamp:
-            return
-        frame_index = len(frames) + 1
-        frame_name = f"frame-{frame_index:04d}-{timestamp}.png"
-        frame_path = replay_dir / frame_name
-        frame_path.write_bytes(base64.b64decode(screenshot))
-        frames.append({"timestamp": timestamp, "path": frame_name})
-        manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
-        self.state.set_replay(
-            request_id,
-            {"requestId": request_id, "runId": run_id, "frameCount": len(frames)},
-        )
-
-    def _replay_response(self, replay_id: str) -> tuple[int, object]:
-        run_id = self.state.run_id_for_request(replay_id) or replay_id
-        manifest_path = self._replay_dir(run_id) / "replay-manifest.json"
-        if not manifest_path.exists():
-            return self._evidence_replay_response(replay_id, run_id)
-        manifest = self._read_replay_manifest(manifest_path, replay_id, run_id)
-        frames = []
-        for index, frame in enumerate(manifest["frames"], start=1):
-            frame_path = (manifest_path.parent / str(frame.get("path") or "")).resolve()
-            if not _is_relative_to(frame_path, manifest_path.parent) or not frame_path.is_file():
-                continue
-            frames.append(
-                {
-                    "index": index,
-                    "timestamp": frame.get("timestamp"),
-                    "path": str(frame.get("path") or ""),
-                    "screenshot": base64.b64encode(frame_path.read_bytes()).decode("ascii"),
-                }
-            )
-        return 200, {"requestId": replay_id, "runId": run_id, "frames": frames}
-
-    def _evidence_replay_response(self, replay_id: str, run_id: str) -> tuple[int, object]:
-        run_dir = Path(self.settings.output.runs_dir) / run_id
-        manifest_path = run_dir / "evidence-manifest.json"
-        frames = []
-        if manifest_path.exists():
-            try:
-                manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-            except (OSError, json.JSONDecodeError) as exc:
-                return 404, {"error": str(exc) or "Unable to read evidence manifest."}
-            timestamps_by_path = self._screenshot_event_timestamps(manifest)
-            frames.extend(self._frames_from_artifact_refs(run_dir, manifest.get("artifacts", []), timestamps_by_path))
-        if not frames:
-            frames.extend(self._event_replay_frames(run_dir))
-        frames.sort(key=lambda frame: frame.get("timestamp") or 0)
-        self._assign_frame_indexes(frames)
-        if not frames:
-            if run_dir.is_dir() or self.state.get_task(replay_id) is not None:
-                return 200, {
-                    "available": False,
-                    "requestId": replay_id,
-                    "runId": run_id,
-                    "frames": [],
-                    "message": "No replay frames were captured.",
-                }
-            return 404, {"error": "Replay frames not found."}
-        return 200, {"requestId": replay_id, "runId": run_id, "frames": frames}
-
-    def _assign_frame_indexes(self, frames: list[dict[str, object]]) -> None:
-        for index, frame in enumerate(frames, start=1):
-            frame["index"] = index
-
-    def _frames_from_artifact_refs(
-        self,
-        run_dir: Path,
-        artifact_refs: object,
-        timestamps_by_path: dict[str, int] | None = None,
-    ) -> list[dict[str, object]]:
-        if not isinstance(artifact_refs, list):
-            return []
-        timestamps = timestamps_by_path or {}
-        frames: list[dict[str, object]] = []
-        seen_paths: set[str] = set()
-        for artifact in artifact_refs:
-            if not isinstance(artifact, dict) or not self._is_screenshot_artifact_ref(artifact):
-                continue
-            relative_path = str(artifact.get("path") or "")
-            if not relative_path or relative_path in seen_paths:
-                continue
-            seen_paths.add(relative_path)
-            frame_path = (run_dir / relative_path).resolve()
-            if not _is_relative_to(frame_path, run_dir) or not frame_path.is_file():
-                continue
-            frames.append(
-                {
-                    "timestamp": timestamps.get(relative_path) or self._artifact_timestamp(artifact),
-                    "path": relative_path,
-                    "screenshot": base64.b64encode(frame_path.read_bytes()).decode("ascii"),
-                }
-            )
-        return frames
-
-    def _event_replay_frames(self, run_dir: Path) -> list[dict[str, object]]:
-        events_path = run_dir / "events.jsonl"
-        if not events_path.exists():
-            return []
-        refs: list[dict[str, object]] = []
-        seen_paths: set[str] = set()
-        for line in events_path.read_text(encoding="utf-8").splitlines():
-            if not line.strip():
-                continue
-            try:
-                event = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if not isinstance(event, dict) or event.get("type") not in {"tool_call_completed", "tool_call_failed"}:
-                continue
-            timestamp = self._timestamp_ms(event.get("timestamp"))
-            payload = event.get("payload") if isinstance(event.get("payload"), dict) else {}
-            artifact_refs = payload.get("artifact_refs")
-            if isinstance(artifact_refs, list):
-                for ref in artifact_refs:
-                    self._append_event_artifact_ref(refs, seen_paths, ref, timestamp)
-            artifact_path = payload.get("artifact_path")
-            if isinstance(artifact_path, str) and artifact_path:
-                self._append_event_artifact_ref(refs, seen_paths, {"kind": "screenshot", "path": artifact_path}, timestamp)
-        return self._frames_from_artifact_refs(run_dir, refs)
-
-    def _append_event_artifact_ref(
-        self,
-        refs: list[dict[str, object]],
-        seen_paths: set[str],
-        ref: object,
-        timestamp: int | None,
-    ) -> None:
-        if not isinstance(ref, dict) or not self._is_screenshot_artifact_ref(ref):
-            return
-        path = ref.get("path")
-        if not isinstance(path, str) or not path or path in seen_paths:
-            return
-        seen_paths.add(path)
-        refs.append({**ref, "timestamp": ref.get("timestamp") or timestamp})
-
-    def _artifact_timestamp(self, artifact: dict[str, object]) -> int | None:
-        timestamp = artifact.get("timestamp")
-        if isinstance(timestamp, int):
-            return timestamp
-        return self._timestamp_ms(artifact.get("created_at"))
-
-    def _is_screenshot_artifact_ref(self, ref: dict[str, object]) -> bool:
-        if ref.get("kind") == "screenshot":
-            return True
-        path = ref.get("path")
-        if not isinstance(path, str):
-            return False
-        normalized = path.replace("\\", "/").lower()
-        return "/screenshots/" in normalized and normalized.endswith((".png", ".jpg", ".jpeg", ".webp"))
-
-    def _screenshot_event_timestamps(self, manifest: dict[str, object]) -> dict[str, int]:
-        timestamps: dict[str, int] = {}
-        events = manifest.get("events")
-        if not isinstance(events, list):
-            return timestamps
-        for event in events:
-            if not isinstance(event, dict) or event.get("event_type") != "artifact_captured":
-                continue
-            payload = event.get("payload")
-            if not isinstance(payload, dict) or payload.get("kind") != "screenshot":
-                continue
-            path = payload.get("path")
-            timestamp = self._timestamp_ms(event.get("timestamp"))
-            if isinstance(path, str) and timestamp is not None:
-                timestamps[path] = timestamp
-        return timestamps
-
-    def _timestamp_ms(self, value: object) -> int | None:
-        if not isinstance(value, str):
-            return None
-        try:
-            normalized = value.replace("Z", "+00:00")
-            return int(time.mktime(time.strptime(normalized[:19], "%Y-%m-%dT%H:%M:%S")) * 1000)
-        except ValueError:
-            return None
-
-    def _replay_video_response(self, replay_id: str) -> tuple[int, object]:
-        run_id = self.state.run_id_for_request(replay_id) or replay_id
-        video_path = self._replay_video_path(run_id)
-        if not video_path.exists():
-            return 200, {"available": False, "error": "Replay video not found.", "runId": run_id}
-        return 200, {
-            "available": True,
-            "requestId": replay_id,
-            "runId": run_id,
-            "format": "webm",
-            "videoUrl": f"/replay-video-file/{run_id}",
-        }
-
-    def _read_replay_manifest(self, manifest_path: Path, request_id: str, run_id: str) -> dict[str, object]:
-        if manifest_path.exists():
-            try:
-                payload = json.loads(manifest_path.read_text(encoding="utf-8"))
-                frames = payload.get("frames") if isinstance(payload, dict) else None
-                if isinstance(frames, list):
-                    video = payload.get("video") if isinstance(payload.get("video"), dict) else None
-                    return {"requestId": request_id, "runId": run_id, "frames": frames, "video": video}
-            except (OSError, json.JSONDecodeError):
-                pass
-        return {"requestId": request_id, "runId": run_id, "frames": []}
-
-    def _store_replay_video(self, replay_id: str, body: dict[str, object]) -> tuple[int, object]:
-        run_id = self.state.run_id_for_request(replay_id) or replay_id
-        video_base64 = body.get("videoBase64")
-        mime_type = body.get("mimeType")
-        if not isinstance(video_base64, str) or not video_base64.strip():
-            return 400, {"error": "videoBase64 is required."}
-        if not isinstance(mime_type, str) or not mime_type.lower().startswith("video/webm"):
-            return 400, {"error": "Only video/webm replay uploads are supported."}
-        replay_dir = self._replay_dir(run_id)
-        self._reset_replay_dir_once(replay_id, replay_dir)
-        replay_dir.mkdir(parents=True, exist_ok=True)
-        video_path = replay_dir / "replay.webm"
-        try:
-            video_path.write_bytes(base64.b64decode(video_base64))
-        except Exception as exc:  # noqa: BLE001 - API returns structured errors.
-            return 400, {"error": str(exc) or "Invalid replay video."}
-        manifest_path = replay_dir / "replay-manifest.json"
-        manifest = self._read_replay_manifest(manifest_path, replay_id, run_id)
-        manifest["video"] = {"path": "replay.webm", "mimeType": "video/webm"}
-        manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
-        return 200, {
-            "available": True,
-            "requestId": replay_id,
-            "runId": run_id,
-            "videoUrl": f"/replay-video-file/{run_id}",
-            "mimeType": "video/webm",
-        }
-
-    def _replay_dir(self, run_id: str) -> Path:
-        slug = re.sub(r"[^a-zA-Z0-9_.-]+", "-", run_id).strip("-") or "run"
-        return Path(self.settings.output.runs_dir) / slug / "playground-replay"
-
-    def _replay_video_path(self, run_id: str) -> Path:
-        return self._replay_dir(run_id) / "replay.webm"
-
-    def _reset_replay_dir_once(self, request_id: str, replay_dir: Path) -> None:
-        if self.state.mark_replay_reset(request_id) and replay_dir.exists():
-            shutil.rmtree(replay_dir)
-
-    def _reset_replay_for_known_run(self, request_id: str, run_id: str | None) -> None:
-        if not run_id:
-            return
-        self.state.bind_run_id(request_id, run_id)
-        self._reset_replay_dir_once(request_id, self._replay_dir(run_id))
-
-    def _strict_case_run_id(self, path_text: str) -> str | None:
-        try:
-            return FsqCaseLoader().load_case(self._resolve_case_yaml_path(path_text)).id
-        except (ConfigurationError, OSError, UnicodeDecodeError):
-            return None
-
-    def _resolve_case_yaml_path(self, path_text: str) -> Path:
-        requested = Path(path_text.strip())
-        if not is_fsq_case_file(requested):
-            raise ConfigurationError(f"FSQ case files must use the {FSQ_CASE_SUFFIX} suffix.")
-        resolved = resolve_workspace_cases_path(requested, self.settings.cases.dir)
-        if resolved.exists() and resolved.is_file():
-            return resolved
-        raise FileNotFoundError(path_text)
-
-
-class _PlaygroundHTTPServer(ThreadingHTTPServer):
-    def __init__(self, server_address: tuple[str, int], handler_class: type[BaseHTTPRequestHandler], playground: PlaygroundServer) -> None:
-        super().__init__(server_address, handler_class)
-        self.playground = playground
-
-
-class _RequestHandler(BaseHTTPRequestHandler):
-    server: _PlaygroundHTTPServer
-
-    def do_GET(self) -> None:
-        parsed = urlparse(self.path)
-        if parsed.path.startswith("/task-stream/"):
-            request_id = unquote(parsed.path.removeprefix("/task-stream/")).strip()
-            self._stream_task_progress(request_id, parse_qs(parsed.query))
-            return
-        if parsed.path.startswith("/replay-video-file/"):
-            status, payload, content_type, extra_headers = self.server.playground.handle_replay_video_file(parsed.path, self.headers.get("Range"))
-            self._send_bytes(status, payload, content_type, extra_headers)
-            return
-        if _is_api_path(parsed.path):
-            status, payload = self.server.playground.handle_get(parsed.path, parse_qs(parsed.query))
-            self._send_json(status, payload)
-            return
-        status, payload, content_type = self.server.playground.static_response(parsed.path)
-        self._send_bytes(status, payload, content_type)
-
-    def do_POST(self) -> None:
-        parsed = urlparse(self.path)
-        body = self._read_json_body()
-        if isinstance(body, str):
-            self._send_json(400, {"error": body})
-            return
-        status, payload = self.server.playground.handle_post(parsed.path, body)
-        self._send_json(status, payload)
-
-    def do_PUT(self) -> None:
-        parsed = urlparse(self.path)
-        body = self._read_json_body()
-        if isinstance(body, str):
-            self._send_json(400, {"error": body})
-            return
-        status, payload = self.server.playground.handle_put(parsed.path, body)
-        self._send_json(status, payload)
-
-    def do_DELETE(self) -> None:
-        parsed = urlparse(self.path)
-        status, payload = self.server.playground.handle_delete(parsed.path)
-        self._send_json(status, payload)
-
-    def log_message(self, format: str, *args: Any) -> None:  # noqa: A002 - stdlib signature.
-        return None
-
-    def handle_one_request(self) -> None:
-        try:
-            super().handle_one_request()
-        except (ConnectionAbortedError, ConnectionResetError, BrokenPipeError):
-            self.close_connection = True
-
-    def _stream_task_progress(self, request_id: str, query: dict[str, list[str]]) -> None:
-        last_sequence = _after_sequence(query) or 0
-        first = self.server.playground.handle_get(f"/task-progress/{request_id}", {"after_sequence": [str(last_sequence)]})
-        if first[0] != 200 or not isinstance(first[1], dict):
-            self._send_json(404, {"error": "Task progress not found."})
-            return
-        self.close_connection = True
-        self.send_response(200)
-        self.send_header("Content-Type", "text/event-stream; charset=utf-8")
-        self.send_header("Cache-Control", "no-cache")
-        self.send_header("Connection", "keep-alive")
-        self.send_header("X-Accel-Buffering", "no")
-        self.end_headers()
-        try:
-            last_sequence = self._write_sse_progress(first[1], last_sequence)
-            status = str(first[1].get("status"))
-            revision = 0
-            while status == "running":
-                payload, revision = self.server.playground.state.wait_for_update(request_id, last_sequence, revision, timeout=15.0)
-                if not isinstance(payload, dict):
-                    break
-                last_sequence = self._write_sse_progress(payload, last_sequence)
-                status = str(payload.get("status"))
-        except (BrokenPipeError, ConnectionResetError):
-            return
-
-    def _write_sse_progress(self, payload: dict[str, object], last_sequence: int) -> int:
-        events = payload.get("events")
-        if isinstance(events, list):
-            for event in events:
-                if isinstance(event, dict) and isinstance(event.get("sequence"), int):
-                    last_sequence = max(last_sequence, int(event["sequence"]))
-        self.wfile.write(b"data: " + json.dumps(payload, ensure_ascii=False).encode("utf-8") + b"\n\n")
-        self.wfile.flush()
-        return last_sequence
-
-    def _read_json_body(self) -> dict[str, object] | str:
-        content_length = int(self.headers.get("Content-Length") or "0")
-        if content_length == 0:
-            return {}
-        raw = self.rfile.read(content_length)
-        try:
-            body = json.loads(raw.decode("utf-8"))
-        except (UnicodeDecodeError, json.JSONDecodeError):
-            return "Request body must be valid JSON."
-        if not isinstance(body, dict):
-            return "Request body must be a JSON object."
-        return body
-
-    def _send_json(self, status: int, payload: object) -> None:
-        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-        self._send_bytes(status, body, "application/json; charset=utf-8")
-
-    def _send_bytes(self, status: int, payload: bytes, content_type: str, extra_headers: dict[str, str] | None = None) -> None:
-        self.send_response(status)
-        self.send_header("Content-Type", content_type)
-        self.send_header("Content-Length", str(len(payload)))
-        for name, value in (extra_headers or {}).items():
-            self.send_header(name, value)
-        self.end_headers()
-        self.wfile.write(payload)
-
-
-def run_playground(settings: Settings, options: PlaygroundServerOptions) -> None:
-    server = PlaygroundServer(settings, options)
-    server.start()
-    try:
-        print(f"Playground: {server.url}")
-        if options.open_browser:
-            webbrowser.open(server.url)
-        while True:
-            time.sleep(3600)
-    except KeyboardInterrupt:
-        return
-    finally:
-        server.stop()
-
-
-def _is_api_path(path: str) -> bool:
-    return path in {"/status", "/session", "/session/setup", "/session/auto", "/runtime-info", "/screenshot", "/yaml/input"} or path.startswith(
-        ("/task-progress/", "/preview/", "/reports/", "/replay/", "/replay-video/", "/runs/", "/step-artifacts/", "/yaml/recorded/")
-    )
-
-
-def _is_relative_to(path: Path, root: Path) -> bool:
-    try:
-        path.relative_to(root)
-    except ValueError:
-        return False
-    else:
-        return True
-
-
-def _step_index_from_step_id(value: str) -> int | None:
-    match = re.search(r"(?:^|[-_/])step[-_](\d+)(?:\D|$)", value)
-    if match is None:
-        return None
-    return int(match.group(1))
-
-
-def _parse_byte_range(range_header: str | None, total_size: int) -> tuple[int, int] | None:
-    if not range_header or total_size <= 0:
-        return None
-    raw = range_header.strip()
-    if not raw.lower().startswith("bytes="):
-        return None
-    spec = raw[len("bytes=") :].split(",", 1)[0].strip()
-    if not spec or "-" not in spec:
-        return None
-    start_text, end_text = spec.split("-", 1)
-    start_text = start_text.strip()
-    end_text = end_text.strip()
-    last_index = total_size - 1
-    try:
-        if start_text == "":
-            suffix_length = int(end_text)
-            if suffix_length <= 0:
-                return None
-            start = max(0, total_size - suffix_length)
-            end = last_index
-        else:
-            start = int(start_text)
-            end = int(end_text) if end_text else last_index
-    except ValueError:
-        return None
-    if start < 0 or start > last_index or end < start:
-        return None
-    return start, min(end, last_index)
-
-
-def _after_sequence(query: dict[str, list[str]]) -> int | None:
-    values = query.get("after_sequence") or query.get("afterSequence") or []
-    if not values:
-        return None
-    try:
-        return max(0, int(values[0]))
-    except (TypeError, ValueError):
-        return None
diff --git a/fsq_agent/adapters/control_plane/playground/_state.py b/fsq_agent/adapters/control_plane/playground/_state.py
deleted file mode 100644
index 0ea9d16d..00000000
--- a/fsq_agent/adapters/control_plane/playground/_state.py
+++ /dev/null
@@ -1,270 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-from datetime import UTC, datetime
-from threading import Condition
-from typing import Literal
-from uuid import uuid4
-
-from fsq_agent.models import FsqAgentError, RunEvent, TaskResult
-
-TaskProgressStatus = Literal["running", "success", "failed", "inconclusive", "error", "cancelled"]
-
-
-def _utc_now() -> str:
-    return datetime.now(UTC).isoformat()
-
-
-@dataclass
-class PlaygroundSession:
-    connected: bool = False
-    device_id: str | None = None
-    display_name: str | None = None
-    metadata: dict[str, object] = field(default_factory=dict)
-
-    def to_json(self) -> dict[str, object]:
-        return {
-            "connected": self.connected,
-            "deviceId": self.device_id,
-            "displayName": self.display_name,
-            "metadata": self.metadata,
-        }
-
-
-@dataclass
-class TaskProgress:
-    request_id: str
-    goal: str
-    run_id: str | None = None
-    status: TaskProgressStatus = "running"
-    started_at: str = field(default_factory=_utc_now)
-    completed_at: str | None = None
-    events: list[dict[str, object]] = field(default_factory=list)
-    preview: dict[str, object] | None = None
-    active_step: dict[str, object] | None = None
-    replay: dict[str, object] | None = None
-    replay_reset: bool = False
-    cancel_requested: bool = False
-    result: dict[str, object] | None = None
-    error: str | None = None
-
-    def to_json(self) -> dict[str, object]:
-        return {
-            "requestId": self.request_id,
-            "runId": self.run_id,
-            "goal": self.goal,
-            "status": self.status,
-            "startedAt": self.started_at,
-            "completedAt": self.completed_at,
-            "events": self.events,
-            "preview": self.preview,
-            "activeStep": self.active_step,
-            "replay": self.replay,
-            "cancelRequested": self.cancel_requested,
-            "result": self.result,
-            "error": self.error,
-        }
-
-
-class PlaygroundState:
-    def __init__(self) -> None:
-        self._lock = Condition()
-        self._revision = 0
-        self.server_id = str(uuid4())
-        self.session = PlaygroundSession()
-        self.current_request_id: str | None = None
-        self.tasks: dict[str, TaskProgress] = {}
-        self.last_run: dict[str, object] | None = None
-
-    def _notify(self) -> None:
-        self._revision += 1
-        self._lock.notify_all()
-
-    def wait_for_update(self, request_id: str, after_sequence: int, last_revision: int, timeout: float) -> tuple[dict[str, object] | None, int]:
-        with self._lock:
-            if self._revision == last_revision:
-                self._lock.wait(timeout)
-            task = self.tasks.get(request_id)
-            if task is None:
-                return None, self._revision
-            payload = task.to_json()
-            payload["events"] = [event for event in task.events if isinstance(event.get("sequence"), int) and event["sequence"] > after_sequence]
-            return payload, self._revision
-
-    def status(self) -> dict[str, object]:
-        with self._lock:
-            return {
-                "status": "ok",
-                "id": self.server_id,
-                "busy": self.current_request_id is not None,
-                "session": self.session.to_json(),
-                "lastRun": self.last_run,
-            }
-
-    def create_session(self, device_id: str) -> dict[str, object]:
-        with self._lock:
-            if self.current_request_id:
-                raise BusyError("Cannot replace session while a task is running.")
-            normalized = device_id.strip()
-            self.session = PlaygroundSession(
-                connected=True,
-                device_id=normalized,
-                display_name=normalized,
-                metadata={"platform": "android"},
-            )
-            return self.session.to_json()
-
-    def destroy_session(self) -> dict[str, object]:
-        with self._lock:
-            if self.current_request_id:
-                raise BusyError("Cannot destroy session while a task is running.")
-            self.session = PlaygroundSession()
-            return self.session.to_json()
-
-    def start_task(self, goal: str) -> str:
-        with self._lock:
-            if self.current_request_id:
-                raise BusyError("Another task is already running.")
-            request_id = str(uuid4())
-            self.current_request_id = request_id
-            self.tasks[request_id] = TaskProgress(request_id=request_id, goal=goal)
-            return request_id
-
-    def add_event(self, request_id: str, event: RunEvent) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return
-            if event.run_id:
-                task.run_id = event.run_id
-            event_payload = event.model_dump(mode="json")
-            if not isinstance(event_payload.get("sequence"), int) or event_payload["sequence"] <= 0:
-                event_payload["sequence"] = len(task.events) + 1
-            task.events.append(event_payload)
-            self._notify()
-
-    def bind_run_id(self, request_id: str, run_id: str) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is not None:
-                task.run_id = run_id
-
-    def set_replay(self, request_id: str, replay: dict[str, object]) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return
-            task.replay = replay
-
-    def set_preview(self, request_id: str, preview: dict[str, object]) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return
-            task.preview = preview
-            self._notify()
-
-    def set_active_step(self, request_id: str, active_step: dict[str, object] | None) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return
-            task.active_step = active_step
-            self._notify()
-
-    def mark_replay_reset(self, request_id: str) -> bool:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return False
-            if task.replay_reset:
-                return False
-            task.replay_reset = True
-            return True
-
-    def request_cancel(self, request_id: str) -> dict[str, object] | None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return None
-            if task.status != "running":
-                return task.to_json()
-            task.cancel_requested = True
-            task.status = "cancelled"
-            task.completed_at = _utc_now()
-            task.active_step = None
-            task.error = "Cancelled by user."
-            if self.current_request_id == request_id:
-                self.current_request_id = None
-            self._notify()
-            return task.to_json()
-
-    def is_cancel_requested(self, request_id: str) -> bool:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            return bool(task and task.cancel_requested)
-
-    def finish_task(self, request_id: str, result: TaskResult, recording: dict[str, object] | None = None) -> None:
-        with self._lock:
-            task = self.tasks[request_id]
-            if task.cancel_requested:
-                return
-            task.run_id = result.report.run_id
-            task.status = result.status
-            task.completed_at = _utc_now()
-            task.active_step = None
-            task.result = {
-                "taskId": result.task_id,
-                "status": result.status,
-                "summary": result.verification.summary,
-                "runId": result.report.run_id,
-                "reportPath": str(result.report.path),
-                "durationMs": result.duration_ms,
-                "recording": recording,
-                "replay": task.replay,
-            }
-            self.last_run = task.result
-            if self.current_request_id == request_id:
-                self.current_request_id = None
-            self._notify()
-
-    def fail_task(self, request_id: str, error: BaseException | str) -> None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is not None:
-                if task.cancel_requested:
-                    return
-                task.status = "error"
-                task.completed_at = _utc_now()
-                task.active_step = None
-                if isinstance(error, FsqAgentError) and error.context:
-                    details = json.dumps(error.context, ensure_ascii=False, default=str)
-                    task.error = f"{str(error) or error.__class__.__name__} Context: {details}"
-                else:
-                    task.error = str(error) or error.__class__.__name__ if isinstance(error, BaseException) else str(error)
-            if self.current_request_id == request_id:
-                self.current_request_id = None
-            self._notify()
-
-    def get_task(self, request_id: str, after_sequence: int | None = None) -> dict[str, object] | None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            if task is None:
-                return None
-            payload = task.to_json()
-            if after_sequence is not None:
-                payload["events"] = [event for event in task.events if isinstance(event.get("sequence"), int) and event["sequence"] > after_sequence]
-            return payload
-
-    def run_id_for_request(self, request_id: str) -> str | None:
-        with self._lock:
-            task = self.tasks.get(request_id)
-            return task.run_id if task else None
-
-
-class BusyError(RuntimeError):
-    pass
diff --git a/fsq_agent/adapters/control_plane/playground/_yaml_lifecycle.py b/fsq_agent/adapters/control_plane/playground/_yaml_lifecycle.py
deleted file mode 100644
index 1ed7bded..00000000
--- a/fsq_agent/adapters/control_plane/playground/_yaml_lifecycle.py
+++ /dev/null
@@ -1,179 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from __future__ import annotations
-
-import os
-import tempfile
-from hashlib import sha256
-from io import StringIO
-from pathlib import Path
-
-from ruamel.yaml import YAML
-from ruamel.yaml.comments import CommentedMap, CommentedSeq
-
-from fsq_agent.case_dsl import FSQ_CASE_SUFFIX, FsqCaseLoader
-from fsq_agent.models import FsqCaseHook, FsqCaseHookAction
-
-
-class YamlLifecycleConflictError(Exception):
-    pass
-
-
-class YamlLifecycleValidationError(Exception):
-    pass
-
-
-class YamlLifecycleWriteError(Exception):
-    pass
-
-
-def yaml_revision(content: bytes) -> str:
-    return f"sha256:{sha256(content).hexdigest()}"
-
-
-def lifecycle_display(metadata: dict[object, object]) -> dict[str, list[dict[str, object]]]:
-    return {
-        "onCaseStart": _display_hooks(metadata.get("onCaseStart")),
-        "onCaseComplete": _display_hooks(metadata.get("onCaseComplete")),
-    }
-
-
-def save_lifecycle(
-    path: Path,
-    *,
-    expected_revision: str,
-    on_case_start: object,
-    on_case_complete: object,
-    size_limit_bytes: int,
-) -> bytes:
-    source = path.read_bytes()
-    if len(source) > size_limit_bytes:
-        raise YamlLifecycleValidationError(f"YAML file is too large to edit ({len(source)} bytes).")
-    if yaml_revision(source) != expected_revision:
-        raise YamlLifecycleConflictError("Case YAML changed on disk. Reload before saving.")
-    try:
-        text = source.decode("utf-8")
-    except UnicodeDecodeError as exc:
-        raise YamlLifecycleValidationError("Case YAML must be UTF-8 text.") from exc
-
-    start_hooks = _request_hooks(on_case_start)
-    complete_hooks = _request_hooks(on_case_complete)
-    yaml_rt = _round_trip_yaml()
-    try:
-        documents = list(yaml_rt.load_all(text))
-    except Exception as exc:
-        raise YamlLifecycleValidationError(str(exc) or "Unable to parse YAML for editing.") from exc
-    if not documents or not isinstance(documents[0], CommentedMap):
-        raise YamlLifecycleValidationError("FSQ metadata document must be a YAML mapping.")
-
-    metadata = documents[0]
-    _replace_lifecycle(metadata, "onCaseStart", start_hooks)
-    _replace_lifecycle(metadata, "onCaseComplete", complete_hooks)
-    try:
-        output = StringIO()
-        yaml_rt.explicit_start = text.lstrip("\ufeff \t\r\n").startswith("---")
-        yaml_rt.dump_all(documents, output)
-        saved_text = output.getvalue()
-    except Exception as exc:
-        raise YamlLifecycleValidationError(str(exc) or "Unable to serialize lifecycle hooks.") from exc
-    if "\r\n" in text:
-        saved_text = saved_text.replace("\n", "\r\n")
-    saved = saved_text.encode("utf-8")
-    if len(saved) > size_limit_bytes:
-        raise YamlLifecycleValidationError(f"Resulting YAML is too large to edit ({len(saved)} bytes).")
-
-    temporary_path: Path | None = None
-    try:
-        with tempfile.NamedTemporaryFile(
-            mode="wb",
-            dir=path.parent,
-            prefix=f".{path.name}.",
-            suffix=FSQ_CASE_SUFFIX,
-            delete=False,
-        ) as handle:
-            temporary_path = Path(handle.name)
-            handle.write(saved)
-            handle.flush()
-            os.fsync(handle.fileno())
-        FsqCaseLoader().load_case(temporary_path)
-        _ensure_source_revision(path, expected_revision)
-        try:
-            temporary_path.replace(path)
-        except OSError as exc:
-            raise YamlLifecycleWriteError(str(exc) or "Unable to replace case YAML.") from exc
-        temporary_path = None
-    except YamlLifecycleConflictError:
-        raise
-    except YamlLifecycleValidationError:
-        raise
-    except YamlLifecycleWriteError:
-        raise
-    except OSError as exc:
-        raise YamlLifecycleWriteError(str(exc) or "Unable to write temporary case YAML.") from exc
-    except Exception as exc:
-        raise YamlLifecycleValidationError(str(exc) or "Unable to validate or save lifecycle hooks.") from exc
-    finally:
-        if temporary_path is not None:
-            temporary_path.unlink(missing_ok=True)
-    return saved
-
-
-def _round_trip_yaml() -> YAML:
-    yaml_rt = YAML(typ="rt")
-    yaml_rt.preserve_quotes = True
-    yaml_rt.explicit_start = False
-    yaml_rt.width = 4096
-    return yaml_rt
-
-
-def _display_hooks(value: object) -> list[dict[str, object]]:
-    if value is None:
-        return []
-    entries = value if isinstance(value, list) else [value]
-    hooks = [FsqCaseHook.model_validate(entry) for entry in entries]
-    actions = [action for hook in hooks for action in hook.actions]
-    return [{"index": index, "action": action.action_name, "value": action.value} for index, action in enumerate(actions, start=1)]
-
-
-def _request_hooks(value: object) -> list[FsqCaseHook]:
-    if not isinstance(value, list):
-        raise YamlLifecycleValidationError("Lifecycle hook fields must be lists.")
-    try:
-        hooks = [_request_hook(action) for action in value]
-    except YamlLifecycleValidationError:
-        raise
-    except Exception as exc:
-        raise YamlLifecycleValidationError(str(exc) or "Invalid lifecycle hook data.") from exc
-    return hooks
-
-
-def _request_hook(action: object) -> FsqCaseHook:
-    if not isinstance(action, dict):
-        raise YamlLifecycleValidationError("Lifecycle actions must be objects.")
-    validated = FsqCaseHookAction.model_validate({"action_name": action.get("action"), "value": action.get("value")})
-    return FsqCaseHook(actions=[validated])
-
-
-def _ensure_source_revision(path: Path, expected_revision: str) -> None:
-    if yaml_revision(path.read_bytes()) != expected_revision:
-        raise YamlLifecycleConflictError("Case YAML changed on disk. Reload before saving.")
-
-
-def _replace_lifecycle(metadata: CommentedMap, key: str, hooks: list[FsqCaseHook]) -> None:
-    if not hooks:
-        metadata.pop(key, None)
-        return
-    serialized = CommentedSeq()
-    for hook in hooks:
-        entry = CommentedMap()
-        for action in hook.actions:
-            entry[action.action_name] = action.value
-        serialized.append(entry)
-    if key in metadata:
-        metadata[key] = serialized
-        return
-    if key == "onCaseStart" and "onCaseComplete" in metadata:
-        metadata.insert(list(metadata).index("onCaseComplete"), key, serialized)
-    else:
-        metadata[key] = serialized
diff --git a/fsq_agent/capabilities/SPEC.md b/fsq_agent/capabilities/SPEC.md
index e64e0f2d..dfcf795a 100644
--- a/fsq_agent/capabilities/SPEC.md
+++ b/fsq_agent/capabilities/SPEC.md
@@ -10,7 +10,7 @@ This module does not execute capabilities, invoke CommonTool or PlatformTool pro
 
 - Internal project dependencies: `models` only. Uses `CapabilityDefinition`, `CapabilityExecutorKind`, `ExecutableStepKind`, `HarnessPlatform`, `ReplayPolicy`, and `ConfigurationError`.
 - External dependencies: standard library dataclasses, inspect, typing, and Pydantic `BaseModel` type references.
-- Forbidden dependencies: `core`, `tools`, `agent`, `cli`, `fsq`, `config`, `providers`, `report`, `playground`, `observation`, `knowledge`, `skills`, OpenAI Agents SDK types, concrete driver/runtime objects, and backend SDKs.
+- Forbidden dependencies: `core`, `tools`, `agent`, `cli`, `fsq`, `config`, `providers`, `report`, `observation`, `knowledge`, `skills`, OpenAI Agents SDK types, concrete driver/runtime objects, and backend SDKs.
 
 ## Public Interface
 
diff --git a/fsq_agent/config/SPEC.md b/fsq_agent/config/SPEC.md
index ce778264..b54f705a 100644
--- a/fsq_agent/config/SPEC.md
+++ b/fsq_agent/config/SPEC.md
@@ -46,7 +46,7 @@ Provider metadata and the workspace registry are read only from `~/.fsq/config.y
 
 Shared configuration rules:
 
-- The explicitly selected configured workspace platform selects exactly one committed preset and matching `harness.<platform>` settings block for dynamic, strict, and Playground execution.
+- The explicitly selected configured workspace platform selects exactly one committed preset and matching `harness.<platform>` settings block for dynamic and strict execution.
 - Repository presets own stable platform/backend, turn-limit, timeout, snapshot, browser policy, lifecycle, delay, and reusable skill settings. Workspace config owns target identity, private runtime secrets, and workspace paths.
 - `agent_context.knowledge.root_dir` resolves to workspace `knowledge/<platform>/`. Preset-configured reusable skill paths remain repository-relative and do not move under that workspace root. Optional pre-plan page knowledge uses the selected platform knowledge root.
 - Validation rejects unsupported platform/backend combinations, mismatched workspace target variants, unsafe roots, and invalid local target files before external actions.
@@ -71,7 +71,7 @@ Android configuration:
 
 - `harness.android.backend` supports `uiautomator2` in the first Android backend.
 - Workspace target `app_id` is required. Android serial is not a configuration field; an entry layer may assign it only to a run-specific settings copy after device selection.
-- Strict Android runs may fall back to FSQ case `appId` metadata where the CLI/playground strict entry permits it.
+- Strict Android runs may fall back to FSQ case `appId` metadata where the active entry contract permits it.
 
 Web configuration:
 
diff --git a/fsq_agent/control_plane/SPEC.md b/fsq_agent/control_plane/SPEC.md
index 05d7a672..b7b10c88 100644
--- a/fsq_agent/control_plane/SPEC.md
+++ b/fsq_agent/control_plane/SPEC.md
@@ -4,7 +4,7 @@
 
 Preserve documented `fsq_agent.control_plane` server entry symbols as compatibility exports for canonical `adapters.control_plane`. Canonical modules own HTTP/static delivery, generated package data, trusted-local Provider/workspace transport, directory selection, authorization state, Devices state, streaming, evidence projection, and replay transport. Old `fsq_agent.control_plane._*` private module paths are unsupported and absent.
 
-The module is an entry-layer application. Shared workspace initialization, target resolution, Driver readiness/install coordination, and Web executable discovery use the public Application boundary; Control Plane projects those results through HTTP and browser UI. Explore and Strict execution delegate to public Execution services while Control Plane retains task state, cancellation projection, streaming, and safe evidence presentation. It does not own a second model/tool loop, capability implementation, FSQ parser, strict lifecycle semantics, recorder, evidence schema, report generator, platform driver, browser discovery table, installer, or Playground behavior.
+The module is an entry-layer application. Shared workspace initialization, target resolution, Driver readiness/install coordination, and Web executable discovery use the public Application boundary; Control Plane projects those results through HTTP and browser UI. Explore and Strict execution delegate to public Execution services while Control Plane retains task state, cancellation projection, streaming, and safe evidence presentation. It does not own a second model/tool loop, capability implementation, FSQ parser, strict lifecycle semantics, recorder, evidence schema, report generator, platform driver, browser discovery table, or installer.
 
 ## Dependencies
 
@@ -19,7 +19,7 @@ The module is an entry-layer application. Shared workspace initialization, targe
 - `report`: Uses existing report generation and report-artifact contracts.
 - External dependencies: Python standard-library HTTP, threading, subprocess, path, MIME, JSON, base64, and browser-opening facilities. Optional platform backend dependencies remain lazy runtime concerns of their owning modules.
 
-The module must not import `playground`, `cli`, `capabilities`, module-private `_*.py` files from another public module, concrete private harnesses/drivers, OpenAI Agents SDK runtime types, or frontend source. Other domain/runtime modules must not import `control_plane`; `cli` may import its public server API.
+The module must not import `cli`, `capabilities`, module-private `_*.py` files from another public module, concrete private harnesses/drivers, OpenAI Agents SDK runtime types, or frontend source. Other domain/runtime modules must not import `control_plane`; `cli` may import its public server API.
 
 ## Public Interface
 
@@ -108,7 +108,7 @@ Control Plane projects existing execution facts into:
 - A contained ordered per-step evidence index sourced from persisted event artifact references and `evidence-manifest.json`.
 - A contained chronological screenshot-frame sequence used only by the explicit replay endpoint.
 
-SSE payloads do not embed screenshot bytes, large UI snapshots, replay frames/video, hidden reasoning, secret values, or unrestricted backend objects. Artifact paths are resolved only below the frozen run directory. Evidence absence or read failure is explicit and does not imply run success or failure. Control Plane replay storage is independent of Playground replay storage and neither module imports or delegates to the other.
+SSE payloads do not embed screenshot bytes, large UI snapshots, replay frames/video, hidden reasoning, secret values, or unrestricted backend objects. Artifact paths are resolved only below the frozen run directory. Evidence absence or read failure is explicit and does not imply run success or failure. Control Plane stores generated replay video only under its run-local `control-plane-replay` directory and ignores unrelated Run files.
 
 All API errors use `code`, `message`, `action`, and optional safe `details`.
 
@@ -138,7 +138,7 @@ All API errors use `code`, `message`, `action`, and optional safe `details`.
 - Internal modules: all `_*.py` files and generated `static` content are private implementation details.
 - Domain boundaries: Control Plane owns local HTTP/UI adaptation, trusted-local Provider/workspace transport, host-native directory chooser orchestration, safe projections, device-flow task lifecycle, workspace-aware Devices state, evidence presentation, and replay-video transport. Application owns workspace target/readiness/mutation use cases; Config owns Provider/registry/platform persistence and settings composition; other modules retain their execution and domain responsibilities.
 - Boundary models: HTTP request/response dictionaries and private immutable discovery/projection records sit at the transport boundary; shared runtime facts use `models` contracts.
-- Dependency direction: CLI may import Control Plane public APIs; Control Plane imports Application, Execution, and other owning-module public APIs only; owning modules and Playground do not import Control Plane.
+- Dependency direction: CLI may import Control Plane public APIs; Control Plane imports Application, Execution, and other owning-module public APIs only; owning modules do not import Control Plane.
 - Rationale: The module coordinates trusted local transport, multi-file workspace creation and platform mutation, read-only filesystem browsing, Provider configuration, workspace-selected local targets, two Devices execution paths, state streaming, evidence persistence, and static delivery, so Level 3 is required. Additional repository/domain layers would only pass data through.
 
 ## Error Handling
@@ -158,13 +158,13 @@ Static serving rejects path traversal and cross-entry fallback. Missing generate
 ## Verification Scope
 
 - Verification covers Provider Config plus workspace parent-directory selection and workspace list/summary/create/platform-detail/add/update route methods and shapes; picker exact-body, selected/cancelled, normalization, one-active conflict, unavailable/failure, fixed-argument no-shell host adapters, bounded output, and shutdown cleanup; registry/canonical platform ordering, partial/unavailable projection, all four platform target variants, immutable identity, independent exact revisions/conflicts, no platform deletion path, atomic writes, rollback/adoption preservation, bounded tree/file browsing, no-store behavior, loopback/same-origin gates, independent GitHub authorization/discovery/save lifecycle, offered-model validation, expiration/cancellation/shutdown scrubbing, saved-only connection testing, workspace-platform readiness/target discovery, safe platform-scoped case discovery, Explore/Strict validation and delegation, strict AI-assertion provider gating, frozen workspace-platform run state, one-task locking, state transitions, cancellation, SSE resume, latest and per-step evidence projection, replay-frame ordering, replay-video validation/storage/range reads, terminal Explore generated-YAML saving to the frozen cases directory, safe errors, static serving, and isolated-wheel startup.
-- Security boundaries cover trusted-local Provider/workspace data, list/detail secret separation, `.fsq` denial, path/symlink containment, exact server-issued step ids, bounded reads/discovery and artifact/frame/video IO, atomic video replacement, secret/reasoning redaction, no browser-supplied roots/artifact paths, no CORS, and no imports from Playground or module-private implementation files.
+- Security boundaries cover trusted-local Provider/workspace data, list/detail secret separation, `.fsq` denial, path/symlink containment, exact server-issued step ids, bounded reads/discovery and artifact/frame/video IO, atomic video replacement, secret/reasoning redaction, no browser-supplied roots/artifact paths, no CORS, and no imports from module-private implementation files.
 - Compatibility verification proves Control Plane can start from any directory, workspace APIs and Devices use only registered roots plus explicit platform selection, unsupported legacy workspaces remain safely unavailable, and no execution derives configuration or output from the process startup directory.
 - Integration verification proves at least one available platform can start Explore and Strict runs, emit progress/evidence, switch evidence views through the API, cancel, reach a truthful terminal state, retrieve one step's Before/After artifacts, enumerate replay frames, upload a generated WebM, and seek its stored range response.
 
 ## Current Invariants
 
-- Control Plane is independent from Playground and does not delegate to it.
+- Control Plane composes its browser transport directly over public Application and Execution boundaries and does not delegate to another browser adapter.
 - Control Plane composes shared execution authority; it never implements a second agent loop, strict runner, parser, lifecycle engine, capability table, evidence schema, recorder, or report generator.
 - Control Plane transport never owns Provider/registry/config file formats, GitHub protocol behavior, token exchange, or model invocation. It delegates persistence/settings rules to `config` and provider protocols to `providers`.
 - Provider Config and workspace APIs require a loopback bind and peer, reject cross-origin writes, disable caching, and do not enable CORS. The complete Azure key and platform env values are returned only through their documented trusted-local selected-platform detail surface; GitHub tokens are never returned.
diff --git a/fsq_agent/core/SPEC.md b/fsq_agent/core/SPEC.md
index 94bd70ec..def20a4d 100644
--- a/fsq_agent/core/SPEC.md
+++ b/fsq_agent/core/SPEC.md
@@ -30,7 +30,7 @@ Current `__init__.py` exports via `__all__`:
 - `CapabilityRegistry`: Validated runtime registry for decorated capabilities. It resolves canonical names and `ReplayPolicy(kind="fsq_command").alias` values, rejects duplicate names and ambiguous replay aliases, exposes serializable snapshots, and validates that every capability has a parameter model/schema and executor binding.
 - `CapabilityDefinitionFactory`: Concrete factory class for PlatformTool capability definitions. It exposes `platform_definitions(platform, backend=None, include_ai_assertion=True)` so registry bootstrap can select the active platform/backend's PlatformTools without exposing function-style helper exports or private concrete backend driver classes.
 - `DriverFactory`: Concrete factory class for selecting private concrete backend drivers from config-owned platform backend settings. It exposes typed `create_android_driver`, `create_web_driver`, `create_windows_driver`, and `create_macos_driver` methods, each returning the corresponding public driver protocol. It is not named `Default` because config selects the backend implementation; additional platform driver implementations belong behind this config-selected factory boundary.
-- `HarnessFactory`: Concrete factory class for constructing runtime harnesses. Each supported platform has one built-in harness implementation; this factory is a convenience composition boundary that creates the configured driver through `DriverFactory` and wraps it in the private concrete platform harness. It returns `HarnessInterface` and accepts the active platform, `HarnessSettings`, optional `ArtifactStore`, optional `AIAssertionEvaluatorProtocol`, runtime secret settings, and Android app/serial overrides used by strict cases and playground device selection.
+- `HarnessFactory`: Concrete factory class for constructing runtime harnesses. Each supported platform has one built-in harness implementation; this factory is a convenience composition boundary that creates the configured driver through `DriverFactory` and wraps it in the private concrete platform harness. It returns `HarnessInterface` and accepts the active platform, `HarnessSettings`, optional `ArtifactStore`, optional `AIAssertionEvaluatorProtocol`, runtime secret settings, and Android app/serial overrides used by strict cases and Control Plane device selection.
 - `RuntimeSecretStore`: Process-local runtime-secret resolver built from the names and private values in `RuntimeSecretSettings`. It exposes safe available names, resolves values only in memory, never reads workspace secrets from `os.environ`, and never persists values.
 - `AndroidDeviceDiscovery`: Stable service class that resolves ADB from `PATH`, executes only the fixed bounded `adb devices -l` command, parses every well-formed device state and safe metadata field into model-owned contracts, and returns expected discovery failures as `AndroidDeviceDiscoveryResult`. It does not select a device or emit CLI/HTTP response wording.
 - `HarnessInterface`: Protocol describing platform capabilities required by StepRunner. Concrete Android, Web, iOS, and fake harnesses may satisfy the protocol structurally.
diff --git a/fsq_agent/execution/SPEC.md b/fsq_agent/execution/SPEC.md
index 3274e897..644c1b77 100644
--- a/fsq_agent/execution/SPEC.md
+++ b/fsq_agent/execution/SPEC.md
@@ -26,7 +26,7 @@ The package exports its supported services and result contracts through `executi
 - `DynamicExecutionRequest`, `DynamicExecutionResult`, `DeterministicExecutionRequest`, `DeterministicExecutionResult`, `LifecycleExecutionRequest`, `LifecycleExecutionResult`, and `RecordingResult`: immutable execution-boundary contracts with no transport types.
 - Run lifecycle operations allocate a collision-resistant Workspace-wide ID, atomically create its direct platform directory, write `fsq.run/v1` metadata before actions, advance monotonic active states, and atomically finalize one immutable terminal state. Allocation checks every configured platform and retries a collision at most five times.
 
-Public services accept already resolved Workspace/platform settings and explicit collaborators. They return normalized results and safe artifact references; adapters alone map them to CLI output, HTTP/SSE state, or Playground responses.
+Public services accept already resolved Workspace/platform settings and explicit collaborators. They return normalized results and safe artifact references; adapters alone map them to CLI output or HTTP/SSE state.
 
 Execution services are imported from `fsq_agent.execution`. Package-root `_strict_lifecycle` and `_strict_case_recording` compatibility modules are absent.
 
@@ -58,7 +58,7 @@ Initial metadata failure prevents external actions and removes only an empty req
 
 ## Verification Scope
 
-- Dynamic, deterministic, lifecycle, and recording behavior is identical across CLI, Control Plane, and Playground for equivalent inputs and collaborators.
+- Dynamic, deterministic, lifecycle, and recording behavior is identical across CLI and Control Plane for equivalent inputs and collaborators.
 - Lifecycle verification covers configuration and Case hook ordering, repeated actions, nested Cases, recursion, containment, start failure, completion hooks, teardown, cancellation, and platform shell selection.
 - Recording verification covers replay-policy filtering, authored aliases, normalized safe params, browser lifecycle facts, runtime-secret exclusion, validation, atomic Run-local writes, optional publication, and failure isolation.
 - Compatibility verification proves canonical and package-root lifecycle symbols share identity and no adapter contains an independent lifecycle engine or recorder. Recording verification exercises the public `RecordingService` boundary rather than importing its private recorder implementation.
diff --git a/fsq_agent/playground/SPEC.md b/fsq_agent/playground/SPEC.md
deleted file mode 100644
index b0a09cc0..00000000
--- a/fsq_agent/playground/SPEC.md
+++ /dev/null
@@ -1,161 +0,0 @@
-# Module: playground compatibility entry
-
-## Purpose
-
-Preserve documented `fsq_agent.playground` server entry symbols as compatibility exports for canonical `adapters.control_plane.playground`. Canonical modules own the HTTP API, generated package data, server-side session/task state, execution adaptation, safe YAML/run-artifact access, replay persistence, and production static serving. Old `fsq_agent.playground._*` private module paths are unsupported and absent.
-
-The authored browser application and browser-local interaction state are owned by `frontend/playground/SPEC.md`. This Python module is an entry-layer convenience surface that reuses existing FSQ-Agent execution, configuration, platform harness/tool provider, event, report, and recording contracts rather than implementing a separate agent loop or platform runner.
-
-## Dependencies
-
-- `models`: Uses `Task`, `TaskResult`, `RunEvent`, report artifacts, and shared configuration/error models.
-- `config`: Receives validated workspace-platform startup settings, refreshes only the user-provider portion at each complete execution boundary, and applies the same runtime/provider/strict validation policy used by CLI entry points.
-- `providers`: Builds the provider-backed AI assertion evaluator used by configured dynamic and strict execution.
-- `agent`: Runs dynamic goal/raw-reference tasks through `FsqAgent.run` and receives live events through an event sink.
-- `execution`: Coordinates shared dynamic, deterministic, lifecycle, cancellation/teardown, report-input, and recording behavior.
-- `fsq`: Loads strict FSQ YAML cases and converts them into executable steps for strict mode.
-- `core`: Uses shared Android device discovery, active platform harnesses, platform CommonTool providers, and driver capabilities for session metadata, screenshot capture, and strict-core step execution.
-- `report`: Resolves generated report paths for completed runs.
-- External dependencies: Pydantic supplies validation errors at the execution boundary. PyYAML is used only by playground HTTP display endpoints to parse YAML into a safe presentation model. `ruamel.yaml` is used only for round-trip mutation of editable Input YAML lifecycle metadata. Presentation parsing and round-trip mutation must not replace `fsq` strict case loading, lifecycle validation, or executable-step conversion. Generated browser assets are supplied by the frontend workspace at the package/static-serving boundary; Python runtime code does not depend on Node.js or authored frontend modules.
-The module must not be imported by `models`, `config`, `providers`, `tools`, `observation`, `knowledge`, `skills`, `fsq`, `core`, `agent`, or `report`. `cli` may import `playground` to expose the public command.
-
-The playground module must not import `capabilities` or decorator internals. It consumes public execution APIs, registry-backed strict adapters, and normalized run events in the same way as CLI entry paths.
-
-## Public Interface
-
-Current `__init__.py` exports via `__all__`:
-
-- `PlaygroundServer`: Local HTTP server wrapper.
-- `PlaygroundServerOptions`: Host, port, open-browser flag, and optional static path overrides for tests.
-- `run_playground(settings: Settings, options: PlaygroundServerOptions) -> None`: Blocking entry helper used by the CLI command after explicit workspace/platform resolution. It does not discover or select a workspace or platform.
-
-Initial HTTP API:
-
-| Endpoint | Behavior |
-|---|---|
-| `GET /status` | Return server health, selected session summary, and busy flag. |
-| `GET /session` | Return current Android session state, or a structured unavailable response when the active platform is not Android. |
-| `GET /session/setup` | Return Android setup schema plus discovered ADB targets, or a structured unavailable response when the active platform is not Android. |
-| `POST /session/auto` | Automatically select/create an Android session only when device discovery has one unambiguous online target; unavailable for non-Android platforms. |
-| `POST /session` | Select/create one Android session by device id when no task is running; unavailable for non-Android platforms. |
-| `DELETE /session` | Clear active session metadata when no task is running; unavailable for non-Android platforms. |
-| `GET /runtime-info` | Return platform/runtime metadata, preview capability, Android app id presence and selected device id when applicable, Web backend/channel/browser-executable-configured/headless/base URL presence when applicable, macOS backend/Appium-server-configured/bundle-id-presence/app-path-presence when applicable, and last run summary. Android runtime info has no configured/default serial member. |
-| `GET /yaml/input?path=...` | Resolve an input case YAML path inside `settings.cases.dir`, enforce containment and a conservative display size limit, read UTF-8 text, validate lifecycle metadata through existing FSQ case models, and return safe metadata, ordered `onCaseStart`/`onCaseComplete` presentation data, source revision, editability, and styled command-display data without executing hooks or commands. Raw YAML text may be returned only as copy-source data and must not be the primary visual presentation. |
-| `PUT /yaml/input/lifecycle` | Update only case-level `onCaseStart` and `onCaseComplete` metadata for one safely resolved live Input YAML file. The request supplies the input path, the revision returned by `GET /yaml/input`, and structured ordered hook/action data. The endpoint validates hooks through shared FSQ models, round-trip updates only the first YAML document, validates the complete temporary case through `FsqCaseLoader`, atomically replaces the source, and returns the refreshed Input YAML response. Empty hook lists remove their lifecycle keys. |
-| `GET /yaml/recorded/{request_or_run_id}` | Resolve a playground request id to its run id when possible or treat the value as a run id, read run-local `recording.json` metadata and `recorded.fsq.yaml` content only from inside `settings.output.runs_dir / run_id`, parse generated YAML only into a presentation model, and return styled-display data or recording status/warnings/errors. Each recorded display step exposes a `displayIndex` for presentation and an `artifactStepId` for querying step artifacts. Artifact step ids are derived by ordered alignment of each authored YAML action alias with persisted successful replay-event aliases; historical successful platform events without replay metadata use `fsq_action_name` as the compatibility alias. Extra events do not shift later matches, and an unmatched step has a null `artifactStepId`. Raw YAML text may be returned only as copy-source data and must not be the primary visual presentation. |
-| `POST /runs/load` | Resolve a user-supplied run id, runs-root-relative directory, or runs-root-contained absolute directory to one existing direct child of `settings.output.runs_dir`; reject files, the runs root, escapes, missing directories, and unrecognized directories; and return the normalized run id plus report, recorded-YAML, replay, and step-artifact availability metadata without aggregating artifact content. |
-| `GET /runs/{run_id}/progress` | Resolve one direct-child run id under `settings.output.runs_dir` and return valid persisted `RunEvent` dictionaries from its run-local `events.jsonl` in file order for the same Progress presentation used during live execution. Invalid JSON and non-object lines are skipped, missing or non-positive sequences are assigned monotonically, and a missing event log returns an empty event list. |
-| `POST /execute` | Start one dynamic goal, raw YAML-reference, or strict YAML execution and return a request id immediately. |
-| `POST /cancel/{request_id}` | Request cooperative cancellation for the currently running task and return the updated task state. |
-| `GET /task-progress/{request_id}` | Return progress and final result metadata for one request id. Without query parameters it returns accumulated events for compatibility; with `after_sequence` it returns only events whose sequence is greater than the supplied value so browser polling can append new progress without re-rendering history. |
-| `GET /task-stream/{request_id}` | Server-Sent Events stream of the same progress payloads. Emits a `data:` event whenever new progress is available and closes once the task leaves `running`. Honors `after_sequence` to resume. Polling `/task-progress` remains the fallback. |
-| `GET /screenshot` | Return an active-platform base64 screenshot and timestamp when available, or a structured unavailable/error response. |
-| `GET /replay/{request_or_run_id}` | Return persisted timestamped screenshot frames for one playground request id or run id, including the frame index, source path when available, and base64 screenshot bytes used by browser replay-video generation. A known request/run with no captured frames returns `200` with `available: false` and an empty frame list; an unknown id returns `404`. |
-| `GET /replay-video/{request_or_run_id}` | Return metadata for a stored run-local replay video when available. |
-| `POST /replay-video/{request_or_run_id}` | Store a browser-generated run-local replay video. |
-| `GET /replay-video-file/{request_or_run_id}` | Return the generated replay video bytes for browser playback. Honors HTTP `Range` requests (responds `206 Partial Content` with `Content-Range` and `Accept-Ranges: bytes`) so the browser can seek inside the WebM. |
-| `GET /step-artifacts/{request_or_run_id}/{step_id_or_index}` | Resolve one completed-run step and return safe run-local artifacts for that step. A step-id selector resolves strictly against artifact and event step ids; a numeric selector resolves against evidence step indices. Strict YAML uses evidence step ids; dynamic raw-YAML may best-effort use runner metadata. The endpoint returns screenshot and supported text artifacts, or a structured no-artifacts response. |
-| `GET /reports/{run_id}` | Resolve a stored Markdown or JSON report for one run id and return safe metadata or content. |
-
-`POST /execute` accepts exactly one of `goal`, `caseYamlPath`, or `strictCaseYamlPath`. `goal` constructs a dynamic `Task` equivalent to CLI `--goal`. Case paths must identify exact lowercase `.fsq.yaml` files contained below the selected platform's resolved `settings.cases.dir`; the same boundary applies to Input YAML display/edit and strict lifecycle `runCase` dependencies. Dynamic case input is read as complete UTF-8 raw reference text and is not parsed into strict steps. Strict case input executes through the shared lifecycle service and active platform harness. Lifecycle and main steps share one report and evidence manifest. Playground dynamic execution attempts post-run recording with `allow_failure=True`; a validated Goal recording, including a valid draft, is atomically published as `cases/<platform>/<run-id>.fsq.yaml`, while dynamic raw-case and strict YAML execution do not publish through this path.
-
-At the beginning of every accepted `/execute`, Playground copies its startup settings and refreshes only the user-provider snapshot before validating or constructing provider-dependent runtime objects. The server's selected workspace/platform identity, platform-config-derived target/secrets, session metadata, cases/knowledge/runs roots, and all other runtime policy remain unchanged for its lifetime. The refreshed snapshot is frozen for that complete execution; Provider changes do not alter a preparing/running/finalizing task.
-
-Lifecycle `runCase` uses strict path resolution and recursion detection, and repeated actions preserve authored order. Before-hook failure skips the remaining before/main work as appropriate, while after hooks still execute. Windows `runShell` uses PowerShell; other platforms use the local system shell. Playground cancellation applies throughout lifecycle execution.
-
-`PUT /yaml/input/lifecycle` is a source-editing operation, not an execution path. Each lifecycle field is represented as one ordered list of `runCase`/`runShell` actions; action types may repeat. Playground validates each row through shared FSQ action/hook models and serializes each row as one single-action YAML list item. It must not resolve `runCase` paths, run shell commands, adapt command steps, or execute lifecycle hooks. The server rejects saves while a task is running. The revision is a SHA-256 digest of the exact UTF-8 source bytes returned by `GET /yaml/input`; a mismatch returns `409` without modifying the source.
-
-## Platform Playground Blocks
-
-Shared playground behavior:
-
-- Runtime info reports the active platform and safe backend metadata.
-- Dynamic and strict execution use the selected platform's private runtime secret store as CLI execution. Playground may expose configured names but never values. Platform target/secret changes require restart; saved Provider changes are captured by the next `/execute` without restart.
-- `/execute`, progress polling, screenshots, replay frames/video, and report lookup route through the active platform execution path.
-- Strict execution parses YAML through the active platform registry snapshot containing inherited CommonTools plus active PlatformTools. Authored command names resolve through canonical capability names and active `fsq_command` replay aliases.
-- Strict execution always uses the shared lifecycle service, including cases without hooks. Lifecycle, child, and main steps share progress, evidence, report, preview, and replay behavior.
-- Existing-run loading is platform-neutral, read-only, and reuses the same report, recorded-YAML, replay, and step-artifact endpoints used after a live completed run.
-
-Android playground behavior:
-
-- Android session/setup endpoints project the public `core` Android discovery result into Playground targets and selected device state. They have no configured serial source and mark a discovery default only when exactly one online device is selectable.
-- Android screenshot preview uses the Android harness/driver screenshot path.
-
-Web playground behavior:
-
-- Android session/setup endpoints return structured unavailable responses when Web is active.
-- Web runtime info reports backend, channel, browser executable configured state, headless mode, and base URL presence.
-- Web dynamic and strict execution construct the active harness through `HarnessFactory` and the config-selected Web backend driver without launching a browser; `startBrowser` and `closeBrowser` remain explicit task/FSQ capabilities and are not injected by playground routes.
-- Web screenshot preview uses the active Web harness/driver screenshot path when a page is started and returns a structured unavailable/error response before `startBrowser` or after `closeBrowser`.
-
-Windows playground behavior:
-
-- Android session/setup endpoints return structured unavailable responses when Windows is active.
-- Windows runtime info reports backend, pywinauto backend kind, app path configured state, window title regex presence, launch-args count, busy state, and last-run summary.
-- Windows dynamic and strict execution construct the active harness through `HarnessFactory` and the config-selected Windows backend driver without launching the app during route setup, registry bootstrap, or YAML parsing; `launchApp` and `killApp` remain explicit task/FSQ capabilities and are not injected by playground routes.
-- Windows strict execution parses replay aliases such as `launchApp`, `clickOn`, `typeText`, `pressKey`, `uiSnapshot`, `assertVisible`, and `assertWithAI` through the Windows registry snapshot.
-- Windows screenshot preview uses the active Windows harness/driver screenshot path when a pywinauto window is available and returns a structured unavailable/error response before `launchApp` or after app cleanup.
-
-macOS playground behavior:
-
-- Android session/setup endpoints return structured unavailable responses when macOS is active.
-- macOS runtime info reports backend, Appium server configured state, bundle id presence, app path presence, busy state, and last-run summary.
-- macOS dynamic and strict execution construct the active harness through `HarnessFactory` and the config-selected macOS backend driver without connecting to Appium or launching the app during route setup; `launchApp` and `killApp` remain explicit task/FSQ capabilities and are not injected by playground routes.
-- macOS screenshot preview uses the active macOS harness/driver screenshot path when a Mac2 session exists and returns a structured unavailable/error response before `launchApp` or after session cleanup.
-- macOS strict execution parses replay aliases such as `clickOn`, `typeText`, `uiSnapshot`, `assertVisible`, `assertElementsOrder`, and `assertWithAI` through the macOS registry snapshot.
-
-## Internal Structure
-
-- `__init__.py`: Public exports only.
-- `_server.py`: Local HTTP server, JSON route dispatch, static serving, lifecycle, safe Input YAML and existing-run path resolution, input presentation shaping, existing-run availability inspection, run-local replay/video/report/artifact resolution, step-artifact response shaping, and dynamic recording option propagation.
-- `_yaml_lifecycle.py`: Private Input YAML lifecycle editing service. It validates structured hooks through public FSQ models, computes revisions, performs `ruamel.yaml` round-trip first-document mutation, validates temporary complete cases through `FsqCaseLoader`, preserves unrelated documents and formatting where supported, and atomically replaces source files.
-- `_state.py`: In-memory session/task state, one-task lock, progress event buffering with optional sequence-window projection, final result summaries, and request id generation.
-- `_android.py`: Playground target/error projection over shared `core` Android discovery, setup schema generation, Android session metadata, and screenshot helper boundaries.
-- `_execution.py`: Provider-only settings refresh at the complete-task boundary plus transport task-state, cancellation, preview, collaborator, and result adaptation around public Execution services.
-- `adapters/control_plane/playground/static/`: Untracked Vite-generated production assets included as Python package data beside the canonical Playground server. Authored source ownership is defined by `frontend/playground/SPEC.md`.
-- `SPEC.md`: Module design.
-
-## Python Architecture
-
-- Architecture level: Level 3 Layered Application.
-- Public API: `PlaygroundServer`, `PlaygroundServerOptions`, `run_playground`, and the local HTTP endpoints listed in this SPEC.
-- Internal modules: `_server.py`, `_state.py`, `_android.py`, `_execution.py`, `_yaml_lifecycle.py`, and generated package assets under `static`.
-- Domain boundaries: playground owns HTTP behavior, Input YAML lifecycle editing, safe run-artifact lookup, replay persistence, execution presentation adaptation, and task/session state. Shared models and `fsq` own lifecycle syntax and case validation; Execution owns dynamic/deterministic coordination, lifecycle execution, and recording. The frontend Playground module owns browser-local rendering, view state, interaction, and replay generation.
-- Boundary models: JSON request and response payloads returned by `_server.py`, ordered `FsqCaseHook`/`FsqCaseHookAction` values consumed for lifecycle validation, shared `Settings`, `Task`, `TaskResult`, `RunEvent`, report artifacts, and session/task progress dictionaries.
-- Dependency direction: playground may import public APIs from `execution`, `models`, `config`, `providers`, `agent`, `fsq`, `core`, and `report`; those modules must not import playground. Playground must not import package-root composition helpers, CLI-private modules, `capabilities`, decorator internals, or authored frontend source. Python runtime code consumes generated assets only at the packaging and static-serving boundary.
-- Rationale: playground coordinates HTTP transport, runtime state, execution adapters, filesystem-safe artifact access, replay persistence, reports, and recording summaries, so Level 3 remains appropriate. Browser-local application behavior is a separate frontend ownership boundary and does not require another Python layer.
-
-## Error Handling
-
-The playground returns JSON errors for API failures and does not expose tracebacks by default. Missing goals, missing case YAML paths, unreadable YAML references, ambiguous input bodies, Android-only endpoint use while a non-Android platform is active, ADB discovery errors, missing selected Android device, Web screenshot/runtime construction failures, macOS Appium/runtime construction failures, report resolution failures, and screenshot capture failures must produce concise structured errors. Recording failures must not change the dynamic run status. Goal publication failures preserve both execution and valid recording status and appear only as secret-safe recording warnings.
-
-Playground startup requires the generated static root and production entry. When either is absent in a source checkout, startup fails before binding the HTTP server with a concise instruction to run `npm ci` and `npm run build`. Installed wheels contain the generated assets and do not require Node.js at runtime.
-
-YAML display endpoints must return concise structured errors for missing paths, missing files, directory paths, non-UTF-8 reads, display size-limit failures, request ids that cannot resolve to runs, missing run directories, missing `recording.json`, invalid recording metadata, and recorded-case paths that escape the run directory. A skipped or failed recording must be displayed as recording metadata with warnings/errors when available rather than treated as a dynamic run failure. Recorded YAML and loaded-run YAML remain read-only.
-
-Input YAML lifecycle saves must not expose tracebacks or partially update source files. Malformed request data, invalid shared hook models, unsupported YAML document shapes, invalid complete FSQ cases, and serialization failures return `400`. Missing files return `404`. Busy/finalizing state and source revision conflicts return `409`; revision conflicts state that the file changed on disk and require reload. Existing or resulting files above the display/edit size limit return `413`. Atomic-write failures return `500`. The service writes a UTF-8 temporary file in the source directory, validates it through `FsqCaseLoader`, flushes it, and uses `os.replace`; every failure before replacement leaves the source unchanged and cleans up the temporary file.
-
-Existing-run loading must trim and validate the submitted `path`, resolve relative values under the resolved `settings.output.runs_dir`, and allow absolute values only when they resolve to an existing direct child directory of that root. It must reject the runs root itself, nested descendants, files, path or symlink escapes, missing directories, and directories without a recognized run marker. Recognized markers are `report.md`, `report.json`, `core-report.md`, `core-report.json`, `evidence-manifest.json`, `events.jsonl`, `recording.json`, `recorded.fsq.yaml`, `playground-replay/replay-manifest.json`, or `playground-replay/replay.webm`. Missing input, invalid directory shape, escapes, and unrecognized directories return structured `400` errors; a missing directory returns `404`.
-
-The successful existing-run response returns `available: true`, the direct-child directory name as `runId`, and an `availability` object. `report` is true when any supported report file is present. `recordedYaml` is true when `recording.json` or `recorded.fsq.yaml` is present. `replay` is true when a stored replay manifest/video exists or screenshot replay sources are discoverable from evidence/events metadata. `stepArtifacts` is true when `evidence-manifest.json` or `events.jsonl` is present. These flags report discoverability, not content validity; malformed content is handled independently by its dedicated endpoint and UI surface. The load endpoint must not return report, YAML, screenshot, observation, or video content and must not mutate the run.
-
-Existing-run Progress retrieval must accept only a non-empty direct-child run id, read only `events.jsonl` under that validated run directory, preserve valid event dictionaries and file order, and assign monotonically increasing display sequences only when a sequence is missing, non-integer, or non-positive. Invalid JSON and non-object lines are skipped. A missing event log returns `200` with the run id and an empty `events` list; unsafe or missing run ids return structured errors. The endpoint must not synthesize historical tool calls from reports, evidence manifests, or recording metadata.
-
-Step artifact endpoints are read-only and must read only under the resolved run directory. They must return concise structured errors for unsafe paths, invalid step identifiers, and unsupported artifact content. Event `artifact_refs` are authoritative when present; the legacy singular `artifact_path` is a fallback only and must not add a duplicate screenshot with missing phase metadata when the same path already exists in `artifact_refs`. A text artifact exceeding the display size limit must return an error on that artifact without suppressing other step artifacts such as screenshots. Missing files or no matching artifacts must not imply run failure.
-
-## Verification Scope
-
-- Verification covers playground state/session behavior, runtime info, dynamic and strict execution adapters, strict lifecycle execution, Input YAML lifecycle display/save behavior, progress delivery, cancellation, report lookup, recorded YAML display, Goal recording publication, existing-run loading, replay/video endpoints, and step-artifact preview.
-- Boundary verification ensures the server accepts an already resolved explicit workspace/platform context; all case/lifecycle paths remain in that platform's cases root; all run and artifact endpoints remain in that platform's run root and stay read-only where specified; YAML lifecycle saves are atomic and revision-checked; unsafe paths are rejected; secret redaction is preserved; and dynamic raw YAML display remains separate from strict YAML execution.
-- Frontend integration verification ensures Python static serving resolves the generated assets, missing generated output fails with the documented build instruction, API/SSE/binary/range contracts remain consumable by the browser application, and a built wheel runs the Playground without Node.js. Frontend source and build verification are owned by `frontend/SPEC.md` and `frontend/playground/SPEC.md`.
-
-## Current Invariants
-
-### Execution and Ownership
-
-- Goal, YAML, and Strict YAML preserve the corresponding CLI execution semantics: dynamic goal task construction, non-strict raw UTF-8 YAML reference material, and registry-backed deterministic strict execution with core evidence reporting.
-- Playground delegates complete run ordering, lifecycle, and recording policy to public Execution services and retains only transport/session adaptation.
-- Each `/execute` captures the latest complete Provider snapshot while preserving startup workspace/platform/config/session/path policy. Active tasks never change Provider in place, and Playground never infers or switches platform.
-- Capability declaration and discovery remain bootstrap concerns. Playground consumes validated registry metadata, public execution APIs, and normalized results rather than decorator internals or platform action catalogs.
-- Completed dynamic runs use post-run recording with `allow_failure=True`; validated Goal recordings and drafts atomically publish a run-id-named copy to the selected platform cases directory. Recording or publication failure does not change execution status, and publication failure does not change a valid recording status.
-- Authored browser source and npm dependencies are owned by `frontend/SPEC.md` and `frontend/playground/SPEC.md`. The Python package owns production serving of generated assets; generated bundles are package data rather than authored or tracked source.
diff --git a/fsq_agent/playground/__init__.py b/fsq_agent/playground/__init__.py
deleted file mode 100644
index 8591ab1a..00000000
--- a/fsq_agent/playground/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from fsq_agent.adapters.control_plane.playground import PlaygroundServer, PlaygroundServerOptions, run_playground
-
-__all__ = ["PlaygroundServer", "PlaygroundServerOptions", "run_playground"]
diff --git a/pyproject.toml b/pyproject.toml
index bec2dd84..98161a16 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
  
 [project]
 name = "fsq-agent"
-version = "0.1.0a2"
+version = "0.1.0a3"
 description = "Goal-driven FSQ automated testing agent built around OpenAI Agents SDK, Azure OpenAI, harness actions, local utilities, observation, and reporting."
 readme = "README.md"
 license = "MIT"
@@ -62,7 +62,6 @@ fsq-agent = "fsq_agent.adapters.cli:main"
 packages = ["fsq_agent"]
 artifacts = [
     "fsq_agent/adapters/control_plane/static/**",
-    "fsq_agent/adapters/control_plane/playground/static/**",
     "fsq_agent/resources/**",
 ]
 
@@ -104,7 +103,6 @@ artifacts = [
     "knowledge/skills/**",
     "fsq_agent/resources/**",
     "fsq_agent/adapters/control_plane/static/**",
-    "fsq_agent/adapters/control_plane/playground/static/**",
 ]
 
 [tool.pytest.ini_options]
diff --git a/scripts/distribute-frontend-build.mjs b/scripts/distribute-frontend-build.mjs
index cc521a93..b05310bf 100644
--- a/scripts/distribute-frontend-build.mjs
+++ b/scripts/distribute-frontend-build.mjs
@@ -3,10 +3,7 @@ import { basename, dirname, resolve } from 'node:path';
 
 const root = resolve(import.meta.dirname, '..');
 const staging = resolve(root, '.frontend-dist');
-const entries = [
-  { name: 'playground', target: resolve(root, 'fsq_agent/adapters/control_plane/playground/static') },
-  { name: 'control-plane', target: resolve(root, 'fsq_agent/adapters/control_plane/static') },
-];
+const entries = [{ name: 'control-plane', target: resolve(root, 'fsq_agent/adapters/control_plane/static') }];
 
 const manifest = JSON.parse(await readFile(resolve(staging, '.vite/manifest.json'), 'utf8'));
 
diff --git a/tests/test_adapter_compatibility.py b/tests/test_adapter_compatibility.py
index 916d6fb8..73eed257 100644
--- a/tests/test_adapter_compatibility.py
+++ b/tests/test_adapter_compatibility.py
@@ -2,6 +2,7 @@
 # Licensed under the MIT License.
 
 import importlib
+from importlib.util import find_spec
 
 
 def test_cli_compatibility_paths_share_canonical_module_objects() -> None:
@@ -16,7 +17,6 @@ def test_control_plane_compatibility_paths_share_canonical_module_objects() -> N
     assert legacy.ControlPlaneServer is canonical.ControlPlaneServer
 
 
-def test_playground_compatibility_paths_share_canonical_module_objects() -> None:
-    legacy = importlib.import_module("fsq_agent.playground")
-    canonical = importlib.import_module("fsq_agent.adapters.control_plane.playground")
-    assert legacy.PlaygroundServer is canonical.PlaygroundServer
+def test_legacy_playground_packages_are_absent() -> None:
+    assert find_spec("fsq_agent.playground") is None
+    assert find_spec("fsq_agent.adapters.control_plane.playground") is None
diff --git a/tests/test_capabilities.py b/tests/test_capabilities.py
index 2ba6e9ff..0d2e1086 100644
--- a/tests/test_capabilities.py
+++ b/tests/test_capabilities.py
@@ -357,7 +357,6 @@ def test_capabilities_imports_only_models_across_project_modules() -> None:
         "fsq_agent.fsq",
         "fsq_agent.knowledge",
         "fsq_agent.observation",
-        "fsq_agent.playground",
         "fsq_agent.providers",
         "fsq_agent.report",
         "fsq_agent.skills",
diff --git a/tests/test_distribution_contract.py b/tests/test_distribution_contract.py
index ab9952f0..25bc9622 100644
--- a/tests/test_distribution_contract.py
+++ b/tests/test_distribution_contract.py
@@ -144,18 +144,18 @@ def test_release_workflow_is_manual_safe_and_uses_oidc_trusted_publishing() -> N
     assert "password:" not in raw
 
 
-def test_distribution_includes_both_frontend_asset_trees() -> None:
+def test_distribution_includes_only_control_plane_frontend_assets() -> None:
     project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
-    expected = {
-        "fsq_agent/adapters/control_plane/static",
-        "fsq_agent/adapters/control_plane/playground/static",
-    }
+    expected = "fsq_agent/adapters/control_plane/static/**"
+    retired = "fsq_agent/adapters/control_plane/playground/static/**"
 
     wheel = project["tool"]["hatch"]["build"]["targets"]["wheel"]
-    assert set(wheel["artifacts"]) == {*(f"{path}/**" for path in expected), "fsq_agent/resources/**"}
+    assert set(wheel["artifacts"]) == {expected, "fsq_agent/resources/**"}
+    assert retired not in wheel["artifacts"]
     assert "force-include" not in wheel
     sdist = project["tool"]["hatch"]["build"]["targets"]["sdist"]
-    assert {*(f"{path}/**" for path in expected)} <= set(sdist["artifacts"])
+    assert expected in sdist["artifacts"]
+    assert retired not in sdist["artifacts"]
     assert "force-include" not in sdist
 
 
@@ -170,7 +170,6 @@ def test_sdist_maps_runtime_resources_to_package_paths() -> None:
         "knowledge/skills/**",
         "fsq_agent/resources/**",
         "fsq_agent/adapters/control_plane/static/**",
-        "fsq_agent/adapters/control_plane/playground/static/**",
     }
 
 
diff --git a/tests/test_playground.py b/tests/test_playground.py
deleted file mode 100644
index db7e08f9..00000000
--- a/tests/test_playground.py
+++ /dev/null
@@ -1,4125 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-import asyncio
-import base64
-import json
-import os
-import re
-import shutil
-import subprocess
-from pathlib import Path
-from urllib.error import HTTPError
-from urllib.parse import urlparse
-from urllib.request import Request, urlopen
-
-import pytest
-import yaml
-
-from fsq_agent.adapters.control_plane.playground._android import AndroidTarget, discover_adb_targets, resolve_auto_session
-from fsq_agent.adapters.control_plane.playground._execution import PlaygroundExecutionHandle, _event_sink, _PlaygroundEvidenceRecorder, _run_dynamic_task, task_from_case_yaml, task_from_goal
-from fsq_agent.adapters.control_plane.playground._server import STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES, YAML_DISPLAY_SIZE_LIMIT_BYTES, PlaygroundServer, PlaygroundServerOptions
-from fsq_agent.adapters.control_plane.playground._state import BusyError, PlaygroundState
-from fsq_agent.case_dsl import FsqCaseLoader, FsqExecutableStepAdapter
-from fsq_agent.config import Settings, save_azure_openai_provider
-from fsq_agent.execution import RecordingResult
-from fsq_agent.models import (
-    AndroidDevice,
-    AndroidDeviceDiscoveryResult,
-    ConfigurationError,
-    HarnessActionResult,
-    HarnessArtifactRef,
-    HarnessContext,
-    ReportArtifact,
-    RunEvent,
-    RunnerEvent,
-    TaskResult,
-    VerificationResult,
-)
-
-
-def _require_loopback(url: str) -> None:
-    parsed = urlparse(url)
-    if parsed.scheme != "http" or parsed.hostname not in {"127.0.0.1", "localhost"}:
-        raise ValueError("Test HTTP requests must target an in-process loopback server")
-
-
-def _open_loopback(request: str | Request):
-    url = request.full_url if isinstance(request, Request) else request
-    _require_loopback(url)
-    # The URL is restricted above to an HTTP loopback host owned by the test.
-    return urlopen(request, timeout=5)  # noqa: S310
-
-
-def _loopback_json_put_request(url: str, payload: dict[str, object]) -> Request:
-    _require_loopback(url)
-    # The URL is restricted above to an HTTP loopback host owned by the test.
-    return Request(  # noqa: S310
-        url,
-        method="PUT",
-        headers={"Content-Type": "application/json"},
-        data=json.dumps(payload).encode("utf-8"),
-    )
-
-
-def _preview_token(run_id: str, step_id: str) -> str:
-    return f"{run_id}:{step_id}"
-
-
-def test_android_discovery_projects_default_online_device(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.AndroidDeviceDiscovery.discover",
-        lambda _self, **_kwargs: AndroidDeviceDiscoveryResult(
-            devices=[
-                AndroidDevice(
-                    serial="emulator-5554",
-                    state="device",
-                    metadata={"product": "sdk_gphone64_x86_64", "model": "sdk_gphone64_x86_64", "device": "emu64xa"},
-                ),
-                AndroidDevice(serial="offline-1", state="offline"),
-            ]
-        ),
-    )
-
-    targets, error = discover_adb_targets()
-
-    assert error is None
-    assert len(targets) == 1
-    assert targets[0].id == "emulator-5554"
-    assert targets[0].is_default is True
-    assert "sdk gphone64 x86 64" in targets[0].description
-
-
-def test_android_discovery_has_no_default_when_multiple_devices_are_online(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.AndroidDeviceDiscovery.discover",
-        lambda _self, **_kwargs: AndroidDeviceDiscoveryResult(devices=[AndroidDevice(serial="device-1", state="device"), AndroidDevice(serial="device-2", state="device")]),
-    )
-
-    targets, error = discover_adb_targets()
-
-    assert error is None
-    assert [target.id for target in targets] == ["device-1", "device-2"]
-    assert not any(target.is_default for target in targets)
-
-
-def test_task_from_goal_matches_dynamic_goal_contract() -> None:
-    task = task_from_goal("  Open rewards panel  ")
-
-    assert task.id == "open-rewards-panel"
-    assert task.name == "Open rewards panel"
-    assert task.planning_reference_kind == "goal"
-    assert task.planning_reference_text == "Open rewards panel"
-    assert task.verification_goal is None
-
-
-def test_task_from_case_yaml_preserves_raw_reference(tmp_path: Path) -> None:
-    cases_dir = tmp_path / "cases"
-    cases_dir.mkdir()
-    case_path = cases_dir / "sample.fsq.yaml"
-    content = "schemaVersion: fsq.ai-test/v1\nname: Sample\n---\n- launchApp\n"
-    case_path.write_text(content, encoding="utf-8")
-    settings = Settings()
-    settings.cases.dir = cases_dir
-
-    task = task_from_case_yaml("sample.fsq.yaml", settings)
-
-    assert task.name == "Case reference: sample.fsq.yaml"
-    assert task.planning_reference_kind == "raw_case"
-    assert task.planning_reference_text is not None
-    assert str(case_path.resolve()) in task.planning_reference_text
-    assert content in task.planning_reference_text
-
-
-def test_task_from_case_yaml_rejects_wrong_suffix(tmp_path: Path) -> None:
-    cases_dir = tmp_path / "cases"
-    cases_dir.mkdir()
-    (cases_dir / "sample.yaml").write_text("name: Sample\n", encoding="utf-8")
-    settings = Settings()
-    settings.cases.dir = cases_dir
-
-    with pytest.raises(ConfigurationError, match=r"\.fsq\.yaml"):
-        task_from_case_yaml("sample.yaml", settings)
-
-
-def test_playground_case_inputs_reject_paths_outside_workspace_cases(tmp_path: Path) -> None:
-    cases_dir = tmp_path / "cases"
-    cases_dir.mkdir()
-    outside = tmp_path / "outside.fsq.yaml"
-    outside.write_text("schemaVersion: fsq.ai-test/v1\nname: Outside\n---\n- launchApp\n", encoding="utf-8")
-    settings = Settings()
-    settings.cases.dir = cases_dir
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    with pytest.raises(ConfigurationError, match="workspace cases"):
-        task_from_case_yaml(str(outside), settings)
-    status, payload = server.handle_get("/yaml/input", {"path": [str(outside)]})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "workspace cases" in payload["error"]
-
-
-def test_auto_session_ignores_settings_serial_when_multiple_devices_are_online(monkeypatch) -> None:
-    settings = Settings()
-    settings.harness.android.serial = "device-2"
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.discover_adb_targets",
-        lambda: (
-            [
-                AndroidTarget(id="device-1", label="device-1", is_default=True),
-                AndroidTarget(id="device-2", label="device-2"),
-            ],
-            None,
-        ),
-    )
-
-    session, info = resolve_auto_session(settings)
-
-    assert session is None
-    assert info["reason"] == "multiple_devices"
-    assert "configuredSerial" not in info
-
-
-def test_auto_session_uses_single_online_device(monkeypatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.discover_adb_targets",
-        lambda: ([AndroidTarget(id="device-1", label="device-1", is_default=True)], None),
-    )
-
-    session, info = resolve_auto_session(Settings())
-
-    assert session is not None
-    assert session.device_id == "device-1"
-    assert info["reason"] == "single_device"
-
-
-def test_auto_session_requires_manual_selection_for_multiple_devices(monkeypatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.discover_adb_targets",
-        lambda: (
-            [
-                AndroidTarget(id="device-1", label="device-1", is_default=True),
-                AndroidTarget(id="device-2", label="device-2"),
-            ],
-            None,
-        ),
-    )
-
-    session, info = resolve_auto_session(Settings())
-
-    assert session is None
-    assert info["reason"] == "multiple_devices"
-
-
-def test_auto_session_reports_no_devices(monkeypatch) -> None:
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._android.discover_adb_targets", lambda: ([], None))
-
-    session, info = resolve_auto_session(Settings())
-
-    assert session is None
-    assert info["reason"] == "no_devices"
-
-
-def test_android_runtime_info_omits_configured_serial() -> None:
-    settings = Settings()
-    settings.harness.android.serial = "stale-device"
-    server = PlaygroundServer(settings)
-
-    status, payload = server.handle_get("/runtime-info", {})
-
-    assert status == 200
-    assert "configuredSerial" not in payload["metadata"]
-
-
-def test_playground_state_locks_concurrent_tasks(tmp_path: Path) -> None:
-    state = PlaygroundState()
-    state.create_session("device-1")
-    request_id = state.start_task("Do it")
-
-    with pytest.raises(BusyError, match="already running"):
-        state.start_task("Do something else")
-
-    result = TaskResult(
-        task_id="task",
-        status="success",
-        steps=[],
-        verification=VerificationResult(status="success", summary="ok"),
-        report=ReportArtifact(run_id="run-1", path=tmp_path / "report.md"),
-    )
-    state.add_event(
-        request_id,
-        RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"),
-    )
-    state.finish_task(request_id, result)
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["runId"] == "run-1"
-    assert progress["status"] == "success"
-    assert progress["result"]["runId"] == "run-1"
-    assert state.current_request_id is None
-
-
-def test_playground_server_static_path_rejects_traversal(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    static_dir.mkdir()
-    (static_dir / "index.html").write_text("hello", encoding="utf-8")
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(static_path=static_dir))
-
-    status, body, content_type = server.static_response("/../secret.txt")
-
-    assert status == 200
-    assert body == b"hello"
-    assert content_type.startswith("text/html")
-
-
-def test_playground_server_serves_nested_vite_entry_at_root(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    entry = static_dir / "playground" / "index.html"
-    entry.parent.mkdir(parents=True)
-    entry.write_text("vite playground", encoding="utf-8")
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(static_path=static_dir))
-
-    status, body, content_type = server.static_response("/")
-
-    assert status == 200
-    assert body == b"vite playground"
-    assert content_type.startswith("text/html")
-
-
-def test_playground_server_start_requires_built_frontend(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    static_dir.mkdir()
-    server = PlaygroundServer(
-        Settings(),
-        PlaygroundServerOptions(port=0, static_path=static_dir, open_browser=False),
-    )
-
-    with pytest.raises(FileNotFoundError, match=r"npm ci.*npm run build"):
-        server.start()
-
-
-def test_playground_server_report_endpoint_returns_content(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    report_dir = settings.output.runs_dir / "run-1"
-    report_dir.mkdir(parents=True)
-    (report_dir / "report.md").write_text("# report", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/reports/run-1", {})
-
-    assert status == 200
-    assert payload["runId"] == "run-1"
-    assert payload["content"] == "# report"
-
-
-def test_playground_server_load_run_accepts_id_relative_and_absolute_paths(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "report.md").write_text("# Report", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    for path_value in ("run-1", os.path.join(".", "run-1"), str(run_dir.resolve())):
-        status, payload = server.handle_post("/runs/load", {"path": path_value})
-
-        assert status == 200
-        assert payload == {
-            "available": True,
-            "runId": "run-1",
-            "availability": {
-                "report": True,
-                "recordedYaml": False,
-                "replay": False,
-                "stepArtifacts": False,
-            },
-        }
-
-
-def test_playground_server_load_run_reports_complete_availability(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    replay_dir = run_dir / "playground-replay"
-    replay_dir.mkdir(parents=True)
-    (run_dir / "core-report.md").write_text("# Report", encoding="utf-8")
-    (run_dir / "recording.json").write_text("{}", encoding="utf-8")
-    (run_dir / "evidence-manifest.json").write_text("{}", encoding="utf-8")
-    (replay_dir / "replay.webm").write_bytes(b"video")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_post("/runs/load", {"path": "run-1"})
-
-    assert status == 200
-    assert payload["availability"] == {
-        "report": True,
-        "recordedYaml": True,
-        "replay": True,
-        "stepArtifacts": True,
-    }
-
-
-def test_playground_server_load_run_discovers_replay_from_screenshot_evidence(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps({"artifacts": [{"kind": "screenshot", "path": "artifacts/screenshots/step-1.png"}]}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_post("/runs/load", {"path": "run-1"})
-
-    assert status == 200
-    assert payload["availability"]["replay"] is True
-    assert payload["availability"]["stepArtifacts"] is True
-
-
-def test_playground_server_load_run_rejects_invalid_directories(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.output.runs_dir.mkdir()
-    unrecognized = settings.output.runs_dir / "empty-run"
-    unrecognized.mkdir()
-    nested = settings.output.runs_dir / "group" / "run-1"
-    nested.mkdir(parents=True)
-    (nested / "report.md").write_text("# Report", encoding="utf-8")
-    file_path = settings.output.runs_dir / "report.md"
-    file_path.write_text("# Report", encoding="utf-8")
-    outside = tmp_path / "outside"
-    outside.mkdir()
-    (outside / "report.md").write_text("# Report", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    cases = [
-        ({}, 400),
-        ({"path": ""}, 400),
-        ({"path": str(settings.output.runs_dir)}, 400),
-        ({"path": "empty-run"}, 400),
-        ({"path": "group/run-1"}, 400),
-        ({"path": str(file_path)}, 400),
-        ({"path": "../outside"}, 400),
-        ({"path": str(outside)}, 400),
-        ({"path": "missing-run"}, 404),
-    ]
-    for body, expected_status in cases:
-        status, payload = server.handle_post("/runs/load", body)
-
-        assert status == expected_status
-        assert payload["available"] is False
-        assert payload["error"]
-
-
-def test_playground_server_loaded_run_progress_restores_persisted_events(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    events = [
-        {"type": "run_started", "title": "Run started", "sequence": 7, "payload": {}},
-        {
-            "type": "tool_call_completed",
-            "title": "Clicked",
-            "payload": {"status": "passed", "runner_step_id": "run-1-step-002"},
-        },
-        {"type": "run_completed", "title": "Run completed", "sequence": 0, "payload": {"status": "success"}},
-    ]
-    (run_dir / "events.jsonl").write_text(
-        "\n".join([json.dumps(events[0]), "not-json", "[]", json.dumps(events[1]), json.dumps(events[2])]),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/runs/run-1/progress", {})
-
-    assert status == 200
-    assert payload["runId"] == "run-1"
-    assert [event["title"] for event in payload["events"]] == ["Run started", "Clicked", "Run completed"]
-    assert [event["sequence"] for event in payload["events"]] == [7, 8, 9]
-    assert payload["events"][1]["payload"]["runner_step_id"] == "run-1-step-002"
-
-
-def test_playground_server_loaded_run_progress_returns_empty_without_event_log(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "report.md").write_text("# Report", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/runs/run-1/progress", {})
-
-    assert status == 200
-    assert payload == {"runId": "run-1", "events": []}
-
-
-def test_playground_server_loaded_run_progress_rejects_unsafe_or_missing_run_ids(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.output.runs_dir.mkdir()
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    unsafe_status, unsafe_payload = server.handle_get("/runs/../outside/progress", {})
-    missing_status, missing_payload = server.handle_get("/runs/missing/progress", {})
-
-    assert unsafe_status == 400
-    assert unsafe_payload["error"]
-    assert missing_status == 404
-    assert missing_payload["error"]
-
-
-def test_playground_server_yaml_input_endpoint_returns_content(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "sample.fsq.yaml"
-    case_path.write_text("schemaVersion: fsq.ai-test/v1\nname: Sample\nplatform: android\ndescription: Open sample\ntags: [smoke]\n---\n- launchApp\n", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["sample.fsq.yaml"]})
-
-    assert status == 200
-    assert payload["kind"] == "input"
-    assert payload["path"] == "sample.fsq.yaml"
-    assert payload["resolvedPath"] == str(case_path.resolve())
-    assert payload["sizeBytes"] == case_path.stat().st_size
-    assert "launchApp" in payload["content"]
-    assert payload["display"]["metadata"]["title"] == "Sample"
-    assert payload["display"]["metadata"]["platform"] == "android"
-    assert payload["display"]["metadata"]["tags"] == ["smoke"]
-    assert payload["display"]["metadata"]["fields"] == [
-        {"key": "platform", "label": "Platform", "value": "android"},
-        {"key": "schemaVersion", "label": "Schema", "value": "fsq.ai-test/v1"},
-        {"key": "description", "label": "Description", "value": "Open sample"},
-        {"key": "path", "label": "Path", "value": "sample.fsq.yaml"},
-    ]
-    assert payload["display"]["steps"] == [{"index": 1, "displayIndex": 1, "artifactStepId": None, "action": "launchApp", "kind": "setup", "badges": [], "params": []}]
-
-
-def test_playground_server_yaml_input_rejects_wrong_suffix(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    (settings.cases.dir / "sample.yaml").write_text("name: Sample\n", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["sample.yaml"]})
-
-    assert status == 400
-    assert ".fsq.yaml" in payload["error"]
-
-
-def test_playground_server_yaml_input_endpoint_returns_ordered_lifecycle_and_revision(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "lifecycle.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\n"
-        "name: Lifecycle\n"
-        "platform: android\n"
-        "onCaseStart:\n"
-        "- runShell: echo first\n"
-        "  runCase: hooks/login.fsq.yaml\n"
-        "onCaseComplete:\n"
-        "- runShell: echo complete\n"
-        "---\n"
-        "- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["lifecycle.fsq.yaml"]})
-
-    assert status == 200
-    assert payload["editable"] is True
-    assert payload["revision"].startswith("sha256:")
-    assert payload["display"]["lifecycle"] == {
-        "onCaseStart": [
-            {"index": 1, "action": "runShell", "value": "echo first"},
-            {"index": 2, "action": "runCase", "value": "hooks/login.fsq.yaml"},
-        ],
-        "onCaseComplete": [{"index": 1, "action": "runShell", "value": "echo complete"}],
-    }
-
-
-def test_playground_server_saves_input_lifecycle_and_preserves_commands(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "editable.fsq.yaml"
-    original = (
-        "# case comment\n"
-        "schemaVersion: fsq.ai-test/v1\n"
-        "name: Editable\n"
-        "platform: android\n"
-        "onCaseStart:\n"
-        "- runShell: echo old\n"
-        "onCaseComplete:\n"
-        "- runShell: echo remove\n"
-        "---\n"
-        "# command comment\n"
-        "- launchApp: {}\n"
-        "- tapOn:\n"
-        "    target: Login\n"
-        "    locator:\n"
-        "      text: Login\n"
-    )
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    get_status, loaded = server.handle_get("/yaml/input", {"path": ["editable.fsq.yaml"]})
-    assert get_status == 200
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "editable.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [
-                {
-                    "action": "runCase",
-                    "value": "cases/fsq-testcases/android/bottom_bar/access_downloads_through_overflow_menu.fsq.yaml",
-                },
-                {"action": "runCase", "value": "hooks/second.fsq.yaml"},
-                {
-                    "action": "runShell",
-                    "value": "powershell -ExecutionPolicy Bypass -File .fsq-agent-workspace/scripts/clean_edge_data.ps1",
-                },
-            ],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 200
-    assert payload["revision"] != loaded["revision"]
-    assert payload["display"]["lifecycle"]["onCaseComplete"] == []
-    saved = case_path.read_text(encoding="utf-8")
-    assert "# case comment" in saved
-    assert "# command comment" in saved
-    long_run_case_line = "- runCase: cases/fsq-testcases/android/bottom_bar/access_downloads_through_overflow_menu.fsq.yaml"
-    long_run_shell_line = "- runShell: powershell -ExecutionPolicy Bypass -File .fsq-agent-workspace/scripts/clean_edge_data.ps1"
-    assert long_run_case_line in saved
-    assert "runCase: hooks/second.fsq.yaml" in saved
-    assert long_run_shell_line in saved
-    assert saved.index(long_run_case_line) < saved.index("runCase: hooks/second.fsq.yaml") < saved.index(long_run_shell_line)
-    assert "onCaseComplete" not in saved
-    assert yaml.safe_load_all(saved)
-    assert list(yaml.safe_load_all(saved))[1] == list(yaml.safe_load_all(original))[1]
-
-
-def test_playground_server_lifecycle_save_preserves_leading_separator_quotes_and_hook_order(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "roundtrip.fsq.yaml"
-    case_path.write_text(
-        '---\nschemaVersion: fsq.ai-test/v1\nname: "Quoted case"\nplatform: android\n---\n- launchApp: {}\n',
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["roundtrip.fsq.yaml"]})
-
-    status, _payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "roundtrip.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [
-                {"action": "runShell", "value": "echo first"},
-                {"action": "runShell", "value": "echo second"},
-                {"action": "runCase", "value": "hooks/second.fsq.yaml"},
-            ],
-            "onCaseComplete": [],
-        },
-    )
-
-    saved = case_path.read_text(encoding="utf-8")
-    assert status == 200
-    assert saved.startswith("---\n")
-    assert 'name: "Quoted case"' in saved
-    assert saved.index("schemaVersion:") < saved.index("name:") < saved.index("platform:") < saved.index("onCaseStart:")
-    assert saved.index("echo first") < saved.index("echo second") < saved.index("hooks/second.fsq.yaml")
-
-
-def test_playground_server_lifecycle_save_rejects_invalid_complete_case_without_writing(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "invalid-case.fsq.yaml"
-    original = "name: Missing required metadata\nplatform: android\n---\n- launchApp: {}\n"
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["invalid-case.fsq.yaml"]})
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "invalid-case.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 400
-    assert payload["error"]
-    assert case_path.read_text(encoding="utf-8") == original
-    assert not list(case_path.parent.glob(f".{case_path.name}.*.tmp"))
-
-
-def test_playground_server_lifecycle_save_reports_path_and_size_errors(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    (settings.cases.dir / "folder.fsq.yaml").mkdir()
-    large_path = settings.cases.dir / "large-save.fsq.yaml"
-    large_path.write_text("x" * (YAML_DISPLAY_SIZE_LIMIT_BYTES + 1), encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    body = {"revision": "sha256:none", "onCaseStart": [], "onCaseComplete": []}
-
-    missing_status, _missing_payload = server.handle_put("/yaml/input/lifecycle", {"path": "missing.fsq.yaml", **body})
-    directory_status, _directory_payload = server.handle_put("/yaml/input/lifecycle", {"path": "folder.fsq.yaml", **body})
-    oversized_status, _oversized_payload = server.handle_put("/yaml/input/lifecycle", {"path": "large-save.fsq.yaml", **body})
-
-    assert missing_status == 404
-    assert directory_status == 400
-    assert oversized_status == 413
-
-
-def test_playground_server_lifecycle_atomic_replace_failure_preserves_source(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "replace-failure.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: Replace\nplatform: android\n---\n- launchApp: {}\n"
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["replace-failure.fsq.yaml"]})
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._yaml_lifecycle.os.replace",
-        lambda source, destination: (_ for _ in ()).throw(OSError("replace failed")),
-    )
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "replace-failure.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 500
-    assert "replace failed" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == original
-    assert not list(case_path.parent.glob(f".{case_path.name}.*.tmp"))
-
-
-def test_playground_server_lifecycle_temp_write_failure_returns_500(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "temp-failure.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: Temp\nplatform: android\n---\n- launchApp: {}\n"
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["temp-failure.fsq.yaml"]})
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._yaml_lifecycle.tempfile.NamedTemporaryFile",
-        lambda **kwargs: (_ for _ in ()).throw(OSError("temp create failed")),
-    )
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "temp-failure.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 500
-    assert "temp create failed" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == original
-
-
-def test_playground_server_lifecycle_serialization_failure_returns_400(tmp_path: Path, monkeypatch) -> None:
-    from ruamel.yaml import YAML
-
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "serialize-failure.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: Serialize\nplatform: android\n---\n- launchApp: {}\n"
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["serialize-failure.fsq.yaml"]})
-    real_yaml = YAML(typ="rt")
-
-    class FailingYaml:
-        explicit_start = False
-
-        def load_all(self, text: str):
-            return real_yaml.load_all(text)
-
-        def dump_all(self, documents: object, output: object) -> None:
-            raise ValueError("serialize failed")
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._yaml_lifecycle._round_trip_yaml", FailingYaml)
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "serialize-failure.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 400
-    assert "serialize failed" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == original
-
-
-def test_playground_server_lifecycle_result_size_limit_preserves_source(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "result-large.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: Large result\nplatform: android\n---\n- launchApp: {}\n"
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["result-large.fsq.yaml"]})
-
-    status, _payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "result-large.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "x" * YAML_DISPLAY_SIZE_LIMIT_BYTES}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 413
-    assert case_path.read_text(encoding="utf-8") == original
-
-
-def test_playground_server_lifecycle_save_uses_input_path_resolution_policy(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    relative_case = settings.cases.dir / "relative.fsq.yaml"
-    absolute_case = settings.cases.dir / "absolute.fsq.yaml"
-    content = "schemaVersion: fsq.ai-test/v1\nname: Path\nplatform: android\n---\n- launchApp: {}\n"
-    relative_case.write_text(content, encoding="utf-8")
-    absolute_case.write_text(content, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    for path_text in (relative_case.name, str(absolute_case)):
-        _status, loaded = server.handle_get("/yaml/input", {"path": [path_text]})
-        status, _payload = server.handle_put(
-            "/yaml/input/lifecycle",
-            {
-                "path": path_text,
-                "revision": loaded["revision"],
-                "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-                "onCaseComplete": [],
-            },
-        )
-        assert status == 200
-
-
-def test_playground_server_rejects_stale_lifecycle_revision_without_writing(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "conflict.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Conflict\nplatform: android\n---\n- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["conflict.fsq.yaml"]})
-    externally_changed = case_path.read_text(encoding="utf-8").replace("name: Conflict", "name: Changed")
-    case_path.write_text(externally_changed, encoding="utf-8")
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "conflict.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 409
-    assert "changed on disk" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == externally_changed
-
-
-def test_playground_server_detects_source_change_during_lifecycle_validation(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "validation-race.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: Race\nplatform: android\n---\n- launchApp: {}\n"
-    external = original.replace("name: Race", "name: External")
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["validation-race.fsq.yaml"]})
-    real_load_case = FsqCaseLoader.load_case
-
-    def change_source_during_validation(loader: FsqCaseLoader, path: Path):
-        result = real_load_case(loader, path)
-        case_path.write_text(external, encoding="utf-8")
-        return result
-
-    monkeypatch.setattr(FsqCaseLoader, "load_case", change_source_during_validation)
-
-    status, payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "validation-race.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert status == 409
-    assert "changed on disk" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == external
-    assert not list(case_path.parent.glob(f".{case_path.name}.*.tmp"))
-
-
-def test_playground_server_rejects_invalid_or_busy_lifecycle_save(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "invalid.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Invalid\nplatform: android\n---\n- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    _status, loaded = server.handle_get("/yaml/input", {"path": ["invalid.fsq.yaml"]})
-    original = case_path.read_text(encoding="utf-8")
-
-    invalid_status, invalid_payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "invalid.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [{"action": "runShell", "value": ""}],
-            "onCaseComplete": [],
-        },
-    )
-    server.state.start_task("busy")
-    busy_status, busy_payload = server.handle_put(
-        "/yaml/input/lifecycle",
-        {
-            "path": "invalid.fsq.yaml",
-            "revision": loaded["revision"],
-            "onCaseStart": [],
-            "onCaseComplete": [],
-        },
-    )
-
-    assert invalid_status == 400
-    assert invalid_payload["error"]
-    assert busy_status == 409
-    assert "task is running" in busy_payload["error"]
-    assert case_path.read_text(encoding="utf-8") == original
-
-
-def test_playground_server_yaml_input_endpoint_reports_missing_file(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["missing.fsq.yaml"]})
-
-    assert status == 404
-    assert payload["available"] is False
-    assert "Case YAML not found" in payload["error"]
-
-
-def test_playground_server_yaml_input_endpoint_reports_directory(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    (settings.cases.dir / "folder.fsq.yaml").mkdir(parents=True)
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["folder.fsq.yaml"]})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "directory" in payload["error"]
-
-
-def test_playground_server_yaml_input_endpoint_limits_display_size(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "large.fsq.yaml"
-    case_path.write_text("x" * (YAML_DISPLAY_SIZE_LIMIT_BYTES + 1), encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["large.fsq.yaml"]})
-
-    assert status == 413
-    assert payload["available"] is False
-    assert payload["limitBytes"] == YAML_DISPLAY_SIZE_LIMIT_BYTES
-
-
-def test_playground_server_yaml_input_endpoint_reports_display_parse_errors(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "broken.fsq.yaml"
-    case_path.write_text("schemaVersion: [\n", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/input", {"path": ["broken.fsq.yaml"]})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert payload["error"]
-
-
-def test_playground_server_recorded_yaml_endpoint_returns_content(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    recorded_path = run_dir / "recorded.fsq.yaml"
-    recorded_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Recorded\nplatform: android\n---\n- inputText:\n    text: TEST_PASSWORD\n    textType: runtimeSecret\n    target: Password\n    locator:\n      resourceId: com.example:id/password\n      text: null\n",
-        encoding="utf-8",
-    )
-    (run_dir / "recording.json").write_text(
-        json.dumps(
-            {
-                "status": "recorded",
-                "recorded_case_path": str(recorded_path),
-                "command_count": 1,
-                "validation_status": "passed",
-                "draft": False,
-                "required_runtime_secret_names": [],
-                "warnings": [],
-                "skipped_tool_calls": [],
-                "errors": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Recorded")
-    server.state.bind_run_id(request_id, "run-1")
-
-    status, payload = server.handle_get(f"/yaml/recorded/{request_id}", {})
-
-    assert status == 200
-    assert payload["kind"] == "recorded"
-    assert payload["runId"] == "run-1"
-    assert payload["status"] == "recorded"
-    assert payload["validationStatus"] == "passed"
-    assert payload["commandCount"] == 1
-    assert payload["recordedCasePath"] == str(recorded_path)
-    assert "inputText" in payload["content"]
-    assert payload["display"]["metadata"]["title"] == "Recorded"
-    assert {field["key"]: field["value"] for field in payload["display"]["metadata"]["fields"]}["path"] == str(recorded_path)
-    assert payload["display"]["steps"][0]["action"] == "inputText"
-    assert payload["display"]["steps"][0]["params"] == [
-        {"key": "text", "value": "TEST_PASSWORD", "kind": "scalar"},
-        {"key": "textType", "value": "runtimeSecret", "kind": "scalar"},
-        {"key": "target", "value": "Password", "kind": "scalar"},
-        {
-            "key": "locator",
-            "value": "",
-            "kind": "object",
-            "fields": [
-                {"key": "resourceId", "value": "com.example:id/password", "kind": "scalar"},
-                {"key": "text", "value": "null", "kind": "null"},
-            ],
-        },
-    ]
-
-
-def _recorded_run_with_events(tmp_path: Path, *, events: list[dict], commands: str | None = None) -> Settings:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    recorded_path = run_dir / "recorded.fsq.yaml"
-    recorded_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Recorded\nplatform: android\n---\n" + (commands or "- launchApp:\n    appId: com.example\n- clickOn:\n    target: Login\n"),
-        encoding="utf-8",
-    )
-    (run_dir / "recording.json").write_text(
-        json.dumps(
-            {
-                "status": "recorded",
-                "recorded_case_path": str(recorded_path),
-                "command_count": 2,
-                "validation_status": "passed",
-                "draft": False,
-                "required_runtime_secret_names": [],
-                "warnings": [],
-                "skipped_tool_calls": [],
-                "errors": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-    if events:
-        (run_dir / "events.jsonl").write_text("\n".join(json.dumps(event) for event in events), encoding="utf-8")
-    return settings
-
-
-def _recorded_command_event(*, tool_name: str, alias: str, step_id: str, step_kind: str) -> dict:
-    return {
-        "type": "tool_call_completed",
-        "timestamp": "2026-07-07T00:00:01+00:00",
-        "tool_name": tool_name,
-        "payload": {
-            "tool_origin": "platform",
-            "status": "passed",
-            "step_kind": step_kind,
-            "replay": {"kind": "fsq_command", "alias": alias},
-            "runner_step_id": step_id,
-            "artifact_refs": [],
-        },
-    }
-
-
-def test_playground_server_recorded_yaml_steps_expose_display_and_artifact_step_ids(tmp_path: Path) -> None:
-    events = [
-        _recorded_command_event(tool_name="launch_app", alias="launchApp", step_id="agent-launch_app-1", step_kind="action"),
-        _recorded_command_event(tool_name="ui_snapshot", alias="uiTree", step_id="agent-ui_snapshot-2", step_kind="observation"),
-        _recorded_command_event(tool_name="click_on", alias="clickOn", step_id="agent-click_on-3", step_kind="action"),
-    ]
-    settings = _recorded_run_with_events(tmp_path, events=events)
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    steps = payload["display"]["steps"]
-    assert [step["displayIndex"] for step in steps] == [1, 2]
-    assert [step["artifactStepId"] for step in steps] == ["agent-launch_app-1", "agent-click_on-3"]
-
-
-def test_playground_server_recorded_yaml_steps_artifact_step_id_null_without_events(tmp_path: Path) -> None:
-    settings = _recorded_run_with_events(tmp_path, events=[])
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    steps = payload["display"]["steps"]
-    assert [step["displayIndex"] for step in steps] == [1, 2]
-    assert [step["artifactStepId"] for step in steps] == [None, None]
-
-
-def test_playground_server_recorded_yaml_steps_keep_partial_alias_matches(tmp_path: Path) -> None:
-    events = [
-        _recorded_command_event(tool_name="launch_app", alias="launchApp", step_id="agent-launch_app-1", step_kind="action"),
-    ]
-    settings = _recorded_run_with_events(tmp_path, events=events)
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    steps = payload["display"]["steps"]
-    assert [step["artifactStepId"] for step in steps] == ["agent-launch_app-1", None]
-
-
-def test_playground_server_recorded_yaml_steps_keep_matches_after_unmatched_middle_step(tmp_path: Path) -> None:
-    events = [
-        _recorded_command_event(tool_name="launch_app", alias="launchApp", step_id="agent-launch_app-1", step_kind="setup"),
-        _recorded_command_event(tool_name="assert_visible", alias="assertVisible", step_id="agent-assert_visible-3", step_kind="assertion"),
-    ]
-    settings = _recorded_run_with_events(
-        tmp_path,
-        events=events,
-        commands="- launchApp:\n    appId: com.example\n- clickOn:\n    target: Login\n- assertVisible:\n    target: Login\n",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    steps = payload["display"]["steps"]
-    assert [step["artifactStepId"] for step in steps] == [
-        "agent-launch_app-1",
-        None,
-        "agent-assert_visible-3",
-    ]
-
-
-def test_playground_server_recorded_yaml_steps_align_historical_observation_commands(tmp_path: Path) -> None:
-    events = [
-        _recorded_command_event(tool_name="launch_app", alias="launchApp", step_id="agent-launch_app-1", step_kind="setup"),
-        _recorded_command_event(tool_name="ui_snapshot", alias="uiTree", step_id="agent-ui_snapshot-2", step_kind="observation"),
-        _recorded_command_event(tool_name="assert_visible", alias="assertVisible", step_id="agent-assert_visible-3", step_kind="assertion"),
-    ]
-    settings = _recorded_run_with_events(
-        tmp_path,
-        events=events,
-        commands="- launchApp:\n    appId: com.example\n- uiTree\n- assertVisible:\n    target: Login\n",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    steps = payload["display"]["steps"]
-    assert [step["artifactStepId"] for step in steps] == [
-        "agent-launch_app-1",
-        "agent-ui_snapshot-2",
-        "agent-assert_visible-3",
-    ]
-
-
-def test_playground_server_recorded_yaml_endpoint_returns_skipped_metadata(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "recording.json").write_text(
-        json.dumps(
-            {
-                "status": "skipped",
-                "recorded_case_path": None,
-                "command_count": 0,
-                "validation_status": "not_run",
-                "draft": True,
-                "warnings": ["No replayable commands found."],
-                "skipped_tool_calls": [{"tool": "helper"}],
-                "errors": [],
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    assert payload["status"] == "skipped"
-    assert payload["draft"] is True
-    assert payload["content"] is None
-    assert payload["warnings"] == ["No replayable commands found."]
-    assert payload["skippedToolCalls"] == [{"tool": "helper"}]
-
-
-def test_playground_server_recorded_yaml_endpoint_returns_failed_metadata(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "recording.json").write_text(
-        json.dumps(
-            {
-                "status": "failed",
-                "recorded_case_path": None,
-                "command_count": 0,
-                "validation_status": "failed",
-                "draft": False,
-                "warnings": [],
-                "errors": ["validation failed"],
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 200
-    assert payload["status"] == "failed"
-    assert payload["validationStatus"] == "failed"
-    assert payload["content"] is None
-    assert payload["errors"] == ["validation failed"]
-
-
-def test_playground_server_recorded_yaml_endpoint_reports_missing_run(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/missing-run", {})
-
-    assert status == 404
-    assert payload["available"] is False
-    assert payload["runId"] == "missing-run"
-
-
-def test_playground_server_recorded_yaml_endpoint_reports_missing_metadata(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "recorded.fsq.yaml").write_text("schemaVersion: fsq.ai-test/v1\n", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 404
-    assert payload["available"] is False
-    assert "Recording metadata not found" in payload["error"]
-
-
-def test_playground_server_recorded_yaml_endpoint_reports_invalid_metadata(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "recording.json").write_text("[]", encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "JSON object" in payload["error"]
-
-
-def test_playground_server_recorded_yaml_endpoint_reports_non_utf8_case(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    recorded_path = run_dir / "recorded.fsq.yaml"
-    recorded_path.write_bytes(b"\xff")
-    (run_dir / "recording.json").write_text(
-        json.dumps({"status": "recorded", "recorded_case_path": str(recorded_path)}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "UTF-8" in payload["error"]
-
-
-def test_playground_server_recorded_yaml_endpoint_rejects_escaped_case_path(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "recording.json").write_text(
-        json.dumps({"status": "recorded", "recorded_case_path": "../outside.fsq.yaml"}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "outside" in payload["error"]
-
-
-def test_playground_server_recorded_yaml_endpoint_rejects_noncanonical_contained_case_path(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    alternate_path = run_dir / "alternate.fsq.yaml"
-    alternate_path.write_text("schemaVersion: fsq.ai-test/v1\n", encoding="utf-8")
-    (run_dir / "recording.json").write_text(
-        json.dumps({"status": "recorded", "recorded_case_path": str(alternate_path)}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/yaml/recorded/run-1", {})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "recorded.fsq.yaml" in payload["error"]
-
-
-def test_playground_server_step_artifacts_endpoint_returns_manifest_artifacts(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    screenshot_dir = run_dir / "artifacts" / "screenshots"
-    tree_dir = run_dir / "artifacts" / "ui-trees"
-    screenshot_dir.mkdir(parents=True)
-    tree_dir.mkdir(parents=True)
-    (screenshot_dir / "run-1-step-001-prepare-before-action.png").write_bytes(b"before")
-    (screenshot_dir / "run-1-step-001-finalize-after-action.png").write_bytes(b"after")
-    (tree_dir / "run-1-step-001-finalize-after-action.json").write_text(
-        json.dumps({"xml": '<hierarchy><node text="Login" /></hierarchy>'}),
-        encoding="utf-8",
-    )
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps(
-            {
-                "events": [
-                    {
-                        "event_type": "artifact_captured",
-                        "timestamp": "2026-07-07T00:00:01+00:00",
-                        "payload": {
-                            "kind": "screenshot",
-                            "path": "artifacts/screenshots/run-1-step-001-prepare-before-action.png",
-                            "reason": "before-action",
-                            "phase": "prepare",
-                        },
-                    },
-                    {
-                        "event_type": "artifact_captured",
-                        "timestamp": "2026-07-07T00:00:02+00:00",
-                        "payload": {
-                            "kind": "screenshot",
-                            "path": "artifacts/screenshots/run-1-step-001-finalize-after-action.png",
-                            "reason": "after-action",
-                            "phase": "finalize",
-                        },
-                    },
-                    {
-                        "event_type": "artifact_captured",
-                        "timestamp": "2026-07-07T00:00:03+00:00",
-                        "payload": {
-                            "kind": "ui_tree",
-                            "path": "artifacts/ui-trees/run-1-step-001-finalize-after-action.json",
-                            "reason": "after-action",
-                            "phase": "finalize",
-                        },
-                    },
-                ],
-                "artifacts": [
-                    {
-                        "kind": "screenshot",
-                        "step_id": "run-1-step-001",
-                        "path": "artifacts/screenshots/run-1-step-001-prepare-before-action.png",
-                    },
-                    {
-                        "kind": "screenshot",
-                        "step_id": "run-1-step-001",
-                        "path": "artifacts/screenshots/run-1-step-001-finalize-after-action.png",
-                    },
-                    {
-                        "kind": "ui_tree",
-                        "step_id": "run-1-step-001",
-                        "path": "artifacts/ui-trees/run-1-step-001-finalize-after-action.json",
-                        "mime_type": "application/json",
-                    },
-                ],
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/1", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    assert payload["runId"] == "run-1"
-    assert payload["stepIndex"] == 1
-    assert [artifact["kind"] for artifact in payload["artifacts"]] == ["screenshot", "screenshot", "ui_tree"]
-    assert [artifact["reason"] for artifact in payload["artifacts"]] == ["before-action", "after-action", "after-action"]
-    assert payload["artifacts"][0]["contentBase64"] == base64.b64encode(b"before").decode("ascii")
-    assert payload["artifacts"][1]["contentBase64"] == base64.b64encode(b"after").decode("ascii")
-    assert payload["artifacts"][2]["mimeType"] == "application/xml"
-    assert payload["artifacts"][2]["content"] == '<hierarchy>\n  <node text="Login" />\n</hierarchy>'
-
-
-def test_playground_server_step_artifacts_endpoint_returns_no_artifacts(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "evidence-manifest.json").write_text(json.dumps({"artifacts": []}), encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/1", {})
-
-    assert status == 200
-    assert payload["available"] is False
-    assert payload["artifacts"] == []
-    assert "No artifacts" in payload["message"]
-
-
-def test_playground_server_step_artifacts_endpoint_ignores_duplicate_legacy_artifact_path(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    screenshot_path = "artifacts/screenshots/agent-click-1-prepare-before-action.png"
-    screenshot_file = run_dir / screenshot_path
-    screenshot_file.parent.mkdir(parents=True)
-    screenshot_file.write_bytes(b"before")
-    event = {
-        "type": "tool_call_completed",
-        "timestamp": "2026-07-21T00:00:01+00:00",
-        "tool_name": "click_on",
-        "payload": {
-            "runner_step_id": "agent-click-1",
-            "artifact_path": screenshot_path,
-            "artifact_refs": [
-                {
-                    "kind": "screenshot",
-                    "path": screenshot_path,
-                    "step_id": "agent-click-1",
-                    "phase": "prepare",
-                }
-            ],
-        },
-    }
-    (run_dir / "events.jsonl").write_text(json.dumps(event), encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/agent-click-1", {})
-
-    assert status == 200
-    assert len(payload["artifacts"]) == 1
-    assert payload["artifacts"][0]["path"] == screenshot_path
-    assert payload["artifacts"][0]["phase"] == "prepare"
-
-
-def test_playground_server_step_artifacts_endpoint_resolves_by_artifact_step_id(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    events = [
-        {
-            "type": "tool_call_completed",
-            "timestamp": "2026-07-07T00:00:01+00:00",
-            "tool_name": "launch_app",
-            "payload": {
-                "tool_origin": "platform",
-                "status": "passed",
-                "replay": {"kind": "fsq_command", "alias": "launchApp"},
-                "runner_step_id": "agent-launch_app-1",
-                "artifact_refs": [],
-            },
-        },
-        {
-            "type": "tool_call_completed",
-            "timestamp": "2026-07-07T00:00:02+00:00",
-            "tool_name": "ui_tree",
-            "payload": {
-                "tool_origin": "platform",
-                "status": "passed",
-                "fsq_action_name": "uiTree",
-                "replay": {"kind": "fsq_command", "alias": "uiTree"},
-                "runner_step_id": "agent-ui_tree-2",
-                "runner_result": {
-                    "step_id": "agent-ui_tree-2",
-                    "phase_reports": [
-                        {
-                            "phase": "invoke",
-                            "metadata": {"harness_output": {"xml": '<hierarchy><node text="Recorded" /></hierarchy>'}},
-                        }
-                    ],
-                },
-                "artifact_refs": [],
-            },
-        },
-    ]
-    (run_dir / "events.jsonl").write_text("\n".join(json.dumps(event) for event in events), encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/agent-ui_tree-2", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    assert len(payload["artifacts"]) == 1
-    artifact = payload["artifacts"][0]
-    assert artifact["kind"] == "ui_tree"
-    assert artifact["path"] == ""
-    assert artifact["phase"] == "invoke"
-    assert artifact["reason"] == "output"
-    assert isinstance(artifact["timestamp"], int)
-    assert artifact["mimeType"] == "application/xml"
-    assert artifact["content"] == '<hierarchy>\n  <node text="Recorded" />\n</hierarchy>'
-
-
-def test_playground_server_step_artifacts_extracts_xml_from_ui_snapshot(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    snapshot_path = run_dir / "artifacts" / "ui-snapshots" / "before.json"
-    snapshot_path.parent.mkdir(parents=True)
-    snapshot_path.write_text(
-        json.dumps({"xml": '<hierarchy><node text="Before" /></hierarchy>'}),
-        encoding="utf-8",
-    )
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps(
-            {
-                "artifacts": [
-                    {
-                        "kind": "ui_snapshot",
-                        "step_id": "agent-click-1",
-                        "path": "artifacts/ui-snapshots/before.json",
-                        "phase": "prepare",
-                        "reason": "before-action",
-                    }
-                ]
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/agent-click-1", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    artifact = payload["artifacts"][0]
-    assert artifact["kind"] == "ui_snapshot"
-    assert artifact["mimeType"] == "application/xml"
-    assert artifact["content"] == '<hierarchy>\n  <node text="Before" />\n</hierarchy>'
-
-
-def test_playground_server_step_artifacts_does_not_expand_xml_entities(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    snapshot_path = run_dir / "artifacts" / "ui-snapshots" / "before.json"
-    snapshot_path.parent.mkdir(parents=True)
-    xml = '<!DOCTYPE hierarchy [<!ENTITY injected "expanded">]><hierarchy><node text="&injected;" /></hierarchy>'
-    snapshot_path.write_text(json.dumps({"xml": xml}), encoding="utf-8")
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps(
-            {
-                "artifacts": [
-                    {
-                        "kind": "ui_snapshot",
-                        "step_id": "agent-click-1",
-                        "path": "artifacts/ui-snapshots/before.json",
-                        "phase": "prepare",
-                        "reason": "before-action",
-                    }
-                ]
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/agent-click-1", {})
-
-    assert status == 200
-    artifact = payload["artifacts"][0]
-    assert artifact["mimeType"] == "application/xml"
-    assert artifact["content"] == xml
-    assert "expanded" in artifact["content"]
-
-
-def test_playground_server_step_artifacts_endpoint_reports_missing_run(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/missing-run/1", {})
-
-    assert status == 404
-    assert payload["available"] is False
-    assert payload["runId"] == "missing-run"
-
-
-def test_playground_server_step_artifacts_endpoint_rejects_escaped_artifact_path(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps({"artifacts": [{"kind": "screenshot", "step_id": "run-1-step-001", "path": "../outside.png"}]}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/1", {})
-
-    assert status == 400
-    assert payload["available"] is False
-    assert "outside" in payload["error"]
-
-
-def test_playground_server_step_artifacts_endpoint_skips_missing_files(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    run_dir.mkdir(parents=True)
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps({"artifacts": [{"kind": "screenshot", "step_id": "run-1-step-001", "path": "artifacts/screenshots/missing.png"}]}),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/1", {})
-
-    assert status == 200
-    assert payload["available"] is False
-    assert payload["artifacts"] == []
-
-
-def test_playground_server_step_artifacts_endpoint_limits_text_size(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    screenshot_dir = run_dir / "artifacts" / "screenshots"
-    tree_dir = run_dir / "artifacts" / "ui-trees"
-    screenshot_dir.mkdir(parents=True)
-    tree_dir.mkdir(parents=True)
-    (screenshot_dir / "before.png").write_bytes(b"before")
-    (tree_dir / "too-large.json").write_text("x" * (STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES + 1), encoding="utf-8")
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps(
-            {
-                "artifacts": [
-                    {
-                        "kind": "screenshot",
-                        "step_id": "run-1-step-001",
-                        "path": "artifacts/screenshots/before.png",
-                        "reason": "before-action",
-                    },
-                    {
-                        "kind": "ui_tree",
-                        "step_id": "run-1-step-001",
-                        "path": "artifacts/ui-trees/too-large.json",
-                        "reason": "before-action",
-                    },
-                ]
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/step-artifacts/run-1/1", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    assert [artifact["kind"] for artifact in payload["artifacts"]] == ["screenshot", "ui_tree"]
-    assert payload["artifacts"][0]["contentBase64"] == base64.b64encode(b"before").decode("ascii")
-    assert "content" not in payload["artifacts"][1]
-    assert "too large" in payload["artifacts"][1]["error"]
-    assert payload["artifacts"][1]["limitBytes"] == STEP_ARTIFACT_TEXT_SIZE_LIMIT_BYTES
-
-
-def test_playground_server_task_progress_filters_events_after_sequence(tmp_path: Path) -> None:
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Incremental progress")
-    for sequence in range(1, 4):
-        server.state.add_event(
-            request_id,
-            RunEvent(
-                run_id="run-1",
-                task_id="task",
-                type="planning_update",
-                title=f"Event {sequence}",
-                sequence=sequence,
-            ),
-        )
-    result = TaskResult(
-        task_id="task",
-        status="success",
-        steps=[],
-        verification=VerificationResult(status="success", summary="ok"),
-        report=ReportArtifact(run_id="run-1", path=tmp_path / "report.md"),
-    )
-    server.state.finish_task(request_id, result)
-
-    full_status, full_payload = server.handle_get(f"/task-progress/{request_id}", {})
-    incremental_status, incremental_payload = server.handle_get(
-        f"/task-progress/{request_id}",
-        {"after_sequence": ["2"]},
-    )
-
-    assert full_status == 200
-    assert [event["sequence"] for event in full_payload["events"]] == [1, 2, 3]
-    assert incremental_status == 200
-    assert [event["sequence"] for event in incremental_payload["events"]] == [3]
-    assert incremental_payload["status"] == "success"
-    assert incremental_payload["result"]["runId"] == "run-1"
-
-
-def test_playground_state_assigns_sequence_for_unsequenced_events() -> None:
-    state = PlaygroundState()
-    request_id = state.start_task("Strict progress")
-
-    state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Start"))
-    state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_completed", title="Done"))
-
-    full_progress = state.get_task(request_id)
-    incremental_progress = state.get_task(request_id, after_sequence=1)
-
-    assert full_progress is not None
-    assert [event["sequence"] for event in full_progress["events"]] == [1, 2]
-    assert incremental_progress is not None
-    assert [event["sequence"] for event in incremental_progress["events"]] == [2]
-
-
-def test_playground_state_includes_fsq_error_context() -> None:
-    state = PlaygroundState()
-    request_id = state.start_task("Invalid strict case")
-
-    state.fail_task(
-        request_id,
-        ConfigurationError(
-            "Invalid FSQ command parameters.",
-            context={"step_index": 0, "action_name": "launchApp", "validation_errors": [{"loc": ["app_path"]}]},
-        ),
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert "Invalid FSQ command parameters." in progress["error"]
-    assert '"action_name": "launchApp"' in progress["error"]
-    assert '"app_path"' in progress["error"]
-
-
-def test_playground_strict_recorder_updates_active_step_without_progress_events(tmp_path: Path) -> None:
-    state = PlaygroundState()
-    request_id = state.start_task("Strict progress")
-    recorder = _PlaygroundEvidenceRecorder(run_id="strict_case", output_dir=tmp_path, state=state, request_id=request_id)
-
-    recorder.record_event(RunnerEvent(event_type="step_start", run_id="strict_case", step_id="strict_case-step-002"))
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["events"] == []
-    assert progress["activeStep"] == {"stepId": "strict_case-step-002", "stepIndex": 2}
-
-
-def test_playground_state_cancel_request_marks_task_cancelled() -> None:
-    state = PlaygroundState()
-    request_id = state.start_task("Cancelable")
-
-    payload = state.request_cancel(request_id)
-
-    assert payload is not None
-    assert payload["status"] == "cancelled"
-    assert payload["cancelRequested"] is True
-    assert state.is_cancel_requested(request_id) is True
-    assert state.current_request_id is None
-
-
-def test_playground_server_cancel_endpoint_cancels_current_task(tmp_path: Path) -> None:
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Cancelable")
-
-    class FakeHandle:
-        def __init__(self) -> None:
-            self.cancelled = False
-
-        def cancel(self) -> None:
-            self.cancelled = True
-
-    handle = FakeHandle()
-    server._execution_handles[request_id] = handle  # type: ignore[assignment]
-
-    status, payload = server.handle_post(f"/cancel/{request_id}", {})
-
-    assert status == 200
-    assert payload["status"] == "cancelled"
-    assert payload["cancelRequested"] is True
-    assert handle.cancelled is True
-    assert server.state.current_request_id is None
-
-
-def test_playground_event_sink_ignores_events_after_cancel() -> None:
-    state = PlaygroundState()
-    request_id = state.start_task("Cancelable")
-    sink = _event_sink(state, request_id)
-
-    sink(RunEvent(run_id="run-1", task_id="task", type="run_started", title="Started"))
-    state.request_cancel(request_id)
-    sink(RunEvent(run_id="run-1", task_id="task", type="planning_update", title="Late event"))
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["status"] == "cancelled"
-    assert [event["title"] for event in progress["events"]] == ["Started"]
-
-
-def test_playground_server_persists_replay_frames(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Replay me")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-
-    server._record_replay_frame(
-        request_id,
-        {"available": True, "screenshot": base64.b64encode(b"frame-1").decode("ascii"), "timestamp": 1000},
-    )
-    server._record_replay_frame(
-        request_id,
-        {"available": True, "screenshot": base64.b64encode(b"frame-2").decode("ascii"), "timestamp": 1800},
-    )
-
-    status, payload = server.handle_get(f"/replay/{request_id}", {})
-    progress = server.state.get_task(request_id)
-
-    assert status == 200
-    assert [frame["timestamp"] for frame in payload["frames"]] == [1000, 1800]
-    assert [frame["index"] for frame in payload["frames"]] == [1, 2]
-    assert [frame["path"] for frame in payload["frames"]] == ["frame-0001-1000.png", "frame-0002-1800.png"]
-    assert base64.b64decode(payload["frames"][0]["screenshot"]) == b"frame-1"
-    assert (settings.output.runs_dir / "run-1" / "playground-replay" / "replay-manifest.json").exists()
-    assert progress is not None
-    assert progress["replay"]["runId"] == "run-1"
-    assert progress["replay"]["frameCount"] == 2
-    assert "manifestPath" not in progress["replay"]
-
-
-def test_playground_server_replay_returns_empty_for_known_request_without_frames(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("No frames")
-    server.state.fail_task(request_id, "Invalid FSQ command parameters.")
-
-    status, payload = server.handle_get(f"/replay/{request_id}", {})
-    missing_status, missing_payload = server.handle_get("/replay/unknown", {})
-
-    assert status == 200
-    assert payload == {
-        "available": False,
-        "requestId": request_id,
-        "runId": request_id,
-        "frames": [],
-        "message": "No replay frames were captured.",
-    }
-    assert missing_status == 404
-    assert missing_payload["error"] == "Replay frames not found."
-
-
-def test_playground_server_replay_uses_evidence_screenshots(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    screenshot_dir = run_dir / "artifacts" / "screenshots"
-    screenshot_dir.mkdir(parents=True)
-    (screenshot_dir / "step-1.png").write_bytes(b"evidence-frame")
-    (run_dir / "evidence-manifest.json").write_text(
-        json.dumps(
-            {
-                "run_id": "run-1",
-                "events": [
-                    {
-                        "event_type": "artifact_captured",
-                        "timestamp": "2026-06-17T10:49:07Z",
-                        "payload": {"kind": "screenshot", "path": "artifacts/screenshots/step-1.png"},
-                    }
-                ],
-                "artifacts": [
-                    {"kind": "screenshot", "path": "artifacts/screenshots/step-1.png"},
-                ],
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/replay/run-1", {})
-
-    assert status == 200
-    assert payload["runId"] == "run-1"
-    assert isinstance(payload["frames"][0]["timestamp"], int)
-    assert payload["frames"][0]["index"] == 1
-    assert payload["frames"][0]["path"] == "artifacts/screenshots/step-1.png"
-    assert base64.b64decode(payload["frames"][0]["screenshot"]) == b"evidence-frame"
-
-
-def test_playground_server_replay_falls_back_to_event_screenshots(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    run_dir = settings.output.runs_dir / "run-1"
-    screenshot_dir = run_dir / "artifacts" / "screenshots"
-    screenshot_dir.mkdir(parents=True)
-    (screenshot_dir / "step-1.png").write_bytes(b"event-frame")
-    (run_dir / "evidence-manifest.json").write_text(json.dumps({"run_id": "run-1", "steps": []}), encoding="utf-8")
-    (run_dir / "events.jsonl").write_text(
-        json.dumps(
-            {
-                "type": "tool_call_completed",
-                "timestamp": "2026-06-17T10:49:07Z",
-                "payload": {
-                    "artifact_refs": [
-                        {"kind": "screenshot", "path": "artifacts/screenshots/step-1.png"},
-                    ]
-                },
-            }
-        ),
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-
-    status, payload = server.handle_get("/replay/run-1", {})
-
-    assert status == 200
-    assert payload["runId"] == "run-1"
-    assert isinstance(payload["frames"][0]["timestamp"], int)
-    assert payload["frames"][0]["index"] == 1
-    assert payload["frames"][0]["path"] == "artifacts/screenshots/step-1.png"
-    assert base64.b64decode(payload["frames"][0]["screenshot"]) == b"event-frame"
-
-
-def test_playground_static_progress_summarizes_replay_frames() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    styles = (static_dir / "playground.css").read_text(encoding="utf-8")
-
-    assert "appendReplayFramesProgress" in script
-    assert "replayFrameSummaries" in script
-    assert "renderReplayFrameGallery" not in script
-    assert "progress-frame-gallery" not in styles
-    assert "src: `data:image/png;base64,${frame.screenshot}`" in script
-    assert "path: frame.path || ''" in script
-
-
-def test_playground_static_run_button_can_cancel() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    styles = (static_dir / "playground.css").read_text(encoding="utf-8")
-
-    assert "cancelExecution" in script
-    assert "setRunButtonCancel" in script
-    assert "setRunButtonIdle" in script
-    assert "Cancel" in script
-    assert "els.runSelected.classList.add('secondary-button')" in script
-    assert "els.runSelected.classList.remove('secondary-button')" in script
-    assert "button.cancel" not in styles
-    assert "button.secondary-button" in styles
-    assert "#run-selected" in styles
-    assert "min-width: 80px" in styles
-
-
-def test_playground_server_preview_endpoint_returns_latest_screenshot(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    screenshot_path = settings.output.runs_dir / "run-1" / "artifacts" / "screenshots" / "step-1.png"
-    screenshot_path.parent.mkdir(parents=True)
-    screenshot_path.write_bytes(b"preview")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Strict")
-    preview_token = _preview_token("run-1", "step-1")
-    server.state.set_preview(
-        request_id,
-        {
-            "runId": "run-1",
-            "path": "artifacts/screenshots/step-1.png",
-            "timestamp": "2026-06-17T10:49:07+00:00",
-            "token": preview_token,
-        },
-    )
-
-    status, payload = server.handle_get(f"/preview/{request_id}", {})
-
-    assert status == 200
-    assert payload["token"] == preview_token
-    assert base64.b64decode(payload["screenshot"]) == b"preview"
-
-
-def test_playground_server_resets_replay_dir_once_per_request(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    replay_dir = settings.output.runs_dir / "run-1" / "playground-replay"
-    replay_dir.mkdir(parents=True)
-    (replay_dir / "old-frame.png").write_bytes(b"old")
-    (replay_dir / "replay.webm").write_bytes(b"old-video")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Replay me")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-
-    server._record_replay_frame(
-        request_id,
-        {"available": True, "screenshot": base64.b64encode(b"frame-1").decode("ascii"), "timestamp": 1000},
-    )
-    server._record_replay_frame(
-        request_id,
-        {"available": True, "screenshot": base64.b64encode(b"frame-2").decode("ascii"), "timestamp": 1800},
-    )
-
-    assert not (replay_dir / "old-frame.png").exists()
-    assert not (replay_dir / "replay.webm").exists()
-    assert sorted(path.name for path in replay_dir.glob("frame-*.png")) == [
-        "frame-0001-1000.png",
-        "frame-0002-1800.png",
-    ]
-
-
-def test_playground_server_stores_uploaded_replay_video(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Replay me")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-
-    status, payload = server.handle_post(
-        f"/replay-video/{request_id}",
-        {"mimeType": "video/webm", "videoBase64": base64.b64encode(b"webm").decode("ascii")},
-    )
-    video_status, video_bytes, content_type, headers = server.handle_replay_video_file(f"/replay-video-file/{request_id}")
-
-    assert status == 200
-    assert payload["videoUrl"] == "/replay-video-file/run-1"
-    assert (settings.output.runs_dir / "run-1" / "playground-replay" / "replay.webm").read_bytes() == b"webm"
-    assert video_status == 200
-    assert video_bytes == b"webm"
-    assert content_type == "video/webm"
-    assert headers == {"Accept-Ranges": "bytes"}
-
-
-def test_playground_server_accepts_webm_upload_with_codecs(tmp_path: Path) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Replay me")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-
-    status, payload = server.handle_post(
-        f"/replay-video/{request_id}",
-        {"mimeType": "video/webm;codecs=vp8", "videoBase64": base64.b64encode(b"webm").decode("ascii")},
-    )
-
-    assert status == 200
-    assert payload["videoUrl"] == "/replay-video-file/run-1"
-
-
-def test_playground_execute_requires_session() -> None:
-    server = PlaygroundServer(Settings())
-
-    status, payload = server.handle_post("/execute", {"goal": "Do it"})
-
-    assert status == 409
-    assert "No active" in payload["error"]
-
-
-def test_playground_web_platform_does_not_require_android_session(monkeypatch) -> None:
-    settings = Settings(harness={"platform": "web"})
-    captured = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(settings)
-
-    status, payload = server.handle_post("/execute", {"goal": "Do it"})
-
-    assert status == 202
-    assert payload["requestId"]
-    assert captured["device_id"] is None
-
-
-def test_playground_execute_refreshes_only_provider_snapshot(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    user_root = tmp_path / "user"
-    save_azure_openai_provider(
-        base_url="https://new.openai.azure.com",
-        model="new-model",
-        api_key="new-key",
-        user_config_root=user_root,
-    )
-    settings = Settings(harness={"platform": "web"})
-    settings.workspace.root_dir = tmp_path / "workspace"
-    settings.openai_agents.provider = "azure_openai"
-    settings.openai_agents.model = "old-model"
-    settings.openai_agents.base_url = "https://old.openai.azure.com/openai/v1/"
-    settings.openai_agents.api_key = "old-key"
-    settings.openai_agents.user_config_root = user_root
-    captured: dict[str, object] = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-        return PlaygroundExecutionHandle(request_id=kwargs["request_id"])
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(settings)
-
-    status, _ = server.handle_post("/execute", {"goal": "Do it"})
-
-    run_settings = captured["settings"]
-    assert status == 202
-    assert run_settings.openai_agents.model == "new-model"
-    assert run_settings.openai_agents.api_key == "new-key"
-    assert run_settings.workspace.root_dir == tmp_path / "workspace"
-    assert server.settings.openai_agents.model == "old-model"
-    assert server.settings.openai_agents.api_key == "old-key"
-
-
-def test_playground_macos_platform_does_not_require_android_session(monkeypatch) -> None:
-    settings = Settings(harness={"platform": "macos"})
-    settings.harness.macos.appium_server_url = "http://127.0.0.1:4723"
-    settings.harness.macos.bundle_id = "com.example.MacApp"
-    captured = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(settings)
-
-    status, payload = server.handle_post("/execute", {"goal": "Do it"})
-
-    assert status == 202
-    assert payload["requestId"]
-    assert captured["device_id"] is None
-
-
-def test_playground_web_platform_session_endpoints_are_unavailable() -> None:
-    chrome_path = Path("C:/Chrome/chrome.exe")
-    settings = Settings(
-        harness={
-            "platform": "web",
-            "web": {"backend": "playwright", "channel": "chrome", "headless": False, "base_url": "https://example.test"},
-        }
-    )
-    settings.harness.web.browser_executable_path = chrome_path
-    server = PlaygroundServer(settings)
-
-    session_status, session_payload = server.handle_get("/session", {})
-    setup_status, setup_payload = server.handle_get("/session/setup", {})
-    auto_status, auto_payload = server.handle_post("/session/auto", {})
-    runtime_status, runtime_payload = server.handle_get("/runtime-info", {})
-
-    assert session_status == 200
-    assert session_payload["available"] is False
-    assert setup_status == 200
-    assert setup_payload["available"] is False
-    assert auto_status == 409
-    assert auto_payload["available"] is False
-    assert runtime_status == 200
-    assert runtime_payload["platformId"] == "web"
-    assert runtime_payload["metadata"]["backend"] == "playwright"
-    assert runtime_payload["metadata"]["channel"] == "chrome"
-    assert runtime_payload["metadata"]["browserExecutableConfigured"] is True
-    assert runtime_payload["metadata"]["headless"] is False
-    assert runtime_payload["metadata"]["baseUrlPresent"] is True
-
-
-def test_playground_windows_platform_does_not_require_android_session(monkeypatch) -> None:
-    settings = Settings(harness={"platform": "windows", "windows": {"app_path": "C:/App/app.exe"}})
-    captured = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(settings)
-
-    status, payload = server.handle_post("/execute", {"goal": "Do it"})
-
-    assert status == 202
-    assert payload["requestId"]
-    assert captured["device_id"] is None
-
-
-def test_playground_windows_platform_runtime_info_and_session_endpoints() -> None:
-    settings = Settings(
-        harness={
-            "platform": "windows",
-            "windows": {"app_path": "C:/App/app.exe", "window_title_re": ".*Edge Beta", "launch_args": ["--x"]},
-        }
-    )
-    server = PlaygroundServer(settings)
-
-    session_status, session_payload = server.handle_get("/session", {})
-    auto_status, _auto_payload = server.handle_post("/session/auto", {})
-    runtime_status, runtime_payload = server.handle_get("/runtime-info", {})
-
-    assert session_status == 200
-    assert session_payload["available"] is False
-    assert auto_status == 409
-    assert runtime_status == 200
-    assert runtime_payload["platformId"] == "windows"
-    assert runtime_payload["metadata"]["backend"] == "pywinauto"
-    assert runtime_payload["metadata"]["appPathConfigured"] is True
-    assert runtime_payload["metadata"]["windowTitleRePresent"] is True
-    assert runtime_payload["metadata"]["launchArgsCount"] == 1
-
-
-def test_playground_macos_platform_runtime_info_and_session_endpoints() -> None:
-    settings = Settings(harness={"platform": "macos", "macos": {"action_timeout_seconds": 11, "new_command_timeout_seconds": 420}})
-    settings.harness.macos.appium_server_url = "http://127.0.0.1:4723"
-    settings.harness.macos.bundle_id = "com.example.MacApp"
-    server = PlaygroundServer(settings)
-
-    session_status, session_payload = server.handle_get("/session", {})
-    setup_status, setup_payload = server.handle_get("/session/setup", {})
-    auto_status, auto_payload = server.handle_post("/session/auto", {})
-    delete_status, delete_payload = server.handle_delete("/session")
-    runtime_status, runtime_payload = server.handle_get("/runtime-info", {})
-
-    assert session_status == 200
-    assert session_payload["available"] is False
-    assert "macos" in session_payload["message"]
-    assert setup_status == 200
-    assert setup_payload["available"] is False
-    assert auto_status == 409
-    assert auto_payload["available"] is False
-    assert delete_status == 409
-    assert delete_payload["available"] is False
-    assert "macos" in delete_payload["message"]
-    assert runtime_status == 200
-    assert runtime_payload["platformId"] == "macos"
-    assert runtime_payload["metadata"]["backend"] == "appium_mac2"
-    assert runtime_payload["metadata"]["appiumServerConfigured"] is True
-    assert runtime_payload["metadata"]["bundleIdPresent"] is True
-    assert runtime_payload["metadata"]["appPathConfigured"] is False
-    assert runtime_payload["metadata"]["actionTimeoutSeconds"] == 11
-    assert runtime_payload["metadata"]["newCommandTimeoutSeconds"] == 420
-
-
-def test_playground_web_screenshot_uses_active_harness(tmp_path: Path) -> None:
-    class FakeWebHarness:
-        def get_context(self) -> HarnessContext:
-            return HarnessContext(platform="web", metadata={"browser_started": True})
-
-        def screenshot(self) -> bytes:
-            return b"png"
-
-    settings = Settings(harness={"platform": "web"})
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Web preview")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-    handle = PlaygroundExecutionHandle(request_id=request_id)
-    handle.bind_harness(FakeWebHarness())
-    server._execution_handles[request_id] = handle
-
-    status, payload = server.handle_get("/screenshot", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    assert payload["platform"] == "web"
-    assert base64.b64decode(payload["screenshot"]) == b"png"
-    frames = sorted((settings.output.runs_dir / "run-1" / "playground-replay").glob("frame-*.png"))
-    assert len(frames) == 1
-    assert frames[0].read_bytes() == b"png"
-
-
-def test_playground_macos_screenshot_uses_active_harness(tmp_path: Path) -> None:
-    class FakeMacOSHarness:
-        def get_context(self) -> HarnessContext:
-            return HarnessContext(platform="macos", session_id="mac2:session")
-
-        def screenshot(self) -> bytes:
-            return b"mac-png"
-
-    settings = Settings(harness={"platform": "macos"})
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("macOS preview")
-    server.state.add_event(request_id, RunEvent(run_id="run-1", task_id="task", type="run_started", title="Run started"))
-    handle = PlaygroundExecutionHandle(request_id=request_id)
-    handle.bind_harness(FakeMacOSHarness())
-    server._execution_handles[request_id] = handle
-
-    status, payload = server.handle_get("/screenshot", {})
-
-    assert status == 200
-    assert payload["available"] is True
-    assert payload["platform"] == "macos"
-    assert base64.b64decode(payload["screenshot"]) == b"mac-png"
-
-
-def test_playground_macos_screenshot_requires_launched_session(tmp_path: Path) -> None:
-    class FakeMacOSHarness:
-        def get_context(self) -> HarnessContext:
-            return HarnessContext(platform="macos")
-
-        def screenshot(self) -> bytes:
-            raise AssertionError("screenshot should not be called before launch")
-
-    settings = Settings(harness={"platform": "macos"})
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("macOS preview")
-    handle = PlaygroundExecutionHandle(request_id=request_id)
-    handle.bind_harness(FakeMacOSHarness())
-    server._execution_handles[request_id] = handle
-
-    status, payload = server.handle_get("/screenshot", {})
-
-    assert status == 200
-    assert payload["available"] is False
-    assert payload["platform"] == "macos"
-    assert "launchApp" in payload["error"]
-
-
-def test_playground_web_screenshot_reports_not_started(tmp_path: Path) -> None:
-    class FakeWebHarness:
-        def get_context(self) -> HarnessContext:
-            return HarnessContext(platform="web", metadata={"browser_started": False})
-
-        def screenshot(self) -> bytes:
-            raise AssertionError("screenshot should not be called before startBrowser")
-
-    settings = Settings(harness={"platform": "web"})
-    settings.output.runs_dir = tmp_path / "runs"
-    server = PlaygroundServer(settings, PlaygroundServerOptions(static_path=tmp_path))
-    request_id = server.state.start_task("Web preview")
-    handle = PlaygroundExecutionHandle(request_id=request_id)
-    handle.bind_harness(FakeWebHarness())
-    server._execution_handles[request_id] = handle
-
-    status, payload = server.handle_get("/screenshot", {})
-
-    assert status == 200
-    assert payload == {
-        "available": False,
-        "platform": "web",
-        "error": "Browser is not started. Call startBrowser before Web page actions.",
-    }
-
-
-def test_playground_execute_requires_exactly_one_source() -> None:
-    server = PlaygroundServer(Settings())
-    server.state.create_session("device-1")
-
-    missing_status, missing_payload = server.handle_post("/execute", {})
-    both_status, both_payload = server.handle_post("/execute", {"goal": "Do it", "caseYamlPath": "case.fsq.yaml"})
-    strict_both_status, strict_both_payload = server.handle_post("/execute", {"caseYamlPath": "case.fsq.yaml", "strictCaseYamlPath": "case.fsq.yaml"})
-
-    assert missing_status == 400
-    assert "Exactly one" in missing_payload["error"]
-    assert both_status == 400
-    assert "Exactly one" in both_payload["error"]
-    assert strict_both_status == 400
-    assert "Exactly one" in strict_both_payload["error"]
-
-
-def test_playground_execute_starts_strict_yaml(monkeypatch) -> None:
-    captured = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(Settings())
-    server.state.create_session("device-1")
-
-    status, payload = server.handle_post("/execute", {"strictCaseYamlPath": "case.fsq.yaml"})
-
-    assert status == 202
-    assert payload["requestId"]
-    assert captured["goal"] is None
-    assert captured["case_yaml_path"] is None
-    assert captured["strict_case_yaml_path"] == "case.fsq.yaml"
-    assert captured["record"] is True
-    assert captured["record_on_failure"] is True
-
-
-def test_playground_execute_passes_recording_options(monkeypatch) -> None:
-    captured = {}
-
-    def fake_start_dynamic_goal_execution(**kwargs):
-        captured.update(kwargs)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", fake_start_dynamic_goal_execution)
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(record=False, record_on_failure=False))
-    server.state.create_session("device-1")
-
-    status, payload = server.handle_post("/execute", {"goal": "Do it"})
-
-    assert status == 202
-    assert payload["requestId"]
-    assert captured["record"] is False
-    assert captured["record_on_failure"] is False
-
-
-def test_playground_dynamic_goal_records_with_failure_drafts(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    state = PlaygroundState()
-    request_id = state.start_task("Do it")
-    captured = {}
-
-    class FakeAgent:
-        async def run(self, task, event_sink=None):
-            captured["task"] = task
-            return TaskResult(
-                task_id=task.id,
-                status="failed",
-                steps=[],
-                verification=VerificationResult(status="failed", summary="not done"),
-                report=ReportArtifact(run_id="run-1", path=tmp_path / "report.md"),
-            )
-
-    def fake_record(_self, **kwargs):
-        captured.update(kwargs)
-        return RecordingResult(
-            status="skipped",
-            recording_path=kwargs["run_dir"] / "recording.json",
-            recorded_case_path=None,
-            published_case_path=None,
-            command_count=0,
-            required_runtime_secret_names=(),
-            warnings=(),
-            skipped_tool_calls=(),
-            errors=(),
-            validation_status="not_run",
-            draft=True,
-        )
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.validate_runtime_settings", lambda _settings: None)
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._execution.FsqAgent.from_settings",
-        lambda _settings, _runtime_factory, harness_factory=None: FakeAgent(),
-    )
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.RecordingService.record", fake_record)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal="Do it",
-        case_yaml_path=None,
-        strict_case_yaml_path=None,
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert captured["task"].planning_reference_kind == "goal"
-    assert captured["allow_failure"] is True
-    assert captured["publication_directory"] == settings.cases.dir
-    assert progress["result"]["recording"]["draft"] is True
-
-
-def test_playground_dynamic_goal_does_not_overwrite_cancelled_task(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.output.runs_dir = tmp_path / "runs"
-    state = PlaygroundState()
-    request_id = state.start_task("Do it")
-
-    class FakeAgent:
-        async def run(self, task, event_sink=None):
-            state.request_cancel(request_id)
-            if event_sink is not None:
-                event_sink(RunEvent(run_id="run-1", task_id=task.id, type="planning_update", title="Late event"))
-            return TaskResult(
-                task_id=task.id,
-                status="success",
-                steps=[],
-                verification=VerificationResult(status="success", summary="done"),
-                report=ReportArtifact(run_id="run-1", path=tmp_path / "report.md"),
-            )
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.validate_runtime_settings", lambda _settings: None)
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._execution.FsqAgent.from_settings",
-        lambda _settings, _runtime_factory, harness_factory=None: FakeAgent(),
-    )
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal="Do it",
-        case_yaml_path=None,
-        strict_case_yaml_path=None,
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["status"] == "cancelled"
-    assert progress["result"] is None
-    assert progress["events"] == []
-
-
-def test_playground_execute_clears_strict_replay_dir_at_start(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "strict_case.fsq.yaml"
-    case_path.write_text(
-        """
-schemaVersion: fsq.ai-test/v1
-name: Strict Case
-platform: android
----
-- launchApp
-- waitMs:
-    duration_ms: 1
-    reason: settle
-""",
-        encoding="utf-8",
-    )
-    replay_dir = settings.output.runs_dir / "strict_case" / "playground-replay"
-    replay_dir.mkdir(parents=True)
-    (replay_dir / "old-frame.png").write_bytes(b"old")
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._server.start_dynamic_goal_execution", lambda **_kwargs: None)
-    server = PlaygroundServer(settings)
-    server.state.create_session("device-1")
-
-    status, _payload = server.handle_post("/execute", {"strictCaseYamlPath": "strict_case.fsq.yaml"})
-
-    assert status == 202
-    assert not replay_dir.exists()
-
-
-def test_playground_strict_yaml_execution_uses_standard_step_adapter(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.harness.android.serial = "device-1"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "strict_case.fsq.yaml"
-    case_path.write_text(
-        """
-schemaVersion: fsq.ai-test/v1
-name: Strict Case
-platform: android
-appId: com.microsoft.emmx
----
-- launchApp
-- waitMs:
-    duration_ms: 1
-    reason: settle
-""",
-        encoding="utf-8",
-    )
-    state = PlaygroundState()
-    request_id = state.start_task("Strict")
-    captured = {}
-
-    class FakeDriver:
-        def __init__(self, *, app_id: str, serial: str | None) -> None:
-            captured["driver"] = {"app_id": app_id, "serial": serial}
-
-    def fake_run_strict_lifecycle_case(**kwargs):
-        steps = FsqExecutableStepAdapter(registry_snapshot=kwargs["registry_snapshot"]).to_executable_steps(kwargs["case"])
-        captured["steps"] = kwargs["resolve_steps"](steps, kwargs["case"])
-        captured["run_id"] = kwargs["run_id"]
-        output_dir = kwargs["output_dir"]
-        output_dir.mkdir(parents=True, exist_ok=True)
-        report_path = output_dir / "core-report.md"
-        json_path = output_dir / "core-report.json"
-        manifest_path = output_dir / "evidence-manifest.json"
-        report_path.write_text("report", encoding="utf-8")
-        json_path.write_text('{"summary":{"status":"passed","failed_steps":0}}', encoding="utf-8")
-        manifest_path.write_text("{}", encoding="utf-8")
-        return ReportArtifact(run_id=kwargs["run_id"], path=report_path, evidence_manifest_path=manifest_path)
-
-    monkeypatch.setattr("fsq_agent.drivers._factory.UiAutomator2AndroidDriver", FakeDriver)
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.run_strict_lifecycle_case", fake_run_strict_lifecycle_case)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="strict_case.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["result"]["status"] == "success"
-    assert captured["driver"] == {"app_id": "com.microsoft.emmx", "serial": "device-1"}
-    assert re.fullmatch(r"strict-case-\d{8}T\d{6}Z-[0-9a-f]{6}", captured["run_id"])
-    assert (settings.output.runs_dir / captured["run_id"]).parent == settings.output.runs_dir
-    assert captured["steps"][0].action_name == "launch_app"
-    assert captured["steps"][0].metadata["authored_action_name"] == "launchApp"
-
-
-def test_playground_strict_yaml_executes_full_shared_lifecycle(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings(
-        cases={"dir": tmp_path / "cases"},
-        case_lifecycle={
-            "onCaseStart": [{"runShell": "echo config-before"}],
-            "onCaseComplete": [{"runShell": "echo config-after"}],
-        },
-    )
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.harness.android.app_id = "com.example"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "strict_lifecycle.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\n"
-        "name: Strict Lifecycle\n"
-        "platform: android\n"
-        "appId: com.example\n"
-        "onCaseStart:\n"
-        "- runShell: echo case-before\n"
-        "onCaseComplete:\n"
-        "- runShell: echo case-after\n"
-        "---\n"
-        "- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    actions: list[str] = []
-
-    class FakeHarness:
-        def get_context(self) -> HarnessContext:
-            return HarnessContext(platform="android", session_id="session-1")
-
-        def action_space(self) -> dict[str, object]:
-            return {}
-
-        def before_action(self, step, context) -> None:
-            return None
-
-        def invoke_action(self, step, context):
-            actions.append(step.action_name)
-            return HarnessActionResult(status="passed", action_name=step.action_name)
-
-        def after_action(self, step, context, action_result) -> None:
-            return None
-
-        def capture_artifact(self, kind, reason, context, step_id, phase):
-            return HarnessArtifactRef(
-                artifact_id=f"{step_id}-{phase}-{kind}",
-                kind=kind,
-                path=Path(f"artifacts/raw/{step_id}-{phase}-{reason}.{kind}"),
-            )
-
-        def classify_error(self, error, phase, step):
-            return "unknown"
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution._build_strict_harness", lambda *args, **kwargs: FakeHarness())
-    state = PlaygroundState()
-    request_id = state.start_task("Strict lifecycle")
-    active_steps: list[dict[str, object] | None] = []
-    original_set_active_step = state.set_active_step
-
-    def record_active_step(request_id_value: str, active_step: dict[str, object] | None) -> None:
-        active_steps.append(active_step)
-        original_set_active_step(request_id_value, active_step)
-
-    monkeypatch.setattr(state, "set_active_step", record_active_step)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="strict_lifecycle.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    manifest_path = settings.output.runs_dir / progress["result"]["runId"] / "evidence-manifest.json"
-    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    commands = [step["metadata"].get("command") for step in manifest["steps"] if step["metadata"].get("command")]
-    assert progress["result"]["status"] == "success"
-    assert actions == ["launch_app"]
-    assert commands == ["echo config-before", "echo case-before", "echo case-after", "echo config-after"]
-    assert any(step and str(step.get("stepId", "")).startswith("strict_lifecycle-hook-shell-") for step in active_steps)
-    assert any(step.get("source_ref", {}).get("metadata", {}).get("lifecycle_phase") == "case" for step in manifest["steps"])
-
-
-def test_playground_strict_preflight_failure_runs_no_hooks_or_harness(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings(harness={"platform": "windows"}, cases={"dir": tmp_path / "cases"})
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.harness.windows.app_path = tmp_path / "app.exe"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "preflight.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\n"
-        "name: Preflight\n"
-        "platform: windows\n"
-        "onCaseStart:\n"
-        "- runShell: should-not-run\n"
-        "---\n"
-        "- typeText:\n"
-        "    target: Secret\n"
-        "    locator:\n"
-        "      title: Secret\n"
-        "    text:\n"
-        "      runtimeSecret: NOT_ALLOWED\n",
-        encoding="utf-8",
-    )
-    shell_calls: list[str] = []
-    harness_builds: list[bool] = []
-
-    def record_harness_build(*_args: object, **_kwargs: object) -> None:
-        harness_builds.append(True)
-
-    monkeypatch.setattr("fsq_agent.execution.lifecycle._run_shell_command", shell_calls.append)
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._execution._build_strict_harness",
-        record_harness_build,
-    )
-    state = PlaygroundState()
-    request_id = state.start_task("Preflight")
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="preflight.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["status"] == "error"
-    assert "Runtime secret name is not allowed" in progress["error"]
-    assert shell_calls == []
-    assert harness_builds == []
-
-
-def test_playground_strict_without_hooks_still_uses_shared_service(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings(cases={"dir": tmp_path / "cases"})
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.harness.android.app_id = "com.example"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "no-hooks.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: No Hooks\nplatform: android\nappId: com.example\n---\n- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    calls: list[str] = []
-
-    def fake_shared(**kwargs):
-        calls.append(kwargs["case"].id)
-        output_dir = kwargs["output_dir"]
-        output_dir.mkdir(parents=True, exist_ok=True)
-        report_path = output_dir / "core-report.md"
-        report_path.write_text("report", encoding="utf-8")
-        report_path.with_suffix(".json").write_text('{"summary":{"status":"passed","failed_steps":0}}', encoding="utf-8")
-        manifest_path = output_dir / "evidence-manifest.json"
-        manifest_path.write_text("{}", encoding="utf-8")
-        return ReportArtifact(run_id=kwargs["run_id"], path=report_path, evidence_manifest_path=manifest_path)
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.run_strict_lifecycle_case", fake_shared)
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution._build_strict_harness", lambda *args, **kwargs: object())
-    state = PlaygroundState()
-    request_id = state.start_task("No hooks")
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="no-hooks.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    assert calls == ["no-hooks"]
-
-
-def test_playground_child_run_case_is_active_before_child_steps_and_shares_manifest(tmp_path: Path, monkeypatch) -> None:
-    settings = Settings(cases={"dir": tmp_path / "cases"})
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.harness.android.app_id = "com.example"
-    settings.cases.dir.mkdir()
-    child_path = settings.cases.dir / "child.fsq.yaml"
-    child_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Child\nplatform: android\n---\n- tapOn:\n    target: Child\n",
-        encoding="utf-8",
-    )
-    root_path = settings.cases.dir / "root-child.fsq.yaml"
-    root_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: Root Child\nplatform: android\nappId: com.example\nonCaseStart:\n- runCase: child.fsq.yaml\n---\n- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    actions: list[str] = []
-
-    class FakeHarness:
-        def get_context(self):
-            return HarnessContext(platform="android", session_id="session-1")
-
-        def action_space(self):
-            return {}
-
-        def before_action(self, step, context):
-            return None
-
-        def invoke_action(self, step, context):
-            actions.append(step.action_name)
-            return HarnessActionResult(status="passed", action_name=step.action_name)
-
-        def after_action(self, step, context, action_result):
-            return None
-
-        def capture_artifact(self, kind, reason, context, step_id, phase):
-            return HarnessArtifactRef(
-                artifact_id=f"{step_id}-{phase}-{kind}",
-                kind=kind,
-                path=Path(f"artifacts/raw/{step_id}-{phase}-{kind}"),
-            )
-
-        def classify_error(self, error, phase, step):
-            return "unknown"
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution._build_strict_harness", lambda *args, **kwargs: FakeHarness())
-    state = PlaygroundState()
-    request_id = state.start_task("Root child")
-    active_ids: list[str] = []
-    preview_paths: list[str] = []
-    original_set_active = state.set_active_step
-    original_set_preview = state.set_preview
-
-    def record_active(request_id_value, active_step):
-        if active_step and active_step.get("stepId"):
-            active_ids.append(str(active_step["stepId"]))
-        original_set_active(request_id_value, active_step)
-
-    monkeypatch.setattr(state, "set_active_step", record_active)
-
-    def record_preview(request_id_value, preview):
-        preview_paths.append(str(preview.get("path", "")))
-        original_set_preview(request_id_value, preview)
-
-    monkeypatch.setattr(state, "set_preview", record_preview)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="root-child.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    manifest_path = settings.output.runs_dir / progress["result"]["runId"] / "evidence-manifest.json"
-    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    parent_index = next(index for index, step_id in enumerate(active_ids) if "hook-run-case" in step_id)
-    child_index = next(index for index, step_id in enumerate(active_ids) if step_id.startswith("child-case-step"))
-    assert parent_index < child_index
-    assert actions == ["tap_on", "launch_app"]
-    assert any("child-case-step-001" in path for path in preview_paths)
-    assert any(step["metadata"].get("hook_action_name") == "runCase" for step in manifest["steps"])
-    assert any(step["step_id"].startswith("child-case-step") for step in manifest["steps"])
-    assert any(step["step_id"] == "root-child-step-001" for step in manifest["steps"])
-
-
-def test_playground_strict_web_yaml_execution_uses_web_harness(tmp_path: Path, monkeypatch) -> None:
-    chrome_path = tmp_path / "Google" / "Chrome" / "Application" / "chrome.exe"
-    chrome_path.parent.mkdir(parents=True)
-    chrome_path.write_text("", encoding="utf-8")
-    chrome_path.chmod(0o755)
-    settings = Settings(
-        harness={
-            "platform": "web",
-            "web": {
-                "backend": "playwright",
-                "channel": "chrome",
-                "headless": True,
-                "base_url": "https://example.test",
-                "viewport_width": 1280,
-                "viewport_height": 720,
-            },
-        }
-    )
-    settings.harness.web.browser_executable_path = chrome_path
-    settings.cases.dir = tmp_path / "cases"
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "strict_web.fsq.yaml"
-    case_path.write_text(
-        """
-schemaVersion: fsq.ai-test/v1
-name: Strict Web Case
-platform: web
----
-- startBrowser
-- navigateTo:
-    url: /search
-- clickOn:
-    target: Search
-- closeBrowser
-""",
-        encoding="utf-8",
-    )
-    state = PlaygroundState()
-    request_id = state.start_task("Strict Web")
-    captured = {}
-
-    class FakeWebDriver:
-        def __init__(self, **kwargs):
-            captured["driver"] = kwargs
-
-    def fake_run_strict_lifecycle_case(**kwargs):
-        steps = FsqExecutableStepAdapter(registry_snapshot=kwargs["registry_snapshot"]).to_executable_steps(kwargs["case"])
-        captured["steps"] = kwargs["resolve_steps"](steps, kwargs["case"])
-        captured["registry"] = kwargs["registry"]
-        output_dir = kwargs["output_dir"]
-        output_dir.mkdir(parents=True, exist_ok=True)
-        report_path = output_dir / "core-report.md"
-        json_path = output_dir / "core-report.json"
-        manifest_path = output_dir / "evidence-manifest.json"
-        report_path.write_text("report", encoding="utf-8")
-        json_path.write_text('{"summary":{"status":"passed","failed_steps":0}}', encoding="utf-8")
-        manifest_path.write_text("{}", encoding="utf-8")
-        return ReportArtifact(run_id=kwargs["run_id"], path=report_path, evidence_manifest_path=manifest_path)
-
-    monkeypatch.setattr("fsq_agent.drivers._factory.PlaywrightWebDriver", FakeWebDriver)
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.run_strict_lifecycle_case", fake_run_strict_lifecycle_case)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="strict_web.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["result"]["status"] == "success"
-    assert captured["driver"] == {
-        "channel": "chrome",
-        "executable_path": chrome_path,
-        "headless": True,
-        "base_url": "https://example.test",
-        "viewport": (1280, 720),
-    }
-    assert captured["registry"].resolve("uiSnapshot") is not None
-    assert captured["registry"].resolve("startBrowser") is not None
-    assert captured["registry"].resolve("tapOn") is None
-    assert [step.action_name for step in captured["steps"]] == ["start_browser", "navigate_to", "click_on", "close_browser"]
-    assert captured["steps"][0].metadata["authored_action_name"] == "startBrowser"
-    assert captured["steps"][-1].metadata["authored_action_name"] == "closeBrowser"
-
-
-def test_playground_strict_windows_yaml_execution_uses_windows_harness(tmp_path: Path, monkeypatch) -> None:
-    app_path = tmp_path / "windows-app.exe"
-    app_path.write_text("", encoding="utf-8")
-    settings = Settings(
-        harness={
-            "platform": "windows",
-            "windows": {
-                "backend": "pywinauto",
-                "backend_kind": "win32",
-                "window_title_re": ".*Legacy App",
-                "launch_args": ["--flag", "two words"],
-            },
-        }
-    )
-    settings.harness.windows.app_path = app_path
-    settings.cases.dir = tmp_path / "cases"
-    settings.output.runs_dir = tmp_path / "runs"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "strict_windows.fsq.yaml"
-    case_path.write_text(
-        """
-schemaVersion: fsq.ai-test/v1
-name: Strict Windows Case
-platform: windows
----
-- launchApp
-- uiSnapshot
-- killApp
-""",
-        encoding="utf-8",
-    )
-    state = PlaygroundState()
-    request_id = state.start_task("Strict Windows")
-    captured = {}
-
-    class FakeWindowsDriver:
-        def __init__(self, **kwargs):
-            captured["driver"] = kwargs
-
-    def fake_run_strict_lifecycle_case(**kwargs):
-        steps = FsqExecutableStepAdapter(registry_snapshot=kwargs["registry_snapshot"]).to_executable_steps(kwargs["case"])
-        captured["steps"] = kwargs["resolve_steps"](steps, kwargs["case"])
-        captured["registry"] = kwargs["registry"]
-        output_dir = kwargs["output_dir"]
-        output_dir.mkdir(parents=True, exist_ok=True)
-        report_path = output_dir / "core-report.md"
-        json_path = output_dir / "core-report.json"
-        manifest_path = output_dir / "evidence-manifest.json"
-        report_path.write_text("report", encoding="utf-8")
-        json_path.write_text('{"summary":{"status":"passed","failed_steps":0}}', encoding="utf-8")
-        manifest_path.write_text("{}", encoding="utf-8")
-        return ReportArtifact(run_id=kwargs["run_id"], path=report_path, evidence_manifest_path=manifest_path)
-
-    monkeypatch.setattr("fsq_agent.drivers._factory.PywinautoWindowsDriver", FakeWindowsDriver)
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution.run_strict_lifecycle_case", fake_run_strict_lifecycle_case)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="strict_windows.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["result"]["status"] == "success"
-    assert captured["driver"] == {
-        "app_path": app_path,
-        "backend_kind": "win32",
-        "window_title_re": ".*Legacy App",
-        "launch_args": ["--flag", "two words"],
-    }
-    assert captured["registry"].resolve("uiSnapshot") is not None
-    assert [step.action_name for step in captured["steps"]] == ["launch_app", "ui_snapshot", "kill_app"]
-    assert captured["steps"][0].metadata["authored_action_name"] == "launchApp"
-    assert captured["steps"][-1].metadata["authored_action_name"] == "killApp"
-
-
-def test_playground_strict_yaml_runs_outside_async_event_loop(monkeypatch) -> None:
-    settings = Settings()
-    state = PlaygroundState()
-    request_id = state.start_task("Strict")
-    captured = {}
-
-    def fake_run_strict_case_yaml(_settings, _state, _request_id, path_text):
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            captured["running_loop"] = False
-        else:
-            captured["running_loop"] = True
-        captured["path_text"] = path_text
-        return TaskResult(
-            task_id="strict",
-            status="success",
-            steps=[],
-            verification=VerificationResult(status="success", summary="ok"),
-            report=ReportArtifact(run_id="run-1", path=Path("core-report.md")),
-        )
-
-    monkeypatch.setattr("fsq_agent.adapters.control_plane.playground._execution._run_strict_case_yaml", fake_run_strict_case_yaml)
-
-    _run_dynamic_task(
-        settings=settings,
-        state=state,
-        request_id=request_id,
-        goal=None,
-        case_yaml_path=None,
-        strict_case_yaml_path="strict_case.fsq.yaml",
-        device_id=None,
-        record=True,
-        record_on_failure=True,
-    )
-
-    progress = state.get_task(request_id)
-    assert progress is not None
-    assert progress["status"] == "success"
-    assert captured == {"running_loop": False, "path_text": "strict_case.fsq.yaml"}
-
-
-def test_playground_auto_session_route_creates_single_device_session(monkeypatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.discover_adb_targets",
-        lambda: ([AndroidTarget(id="device-1", label="device-1", is_default=True)], None),
-    )
-    server = PlaygroundServer(Settings())
-
-    status, payload = server.handle_post("/session/auto", {})
-
-    assert status == 200
-    assert payload["session"]["deviceId"] == "device-1"
-    assert payload["autoCreate"]["reason"] == "single_device"
-
-
-def test_playground_auto_session_route_requires_manual_selection(monkeypatch) -> None:
-    monkeypatch.setattr(
-        "fsq_agent.adapters.control_plane.playground._android.discover_adb_targets",
-        lambda: (
-            [
-                AndroidTarget(id="device-1", label="device-1", is_default=True),
-                AndroidTarget(id="device-2", label="device-2"),
-            ],
-            None,
-        ),
-    )
-    server = PlaygroundServer(Settings())
-
-    status, payload = server.handle_post("/session/auto", {})
-
-    assert status == 409
-    assert payload["reason"] == "multiple_devices"
-    assert len(payload["targets"]) == 2
-
-
-def test_playground_server_serves_status_over_http(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    static_dir.mkdir()
-    (static_dir / "index.html").write_text("hello", encoding="utf-8")
-    server = PlaygroundServer(Settings(), PlaygroundServerOptions(port=0, static_path=static_dir, open_browser=False))
-    server.start()
-    try:
-        with _open_loopback(f"{server.url}/status") as response:
-            payload = json.loads(response.read().decode("utf-8"))
-    finally:
-        server.stop()
-
-    assert payload["status"] == "ok"
-    assert payload["busy"] is False
-
-
-def test_playground_server_saves_yaml_lifecycle_over_http(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    static_dir.mkdir()
-    (static_dir / "index.html").write_text("hello", encoding="utf-8")
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "http.fsq.yaml"
-    case_path.write_text(
-        "schemaVersion: fsq.ai-test/v1\nname: HTTP\nplatform: android\n---\n- launchApp: {}\n",
-        encoding="utf-8",
-    )
-    server = PlaygroundServer(settings, PlaygroundServerOptions(port=0, static_path=static_dir, open_browser=False))
-    server.start()
-    try:
-        with _open_loopback(f"{server.url}/yaml/input?path=http.fsq.yaml") as response:
-            loaded = json.loads(response.read().decode("utf-8"))
-        request = _loopback_json_put_request(
-            f"{server.url}/yaml/input/lifecycle",
-            {
-                "path": "http.fsq.yaml",
-                "revision": loaded["revision"],
-                "onCaseStart": [{"action": "runShell", "value": "echo setup"}],
-                "onCaseComplete": [],
-            },
-        )
-        with _open_loopback(request) as response:
-            payload = json.loads(response.read().decode("utf-8"))
-    finally:
-        server.stop()
-
-    assert payload["display"]["lifecycle"]["onCaseStart"] == [{"index": 1, "action": "runShell", "value": "echo setup"}]
-
-
-def test_playground_server_rejects_stale_yaml_lifecycle_over_http(tmp_path: Path) -> None:
-    static_dir = tmp_path / "static"
-    static_dir.mkdir()
-    (static_dir / "index.html").write_text("hello", encoding="utf-8")
-    settings = Settings()
-    settings.cases.dir = tmp_path / "cases"
-    settings.cases.dir.mkdir()
-    case_path = settings.cases.dir / "http-conflict.fsq.yaml"
-    original = "schemaVersion: fsq.ai-test/v1\nname: HTTP conflict\nplatform: android\n---\n- launchApp: {}\n"
-    external = original.replace("name: HTTP conflict", "name: External")
-    case_path.write_text(original, encoding="utf-8")
-    server = PlaygroundServer(settings, PlaygroundServerOptions(port=0, static_path=static_dir, open_browser=False))
-    server.start()
-    try:
-        with _open_loopback(f"{server.url}/yaml/input?path=http-conflict.fsq.yaml") as response:
-            loaded = json.loads(response.read().decode("utf-8"))
-        case_path.write_text(external, encoding="utf-8")
-        request = _loopback_json_put_request(
-            f"{server.url}/yaml/input/lifecycle",
-            {
-                "path": "http-conflict.fsq.yaml",
-                "revision": loaded["revision"],
-                "onCaseStart": [{"action": "runShell", "value": "echo draft"}],
-                "onCaseComplete": [],
-            },
-        )
-        with pytest.raises(HTTPError) as error:
-            _open_loopback(request)
-        payload = json.loads(error.value.read().decode("utf-8"))
-    finally:
-        server.stop()
-
-    assert error.value.code == 409
-    assert "changed on disk" in payload["error"]
-    assert case_path.read_text(encoding="utf-8") == external
-
-
-def test_playground_static_progress_is_right_side_tab_and_numbered() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    html = (static_dir / "index.html").read_text(encoding="utf-8")
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    styles = (static_dir / "playground.css").read_text(encoding="utf-8")
-    clear_page_body = script[script.index("function clearPage()") : script.index("async function refreshStatus()")]
-    start_execution_body = script[script.index("async function startExecution(payload)") : script.index("async function cancelExecution()")]
-
-    assert 'class="section progress-section"' not in html
-    assert html.index('id="yaml-input-tab"') < html.index('id="yaml-recorded-tab"') < html.index('id="yaml-progress-tab"')
-    assert html.index('id="preview-tab"') < html.index('id="report-tab"')
-    assert html.index('id="progress-pane"') < html.index('id="session-section"')
-    assert "FSQ-Agent Playground" in html
-    assert "status-pill status-connecting" in html
-    assert "preview-tab" in html
-    assert 'id="progress-tab"' not in html
-    assert "yaml-progress-tab" in html
-    assert "report-tab" in html
-    assert "report-content" in html
-    assert "preview-pane" in html
-    assert "step-artifact-preview" in html
-    assert "progress-pane" in html
-    assert "panel-resizer" in html
-    assert 'role="separator"' in html
-    assert 'aria-orientation="vertical"' in html
-    assert "replay-screenshots" not in html
-    assert 'id="replay-video" controls' in html
-    assert 'id="replay-video-play"' not in html
-    assert 'aria-label="Play replay video"' not in html
-    assert "Use Selected" not in html
-    assert "Disconnect" not in html
-    assert "createSession" not in script
-    assert "destroySession" not in script
-    assert '<button id="refresh" class="secondary-button" type="button">Clear</button>' in html
-    assert "progress-run-id" in html
-    assert "handleProgressRunIdClick" in script
-    assert "selectProgressRunId" in script
-    assert "clearSelectedProgressRunId" in script
-    assert "clearSelectedProgressItem();\n  selectProgressRunId();" in script
-    assert "els.progressRunId.addEventListener('click', handleProgressRunIdClick)" in script
-    assert "els.progressRunId.dataset.runId = runId" in script
-    assert "delete els.progressRunId.dataset.runId" in script
-    assert "progressSequence" in script
-    assert "lastProgressSequence" in script
-    assert "modeStates" in script
-    assert "highlightRunStartSummary" in script
-    assert "if (state.currentExecutionMode !== 'strict-yaml') return" in script
-    assert "const title = els.yamlInputViewer.querySelector('.yaml-case-title-row')" in script
-    assert "selectYamlRegion(title)" in script
-    assert "createRunModeState" in script
-    assert "saveRunModeState" in script
-    assert "restoreRunModeState" in script
-    assert "switchRunMode" in script
-    assert "resetRunModeStates" in script
-    assert "stripTransientModeClasses" in script
-    assert "bindProgressDetailToggles" in script
-    assert "finishingRun" in script
-    assert "const PROGRESS_POLL_INTERVAL_MS = 750;" in script
-    assert "YAML_STEP_CENTER_TOLERANCE_RATIO" in script
-    assert "window.setInterval(refreshProgress, PROGRESS_POLL_INTERVAL_MS)" in script
-    assert "after_sequence=${state.lastProgressSequence}" in script
-    assert "function updateLastProgressSequence" in script
-    assert "setServerStatus" in script
-    assert "status-pill status-${status}" in script
-    assert "progressDetailOpenState" in script
-    assert "selectedProgressItem" in script
-    assert "activeProgressItem" in script
-    assert "activeProgressItemClearTimer" in script
-    assert "screenshotTimer" not in script
-    assert "screenshotInFlight" not in script
-    assert "state.replayTimer" not in script
-    assert "state.replayIndex" not in script
-    assert "replayRequestId" in script
-    assert "previewToken" in script
-    assert "pendingReplayVideoCleanup" in script
-    assert "replayVideoInFlight" in script
-    assert "CONTROL_PANEL_WIDTH_STORAGE_KEY" in script
-    assert "initPanelResizer" in script
-    assert "applyControlPanelWidth" in script
-    assert "localStorage.setItem(CONTROL_PANEL_WIDTH_STORAGE_KEY" in script
-    assert "ArrowLeft" in script
-    assert "ArrowRight" in script
-    assert "function makeReplaySeekable" in script
-    assert "makeMetadataSeekable" in script
-    assert "const REPLAY_FAST_ACTION_DELAY_MS = 900;" in script
-    assert "const REPLAY_FAST_MAX_DELAY_MS = 1500;" in script
-    assert "const REPLAY_FAST_FALLBACK_DELAY_MS = 500;" in script
-    assert "const REPLAY_FAST_FINAL_FRAME_HOLD_MS = 700;" in script
-    assert "const REPLAY_FAST_TIME_SCALE = 10;" in script
-    assert "REPLAY_FAST_FINAL_FRAME_HOLD_MS" in script
-    assert "requestCanvasFrame();" in script
-    assert "await waitMs(REPLAY_FAST_FINAL_FRAME_HOLD_MS);" in script
-    assert script.index("await waitMs(REPLAY_FAST_FINAL_FRAME_HOLD_MS);") < script.index("recorder.stop();")
-    assert "liveVideoRecorder" not in script
-    assert "liveVideoChunks" not in script
-    assert "function clearPage()" in script
-    assert "if (state.currentRequestId) return" in clear_page_body
-    assert "els.refresh.addEventListener('click', clearPage)" in script
-    assert "els.refresh.disabled = true" in script
-    assert "els.refresh.disabled = false" in script
-    assert "els.deviceSelect.disabled = true" in script
-    assert "els.deviceSelect.disabled = false" in script
-    assert "els.deviceSelect.disabled = Boolean(state.currentRequestId || state.finishingRun || status.busy)" in script
-    assert "showRightTab('progress')" not in start_execution_body
-    assert script.index("setRunButtonIdle();", script.index("ensureReplayVideoGenerated")) < script.index("els.refresh.disabled = false", script.index("ensureReplayVideoGenerated"))
-    assert "window.clearInterval(state.progressTimer)" in script
-    assert "stopLiveScreenshotPolling" not in script
-    assert "stopReplay" not in script
-    assert "clearRunId();" in clear_page_body
-    assert "resetRunModeStates();" in clear_page_body
-    assert "els.progress.innerHTML = ''" in script
-    assert "els.reportContent.textContent = ''" in script
-    assert "clearPreview();" in clear_page_body
-    assert "clearPreview('Loading live preview...')" in script
-    assert "highlightRunStartSummary();" in script
-    assert "function clearPreview" in script
-    assert "els.screenshot.removeAttribute('src')" in script
-    assert "refreshStatus();" in clear_page_body
-    assert "els.sessionMessage.textContent = ''" not in clear_page_body
-    assert "els.deviceSelect.innerHTML = ''" not in clear_page_body
-    assert "captureProgressDetailState" in script
-    assert "data-detail-key" in script
-    assert "event.sequence" in script
-    assert "syncYamlStepWithProgressEvent(event)" not in script
-    assert "strict_yaml_step" not in script
-    assert "backendSequence" in script
-    assert "tool_arguments" in script
-    assert "tool_output_preview" in script
-    assert "event.payload" in script
-    assert "eventDetails" in script
-    assert 'name="run-mode"' in html
-    assert "strict-yaml" in html
-    assert "caseYaml" in script
-    assert "runYaml" in script
-    assert "runSelected" in script
-    assert "currentRunMode() === 'strict-yaml'" in script
-    assert "currentRunMode" in script
-    assert "updateRunMode" in script
-    assert "caseYamlPath" in script
-    assert "strictCaseYamlPath" in script
-    assert "loadReport" in script
-    assert "?format=markdown" in script
-    assert "renderMarkdown" in script
-    assert "escapeHtml" in script
-    assert "showRightTab" in script
-    assert "showRightTab('progress')" not in script
-    assert "showYamlView('progress')" in script
-    assert "renderProgressText" in script
-    assert "handleProgressItemClick" in script
-    assert "function progressEventStepId(event)" in script
-    assert "payload.runner_step_id" in script
-    assert "runnerResult.step_id" in script
-    assert "item.dataset.yamlStepId = stepId" in script
-    assert "item.dataset.progressSequenceLabel = sequence" in script
-    assert "if (item.dataset.yamlStepId) loadStepArtifactsForCard(item)" in script
-    assert "appendProgress(eventLabel(event), event.sequence, eventDetails(event), eventStatus(event), event)" in script
-    assert ".progress-item-with-artifacts" in styles
-    assert "stepCard.dataset.progressSequenceLabel || stepCard.dataset.yamlStepIndex" in script
-    assert "if (state.currentRequestId || state.finishingRun) return" in script
-    assert "activateProgressItem(item)" in script
-    assert "scheduleClearActiveProgressItem" in script
-    assert "selectProgressItem" in script
-    assert "clearSelectedProgressRunId();\n    selectProgressItem(item);" in script
-    assert "clearSelectedProgressItem" in script
-    assert "document.addEventListener('click', handleProgressItemClick)" in script
-    assert "toolName" in script
-    assert "progressRunId" in script
-    assert "function setRunId(runId)" in script
-    assert "function clearRunId()" in script
-    assert "setRunId(event.run_id || event.runId)" in script
-    assert "setRunId(progress.result.runId)" in script
-    assert "event.type === 'run_started'" in script
-    assert "progress.activeStep" in script
-    assert "function syncYamlStepWithActiveStep" in script
-    assert "function activateYamlStepCard" in script
-    assert "function centerYamlStepCard" in script
-    assert "scheduleClearActiveYamlStepCard" in script
-    assert "cancelActiveYamlStepClearTimer" in script
-    assert "Run ID: ${runId}" in script
-    assert "refreshPreviewFromReplay" in script
-    assert "refreshPreview" in script
-    assert "api(`/preview/${encodeURIComponent(requestId)}`)" in script
-    assert "stepArtifactPreview" in script
-    assert "stepArtifactPreviewActive" in script
-    assert "showCompletedRunReplayPreview" in script
-    assert "loadStepArtifactsForCard" in script
-    assert "api(`/step-artifacts/${encodeURIComponent(runId)}/${encodeURIComponent(stepIdentifier)}`)" in script
-    assert "const shouldShowLoading = els.stepArtifactPreview.hidden || !els.stepArtifactPreview.hasChildNodes()" in script
-    assert "preloadStepArtifactScreenshots" in script
-    assert "stepArtifactImageSrc" in script
-    assert "renderStepArtifactPreview" in script
-    assert "renderStepArtifactScreenshots" in script
-    assert "renderStepArtifactTextArtifacts" in script
-    assert "typeof artifact.content === 'string' || typeof artifact.error === 'string'" in script
-    assert "typeof candidate.error === 'string'" in script
-    assert "uiTreeDiff && OBSERVATION_ARTIFACT_KINDS.includes(candidate.kind)" in script
-    assert "error.textContent = artifact.error" in script
-    assert "renderUiTreeDiffArtifact" in script
-    assert "OBSERVATION_ARTIFACT_KINDS" in script
-    assert "uiTreeDiff && OBSERVATION_ARTIFACT_KINDS.includes(artifact.kind)" in script
-    assert "renderDiffPane" in script
-    assert "renderDiffOverview" in script
-    assert "syncDiffPaneScroll" in script
-    assert "createScreenshotHeightResizer" in script
-    assert "step-artifact-screenshot-border-resizer" in styles
-    assert "step-artifact-screenshot-scroll" in script
-    assert "step-artifact-screenshot-scroll" in styles
-    assert ".step-artifact-screenshot-scroll > .step-artifact-section" in styles
-    assert "flex: 0 0 100%" in styles
-    assert "currentCardWidth" in script
-    assert "currentImageAspect" in script
-    assert "currentRenderedImageWidth" in script
-    assert "shotBaseCardWidth" in script
-    assert "Math.max(baseCardWidth, nextImageWidth)" in script
-    assert "appliedDelta" in script
-    assert "initializeScreenshotResizeLayout" in script
-    assert "requestAnimationFrame" in script
-    assert "applyScreenshotRegionHeight" in script
-    assert "keepResizeBorderInPreview" not in script
-    assert "setPointerCapture" in script
-    assert "step-artifact-region-user-sized" in styles
-    assert ".step-artifact-image-card {" in styles
-    assert "margin: 0" in styles
-    assert "background: #eef2f7" in styles
-    assert "justify-content: safe center" in styles
-    assert "overflow-x: scroll" in styles
-    assert "scrollbar-gutter: stable" in styles
-    assert "height: min(80vh, 820px)" in styles
-    assert "createDiffTopResizer" in script
-    assert "step-artifact-ui-tree-border-resizer" in styles
-    assert "step-artifact-ui-tree-bottom-border-resizer" in styles
-    assert "gap: 24px" in styles
-    assert "startDiff" not in script
-    assert "createDiffHeightResizer" in script
-    assert "renderDiffHeader" not in script
-    assert "bindSynchronizedArtifactScroll" not in script
-    assert "diffTextLines" in script
-    assert "myersDiffLines" in script
-    assert "backtrackMyersDiff" in script
-    assert "patienceDiffLines" in script
-    assert "longestIncreasingAnchorSequence" in script
-    assert "annotateInlineDiff" in script
-    assert "inlineTextChanges" in script
-    assert "compactDiffContext" not in script
-    assert "step-artifact-diff-card" in styles
-    assert "step-artifact-diff-headrow" in styles
-    assert "step-artifact-diff-pane" in styles
-    assert "step-artifact-diff-overview" in styles
-    assert "step-artifact-diff-line-added" in styles
-    assert "step-artifact-diff-line-removed" in styles
-    assert "step-artifact-diff-inline-change" in styles
-    assert "diff-pane-before" in styles
-    assert "diff-pane-after" in styles
-    assert "completedRunId" in script
-    assert "startLiveScreenshotPolling" not in script
-    assert "refreshScreenshot({ preservePrevious: true })" not in script
-    assert "preloadImage" in script
-    assert "showReplayFrame" in script
-    assert "loadReplayFrames" in script
-    assert "loadReplayVideo" in script
-    assert "showReplayVideoPreview" in script
-    assert "async function showReplayVideoPreview(videoUrl)" in script
-    assert "await waitForReplayVideoReady()" in script
-    assert "function waitForReplayVideoReady()" in script
-    assert "els.replayVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA" in script
-    assert "function cancelPendingReplayVideoReadyWait()" in script
-    assert "startReplay" not in script
-    assert "replayVideoEnded" not in script
-    assert "replayVideoStarted" not in script
-    assert "replayVideoPaused" not in script
-    assert "normalizeReplayVideoDuration" not in script
-    assert "generateReplayVideo" in script
-    assert "recordLiveReplayFrame" not in script
-    assert "finalizeLiveReplayVideo" not in script
-    assert "appendReplayVideoGeneratingProgress" in script
-    assert "Generating replay video..." in script
-    assert "Replay video saved" in script
-    assert "Replay video was not generated:" in script
-    assert "if (progress.result?.runId && state.replayRequestId && progress.status !== 'cancelled')" in script
-    assert "MediaRecorder produced an empty video" in script
-    assert "no replay frames found" in script
-    assert "discardLiveReplayVideo" not in script
-    assert "ensureReplayVideoGenerated" in script
-    assert "setRunButtonCancel({ disabled: true })" in script
-    assert "state.finishingRun = true" in script
-    assert "state.finishingRun = false" in script
-    assert script.index("ensureReplayVideoGenerated") < script.index("clearSelectedYamlRegion()", script.index("ensureReplayVideoGenerated"))
-    assert "!state.currentRequestId && !state.finishingRun" in script
-    assert "} else if (state.finishingRun)" in script
-    assert script.index("setRunButtonCancel({ disabled: true })") < script.index("ensureReplayVideoGenerated")
-    assert script.index("ensureReplayVideoGenerated") < script.index("setRunButtonIdle();", script.index("ensureReplayVideoGenerated"))
-    assert "replayVideoMimeType" in script
-    assert "MediaRecorder.isTypeSupported" in script
-    assert "uploadReplayVideo" in script
-    assert "blobToBase64" in script
-    assert "const seekable = await makeReplaySeekable(videoBlob, durationMs);" in script
-    assert "Replay video is not seekable" in script
-    assert "Failed to rewrite WebM index" in script
-    assert "els.replayVideo.addEventListener('loadedmetadata', normalizeReplayVideoDuration)" not in script
-    assert "finishDurationFix" not in script
-    assert "els.replayVideo.currentTime = 1e101" not in script
-    assert "await showReplayVideoPreview(replayVideo.videoUrl)" in script
-    assert "showRightTab('preview')" in script
-    assert "api(`/replay-video/${encodeURIComponent(requestId)}`)" in script
-    assert "method: 'POST'" in script
-    assert "recorder.start();" in script
-    assert "replayVideo.videoUrl" in script
-    assert "replayFrameDelay" in script
-    assert "[replay-video] draw screenshot" in script
-    assert "replayFrameDisplayDuration" in script
-    assert "durationMs" in script
-    assert "api(`/replay/${encodeURIComponent(requestId)}`)" in script
-    assert "next.timestamp - current.timestamp" in script
-    assert "window.setTimeout" in script
-    assert "window.clearTimeout(state.replay" not in script
-    assert "No replay frames yet." not in script
-    assert "No replay run yet." not in script
-    assert "Unable to load replay" not in script
-    assert "eventStatus" in script
-    assert "statusFromValue" in script
-    assert "progress-status-${status}" in script
-    assert "/session/auto" in script
-    assert "ensureSession" in script
-    assert "padStart(3, '0')" in script
-    assert "progress-number" in styles
-    assert "#replay-video" in styles
-    assert "status-pill" in styles
-    assert "status-ready" in styles
-    assert "status-running" in styles
-    assert "status-error" in styles
-    assert "progress-run-id" in styles
-    assert ".progress-run-id:hover" in styles
-    assert ".progress-run-id.progress-run-id-selected" in styles
-    assert "flex: 0 0 auto" in styles
-    assert "progress-title" in styles
-    assert ".progress-item:hover" in styles
-    assert ".progress-item.progress-item-active" in styles
-    assert ".progress-item.progress-item-selected" in styles
-    assert "background: #dbeafe" in styles
-    assert "box-shadow: inset 3px 0 0 #2563eb" in styles
-    assert "box-shadow: inset 3px 0 0 #60a5fa" in styles
-    assert "cursor: pointer" in styles
-    assert "progress-message" in styles
-    assert "progress-tool" in styles
-    assert "progress-detail" in styles
-    assert "progress-status-dot" in styles
-    assert "progress-status-success" in styles
-    assert ".replay-video-play" not in styles
-    assert ".replay-video-progress" not in styles
-    assert "progress-status-failed" in styles
-    assert "screenshot-refresh" not in styles
-    assert "#22c55e" in styles
-    assert "#ef4444" in styles
-    assert ".progress-pane" in styles
-    assert "grid-template-rows: auto minmax(0, 1fr) auto auto" not in styles
-    assert "grid-template-rows: auto minmax(420px, 62vh) auto auto" not in styles
-    assert "run-mode-row" in styles
-    assert "report-pane" in styles
-    assert "report-content" in styles
-    assert "tab-button.active" in styles
-    assert "[hidden]" in styles
-
-
-def test_playground_frontend_uses_locked_npm_dependency_without_vendor_bundle() -> None:
-    root = Path(__file__).parents[1]
-    package = json.loads((root / "package.json").read_text(encoding="utf-8"))
-    html = (root / "frontend" / "playground" / "index.html").read_text(encoding="utf-8")
-    script = (root / "frontend" / "playground" / "playground.js").read_text(encoding="utf-8")
-
-    assert package["private"] is True
-    assert package["engines"]["node"] == "^20.19.0 || >=22.12.0"
-    assert package["dependencies"]["ts-ebml"] == "3.0.2"
-    assert package["scripts"]["build"] == "vite build && node scripts/distribute-frontend-build.mjs"
-    assert "vendor/ts-ebml.min.js" not in html
-    assert '<script type="module" src="./playground.js"></script>' in html
-    assert "import EBML from 'ts-ebml/dist/EBML.js';" in script
-    assert "const { Decoder, Reader, tools: ebmlTools } = EBML;" in script
-    assert "window.EBML" not in script
-    assert not (root / "fsq_agent" / "playground" / "static" / "vendor" / "ts-ebml.min.js").exists()
-
-
-def test_playground_static_hides_session_section_for_non_android_platforms() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    html = (static_dir / "index.html").read_text(encoding="utf-8")
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-
-    assert 'id="session-section"' in html
-    assert "sessionSection: document.getElementById('session-section')" in script
-    assert "function updateSessionVisibility()" in script
-    assert "els.sessionSection.hidden = !platformRequiresSession();" in script
-
-
-def test_playground_static_preserves_android_auto_session_error() -> None:
-    script_path = Path(__file__).parents[1] / "frontend" / "playground" / "playground.js"
-    script = script_path.read_text(encoding="utf-8")
-    refresh_body = script[script.index("async function refreshAll()") : script.index("function clearPage()")]
-    auto_body = script[script.index("async function autoCreateSessionIfPossible(") : script.index("async function ensureSession()")]
-
-    assert "const sessionReady = await autoCreateSessionIfPossible({ silent: true });" in refresh_body
-    assert "if (sessionReady) await refreshStatus();" in refresh_body
-    assert "els.sessionMessage.textContent = error.message;" in auto_body
-    assert "error.message.includes('Multiple')" not in auto_body
-
-
-def test_playground_static_input_yaml_lifecycle_editor_contract() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    html = (static_dir / "index.html").read_text(encoding="utf-8")
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    styles = (static_dir / "playground.css").read_text(encoding="utf-8")
-    lifecycle_model = (static_dir / "lifecycle-editor-model.js").read_text(encoding="utf-8")
-
-    assert 'id="yaml-lifecycle-save"' in html
-    assert 'id="yaml-lifecycle-discard"' in html
-    assert 'id="toast"' in html
-    assert 'role="status"' in html
-    assert '<script type="module" src="./playground.js"></script>' in html
-    assert "import LifecycleEditorModel from './lifecycle-editor-model.js';" in script
-    assert "renderLifecycleSection('onCaseStart', 'Before case')" in script
-    assert "renderLifecycleSection('onCaseComplete', 'After case')" in script
-    assert "function renderYamlCaseSteps(steps)" in script
-    assert "title.textContent = 'Case steps'" in script
-    assert "renderYamlCaseSteps(display.steps || [])" in script
-    assert "addLifecycleAction" in script
-    assert "deleteLifecycleAction" in script
-    assert "moveLifecycleAction" in script
-    assert "method: 'PUT'" in script
-    assert "Save or discard lifecycle changes before running." in script
-    assert "Save or discard lifecycle changes before loading a run." in script
-    assert "Discard unsaved lifecycle changes and reload YAML?" in script
-    assert "function lifecycleValidationError()" in script
-    assert "Lifecycle action values cannot be empty." in lifecycle_model
-    update_toolbar_body = script[script.index("function updateLifecycleToolbar()") : script.index("async function saveLifecycleDraft()")]
-    save_body = script[script.index("async function saveLifecycleDraft()") : script.index("function discardLifecycleDraft()")]
-    assert "setYamlInputStatus(invalid, 'error')" not in update_toolbar_body
-    assert "Boolean(invalid)" not in update_toolbar_body
-    assert "setYamlInputStatus(validationError, 'error')" in save_body
-    assert "function saveLifecycleDraft()" in script
-    assert "function setLifecycleEditorDisabled(disabled)" in script
-    assert "function lifecycleEditorIsDisabled()" in script
-    assert "'.yaml-lifecycle-section select, .yaml-lifecycle-section input, .yaml-lifecycle-section button'" in script
-    assert "const editorDisabled = Boolean(state.currentRequestId || state.finishingRun || state.yamlLifecycleSaving)" in script
-    assert "if (!Object.hasOwn(control.dataset, 'lifecycleWasDisabled'))" in script
-    finishing_block = script[script.index("state.finishingRun = true;") : script.index("scheduleClearActiveYamlStepCard();")]
-    assert "updateLifecycleToolbar();" in finishing_block
-    assert "showToast('Lifecycle hooks saved.')" in script
-    assert "function showToast(message, durationMs = 2000)" in script
-    assert "function hideToast()" in script
-    assert "setYamlInputStatus('Lifecycle hooks saved.'" not in script
-    assert "function discardLifecycleDraft()" in script
-    assert "state.yamlLifecycleSnapshot = cloneLifecycle(payload.display?.lifecycle" in script
-    assert "setYamlInputStatus(error.message, 'error')" in script
-    catch_body = save_body[save_body.index("} catch (error) {") : save_body.index("} finally {")]
-    assert "state.yamlLifecycleDraft =" not in catch_body
-    assert "state.yamlLifecycleSnapshot =" not in catch_body
-    assert "renderYamlDisplay(els.yamlRecordedViewer, state.yamlRecordedDisplay" in script
-    assert "renderYamlDisplay(els.yamlRecordedViewer, state.yamlRecordedDisplay, 'Recorded YAML is empty.', { lifecycleEditor" not in script
-    assert "renderYamlDisplay(els.yamlInputViewer, state.yamlInputDisplay, 'YAML file is empty.', { lifecycleEditor: state.yamlInputEditable })" in script
-    assert html.index('id="yaml-lifecycle-toolbar"') < html.index('id="yaml-input-viewer"')
-    assert ".yaml-lifecycle-action-row" in styles
-    assert ".toast" in styles
-    assert ".yaml-lifecycle-toolbar-actions" in styles
-    assert "margin-left: auto" in styles
-    assert ".yaml-lifecycle-action-row select," in styles
-    assert "height: 32px" in styles
-    assert "margin: 0" in styles
-    assert ".yaml-case-steps-heading" in styles
-    assert '.yaml-lifecycle-section[data-lifecycle-field="onCaseComplete"]' in styles
-    assert "border-top: 1px solid #d8dee8" in styles
-    assert "@media (max-width: 760px)" in styles
-
-
-def test_playground_static_loaded_run_preserves_run_mode_yaml_state() -> None:
-    script_path = Path(__file__).parents[1] / "frontend" / "playground" / "playground.js"
-    script = script_path.read_text(encoding="utf-8")
-    switch_body = script[script.index("function switchRunMode()") : script.index("function updateRunMode(")]
-    start_body = script[script.index("async function startExecution(payload)") : script.index("function highlightRunStartSummary()")]
-    load_body = script[script.index("async function activateLoadedRun(runId, availability)") : script.index("async function loadExistingRunProgress(runId)")]
-
-    assert "saveRunModeState(state.activeRunMode);" in load_body
-    assert "restoreRunModeState(mode);" in switch_body
-    assert "state.loadedRunId = null;" not in switch_body
-    assert "saveRunModeState('goal');" in load_body
-    assert "function loadedRunIsActive()" in script
-    assert "if (loadedRunId)" not in switch_body
-    assert "if (state.loadedRunId)" in start_body
-    assert "restoreRunModeState(state.activeRunMode);" in start_body
-    assert start_body.index("restoreRunModeState(state.activeRunMode);") < start_body.index("state.loadedRunId = null;")
-
-
-def test_playground_static_run_modes_preserve_preview_and_report_state() -> None:
-    script_path = Path(__file__).parents[1] / "frontend" / "playground" / "playground.js"
-    script = script_path.read_text(encoding="utf-8")
-    create_body = script[script.index("function createRunModeState()") : script.index("const REPLAY_FAST_SAME_EVENT_DELAY_MS")]
-    save_body = script[script.index("function saveRunModeState(") : script.index("function restoreRunModeState(")]
-    restore_body = script[script.index("function restoreRunModeState(") : script.index("function stripTransientModeClasses()")]
-    switch_body = script[script.index("function switchRunMode()") : script.index("function updateRunMode(")]
-    completed_run_body = script[script.index("function completedRunId()") : script.index("async function showCompletedRunReplayPreview(")]
-
-    for field in (
-        "rightActiveTab",
-        "reportHtml",
-        "replayRequestId",
-        "previewToken",
-        "replayVideoSrc",
-        "screenshotSrc",
-        "stepArtifactNodes",
-    ):
-        assert field in create_body
-        assert f"modeState.{field}" in save_body
-        assert f"modeState.{field}" in restore_body
-    assert "showRightTab(modeState.rightActiveTab);" in restore_body
-    assert "saveRunModeState(state.activeRunMode);" in switch_body
-    assert "if (loadedRunIsActive()) return state.loadedRunId;" in completed_run_body
-
-
-def test_playground_static_oversized_ui_tree_errors_stay_side_by_side() -> None:
-    script_path = Path(__file__).parents[1] / "frontend" / "playground" / "playground.js"
-    script = script_path.read_text(encoding="utf-8")
-    text_artifacts_body = script[script.index("function renderStepArtifactTextArtifacts(") : script.index("const OBSERVATION_ARTIFACT_KINDS")]
-    comparison_body = script[script.index("function renderUiTreeDiffArtifact(") : script.index("function createDiffHeightResizer(")]
-
-    assert "const uiTreeDiff = renderUiTreeDiffArtifact(artifacts);" in text_artifacts_body
-    assert "uiTreeDiff && OBSERVATION_ARTIFACT_KINDS.includes(candidate.kind)" in text_artifacts_body
-    assert "typeof artifact.content === 'string' || typeof artifact.error === 'string'" in comparison_body
-    assert "UI Tree diff" not in comparison_body
-    assert "UI Tree (no changes)" not in comparison_body
-    assert "card.appendChild(label);" not in comparison_body
-    assert "if (!beforeArtifact && !afterArtifact) return null;" in comparison_body
-    assert "if (!beforeArtifact || !afterArtifact)" in comparison_body
-    assert "const side = beforeArtifact ? 'before' : 'after';" in comparison_body
-    assert "const title = beforeArtifact ? 'Before' : 'After';" in comparison_body
-    assert "split.appendChild(pane);" in comparison_body
-    assert "fallbackKind" not in comparison_body
-    assert "renderArtifactErrorPane('before', 'Before', before)" in comparison_body
-    assert "renderArtifactErrorPane('after', 'After', after)" in comparison_body
-    assert "artifact.error || 'UI tree is unavailable.'" in comparison_body
-    assert "pane.appendChild(renderDiffPaneHeader(title));" in comparison_body
-    assert "function renderDiffPaneHeader(title)" in script
-    assert "header.className = 'step-artifact-image-label step-artifact-diff-headrow';" in script
-    assert "headerNumber" not in comparison_body
-
-
-def test_playground_static_load_run_is_goal_mode_only() -> None:
-    script_path = Path(__file__).parents[1] / "frontend" / "playground" / "playground.js"
-    script = script_path.read_text(encoding="utf-8")
-    update_body = script[script.index("function updateRunMode(") : script.index("function syncYamlTabOrder(mode)")]
-    toggle_body = script[script.index("function toggleLoadRunForm()") : script.index("function resetLoadRunForm(")]
-    load_body = script[script.index("async function loadExistingRun()") : script.index("async function activateLoadedRun(")]
-
-    assert "const loadRunAvailable = mode === 'goal';" in update_body
-    assert "els.loadRunToggle.hidden = !loadRunAvailable;" in update_body
-    assert "resetLoadRunForm({ collapse: true })" in update_body
-    assert "currentRunMode() !== 'goal'" in toggle_body
-    assert "currentRunMode() !== 'goal'" in load_body
-
-
-def test_playground_lifecycle_editor_model_behavior() -> None:
-    node = shutil.which("node")
-    if node is None:
-        pytest.skip("Node.js is required for lifecycle editor model verification.")
-    model_path = Path(__file__).parents[1] / "frontend" / "playground" / "lifecycle-editor-model.js"
-    script = f"""
-import model from {json.dumps(model_path.as_uri())};
-const snapshot = model.empty();
-let draft = model.addAction(snapshot, 'onCaseStart', 'runCase');
-const invalidEmpty = model.validationError(draft);
-draft = model.updateAction(draft, 'onCaseStart', 0, 'value', 'hooks/setup.fsq.yaml');
-draft = model.addAction(draft, 'onCaseStart', 'runCase');
-draft = model.updateAction(draft, 'onCaseStart', 1, 'value', 'hooks/second.fsq.yaml');
-draft = model.addAction(draft, 'onCaseStart', 'runShell');
-draft = model.updateAction(draft, 'onCaseStart', 2, 'value', 'echo ready');
-draft = model.moveAction(draft, 'onCaseStart', 2, -1);
-draft = model.moveAction(draft, 'onCaseStart', 1, -1);
-const ordered = model.actions(draft, 'onCaseStart').map((action) => [action.action, action.value]);
-draft = model.deleteAction(draft, 'onCaseStart', 1);
-const valid = model.validationError(draft);
-const discarded = model.clone(snapshot);
-console.log(JSON.stringify({{ invalidEmpty, ordered, remaining: model.actions(draft, 'onCaseStart'), valid, discarded }}));
-"""
-
-    # The executable comes from shutil.which and every argument is fixed test data.
-    result = subprocess.run([node, "--input-type=module", "-e", script], check=True, capture_output=True, text=True)  # noqa: S603
-    payload = json.loads(result.stdout)
-
-    assert payload["invalidEmpty"] == "Lifecycle action values cannot be empty."
-    assert payload["ordered"] == [
-        ["runShell", "echo ready"],
-        ["runCase", "hooks/setup.fsq.yaml"],
-        ["runCase", "hooks/second.fsq.yaml"],
-    ]
-    assert payload["remaining"] == [
-        {"action": "runShell", "value": "echo ready"},
-        {"action": "runCase", "value": "hooks/second.fsq.yaml"},
-    ]
-    assert payload["valid"] == ""
-    assert payload["discarded"] == {"onCaseStart": [], "onCaseComplete": []}
-
-
-def test_playground_static_yaml_section_is_left_side_context() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    html = (static_dir / "index.html").read_text(encoding="utf-8")
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    styles = (static_dir / "playground.css").read_text(encoding="utf-8")
-    run_start = html.index('class="section run-section"')
-    run_section = html[run_start : html.index("</section>", run_start)]
-    execution_section = html[html.index('id="execution-section"') : html.index('id="session-section"')]
-
-    assert html.index('id="execution-section"') < html.index("<h2>Session</h2>")
-    assert "<h2>Execution</h2>" in execution_section
-    assert "<h2>YAML</h2>" not in execution_section
-    assert html.index('id="case-yaml"') > html.index('class="section run-section"')
-    assert 'id="case-yaml"' in run_section
-    assert 'id="yaml-path-row"' in run_section
-    assert 'class="run-input-row"' in run_section
-    assert 'id="case-yaml"' not in execution_section
-    assert 'id="load-run-toggle"' in execution_section
-    assert 'id="load-run-form"' in execution_section
-    assert 'id="load-run-path"' in execution_section
-    assert 'id="load-run-submit"' in execution_section
-    assert 'id="load-run-cancel"' in execution_section
-    assert 'id="load-run-status"' in execution_section
-    assert "yaml-input-tab" in html
-    assert ">Source YAML</button>" in html
-    assert ">Input YAML</button>" not in html
-    assert ">Input</button>" not in html
-    assert "yaml-recorded-tab" in html
-    assert ">Generated YAML</button>" in html
-    assert ">Recorded</button>" not in html
-    assert "No generated YAML yet." in html
-    assert "Loading generated YAML..." in script
-    assert "Generated YAML is empty." in script
-    assert "No generated YAML is available for this run." in script
-    assert "yaml-input-pane" in html
-    assert "yaml-recorded-pane" in html
-    assert "yaml-refresh" not in html
-    assert "yaml-copy" not in html
-    assert "yaml-input-viewer" in html
-    assert "yaml-recorded-viewer" in html
-    yaml_title_style = styles[styles.index(".yaml-case-title {") : styles.index("}", styles.index(".yaml-case-title {"))]
-    assert "line-clamp: 2" in yaml_title_style
-    assert "line-clamp: 3" not in yaml_title_style
-    assert "yaml-placeholder" not in html
-    assert "loadInputYaml" in script
-    assert "loadRecordedYaml" in script
-    assert "async function loadExistingRun()" in script
-    assert "api('/runs/load', { method: 'POST'" in script
-    assert "function setLoadRunControlsDisabled" in script
-    assert "function resetLoadRunForm" in script
-    assert "state.loadedRunId" in script
-    assert "existingRun = false" in script
-    assert "await loadRecordedYaml(runId, availability.recordedYaml, { existingRun: true })" in script
-    assert "async function loadExistingRunProgress(runId)" in script
-    assert "api(`/runs/${encodeURIComponent(runId)}/progress`)" in script
-    assert "appendProgress(eventLabel(event), event.sequence, eventDetails(event), eventStatus(event), event)" in script
-    assert "No persisted progress events are available for this run." in script
-    assert "Loaded existing run:" not in script
-    assert "els.loadRunPath.addEventListener('keydown'" in script
-    assert "els.loadRunCancel.addEventListener('click'" in script
-    assert "state.loadedRunId = null" in script
-    assert "showYamlView" in script
-    assert "copyActiveYaml" not in script
-    assert "renderYamlDisplay" in script
-    assert "renderYamlContent" not in script
-    assert "highlightYamlLine" not in script
-    assert "renderYamlCaseTitle" in script
-    assert "renderYamlCaseSummary" in script
-    assert "[metadata.platform, metadata.schemaVersion]" not in script
-    assert "renderYamlSteps" in script
-    assert "renderYamlStep" in script
-    assert "card.dataset.yamlStepIndex" in script
-    assert "card.dataset.yamlAction" in script
-    assert "card.dataset.yamlActionKey" in script
-    assert "normalizeYamlActionName" in script
-    assert "renderYamlParams" in script
-    assert "renderYamlNestedParams" in script
-    assert "formatYamlValue" in script
-    assert "setRecordedYamlNoContent" in script
-    assert "api(`/yaml/input?path=${encodeURIComponent(path)}`)" in script
-    assert "setYamlInputStatus('', 'success')" in script
-    assert "message === 'No YAML loaded.' ? '' : message" in script
-    assert "clearYamlInput('YAML path is required.')" not in script
-    assert "renderYamlEmpty(els.yamlInputViewer, error.message)" not in script
-    assert "renderYamlEmpty(els.yamlInputViewer, '')" in script
-    assert "if (!message) return" in script
-    assert "yaml.resolvedPath || path" not in script
-    assert "element.hidden = !message" in script
-    assert "api(`/yaml/recorded/${encodeURIComponent(runId)}`)" in script
-    assert "await loadRecordedYaml(progress.result.runId, progress.result.recording || null)" in script
-    assert "recordedYamlLoaded" not in script
-    assert "return Boolean(yaml.content)" not in script
-    assert "setYamlRecordedStatus(recordingStatusSummary" not in script
-    assert "setYamlRecordedStatus('No recorded YAML yet.'" not in script
-    assert "state.yamlInputContent" in script
-    assert "state.yamlRecordedContent" in script
-    assert "state.yamlInputLastPreviewPath" in script
-    assert "selectedYamlRegion" in script
-    assert "selectedYamlStepCard" in script
-    assert "selectedYamlCaseSummary" in script
-    assert "selectedYamlCaseTitle" in script
-    assert "activeYamlStepCard" in script
-    assert "activeYamlStepClearTimer" in script
-    assert "YAML_SELECTABLE_REGION_SELECTOR" in script
-    assert "yamlPathRow" in script
-    assert "loadRunToggle" in script
-    assert "loadRunForm" in script
-    assert "executionSection" in script
-    assert "yamlTabs" in script
-    assert "els.executionSection.hidden = false" in script
-    assert "els.yamlCopy" not in script
-    assert "els.yamlInputTab.hidden = true" in script
-    assert "els.yamlRecordedTab.hidden = false" in script
-    assert "els.yamlInputTab.hidden = false" in script
-    assert "els.yamlRecordedTab.hidden = true" in script
-    assert "const progressAvailable = !els.yamlProgressTab.hidden" in script
-    assert "if (viewName === 'progress' && progressAvailable) selectedView = 'progress'" in script
-    assert "els.progressPane.hidden = !showProgress" in script
-    assert "els.yamlPathRow.hidden = !hasInputYaml" in script
-    assert "els.caseYaml.disabled = !hasInputYaml || Boolean(state.currentRequestId)" in script
-    assert "yamlRefresh" not in script
-    assert "els.yamlInputTab.hidden = true" in script
-    assert "els.yamlInputTab.hidden = false" in script
-    assert "if (mode === 'goal')" in script
-    assert "showYamlView('progress')" in script
-    assert "function syncYamlTabOrder(mode)" in script
-    assert "mode === 'goal' || mode === 'yaml'" in script
-    assert ".load-run-form" in styles
-    assert ".load-run-actions" in styles
-    assert "? [els.yamlProgressTab, els.yamlInputTab, els.yamlRecordedTab]" in script
-    assert ": [els.yamlInputTab, els.yamlRecordedTab, els.yamlProgressTab]" in script
-    assert "showYamlView('recorded')" in script
-    assert "Input YAML inactive in Goal mode" not in script
-    assert "loadInputYaml();" in script
-    assert "clipboard" not in script
-    assert "execCommand('copy')" not in script
-    assert "clearSelectedYamlRegion" in script
-    assert "function clearSelectedYamlRegion(root = null)" in script
-    assert "if (root && state.selectedYamlRegion && !root.contains(state.selectedYamlRegion)) return" in script
-    assert "clearStepArtifactPreview" in script
-    assert "selectYamlRegion" in script
-    assert "handleYamlRegionClick" in script
-    assert "document.addEventListener('click', handleYamlRegionClick)" in script
-    assert "if (state.currentRequestId || state.finishingRun) return" in script
-    assert script.count("if (state.currentRequestId || state.finishingRun) return") >= 3
-    assert "if (els.yamlInputViewer.contains(region) && currentRunMode() !== 'strict-yaml') return" in script
-    assert "if (!runId) return" in script
-    assert "els.yamlRecordedViewer.contains(region)" in script
-    assert "const stepCard = region.closest('.yaml-step-card')" in script
-    assert "const caseSummary = region.closest('.yaml-case-summary')" in script
-    assert "const caseTitle = region.closest('.yaml-case-title-row')" in script
-    assert "if (stepCard && stepCard !== region) stepCard.classList.add('yaml-region-selected')" in script
-    assert "if (caseSummary && caseSummary !== region) caseSummary.classList.add('yaml-region-selected')" in script
-    assert "state.selectedYamlCaseTitle.classList.add('yaml-region-selected')" in script
-    assert "execution-section" in styles
-    assert "flex: 1 1 auto" in styles
-    assert "min-height: 320px" in styles
-    assert "--control-panel-width: clamp(320px, 32vw, 520px)" in styles
-    assert "grid-template-columns: minmax(300px, var(--control-panel-width)) 8px minmax(0, 1fr)" in styles
-    assert "panel-resizer" in styles
-    assert "cursor: col-resize" in styles
-    assert "yaml-tabs" in styles
-    assert "width: fit-content" in styles
-    assert "border-bottom: 1px solid #d8dee8" in styles
-    assert ".yaml-tab-button.active::after" in styles
-    assert "box-shadow: 0 1px 2px rgba(15, 23, 42, 0.12)" not in styles
-    assert "run-input-row" in styles
-    assert "grid-template-columns: minmax(0, 1fr) auto" in styles
-    assert ".run-input-row .yaml-path-row" in styles
-    assert ".run-input-row #run-selected" in styles
-    assert "grid-column: 1 / -1" in styles
-    assert "justify-self: end" in styles
-    assert "height: calc(100vh - 24px)" in styles
-    assert "yaml-viewer" in styles
-    assert "yaml-placeholder" not in styles
-    assert "max-height: min(32vh, 330px)" not in styles
-    assert "yaml-code-row" not in styles
-    assert "yaml-line-number" not in styles
-    assert "yaml-case-summary" in styles
-    assert ".yaml-case-summary:hover" in styles
-    assert ".yaml-case-summary.yaml-region-selected" in styles
-    assert "yaml-case-title-row" in styles
-    assert ".yaml-case-title-row:hover" in styles
-    assert ".yaml-case-title-row.yaml-region-selected" in styles
-    assert "background: #d7eaff" in styles
-    assert "box-shadow: inset 3px 0 0 #93c5fd" in styles
-    assert "position: sticky" in styles
-    assert "top: 0" in styles
-    assert "z-index: 1" in styles
-    assert "border-bottom: 1px solid #d8e8fb" in styles
-    assert "background: #eef6ff" in styles
-    assert "color: #0f4c81" in styles
-    assert "-webkit-line-clamp: 2" in styles
-    assert "title.title = title.textContent" in script
-    assert "yaml-metadata-grid" in styles
-    assert ".yaml-metadata-item:hover" in styles
-    assert ".yaml-metadata-item.yaml-region-selected" in styles
-    assert "yaml-chip" in styles
-    assert "yaml-step-card" in styles
-    assert ".yaml-step-card:hover" in styles
-    assert ".yaml-step-card:focus-within" in styles
-    assert ".yaml-step-card.yaml-region-selected" in styles
-    assert "yaml-step-header" in styles
-    assert ".yaml-step-card:hover .yaml-step-header" in styles
-    assert ".yaml-step-card.yaml-region-selected .yaml-step-header" in styles
-    assert ".yaml-step-card.yaml-region-selected .yaml-step-index" in styles
-    assert ".yaml-step-card.yaml-step-card-active" in styles
-    assert "color: #0f3f8a" in styles
-    assert "font-size: 13px" in styles
-    assert "step-artifact-preview" in styles
-    assert "step-artifact-screenshot-row" in styles
-    assert "step-artifact-compare" in styles
-    assert "step-artifact-text-card" in styles
-    assert "isXmlStepArtifact" in script
-    assert "step-artifact-xml" in script
-    assert 'payload.get("xml")' in (Path(__file__).parents[1] / "fsq_agent" / "adapters" / "control_plane" / "playground" / "_server.py").read_text(encoding="utf-8")
-    assert "pre.step-artifact-xml" in styles
-    assert "border-left-color: #86efac" in styles
-    assert "step-artifact-connector" in styles
-    assert "before / after" not in script
-    assert ".step-artifact-connector::before" in styles
-    assert ".step-artifact-connector::after" in styles
-    assert "rotate(45deg)" in styles
-    assert "step-artifact-arrow" not in styles
-    assert "border-radius: 999px" in styles
-    assert "arrow.textContent = '->'" not in script
-    assert "border-left: 3px solid #bfdbfe" in styles
-    assert "white-space: pre" in styles
-    assert "tab-size: 2" in styles
-    assert "background: #0f172a" not in styles
-    assert "cursor: pointer" in styles
-    assert "yaml-action-name" in styles
-    assert "width: fit-content" in styles
-    assert "border-radius: 6px" in styles
-    assert "yaml-action-name-setup" in styles
-    assert "yaml-action-name-action" in styles
-    assert "yaml-action-name-assertion" in styles
-    assert "yaml-action-name-teardown" in styles
-    assert "yaml-step-kind" not in styles
-    assert "yaml-step-kind" not in script
-    assert "yaml-param-row" in styles
-    assert ".yaml-param-row:hover" in styles
-    assert ".yaml-param-row.yaml-region-selected" in styles
-    assert "yaml-param-nested" in styles
-    assert "yaml-param-row-nested" in styles
-    assert "yaml-param-value-null" in styles
-    assert "font-style: italic" in styles
-    assert "yaml-param-value-secret" in styles
-
-
-def test_playground_progress_prefers_sse_with_polling_fallback() -> None:
-    static_dir = Path(__file__).parents[1] / "frontend" / "playground"
-    script = (static_dir / "playground.js").read_text(encoding="utf-8")
-    assert "window.EventSource" in script
-    assert "new EventSource(`/task-stream/${encodeURIComponent(requestId)}`)" in script
-    assert "state.progressStream" in script
-    assert "stream.onmessage" in script
-    assert "function applyProgress(progress)" in script
-    assert "function stopProgressUpdates()" in script
-    assert "window.setInterval(refreshProgress, PROGRESS_POLL_INTERVAL_MS)" in script
diff --git a/vite.config.js b/vite.config.js
index 2572afaf..db40ee86 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -2,31 +2,9 @@ import { resolve } from 'node:path';
 import { defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 
-const apiPrefixes = [
-  '/cancel',
-  '/execute',
-  '/preview',
-  '/replay',
-  '/replay-video',
-  '/replay-video-file',
-  '/reports',
-  '/runs',
-  '/runtime-info',
-  '/screenshot',
-  '/session',
-  '/status',
-  '/step-artifacts',
-  '/task-progress',
-  '/task-stream',
-  '/yaml',
-];
-
 export default defineConfig(({ mode }) => {
   const env = loadEnv(mode, process.cwd(), '');
-  const playgroundOrigin = env.FSQ_PLAYGROUND_API_ORIGIN || 'http://127.0.0.1:8878';
   const controlPlaneOrigin = env.FSQ_CONTROL_PLANE_API_ORIGIN || 'http://127.0.0.1:8879';
-  const proxy = Object.fromEntries(apiPrefixes.map((prefix) => [prefix, { target: playgroundOrigin }]));
-  proxy['/api/control-plane'] = { target: controlPlaneOrigin, changeOrigin: false };
 
   return {
     appType: 'mpa',
@@ -34,7 +12,9 @@ export default defineConfig(({ mode }) => {
     plugins: [react()],
     server: {
       host: '127.0.0.1',
-      proxy,
+      proxy: {
+        '/api/control-plane': { target: controlPlaneOrigin, changeOrigin: false },
+      },
     },
     build: {
       outDir: resolve(import.meta.dirname, '.frontend-dist'),
@@ -42,7 +22,6 @@ export default defineConfig(({ mode }) => {
       manifest: true,
       rollupOptions: {
         input: {
-          playground: resolve(import.meta.dirname, 'frontend/playground/index.html'),
           controlPlane: resolve(import.meta.dirname, 'frontend/control-plane/index.html'),
         },
       },