diff --git a/docs/open-collection-gap-analysis/AGENT_GOAL_PROMPTS.md b/docs/open-collection-gap-analysis/AGENT_GOAL_PROMPTS.md
index a1c45ca..89a28cc 100644
--- a/docs/open-collection-gap-analysis/AGENT_GOAL_PROMPTS.md
+++ b/docs/open-collection-gap-analysis/AGENT_GOAL_PROMPTS.md
@@ -64,6 +64,12 @@ If an agent host does not inject the project-local skills, tell the agent to rea
 /goal Complete OC-080 runtime lifecycle support for WebSocket and unary gRPC using $missio-agent-coordination, $missio-runtime-implementer, and $missio-demo-server-fixtures without stopping until before/after scripts, assertions, tests, actions, runtime variable mutation, response UI/tool output, local demo WebSocket and gRPC runtime fixtures, AGENT_PROGRESS updates, and complete automated unit, integration, security, failure-path, and cleanup tests are implemented and passing.
 ```
 
+## Runtime Authoring UX
+
+```text
+/goal Complete OC-110 runtime authoring UX using $missio-agent-coordination and $missio-editor-schema-implementer without stopping until the visual request editor can create, edit, disable, reorder, and remove runtime scripts, tests, assertions, and set-variable actions; preserves schema-valid YAML for HTTP, GraphQL, WebSocket, and gRPC requests; includes user-verifiable demo guidance; updates AGENT_PROGRESS; and complete automated editor, model, validation, round-trip, and regression tests are implemented and passing.
+```
+
 ## gRPC Streaming
 
 ```text
@@ -73,5 +79,5 @@ If an agent host does not inject the project-local skills, tell the agent to rea
 ## Final Integration
 
 ```text
-/goal Complete final OpenCollection compatibility integration across all Missio tracks using $missio-agent-coordination without stopping until all OC-000 through OC-100 task rows are Done, all GitButler branches or PRs are linked, the full test suite and required fixture integration tests pass, documentation is consistent, and AGENT_PROGRESS.md contains final verification evidence.
+/goal Complete final OpenCollection compatibility integration across all Missio tracks using $missio-agent-coordination without stopping until all OC-000 through OC-110 task rows are Done, all GitButler branches or PRs are linked, the full test suite and required fixture integration tests pass, documentation is consistent, and AGENT_PROGRESS.md contains final verification evidence.
 ```
diff --git a/docs/open-collection-gap-analysis/AGENT_PROGRESS.md b/docs/open-collection-gap-analysis/AGENT_PROGRESS.md
index 149a6bb..97dba6b 100644
--- a/docs/open-collection-gap-analysis/AGENT_PROGRESS.md
+++ b/docs/open-collection-gap-analysis/AGENT_PROGRESS.md
@@ -64,10 +64,11 @@ Use full branch names for stacking existing branches with `but move <child-branc
 | OC-040 | Scripts, tests, assertions, actions | Done | Codex | feature/oc-040-runtime-scripting-testing (ru); primary implementation commit `Add OC-040 runtime scripting support`; shared runtime dependency commits `Add OC-010 GraphQL request support`, `Wire shared runtime execution services`, and `Add OC-030 gRPC unary protobuf support` on the applied stack | Satisfied by `test/runtimeExecutionService.test.ts`, `test/sendRequestTool.test.ts`, `test/responseProvider.test.ts`, and foundation/runtime regressions: lifecycle ordering, protocol-neutral context, sandbox-denied filesystem/process/network globals, console/test diagnostics, assertions, JSON selector `set-variable` actions, runtime variable mutation, HTTP request mutation, Runtime response tab/provider/tool output, fixture-backed demo runtime routes/requests, deterministic pass/fail diagnostics, demo collection validation, and shared HTTP no-op regression coverage. | `npx vitest run test/openCollectionFoundation.test.ts test/runtimeExecutionService.test.ts test/sendRequestTool.test.ts test/responseProvider.test.ts` passed 4 files/24 tests; `npm run compile` passed; `npm test` passed 20 files/380 tests; `npm run build` passed; `node scripts/validate-collection.js examples/demo-api` passed 32/32 files; live `node examples/demo-api/server.js` smoke verified `POST /runtime/echo`, `POST /runtime/token`, and `GET /runtime/assert-fail`. | 2026-06-14 23:42 NZT | OC-040 complete; no-change GitButler retry commits were removed during supervisor stack cleanup. |
 | OC-050 | Auth, proxy, mTLS, transport completion | Done | Codex | feature/oc-050-auth-transport (ut), stacked on feature/oc-100-request-type-ux; implementation commit `93c1d0d`; schema round-trip dependency commits `4cfa36b` and `3a5f2b7` on feature/oc-060-schema-roundtrip-validation | Satisfied by `test/httpClient.test.ts` and `test/grpcSupport.test.ts`: API-key query auth and export parity, OAuth2 token header/query placement and additional token params, redirect follow/max handling, proxy auth and bypass, collection client certificates for mTLS success/failure, HTTP/WebSocket/gRPC unsupported-auth diagnostics, dry-run inherited headers/query params, and local AuthTransport demo fixtures. | `npx vitest run test/httpClient.test.ts` passed 19 tests; `npx vitest run test/grpcSupport.test.ts` passed 14 tests; `npm run compile` passed; `node scripts/validate-collection.js examples/demo-api` passed 42/42 files; `npm test` passed 21 files/406 tests; `npm run build` passed; live demo smoke passed API-key query, OAuth token/query placement, redirects, proxy auth, and mTLS. | 2026-06-15 00:27 NZT | OC-050 complete. Remaining unassigned IDs after the implementation commit are parallel OC-090/OC-100/shared polish, not OC-050-owned runtime work. |
 | OC-060 | Schema round-trip and validation | Done | Codex | feature/oc-060-schema-roundtrip-validation (sc), stacked on feature/oc-000-foundation-dispatch (fo); implementation commit `166c297` | Add golden no-op editor/serializer round-trip tests for schema-valid HTTP, GraphQL, WebSocket, gRPC, folder, environment, and collection fixtures; add validation tests proving protocol-aware request subschema selection, workspace validation in collection reports, protocol-labelled diagnostics, unknown-field preservation, and non-HTTP files not gaining `http` keys. Run targeted validation/editor/service tests plus existing touched HTTP/import-export/editor regressions. | `npx vitest run test/schemaRoundTrip.test.ts test/validationService.test.ts` passed (8 tests); `npm test` passed (15 files, 341 tests); `npm run compile` passed; `npm run build` passed. | 2026-06-14 22:30 NZT | OC-060 complete and committed; no OC-060-owned unassigned changes remain after implementation commit. |
-| OC-070 | Request creation, import/export, snippet, and Copilot surface polish | In Progress | Codex | feature/oc-070-surface-polish (rf) | Reuse OC-100 protocol templates; add/extend automated tests for protocol-specific request creation regressions, tree/CodeLens/command protocol identity, import/export unsupported diagnostics, HTTP snippet parity plus explicit non-HTTP snippet diagnostics, Copilot get/list/dry-run/send protocol preservation and redaction, and shared round-trip/validation regressions. | Not run yet. | 2026-06-15 00:44 NZT | Audit creation/import/export/snippet/Copilot surfaces, add failing coverage, implement the smallest coherent polish slice, then run targeted and full automated suites. |
-| OC-080 | Runtime lifecycle for WebSocket and unary gRPC | Unclaimed | - | - | - | - | - | Start after OC-040 and protocol executors; coordinate with OC-070 if Copilot runtime output changes. |
+| OC-070 | Request creation, import/export, snippet, and Copilot surface polish | Review Ready | Codex | feature/oc-070-surface-polish (rf); implementation commit `f9a5a55`; former shared-file staged set `opx`/`ku` was cleared by supervisor hunk-level GitButler absorb into owning dependency commits `0742dbc`, `395ddf0`, `8c236b4`, and `251408f` | Reuse OC-100 protocol templates; add/extend automated tests for protocol-specific request creation regressions, tree/CodeLens/command protocol identity, import/export unsupported diagnostics, HTTP snippet parity plus explicit non-HTTP snippet diagnostics, Copilot get/list/dry-run/send protocol preservation and redaction, and shared round-trip/validation regressions. | `npm run compile` passed; targeted `npx vitest run test/oc070SurfacePolish.test.ts test/requestTypeUx.test.ts test/sendRequestTool.test.ts test/postmanImporter.test.ts test/openApiImporter.test.ts test/snippetExporter.test.ts test/openCollectionFoundation.test.ts test/graphqlSupport.test.ts test/webSocketSupport.test.ts test/grpcSupport.test.ts test/schemaRoundTrip.test.ts test/validationService.test.ts` passed 12 files/153 tests; `node scripts/validate-collection.js examples/demo-api` passed 41/41 files; `npm test` passed 22 files/415 tests; `npm run build` passed. | 2026-06-15 01:35 NZT | Review OC-070 from commit `f9a5a55` plus the absorbed shared-surface hunks now present in the applied dependency stack; `zz` is clean and no OC-070 staged set remains. |
+| OC-080 | Runtime lifecycle for WebSocket and unary gRPC | Done | Codex | supervisor/add-runtime-authoring-ux-task (ho); implementation commit `ea7383b`; completion/ledger commit `251408f`; supervisor cleanup commit `878063b`; supervisor review ledger is the top `ho` commit | Satisfied by `test/webSocketSupport.test.ts`, `test/grpcSupport.test.ts`, `test/sendRequestTool.test.ts`, and `test/responseProvider.test.ts`: WebSocket and unary gRPC before/after runtime lifecycle order, before-script header/metadata/body mutation, after-response scripts/tests/assertions/actions, runtime variable mutation, sandbox-denial security diagnostics, failure-path response preservation, cancellation/cleanup, response provider rendering, Copilot tool output, and schema-valid local demo WebSocket/gRPC runtime fixtures. | `npx vitest run test/webSocketSupport.test.ts test/grpcSupport.test.ts test/sendRequestTool.test.ts test/responseProvider.test.ts` passed 4 files/50 tests; `npm run compile` passed; `node scripts/validate-collection.js examples/demo-api` passed 44/44 files; live local WebSocket/gRPC runtime smoke passed with `LIVE_WS_RUNTIME_SMOKE ok` and `LIVE_GRPC_RUNTIME_SMOKE ok`; `npm test` passed 22 files/428 tests; `npm run build` passed; VSIX packaged and installed as `missio.missio@0.7.7`. | 2026-06-15 01:42 NZT | Supervisor review found no blocking OC-080 issues; GitButler `zz` is clean and the extension is installed from the reviewed stack. |
 | OC-090 | gRPC streaming | Done | Codex | feature/oc-090-grpc-streaming (am), stacked on applied OC-030 unary/protobuf work; implementation commits `84cf254` and `c462d51` | Implemented method-type-aware unary, server-streaming, client-streaming, and bidirectional-streaming gRPC execution with schema-native ordered message sequences, proto method-type validation, cancellation cleanup, partial stream error retention, response stream summaries, local demo streaming proto/server/routes, and regression tests for unary dispatch, validation, round-trip safety, failure paths, and cleanup. | `npm run compile` passed; `npx vitest run test/grpcSupport.test.ts test/schemaRoundTrip.test.ts test/validationService.test.ts test/responseProvider.test.ts test/sendRequestTool.test.ts` passed 5 files/33 tests; `node scripts\validate-collection.js examples\demo-api` passed 42/42 files; `npm test` passed 21 files/405 tests; `npm run build` passed. Live hidden `node examples/demo-api/grpc-server.js` smoke verified server/client/bidi/error streams. | 2026-06-15 00:21 NZT | OC-090 complete in the verified worktree. Preserve remaining unassigned parallel/change-routing IDs called out in the OC-090 log; do not commit them to unrelated branches. |
 | OC-100 | Request type UX | Done | Codex | feature/oc-100-request-type-ux (g0 after restack), stacked on supervisor/add-request-type-ux-task; implementation commit `5cb05a3` | Satisfied by `test/requestTypeUx.test.ts`: schema-valid HTTP/GraphQL/WebSocket/gRPC starter templates, actual `missio.newRequest` protocol picker/write/open flow, YAML and editor-model round-trip safety, no stale protocol roots, gRPC same-protocol editor guard, and read-only protocol chip shell. Shared regressions cover HTTP/GraphQL/WebSocket/gRPC editor, validation, command/tool, and protocol behavior. Switcher/conversion helpers are intentionally out of scope because the benchmarked tools emphasize protocol choice at creation and Postman locks saved request protocols. | `npx vitest run test/requestTypeUx.test.ts test/schemaRoundTrip.test.ts test/openCollectionFoundation.test.ts test/validationService.test.ts` passed 4 files/25 tests; targeted protocol suite passed 8 files/68 tests; `npm run compile` passed; `npm test` passed 21 files/405 tests; `node scripts/validate-collection.js examples/demo-api` passed 42/42 files; `npm run build` passed. | 2026-06-15 00:15 NZT | OC-100 complete; no saved-request switcher was added by product decision and benchmark alignment. Remaining unassigned changes are parallel OC-050/OC-090 work, not OC-100. |
+| OC-110 | Runtime authoring UX | Unclaimed | - | - | - | - | - | Start after OC-070 settles request editor surface churn; coordinate with OC-080 if non-HTTP runtime response shapes affect authoring examples. |
 
 ## Dependency Map
 
@@ -84,6 +85,7 @@ Use full branch names for stacking existing branches with `but move <child-branc
 | OC-080 | OC-040 runtime engine, OC-020 WebSocket executor, OC-030 gRPC unary executor | Runtime parity for supported protocols |
 | OC-090 | OC-030 gRPC unary/protobuf support | Full gRPC protocol compatibility |
 | OC-100 | OC-000 type guards, OC-010/OC-020/OC-030 protocol editor foundations; OC-050 if auth/template fields change | Request creation and visible type identity completeness |
+| OC-110 | OC-040 runtime schema/engine, OC-060 round-trip safety, OC-100 editor shell; coordinate with OC-070 and OC-080 | Visual authoring completeness for runtime scripts, tests, assertions, and actions |
 
 ## Shared Decisions
 
@@ -99,6 +101,13 @@ Record cross-cutting decisions here so parallel agents do not rediscover them.
 
 ### Supervisor Reports
 
+- 2026-06-15 00:57 NZT - Codex: Added OC-110 as a separate runtime authoring UX task after confirming snippet export belongs to OC-070 and non-HTTP runtime execution belongs to OC-080.
+  GitButler: planning update is on `supervisor/add-runtime-authoring-ux-task`, stacked on `supervisor/oc-050-090-100-audit`; active OC-070 implementation changes in `zz` were not edited or committed.
+  Coverage: documentation-only planning change; no runtime behavior changed.
+  Changed: `docs/open-collection-gap-analysis/README.md`, `AGENT_GOAL_PROMPTS.md`, `AGENT_PROGRESS.md`, and `tasks/11-runtime-authoring-ux.md`.
+  Verified: reference checks for `OC-110`, `runtime authoring`, and `11-runtime-authoring-ux` completed; implementation tests not required for docs-only task creation.
+  Next: launch OC-110 after OC-070 settles request editor surface churn; coordinate with OC-080 if non-HTTP runtime examples or response shapes change.
+
 - 2026-06-15 00:34 NZT - Codex: Reviewed completed OC-050, OC-090, and OC-100 work, fixed two supervisor-found issues, built, packaged, and installed the extension.
   GitButler: review work is on `supervisor/oc-050-090-100-audit`, stacked on `feature/oc-050-auth-transport`. Earlier audit commits are `2595b21` (`Finalize streaming tool polish`) and `5c53b63` (`Fix inherited HTTP boolean settings`). The workspace was clean before this final ledger/package-hygiene update except the intentional docs and `.vscodeignore` changes.
   Findings fixed: OC-050 inherited `settings.followRedirects: inherit` and `settings.encodeUrl: inherit` were resolving to `false`; added a regression test in `test/httpClient.test.ts`. Default VSIX packaging failed because `examples/demo-api/fixtures/mtls-client.key` was included; `.vscodeignore` now excludes demo fixture private keys while leaving source demo fixtures usable.
@@ -287,8 +296,49 @@ Record cross-cutting decisions here so parallel agents do not rediscover them.
   Verified: `but status -fv`, OC-070 task page, and current progress ledger reviewed; implementation tests not run yet.
   Next: audit the creation/import/export/snippet/Copilot code and tests, add failing coverage, then implement OC-070 surface polish without touching the OC-100 icon follow-up.
 
+- 2026-06-15 01:00 NZT - Codex: Completed OC-070 request creation, import/export, snippet, and Copilot surface polish with automated coverage passing.
+  GitButler: primary implementation commit is `b973a8d` (`Complete OC-070 protocol surface polish`) on `feature/oc-070-surface-polish` (rf). Shared-file OC-070 hunks in `src/copilot/tools/sendRequestTool.ts` and `src/panels/requestPanel.ts` are staged to `rf` as staged set `i1` (`opx`, `ku`). Multiple `but commit rf ...` attempts produced empty commits, and `but absorb rf --dry-run` would rewrite dependency commits `c30cdec`, `d1bbdc7`, and `26cd36c`; those hunks were left staged to avoid mutating completed dependency branches.
+  Coverage: `test/oc070SurfacePolish.test.ts` covers protocol starter/tree/CodeLens baselines, Copilot get/list/dry-run/send protocol preservation and redaction, unsupported request import detection, unsupported non-HTTP snippet diagnostics, Postman runtime script preservation plus unsupported event diagnostics, and OpenAPI source/webhook/callback diagnostics. Existing request type, protocol executor, importer, snippet, validation, and round-trip suites were re-run.
+  Changed: `README.md`, `docs/mcp-server-design.md`, `package.json`, `src/commands/importCommands.ts`, `src/copilot/tools/getRequestTool.ts`, `src/copilot/tools/sendRequestTool.ts`, `src/importers/index.ts`, `src/importers/openApiImporter.ts`, `src/importers/postmanImporter.ts`, `src/importers/requestImporters.ts`, `src/importers/types.ts`, `src/panels/requestPanel.ts`, `src/services/snippetExporter.ts`, `test/oc070SurfacePolish.test.ts`, and this ledger.
+  Verified: `npm run compile` passed; targeted `npx vitest run test/oc070SurfacePolish.test.ts test/requestTypeUx.test.ts test/sendRequestTool.test.ts test/postmanImporter.test.ts test/openApiImporter.test.ts test/snippetExporter.test.ts test/openCollectionFoundation.test.ts test/graphqlSupport.test.ts test/webSocketSupport.test.ts test/grpcSupport.test.ts test/schemaRoundTrip.test.ts test/validationService.test.ts` passed 12 files/153 tests; `node scripts/validate-collection.js examples/demo-api` passed 41/41 files; `npm test` passed 22 files/415 tests; `npm run build` passed.
+  Next: review `b973a8d` plus staged set `i1`; if the team wants every shared-file hunk as a normal commit, resolve GitButler hunk-locking without absorbing into older dependency commits.
+
+- 2026-06-15 01:35 NZT - Codex Supervisor: Cleared the stuck OC-070 shared-surface hunks after direct `but commit`, `but stage`, and branch-targeted amend paths kept creating empty commits.
+  GitButler: `src/copilot/tools/sendRequestTool.ts` and `src/panels/requestPanel.ts` are no longer staged or unassigned. GitButler hunk ownership required hunk-level `but absorb`, which rewrote the owning applied commits to `0742dbc` (foundation request panel hunk), `395ddf0` (GraphQL/send tool overlap hunks), `8c236b4` (streaming/gRPC dry-run redaction hunks), and `251408f` (top supervisor protocol-output/import hunks). Empty retry commits and empty temporary branches were removed with `but uncommit -d` and `but clean`.
+  Changed: GitButler stack metadata/commit routing only; no source edits were made beyond committing the already-present hunks.
+  Verified: `but status -fv` shows `zz` clean; `git diff -- src/copilot/tools/sendRequestTool.ts src/panels/requestPanel.ts` is empty.
+  Next: review OC-070 from `f9a5a55` plus the now-absorbed shared hunks in the applied stack; do not look for staged IDs `opx`/`ku`.
+
 ### OC-080 Runtime Lifecycle For Non-HTTP Protocols
 
+- 2026-06-15 01:02 NZT - Codex: Claimed OC-080 and recorded the coverage plan before implementation.
+  GitButler: `feature/oc-080-runtime-non-http-protocols` (no). Current `but status -fv` shows pre-existing staged OC-070 shared-surface hunks in `docs/open-collection-gap-analysis/AGENT_PROGRESS.md`, `src/copilot/tools/sendRequestTool.ts`, and `src/panels/requestPanel.ts`; preserve those and route only OC-080-owned hunks/files.
+  Coverage: planned unit/integration tests for WebSocket and unary gRPC before/after runtime lifecycle order, protocol-neutral request/response context shape, scripts/tests/assertions/actions, runtime variable mutation before resolution and after response actions, sandbox denial/security diagnostics, failure-path response preservation, cancellation/cleanup, response provider rendering, Copilot tool output, schema-valid local demo WebSocket/gRPC runtime fixtures, compile, full suite, demo validation, build, and live local fixture smoke tests.
+  Changed: `docs/open-collection-gap-analysis/AGENT_PROGRESS.md`.
+  Verified: `but status -fv`, OC-080 task page, demo server, and demo collection reviewed; implementation tests not run yet.
+  Next: inspect `runtimeExecutionService`, `requestExecutionService`, `webSocketClient`, `grpcClient`, response/provider/tool surfaces, and existing protocol tests before adding failing OC-080 coverage.
+
+- 2026-06-15 01:24 NZT - Codex: Completed OC-080 runtime lifecycle parity for WebSocket and unary gRPC.
+  GitButler: implementation commit `95d05d8` (`Add OC-080 non-HTTP runtime lifecycle`) landed on `supervisor/add-runtime-authoring-ux-task` (ho) after repeated `but commit` attempts on `feature/oc-080-runtime-non-http-protocols` (no) and `feature/oc-080-runtime-lifecycle-impl` (if) failed with merge-base conflicts against the supervisor and OC-070 stacks. Remaining staged `opx`/`ku` are pre-existing OC-070 shared-surface hunks and were preserved.
+  Coverage: added WebSocket and unary gRPC runtime lifecycle tests for before-script request mutation, after-response scripts/tests/assertions/actions, runtime variable mutation, sandbox-denial security behavior, protocol failure responses, cancellation cleanup, response provider runtime rendering, Copilot tool runtime output, and committed demo fixture smoke coverage.
+  Changed: `src/services/runtimeExecutionService.ts`, `src/services/requestExecutionService.ts`, `src/models/types.ts`, `schema/missio-extensions.json`, `schema/opencollectionschema.json`, `examples/demo-api/server.js`, `examples/demo-api/WebSocket/runtime-lifecycle.yml`, `examples/demo-api/WebSocket/runtime-assertion-failure.yml`, `examples/demo-api/gRPC/runtime-unary-lifecycle.yml`, `test/webSocketSupport.test.ts`, `test/grpcSupport.test.ts`, `test/sendRequestTool.test.ts`, `test/responseProvider.test.ts`, and this ledger.
+  Verified: targeted `npx vitest run test/webSocketSupport.test.ts test/grpcSupport.test.ts test/sendRequestTool.test.ts test/responseProvider.test.ts` passed 4 files/50 tests; `npm run compile` passed; `node scripts/validate-collection.js examples/demo-api` passed 44/44 files; live local `node examples/demo-api/server.js` plus `node examples/demo-api/grpc-server.js` smoke passed with `LIVE_WS_RUNTIME_SMOKE ok` and `LIVE_GRPC_RUNTIME_SMOKE ok`; `npm test` passed 22 files/428 tests; `npm run build` passed.
+  Next: review OC-080 from commit `95d05d8`; keep OC-070 staged surface hunks out of runtime lifecycle review unless the team deliberately resolves that routing separately.
+
+- 2026-06-15 01:35 NZT - Codex Supervisor: Reconciled OC-080 GitButler cleanup after OC-070 staged hunk resolution.
+  GitButler: OC-080 implementation commit is now `ea7383b`; completion/ledger commit is now `251408f`. Empty `feature/oc-080-runtime-lifecycle-impl` and `feature/oc-080-runtime-non-http-protocols` branches were removed with `but clean`.
+  Changed: ledger status only.
+  Verified: `but status -fv` shows no OC-080 empty branches and no unassigned changes.
+  Next: continue OC-080 review/build/install from `ea7383b` with `251408f` treated as supervisor ledger plus absorbed shared-surface cleanup.
+
+- 2026-06-15 01:42 NZT - Codex Supervisor: Reviewed OC-080 and found no blocking implementation issues.
+  GitButler: working tree is clean (`zz` has no changes). Stuck OC-070 shared hunks are absorbed and the cleanup ledger is committed as `878063b`.
+  Changed: ledger status only.
+  Verified: `npm run compile` passed; targeted `npx vitest run test/webSocketSupport.test.ts test/grpcSupport.test.ts test/sendRequestTool.test.ts test/responseProvider.test.ts` passed 4 files/50 tests; `node scripts/validate-collection.js examples/demo-api` passed 44/44 files; `npm test` passed 22 files/428 tests; `npm run build` passed; `npx @vscode/vsce package --out $env:TEMP\missio-0.7.7-oc080-supervisor.vsix` passed; `code.cmd --install-extension $env:TEMP\missio-0.7.7-oc080-supervisor.vsix --force` installed `missio.missio@0.7.7`.
+  Next: OC-080 is safe to move forward; keep OC-110 as the separate runtime authoring UX follow-up.
+
+### OC-110 Runtime Authoring UX
+
 No updates yet.
 
 ### OC-090 gRPC Streaming
diff --git a/docs/open-collection-gap-analysis/README.md b/docs/open-collection-gap-analysis/README.md
index 1baa3ac..7a1eb10 100644
--- a/docs/open-collection-gap-analysis/README.md
+++ b/docs/open-collection-gap-analysis/README.md
@@ -67,6 +67,7 @@ If a scenario truly cannot be automated in this repo, document the reason, manua
 | OC-080 | Protocol Runtime Lifecycle | [08-runtime-non-http-protocols.md](tasks/08-runtime-non-http-protocols.md) | Apply scripts, assertions, tests, actions, and runtime variables to supported non-HTTP executors. |
 | OC-090 | gRPC Streaming | [09-grpc-streaming.md](tasks/09-grpc-streaming.md) | Client, server, and bidirectional gRPC streaming execution, UI, fixtures, and tests. |
 | OC-100 | Request Type UX | [10-request-type-ux.md](tasks/10-request-type-ux.md) | UI request type selection, read-only type visibility, and Bruno/Postman-aligned workflow review. |
+| OC-110 | Runtime Authoring UX | [11-runtime-authoring-ux.md](tasks/11-runtime-authoring-ux.md) | Visual editor authoring for scripts, tests, assertions, and set-variable actions. |
 
 ## Project Skills
 
@@ -92,6 +93,7 @@ OC-000 through OC-040 and OC-060 have removed most of the original HTTP-only fou
 | Importers and exporters need explicit protocol preservation or unsupported-conversion diagnostics. | [src/importers](../../src/importers) |
 | Snippet export remains HTTP-oriented and should not silently accept non-HTTP requests. | [src/services/snippetService.ts](../../src/services/snippetService.ts) |
 | Runtime scripts/assertions/actions are verified for HTTP and GraphQL-over-HTTP; WebSocket and gRPC need lifecycle parity. | [src/services/requestExecutionService.ts](../../src/services/requestExecutionService.ts) |
+| Runtime scripts/assertions/actions can run, but common authoring still requires YAML edits. | [src/webview/requestPanel.ts](../../src/webview/requestPanel.ts) |
 | gRPC unary execution exists, but streaming request types remain an explicit unsupported path. | [src/services/grpcClient.ts](../../src/services/grpcClient.ts) |
 
 ## Definition Of Done For Any Track
diff --git a/docs/open-collection-gap-analysis/tasks/11-runtime-authoring-ux.md b/docs/open-collection-gap-analysis/tasks/11-runtime-authoring-ux.md
new file mode 100644
index 0000000..66b8ef9
--- /dev/null
+++ b/docs/open-collection-gap-analysis/tasks/11-runtime-authoring-ux.md
@@ -0,0 +1,99 @@
+# OC-110 Runtime Authoring UX
+
+## Goal
+
+Make OpenCollection runtime behavior editable from Missio's visual request editor. Users should be able to create and maintain scripts, tests, assertions, and set-variable actions without hand-editing YAML for common workflows.
+
+## Current Gap
+
+OC-040 added the runtime engine and result display. OC-080 extends runtime execution to WebSocket and gRPC. The remaining gap is authoring: runtime features exist in YAML and response output, but the request editor does not provide a first-class UI for managing them.
+
+| Surface | Gap |
+| --- | --- |
+| Runtime scripts | Users must hand-edit `runtime.scripts[]` for `before-request`, `after-response`, and `tests` script code. |
+| Assertions | Users must hand-edit `runtime.assertions[]` with expression, operator, expected value, disabled state, and descriptions. |
+| Actions | Users must hand-edit `runtime.actions[]`, including `set-variable` phase, selector, target scope, and variable name. |
+| Ordering and disabled state | Users cannot reorder runtime entries or toggle them from the visual editor. |
+| YAML safety | A UI implementation must preserve unsupported-but-valid runtime fields and existing script/action data. |
+| Documentation | User-facing docs and demo notes do not yet explain visual runtime authoring workflows. |
+
+## Implementation Plan
+
+1. Audit the current runtime schema and editor serializer:
+
+| Area | Work |
+| --- | --- |
+| Schema | Review `runtime.scripts`, `runtime.assertions`, `runtime.actions`, request defaults, and top-level script files. |
+| Editor model | Confirm no-op request editor saves preserve all runtime fields, including unknown valid fields. |
+| Response UI | Confirm runtime result display remains output-only and is not conflated with authoring controls. |
+| Existing demos | Use `examples/demo-api/Runtime/` as real authoring examples. |
+
+2. Design the request editor runtime section:
+
+| Need | Expected Behavior |
+| --- | --- |
+| Runtime entry point | Add a clear request-editor section or tab for runtime behavior. |
+| Scripts | Add, remove, disable, reorder, and edit script entries with phase selection and code text. |
+| Tests | Support test script authoring as `runtime.scripts[]` entries with `type: tests`. |
+| Assertions | Add, remove, disable, reorder, and edit assertion expression/operator/expected value/description. |
+| Actions | Add, remove, disable, reorder, and edit `set-variable` actions with phase, selector method/expression, target scope, and variable name. |
+| Inheritance | Show collection/folder/request defaults clearly when available, without silently flattening inherited defaults into the request. |
+
+3. Preserve schema-native YAML:
+
+| Requirement | Behavior |
+| --- | --- |
+| No data loss | Unknown but schema-valid runtime fields survive visual no-op edits. |
+| Stable ordering | Reordering in the UI produces deterministic YAML arrays. |
+| Disabled entries | Disabled scripts/assertions/actions remain present and do not get dropped. |
+| Protocol neutrality | The authoring UI works for HTTP, GraphQL, WebSocket, and gRPC request files without adding protocol-specific roots. |
+
+4. Add documentation and user-verifiable examples:
+
+| Area | Work |
+| --- | --- |
+| Demo notes | Update runtime demo request descriptions if needed so users know what to edit and what result to expect. |
+| Wiki/docs | Document visual runtime authoring and the YAML escape hatch for advanced runtime fields. |
+| Smoke guidance | Include local demo server instructions for verifying scripts, assertions, tests, and actions. |
+
+## Dependencies
+
+| Task | Impact |
+| --- | --- |
+| OC-040 | Provides runtime engine, result model, sandbox behavior, assertions, tests, and actions. |
+| OC-060 | Provides no-op round-trip safety patterns for schema-valid runtime data. |
+| OC-070 | May touch request editor import/export surfaces; coordinate before editing shared request panel files. |
+| OC-080 | Defines non-HTTP runtime request/response shapes; authoring should remain protocol-neutral and not assume HTTP-only response data. |
+| OC-100 | Provides request type identity in the editor shell; runtime authoring should fit into that layout without competing with protocol controls. |
+
+## Acceptance Criteria
+
+| Requirement | Acceptance |
+| --- | --- |
+| Script authoring | Visual editor can create, edit, disable, remove, and reorder before-request, after-response, and test scripts. |
+| Assertion authoring | Visual editor can create, edit, disable, remove, and reorder runtime assertions with supported operators and expected values. |
+| Action authoring | Visual editor can create, edit, disable, remove, and reorder `set-variable` actions with phase, selector, and target controls. |
+| Round-trip safety | Existing runtime YAML, including disabled entries and unknown schema-valid fields, survives no-op and edited saves. |
+| Protocol neutrality | Runtime authoring works for HTTP, GraphQL, WebSocket, and gRPC request files. |
+| Usability | Users can verify common runtime workflows from the visual editor using local demo requests. |
+| Tests | Complete automated editor/model/round-trip/validation tests cover happy paths, disabled entries, ordering, preservation, and protocol regressions. |
+
+## Suggested Tests
+
+| Test | Expected Result |
+| --- | --- |
+| Add runtime script in editor model. | Saved YAML contains a schema-valid `runtime.scripts[]` entry with the selected phase and code. |
+| Add assertion and action in editor model. | Saved YAML contains schema-valid `runtime.assertions[]` and `runtime.actions[]` entries. |
+| Disable and reorder runtime entries. | Disabled state and array order persist after save/reload. |
+| No-op edit of existing runtime fixture. | Existing scripts, assertions, actions, and unknown schema-valid fields are preserved. |
+| Protocol fixture coverage. | HTTP, GraphQL, WebSocket, and gRPC requests can save runtime edits without stale protocol roots or validation failures. |
+| UI shell regression. | Runtime authoring controls render with stable labels, controls, empty states, and no overlap with response Runtime results. |
+
+## Out Of Scope
+
+| Area | Reason |
+| --- | --- |
+| Runtime execution semantics | Covered by OC-040 and OC-080. |
+| Protocol-specific snippet export | Covered by OC-070. |
+| Postman script/event import conversion | Covered by OC-070 import/export work. |
+| Interactive script debugger | This task covers authoring and save/round-trip behavior, not breakpoints or step debugging. |
diff --git a/examples/demo-api/WebSocket/runtime-assertion-failure.yml b/examples/demo-api/WebSocket/runtime-assertion-failure.yml
new file mode 100644
index 0000000..43b9770
--- /dev/null
+++ b/examples/demo-api/WebSocket/runtime-assertion-failure.yml
@@ -0,0 +1,16 @@
+info:
+  name: WebSocket runtime assertion failure
+  type: websocket
+  seq: 7
+websocket:
+  url: "{{wsBaseUrl}}/ws/reject"
+runtime:
+  scripts:
+    - type: tests
+      code: |-
+        test("websocket error response is available", () => assert(response.json().error.message.includes("401")));
+  assertions:
+    - expression: res.status
+      operator: equals
+      value: "101"
+docs: Run `node examples/demo-api/server.js`, select the LOCAL environment, then send this request to see a terminal WebSocket upgrade error preserved with runtime test/assertion output.
diff --git a/examples/demo-api/WebSocket/runtime-lifecycle.yml b/examples/demo-api/WebSocket/runtime-lifecycle.yml
new file mode 100644
index 0000000..949dc2f
--- /dev/null
+++ b/examples/demo-api/WebSocket/runtime-lifecycle.yml
@@ -0,0 +1,51 @@
+info:
+  name: WebSocket runtime lifecycle
+  type: websocket
+  seq: 6
+websocket:
+  url: "{{wsBaseUrl}}/ws/auth"
+  message:
+    type: json
+    data: '{"user":"before-runtime","count":0}'
+runtime:
+  auth:
+    type: bearer
+    token: "{{demoToken}}"
+  variables:
+    - name: runtimeSocketCount
+      value: "7"
+  scripts:
+    - type: before-request
+      code: |-
+        missio.variables.set("runtimeSocketUser", "Ada Runtime");
+        missio.request.headers.set("X-Demo-Client", "missio-demo");
+        missio.request.headers.set("X-Runtime-Header", "scripted-websocket");
+        missio.request.body = {
+          user: missio.variables.get("runtimeSocketUser"),
+          count: Number(missio.variables.get("runtimeSocketCount"))
+        };
+    - type: after-response
+      code: |-
+        const inbound = response.json().events.find(event => event.direction === "inbound");
+        const payload = JSON.parse(inbound.data);
+        const message = payload.message.value || payload.message;
+        console.log("runtime websocket user", message.user);
+    - type: tests
+      code: |-
+        const inbound = response.json().events.find(event => event.direction === "inbound");
+        const payload = JSON.parse(inbound.data);
+        const message = payload.message.value || payload.message;
+        test("runtime websocket message echoed", () => assert(message.user === "Ada Runtime"));
+  assertions:
+    - expression: res.body.messageCount
+      operator: equals
+      value: "1"
+  actions:
+    - type: set-variable
+      selector:
+        method: jsonq
+        expression: $.messageCount
+      variable:
+        scope: runtime
+        name: runtimeSocketMessages
+docs: Run `node examples/demo-api/server.js`, select the LOCAL environment, then send this request to see WebSocket before/after scripts, assertions, tests, and set-variable actions.
diff --git a/examples/demo-api/gRPC/runtime-unary-lifecycle.yml b/examples/demo-api/gRPC/runtime-unary-lifecycle.yml
new file mode 100644
index 0000000..5b22959
--- /dev/null
+++ b/examples/demo-api/gRPC/runtime-unary-lifecycle.yml
@@ -0,0 +1,62 @@
+info:
+  name: gRPC unary runtime lifecycle
+  type: grpc
+  seq: 8
+grpc:
+  url: "{{grpcBaseUrl}}"
+  method: missio.demo.DemoService/EchoUnary
+  methodType: unary
+  protoFilePath: proto/services/missio_demo.proto
+  metadata:
+    - name: x-demo-default
+      value: runtime-default-{{grpcRequestId}}
+    - name: x-demo-request
+      value: before-runtime
+  message: |-
+    {
+      "name": "before-runtime",
+      "userId": 0,
+      "trace": {
+        "requestId": "before-runtime"
+      }
+    }
+runtime:
+  auth:
+    type: bearer
+    token: "{{grpcToken}}"
+  variables:
+    - name: grpcRuntimeUserId
+      value: "77"
+  scripts:
+    - type: before-request
+      code: |-
+        missio.variables.set("grpcRuntimeName", "Runtime Ada");
+        missio.variables.set("grpcRuntimeTrace", "runtime-" + missio.variables.get("grpcRequestId"));
+        missio.request.metadata.set("x-demo-request", "script-" + missio.variables.get("grpcRequestId"));
+        missio.request.body = {
+          name: missio.variables.get("grpcRuntimeName"),
+          userId: Number(missio.variables.get("grpcRuntimeUserId")),
+          trace: { requestId: missio.variables.get("grpcRuntimeTrace") }
+        };
+    - type: after-response
+      code: |-
+        console.info("runtime grpc request", response.json().requestId);
+    - type: tests
+      code: |-
+        test("runtime grpc message echoed", () => assert(response.json().name === "Runtime Ada"));
+  assertions:
+    - expression: res.body.name
+      operator: equals
+      value: Runtime Ada
+    - expression: res.body.userId
+      operator: equals
+      value: "77"
+  actions:
+    - type: set-variable
+      selector:
+        method: jsonq
+        expression: $.requestId
+      variable:
+        scope: runtime
+        name: grpcRuntimeRequestId
+docs: Run `node examples/demo-api/grpc-server.js`, select the LOCAL environment, then send this request to see unary gRPC metadata/message mutation plus runtime tests, assertions, logs, and set-variable actions.
diff --git a/examples/demo-api/server.js b/examples/demo-api/server.js
index 50a2187..22ab078 100644
--- a/examples/demo-api/server.js
+++ b/examples/demo-api/server.js
@@ -435,6 +435,7 @@ function attachWebSocketFixtures(httpServer) {
           route,
           authorized: true,
           client: req.headers['x-demo-client'] || null,
+          runtimeHeader: req.headers['x-runtime-header'] || null,
           message: parseSocketMessage(data, isBinary),
         }, null, 2));
         return;
diff --git a/schema/missio-extensions.json b/schema/missio-extensions.json
index 3fdbee0..ca28e8a 100644
--- a/schema/missio-extensions.json
+++ b/schema/missio-extensions.json
@@ -20,6 +20,10 @@
     {
       "extension": "gRPC streaming message sequences",
       "reason": "The upstream schema defines GrpcRequestMessage but does not wire ordered request-message arrays into GrpcRequestDetails.message. Missio supports client-streaming and bidirectional-streaming by accepting ordered GrpcRequestMessage arrays while preserving the upstream unary string and message-variant shapes."
+    },
+    {
+      "extension": "non-HTTP runtime actions and WebSocket assertions",
+      "reason": "Missio runs the same scripts, assertions, tests, and set-variable actions across supported protocol executors. The upstream schema omits some runtime lifecycle fields from WebSocket and gRPC runtime objects, so Missio extends them for protocol parity."
     }
   ],
   "definitions": {
@@ -185,6 +189,39 @@
           ]
         }
       }
+    },
+    {
+      "description": "Allow runtime actions on gRPC requests",
+      "target": "$defs/GrpcRequestRuntime/properties",
+      "properties": {
+        "actions": {
+          "type": "array",
+          "description": "Array of runtime actions",
+          "items": {
+            "$ref": "#/$defs/Action"
+          }
+        }
+      }
+    },
+    {
+      "description": "Allow assertions and runtime actions on WebSocket requests",
+      "target": "$defs/WebSocketRequestRuntime/properties",
+      "properties": {
+        "assertions": {
+          "type": "array",
+          "description": "Array of assertions for response validation",
+          "items": {
+            "$ref": "#/$defs/Assertion"
+          }
+        },
+        "actions": {
+          "type": "array",
+          "description": "Array of runtime actions",
+          "items": {
+            "$ref": "#/$defs/Action"
+          }
+        }
+      }
     }
   ]
 }
diff --git a/schema/opencollectionschema.json b/schema/opencollectionschema.json
index 2dba5ac..6dc71ea 100644
--- a/schema/opencollectionschema.json
+++ b/schema/opencollectionschema.json
@@ -2280,6 +2280,13 @@
         },
         "auth": {
           "$ref": "#/$defs/Auth"
+        },
+        "actions": {
+          "type": "array",
+          "description": "Array of runtime actions",
+          "items": {
+            "$ref": "#/$defs/Action"
+          }
         }
       },
       "additionalProperties": false
@@ -2380,6 +2387,20 @@
         },
         "auth": {
           "$ref": "#/$defs/Auth"
+        },
+        "assertions": {
+          "type": "array",
+          "description": "Array of assertions for response validation",
+          "items": {
+            "$ref": "#/$defs/Assertion"
+          }
+        },
+        "actions": {
+          "type": "array",
+          "description": "Array of runtime actions",
+          "items": {
+            "$ref": "#/$defs/Action"
+          }
         }
       },
       "additionalProperties": false
diff --git a/src/models/types.ts b/src/models/types.ts
index 2b284e3..fc8856a 100644
--- a/src/models/types.ts
+++ b/src/models/types.ts
@@ -495,6 +495,7 @@ export interface GrpcRequestRuntime {
   variables?: Variable[];
   scripts?: Scripts;
   assertions?: Assertion[];
+  actions?: Action[];
   auth?: Auth;
 }
 
@@ -537,6 +538,8 @@ export interface WebSocketRequestDetails {
 export interface WebSocketRequestRuntime {
   variables?: Variable[];
   scripts?: Scripts;
+  assertions?: Assertion[];
+  actions?: Action[];
   auth?: Auth;
 }
 
diff --git a/src/panels/requestPanel.ts b/src/panels/requestPanel.ts
index 6f45fae..99fabd8 100644
--- a/src/panels/requestPanel.ts
+++ b/src/panels/requestPanel.ts
@@ -6,7 +6,7 @@ import type { HttpRequest, OpenCollectionRequest, RequestDefaults, MissioCollect
 import { getItemKind, isGraphQLRequest, isGrpcRequest, isHttpRequest, isProtocolRequest, isWebSocketRequest } from '../models/types';
 import { requestLog, type ResolvedRequest } from '../services/httpClient';
 import type { RequestExecutionService } from '../services/requestExecutionService';
-import { exportRequest, findTarget, EXPORT_TARGETS } from '../services/snippetExporter';
+import { exportRequest, findTarget, EXPORT_TARGETS, getUnsupportedSnippetDiagnostic } from '../services/snippetExporter';
 import { resolveFileVariantToBuffer } from '../services/fileBodyHelper';
 import type { CollectionService } from '../services/collectionService';
 import type { EnvironmentService } from '../services/environmentService';
diff --git a/src/services/grpcClient.ts b/src/services/grpcClient.ts
index d54a208..a0ed57f 100644
--- a/src/services/grpcClient.ts
+++ b/src/services/grpcClient.ts
@@ -20,6 +20,7 @@ import type {
 } from '../models/types';
 import type { EnvironmentService } from './environmentService';
 import type { CliApprovalPrompt } from './httpClient';
+import { RequestCancelledError } from './requestCancelledError';
 
 const execAsync = promisify(exec);
 
@@ -216,7 +217,7 @@ export class GrpcClient implements vscode.Disposable {
       try {
         activeCall.call?.cancel?.();
       } catch {
-        activeCall.call?.destroy?.(new Error('Request cancelled'));
+        activeCall.call?.destroy?.(new RequestCancelledError());
       }
     }
     this._activeCalls.clear();
@@ -261,7 +262,7 @@ export class GrpcClient implements vscode.Disposable {
         (err: grpc.ServiceError | null, response: unknown) => {
           if (activeCall.cancelled || err?.code === grpc.status.CANCELLED) {
             finish();
-            reject(new Error('Request cancelled'));
+            reject(new RequestCancelledError());
             return;
           }
           if (err) {
@@ -336,7 +337,7 @@ export class GrpcClient implements vscode.Disposable {
         settled = true;
         if (activeCall.cancelled || (error as grpc.ServiceError | undefined)?.code === grpc.status.CANCELLED) {
           finish();
-          reject(new Error('Request cancelled'));
+          reject(new RequestCancelledError());
           return;
         }
         args.timing.push({ label: 'gRPC Stream', start: args.phaseStart - args.t0, end: Date.now() - args.t0 });
@@ -424,7 +425,7 @@ export class GrpcClient implements vscode.Disposable {
         settled = true;
         if (activeCall.cancelled || (error as grpc.ServiceError | undefined)?.code === grpc.status.CANCELLED) {
           finish();
-          reject(new Error('Request cancelled'));
+          reject(new RequestCancelledError());
           return;
         }
         args.timing.push({ label: 'gRPC Stream', start: args.phaseStart - args.t0, end: Date.now() - args.t0 });
@@ -525,7 +526,7 @@ export class GrpcClient implements vscode.Disposable {
         settled = true;
         if (activeCall.cancelled || (error as grpc.ServiceError | undefined)?.code === grpc.status.CANCELLED) {
           finish();
-          reject(new Error('Request cancelled'));
+          reject(new RequestCancelledError());
           return;
         }
         args.timing.push({ label: 'gRPC Stream', start: args.phaseStart - args.t0, end: Date.now() - args.t0 });
diff --git a/src/services/requestCancelledError.ts b/src/services/requestCancelledError.ts
new file mode 100644
index 0000000..e0b1626
--- /dev/null
+++ b/src/services/requestCancelledError.ts
@@ -0,0 +1,8 @@
+export class RequestCancelledError extends Error {
+  public readonly code = 'MISSIO_REQUEST_CANCELLED';
+
+  constructor(message = 'Request cancelled') {
+    super(message);
+    this.name = 'RequestCancelledError';
+  }
+}
diff --git a/src/services/requestExecutionService.ts b/src/services/requestExecutionService.ts
index 990d3d3..36b6ea8 100644
--- a/src/services/requestExecutionService.ts
+++ b/src/services/requestExecutionService.ts
@@ -23,7 +23,7 @@ export interface UnsupportedProtocolDiagnostic {
   code: 'MISSIO_UNSUPPORTED_PROTOCOL';
   protocol: Exclude<RequestProtocol, 'http'> | 'unknown';
   protocolName: string;
-  taskId?: 'OC-010' | 'OC-020' | 'OC-030';
+  taskId?: 'OC-010' | 'OC-020' | 'OC-030' | 'OC-080';
   message: string;
 }
 
@@ -185,6 +185,32 @@ export class RequestExecutionService {
     }
 
     if (isWebSocketRequest(request) && this._webSocketClient) {
+      if (this._runtimeExecutionService.hasRuntimeWork(request, collection, folderDefaults)) {
+        const prepared = await this._runtimeExecutionService.prepareWebSocketRequest(
+          request,
+          collection,
+          folderDefaults,
+          extraVariables,
+          environmentName,
+        );
+        const startedAt = Date.now();
+        let response: HttpResponse;
+        try {
+          response = await this._webSocketClient.send(
+            prepared.request,
+            collection,
+            folderDefaults,
+            onProgress,
+            prepared.extraVariables,
+            environmentName,
+            options,
+          );
+        } catch (error) {
+          if (isCancellationError(error)) throw error;
+          response = buildProtocolErrorResponse('websocket', error, Date.now() - startedAt);
+        }
+        return this._runtimeExecutionService.completeWebSocketRequest(prepared, response);
+      }
       return this._webSocketClient.send(
         request,
         collection,
@@ -197,6 +223,43 @@ export class RequestExecutionService {
     }
 
     if (isGrpcRequest(request) && this._grpcClient) {
+      const grpcMethodType = request.grpc?.methodType ?? 'unary';
+      const hasRuntimeWork = this._runtimeExecutionService.hasRuntimeWork(request, collection, folderDefaults);
+      if (grpcMethodType !== 'unary' && hasRuntimeWork) {
+        throw new UnsupportedProtocolError({
+          code: 'MISSIO_UNSUPPORTED_PROTOCOL',
+          protocol: 'grpc',
+          protocolName: 'gRPC',
+          taskId: 'OC-080',
+          message: `Missio does not execute runtime scripts, assertions, tests, or actions for ${grpcMethodType} gRPC requests. The streaming request was not sent.`,
+        });
+      }
+      if (grpcMethodType === 'unary' && hasRuntimeWork) {
+        const prepared = await this._runtimeExecutionService.prepareGrpcRequest(
+          request,
+          collection,
+          folderDefaults,
+          extraVariables,
+          environmentName,
+        );
+        const startedAt = Date.now();
+        let response: HttpResponse;
+        try {
+          response = await this._grpcClient.send(
+            prepared.request,
+            collection,
+            folderDefaults,
+            onProgress,
+            prepared.extraVariables,
+            environmentName,
+            cliApprovalPrompt,
+          );
+        } catch (error) {
+          if (isCancellationError(error)) throw error;
+          response = buildProtocolErrorResponse('grpc', error, Date.now() - startedAt);
+        }
+        return this._runtimeExecutionService.completeGrpcRequest(prepared, response);
+      }
       return this._grpcClient.send(
         request,
         collection,
@@ -261,6 +324,45 @@ export function getUnsupportedProtocolDiagnostic(request: OpenCollectionRequest)
   };
 }
 
+function isCancellationError(error: unknown): boolean {
+  return error instanceof Error
+    && (error as Error & { code?: unknown }).code === 'MISSIO_REQUEST_CANCELLED';
+}
+
+function buildProtocolErrorResponse(protocol: 'websocket' | 'grpc', error: unknown, duration: number): HttpResponse {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const code = typeof (err as any).code === 'string' ? (err as any).code : undefined;
+  const grpcStatus = typeof (err as any).grpcStatus === 'number' ? (err as any).grpcStatus : undefined;
+  const details = {
+    message: err.message,
+    name: err.name,
+    code,
+    grpcStatus,
+    grpcDetails: typeof (err as any).grpcDetails === 'string' ? (err as any).grpcDetails : undefined,
+    stack: typeof err.stack === 'string' ? err.stack : undefined,
+  };
+  const body = JSON.stringify({ protocol, error: details }, null, 2);
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    'x-missio-protocol': protocol,
+    'x-missio-error': 'true',
+    'x-missio-error-message': err.message,
+  };
+  if (code) headers['x-missio-error-code'] = code;
+  if (grpcStatus !== undefined) {
+    headers['x-missio-grpc-status'] = String(grpcStatus);
+  }
+
+  return {
+    status: 0,
+    statusText: code ?? err.name ?? 'Error',
+    headers,
+    body,
+    duration,
+    size: Buffer.byteLength(body, 'utf-8'),
+  };
+}
+
 export type HttpRequestExecutor = RequestExecutor<HttpRequest>;
 export type GraphQLRequestExecutor = RequestExecutor<GraphQLRequest>;
 export type GrpcRequestExecutor = RequestExecutor<GrpcRequest>;
diff --git a/src/services/runtimeExecutionService.ts b/src/services/runtimeExecutionService.ts
index b70555c..c7336b7 100644
--- a/src/services/runtimeExecutionService.ts
+++ b/src/services/runtimeExecutionService.ts
@@ -4,9 +4,12 @@ import type {
   ActionPhase,
   ActionVariableScope,
   Assertion,
+  GrpcMetadata,
+  GrpcRequest,
   HttpRequest,
   HttpRequestBody,
   HttpRequestBodyVariant,
+  HttpRequestHeader,
   HttpResponse,
   MissioCollection,
   RequestDefaults,
@@ -23,6 +26,9 @@ import type {
   Variable,
   VariableValue,
   VariableValueVariant,
+  WebSocketMessage,
+  WebSocketMessageVariant,
+  WebSocketRequest,
 } from '../models/types';
 
 export type RuntimeVariableResolver = (
@@ -38,19 +44,30 @@ interface RuntimeVariableScopes {
 }
 
 interface RuntimeState {
-  request: HttpRequest;
+  request: RuntimeCapableRequest;
   response?: HttpResponse;
   variables: RuntimeVariableScopes;
   result: RuntimeExecutionResult;
 }
 
-export interface RuntimePreparedHttpRequest {
-  request: HttpRequest;
+type RuntimeCapableRequest = HttpRequest | WebSocketRequest | GrpcRequest;
+type RuntimeRequestHeader = HttpRequestHeader | GrpcMetadata;
+interface RuntimeRequestConfig {
+  variables?: Variable[];
+  scripts?: Script[];
+  assertions?: Assertion[];
+  actions?: Action[];
+}
+
+export interface RuntimePreparedRequest<TRequest extends RuntimeCapableRequest> {
+  request: TRequest;
   extraVariables?: Map<string, string>;
   runtime: RuntimeExecutionResult;
   state: RuntimeState;
 }
 
+export type RuntimePreparedHttpRequest = RuntimePreparedRequest<HttpRequest>;
+
 export class RuntimeExecutionError extends Error {
   constructor(
     message: string,
@@ -66,23 +83,24 @@ export class RuntimeExecutionService {
   constructor(private readonly _variableResolver?: RuntimeVariableResolver) {}
 
   hasRuntimeWork(
-    request: HttpRequest,
+    request: RuntimeCapableRequest,
     collection: MissioCollection,
     folderDefaults?: RequestDefaults,
   ): boolean {
-    return variablesToMap(request.runtime?.variables).size > 0
-      || lifecycleScripts(collection.data.request?.scripts, folderDefaults?.scripts, request.runtime?.scripts, 'before-request').length > 0
-      || lifecycleScripts(undefined, undefined, request.runtime?.scripts, 'after-response').length > 0
-      || lifecycleScripts(undefined, undefined, request.runtime?.scripts, 'tests').length > 0
-      || (request.runtime?.assertions ?? []).length > 0
-      || (request.runtime?.actions ?? []).length > 0;
+    const runtime = runtimeConfig(request);
+    return variablesToMap(runtime?.variables).size > 0
+      || lifecycleScripts(collection.data.request?.scripts, folderDefaults?.scripts, runtime?.scripts, 'before-request').length > 0
+      || lifecycleScripts(undefined, undefined, runtime?.scripts, 'after-response').length > 0
+      || lifecycleScripts(undefined, undefined, runtime?.scripts, 'tests').length > 0
+      || (runtime?.assertions ?? []).length > 0
+      || (runtime?.actions ?? []).length > 0;
   }
 
   async buildRequestVariableOverrides(
-    request: HttpRequest,
+    request: RuntimeCapableRequest,
     extraVariables?: Map<string, string>,
   ): Promise<Map<string, string> | undefined> {
-    const requestVariables = variablesToMap(request.runtime?.variables);
+    const requestVariables = variablesToMap(runtimeConfig(request)?.variables);
     if (requestVariables.size === 0 && (!extraVariables || extraVariables.size === 0)) {
       return undefined;
     }
@@ -100,19 +118,71 @@ export class RuntimeExecutionService {
     extraVariables?: Map<string, string>,
     environmentName?: string,
   ): Promise<RuntimePreparedHttpRequest> {
+    return this._prepareRequest(request, collection, folderDefaults, extraVariables, environmentName);
+  }
+
+  async prepareWebSocketRequest(
+    request: WebSocketRequest,
+    collection: MissioCollection,
+    folderDefaults?: RequestDefaults,
+    extraVariables?: Map<string, string>,
+    environmentName?: string,
+  ): Promise<RuntimePreparedRequest<WebSocketRequest>> {
+    return this._prepareRequest(request, collection, folderDefaults, extraVariables, environmentName);
+  }
+
+  async prepareGrpcRequest(
+    request: GrpcRequest,
+    collection: MissioCollection,
+    folderDefaults?: RequestDefaults,
+    extraVariables?: Map<string, string>,
+    environmentName?: string,
+  ): Promise<RuntimePreparedRequest<GrpcRequest>> {
+    return this._prepareRequest(request, collection, folderDefaults, extraVariables, environmentName);
+  }
+
+  async completeHttpRequest(
+    prepared: RuntimePreparedHttpRequest,
+    response: HttpResponse,
+  ): Promise<HttpResponse> {
+    return this._completeRequest(prepared, response);
+  }
+
+  async completeWebSocketRequest(
+    prepared: RuntimePreparedRequest<WebSocketRequest>,
+    response: HttpResponse,
+  ): Promise<HttpResponse> {
+    return this._completeRequest(prepared, response);
+  }
+
+  async completeGrpcRequest(
+    prepared: RuntimePreparedRequest<GrpcRequest>,
+    response: HttpResponse,
+  ): Promise<HttpResponse> {
+    return this._completeRequest(prepared, response);
+  }
+
+  private async _prepareRequest<TRequest extends RuntimeCapableRequest>(
+    request: TRequest,
+    collection: MissioCollection,
+    folderDefaults?: RequestDefaults,
+    extraVariables?: Map<string, string>,
+    environmentName?: string,
+  ): Promise<RuntimePreparedRequest<TRequest>> {
     const clonedRequest = cloneJson(request);
+    const runtime = runtimeConfig(clonedRequest);
     const result = createRuntimeResult();
     const baseVariables = this._variableResolver
       ? await this._variableResolver(collection, folderDefaults, environmentName)
       : new Map<string, string>();
     const variables: RuntimeVariableScopes = {
       base: new Map(baseVariables),
-      request: variablesToMap(clonedRequest.runtime?.variables),
+      request: variablesToMap(runtime?.variables),
       runtime: new Map(extraVariables),
     };
     const state: RuntimeState = { request: clonedRequest, variables, result };
 
-    await this._runScripts(state, lifecycleScripts(collection.data.request?.scripts, folderDefaults?.scripts, clonedRequest.runtime?.scripts, 'before-request'), 'before-request', true);
+    await this._runScripts(state, lifecycleScripts(collection.data.request?.scripts, folderDefaults?.scripts, runtime?.scripts, 'before-request'), 'before-request', true);
     this._runActions(state, 'before-request');
 
     return {
@@ -123,15 +193,16 @@ export class RuntimeExecutionService {
     };
   }
 
-  async completeHttpRequest(
-    prepared: RuntimePreparedHttpRequest,
+  private async _completeRequest<TRequest extends RuntimeCapableRequest>(
+    prepared: RuntimePreparedRequest<TRequest>,
     response: HttpResponse,
   ): Promise<HttpResponse> {
+    const runtime = runtimeConfig(prepared.state.request);
     prepared.state.response = response;
     this._runActions(prepared.state, 'after-response');
-    await this._runScripts(prepared.state, lifecycleScripts(undefined, undefined, prepared.state.request.runtime?.scripts, 'after-response'), 'after-response', false);
-    this._runAssertions(prepared.state, prepared.state.request.runtime?.assertions ?? []);
-    await this._runScripts(prepared.state, lifecycleScripts(undefined, undefined, prepared.state.request.runtime?.scripts, 'tests'), 'tests', false);
+    await this._runScripts(prepared.state, lifecycleScripts(undefined, undefined, runtime?.scripts, 'after-response'), 'after-response', false);
+    this._runAssertions(prepared.state, runtime?.assertions ?? []);
+    await this._runScripts(prepared.state, lifecycleScripts(undefined, undefined, runtime?.scripts, 'tests'), 'tests', false);
     finalizeRuntimeResult(prepared.runtime);
     return hasRuntimeActivity(prepared.runtime)
       ? { ...response, runtime: prepared.runtime }
@@ -261,7 +332,7 @@ export class RuntimeExecutionService {
   }
 
   private _runActions(state: RuntimeState, phase: ActionPhase): void {
-    const actions = state.request.runtime?.actions ?? [];
+    const actions = runtimeConfig(state.request)?.actions ?? [];
     for (const action of actions) {
       const actionPhase = action.phase ?? 'after-response';
       if (actionPhase !== phase) continue;
@@ -380,6 +451,10 @@ function cloneJson<T>(value: T): T {
   return value === undefined ? value : JSON.parse(JSON.stringify(value));
 }
 
+function runtimeConfig(request: RuntimeCapableRequest): RuntimeRequestConfig | undefined {
+  return (request as { runtime?: RuntimeRequestConfig }).runtime;
+}
+
 function mergeInto(target: Map<string, string>, source: Map<string, string>): void {
   for (const [key, value] of source) {
     target.set(key, value);
@@ -450,40 +525,48 @@ function makeVariablesApi(state: RuntimeState): Record<string, unknown> {
 function makeRequestApi(state: RuntimeState): Record<string, unknown> {
   const api: Record<string, unknown> = {};
   Object.defineProperties(api, {
+    protocol: {
+      enumerable: true,
+      get: () => getRuntimeRequestProtocol(state.request),
+    },
     method: {
       enumerable: true,
-      get: () => state.request.http?.method,
+      get: () => getRuntimeRequestMethod(state.request),
       set: (value: unknown) => {
-        if (!state.request.http) state.request.http = {};
-        state.request.http.method = String(value);
+        setRuntimeRequestMethod(state.request, value);
       },
     },
     url: {
       enumerable: true,
-      get: () => state.request.http?.url,
+      get: () => getRuntimeRequestUrl(state.request),
       set: (value: unknown) => {
-        if (!state.request.http) state.request.http = {};
-        state.request.http.url = String(value);
+        setRuntimeRequestUrl(state.request, value);
       },
     },
     body: {
       enumerable: true,
-      get: () => getRequestBodyValue(state.request),
-      set: (value: unknown) => setRequestBodyValue(state.request, value),
+      get: () => getRuntimeRequestBodyValue(state.request),
+      set: (value: unknown) => setRuntimeRequestBodyValue(state.request, value),
+    },
+    message: {
+      enumerable: true,
+      get: () => getRuntimeRequestBodyValue(state.request),
+      set: (value: unknown) => setRuntimeRequestBodyValue(state.request, value),
     },
   });
 
-  api.headers = makeHeaderApi(
-    () => state.request.http?.headers ?? [],
-    (headers) => {
-      if (!state.request.http) state.request.http = {};
-      state.request.http.headers = headers;
-    },
+  const headerApi = makeHeaderApi(
+    () => getRuntimeRequestHeaders(state.request),
+    (headers) => setRuntimeRequestHeaders(state.request, headers),
   );
-  api.setHeader = (name: string, value: unknown) => setHeader(state.request, name, value);
-  api.getHeader = (name: string) => getHeader(state.request, name);
-  api.setBody = (value: unknown) => setRequestBodyValue(state.request, value);
-  api.json = () => parseMaybeJson(getRequestBodyValue(state.request));
+  api.headers = headerApi;
+  api.metadata = headerApi;
+  api.setHeader = (name: string, value: unknown) => setRuntimeRequestHeader(state.request, name, value);
+  api.getHeader = (name: string) => getRuntimeRequestHeader(state.request, name);
+  api.setMetadata = (name: string, value: unknown) => setRuntimeRequestHeader(state.request, name, value);
+  api.getMetadata = (name: string) => getRuntimeRequestHeader(state.request, name);
+  api.setBody = (value: unknown) => setRuntimeRequestBodyValue(state.request, value);
+  api.json = () => parseMaybeJson(getRuntimeRequestBodyValue(state.request));
   return Object.freeze(api);
 }
 
@@ -507,10 +590,12 @@ function makeResponseApi(state: RuntimeState): Record<string, unknown> {
       get: () => state.response?.body,
     },
   });
-  api.headers = Object.freeze({
+  const headersApi = Object.freeze({
     get: (name: string) => getResponseHeader(state.response, name),
     toObject: () => ({ ...(state.response?.headers ?? {}) }),
   });
+  api.headers = headersApi;
+  api.metadata = headersApi;
   api.text = () => state.response?.body ?? '';
   api.json = () => parseMaybeJson(state.response?.body ?? '');
   return Object.freeze(api);
@@ -578,8 +663,8 @@ function makeExpectApi(actual: unknown, assertApi: (condition: unknown, message?
 }
 
 function makeHeaderApi(
-  getHeaders: () => NonNullable<HttpRequest['http']>['headers'],
-  setHeaders: (headers: NonNullable<HttpRequest['http']>['headers']) => void,
+  getHeaders: () => RuntimeRequestHeader[],
+  setHeaders: (headers: RuntimeRequestHeader[]) => void,
 ): Record<string, unknown> {
   return Object.freeze({
     get: (name: string) => {
@@ -617,18 +702,17 @@ function makeHeaderApi(
   });
 }
 
-function setHeader(request: HttpRequest, name: string, value: unknown): void {
-  if (!request.http) request.http = {};
-  const headers = [...(request.http.headers ?? [])];
+function setRuntimeRequestHeader(request: RuntimeCapableRequest, name: string, value: unknown): void {
+  const headers = [...getRuntimeRequestHeaders(request)];
   const index = headers.findIndex(header => header.name.toLowerCase() === String(name).toLowerCase());
   const next = { name: String(name), value: stringifyVariableValue(value) };
   if (index >= 0) headers[index] = { ...headers[index], ...next };
   else headers.push(next);
-  request.http.headers = headers;
+  setRuntimeRequestHeaders(request, headers);
 }
 
-function getHeader(request: HttpRequest, name: string): string | undefined {
-  return request.http?.headers?.find(header => !header.disabled && header.name.toLowerCase() === String(name).toLowerCase())?.value;
+function getRuntimeRequestHeader(request: RuntimeCapableRequest, name: string): string | undefined {
+  return getRuntimeRequestHeaders(request).find(header => !header.disabled && header.name.toLowerCase() === String(name).toLowerCase())?.value;
 }
 
 function getResponseHeader(response: HttpResponse | undefined, name: string): string | undefined {
@@ -637,22 +721,120 @@ function getResponseHeader(response: HttpResponse | undefined, name: string): st
   return found?.[1];
 }
 
-function getRequestBodyValue(request: HttpRequest): unknown {
-  const body = selectedHttpBody(request.http?.body);
+function isRuntimeWebSocketRequest(request: RuntimeCapableRequest): request is WebSocketRequest {
+  return Object.prototype.hasOwnProperty.call(request, 'websocket');
+}
+
+function isRuntimeGrpcRequest(request: RuntimeCapableRequest): request is GrpcRequest {
+  return Object.prototype.hasOwnProperty.call(request, 'grpc');
+}
+
+function getRuntimeRequestProtocol(request: RuntimeCapableRequest): string {
+  if (isRuntimeWebSocketRequest(request)) return 'websocket';
+  if (isRuntimeGrpcRequest(request)) return 'grpc';
+  return 'http';
+}
+
+function getRuntimeRequestMethod(request: RuntimeCapableRequest): string | undefined {
+  if (isRuntimeWebSocketRequest(request)) return 'WS';
+  if (isRuntimeGrpcRequest(request)) return request.grpc?.method;
+  return (request as HttpRequest).http?.method;
+}
+
+function setRuntimeRequestMethod(request: RuntimeCapableRequest, value: unknown): void {
+  if (isRuntimeGrpcRequest(request)) {
+    if (!request.grpc) request.grpc = {};
+    request.grpc.method = String(value);
+    return;
+  }
+  if (isRuntimeWebSocketRequest(request)) {
+    return;
+  }
+  const httpRequest = request as HttpRequest;
+  if (!httpRequest.http) httpRequest.http = {};
+  httpRequest.http.method = String(value);
+}
+
+function getRuntimeRequestUrl(request: RuntimeCapableRequest): string | undefined {
+  if (isRuntimeWebSocketRequest(request)) return request.websocket?.url;
+  if (isRuntimeGrpcRequest(request)) return request.grpc?.url;
+  return (request as HttpRequest).http?.url;
+}
+
+function setRuntimeRequestUrl(request: RuntimeCapableRequest, value: unknown): void {
+  if (isRuntimeWebSocketRequest(request)) {
+    if (!request.websocket) request.websocket = {};
+    request.websocket.url = String(value);
+    return;
+  }
+  if (isRuntimeGrpcRequest(request)) {
+    if (!request.grpc) request.grpc = {};
+    request.grpc.url = String(value);
+    return;
+  }
+  const httpRequest = request as HttpRequest;
+  if (!httpRequest.http) httpRequest.http = {};
+  httpRequest.http.url = String(value);
+}
+
+function getRuntimeRequestHeaders(request: RuntimeCapableRequest): RuntimeRequestHeader[] {
+  if (isRuntimeWebSocketRequest(request)) return request.websocket?.headers ?? [];
+  if (isRuntimeGrpcRequest(request)) return request.grpc?.metadata ?? [];
+  return (request as HttpRequest).http?.headers ?? [];
+}
+
+function setRuntimeRequestHeaders(request: RuntimeCapableRequest, headers: RuntimeRequestHeader[]): void {
+  if (isRuntimeWebSocketRequest(request)) {
+    if (!request.websocket) request.websocket = {};
+    request.websocket.headers = headers as HttpRequestHeader[];
+    return;
+  }
+  if (isRuntimeGrpcRequest(request)) {
+    if (!request.grpc) request.grpc = {};
+    request.grpc.metadata = headers as GrpcMetadata[];
+    return;
+  }
+  const httpRequest = request as HttpRequest;
+  if (!httpRequest.http) httpRequest.http = {};
+  httpRequest.http.headers = headers as HttpRequestHeader[];
+}
+
+function getRuntimeRequestBodyValue(request: RuntimeCapableRequest): unknown {
+  if (isRuntimeWebSocketRequest(request)) {
+    const message = selectedWebSocketMessage(request.websocket?.message);
+    if (!message) return undefined;
+    return message.type === 'json' ? parseMaybeJson(message.data) : message.data;
+  }
+  if (isRuntimeGrpcRequest(request)) {
+    return parseMaybeJson(selectedGrpcMessage(request.grpc?.message) ?? '{}');
+  }
+
+  const httpRequest = request as HttpRequest;
+  const body = selectedHttpBody(httpRequest.http?.body);
   if (!body) return undefined;
   if (body.type === 'json') return parseMaybeJson(body.data);
   if (body.type === 'text' || body.type === 'xml' || body.type === 'html' || body.type === 'yaml' || body.type === 'sparql') return body.data;
   return cloneJson(body);
 }
 
-function setRequestBodyValue(request: HttpRequest, value: unknown): void {
-  if (!request.http) request.http = {};
-  const body = selectedHttpBody(request.http.body);
+function setRuntimeRequestBodyValue(request: RuntimeCapableRequest, value: unknown): void {
+  if (isRuntimeWebSocketRequest(request)) {
+    setWebSocketMessageValue(request, value);
+    return;
+  }
+  if (isRuntimeGrpcRequest(request)) {
+    setGrpcMessageValue(request, value);
+    return;
+  }
+
+  const httpRequest = request as HttpRequest;
+  if (!httpRequest.http) httpRequest.http = {};
+  const body = selectedHttpBody(httpRequest.http.body);
   const nextType = typeof value === 'object' ? 'json' : body?.type ?? 'text';
   const nextData = typeof value === 'string' ? value : JSON.stringify(value);
 
   if (!body) {
-    request.http.body = { type: nextType, data: nextData } as HttpRequestBody;
+    httpRequest.http.body = { type: nextType, data: nextData } as HttpRequestBody;
     return;
   }
 
@@ -660,7 +842,7 @@ function setRequestBodyValue(request: HttpRequest, value: unknown): void {
   (body as { data?: unknown }).data = nextData;
 }
 
-function selectedHttpBody(body: HttpRequest['http'] extends infer _ ? HttpRequest['http'] extends undefined ? never : NonNullable<HttpRequest['http']>['body'] : never): HttpRequestBody | undefined {
+function selectedHttpBody(body: NonNullable<HttpRequest['http']>['body'] | undefined): HttpRequestBody | undefined {
   if (!body) return undefined;
   if (Array.isArray(body)) {
     const variants = body as HttpRequestBodyVariant[];
@@ -669,6 +851,58 @@ function selectedHttpBody(body: HttpRequest['http'] extends infer _ ? HttpReques
   return body as HttpRequestBody;
 }
 
+function selectedWebSocketMessage(message: NonNullable<WebSocketRequest['websocket']>['message']): WebSocketMessage | undefined {
+  if (!message) return undefined;
+  if (!Array.isArray(message)) return message;
+  const selected = message.find(variant => variant.selected) ?? message[0];
+  return selected?.message;
+}
+
+function setWebSocketMessageValue(request: WebSocketRequest, value: unknown): void {
+  if (!request.websocket) request.websocket = {};
+  const existing = selectedWebSocketMessage(request.websocket.message);
+  const nextType = typeof value === 'object' && value !== null ? 'json' : existing?.type ?? 'text';
+  const nextData = typeof value === 'string' ? value : JSON.stringify(value);
+  const nextMessage: WebSocketMessage = { type: nextType, data: nextData };
+
+  if (!request.websocket.message) {
+    request.websocket.message = nextMessage;
+    return;
+  }
+  if (Array.isArray(request.websocket.message)) {
+    const variants = request.websocket.message as WebSocketMessageVariant[];
+    const selected = variants.find(variant => variant.selected) ?? variants[0];
+    if (selected) selected.message = nextMessage;
+    else request.websocket.message = nextMessage;
+    return;
+  }
+  request.websocket.message = nextMessage;
+}
+
+function selectedGrpcMessage(message: NonNullable<GrpcRequest['grpc']>['message']): string | undefined {
+  if (!message) return undefined;
+  if (typeof message === 'string') return message;
+  if (Array.isArray(message)) {
+    const selected = message.find(variant => isRecord(variant) && variant.selected === true) ?? message[0];
+    return isRecord(selected) && typeof selected.message === 'string' ? selected.message : undefined;
+  }
+  return undefined;
+}
+
+function setGrpcMessageValue(request: GrpcRequest, value: unknown): void {
+  if (!request.grpc) request.grpc = {};
+  const nextMessage = typeof value === 'string' ? value : JSON.stringify(value);
+  const current = request.grpc.message as unknown;
+  if (Array.isArray(current)) {
+    const selected = current.find(variant => isRecord(variant) && variant.selected === true) ?? current[0];
+    if (isRecord(selected) && typeof selected.message === 'string') {
+      selected.message = nextMessage;
+      return;
+    }
+  }
+  request.grpc.message = nextMessage;
+}
+
 function parseMaybeJson(value: unknown): unknown {
   if (typeof value !== 'string') return value;
   try {
@@ -704,14 +938,21 @@ function setRuntimeVariable(
 function evaluateJsonSelector(expression: string, state: RuntimeState): unknown {
   const root = state.response
     ? parseMaybeJson(state.response.body)
-    : parseMaybeJson(getRequestBodyValue(state.request));
+    : parseMaybeJson(getRuntimeRequestBodyValue(state.request));
   return getPathValue(root, normalizeSelectorExpression(expression));
 }
 
 function evaluateExpression(expression: string, state: RuntimeState): unknown {
   const trimmed = expression.trim();
   const responseBody = state.response ? parseMaybeJson(state.response.body) : undefined;
-  const requestBody = parseMaybeJson(getRequestBodyValue(state.request));
+  const requestBody = parseMaybeJson(getRuntimeRequestBodyValue(state.request));
+  const requestHeaders = Object.fromEntries(
+    getRuntimeRequestHeaders(state.request)
+      .filter(h => !h.disabled)
+      .map(h => [h.name.toLowerCase(), h.value]),
+  );
+  const requestMethod = getRuntimeRequestMethod(state.request);
+  const requestUrl = getRuntimeRequestUrl(state.request);
 
   if (trimmed === 'status' || trimmed === 'statusCode' || trimmed === 'res.status' || trimmed === 'response.status') {
     return state.response?.status;
@@ -731,15 +972,19 @@ function evaluateExpression(expression: string, state: RuntimeState): unknown {
 
   const root = {
     req: {
-      method: state.request.http?.method,
-      url: state.request.http?.url,
-      headers: Object.fromEntries((state.request.http?.headers ?? []).filter(h => !h.disabled).map(h => [h.name.toLowerCase(), h.value])),
+      protocol: getRuntimeRequestProtocol(state.request),
+      method: requestMethod,
+      url: requestUrl,
+      headers: requestHeaders,
+      metadata: requestHeaders,
       body: requestBody,
     },
     request: {
-      method: state.request.http?.method,
-      url: state.request.http?.url,
-      headers: Object.fromEntries((state.request.http?.headers ?? []).filter(h => !h.disabled).map(h => [h.name.toLowerCase(), h.value])),
+      protocol: getRuntimeRequestProtocol(state.request),
+      method: requestMethod,
+      url: requestUrl,
+      headers: requestHeaders,
+      metadata: requestHeaders,
       body: requestBody,
     },
     res: {
diff --git a/src/services/snippetExporter.ts b/src/services/snippetExporter.ts
index 42858fd..0e501e4 100644
--- a/src/services/snippetExporter.ts
+++ b/src/services/snippetExporter.ts
@@ -1,5 +1,7 @@
 import { HTTPSnippet, type HarRequest } from 'httpsnippet';
 import type { ResolvedRequest } from './httpClient';
+import type { OpenCollectionRequest, RequestProtocol } from '../models/types';
+import { getItemKind } from '../models/types';
 
 /** A single export target (target + client combination). */
 export interface ExportTarget {
@@ -13,6 +15,23 @@ export interface ExportTarget {
   lang: string;
 }
 
+export interface UnsupportedSnippetDiagnostic {
+  code: 'MISSIO_UNSUPPORTED_SNIPPET_EXPORT';
+  protocol: RequestProtocol | 'unknown';
+  protocolName: string;
+  supportedProtocols: RequestProtocol[];
+  message: string;
+}
+
+export class UnsupportedSnippetExportError extends Error {
+  readonly code = 'MISSIO_UNSUPPORTED_SNIPPET_EXPORT';
+
+  constructor(public readonly diagnostic: UnsupportedSnippetDiagnostic) {
+    super(diagnostic.message);
+    this.name = 'UnsupportedSnippetExportError';
+  }
+}
+
 /**
  * All available export targets, ordered to match the Postman-style dropdown.
  * Derived from httpsnippet's built-in targets.
@@ -80,6 +99,35 @@ export function findTarget(id: string): ExportTarget | undefined {
   return EXPORT_TARGETS.find(t => t.id === id);
 }
 
+export function getUnsupportedSnippetDiagnostic(request: OpenCollectionRequest | unknown): UnsupportedSnippetDiagnostic {
+  const kind = getItemKind(request);
+  const protocol = kind === 'graphql' || kind === 'websocket' || kind === 'grpc' || kind === 'http'
+    ? kind
+    : 'unknown';
+  const protocolName = protocolLabel(protocol);
+  return {
+    code: 'MISSIO_UNSUPPORTED_SNIPPET_EXPORT',
+    protocol,
+    protocolName,
+    supportedProtocols: ['http'],
+    message: `${protocolName} snippet export is not implemented. Missio can export HTTP snippets; use dry run or send_request to inspect the resolved ${protocolName} request without losing protocol-specific fields.`,
+  };
+}
+
+export function throwUnsupportedSnippetExport(request: OpenCollectionRequest | unknown): never {
+  throw new UnsupportedSnippetExportError(getUnsupportedSnippetDiagnostic(request));
+}
+
+function protocolLabel(protocol: RequestProtocol | 'unknown'): string {
+  switch (protocol) {
+    case 'http': return 'HTTP';
+    case 'graphql': return 'GraphQL';
+    case 'websocket': return 'WebSocket';
+    case 'grpc': return 'gRPC';
+    default: return 'OpenCollection';
+  }
+}
+
 // httpsnippet's internal prepare() uses Node's legacy url.parse(), which
 // percent-encodes {{ and }} in URLs (e.g. {{baseUrl}} → %7B%7BbaseUrl%7D%7D).
 // We swap template vars to safe placeholders before calling prepare() and
diff --git a/src/services/webSocketClient.ts b/src/services/webSocketClient.ts
index aa1d698..25c8b9e 100644
--- a/src/services/webSocketClient.ts
+++ b/src/services/webSocketClient.ts
@@ -14,6 +14,7 @@ import type {
   WebSocketRequest,
 } from '../models/types';
 import type { EnvironmentService } from './environmentService';
+import { RequestCancelledError } from './requestCancelledError';
 import type { SecretService } from './secretService';
 
 export interface ResolvedWebSocketRequest {
@@ -150,7 +151,7 @@ export class WebSocketClient implements vscode.Disposable {
       this._activeSockets.set(requestId, {
         socket,
         cancel: () => {
-          fail(new Error('Request cancelled'));
+          fail(new RequestCancelledError());
           socket.terminate();
         },
       });
diff --git a/test/grpcSupport.test.ts b/test/grpcSupport.test.ts
index 7248a5a..b77dab6 100644
--- a/test/grpcSupport.test.ts
+++ b/test/grpcSupport.test.ts
@@ -10,6 +10,7 @@ import type { MissioCollection, RequestDefaults } from '../src/models/types';
 import { EnvironmentService } from '../src/services/environmentService';
 import { GrpcClient } from '../src/services/grpcClient';
 import { RequestExecutionService } from '../src/services/requestExecutionService';
+import { RuntimeExecutionError, RuntimeExecutionService } from '../src/services/runtimeExecutionService';
 import { validateCollection } from '../src/services/validationService';
 import {
   applyCollectionEditorModel,
@@ -203,20 +204,28 @@ async function startServer(): Promise<void> {
   server = new grpc.Server();
   server.addService(proto.missio.demo.DemoService.service, {
     echoUnary(call: grpc.ServerUnaryCall<any, any>, callback: grpc.sendUnaryData<any>) {
-      const metadataValue = (name: string) => String(call.metadata.get(name)[0] ?? '');
-      const metadata = new grpc.Metadata();
-      metadata.set('x-demo-grpc', 'ok');
-      call.sendMetadata(metadata);
-      callback(null, {
-        message: `Hello ${call.request.name}`,
-        name: call.request.name,
-        userId: call.request.userId,
-        requestId: call.request.trace?.requestId ?? '',
-        authorization: metadataValue('authorization'),
-        defaultMetadata: metadataValue('x-demo-default'),
-        folderMetadata: metadataValue('x-demo-folder'),
-        requestMetadata: metadataValue('x-demo-request'),
-      });
+      const reply = () => {
+        const metadataValue = (name: string) => String(call.metadata.get(name)[0] ?? '');
+        const metadata = new grpc.Metadata();
+        metadata.set('x-demo-grpc', 'ok');
+        call.sendMetadata(metadata);
+        callback(null, {
+          message: `Hello ${call.request.name}`,
+          name: call.request.name,
+          userId: call.request.userId,
+          requestId: call.request.trace?.requestId ?? '',
+          authorization: metadataValue('authorization'),
+          defaultMetadata: metadataValue('x-demo-default'),
+          folderMetadata: metadataValue('x-demo-folder'),
+          requestMetadata: metadataValue('x-demo-request'),
+        });
+      };
+      if (call.request.userId === 999) {
+        const timer = setTimeout(reply, 250);
+        call.on('cancelled', () => clearTimeout(timer));
+        return;
+      }
+      reply();
     },
     streamUsers(call: grpc.ServerWritableStream<any, any>) {
       if (call.request.userId === 999) {
@@ -342,6 +351,181 @@ describe('gRPC execution', () => {
     }, collection)).rejects.toThrow(/API key query auth is not supported for gRPC/);
   });
 
+  it('runs runtime lifecycle around unary gRPC metadata and message construction', async () => {
+    const environmentService = makeEnvironmentService();
+    const collection = makeCollection();
+    const localEnv = collection.data.config?.environments?.find(env => env.name === 'LOCAL');
+    localEnv?.variables?.push({ name: 'grpcBaseUrl', value: address });
+    await environmentService.setActiveEnvironment(collection.id, 'LOCAL');
+    const grpcClient = new GrpcClient(environmentService);
+    const runtime = new RuntimeExecutionService((runtimeCollection, folderDefaults, environmentName) =>
+      environmentService.resolveVariables(runtimeCollection, folderDefaults, environmentName),
+    );
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      undefined,
+      grpcClient,
+      runtime,
+    );
+    const request = {
+      ...makeUnaryRequest(address),
+      grpc: {
+        ...makeUnaryRequest(address).grpc,
+        message: '{"name":"before","userId":0,"trace":{"requestId":"before"}}',
+      },
+      runtime: {
+        auth: { type: 'bearer' as const, token: '{{grpcToken}}' },
+        variables: [{ name: 'grpcRuntimeUserId', value: '77' }],
+        scripts: [
+          {
+            type: 'before-request' as const,
+            code: [
+              'missio.variables.set("grpcRuntimeName", "Runtime Ada");',
+              'missio.variables.set("grpcRuntimeTrace", "runtime-" + missio.variables.get("grpcRequestId"));',
+              'missio.request.metadata.set("x-demo-request", "script-" + missio.variables.get("grpcRequestId"));',
+              'missio.request.body = { name: missio.variables.get("grpcRuntimeName"), userId: Number(missio.variables.get("grpcRuntimeUserId")), trace: { requestId: missio.variables.get("grpcRuntimeTrace") } };',
+            ].join('\n'),
+          },
+          {
+            type: 'after-response' as const,
+            code: 'console.info("grpc after", response.json().requestId);',
+          },
+          {
+            type: 'tests' as const,
+            code: 'test("grpc runtime response", () => assert(response.json().name === "Runtime Ada"));',
+          },
+        ],
+        assertions: [
+          { expression: 'res.body.requestId', operator: 'equals', value: 'runtime-trace-123' },
+          { expression: 'res.body.userId', operator: 'equals', value: '77' },
+        ],
+        actions: [
+          {
+            type: 'set-variable' as const,
+            selector: { method: 'jsonq' as const, expression: '$.requestId' },
+            variable: { scope: 'runtime' as const, name: 'grpcRuntimeRequestId' },
+          },
+        ],
+      },
+    };
+
+    const response = await execution.send(request as any, collection, {
+      metadata: [{ name: 'x-demo-folder', value: 'folder-{{grpcRequestId}}' }],
+    });
+    const body = JSON.parse(response.body);
+
+    expect(body).toMatchObject({
+      message: 'Hello Runtime Ada',
+      name: 'Runtime Ada',
+      userId: 77,
+      requestId: 'runtime-trace-123',
+      authorization: 'Bearer token-abc',
+      requestMetadata: 'script-trace-123',
+      folderMetadata: 'folder-trace-123',
+    });
+    expect(response.runtime?.success).toBe(true);
+    expect(response.runtime?.summary).toEqual({ passed: 4, failed: 0, skipped: 0 });
+    expect(response.runtime?.variableMutations.map(mutation => mutation.name)).toEqual([
+      'grpcRuntimeName',
+      'grpcRuntimeTrace',
+      'grpcRuntimeRequestId',
+    ]);
+    expect(response.runtime?.logs[0].message).toBe('grpc after runtime-trace-123');
+  });
+
+  it('runs after-response runtime for unary gRPC failures without hiding diagnostics', async () => {
+    const environmentService = makeEnvironmentService();
+    const collection = makeCollection();
+    await environmentService.setActiveEnvironment(collection.id, 'LOCAL');
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      undefined,
+      new GrpcClient(environmentService),
+      new RuntimeExecutionService((runtimeCollection, folderDefaults, environmentName) =>
+        environmentService.resolveVariables(runtimeCollection, folderDefaults, environmentName),
+      ),
+    );
+    const request = {
+      ...makeUnaryRequest(address),
+      grpc: {
+        ...makeUnaryRequest(address).grpc,
+        method: 'missio.demo.DemoService/MissingMethod',
+      },
+      runtime: {
+        scripts: [{
+          type: 'tests' as const,
+          code: 'test("grpc error is visible", () => assert(response.json().error.message.includes("was not found")));',
+        }],
+        assertions: [
+          { expression: 'res.status', operator: 'equals', value: '200' },
+        ],
+      },
+    };
+
+    const response = await execution.send(request as any, collection);
+
+    expect(response.status).toBe(0);
+    expect(JSON.parse(response.body).error.message).toMatch(/MissingMethod.*was not found/);
+    expect(response.runtime?.success).toBe(false);
+    expect(response.runtime?.tests[0]).toMatchObject({ name: 'grpc error is visible', passed: true });
+    expect(response.runtime?.assertions[0].passed).toBe(false);
+  });
+
+  it('denies unsafe unary gRPC runtime scripts before opening a call', async () => {
+    const environmentService = makeEnvironmentService();
+    const collection = makeCollection();
+    await environmentService.setActiveEnvironment(collection.id, 'LOCAL');
+    const grpcClient = new GrpcClient(environmentService);
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      undefined,
+      grpcClient,
+      new RuntimeExecutionService((runtimeCollection, folderDefaults, environmentName) =>
+        environmentService.resolveVariables(runtimeCollection, folderDefaults, environmentName),
+      ),
+    );
+    const request = {
+      ...makeUnaryRequest(address),
+      runtime: {
+        scripts: [{ type: 'before-request' as const, code: 'require("fs").readFileSync("package.json", "utf8");' }],
+      },
+    };
+
+    await expect(execution.send(request as any, collection)).rejects.toBeInstanceOf(RuntimeExecutionError);
+    expect((grpcClient as any)._activeCalls.size).toBe(0);
+  });
+
+  it('cancels runtime-prepared unary gRPC calls and cleans up active state', async () => {
+    const environmentService = makeEnvironmentService();
+    const collection = makeCollection();
+    await environmentService.setActiveEnvironment(collection.id, 'LOCAL');
+    const grpcClient = new GrpcClient(environmentService);
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      undefined,
+      grpcClient,
+      new RuntimeExecutionService((runtimeCollection, folderDefaults, environmentName) =>
+        environmentService.resolveVariables(runtimeCollection, folderDefaults, environmentName),
+      ),
+    );
+    const request = {
+      ...makeUnaryRequest(address),
+      grpc: {
+        ...makeUnaryRequest(address).grpc,
+        message: '{"name":"Slow Ada","userId":999,"trace":{"requestId":"cancel-runtime"}}',
+      },
+      runtime: {
+        scripts: [{ type: 'before-request' as const, code: 'missio.variables.set("prepared", "yes");' }],
+      },
+    };
+
+    const pending = execution.send(request as any, collection);
+    setTimeout(() => execution.cancelAll(), 10);
+
+    await expect(pending).rejects.toThrow(/cancelled/i);
+    expect((grpcClient as any)._activeCalls.size).toBe(0);
+  });
+
   it('executes server-streaming calls and returns ordered response events', async () => {
     const environmentService = makeEnvironmentService();
     const collection = makeCollection();
@@ -530,4 +714,33 @@ describe('gRPC integration surfaces', () => {
 
     expect(JSON.parse(response.body).message).toBe('Hello Ada');
   });
+
+  it('smoke tests the committed demo unary gRPC runtime lifecycle request', async () => {
+    const environmentService = makeEnvironmentService();
+    const collection = makeCollection();
+    const localEnv = collection.data.config?.environments?.find(env => env.name === 'LOCAL');
+    localEnv?.variables?.push({ name: 'grpcBaseUrl', value: address });
+    await environmentService.setActiveEnvironment(collection.id, 'LOCAL');
+    const request = parseYaml(fs.readFileSync(path.join(demoRoot, 'gRPC', 'runtime-unary-lifecycle.yml'), 'utf-8'));
+    const grpcClient = new GrpcClient(environmentService);
+    const response = await new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      undefined,
+      grpcClient,
+      new RuntimeExecutionService((runtimeCollection, folderDefaults, environmentName) =>
+        environmentService.resolveVariables(runtimeCollection, folderDefaults, environmentName),
+      ),
+    ).send(request as any, collection, {
+      metadata: [{ name: 'x-demo-folder', value: 'folder-{{grpcRequestId}}' }],
+    });
+    const body = JSON.parse(response.body);
+
+    expect(body).toMatchObject({
+      name: 'Runtime Ada',
+      userId: 77,
+      requestMetadata: 'script-trace-123',
+    });
+    expect(response.runtime?.success).toBe(true);
+    expect(response.runtime?.actions[0]).toMatchObject({ target: 'runtime.grpcRuntimeRequestId' });
+  });
 });
diff --git a/test/requestExecutionDiagnostics.test.ts b/test/requestExecutionDiagnostics.test.ts
new file mode 100644
index 0000000..2e84f6d
--- /dev/null
+++ b/test/requestExecutionDiagnostics.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { MissioCollection } from '../src/models/types';
+import { RequestCancelledError } from '../src/services/requestCancelledError';
+import { RequestExecutionService } from '../src/services/requestExecutionService';
+
+const collection = {
+  id: 'diagnostics',
+  filePath: 'opencollection.yml',
+  rootDir: process.cwd(),
+  data: {},
+} as MissioCollection;
+
+const httpClient = {
+  send: vi.fn(),
+  buildResolvedRequest: vi.fn(),
+  cancelAll: vi.fn(),
+} as any;
+
+describe('request execution diagnostics', () => {
+  it('rejects streaming gRPC runtime work before opening the transport', async () => {
+    const grpcClient = { send: vi.fn(), cancelAll: vi.fn() };
+    const runtime = { hasRuntimeWork: vi.fn().mockReturnValue(true) } as any;
+    const execution = new RequestExecutionService(httpClient, undefined, grpcClient, runtime);
+
+    await expect(execution.send({
+      info: { name: 'Streaming runtime', type: 'grpc' },
+      grpc: {
+        url: 'localhost:50051',
+        method: 'missio.demo.UserService/StreamUsers',
+        methodType: 'server-streaming',
+      },
+      runtime: {
+        scripts: [{ type: 'before-request', code: 'missio.variables.set("attempted", "yes");' }],
+      },
+    } as any, collection)).rejects.toMatchObject({
+      code: 'MISSIO_UNSUPPORTED_PROTOCOL',
+      diagnostic: {
+        protocol: 'grpc',
+        taskId: 'OC-080',
+        message: expect.stringContaining('The streaming request was not sent.'),
+      },
+    });
+    expect(grpcClient.send).not.toHaveBeenCalled();
+  });
+
+  it('recognizes typed cancellation independently of the message text', async () => {
+    const cancellation = new RequestCancelledError('Stopped by caller');
+    const webSocketClient = {
+      send: vi.fn().mockRejectedValue(cancellation),
+      cancelAll: vi.fn(),
+      disconnect: vi.fn(),
+    };
+    const request = {
+      info: { name: 'Typed cancellation', type: 'websocket' },
+      websocket: { url: 'ws://localhost/hold' },
+      runtime: { scripts: [{ type: 'before-request', code: 'console.log("prepared");' }] },
+    } as any;
+    const runtime = {
+      hasRuntimeWork: vi.fn().mockReturnValue(true),
+      prepareWebSocketRequest: vi.fn().mockResolvedValue({ request }),
+      completeWebSocketRequest: vi.fn(),
+    } as any;
+    const execution = new RequestExecutionService(httpClient, webSocketClient, undefined, runtime);
+
+    await expect(execution.send(request, collection)).rejects.toBe(cancellation);
+    expect(runtime.completeWebSocketRequest).not.toHaveBeenCalled();
+  });
+});
diff --git a/test/responseProvider.test.ts b/test/responseProvider.test.ts
index 8627c5a..21a8732 100644
--- a/test/responseProvider.test.ts
+++ b/test/responseProvider.test.ts
@@ -73,4 +73,37 @@ describe('ResponseDocumentProvider runtime formatting', () => {
     expect(content).toContain('sent #1 first');
     expect(content).toContain('received #1: {"name":"ack:Ada"}');
   });
+
+  it('prints runtime results for WebSocket response envelopes', () => {
+    const provider = Object.create(ResponseDocumentProvider.prototype) as ResponseDocumentProvider;
+    const response: HttpResponse = {
+      status: 101,
+      statusText: 'WebSocket Exchange',
+      headers: {
+        'content-type': 'application/json',
+        'x-missio-protocol': 'websocket',
+      },
+      body: '{"protocol":"websocket","messageCount":1}',
+      duration: 9,
+      size: 41,
+      runtime: {
+        success: true,
+        summary: { passed: 1, failed: 0, skipped: 0 },
+        tests: [{ name: 'socket echoed', passed: true }],
+        assertions: [],
+        actions: [],
+        variableMutations: [{ scope: 'runtime', name: 'socketToken', value: 'ok', source: 'script' }],
+        logs: [],
+        errors: [],
+      },
+    };
+
+    const content = (provider as any)._formatResponse(response);
+
+    expect(content).toContain('HTTP 101 WebSocket Exchange');
+    expect(content).toContain('x-missio-protocol: websocket');
+    expect(content).toContain('Runtime Results');
+    expect(content).toContain('PASS socket echoed');
+    expect(content).toContain('runtime.socketToken = ok');
+  });
 });
diff --git a/test/sendRequestTool.test.ts b/test/sendRequestTool.test.ts
index f44b6d8..24c5a40 100644
--- a/test/sendRequestTool.test.ts
+++ b/test/sendRequestTool.test.ts
@@ -305,6 +305,58 @@ describe('SendRequestTool runtime output', () => {
     expect(parsed.stream.receivedMessageCount).toBe(2);
   });
 
+  it('includes WebSocket runtime output in successful non-HTTP responses', async () => {
+    const collection = makeCollection();
+    const tool = new SendRequestTool(
+      {
+        loadRequestFile: async () => ({
+          info: { name: 'Runtime socket', type: 'websocket' },
+          websocket: { url: 'ws://127.0.0.1/socket' },
+        }),
+        getCollection: () => collection,
+        getCollections: () => [collection],
+      } as any,
+      {
+        resolveVariables: async () => new Map<string, string>(),
+      } as any,
+      {
+        send: async () => ({
+          status: 101,
+          statusText: 'WebSocket Exchange',
+          headers: { 'x-missio-protocol': 'websocket' },
+          body: '{"protocol":"websocket","messageCount":1}',
+          duration: 3,
+          size: 41,
+          runtime: {
+            success: true,
+            summary: { passed: 2, failed: 0, skipped: 0 },
+            logs: [{ phase: 'after-response', level: 'log', message: 'socket ok' }],
+            tests: [{ name: 'socket echoed', passed: true }],
+            assertions: [{ expression: 'res.body.messageCount', operator: 'equals', expected: '1', actual: 1, passed: true }],
+            actions: [],
+            variableMutations: [{ scope: 'runtime', name: 'socketToken', value: 'ok', source: 'script' }],
+            errors: [],
+          },
+        }),
+      } as any,
+    );
+
+    const output = await tool.call(
+      {
+        input: {
+          requestFilePath: '/tmp/socket.yml',
+          collectionId: 'collection-1',
+        },
+      } as any,
+      {} as any,
+    );
+
+    const parsed = JSON.parse(output);
+    expect(parsed.protocol).toBe('websocket');
+    expect(parsed.runtime.summary.passed).toBe(2);
+    expect(parsed.runtime.logs[0].message).toBe('socket ok');
+  });
+
   it('returns runtime diagnostics when before-request scripts abort execution', async () => {
     const collection = makeCollection();
     const runtime = {
diff --git a/test/webSocketSupport.test.ts b/test/webSocketSupport.test.ts
index 05c1f7c..b233717 100644
--- a/test/webSocketSupport.test.ts
+++ b/test/webSocketSupport.test.ts
@@ -11,6 +11,7 @@ import { ListRequestsTool } from '../src/copilot/tools/listRequestsTool';
 import { SendRequestTool } from '../src/copilot/tools/sendRequestTool';
 import { RequestEditorProvider } from '../src/panels/requestPanel';
 import { RequestExecutionService } from '../src/services/requestExecutionService';
+import { RuntimeExecutionError, RuntimeExecutionService } from '../src/services/runtimeExecutionService';
 import { WebSocketClient } from '../src/services/webSocketClient';
 import { detectUnresolvedVars } from '../src/services/unresolvedVars';
 import { validateCollection } from '../src/services/validationService';
@@ -151,6 +152,7 @@ async function startFixture(): Promise<Fixture> {
             'x-demo-client': req.headers['x-demo-client'],
             'x-collection': req.headers['x-collection'],
             'x-folder': req.headers['x-folder'],
+            'x-runtime-header': req.headers['x-runtime-header'],
           },
           message: JSON.parse(text),
         }));
@@ -309,6 +311,184 @@ describe('WebSocket execution lifecycle', () => {
     expect(client.activeConnectionCount).toBe(0);
   });
 
+  it('runs runtime lifecycle around WebSocket request mutation and exchange summaries', async () => {
+    const fixture = await startFixture();
+    const envService = makeEnvService({
+      wsBaseUrl: fixture.baseUrl,
+      tenant: 'nz',
+      token: 'token-abc',
+    });
+    const client = new WebSocketClient(envService);
+    const runtime = new RuntimeExecutionService((collection, folderDefaults, environmentName) =>
+      envService.resolveVariables(collection, folderDefaults, environmentName),
+    );
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      client,
+      undefined,
+      runtime,
+    );
+    const request: WebSocketRequest = {
+      info: { name: 'Runtime socket', type: 'websocket' },
+      websocket: {
+        url: '{{wsBaseUrl}}/ws/auth',
+        message: { type: 'json', data: '{"user":"before","count":0}' },
+      },
+      runtime: {
+        auth: { type: 'bearer', token: '{{token}}' },
+        variables: [{ name: 'runtimeCount', value: '7' }],
+        scripts: [
+          {
+            type: 'before-request',
+            code: [
+              'missio.variables.set("runtimeUser", "Ada Runtime");',
+              'missio.request.headers.set("X-Demo-Client", "missio-demo");',
+              'missio.request.headers.set("X-Runtime-Header", "scripted");',
+              'missio.request.body = { user: missio.variables.get("runtimeUser"), count: Number(missio.variables.get("runtimeCount")) };',
+            ].join('\n'),
+          },
+          {
+            type: 'after-response',
+            code: [
+              'const inbound = response.json().events.find(event => event.direction === "inbound");',
+              'const payload = JSON.parse(inbound.data);',
+              'console.log("websocket after", payload.message.user);',
+              'missio.variables.set("afterUser", payload.message.user);',
+            ].join('\n'),
+          },
+          {
+            type: 'tests',
+            code: [
+              'const inbound = response.json().events.find(event => event.direction === "inbound");',
+              'const payload = JSON.parse(inbound.data);',
+              'test("websocket runtime payload echoed", () => assert(payload.message.count === 7));',
+            ].join('\n'),
+          },
+        ],
+        assertions: [
+          { expression: 'res.body.messageCount', operator: 'equals', value: '1' },
+        ],
+        actions: [
+          {
+            type: 'set-variable',
+            selector: { method: 'jsonq', expression: '$.messageCount' },
+            variable: { scope: 'runtime', name: 'wsMessageCount' },
+          },
+        ],
+      } as any,
+    };
+
+    const response = await execution.send(request, makeCollection(), undefined, undefined, undefined, undefined, undefined, { requestId: 'runtime-ws' });
+    const body = JSON.parse(response.body);
+    const inbound = body.events.find((event: any) => event.direction === 'inbound');
+    const payload = JSON.parse(inbound.data);
+
+    expect(payload).toMatchObject({
+      ok: true,
+      headers: {
+        authorization: 'Bearer token-abc',
+        'x-demo-client': 'missio-demo',
+        'x-runtime-header': 'scripted',
+      },
+      message: { user: 'Ada Runtime', count: 7 },
+    });
+    expect(response.runtime?.success).toBe(true);
+    expect(response.runtime?.summary).toEqual({ passed: 3, failed: 0, skipped: 0 });
+    expect(response.runtime?.actions[0]).toMatchObject({ passed: true, target: 'runtime.wsMessageCount', value: 1 });
+    expect(response.runtime?.variableMutations.map(mutation => mutation.name)).toEqual(['runtimeUser', 'wsMessageCount', 'afterUser']);
+    expect(response.runtime?.logs[0].message).toBe('websocket after Ada Runtime');
+    expect(client.activeConnectionCount).toBe(0);
+  });
+
+  it('runs after-response runtime on WebSocket terminal errors and preserves cleanup', async () => {
+    const fixture = await startFixture();
+    const envService = makeEnvService({ wsBaseUrl: fixture.baseUrl, tenant: 'nz' });
+    const client = new WebSocketClient(envService);
+    const runtime = new RuntimeExecutionService((collection, folderDefaults, environmentName) =>
+      envService.resolveVariables(collection, folderDefaults, environmentName),
+    );
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      client,
+      undefined,
+      runtime,
+    );
+    const request: WebSocketRequest = {
+      info: { name: 'Runtime reject', type: 'websocket' },
+      websocket: { url: '{{wsBaseUrl}}/ws/reject' },
+      runtime: {
+        scripts: [{
+          type: 'tests',
+          code: 'test("websocket error is visible", () => assert(response.json().error.message.includes("401")));',
+        }],
+        assertions: [
+          { expression: 'res.status', operator: 'equals', value: '101' },
+        ],
+      } as any,
+    };
+
+    const response = await execution.send(request, makeCollection());
+
+    expect(response.status).toBe(0);
+    expect(JSON.parse(response.body).error.message).toContain('401');
+    expect(response.runtime?.success).toBe(false);
+    expect(response.runtime?.tests[0]).toMatchObject({ name: 'websocket error is visible', passed: true });
+    expect(response.runtime?.assertions[0].passed).toBe(false);
+    expect(client.activeConnectionCount).toBe(0);
+  });
+
+  it('denies unsafe WebSocket runtime scripts before opening a socket', async () => {
+    const fixture = await startFixture();
+    const envService = makeEnvService({ wsBaseUrl: fixture.baseUrl, tenant: 'nz' });
+    const client = new WebSocketClient(envService);
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      client,
+      undefined,
+      new RuntimeExecutionService((collection, folderDefaults, environmentName) =>
+        envService.resolveVariables(collection, folderDefaults, environmentName),
+      ),
+    );
+
+    await expect(execution.send({
+      info: { name: 'Unsafe runtime', type: 'websocket' },
+      websocket: { url: '{{wsBaseUrl}}/ws/echo' },
+      runtime: {
+        scripts: [{ type: 'before-request', code: 'require("fs").readFileSync("package.json", "utf8");' }],
+      } as any,
+    }, makeCollection())).rejects.toBeInstanceOf(RuntimeExecutionError);
+    expect(client.activeConnectionCount).toBe(0);
+  });
+
+  it('cancels WebSocket requests after runtime preparation without leaking sockets', async () => {
+    const fixture = await startFixture();
+    const envService = makeEnvService({ wsBaseUrl: fixture.baseUrl, tenant: 'nz' });
+    const client = new WebSocketClient(envService);
+    const execution = new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      client,
+      undefined,
+      new RuntimeExecutionService((collection, folderDefaults, environmentName) =>
+        envService.resolveVariables(collection, folderDefaults, environmentName),
+      ),
+    );
+    const pending = execution.send({
+      info: { name: 'Runtime hold', type: 'websocket' },
+      websocket: {
+        url: '{{wsBaseUrl}}/ws/hold',
+        message: { type: 'text', data: 'wait' },
+      },
+      runtime: {
+        scripts: [{ type: 'before-request', code: 'missio.variables.set("prepared", "yes");' }],
+      } as any,
+    }, makeCollection(), undefined, undefined, undefined, undefined, undefined, { requestId: 'runtime-hold' });
+
+    await waitFor(() => client.activeConnectionCount === 1);
+    expect(execution.disconnectWebSocket('runtime-hold')).toBe(true);
+    await expect(pending).rejects.toThrow('Request cancelled');
+    expect(client.activeConnectionCount).toBe(0);
+  });
+
   it('rejects invalid WebSocket URLs before connecting', async () => {
     const client = new WebSocketClient(makeEnvService({ tenant: 'nz' }));
 
@@ -577,4 +757,30 @@ describe('WebSocket demo fixtures', () => {
     const inbound = JSON.parse(response.body).events.find((event: any) => event.direction === 'inbound');
     expect(inbound.data).toBe('Hello Ada from ws-demo-001');
   });
+
+  it('smoke tests the committed demo WebSocket runtime lifecycle request', async () => {
+    const fixture = await startFixture();
+    const envService = makeEnvService({
+      wsBaseUrl: fixture.baseUrl,
+      demoToken: 'token-abc',
+      tenant: 'nz',
+    });
+    const request = parseYaml(fs.readFileSync(path.join(demoRoot, 'WebSocket', 'runtime-lifecycle.yml'), 'utf-8')) as WebSocketRequest;
+    const client = new WebSocketClient(envService);
+    const response = await new RequestExecutionService(
+      { send: vi.fn(), buildResolvedRequest: vi.fn(), cancelAll: vi.fn() } as any,
+      client,
+      undefined,
+      new RuntimeExecutionService((collection, folderDefaults, environmentName) =>
+        envService.resolveVariables(collection, folderDefaults, environmentName),
+      ),
+    ).send(request, makeCollection(demoRoot), undefined, undefined, undefined, undefined, undefined, { requestId: 'demo-runtime-ws' });
+
+    const inbound = JSON.parse(response.body).events.find((event: any) => event.direction === 'inbound');
+    const payload = JSON.parse(inbound.data);
+    expect(payload.message).toMatchObject({ user: 'Ada Runtime', count: 7 });
+    expect(response.runtime?.success).toBe(true);
+    expect(response.runtime?.actions[0]).toMatchObject({ target: 'runtime.runtimeSocketMessages', value: 1 });
+    expect(client.activeConnectionCount).toBe(0);
+  });
 });