diff --git a/.yoi/tickets/00001KVMFFYVX/item.md b/.yoi/tickets/00001KVMFFYVX/item.md
index 90e95889..76a8683a 100644
--- a/.yoi/tickets/00001KVMFFYVX/item.md
+++ b/.yoi/tickets/00001KVMFFYVX/item.md
@@ -1,8 +1,8 @@
 ---
 title: 'Workspace web control plane bootstrap'
-state: 'inprogress'
+state: 'closed'
 created_at: '2026-06-21T06:57:06Z'
-updated_at: '2026-06-21T07:15:03Z'
+updated_at: '2026-06-21T07:46:46Z'
 assignee: null
 queued_by: 'workspace-panel'
 queued_at: '2026-06-21T07:11:58Z'
diff --git a/.yoi/tickets/00001KVMFFYVX/resolution.md b/.yoi/tickets/00001KVMFFYVX/resolution.md
new file mode 100644
index 00000000..eadcfd62
--- /dev/null
+++ b/.yoi/tickets/00001KVMFFYVX/resolution.md
@@ -0,0 +1,25 @@
+Workspace web control plane bootstrap を実装し、Orchestrator worktree の `orchestration` branch に統合した。
+
+主な成果:
+- New backend library crate `yoi-workspace-server` / `crates/workspace-server` を追加。
+- Axum-based read-only HTTP API と static/SPA serving surface を追加。
+- `/api/...` と static/SPA fallback を分離し、API route miss を SPA fallback に飲ませない設計にした。
+- `ControlPlaneStore` trait と SQLite implementation `SqliteWorkspaceStore` を追加。
+- SQLite migration/version table、WAL、foreign keys、busy timeout を設定。
+- `.yoi/tickets` と `.yoi/objectives` を canonical read sources として扱う local project-record bridge を追加し、既存 record workflow を移行・変更しない。
+- Read APIs: `/api/workspace`, `/api/tickets`, `/api/tickets/{id}`, `/api/objectives`, `/api/objectives/{id}`, `/api/runs`, `/api/runners`。
+- Future runner/event-stream extension seams を response/state shape に用意しつつ、scheduler/runner dispatch/write API は実装しない。
+- SvelteKit static SPA skeleton を `web/workspace` に追加し、npm lockfile、static adapter、README、generated artifact ignore/source-filter handling を追加。
+- `Cargo.lock` と `package.nix` cargo hash / source filtering を更新。
+
+統合・検証:
+- Merge commit: `3e03e536 merge: workspace web control plane`
+- Implementation commit: `ab7658c1 feat: bootstrap workspace web control plane`
+- Reviewer final verdict: approve
+- Validation passed: `cargo fmt --check`, `git diff --check HEAD^1..HEAD`, `cargo test -p yoi-workspace-server`, `cargo check -p yoi-workspace-server`, `cargo check -p yoi`, `cd web/workspace && npm ci && npm run check && npm run build`, `cargo run -p yoi -- ticket doctor`, `cargo run -p yoi -- objective doctor`, and `nix build .#yoi --no-link`。
+
+範囲外 / deferrals:
+- Product CLI/server launch command は未追加。backend library exposes `serve(...)`; launch surface は future Ticket で設計する。
+- Write API、runner job dispatch、scheduler、hosted/multi-tenant auth、billing/quota、memory migration は実装していない。
+- Event stream implementation は未実装で、extension seam のみ。
+- Generated SPA assets are not committed; configured static directory such as `web/workspace/build` can be served after frontend build。
\ No newline at end of file
diff --git a/.yoi/tickets/00001KVMFFYVX/thread.md b/.yoi/tickets/00001KVMFFYVX/thread.md
index c77ba471..c9d1c547 100644
--- a/.yoi/tickets/00001KVMFFYVX/thread.md
+++ b/.yoi/tickets/00001KVMFFYVX/thread.md
@@ -152,3 +152,287 @@ Next action:
 - Wait for Coder implementation report, then spawn Reviewer read-only for the implementation diff. Orchestrator will not merge/close until reviewer approval and validation evidence are available。
 
 ---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T07:37:30Z -->
+
+## Implementation report
+
+Coder implementation report received from `yoi-coder-00001KVMFFYVX`.
+
+Implementation commit:
+- `ab7658c1 feat: bootstrap workspace web control plane`
+
+Changed areas:
+- New Cargo workspace crate:
+  - `crates/workspace-server`
+  - HTTP router with `/api/...` separation from static/SPA fallback。
+  - Local/dev workspace API state carrying `workspace_id`。
+  - Bounded read APIs for `/api/workspace`, `/api/tickets`, `/api/tickets/{id}`, `/api/objectives`, `/api/objectives/{id}`, `/api/runs`, `/api/runners`。
+  - Reserved extension-point response fields for future event streams and runner connections。
+- Store abstraction and SQLite implementation:
+  - `ControlPlaneStore` trait。
+  - `SqliteWorkspaceStore`。
+  - migration/version table。
+  - WAL, foreign keys, busy timeout。
+  - initial schema for workspace/runtime/projection seams while keeping `.yoi` records canonical。
+- Local project-record bridge:
+  - reads existing `.yoi/tickets`。
+  - reads existing `.yoi/objectives`。
+  - does not migrate or mutate canonical records。
+- SvelteKit static SPA skeleton:
+  - `web/workspace`
+  - npm + committed `package-lock.json`
+  - static adapter build output to `web/workspace/build`
+  - generated artifact handling documented in `web/workspace/README.md`。
+- Packaging/source handling:
+  - added Rust dependencies and updated `Cargo.lock`。
+  - updated `package.nix` cargo hash。
+  - excluded generated frontend directories from Nix package source filtering。
+
+Coder validation reported:
+- `cargo fmt --check`: passed
+- `cargo test -p yoi-workspace-server`: passed
+- `cargo check -p yoi-workspace-server`: passed
+- `cargo check -p yoi`: passed
+- `cd web/workspace && npm run check && npm run build`: passed
+- `git diff --check`: passed
+- `cargo run -p yoi -- ticket doctor`: passed
+- `cargo run -p yoi -- objective doctor`: passed
+- `nix build .#yoi --no-link`: passed after updating `cargoHash`
+
+Coder dependency/package/frontend decisions:
+- Used `axum` for HTTP routing。
+- Used `rusqlite` with bundled SQLite to avoid system SQLite packaging requirements。
+- Backend remains a library crate, not a product CLI façade。
+- No product `yoi` CLI command was added in this slice。
+- Frontend uses npm/SvelteKit static adapter with committed lockfile; generated build output is not checked in。
+- Nix package does not build frontend in this bootstrap; it excludes generated frontend artifacts from source filtering。
+
+Known deferrals reported:
+- No write API。
+- No runner job dispatch or scheduler。
+- No hosted/multi-tenant auth or SaaS behavior。
+- No event stream implementation yet; only reserved extension-point seam。
+- No checked-in generated SPA assets; backend can serve configured static directory such as `web/workspace/build` after running frontend build。
+
+Orchestrator evidence checked:
+- Implementation worktree is clean on `impl/00001KVMFFYVX-workspace-web-control-plane`。
+- HEAD is `ab7658c1`。
+- Diff `1d27f6c9..HEAD` touches expected backend/frontend/package files: 18 files, about 3377 insertions / 1 deletion。
+- `git diff --check 1d27f6c9..HEAD` produced no diagnostics。
+
+Next action:
+- Route to read-only Reviewer Pod for acceptance review against the Ticket and Objective context。
+
+---
+
+<!-- event: comment author: yoi-orchestrator at: 2026-06-21T07:38:14Z -->
+
+## Comment
+
+Review routing:
+
+Spawned read-only Reviewer Pod:
+- `yoi-reviewer-00001KVMFFYVX-r1`
+
+Review target:
+- Worktree: `/home/hare/Projects/yoi/.worktree/00001KVMFFYVX-workspace-web-control-plane`
+- Branch: `impl/00001KVMFFYVX-workspace-web-control-plane`
+- Baseline: `1d27f6c9`
+- Implementation commit: `ab7658c1 feat: bootstrap workspace web control plane`
+- Diff: `1d27f6c9..ab7658c1`
+
+Reviewer scope:
+- read-only `/home/hare/Projects/yoi`
+
+Reviewer focus:
+- Acceptance criteria for backend crate, store abstraction + SQLite, static SPA, bounded read APIs, static/API route separation, package/Nix/frontend hygiene。
+- No write API / scheduler / SaaS overreach。
+- `.yoi` Ticket / Objective records remain canonical and read-only。
+- SQLite migrations/settings are deterministic and server-appropriate。
+- Frontend generated artifacts are not committed and source filtering is safe。
+- Validation evidence includes Rust tests/checks, frontend check/build, doctors, and `nix build .#yoi --no-link`。
+
+Orchestrator will wait for reviewer verdict before integration。
+
+---
+
+<!-- event: review author: yoi-reviewer-00001KVMFFYVX-r1 at: 2026-06-21T07:44:49Z status: approve -->
+
+## Review: approve
+
+Verdict: `approve`
+
+確認範囲:
+- Ticket/context:
+  - `.yoi/tickets/00001KVMFFYVX/item.md`
+  - `.yoi/tickets/00001KVMFFYVX/thread.md`
+  - `.yoi/objectives/00001KVJPT2PP/item.md`
+- Diff `1d27f6c9..ab7658c1`:
+  - `Cargo.toml`
+  - `Cargo.lock`
+  - `crates/workspace-server/Cargo.toml`
+  - `crates/workspace-server/src/lib.rs`
+  - `crates/workspace-server/src/server.rs`
+  - `crates/workspace-server/src/store.rs`
+  - `crates/workspace-server/src/records.rs`
+  - `package.nix`
+  - `web/workspace/package.json`
+  - `web/workspace/package-lock.json`
+  - `web/workspace/.gitignore`
+  - `web/workspace/README.md`
+  - `web/workspace/svelte.config.js`
+  - `web/workspace/vite.config.ts`
+  - `web/workspace/tsconfig.json`
+  - `web/workspace/src/app.html`
+  - `web/workspace/src/routes/+layout.ts`
+  - `web/workspace/src/routes/+page.svelte`
+
+Blocking issues:
+- None found。
+
+Acceptance verification:
+- New `yoi-workspace-server` crate is a library/backend crate, not a product CLI façade。
+- Existing `yoi` CLI ownership is preserved; `yoi` does not depend on the new crate。
+- HTTP routes are read-only `GET` routes for `/api/workspace`, `/api/tickets`, `/api/tickets/{id}`, `/api/objectives`, `/api/objectives/{id}`, `/api/runs`, `/api/runners`。
+- SPA/static fallback explicitly rejects `/api` and `/api/...`, so API paths are not swallowed by SPA fallback。
+- `.yoi/tickets` and `.yoi/objectives` remain canonical read sources; no `.yoi` write/migration path was introduced。
+- Store abstraction is explicit via `ControlPlaneStore`; SQLite is behind `SqliteWorkspaceStore`。
+- SQLite setup includes migrations/version table, WAL, foreign keys, and busy timeout。
+- Runtime tables for runs/runners are skeletal/read-only and do not implement scheduling or dispatch。
+- Auth is explicitly represented as local/dev placeholder, not production SaaS auth。
+- SvelteKit frontend is static SPA skeleton with npm lockfile; generated `node_modules`, `.svelte-kit`, and `build` are ignored/excluded。
+- `package.nix` source filtering excludes frontend generated artifacts; `nix build .#yoi --no-link` passed with updated cargo hash。
+
+Non-blocking concerns:
+- No committed CLI/binary entrypoint or full listener smoke test for starting the server end-to-end. Library exposes `serve(...)` and router tests cover API/static separation, acceptable for bootstrap; follow-up should add launch surface when product command is designed。
+- Detail responses for tickets/objectives do not include `workspace_id`, while list/runtime responses do. Future multi-workspace API expansion should make detail shapes consistently workspace-qualified。
+- Missing valid objective IDs appear likely to map filesystem `Io` errors to HTTP 500 rather than 404. Tighten when read API contract is hardened。
+- Static path traversal rejects `..`, but symlink escape hardening is not implemented. Acceptable for configured local build/static directory and local/dev bootstrap, revisit before non-local exposure。
+
+Reviewer validation:
+- `cargo fmt --check`: passed
+- `git diff --check 1d27f6c9..HEAD`: passed
+- `cargo test -p yoi-workspace-server`: passed
+- `cargo check -p yoi-workspace-server`: passed
+- `cargo check -p yoi`: passed
+- `cd web/workspace && npm run check && npm run build`: initially failed because `node_modules` absent。
+- `cd web/workspace && npm ci && npm run check && npm run build`: passed
+- `cargo run -p yoi -- ticket doctor`: passed
+- `cargo run -p yoi -- objective doctor`: passed
+- `nix build .#yoi --no-link`: passed
+- Focused route/static validation:
+  - Inspected router definitions and fallback logic。
+  - Existing `yoi-workspace-server` tests exercise `/api/workspace`, `/api/tickets`, `/api/objectives`, `/api/runners`, static asset serving, SPA fallback, and `/api/...` miss separation。
+  - Store migration/persistence and local record read bridge are covered by crate tests。
+
+Worktree status:
+- Tracked worktree clean at `ab7658c1` on `impl/00001KVMFFYVX-workspace-web-control-plane`。
+- Ignored validation artifacts remain in the implementation worktree: `web/workspace/node_modules/`, `web/workspace/.svelte-kit/`, `web/workspace/build/`。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T07:45:59Z -->
+
+## Implementation report
+
+Reviewer r1 approvalを受けて、実装ブランチを Orchestrator worktree の `orchestration` branch に統合した。
+
+統合:
+- Merge commit: `3e03e536 merge: workspace web control plane`
+- Merged branch: `impl/00001KVMFFYVX-workspace-web-control-plane`
+- Implementation commit:
+  - `ab7658c1 feat: bootstrap workspace web control plane`
+
+Orchestrator worktree validation:
+- `cargo fmt --check`: passed
+- `git diff --check HEAD^1..HEAD`: passed
+- `cargo test -p yoi-workspace-server`: passed
+- `cargo check -p yoi-workspace-server`: passed
+- `cargo check -p yoi`: passed
+- `cd web/workspace && npm ci && npm run check && npm run build`: passed
+  - `npm ci` reported 4 low severity vulnerabilities via npm audit output; build/check succeeded and no blocking validation failure occurred。
+- `cargo run -p yoi -- ticket doctor`: passed (`doctor: ok`)
+- `cargo run -p yoi -- objective doctor`: passed (`doctor: ok`)
+- `nix build .#yoi --no-link`: passed
+
+Validation generated ignored frontend artifacts in Orchestrator worktree:
+- `web/workspace/node_modules/`
+- `web/workspace/.svelte-kit/`
+- `web/workspace/build/`
+
+These were removed after validation. Final Orchestrator worktree status after validation cleanup is clean on `orchestration` at `3e03e536`。
+
+---
+
+<!-- event: state_changed author: yoi-orchestrator at: 2026-06-21T07:46:04Z from: inprogress to: done reason: implementation_merged_and_validated field: state -->
+
+## State changed
+
+Reviewer approval、Orchestrator worktree への統合、Rust/frontend/Nix/doctor validation が完了したため `done` に遷移する。
+
+---
+
+<!-- event: state_changed author: hare at: 2026-06-21T07:46:19Z from: done to: closed reason: closed field: state -->
+
+## State changed
+
+Ticket を closed にしました。
+
+
+---
+
+<!-- event: close author: hare at: 2026-06-21T07:46:19Z status: closed -->
+
+## 完了
+
+Workspace web control plane bootstrap を実装し、Orchestrator worktree の `orchestration` branch に統合した。
+
+主な成果:
+- New backend library crate `yoi-workspace-server` / `crates/workspace-server` を追加。
+- Axum-based read-only HTTP API と static/SPA serving surface を追加。
+- `/api/...` と static/SPA fallback を分離し、API route miss を SPA fallback に飲ませない設計にした。
+- `ControlPlaneStore` trait と SQLite implementation `SqliteWorkspaceStore` を追加。
+- SQLite migration/version table、WAL、foreign keys、busy timeout を設定。
+- `.yoi/tickets` と `.yoi/objectives` を canonical read sources として扱う local project-record bridge を追加し、既存 record workflow を移行・変更しない。
+- Read APIs: `/api/workspace`, `/api/tickets`, `/api/tickets/{id}`, `/api/objectives`, `/api/objectives/{id}`, `/api/runs`, `/api/runners`。
+- Future runner/event-stream extension seams を response/state shape に用意しつつ、scheduler/runner dispatch/write API は実装しない。
+- SvelteKit static SPA skeleton を `web/workspace` に追加し、npm lockfile、static adapter、README、generated artifact ignore/source-filter handling を追加。
+- `Cargo.lock` と `package.nix` cargo hash / source filtering を更新。
+
+統合・検証:
+- Merge commit: `3e03e536 merge: workspace web control plane`
+- Implementation commit: `ab7658c1 feat: bootstrap workspace web control plane`
+- Reviewer final verdict: approve
+- Validation passed: `cargo fmt --check`, `git diff --check HEAD^1..HEAD`, `cargo test -p yoi-workspace-server`, `cargo check -p yoi-workspace-server`, `cargo check -p yoi`, `cd web/workspace && npm ci && npm run check && npm run build`, `cargo run -p yoi -- ticket doctor`, `cargo run -p yoi -- objective doctor`, and `nix build .#yoi --no-link`。
+
+範囲外 / deferrals:
+- Product CLI/server launch command は未追加。backend library exposes `serve(...)`; launch surface は future Ticket で設計する。
+- Write API、runner job dispatch、scheduler、hosted/multi-tenant auth、billing/quota、memory migration は実装していない。
+- Event stream implementation は未実装で、extension seam のみ。
+- Generated SPA assets are not committed; configured static directory such as `web/workspace/build` can be served after frontend build。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T07:46:46Z -->
+
+## Implementation report
+
+Post-close cleanup completed。
+
+- Stopped child Pods and reclaimed scope:
+  - `yoi-coder-00001KVMFFYVX`
+  - `yoi-reviewer-00001KVMFFYVX-r1`
+- Removed ignored frontend validation artifacts from child worktree before worktree removal:
+  - `web/workspace/node_modules/`
+  - `web/workspace/.svelte-kit/`
+  - `web/workspace/build/`
+- Removed implementation worktree:
+  - `/home/hare/Projects/yoi/.worktree/00001KVMFFYVX-workspace-web-control-plane`
+- Deleted implementation branch:
+  - `impl/00001KVMFFYVX-workspace-web-control-plane`
+- Orchestrator worktree remains clean on `orchestration` at `f33415c7`。
+
+Root/original workspace was not used for merge/validation/cleanup operations。
+
+---
diff --git a/.yoi/tickets/00001KVMG8FTW/artifacts/orchestration-plan.jsonl b/.yoi/tickets/00001KVMG8FTW/artifacts/orchestration-plan.jsonl
new file mode 100644
index 00000000..b89690f2
--- /dev/null
+++ b/.yoi/tickets/00001KVMG8FTW/artifacts/orchestration-plan.jsonl
@@ -0,0 +1 @@
+{"id":"orch-plan-20260621-071725-1","ticket_id":"00001KVMG8FTW","kind":"accepted_plan","accepted_plan":{"summary":"Refactor Plugin one-shot outbound host API from `host_api.https` / `grants.https` to URL-permission-based `host_api.request`, including manifest request targets, enablement grants, runtime two-stage authorization, local/private explicit permissions, inspection diagnostics, docs/templates, and focused tests.","branch":"impl/00001KVMG8FTW-plugin-request-host-api","worktree":"/home/hare/Projects/yoi/.worktree/00001KVMG8FTW-plugin-request-host-api","role_plan":"Orchestrator accepts parallel implementation, creates a child worktree, and spawns a narrow-scope Coder. Reviewer will be spawned read-only after Coder reports implementation commit(s). After approval, Orchestrator will integrate into `orchestration`, validate, record closure, and clean only the child worktree/branch. Coordinate manually if active Workspace web branch creates Cargo.lock/package.nix conflicts."},"author":"yoi-orchestrator","at":"2026-06-21T07:17:25Z"}
diff --git a/.yoi/tickets/00001KVMG8FTW/item.md b/.yoi/tickets/00001KVMG8FTW/item.md
index 85611349..31136383 100644
--- a/.yoi/tickets/00001KVMG8FTW/item.md
+++ b/.yoi/tickets/00001KVMG8FTW/item.md
@@ -1,8 +1,8 @@
 ---
 title: 'Plugin: host_api.https を廃止して URL 権限ベースの host_api.request に統合する'
-state: 'queued'
+state: 'closed'
 created_at: '2026-06-21T07:10:30Z'
-updated_at: '2026-06-21T07:15:41Z'
+updated_at: '2026-06-21T08:12:34Z'
 assignee: null
 readiness: 'implementation_ready'
 risk_flags: ['plugin', 'host-api', 'public-api', 'permissions', 'security', 'local-network', 'breaking-change']
diff --git a/.yoi/tickets/00001KVMG8FTW/resolution.md b/.yoi/tickets/00001KVMG8FTW/resolution.md
new file mode 100644
index 00000000..f9ffcfaa
--- /dev/null
+++ b/.yoi/tickets/00001KVMG8FTW/resolution.md
@@ -0,0 +1,23 @@
+Plugin host API の one-shot outbound request capability を `host_api.https` / `grants.https` から URL permission based `host_api.request` に置き換え、Orchestrator worktree の `orchestration` branch に統合した。
+
+主な成果:
+- Active API / docs / WIT naming を `request` に移行。
+- Manifest に `host_api.request` と `[[request]]` target declaration を追加。
+- Enablement grant を request target grant として扱うよう変更。
+- Runtime authorization を manifest-declared request target と enabled request grant の両方が URL/method/scheme/host/port/path coverage で許可する場合のみ network I/O に進む形にした。
+- Grant-only / missing-grant / broad / partial-coverage states を static inspection と `yoi plugin show` diagnostics で区別。
+- Broad/covering grant と broad manifest + narrower grant の intersection semantics を runtime と static inspection で一致させた。
+- Loopback/local/private target は ambient ではなく、URL host declaration + grant に基づく明示 authority として扱う方針を docs に記録。
+- Embedded credentials、credential-like headers、WebSocket URLs/upgrades、SSE/event-stream requests を reject/unsupported にした。
+- Old `host_api.https` / `grants.https` / `PluginHttps*` / old WIT names は active code/docs/resources から削除。
+- Focused manifest / pod / yoi plugin CLI tests を追加・更新。
+
+統合・検証:
+- Merge commit: `8a15cca5 merge: plugin request host api`
+- Implementation commits: `962b7699`, `0e14e7c1`
+- Reviewer final verdict: approve
+- Validation passed: `cargo fmt --check`, `git diff --check HEAD^1..HEAD`, `cargo test -p manifest request --quiet`, `cargo test -p pod feature::plugin::tests --lib --quiet`, `cargo test -p yoi plugin_cli::tests --quiet`, `cargo check -p manifest -p pod -p yoi --quiet`, stale active naming grep, `cargo run -p yoi -- ticket doctor`, and `nix build .#yoi --no-link`。
+
+範囲外:
+- Regex URL target matching は追加していない。
+- WebSocket/SSE/persistent connection support は `host_api.request` に含めていない。WebSocket は別 capability / design Ticket 側で扱う。
\ No newline at end of file
diff --git a/.yoi/tickets/00001KVMG8FTW/thread.md b/.yoi/tickets/00001KVMG8FTW/thread.md
index d435f9b0..ddd6217f 100644
--- a/.yoi/tickets/00001KVMG8FTW/thread.md
+++ b/.yoi/tickets/00001KVMG8FTW/thread.md
@@ -13,4 +13,499 @@ LocalTicketBackend によって作成されました。
 Ticket を `workspace-panel` が queued にしました。
 
 
+---
+
+<!-- event: decision author: yoi-orchestrator at: 2026-06-21T07:17:14Z -->
+
+## Decision
+
+Routing decision: `implementation_ready`
+
+Reason:
+- Ticket body は `host_api.https` 廃止、`host_api.request` 統一、manifest-declared URL/request target permissions、enablement grant 照合、runtime fail-closed、local/private target 明示 grant、broad/arbitrary URL 表示、docs/tests/diagnostics 更新まで具体化されている。
+- `readiness: implementation_ready` で、relations / orchestration plan に blocker はない。
+- Current active implementation `00001KVMFFYVX` は Workspace web control plane bootstrap で、主対象は backend/frontend/store/Nix packaging。This Ticket の主対象は plugin manifest/pod runtime/plugin CLI/docs/tests で直接の semantic blocker はない。過去のユーザー指示「blocker無いなら並列に」に従い、並列実装可能と判断する。
+- Orchestrator worktree is clean on `orchestration` at `f164483e` で、対象 Ticket 用 worktree / branch は未作成。
+- Visible Pods に対象 Ticket の child Pod は存在しない。
+
+Evidence checked:
+- Ticket body / thread / artifacts via `TicketShow` and direct `item.md` read。
+- `TicketRelationQuery(00001KVMG8FTW)`: no relations / blockers。
+- `TicketOrchestrationPlanQuery(00001KVMG8FTW)`: no records。
+- `ListPods`: active child is only `yoi-coder-00001KVMFFYVX`; no child for this Ticket。
+- Orchestrator git state / worktree list / branch list checked from `/home/hare/Projects/yoi/.worktree/orchestration` only。
+- Bounded code map:
+  - `crates/manifest/src/plugin.rs`: `PluginGrantConfig.https`, `PluginHttpsGrant`, `PluginHostApi::Https`, permission/grant resolution/tests。
+  - `crates/pod/src/feature/plugin.rs`: `PluginHttps*` runtime request path, `yoi:host/https@1.0.0` / raw wasm `yoi:https` imports, URL validation, request bounds, credential header checks, public-IP guard, allowlist checks, plugin tests。
+  - `crates/yoi/src/plugin_cli.rs`: inspection formatting for configured HTTPS grants。
+  - `docs/development/plugin-development.md`: active `host_api.https` / `grants.https` docs。
+
+IntentPacket:
+
+Intent:
+- Replace public/model/config-facing `host_api.https` with URL-permission based one-shot `host_api.request`.
+- Keep existing safe outbound request behavior where applicable, but generalize schemes/targets so explicit manifest + enablement grants can authorize loopback/private/local targets.
+- Keep WebSocket / SSE / persistent connections out of `request`.
+
+Binding decisions / invariants:
+- Do not add backward compatibility aliases for `host_api.https`, `PluginHttps*`, or `grants.https` in active APIs unless explicitly escalated and reapproved。
+- Model/config-facing naming must be `request`; internal names should also avoid `PluginHttps*` unless truly private transitional code is justified and not exposed。
+- Runtime authorization requires both manifest-declared request target permission and enablement grant for that target。
+- Grant-only without manifest request must fail closed or be explicitly diagnosed as unsafe/unused override; do not silently expand authority。
+- Requested-but-ungranted target must fail closed before network I/O。
+- Localhost/loopback/private/local targets are not ambient; they require manifest declaration and enablement grant。
+- Arbitrary URL / broad network access must be visibly distinguished from normal target grants in inspection/diagnostics。
+- Embedded credentials, credential-like headers, request/response bounds, external-content untrusted treatment, and no hidden context injection remain mandatory。
+- WebSocket URL / upgrade / persistent stream must be rejected or explicitly unsupported by `request`。
+- Existing HTTPS request use cases must continue under `host_api.request` with explicit request permission/grant。
+
+Requirements / acceptance criteria:
+- Active API naming uses `host_api.request` / request grant naming。
+- Plugin manifest statically declares request target permissions readable from manifest alone。
+- Enablement config grants request targets and is matched against manifest-declared targets。
+- Runtime checks method/scheme/host/port/path prefix against declared+granted URL permission。
+- `http://localhost` / loopback request can be allowed only with explicit declaration+grant。
+- Existing public HTTPS use case works as request。
+- Broad/arbitrary URL is supported only with clear broad display/diagnostic if implemented。
+- `yoi plugin show` / static inspection distinguishes requested, granted, denied/missing, and broad request permissions。
+- Docs/templates/tests/diagnostics are updated to request naming and WebSocket separate-capability policy。
+
+Implementation latitude:
+- Exact Rust/TOML type names are up to Coder, but active names should be request-oriented, e.g. `PluginRequestGrant`, `PluginRequestTarget`, `host_api.request`.
+- Regex support is optional. If added, it must include review-readable normalized display/warning/label and tests for broad/opaque handling。
+- Request target schema may start with exact scheme/host/optional port/method/path prefix. Keep permission review human-readable。
+- Internal runtime can reuse/refactor existing HTTPS client/request code, but reviewer should see active API renaming and policy changes。
+- Raw wasm/component import migration may choose new import names with tests; if keeping an internal compatibility import is unavoidable, escalate before committing.
+
+Escalate if:
+- Compatibility alias for old `host_api.https` / `grants.https` seems required。
+- Local/private target policy would open without both manifest declaration and grant。
+- Arbitrary URL access becomes visually indistinguishable from normal grants。
+- WebSocket/SSE/daemon lifecycle begins to enter `request`。
+- Secret-bearing headers/env/config would flow from guest memory without explicit SecretRef/grant design。
+- Regex support becomes opaque or hard to review。
+- Parallel active `00001KVMFFYVX` work creates unavoidable `Cargo.lock` / `package.nix` conflict; report rather than broad-rebasing alone。
+
+Validation plan:
+- `cargo fmt --check`
+- Focused manifest plugin tests for request permission parsing/resolution and naming removal。
+- Focused pod plugin tests for grant allow/deny, requested-but-ungranted, granted-but-unrequested, loopback/local allow/deny, WebSocket/upgrade rejection, request/response bounds/credential-header safety。
+- Focused yoi plugin CLI tests for request permission/grant/broad/missing diagnostics。
+- Docs/template grep ensuring active `host_api.https` / `grants.https` / `PluginHttps*` naming is removed except historical Ticket text or explicitly justified migration notes。
+- `cargo check` for affected crates, `git diff --check`, `yoi ticket doctor`。
+
+Reviewer focus:
+- Breaking-change intent is real: no stale active docs/templates/CLI inspection still teaching `host_api.https`。
+- Authorization must be two-stage: manifest request + grant。
+- Local/private network must not become ambient。
+- Old public HTTPS use case must still work under request naming。
+- External content and hidden context constraints remain intact。
+
+---
+
+<!-- event: state_changed author: yoi-orchestrator at: 2026-06-21T07:17:18Z from: queued to: inprogress reason: human_authorized_unblocked_parallel_implementation field: state -->
+
+## State changed
+
+Human authorized queue routing from Workspace Dashboard. Ticket has concrete acceptance criteria and no recorded blockers; active Workspace web control plane implementation is semantically separate enough for parallel implementation. Orchestrator accepts this Plugin host API refactor into implementation.
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T07:18:48Z -->
+
+## Implementation report
+
+Implementation start report:
+
+- Created child implementation worktree:
+  - `/home/hare/Projects/yoi/.worktree/00001KVMG8FTW-plugin-request-host-api`
+- Created branch:
+  - `impl/00001KVMG8FTW-plugin-request-host-api`
+- Base commit:
+  - `4cd4a06e ticket: route plugin request capabilities`
+- Confirmed tracked Ticket project records are visible in the child worktree。
+- Confirmed `.yoi/memory` has no tracked/untracked entries in the child worktree check。
+- Spawned sibling Coder Pod:
+  - `yoi-coder-00001KVMG8FTW`
+- Coder scope:
+  - read: `/home/hare/Projects/yoi`
+  - write: `/home/hare/Projects/yoi/.worktree/00001KVMG8FTW-plugin-request-host-api`
+
+Parallelization note:
+- `00001KVMFFYVX` remains in progress in a separate child worktree. Coder was instructed to avoid unnecessary Cargo.lock/package.nix churn and report if unavoidable conflicts appear。
+
+Next action:
+- Wait for Coder implementation report, then spawn Reviewer read-only for the implementation diff. Orchestrator will not merge/close until reviewer approval and validation evidence are available。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T07:48:07Z -->
+
+## Implementation report
+
+Coder implementation report received from `yoi-coder-00001KVMG8FTW`.
+
+Implementation commit:
+- `962b7699 plugin: replace https host api with request grants`
+
+Changed areas:
+- `crates/manifest/src/plugin.rs`
+  - Replaced active host API/grant naming with `request`。
+  - Added manifest-declared `[[request]]` URL targets with `scheme`, `host`, optional `port`, `methods`, and `path_prefixes`。
+  - Added request grant parsing/labels/broad diagnostics and tests that legacy HTTPS-facing names are not accepted。
+- `crates/pod/src/feature/plugin.rs`
+  - Renamed runtime path/imports to request-oriented naming。
+  - Runtime now requires both manifest request target declaration and enabled request grant before network I/O。
+  - Checks scheme/host/port/path/method, rejects embedded credentials, credential-like headers, WebSocket URLs/upgrades, and SSE/event-stream requests。
+  - Allows loopback/local/private targets only when explicitly declared and granted。
+  - Adds static inspection entries for requested/granted/missing/grant-only/broad request targets。
+- `crates/yoi/src/plugin_cli.rs`
+  - Shows configured request grants and request target eligibility diagnostics, including broad/missing/grant-only states。
+- `resources/plugin/wit/*`
+  - Updated WIT import/interface from HTTPS host API to `yoi:host/request@1.0.0`。
+- `docs/development/plugin-development.md`
+  - Rewrote host API docs for `request`, including manifest targets, enablement grants, loopback policy, broad target diagnostics, and WebSocket/SSE exclusion。
+- `docs/design/plugin-component-model.md`
+  - Updated design wording/import references。
+- `crates/pod/src/pod.rs`
+  - Updated test fixture initialization for the new manifest request target field。
+
+Coder validation reported:
+- `cargo fmt --check`: passed
+- `cargo test -p manifest request`: passed
+- `cargo test -p pod feature::plugin::tests --lib`: passed
+- `cargo test -p yoi plugin_cli::tests`: passed
+- `cargo check -p manifest -p pod -p yoi`: passed
+- `git diff --check`: passed
+- Active naming grep for `host_api.https|grants.https|PluginHttps|yoi:host/https|yoi:https` under `crates docs resources`: no matches
+- `target/debug/yoi ticket doctor`: passed
+
+Coder dependency/package report:
+- No `Cargo.lock`, `package.nix`, or flake changes。
+- No dependency/package churn。
+
+Known deferrals:
+- Regex URL target matching was not added。
+- WebSocket/SSE/persistent connection support remains explicitly outside `host_api.request`。
+
+Orchestrator evidence checked:
+- Implementation worktree is clean on `impl/00001KVMG8FTW-plugin-request-host-api`。
+- HEAD is `962b7699`。
+- Diff `4cd4a06e..HEAD` touches 9 expected manifest/pod/plugin-doc/WIT files, about 768 insertions / 448 deletions。
+- Active stale naming grep under `crates docs resources` returned no matches。
+- `git diff --check 4cd4a06e..HEAD` produced no diagnostics。
+
+Next action:
+- Route to read-only Reviewer Pod for acceptance review against the Ticket and IntentPacket。
+
+---
+
+<!-- event: comment author: yoi-orchestrator at: 2026-06-21T07:48:53Z -->
+
+## Comment
+
+Review routing:
+
+Spawned read-only Reviewer Pod:
+- `yoi-reviewer-00001KVMG8FTW-r1`
+
+Review target:
+- Worktree: `/home/hare/Projects/yoi/.worktree/00001KVMG8FTW-plugin-request-host-api`
+- Branch: `impl/00001KVMG8FTW-plugin-request-host-api`
+- Baseline: `4cd4a06e`
+- Implementation commit: `962b7699 plugin: replace https host api with request grants`
+- Diff: `4cd4a06e..962b7699`
+
+Reviewer scope:
+- read-only `/home/hare/Projects/yoi`
+
+Reviewer focus:
+- Active API/docs/WIT/CLI naming uses request, not stale https names。
+- No compatibility alias remains for old `host_api.https` / `grants.https` unless explicitly justified。
+- Runtime authorization requires both manifest request target and enablement grant before network I/O。
+- Grant-only and missing-grant cases fail closed / diagnose clearly。
+- Local/private/loopback targets require explicit declaration and grant。
+- WebSocket/SSE/persistent stream behavior is rejected or explicitly unsupported by `request`。
+- Broad/arbitrary URL grants are visibly distinguished。
+- Existing public HTTPS use case still works through request naming。
+
+Orchestrator will wait for reviewer verdict before integration。
+
+---
+
+<!-- event: review author: yoi-reviewer-00001KVMG8FTW-r1 at: 2026-06-21T07:58:08Z status: request_changes -->
+
+## Review: request changes
+
+Verdict: `request_changes`
+
+確認範囲:
+- Ticket authority:
+  - `.yoi/tickets/00001KVMG8FTW/item.md`
+  - `.yoi/tickets/00001KVMG8FTW/thread.md`
+- Implementation diff `4cd4a06e..962b7699`:
+  - `crates/manifest/src/plugin.rs`
+  - `crates/pod/src/feature/plugin.rs`
+  - `crates/pod/src/pod.rs`
+  - `crates/yoi/src/plugin_cli.rs`
+  - `docs/design/plugin-component-model.md`
+  - `docs/development/plugin-development.md`
+  - `resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit`
+  - `resources/plugin/wit/yoi-plugin-instance-v1.wit`
+  - `resources/plugin/wit/yoi-plugin-tool-v1.wit`
+
+Blocking issue:
+
+1. Static inspection and runtime authorization disagree for broad / covering request grants。
+
+Static inspection currently treats request target grants as matching only by exact equality:
+- `crates/pod/src/feature/plugin.rs:420-425`
+  - `let granted = record.grants.request.iter().any(|grant| grant == target);`
+- `crates/pod/src/feature/plugin.rs:440-455`
+  - grants without exact equality are reported as `grant-only`, `eligible=false`。
+
+Runtime authorization checks manifest targets and grants independently by URL coverage:
+- `crates/pod/src/feature/plugin.rs:1397-1409`
+  - URL must be allowed by some manifest target and some enabled grant。
+- `crates/pod/src/feature/plugin.rs:1420-1449`
+  - broad grants such as `*://*` or broader path/host scopes can cover a concrete URL even when not equal to the manifest target。
+
+Concrete mismatch:
+- Manifest declares exact target: `https://api.example.test ... /v1`
+- Enablement grants broad target: `*://* GET *`
+- Inspection reports:
+  - manifest target `requested=true granted=false eligible=false`
+  - broad grant as `grant-only ... eligible=false`
+- Runtime still allows `GET https://api.example.test/v1/data`, because URL is covered by both manifest target and broad grant。
+
+The added CLI test appears to codify this inconsistent reporting:
+- `crates/yoi/src/plugin_cli.rs:1566-1574`
+  - expects broad grant display as `grant-only`
+  - expects requested target as `granted=false eligible=false`
+
+This violates the Ticket acceptance/invariants that inspection distinguish requested/granted/denied/broad request permissions accurately, and that grant-only / requested-but-ungranted cases do not silently diverge from runtime behavior。
+
+Required fix:
+- Align static inspection and runtime semantics。
+- If broad / covering grants are valid authorization for declared manifest targets, inspection should report the manifest target as covered/granted, while visibly labeling the covering grant as broad。
+- If only exact target grants are intended to authorize, runtime should deny non-equal grant coverage before network I/O。
+- Apply same reasoning to the inverse shape: broad manifest request plus narrower exact grant can be runtime-allowed for URLs in the intersection while inspection currently reports both sides as ineligible/grant-only。
+
+Non-blocking concern:
+- DNS/private-target semantics are now URL-permission based rather than resolved-address-category based。There is an explicit test allowing a declared/granted hostname to resolve to `127.0.0.1` (`crates/pod/src/feature/plugin.rs:4841-4847`)。This may be acceptable under the new model, but it should be documented/reconfirmed because the Ticket says local/private communication must not be ambient。The implementation interprets “explicit” as declared/granted URL host, not necessarily literal `localhost` / private IP grant。
+
+Reviewer validation passed:
+- `cargo fmt --check`
+- `git diff --check 4cd4a06e..HEAD`
+- `cargo test -p manifest request --quiet` (`7 passed`)
+- `cargo test -p pod feature::plugin::tests --lib --quiet` (`67 passed`)
+- `cargo test -p yoi plugin_cli::tests --quiet` (`18 passed`)
+- `cargo check -p manifest -p pod -p yoi --quiet`
+- `target/debug/yoi ticket doctor`
+- Stale active naming grep under `crates docs resources` for `host_api.https|grants.https|PluginHttps|yoi:host/https|yoi:https`: no matches。
+
+Worktree status:
+- Clean on `impl/00001KVMG8FTW-plugin-request-host-api`。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T08:04:50Z -->
+
+## Implementation report
+
+Coder r1-fix report received from `yoi-coder-00001KVMG8FTW`.
+
+New fix commit:
+- `0e14e7c1 plugin: align request grant inspection coverage`
+
+Branch commits now:
+- `962b7699 plugin: replace https host api with request grants`
+- `0e14e7c1 plugin: align request grant inspection coverage`
+
+Fix summary:
+- `crates/pod/src/feature/plugin.rs`
+  - Static inspection now uses request target coverage/intersection semantics instead of exact equality。
+  - Broad/covering grants are reported as granted/eligible when they cover or intersect manifest targets in a way runtime can allow。
+  - Broad manifest + narrower grant is also reported as eligible with partial-coverage diagnostics。
+  - Truly grant-only/no-manifest-intersection grants remain ineligible。
+  - Added focused static inspection tests for exact manifest target + broad grant and broad manifest target + narrower exact grant。
+- `crates/yoi/src/plugin_cli.rs`
+  - Updated CLI/static inspection test expectations to match aligned broad grant semantics。
+- `docs/development/plugin-development.md`
+  - Documented that explicit request authority is URL-host based, and a granted DNS hostname may resolve to loopback/private addresses if that hostname was intentionally declared/granted。
+
+Coder validation reported:
+- `cargo fmt --check`: passed
+- `git diff --check 4cd4a06e..HEAD`: passed
+- `cargo test -p manifest request --quiet`: passed
+- `cargo test -p pod feature::plugin::tests --lib --quiet`: passed
+- `cargo test -p yoi plugin_cli::tests --quiet`: passed
+- `cargo check -p manifest -p pod -p yoi --quiet`: passed
+- `target/debug/yoi ticket doctor`: passed
+- stale active naming grep under `crates docs resources` for old HTTPS names: no matches
+
+Orchestrator evidence checked:
+- Implementation worktree clean on `impl/00001KVMG8FTW-plugin-request-host-api`。
+- HEAD is `0e14e7c1`。
+- r1-fix diff `962b7699..HEAD` touches only `crates/pod/src/feature/plugin.rs`, `crates/yoi/src/plugin_cli.rs`, and `docs/development/plugin-development.md`。
+- Active stale naming grep under `crates docs resources` returned no matches。
+- `git diff --check 4cd4a06e..HEAD` produced no diagnostics。
+
+Next action:
+- Route back to Reviewer for r2 verification of static inspection/runtime coverage alignment and final acceptance。
+
+---
+
+<!-- event: review author: yoi-reviewer-00001KVMG8FTW-r1 at: 2026-06-21T08:08:04Z status: approve -->
+
+## Review: approve
+
+Verdict: `approve`
+
+確認範囲:
+- r1-fix diff `962b7699..0e14e7c1`:
+  - `crates/pod/src/feature/plugin.rs`
+  - `crates/yoi/src/plugin_cli.rs`
+  - `docs/development/plugin-development.md`
+- Overall changed-file set `4cd4a06e..0e14e7c1`:
+  - `crates/manifest/src/plugin.rs`
+  - `crates/pod/src/feature/plugin.rs`
+  - `crates/pod/src/pod.rs`
+  - `crates/yoi/src/plugin_cli.rs`
+  - `docs/design/plugin-component-model.md`
+  - `docs/development/plugin-development.md`
+  - `resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit`
+  - `resources/plugin/wit/yoi-plugin-instance-v1.wit`
+  - `resources/plugin/wit/yoi-plugin-tool-v1.wit`
+
+Previous blocker verification:
+- r1 blocker is resolved。
+- Static inspection now evaluates request grant coverage/intersection rather than exact equality。
+- Exact manifest target + broad grant is now reported as granted/eligible with broad diagnostics, not `grant-only`。
+- Broad manifest target + narrower exact grant is now reported as runtime-eligible with partial-coverage diagnostics。
+- CLI/static inspection expectations were updated so broad grants are shown as usable grants, not ineligible grant-only。
+- DNS/private-target reviewer concern is documented in `docs/development/plugin-development.md`。
+
+Blocking issues:
+- None。
+
+Non-blocking concerns:
+- None requiring changes before merge。
+
+Overall Ticket satisfaction spot-check:
+- Active API/docs/WIT naming use `request`; stale active `host_api.https` / `grants.https` / `PluginHttps*` / old WIT names were not found under `crates docs resources`。
+- No compatibility alias for old HTTPS naming was visible in active code/docs。
+- Runtime still requires both manifest `host_api.request` / request target declaration and enablement `host_api.request` / matching request grant。
+- Runtime URL checks remain method/scheme/host/port/path based。
+- WebSocket URLs, upgrade headers, and SSE/event-stream requests remain rejected。
+- Embedded URL credentials and credential-like headers remain rejected。
+- Local/private/loopback targets are not ambient; documented authority is URL-host declaration + grant。
+
+Reviewer validation passed:
+- `cargo fmt --check`
+- `git diff --check 4cd4a06e..HEAD`
+- `cargo test -p manifest request --quiet` (`7 passed`)
+- `cargo test -p pod feature::plugin::tests --lib --quiet` (`69 passed`)
+- `cargo test -p yoi plugin_cli::tests --quiet` (`18 passed`)
+- `cargo check -p manifest -p pod -p yoi --quiet`
+- `target/debug/yoi ticket doctor` (`doctor: ok`)
+- Stale active naming grep under `crates docs resources`: no matches。
+
+Worktree status:
+- Clean at HEAD `0e14e7c1` on `impl/00001KVMG8FTW-plugin-request-host-api`。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T08:11:43Z -->
+
+## Implementation report
+
+Reviewer r2 approvalを受けて、実装ブランチを Orchestrator worktree の `orchestration` branch に統合した。
+
+統合:
+- Merge commit: `8a15cca5 merge: plugin request host api`
+- Merged branch: `impl/00001KVMG8FTW-plugin-request-host-api`
+- Implementation commits:
+  - `962b7699 plugin: replace https host api with request grants`
+  - `0e14e7c1 plugin: align request grant inspection coverage`
+
+Orchestrator worktree validation:
+- `cargo fmt --check`: passed
+- `git diff --check HEAD^1..HEAD`: passed
+- `cargo test -p manifest request --quiet`: passed (`7 passed`)
+- `cargo test -p pod feature::plugin::tests --lib --quiet`: passed (`69 passed`)
+- `cargo test -p yoi plugin_cli::tests --quiet`: passed (`18 passed`)
+- `cargo check -p manifest -p pod -p yoi --quiet`: passed
+- Stale active naming grep: `git grep -n -E 'host_api\.https|grants\.https|PluginHttps|yoi:host/https|yoi:https' -- crates docs resources`: no matches
+- `cargo run -p yoi -- ticket doctor`: passed (`doctor: ok`)
+- `nix build .#yoi --no-link`: passed
+
+Final Orchestrator worktree status after validation: clean on `orchestration` at `8a15cca5`。
+
+---
+
+<!-- event: state_changed author: yoi-orchestrator at: 2026-06-21T08:11:51Z from: inprogress to: done reason: implementation_merged_and_validated field: state -->
+
+## State changed
+
+Reviewer approval、Orchestrator worktree への統合、focused plugin request tests/checks、stale naming grep、Ticket doctor、Nix build が完了したため `done` に遷移する。
+
+---
+
+<!-- event: state_changed author: hare at: 2026-06-21T08:12:06Z from: done to: closed reason: closed field: state -->
+
+## State changed
+
+Ticket を closed にしました。
+
+
+---
+
+<!-- event: close author: hare at: 2026-06-21T08:12:06Z status: closed -->
+
+## 完了
+
+Plugin host API の one-shot outbound request capability を `host_api.https` / `grants.https` から URL permission based `host_api.request` に置き換え、Orchestrator worktree の `orchestration` branch に統合した。
+
+主な成果:
+- Active API / docs / WIT naming を `request` に移行。
+- Manifest に `host_api.request` と `[[request]]` target declaration を追加。
+- Enablement grant を request target grant として扱うよう変更。
+- Runtime authorization を manifest-declared request target と enabled request grant の両方が URL/method/scheme/host/port/path coverage で許可する場合のみ network I/O に進む形にした。
+- Grant-only / missing-grant / broad / partial-coverage states を static inspection と `yoi plugin show` diagnostics で区別。
+- Broad/covering grant と broad manifest + narrower grant の intersection semantics を runtime と static inspection で一致させた。
+- Loopback/local/private target は ambient ではなく、URL host declaration + grant に基づく明示 authority として扱う方針を docs に記録。
+- Embedded credentials、credential-like headers、WebSocket URLs/upgrades、SSE/event-stream requests を reject/unsupported にした。
+- Old `host_api.https` / `grants.https` / `PluginHttps*` / old WIT names は active code/docs/resources から削除。
+- Focused manifest / pod / yoi plugin CLI tests を追加・更新。
+
+統合・検証:
+- Merge commit: `8a15cca5 merge: plugin request host api`
+- Implementation commits: `962b7699`, `0e14e7c1`
+- Reviewer final verdict: approve
+- Validation passed: `cargo fmt --check`, `git diff --check HEAD^1..HEAD`, `cargo test -p manifest request --quiet`, `cargo test -p pod feature::plugin::tests --lib --quiet`, `cargo test -p yoi plugin_cli::tests --quiet`, `cargo check -p manifest -p pod -p yoi --quiet`, stale active naming grep, `cargo run -p yoi -- ticket doctor`, and `nix build .#yoi --no-link`。
+
+範囲外:
+- Regex URL target matching は追加していない。
+- WebSocket/SSE/persistent connection support は `host_api.request` に含めていない。WebSocket は別 capability / design Ticket 側で扱う。
+
+---
+
+<!-- event: implementation_report author: yoi-orchestrator at: 2026-06-21T08:12:34Z -->
+
+## Implementation report
+
+Post-close cleanup completed。
+
+- Stopped child Pods and reclaimed scope:
+  - `yoi-coder-00001KVMG8FTW`
+  - `yoi-reviewer-00001KVMG8FTW-r1`
+- Removed implementation worktree:
+  - `/home/hare/Projects/yoi/.worktree/00001KVMG8FTW-plugin-request-host-api`
+- Deleted implementation branch:
+  - `impl/00001KVMG8FTW-plugin-request-host-api`
+- Orchestrator worktree remains clean on `orchestration` at `2601bfa9`。
+
+Root/original workspace was not used for merge/validation/cleanup operations。
+
 ---
diff --git a/.yoi/tickets/00001KVMGAEJN/artifacts/relations.json b/.yoi/tickets/00001KVMGAEJN/artifacts/relations.json
new file mode 100644
index 00000000..966cdb7d
--- /dev/null
+++ b/.yoi/tickets/00001KVMGAEJN/artifacts/relations.json
@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "relations": [
+    {
+      "ticket_id": "00001KVMGAEJN",
+      "kind": "depends_on",
+      "target": "00001KVMG8FTW",
+      "note": "WebSocket capability design should reuse or deliberately diverge from the URL permission/request-target schema produced by `host_api.request`; current Ticket remains requirements_sync_needed until those design decisions are resolved.",
+      "author": "yoi-orchestrator",
+      "at": "2026-06-21T07:17:46Z"
+    }
+  ]
+}
diff --git a/.yoi/tickets/00001KVMGAEJN/item.md b/.yoi/tickets/00001KVMGAEJN/item.md
index 62767bb4..7e8507f9 100644
--- a/.yoi/tickets/00001KVMGAEJN/item.md
+++ b/.yoi/tickets/00001KVMGAEJN/item.md
@@ -1,8 +1,8 @@
 ---
 title: 'Plugin: URL 権限ベースの別 capability として WebSocket support を設計する'
-state: 'queued'
+state: 'planning'
 created_at: '2026-06-21T07:11:34Z'
-updated_at: '2026-06-21T07:15:42Z'
+updated_at: '2026-06-21T07:17:52Z'
 assignee: null
 readiness: 'requirements_sync_needed'
 risk_flags: ['plugin', 'host-api', 'websocket', 'service', 'ingress', 'lifecycle', 'permissions', 'security', 'persistence']
diff --git a/.yoi/tickets/00001KVMGAEJN/thread.md b/.yoi/tickets/00001KVMGAEJN/thread.md
index d38a9af3..e0703cd0 100644
--- a/.yoi/tickets/00001KVMGAEJN/thread.md
+++ b/.yoi/tickets/00001KVMGAEJN/thread.md
@@ -29,4 +29,43 @@ LocalTicketBackend によって作成されました。
 Ticket を `workspace-panel` が queued にしました。
 
 
+---
+
+<!-- event: decision author: yoi-orchestrator at: 2026-06-21T07:17:40Z -->
+
+## Decision
+
+Routing decision: `return_to_planning_requirements_sync`
+
+Reason:
+- Ticket frontmatter has `readiness: requirements_sync_needed`。
+- Intake summary explicitly says this should be handled as WebSocket capability design/spec sync, not implementation-direct routing。
+- Ticket body still lists concrete open questions that must be resolved before implementation or worktree side effects:
+  - WebSocket connection ownership: Yoi host-owned vs Plugin-instance-owned host API。
+  - Incoming message dispatch route: Ingress vs Service event/status stream vs other host routing。
+  - Reconnect / backoff / heartbeat / shutdown / cancellation / restore scope for first slice。
+  - Auth/headers/secrets model and grant/display split。
+  - Whether this work item closes as design/spec only or includes a minimal implementation slice。
+- Related Ticket `00001KVMG8FTW` is now routed for implementation of the `host_api.request` URL permission model. WebSocket design should reuse or intentionally diverge from that resulting URL permission schema after it stabilizes。
+
+Decision:
+- Do not create implementation worktree or spawn Coder/Reviewer for this Ticket now。
+- Return to `planning` with concrete missing requirements/design decisions。
+- Record relation to `00001KVMG8FTW` so WebSocket design can be resumed after request permission model lands。
+
+Required next planning output before queueing again:
+- Decide whether this is design/spec only or includes a minimal implementation slice。
+- Decide connection ownership and lifecycle boundary。
+- Decide incoming-message durable/visible dispatch path and no-hidden-context behavior。
+- Decide WebSocket URL permission/grant schema relative to `host_api.request` request-target schema。
+- Decide auth/secrets display/grant model and non-goals for reconnect/backoff/heartbeat in first slice。
+
+---
+
+<!-- event: state_changed author: yoi-orchestrator at: 2026-06-21T07:17:52Z from: queued to: planning reason: requirements_sync_needed_connection_lifecycle_and_scope_decisions field: state -->
+
+## State changed
+
+Ticket remains `requirements_sync_needed` and has unresolved design questions around connection ownership, incoming-message dispatch path, lifecycle bounds, auth/secrets handling, and design-vs-implementation scope. Returning to planning rather than starting implementation side effects.
+
 ---
diff --git a/Cargo.lock b/Cargo.lock
index cd96cb82..ed21e162 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -196,6 +196,58 @@ dependencies = [
  "fs_extra",
 ]
 
+[[package]]
+name = "axum"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
+dependencies = [
+ "axum-core",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -1039,6 +1091,18 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fancy-regex"
 version = "0.11.0"
@@ -1429,6 +1493,15 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown 0.15.5",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1968,6 +2041,17 @@ dependencies = [
  "redox_syscall 0.7.4",
 ]
 
+[[package]]
+name = "libsqlite3-sys"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "133c182a6a2c87864fe97778797e46c7e999672690dc9fa3ee8e241aa4a9c13f"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "line-clipping"
 version = "0.3.7"
@@ -2201,6 +2285,12 @@ dependencies = [
  "regex-automata",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
 [[package]]
 name = "mcp"
 version = "0.1.0"
@@ -3376,6 +3466,20 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rusqlite"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "165ca6e57b20e1351573e3729b958bc62f0e48025386970b6e4d29e7a7e71f3f"
+dependencies = [
+ "bitflags 2.11.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.27"
@@ -3692,6 +3796,17 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
+dependencies = [
+ "itoa",
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "1.1.1"
@@ -3701,6 +3816,18 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "serde_yaml"
 version = "0.9.34+deprecated"
@@ -4419,6 +4546,7 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -4457,6 +4585,7 @@ version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
+ "log",
  "pin-project-lite",
  "tracing-attributes",
  "tracing-core",
@@ -5839,6 +5968,25 @@ dependencies = [
  "wit-bindgen",
 ]
 
+[[package]]
+name = "yoi-workspace-server"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "axum",
+ "project-record",
+ "rusqlite",
+ "serde",
+ "serde_json",
+ "serde_yaml",
+ "tempfile",
+ "thiserror 2.0.18",
+ "ticket",
+ "tokio",
+ "tower",
+ "tracing",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.2"
diff --git a/Cargo.toml b/Cargo.toml
index 210f5bc2..044d3131 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,7 @@ members = [
     "crates/ticket",
     "crates/project-record",
     "crates/workflow",
+    "crates/workspace-server",
     "tests/e2e",
 ]
 default-members = [
@@ -50,6 +51,7 @@ default-members = [
     "crates/ticket",
     "crates/project-record",
     "crates/workflow",
+    "crates/workspace-server",
 ]
 
 [workspace.package]
@@ -80,21 +82,26 @@ session-store = { path = "crates/session-store" }
 secrets = { path = "crates/secrets" }
 tools = { path = "crates/tools" }
 tui = { path = "crates/tui" }
+yoi-workspace-server = { path = "crates/workspace-server" }
 
 # External
 # Note: `reqwest` and `chrono` are not aggregated here because some crates
 # need `default-features = false`, which workspace inheritance cannot override.
 async-trait = "0.1"
+axum = "0.8"
 fs4 = "0.13"
 futures = "0.3"
 libc = "0.2"
 schemars = "1.2"
 serde = "1.0"
 serde_json = "1.0"
+serde_yaml = "0.9.34"
+rusqlite = { version = "0.37", features = ["bundled"] }
 sha2 = "0.11"
 tempfile = "3.27"
 thiserror = "2.0"
 tokio = "1.52"
+tower = "0.5"
 toml = "1.1"
 tracing = "0.1"
 uuid = "1.23"
diff --git a/crates/manifest/src/plugin.rs b/crates/manifest/src/plugin.rs
index 6f062d4d..aa080db6 100644
--- a/crates/manifest/src/plugin.rs
+++ b/crates/manifest/src/plugin.rs
@@ -150,15 +150,15 @@ pub struct PluginGrantConfig {
     pub digest: Option<String>,
     /// Explicit capabilities granted for the pinned package identity/version/digest.
     pub permissions: Vec<PluginPermission>,
-    /// Bounded outbound HTTPS allowlist entries for `host_api.https`.
-    pub https: Vec<PluginHttpsGrant>,
+    /// Bounded outbound request allowlist entries for `host_api.request`.
+    pub request: Vec<PluginRequestGrant>,
     /// Scoped filesystem allowlist entries for `host_api.fs`.
     pub fs: Vec<PluginFsGrant>,
 }
 
 impl PluginGrantConfig {
     pub fn is_empty(&self) -> bool {
-        self.permissions.is_empty() && self.https.is_empty() && self.fs.is_empty()
+        self.permissions.is_empty() && self.request.is_empty() && self.fs.is_empty()
     }
 
     pub fn binding_error(
@@ -212,17 +212,32 @@ pub enum PluginPermission {
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct PluginHttpsGrant {
-    /// Exact HTTPS request host allowed by this grant. Wildcards are intentionally unsupported.
+pub struct PluginRequestGrant {
+    /// Exact URL scheme allowed by this target, for example `https` or `http`; `*` is broad.
+    pub scheme: String,
+    /// Exact request host allowed by this target. `*` is broad and must be surfaced in diagnostics.
     pub host: String,
-    /// Uppercase HTTP methods allowed for this host, for example `GET` or `POST`.
+    /// Optional exact port. `None` means the scheme default or any explicit port for that host.
+    pub port: Option<u16>,
+    /// Uppercase HTTP methods allowed for this target, for example `GET` or `POST`.
     pub methods: Vec<String>,
-    /// Optional path prefixes allowed for this host. Empty means any absolute path on the host.
+    /// Optional path prefixes allowed for this target. Empty means any absolute path on the host.
     pub path_prefixes: Vec<String>,
 }
 
-impl PluginHttpsGrant {
+impl PluginRequestGrant {
     pub fn label(&self) -> String {
+        let scheme = if self.scheme.trim().is_empty() {
+            "<no-scheme>"
+        } else {
+            self.scheme.as_str()
+        };
+        let host = if self.host.trim().is_empty() {
+            "<no-host>"
+        } else {
+            self.host.as_str()
+        };
+        let port = self.port.map(|port| format!(":{port}")).unwrap_or_default();
         let methods = if self.methods.is_empty() {
             "<no-methods>".to_string()
         } else {
@@ -233,7 +248,16 @@ impl PluginHttpsGrant {
         } else {
             self.path_prefixes.join(",")
         };
-        format!("{} {} {}", self.host, methods, paths)
+        let broad = if self.is_broad() {
+            " [broad-request]"
+        } else {
+            ""
+        };
+        format!("{scheme}://{host}{port} {methods} {paths}{broad}")
+    }
+
+    pub fn is_broad(&self) -> bool {
+        self.scheme.trim() == "*" || self.host.trim() == "*" || self.path_prefixes.is_empty()
     }
 }
 
@@ -322,14 +346,14 @@ impl PluginPermission {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PluginHostApi {
-    Https,
+    Request,
     Fs,
 }
 
 impl fmt::Display for PluginHostApi {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Https => f.write_str("https"),
+            Self::Request => f.write_str("request"),
             Self::Fs => f.write_str("fs"),
         }
     }
@@ -452,6 +476,10 @@ pub struct PluginPackageManifest {
     /// enablement grants must match them before runtime surfaces are exposed.
     #[serde(default)]
     pub permissions: Vec<PluginPermission>,
+    /// Manifest-declared URL targets for `host_api.request`. These are static permission requests;
+    /// enablement grants must explicitly approve matching targets.
+    #[serde(default)]
+    pub request: Vec<PluginRequestGrant>,
 }
 
 impl PluginPackageManifest {
@@ -2586,6 +2614,100 @@ mod tests {
         assert_eq!(manifest.tools.len(), 1);
     }
 
+    #[test]
+    fn request_host_api_manifest_and_grant_parse_with_request_names() {
+        let manifest: PluginPackageManifest = toml::from_str(
+            r#"
+schema_version = 1
+id = "example"
+name = "Example"
+version = "1.0.0"
+description = "Example plugin"
+surfaces = ["tool"]
+
+[[permissions]]
+kind = "host_api"
+api = "request"
+
+[[request]]
+scheme = "https"
+host = "api.example.com"
+port = 443
+methods = ["GET", "POST"]
+path_prefixes = ["/v1/"]
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            manifest.permissions,
+            vec![PluginPermission::host_api(PluginHostApi::Request)]
+        );
+        assert_eq!(manifest.request.len(), 1);
+        assert_eq!(manifest.request[0].scheme, "https");
+        assert_eq!(manifest.request[0].host, "api.example.com");
+        assert_eq!(manifest.request[0].port, Some(443));
+        assert_eq!(
+            manifest.request[0].label(),
+            "https://api.example.com:443 GET,POST /v1/"
+        );
+
+        let grants: PluginGrantConfig = toml::from_str(
+            r#"
+permissions = [{ kind = "host_api", api = "request" }]
+
+[[request]]
+scheme = "http"
+host = "localhost"
+port = 8080
+methods = ["GET"]
+path_prefixes = ["/health"]
+"#,
+        )
+        .unwrap();
+        assert_eq!(
+            grants.permissions,
+            vec![PluginPermission::host_api(PluginHostApi::Request)]
+        );
+        assert_eq!(grants.request[0].scheme, "http");
+        assert_eq!(grants.request[0].host, "localhost");
+    }
+
+    #[test]
+    fn legacy_https_request_names_are_not_accepted() {
+        let manifest_error = toml::from_str::<PluginPackageManifest>(
+            r#"
+schema_version = 1
+id = "example"
+name = "Example"
+version = "1.0.0"
+description = "Example plugin"
+surfaces = ["tool"]
+
+[[permissions]]
+kind = "host_api"
+api = "https"
+"#,
+        )
+        .expect_err(concat!(
+            "host_api.",
+            "https",
+            " must not be an active alias"
+        ));
+        assert!(manifest_error.to_string().contains("unknown variant"));
+
+        let grant_error = toml::from_str::<PluginGrantConfig>(
+            r#"
+permissions = [{ kind = "host_api", api = "request" }]
+
+[[https]]
+host = "api.example.com"
+methods = ["GET"]
+"#,
+        )
+        .expect_err(concat!("grants.", "https", " must not be an active alias"));
+        assert!(grant_error.to_string().contains("unknown field"));
+    }
+
     #[test]
     fn embedded_rust_component_instance_template_is_valid_package_shape() {
         let paths: BTreeSet<_> = RUST_COMPONENT_INSTANCE_TEMPLATE
@@ -3067,7 +3189,7 @@ input_schema = { type = "object", properties = { query = { type = "string" } },
             version: Some(PluginExactVersion("0.1.0".to_string())),
             digest: Some(digest.clone()),
             permissions: vec![PluginPermission::surface(PluginSurface::Hook)],
-            https: Vec::new(),
+            request: Vec::new(),
             fs: Vec::new(),
         };
         let resolution = resolve_enabled_plugins(
@@ -3094,7 +3216,7 @@ input_schema = { type = "object", properties = { query = { type = "string" } },
                 version: Some(PluginExactVersion("0.1.0".to_string())),
                 digest: Some(digest.clone()),
                 permissions: vec![PluginPermission::surface(PluginSurface::Hook)],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             PluginGrantConfig {
@@ -3102,7 +3224,7 @@ input_schema = { type = "object", properties = { query = { type = "string" } },
                 version: Some(PluginExactVersion("0.1.1".to_string())),
                 digest: Some(digest.clone()),
                 permissions: vec![PluginPermission::surface(PluginSurface::Hook)],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             PluginGrantConfig {
@@ -3110,7 +3232,7 @@ input_schema = { type = "object", properties = { query = { type = "string" } },
                 version: Some(PluginExactVersion("0.1.0".to_string())),
                 digest: Some("sha256:unrelated".to_string()),
                 permissions: vec![PluginPermission::surface(PluginSurface::Hook)],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
         ] {
diff --git a/crates/pod/src/feature/plugin.rs b/crates/pod/src/feature/plugin.rs
index 6ff66327..2f93635e 100644
--- a/crates/pod/src/feature/plugin.rs
+++ b/crates/pod/src/feature/plugin.rs
@@ -3,15 +3,15 @@
 //! This module registers *enabled* plugin package tool surface definitions and
 //! executes Tool calls through the minimal sandboxed `yoi-plugin-wasm-1` WASM
 //! ABI. It deliberately does not grant filesystem, environment, hook, service,
-//! ingress, or ambient network authority. WASM Tools can only reach outbound HTTPS
-//! through the explicit `yoi:https` host import, and filesystem read/list/write
+//! ingress, or ambient network authority. WASM Tools can only reach outbound Request
+//! through the explicit `yoi:request` host import, and filesystem read/list/write
 //! through the explicit `yoi:fs` host import, with matching permissions and
 //! scoped allowlist grants.
 
 use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::io::{Read as _, Write as _};
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
+use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
 use std::path::{Component, Path, PathBuf};
 use std::sync::{Arc, Mutex, OnceLock};
 use std::time::Duration;
@@ -23,9 +23,9 @@ use llm_worker::tool::{
 use manifest::plugin::{
     PLUGIN_COMPONENT_INSTANCE_WORLD, PLUGIN_COMPONENT_TOOL_WORLD, PLUGIN_RUNTIME_COMPONENT_KIND,
     PLUGIN_RUNTIME_WASM_ABI, PLUGIN_RUNTIME_WASM_KIND, PluginConfig, PluginDiscoveryLimits,
-    PluginFsGrant, PluginFsOperation, PluginHostApi, PluginPermission, PluginSurface,
-    PluginToolManifest, ResolvedPluginRecord, read_resolved_plugin_runtime_component,
-    read_resolved_plugin_runtime_module,
+    PluginFsGrant, PluginFsOperation, PluginHostApi, PluginPermission, PluginRequestGrant,
+    PluginSurface, PluginToolManifest, ResolvedPluginRecord,
+    read_resolved_plugin_runtime_component, read_resolved_plugin_runtime_module,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -280,7 +280,7 @@ pub fn inspect_resolved_plugin_static(record: &ResolvedPluginRecord) -> PluginSt
         },
     };
 
-    let host_apis = [PluginHostApi::Https, PluginHostApi::Fs]
+    let mut host_apis: Vec<_> = [PluginHostApi::Request, PluginHostApi::Fs]
         .into_iter()
         .filter_map(|api| {
             let permission = PluginPermission::host_api(api);
@@ -301,6 +301,7 @@ pub fn inspect_resolved_plugin_static(record: &ResolvedPluginRecord) -> PluginSt
             })
         })
         .collect();
+    append_request_target_inspection(record, &mut host_apis);
 
     let duplicate_tool_names = duplicate_tool_names(record);
     let tools = if surface_enabled(record, PluginSurface::Tool) {
@@ -416,6 +417,96 @@ fn permission_requested(record: &ResolvedPluginRecord, permission: &PluginPermis
         .any(|requested| requested == permission)
 }
 
+fn append_request_target_inspection(
+    record: &ResolvedPluginRecord,
+    host_apis: &mut Vec<PluginPermissionEligibility>,
+) {
+    for target in &record.manifest.request {
+        let covering_grant = record
+            .grants
+            .request
+            .iter()
+            .find(|grant| request_target_covers(grant, target));
+        let intersecting_grant = covering_grant.or_else(|| {
+            record
+                .grants
+                .request
+                .iter()
+                .find(|grant| request_targets_intersect(target, grant))
+        });
+        let granted = intersecting_grant.is_some();
+        let diagnostic = match (granted, covering_grant, target.is_broad()) {
+            (false, _, broad) => Some(format!(
+                "missing enabled request grant for manifest target{}",
+                if broad { "; broad/arbitrary target" } else { "" }
+            )),
+            (true, None, true) => Some(
+                "partially covered by enabled request grant; broad manifest target is constrained by narrower grants"
+                    .to_string(),
+            ),
+            (true, None, false) => Some(
+                "partially covered by enabled request grant; only intersecting URLs are allowed"
+                    .to_string(),
+            ),
+            (true, Some(grant), _) if grant.is_broad() => {
+                Some("covered by broad/arbitrary enabled request grant".to_string())
+            }
+            _ => None,
+        };
+        host_apis.push(PluginPermissionEligibility {
+            permission: format!("host_api.request target {}", target.label()),
+            requested: true,
+            granted,
+            eligible: granted,
+            diagnostic,
+        });
+    }
+    for grant in &record.grants.request {
+        let matching_manifest = record
+            .manifest
+            .request
+            .iter()
+            .find(|target| request_targets_intersect(target, grant));
+        if let Some(target) = matching_manifest {
+            let diagnostic = if grant.is_broad() {
+                Some(
+                    "broad/arbitrary enabled request grant is constrained by manifest declarations"
+                        .to_string(),
+                )
+            } else if !request_target_covers(target, grant) {
+                Some(
+                    "enabled request grant is only usable where it intersects manifest declarations"
+                        .to_string(),
+                )
+            } else {
+                None
+            };
+            host_apis.push(PluginPermissionEligibility {
+                permission: format!("host_api.request grant {}", grant.label()),
+                requested: true,
+                granted: true,
+                eligible: true,
+                diagnostic,
+            });
+        } else {
+            let broad = if grant.is_broad() {
+                "; broad/arbitrary target"
+            } else {
+                ""
+            };
+            host_apis.push(PluginPermissionEligibility {
+                permission: format!("host_api.request grant-only {}", grant.label()),
+                requested: false,
+                granted: true,
+                eligible: false,
+                diagnostic: Some(format!(
+                    "enabled request grant has no matching manifest declaration{broad}"
+                )),
+            });
+        }
+    }
+}
+
 fn grant_allows(record: &ResolvedPluginRecord, permission: &PluginPermission) -> bool {
     record
         .grants
@@ -627,42 +718,43 @@ impl FeatureModule for PluginToolFeature {
     }
 }
 
-impl PluginHttpsClient for ReqwestPluginHttpsClient {
+impl PluginRequestClient for ReqwestPluginRequestClient {
     fn execute(
         &self,
-        request: &PluginHttpsRequest,
+        request: &PluginRequestRequest,
         url: &reqwest::Url,
-        limits: PluginHttpsLimits,
-    ) -> Result<PluginHttpsResponse, PluginHttpsError> {
-        let pinned_resolution = resolve_https_target_for_client(url, &SystemPluginHttpsResolver)?;
+        limits: PluginRequestLimits,
+    ) -> Result<PluginRequestResponse, PluginRequestError> {
+        let pinned_resolution =
+            resolve_request_target_for_client(url, &SystemPluginRequestResolver)?;
         let method = reqwest::Method::from_bytes(request.method.as_bytes()).map_err(|_| {
-            PluginHttpsError::new(format!("unsupported HTTPS method `{}`", request.method))
+            PluginRequestError::new(format!("unsupported request method `{}`", request.method))
         })?;
         let mut client_builder = reqwest::blocking::Client::builder()
             .redirect(reqwest::redirect::Policy::none())
             .timeout(limits.timeout)
             .no_proxy()
-            .user_agent("yoi-plugin-https-host-api/0.1");
+            .user_agent("yoi-plugin-request-host-api/0.1");
         if let Some(pinned_resolution) = &pinned_resolution {
             for domain in &pinned_resolution.domains {
                 client_builder = client_builder.resolve_to_addrs(domain, &pinned_resolution.addrs);
             }
         }
         let client = client_builder.build().map_err(|error| {
-            PluginHttpsError::new(format!("HTTPS client build failed: {error}"))
+            PluginRequestError::new(format!("request client build failed: {error}"))
         })?;
         let mut builder = client.request(method, url.clone()).timeout(limits.timeout);
         for header in &request.headers {
             let name =
                 reqwest::header::HeaderName::from_bytes(header.name.as_bytes()).map_err(|_| {
-                    PluginHttpsError::new(format!(
-                        "invalid HTTPS request header name `{}`",
+                    PluginRequestError::new(format!(
+                        "invalid request header name `{}`",
                         header.name
                     ))
                 })?;
             let value = reqwest::header::HeaderValue::from_str(&header.value).map_err(|_| {
-                PluginHttpsError::new(format!(
-                    "invalid HTTPS request header value for `{}`",
+                PluginRequestError::new(format!(
+                    "invalid request header value for `{}`",
                     header.name
                 ))
             })?;
@@ -673,16 +765,13 @@ impl PluginHttpsClient for ReqwestPluginHttpsClient {
         }
         let mut response = builder.send().map_err(|error| {
             if error.is_timeout() {
-                PluginHttpsError::new(format!("HTTPS request to {} timed out", safe_url(url)))
+                PluginRequestError::new(format!("request to {} timed out", safe_url(url)))
             } else {
-                PluginHttpsError::new(format!(
-                    "HTTPS request to {} failed: {error}",
-                    safe_url(url)
-                ))
+                PluginRequestError::new(format!("request to {} failed: {error}", safe_url(url)))
             }
         })?;
         let status = response.status().as_u16();
-        let headers = collect_https_response_headers(response.headers());
+        let headers = collect_request_response_headers(response.headers());
         let mut body = Vec::new();
         let read_limit = limits.max_response_bytes.saturating_add(1) as u64;
         response
@@ -690,13 +779,13 @@ impl PluginHttpsClient for ReqwestPluginHttpsClient {
             .take(read_limit)
             .read_to_end(&mut body)
             .map_err(|error| {
-                PluginHttpsError::new(format!("HTTPS response read failed: {error}"))
+                PluginRequestError::new(format!("request response read failed: {error}"))
             })?;
         let truncated = body.len() > limits.max_response_bytes;
         if truncated {
             body.truncate(limits.max_response_bytes);
         }
-        Ok(PluginHttpsResponse {
+        Ok(PluginRequestResponse {
             status,
             headers,
             body: String::from_utf8_lossy(&body).into_owned(),
@@ -705,30 +794,31 @@ impl PluginHttpsClient for ReqwestPluginHttpsClient {
     }
 }
 
-fn execute_plugin_https_request(
+fn execute_plugin_request_request(
     record: &ResolvedPluginRecord,
-    client: &dyn PluginHttpsClient,
+    client: &dyn PluginRequestClient,
     request_bytes: &[u8],
-) -> Result<Vec<u8>, PluginHttpsError> {
-    if request_bytes.len() > PLUGIN_HTTPS_MAX_REQUEST_BYTES {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS request descriptor exceeds {} bytes",
-            PLUGIN_HTTPS_MAX_REQUEST_BYTES
+) -> Result<Vec<u8>, PluginRequestError> {
+    if request_bytes.len() > PLUGIN_REQUEST_MAX_REQUEST_BYTES {
+        return Err(PluginRequestError::new(format!(
+            "request descriptor exceeds {} bytes",
+            PLUGIN_REQUEST_MAX_REQUEST_BYTES
         )));
     }
-    authorize_plugin_host_api(record, PluginHostApi::Https).map_err(|error| {
-        PluginHttpsError::new(format!(
+    authorize_plugin_host_api(record, PluginHostApi::Request).map_err(|error| {
+        PluginRequestError::new(format!(
             "plugin host API dispatch denied: {}",
             error.bounded_message()
         ))
     })?;
-    let request: PluginHttpsRequest = serde_json::from_slice(request_bytes)
-        .map_err(|error| PluginHttpsError::new(format!("invalid HTTPS request JSON: {error}")))?;
-    let url = validate_plugin_https_request(record, &request)?;
-    let mut response = client.execute(&request, &url, PluginHttpsLimits::default())?;
-    enforce_https_response_bounds(&mut response, PluginHttpsLimits::default());
-    serde_json::to_vec(&response)
-        .map_err(|error| PluginHttpsError::new(format!("failed to encode HTTPS response: {error}")))
+    let request: PluginRequestRequest = serde_json::from_slice(request_bytes)
+        .map_err(|error| PluginRequestError::new(format!("invalid request JSON: {error}")))?;
+    let url = validate_plugin_request_request(record, &request)?;
+    let mut response = client.execute(&request, &url, PluginRequestLimits::default())?;
+    enforce_request_response_bounds(&mut response, PluginRequestLimits::default());
+    serde_json::to_vec(&response).map_err(|error| {
+        PluginRequestError::new(format!("failed to encode request response: {error}"))
+    })
 }
 
 fn execute_plugin_fs_request(
@@ -933,13 +1023,18 @@ fn execute_plugin_fs_write(
         .map_err(|error| PluginFsError::new(format!("failed to encode FS write response: {error}")))
 }
 
-fn enforce_https_response_bounds(response: &mut PluginHttpsResponse, limits: PluginHttpsLimits) {
+fn enforce_request_response_bounds(
+    response: &mut PluginRequestResponse,
+    limits: PluginRequestLimits,
+) {
     if response.body.len() > limits.max_response_bytes {
         truncate_string_to_boundary(&mut response.body, limits.max_response_bytes);
         response.truncated = true;
     }
-    if response.headers.len() > PLUGIN_HTTPS_MAX_RESPONSE_HEADERS {
-        response.headers.truncate(PLUGIN_HTTPS_MAX_RESPONSE_HEADERS);
+    if response.headers.len() > PLUGIN_REQUEST_MAX_RESPONSE_HEADERS {
+        response
+            .headers
+            .truncate(PLUGIN_REQUEST_MAX_RESPONSE_HEADERS);
     }
     for header in &mut response.headers {
         header.value = bounded_header_value(&header.value);
@@ -1239,120 +1334,267 @@ fn safe_fs_path(path: &str) -> String {
     }
 }
 
-fn validate_plugin_https_request(
+fn validate_plugin_request_request(
     record: &ResolvedPluginRecord,
-    request: &PluginHttpsRequest,
-) -> Result<reqwest::Url, PluginHttpsError> {
+    request: &PluginRequestRequest,
+) -> Result<reqwest::Url, PluginRequestError> {
     let method = request.method.trim().to_ascii_uppercase();
-    if method != request.method || !PLUGIN_HTTPS_ALLOWED_METHODS.contains(&method.as_str()) {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS method `{}` is not allowed",
+    if method != request.method || !PLUGIN_REQUEST_ALLOWED_METHODS.contains(&method.as_str()) {
+        return Err(PluginRequestError::new(format!(
+            "request method `{}` is not allowed",
             request.method
         )));
     }
-    if request.headers.len() > PLUGIN_HTTPS_MAX_REQUEST_HEADERS {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS request has too many headers (max {})",
-            PLUGIN_HTTPS_MAX_REQUEST_HEADERS
+    if request.headers.len() > PLUGIN_REQUEST_MAX_REQUEST_HEADERS {
+        return Err(PluginRequestError::new(format!(
+            "request descriptor has too many headers (max {})",
+            PLUGIN_REQUEST_MAX_REQUEST_HEADERS
         )));
     }
     for header in &request.headers {
-        validate_https_header(header)?;
+        validate_request_header(header)?;
     }
     if let Some(body) = &request.body {
-        if body.len() > PLUGIN_HTTPS_MAX_REQUEST_BODY_BYTES {
-            return Err(PluginHttpsError::new(format!(
-                "HTTPS request body exceeds {} bytes",
-                PLUGIN_HTTPS_MAX_REQUEST_BODY_BYTES
+        if body.len() > PLUGIN_REQUEST_MAX_REQUEST_BODY_BYTES {
+            return Err(PluginRequestError::new(format!(
+                "request body exceeds {} bytes",
+                PLUGIN_REQUEST_MAX_REQUEST_BODY_BYTES
             )));
         }
     }
     let url = reqwest::Url::parse(&request.url)
-        .map_err(|error| PluginHttpsError::new(format!("invalid HTTPS URL: {error}")))?;
-    if url.scheme() != "https" {
-        return Err(PluginHttpsError::new(format!(
-            "unsupported URL scheme {:?}; only https is allowed",
-            url.scheme()
-        )));
+        .map_err(|error| PluginRequestError::new(format!("invalid request URL: {error}")))?;
+    match url.scheme() {
+        "http" | "https" => {}
+        "ws" | "wss" => {
+            return Err(PluginRequestError::new(
+                "WebSocket URLs are not supported by host_api.request",
+            ));
+        }
+        scheme => {
+            return Err(PluginRequestError::new(format!(
+                "unsupported request URL scheme {scheme:?}; only http and https are allowed"
+            )));
+        }
     }
     if url.host_str().is_none() {
-        return Err(PluginHttpsError::new("HTTPS URL must include a host"));
+        return Err(PluginRequestError::new("request URL must include a host"));
     }
     if !url.username().is_empty() || url.password().is_some() {
-        return Err(PluginHttpsError::new(
-            "HTTPS URLs with embedded credentials are not allowed",
+        return Err(PluginRequestError::new(
+            "request URLs with embedded credentials are not allowed",
         ));
     }
-    validate_static_https_target(&url)?;
-    authorize_https_allowlist(record, &method, &url)?;
+    validate_static_request_target(&url)?;
+    authorize_request_allowlist(record, &method, &url)?;
     Ok(url)
 }
 
-fn validate_https_header(header: &PluginHttpsHeader) -> Result<(), PluginHttpsError> {
-    if header.name.is_empty() || header.name.len() > PLUGIN_HTTPS_MAX_HEADER_NAME_BYTES {
-        return Err(PluginHttpsError::new(
-            "HTTPS request header name is invalid",
-        ));
+fn validate_request_header(header: &PluginRequestHeader) -> Result<(), PluginRequestError> {
+    if header.name.is_empty() || header.name.len() > PLUGIN_REQUEST_MAX_HEADER_NAME_BYTES {
+        return Err(PluginRequestError::new("request header name is invalid"));
     }
-    if header.value.len() > PLUGIN_HTTPS_MAX_HEADER_VALUE_BYTES {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS request header `{}` exceeds {} bytes",
-            header.name, PLUGIN_HTTPS_MAX_HEADER_VALUE_BYTES
+    if header.value.len() > PLUGIN_REQUEST_MAX_HEADER_VALUE_BYTES {
+        return Err(PluginRequestError::new(format!(
+            "request header `{}` exceeds {} bytes",
+            header.name, PLUGIN_REQUEST_MAX_HEADER_VALUE_BYTES
         )));
     }
     if is_sensitive_header(&header.name) {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS request header `{}` is credential-like and must be supplied by an explicit future secret-ref grant, not guest memory",
+        return Err(PluginRequestError::new(format!(
+            "request header `{}` is credential-like and must be supplied by an explicit future secret-ref grant, not guest memory",
             header.name
         )));
     }
+    if header.name.eq_ignore_ascii_case("upgrade")
+        || (header.name.eq_ignore_ascii_case("connection")
+            && header
+                .value
+                .split(',')
+                .any(|value| value.trim().eq_ignore_ascii_case("upgrade")))
+    {
+        return Err(PluginRequestError::new(
+            "persistent connection upgrade headers are not supported by host_api.request",
+        ));
+    }
+    if header.name.eq_ignore_ascii_case("accept")
+        && header
+            .value
+            .split(',')
+            .any(|value| value.trim().eq_ignore_ascii_case("text/event-stream"))
+    {
+        return Err(PluginRequestError::new(
+            "SSE/event-stream requests are not supported by host_api.request",
+        ));
+    }
     reqwest::header::HeaderName::from_bytes(header.name.as_bytes()).map_err(|_| {
-        PluginHttpsError::new(format!(
-            "invalid HTTPS request header name `{}`",
-            header.name
-        ))
+        PluginRequestError::new(format!("invalid request header name `{}`", header.name))
     })?;
     reqwest::header::HeaderValue::from_str(&header.value).map_err(|_| {
-        PluginHttpsError::new(format!(
-            "invalid HTTPS request header value for `{}`",
+        PluginRequestError::new(format!(
+            "invalid request header value for `{}`",
             header.name
         ))
     })?;
     Ok(())
 }
 
-fn authorize_https_allowlist(
+fn authorize_request_allowlist(
     record: &ResolvedPluginRecord,
     method: &str,
     url: &reqwest::Url,
-) -> Result<(), PluginHttpsError> {
-    let host = canonical_host(url)?;
-    let path = url.path();
-    let allowed = record.grants.https.iter().any(|grant| {
-        canonical_grant_host(&grant.host).as_deref() == Some(host.as_str())
-            && grant
-                .methods
-                .iter()
-                .any(|allowed_method| allowed_method.eq_ignore_ascii_case(method))
-            && (grant.path_prefixes.is_empty()
-                || grant
-                    .path_prefixes
-                    .iter()
-                    .any(|prefix| !prefix.is_empty() && path.starts_with(prefix)))
-    });
-    if allowed {
-        return Ok(());
+) -> Result<(), PluginRequestError> {
+    if !request_targets_allow(&record.manifest.request, method, url) {
+        return Err(PluginRequestError::new(format!(
+            "host_api.request target {} {} is not declared by the plugin manifest",
+            method,
+            safe_url(url)
+        )));
     }
-    Err(PluginHttpsError::new(format!(
-        "HTTPS request {} {} is not covered by host/method/path grants",
-        method,
-        safe_url(url)
-    )))
+    if !request_targets_allow(&record.grants.request, method, url) {
+        return Err(PluginRequestError::new(format!(
+            "host_api.request target {} {} is not covered by enabled request grants",
+            method,
+            safe_url(url)
+        )));
+    }
+    Ok(())
 }
 
-fn canonical_grant_host(host: &str) -> Option<String> {
-    let value = normalize_host_literal(host.trim());
-    if value.is_empty() { None } else { Some(value) }
+fn request_targets_allow(targets: &[PluginRequestGrant], method: &str, url: &reqwest::Url) -> bool {
+    targets
+        .iter()
+        .any(|target| request_target_allows(target, method, url))
+}
+
+fn request_target_allows(target: &PluginRequestGrant, method: &str, url: &reqwest::Url) -> bool {
+    let scheme = target.scheme.trim().to_ascii_lowercase();
+    if scheme.is_empty() || (scheme != "*" && scheme != url.scheme()) {
+        return false;
+    }
+    let Ok(host) = canonical_host(url) else {
+        return false;
+    };
+    let target_host = normalize_host_literal(&target.host);
+    if target_host.is_empty() || (target_host != "*" && target_host != host) {
+        return false;
+    }
+    if let Some(port) = target.port {
+        if url.port_or_known_default() != Some(port) {
+            return false;
+        }
+    }
+    if target.methods.is_empty()
+        || !target
+            .methods
+            .iter()
+            .any(|allowed_method| allowed_method.trim().eq_ignore_ascii_case(method))
+    {
+        return false;
+    }
+    target.path_prefixes.is_empty()
+        || target
+            .path_prefixes
+            .iter()
+            .any(|prefix| !prefix.is_empty() && url.path().starts_with(prefix))
+}
+
+fn request_targets_intersect(left: &PluginRequestGrant, right: &PluginRequestGrant) -> bool {
+    request_scheme_intersects(&left.scheme, &right.scheme)
+        && request_host_intersects(&left.host, &right.host)
+        && request_port_intersects(left.port, right.port)
+        && request_methods_intersect(&left.methods, &right.methods)
+        && request_paths_intersect(&left.path_prefixes, &right.path_prefixes)
+}
+
+fn request_target_covers(covering: &PluginRequestGrant, covered: &PluginRequestGrant) -> bool {
+    request_scheme_covers(&covering.scheme, &covered.scheme)
+        && request_host_covers(&covering.host, &covered.host)
+        && request_port_covers(covering.port, covered.port)
+        && request_methods_cover(&covering.methods, &covered.methods)
+        && request_paths_cover(&covering.path_prefixes, &covered.path_prefixes)
+}
+
+fn request_scheme_intersects(left: &str, right: &str) -> bool {
+    let left = left.trim().to_ascii_lowercase();
+    let right = right.trim().to_ascii_lowercase();
+    !left.is_empty() && !right.is_empty() && (left == "*" || right == "*" || left == right)
+}
+
+fn request_scheme_covers(covering: &str, covered: &str) -> bool {
+    let covering = covering.trim().to_ascii_lowercase();
+    let covered = covered.trim().to_ascii_lowercase();
+    !covering.is_empty() && !covered.is_empty() && (covering == "*" || covering == covered)
+}
+
+fn request_host_intersects(left: &str, right: &str) -> bool {
+    let left = normalize_host_literal(left);
+    let right = normalize_host_literal(right);
+    !left.is_empty() && !right.is_empty() && (left == "*" || right == "*" || left == right)
+}
+
+fn request_host_covers(covering: &str, covered: &str) -> bool {
+    let covering = normalize_host_literal(covering);
+    let covered = normalize_host_literal(covered);
+    !covering.is_empty() && !covered.is_empty() && (covering == "*" || covering == covered)
+}
+
+fn request_port_intersects(left: Option<u16>, right: Option<u16>) -> bool {
+    left.is_none() || right.is_none() || left == right
+}
+
+fn request_port_covers(covering: Option<u16>, covered: Option<u16>) -> bool {
+    covering.is_none() || covering == covered
+}
+
+fn request_methods_intersect(left: &[String], right: &[String]) -> bool {
+    !left.is_empty()
+        && !right.is_empty()
+        && left.iter().any(|left_method| {
+            right
+                .iter()
+                .any(|right_method| left_method.trim().eq_ignore_ascii_case(right_method.trim()))
+        })
+}
+
+fn request_methods_cover(covering: &[String], covered: &[String]) -> bool {
+    !covering.is_empty()
+        && !covered.is_empty()
+        && covered.iter().all(|covered_method| {
+            covering.iter().any(|covering_method| {
+                covering_method
+                    .trim()
+                    .eq_ignore_ascii_case(covered_method.trim())
+            })
+        })
+}
+
+fn request_paths_intersect(left: &[String], right: &[String]) -> bool {
+    left.is_empty()
+        || right.is_empty()
+        || left.iter().any(|left_prefix| {
+            !left_prefix.is_empty()
+                && right.iter().any(|right_prefix| {
+                    !right_prefix.is_empty()
+                        && (left_prefix.starts_with(right_prefix)
+                            || right_prefix.starts_with(left_prefix))
+                })
+        })
+}
+
+fn request_paths_cover(covering: &[String], covered: &[String]) -> bool {
+    if covering.is_empty() {
+        return true;
+    }
+    if covered.is_empty() {
+        return false;
+    }
+    covered.iter().all(|covered_prefix| {
+        !covered_prefix.is_empty()
+            && covering.iter().any(|covering_prefix| {
+                !covering_prefix.is_empty() && covered_prefix.starts_with(covering_prefix)
+            })
+    })
 }
 
 fn normalize_host_literal(host: &str) -> String {
@@ -1362,12 +1604,24 @@ fn normalize_host_literal(host: &str) -> String {
         .to_ascii_lowercase()
 }
 
-fn has_usable_https_grant(record: &ResolvedPluginRecord) -> bool {
-    record.grants.https.iter().any(|grant| {
-        canonical_grant_host(&grant.host).is_some()
+fn has_usable_request_grant(record: &ResolvedPluginRecord) -> bool {
+    record.grants.request.iter().any(|grant| {
+        !grant.scheme.trim().is_empty()
+            && !grant.host.trim().is_empty()
             && grant.methods.iter().any(|method| {
                 let method = method.trim().to_ascii_uppercase();
-                PLUGIN_HTTPS_ALLOWED_METHODS.contains(&method.as_str())
+                PLUGIN_REQUEST_ALLOWED_METHODS.contains(&method.as_str())
+            })
+    })
+}
+
+fn has_declared_request_target(record: &ResolvedPluginRecord) -> bool {
+    record.manifest.request.iter().any(|target| {
+        !target.scheme.trim().is_empty()
+            && !target.host.trim().is_empty()
+            && target.methods.iter().any(|method| {
+                let method = method.trim().to_ascii_uppercase();
+                PLUGIN_REQUEST_ALLOWED_METHODS.contains(&method.as_str())
             })
     })
 }
@@ -1380,53 +1634,41 @@ fn has_usable_fs_grant(record: &ResolvedPluginRecord) -> bool {
     })
 }
 
-fn canonical_host(url: &reqwest::Url) -> Result<String, PluginHttpsError> {
+fn canonical_host(url: &reqwest::Url) -> Result<String, PluginRequestError> {
     url.host_str()
         .map(normalize_host_literal)
         .filter(|host| !host.is_empty())
-        .ok_or_else(|| PluginHttpsError::new("HTTPS URL must include a host"))
+        .ok_or_else(|| PluginRequestError::new("request URL must include a host"))
 }
 
-fn validate_static_https_target(url: &reqwest::Url) -> Result<(), PluginHttpsError> {
-    let host = canonical_host(url)?;
-    if is_forbidden_host_name(&host) {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS blocked local/private host {:?}",
-            host
-        )));
-    }
-    if let Ok(ip) = host.parse::<IpAddr>() {
-        validate_public_ip(ip, &host)?;
-    }
+fn validate_static_request_target(url: &reqwest::Url) -> Result<(), PluginRequestError> {
+    let _host = canonical_host(url)?;
     if url.cannot_be_a_base() {
-        return Err(PluginHttpsError::new(
-            "HTTPS URL target is not hierarchical",
+        return Err(PluginRequestError::new(
+            "request URL target is not hierarchical",
         ));
     }
     Ok(())
 }
 
-fn resolve_https_target_for_client(
+fn resolve_request_target_for_client(
     url: &reqwest::Url,
-    resolver: &dyn PluginHttpsResolver,
-) -> Result<Option<PinnedHttpsResolution>, PluginHttpsError> {
+    resolver: &dyn PluginRequestResolver,
+) -> Result<Option<PinnedRequestResolution>, PluginRequestError> {
     let host = canonical_host(url)?;
     if host.parse::<IpAddr>().is_ok() {
         return Ok(None);
     }
-    let port = url
-        .port_or_known_default()
-        .ok_or_else(|| PluginHttpsError::new("HTTPS URL uses a scheme without a default port"))?;
+    let port = url.port_or_known_default().ok_or_else(|| {
+        PluginRequestError::new("request URL uses a scheme without a default port")
+    })?;
     let addrs = resolver.resolve(&host, port)?;
     if addrs.is_empty() {
-        return Err(PluginHttpsError::new(format!(
+        return Err(PluginRequestError::new(format!(
             "DNS lookup for {:?} returned no addresses",
             host
         )));
     }
-    for addr in &addrs {
-        validate_public_ip(addr.ip(), &host)?;
-    }
     let mut domains = Vec::new();
     if let Some(raw_host) = url.host_str() {
         let raw_host = raw_host
@@ -1440,77 +1682,18 @@ fn resolve_https_target_for_client(
     if !domains.contains(&host) {
         domains.push(host);
     }
-    Ok(Some(PinnedHttpsResolution { domains, addrs }))
+    Ok(Some(PinnedRequestResolution { domains, addrs }))
 }
 
-fn validate_public_ip(ip: IpAddr, host: &str) -> Result<(), PluginHttpsError> {
-    let forbidden = match ip {
-        IpAddr::V4(ip) => is_forbidden_ipv4(ip),
-        IpAddr::V6(ip) => is_forbidden_ipv6(ip),
-    };
-    if forbidden {
-        return Err(PluginHttpsError::new(format!(
-            "HTTPS blocked local/private address {ip} for host {:?}",
-            host
-        )));
-    }
-    Ok(())
-}
-
-fn is_forbidden_host_name(host: &str) -> bool {
-    let lower = host.trim_end_matches('.').to_ascii_lowercase();
-    lower == "localhost" || lower.ends_with(".localhost")
-}
-
-fn is_forbidden_ipv4(ip: Ipv4Addr) -> bool {
-    ip.is_private()
-        || ip.is_loopback()
-        || ip.is_link_local()
-        || ip.is_broadcast()
-        || ip.is_documentation()
-        || ip.is_unspecified()
-        || ip.octets()[0] == 0
-        || ip.octets()[0] >= 224
-        || ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1])
-        || ip.octets()[0] == 169 && ip.octets()[1] == 254
-        || ip.octets()[0] == 192 && ip.octets()[1] == 0 && ip.octets()[2] == 0
-        || ip.octets()[0] == 198 && (18..=19).contains(&ip.octets()[1])
-}
-
-fn is_forbidden_ipv6(ip: Ipv6Addr) -> bool {
-    if let Some(mapped) = ipv6_embedded_ipv4(ip) {
-        return is_forbidden_ipv4(mapped);
-    }
-    ip.is_loopback()
-        || ip.is_unspecified()
-        || (ip.segments()[0] & 0xfe00) == 0xfc00
-        || (ip.segments()[0] & 0xffc0) == 0xfe80
-        || (ip.segments()[0] & 0xff00) == 0xff00
-}
-
-fn ipv6_embedded_ipv4(ip: Ipv6Addr) -> Option<Ipv4Addr> {
-    if let Some(mapped) = ip.to_ipv4_mapped() {
-        return Some(mapped);
-    }
-    let segments = ip.segments();
-    if segments[..6] == [0, 0, 0, 0, 0, 0] {
-        return Some(Ipv4Addr::new(
-            (segments[6] >> 8) as u8,
-            segments[6] as u8,
-            (segments[7] >> 8) as u8,
-            segments[7] as u8,
-        ));
-    }
-    None
-}
-
-fn collect_https_response_headers(headers: &reqwest::header::HeaderMap) -> Vec<PluginHttpsHeader> {
+fn collect_request_response_headers(
+    headers: &reqwest::header::HeaderMap,
+) -> Vec<PluginRequestHeader> {
     headers
         .iter()
         .filter(|(name, _)| !is_sensitive_header(name.as_str()))
-        .take(PLUGIN_HTTPS_MAX_RESPONSE_HEADERS)
+        .take(PLUGIN_REQUEST_MAX_RESPONSE_HEADERS)
         .filter_map(|(name, value)| {
-            value.to_str().ok().map(|value| PluginHttpsHeader {
+            value.to_str().ok().map(|value| PluginRequestHeader {
                 name: name.as_str().to_string(),
                 value: bounded_header_value(value),
             })
@@ -1520,8 +1703,8 @@ fn collect_https_response_headers(headers: &reqwest::header::HeaderMap) -> Vec<P
 
 fn bounded_header_value(value: &str) -> String {
     let mut redacted = redact_secret_like(value);
-    if redacted.len() > PLUGIN_HTTPS_MAX_HEADER_VALUE_BYTES {
-        truncate_string_to_boundary(&mut redacted, PLUGIN_HTTPS_MAX_HEADER_VALUE_BYTES);
+    if redacted.len() > PLUGIN_REQUEST_MAX_HEADER_VALUE_BYTES {
+        truncate_string_to_boundary(&mut redacted, PLUGIN_REQUEST_MAX_HEADER_VALUE_BYTES);
         redacted.push('…');
     }
     redacted
@@ -1549,8 +1732,8 @@ fn safe_url(url: &reqwest::Url) -> String {
         path.push('…');
     }
     match url.port() {
-        Some(port) => format!("https://{host}:{port}{path}"),
-        None => format!("https://{host}{path}"),
+        Some(port) => format!("{}://{host}:{port}{path}", url.scheme()),
+        None => format!("{}://{host}{path}", url.scheme()),
     }
 }
 
@@ -1591,7 +1774,7 @@ fn redact_after_secret_word(input: &str, needle: &str) -> String {
             end += 1;
         }
         if end > secret_start {
-            out.push_str(PLUGIN_HTTPS_REDACTION);
+            out.push_str(PLUGIN_REQUEST_REDACTION);
         }
         cursor = end;
     }
@@ -1725,10 +1908,15 @@ fn authorize_plugin_host_api(
         &format!("granted host_api.{api} permission is missing"),
     )?;
     match api {
-        PluginHostApi::Https => {
-            if !has_usable_https_grant(record) {
+        PluginHostApi::Request => {
+            if !has_declared_request_target(record) {
                 return Err(PluginPermissionError(
-                    "granted host_api.https allowlist is missing".to_string(),
+                    "manifest host_api.request target declaration is missing".to_string(),
+                ));
+            }
+            if !has_usable_request_grant(record) {
+                return Err(PluginPermissionError(
+                    "enabled host_api.request grants are missing".to_string(),
                 ));
             }
             Ok(())
@@ -1785,18 +1973,18 @@ const PLUGIN_WASM_FUEL: u64 = 5_000_000;
 const PLUGIN_WASM_TIMEOUT: Duration = Duration::from_secs(1);
 const PLUGIN_WASM_MEMORY_BYTES: usize = 2 * 1024 * 1024;
 const PLUGIN_WASM_TABLE_ELEMENTS: usize = 256;
-const PLUGIN_WASM_HTTPS_MODULE: &str = "yoi:https";
+const PLUGIN_WASM_REQUEST_MODULE: &str = "yoi:request";
 const PLUGIN_WASM_FS_MODULE: &str = "yoi:fs";
-const PLUGIN_HTTPS_MAX_REQUEST_BYTES: usize = 48 * 1024;
-const PLUGIN_HTTPS_MAX_REQUEST_BODY_BYTES: usize = 32 * 1024;
-const PLUGIN_HTTPS_MAX_REQUEST_HEADERS: usize = 16;
-const PLUGIN_HTTPS_MAX_RESPONSE_HEADERS: usize = 16;
-const PLUGIN_HTTPS_MAX_HEADER_NAME_BYTES: usize = 64;
-const PLUGIN_HTTPS_MAX_HEADER_VALUE_BYTES: usize = 1024;
-const PLUGIN_HTTPS_MAX_RESPONSE_BYTES: usize = 64 * 1024;
-const PLUGIN_HTTPS_TIMEOUT: Duration = Duration::from_secs(5);
-const PLUGIN_HTTPS_ALLOWED_METHODS: &[&str] = &["GET", "POST", "PUT", "PATCH", "DELETE"];
-const PLUGIN_HTTPS_REDACTION: &str = "<redacted>";
+const PLUGIN_REQUEST_MAX_REQUEST_BYTES: usize = 48 * 1024;
+const PLUGIN_REQUEST_MAX_REQUEST_BODY_BYTES: usize = 32 * 1024;
+const PLUGIN_REQUEST_MAX_REQUEST_HEADERS: usize = 16;
+const PLUGIN_REQUEST_MAX_RESPONSE_HEADERS: usize = 16;
+const PLUGIN_REQUEST_MAX_HEADER_NAME_BYTES: usize = 64;
+const PLUGIN_REQUEST_MAX_HEADER_VALUE_BYTES: usize = 1024;
+const PLUGIN_REQUEST_MAX_RESPONSE_BYTES: usize = 64 * 1024;
+const PLUGIN_REQUEST_TIMEOUT: Duration = Duration::from_secs(5);
+const PLUGIN_REQUEST_ALLOWED_METHODS: &[&str] = &["GET", "POST", "PUT", "PATCH", "DELETE"];
+const PLUGIN_REQUEST_REDACTION: &str = "<redacted>";
 const PLUGIN_FS_MAX_REQUEST_BYTES: usize = 64 * 1024;
 const PLUGIN_FS_MAX_PATH_BYTES: usize = 4096;
 const PLUGIN_FS_MAX_READ_BYTES: usize = 64 * 1024;
@@ -1902,72 +2090,72 @@ impl std::error::Error for PluginFsError {}
 
 #[derive(Clone, Debug, Deserialize)]
 #[serde(deny_unknown_fields)]
-struct PluginHttpsRequest {
+struct PluginRequestRequest {
     method: String,
     url: String,
     #[serde(default)]
-    headers: Vec<PluginHttpsHeader>,
+    headers: Vec<PluginRequestHeader>,
     #[serde(default)]
     body: Option<String>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
-struct PluginHttpsHeader {
+struct PluginRequestHeader {
     name: String,
     value: String,
 }
 
 #[derive(Clone, Debug, Serialize)]
-struct PluginHttpsResponse {
+struct PluginRequestResponse {
     status: u16,
-    headers: Vec<PluginHttpsHeader>,
+    headers: Vec<PluginRequestHeader>,
     body: String,
     truncated: bool,
 }
 
 #[derive(Clone, Copy, Debug)]
-struct PluginHttpsLimits {
+struct PluginRequestLimits {
     timeout: Duration,
     max_response_bytes: usize,
 }
 
-impl Default for PluginHttpsLimits {
+impl Default for PluginRequestLimits {
     fn default() -> Self {
         Self {
-            timeout: PLUGIN_HTTPS_TIMEOUT,
-            max_response_bytes: PLUGIN_HTTPS_MAX_RESPONSE_BYTES,
+            timeout: PLUGIN_REQUEST_TIMEOUT,
+            max_response_bytes: PLUGIN_REQUEST_MAX_RESPONSE_BYTES,
         }
     }
 }
 
-trait PluginHttpsClient: Send + Sync {
+trait PluginRequestClient: Send + Sync {
     fn execute(
         &self,
-        request: &PluginHttpsRequest,
+        request: &PluginRequestRequest,
         url: &reqwest::Url,
-        limits: PluginHttpsLimits,
-    ) -> Result<PluginHttpsResponse, PluginHttpsError>;
+        limits: PluginRequestLimits,
+    ) -> Result<PluginRequestResponse, PluginRequestError>;
 }
 
-struct ReqwestPluginHttpsClient;
-struct SystemPluginHttpsResolver;
+struct ReqwestPluginRequestClient;
+struct SystemPluginRequestResolver;
 
 #[derive(Clone, Debug)]
-struct PinnedHttpsResolution {
+struct PinnedRequestResolution {
     domains: Vec<String>,
     addrs: Vec<SocketAddr>,
 }
 
-trait PluginHttpsResolver {
-    fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginHttpsError>;
+trait PluginRequestResolver {
+    fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginRequestError>;
 }
 
-impl PluginHttpsResolver for SystemPluginHttpsResolver {
-    fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginHttpsError> {
+impl PluginRequestResolver for SystemPluginRequestResolver {
+    fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginRequestError> {
         let mut addrs = Vec::new();
         for addr in (host, port).to_socket_addrs().map_err(|error| {
-            PluginHttpsError::new(format!("DNS lookup failed for {:?}: {error}", host))
+            PluginRequestError::new(format!("DNS lookup failed for {:?}: {error}", host))
         })? {
             addrs.push(addr);
         }
@@ -1976,9 +2164,9 @@ impl PluginHttpsResolver for SystemPluginHttpsResolver {
 }
 
 #[derive(Debug)]
-struct PluginHttpsError(String);
+struct PluginRequestError(String);
 
-impl PluginHttpsError {
+impl PluginRequestError {
     fn new(message: impl Into<String>) -> Self {
         Self(redact_secret_like(&bounded_message(message.into())))
     }
@@ -2399,7 +2587,7 @@ impl PluginComponentInstanceRuntime {
             &engine,
             PluginComponentHostState {
                 record: record.clone(),
-                https_client: Arc::new(ReqwestPluginHttpsClient),
+                request_client: Arc::new(ReqwestPluginRequestClient),
                 store_limits: wasm_component_store_limits(),
             },
         );
@@ -2727,12 +2915,12 @@ impl PluginWasmError {
 
 struct PluginWasmHostState {
     record: ResolvedPluginRecord,
-    https_client: Arc<dyn PluginHttpsClient>,
+    request_client: Arc<dyn PluginRequestClient>,
     tool_name: Vec<u8>,
     input: Vec<u8>,
     output: Vec<u8>,
     output_error: Option<String>,
-    https_response: Vec<u8>,
+    request_response: Vec<u8>,
     fs_response: Vec<u8>,
     store_limits: wasmi::StoreLimits,
 }
@@ -2764,19 +2952,19 @@ fn run_plugin_wasm_tool(
     tool_name: String,
     input: Vec<u8>,
 ) -> Result<ToolOutput, PluginWasmError> {
-    run_plugin_wasm_tool_with_https_client(
+    run_plugin_wasm_tool_with_request_client(
         record,
         tool_name,
         input,
-        Arc::new(ReqwestPluginHttpsClient),
+        Arc::new(ReqwestPluginRequestClient),
     )
 }
 
-fn run_plugin_wasm_tool_with_https_client(
+fn run_plugin_wasm_tool_with_request_client(
     record: ResolvedPluginRecord,
     tool_name: String,
     input: Vec<u8>,
-    https_client: Arc<dyn PluginHttpsClient>,
+    request_client: Arc<dyn PluginRequestClient>,
 ) -> Result<ToolOutput, PluginWasmError> {
     let tool = record
         .manifest
@@ -2823,12 +3011,12 @@ fn run_plugin_wasm_tool_with_https_client(
         &engine,
         PluginWasmHostState {
             record: record.clone(),
-            https_client,
+            request_client,
             tool_name: tool_name.into_bytes(),
             input,
             output: Vec::new(),
             output_error: None,
-            https_response: Vec::new(),
+            request_response: Vec::new(),
             fs_response: Vec::new(),
             store_limits,
         },
@@ -2859,7 +3047,7 @@ fn run_plugin_wasm_tool_with_https_client(
 #[derive(Clone)]
 struct PluginComponentHostState {
     record: ResolvedPluginRecord,
-    https_client: Arc<dyn PluginHttpsClient>,
+    request_client: Arc<dyn PluginRequestClient>,
     store_limits: wasmtime::StoreLimits,
 }
 
@@ -2868,19 +3056,19 @@ fn run_plugin_component_tool(
     tool_name: String,
     input: Vec<u8>,
 ) -> Result<ToolOutput, PluginWasmError> {
-    run_plugin_component_tool_with_https_client(
+    run_plugin_component_tool_with_request_client(
         record,
         tool_name,
         input,
-        Arc::new(ReqwestPluginHttpsClient),
+        Arc::new(ReqwestPluginRequestClient),
     )
 }
 
-fn run_plugin_component_tool_with_https_client(
+fn run_plugin_component_tool_with_request_client(
     record: ResolvedPluginRecord,
     tool_name: String,
     input: Vec<u8>,
-    https_client: Arc<dyn PluginHttpsClient>,
+    request_client: Arc<dyn PluginRequestClient>,
 ) -> Result<ToolOutput, PluginWasmError> {
     let tool = record
         .manifest
@@ -2925,7 +3113,7 @@ fn run_plugin_component_tool_with_https_client(
         &engine,
         PluginComponentHostState {
             record: record.clone(),
-            https_client,
+            request_client,
             store_limits: wasm_component_store_limits(),
         },
     );
@@ -2966,8 +3154,8 @@ fn validate_component_imports(
 ) -> Result<(), PluginWasmError> {
     for (name, _) in component.component_type().imports(engine) {
         match name {
-            "yoi:host/https@1.0.0" => {
-                authorize_plugin_host_api(record, PluginHostApi::Https).map_err(|error| {
+            "yoi:host/request@1.0.0" => {
+                authorize_plugin_host_api(record, PluginHostApi::Request).map_err(|error| {
                     PluginWasmError::Module(format!(
                         "plugin host API dispatch denied: {}",
                         error.bounded_message()
@@ -2997,18 +3185,18 @@ fn define_plugin_component_host_imports(
 ) -> Result<(), PluginWasmError> {
     linker
         .root()
-        .instance("yoi:host/https@1.0.0")
+        .instance("yoi:host/request@1.0.0")
         .map_err(|error| PluginWasmError::Module(error.to_string()))?
         .func_wrap(
             "request",
             |store: wasmtime::StoreContextMut<'_, PluginComponentHostState>,
              (request,): (String,)|
              -> wasmtime::Result<(String,)> {
-                authorize_plugin_host_api(&store.data().record, PluginHostApi::Https)
+                authorize_plugin_host_api(&store.data().record, PluginHostApi::Request)
                     .map_err(|error| wasmtime::Error::msg(error.bounded_message()))?;
-                let response = execute_plugin_https_request(
+                let response = execute_plugin_request_request(
                     &store.data().record,
-                    store.data().https_client.as_ref(),
+                    store.data().request_client.as_ref(),
                     request.as_bytes(),
                 )
                 .map_err(|error| wasmtime::Error::msg(error.0))?;
@@ -3091,8 +3279,8 @@ fn validate_wasm_imports(
                     )));
                 }
             },
-            PLUGIN_WASM_HTTPS_MODULE => {
-                authorize_plugin_host_api(record, PluginHostApi::Https).map_err(|error| {
+            PLUGIN_WASM_REQUEST_MODULE => {
+                authorize_plugin_host_api(record, PluginHostApi::Request).map_err(|error| {
                     PluginWasmError::Module(format!(
                         "plugin host API dispatch denied: {}",
                         error.bounded_message()
@@ -3102,7 +3290,7 @@ fn validate_wasm_imports(
                     "request" | "response_len" | "response_read" => {}
                     other => {
                         return Err(PluginWasmError::Module(format!(
-                            "unsupported https host import `{other}`"
+                            "unsupported request host import `{other}`"
                         )));
                     }
                 }
@@ -3126,7 +3314,10 @@ fn validate_wasm_imports(
             other => {
                 return Err(PluginWasmError::Module(format!(
                     "unsupported import module `{}`; only `{}`, `{}`, and `{}` are available",
-                    other, PLUGIN_WASM_HOST_MODULE, PLUGIN_WASM_HTTPS_MODULE, PLUGIN_WASM_FS_MODULE
+                    other,
+                    PLUGIN_WASM_HOST_MODULE,
+                    PLUGIN_WASM_REQUEST_MODULE,
+                    PLUGIN_WASM_FS_MODULE
                 )));
             }
         }
@@ -3184,28 +3375,28 @@ fn define_plugin_wasm_host_imports(
         .map_err(|error| PluginWasmError::Module(error.to_string()))?;
     linker
         .func_wrap(
-            PLUGIN_WASM_HTTPS_MODULE,
+            PLUGIN_WASM_REQUEST_MODULE,
             "request",
             |mut caller: wasmi::Caller<'_, PluginWasmHostState>, ptr: i32, len: i32| -> i32 {
-                read_guest_https_request(&mut caller, ptr, len)
+                read_guest_request_request(&mut caller, ptr, len)
             },
         )
         .map_err(|error| PluginWasmError::Module(error.to_string()))?;
     linker
         .func_wrap(
-            PLUGIN_WASM_HTTPS_MODULE,
+            PLUGIN_WASM_REQUEST_MODULE,
             "response_len",
             |caller: wasmi::Caller<'_, PluginWasmHostState>| -> i32 {
-                caller.data().https_response.len() as i32
+                caller.data().request_response.len() as i32
             },
         )
         .map_err(|error| PluginWasmError::Module(error.to_string()))?;
     linker
         .func_wrap(
-            PLUGIN_WASM_HTTPS_MODULE,
+            PLUGIN_WASM_REQUEST_MODULE,
             "response_read",
             |mut caller: wasmi::Caller<'_, PluginWasmHostState>, ptr: i32, len: i32| -> i32 {
-                write_host_bytes_to_guest(&mut caller, ptr, len, HostBuffer::HttpsResponse)
+                write_host_bytes_to_guest(&mut caller, ptr, len, HostBuffer::RequestResponse)
             },
         )
         .map_err(|error| PluginWasmError::Module(error.to_string()))?;
@@ -3261,7 +3452,7 @@ fn define_plugin_wasm_host_imports(
 enum HostBuffer {
     ToolName,
     Input,
-    HttpsResponse,
+    RequestResponse,
     FsResponse,
 }
 
@@ -3277,7 +3468,7 @@ fn write_host_bytes_to_guest(
     let bytes = match buffer {
         HostBuffer::ToolName => caller.data().tool_name.clone(),
         HostBuffer::Input => caller.data().input.clone(),
-        HostBuffer::HttpsResponse => caller.data().https_response.clone(),
+        HostBuffer::RequestResponse => caller.data().request_response.clone(),
         HostBuffer::FsResponse => caller.data().fs_response.clone(),
     };
     if len as usize != bytes.len() {
@@ -3295,12 +3486,12 @@ fn write_host_bytes_to_guest(
     }
 }
 
-fn read_guest_https_request(
+fn read_guest_request_request(
     caller: &mut wasmi::Caller<'_, PluginWasmHostState>,
     ptr: i32,
     len: i32,
 ) -> i32 {
-    let bytes = match read_guest_bytes(caller, ptr, len, PLUGIN_HTTPS_MAX_REQUEST_BYTES) {
+    let bytes = match read_guest_bytes(caller, ptr, len, PLUGIN_REQUEST_MAX_REQUEST_BYTES) {
         Ok(bytes) => bytes,
         Err(error) => {
             caller.data_mut().output_error = Some(error);
@@ -3308,11 +3499,11 @@ fn read_guest_https_request(
         }
     };
     let record = caller.data().record.clone();
-    let https_client = caller.data().https_client.clone();
-    match execute_plugin_https_request(&record, https_client.as_ref(), &bytes) {
+    let request_client = caller.data().request_client.clone();
+    match execute_plugin_request_request(&record, request_client.as_ref(), &bytes) {
         Ok(response) => {
-            caller.data_mut().https_response = response;
-            caller.data().https_response.len() as i32
+            caller.data_mut().request_response = response;
+            caller.data().request_response.len() as i32
         }
         Err(error) => {
             caller.data_mut().output_error = Some(error.0);
@@ -3700,7 +3891,7 @@ mod tests {
     use super::*;
     use manifest::plugin::{
         PluginDiscoveryOptions, PluginEnablementConfig, PluginExactVersion, PluginGrantConfig,
-        PluginHttpsGrant, PluginPackageManifest, PluginRuntimeManifest, SourceQualifiedPluginId,
+        PluginPackageManifest, PluginRequestGrant, PluginRuntimeManifest, SourceQualifiedPluginId,
         resolve_plugin_config_for_startup,
     };
     use serde_json::json;
@@ -3748,6 +3939,7 @@ mod tests {
                 services: Vec::new(),
                 ingresses: Vec::new(),
                 permissions: permissions.clone(),
+                request: Vec::new(),
             },
             enabled_surfaces: vec![PluginSurface::Tool],
             grants: PluginGrantConfig {
@@ -3755,7 +3947,7 @@ mod tests {
                 version: Some(PluginExactVersion("0.1.0".to_string())),
                 digest: Some("sha256:abc".to_string()),
                 permissions,
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -4101,28 +4293,37 @@ mod tests {
         (report, pending)
     }
 
-    fn record_with_https_grant() -> ResolvedPluginRecord {
-        let mut record = record(vec![tool("HttpsTool")]);
-        let https_permission = PluginPermission::HostApi {
-            api: PluginHostApi::Https,
+    fn record_with_request_grant() -> ResolvedPluginRecord {
+        let mut record = record(vec![tool("RequestTool")]);
+        let request_permission = PluginPermission::HostApi {
+            api: PluginHostApi::Request,
         };
-        record.manifest.permissions.push(https_permission.clone());
-        record.grants.permissions.push(https_permission);
-        record.grants.https.push(PluginHttpsGrant {
+        record.manifest.permissions.push(request_permission.clone());
+        record.manifest.request.push(PluginRequestGrant {
+            scheme: "https".to_string(),
             host: "api.example.test".to_string(),
+            port: None,
+            methods: vec!["GET".to_string(), "POST".to_string()],
+            path_prefixes: vec!["/v1".to_string()],
+        });
+        record.grants.permissions.push(request_permission);
+        record.grants.request.push(PluginRequestGrant {
+            scheme: "https".to_string(),
+            host: "api.example.test".to_string(),
+            port: None,
             methods: vec!["GET".to_string(), "POST".to_string()],
             path_prefixes: vec!["/v1".to_string()],
         });
         record
     }
 
-    struct MockHttpsClient {
+    struct MockRequestClient {
         calls: Mutex<usize>,
         response_body: String,
         error: Mutex<Option<String>>,
     }
 
-    impl Default for MockHttpsClient {
+    impl Default for MockRequestClient {
         fn default() -> Self {
             Self {
                 calls: Mutex::new(0),
@@ -4132,26 +4333,26 @@ mod tests {
         }
     }
 
-    impl MockHttpsClient {
+    impl MockRequestClient {
         fn call_count(&self) -> usize {
             *self.calls.lock().expect("mock call lock")
         }
     }
 
-    impl PluginHttpsClient for MockHttpsClient {
+    impl PluginRequestClient for MockRequestClient {
         fn execute(
             &self,
-            _request: &PluginHttpsRequest,
+            _request: &PluginRequestRequest,
             _url: &reqwest::Url,
-            _limits: PluginHttpsLimits,
-        ) -> Result<PluginHttpsResponse, PluginHttpsError> {
+            _limits: PluginRequestLimits,
+        ) -> Result<PluginRequestResponse, PluginRequestError> {
             *self.calls.lock().expect("mock call lock") += 1;
             if let Some(error) = self.error.lock().expect("mock error lock").take() {
-                return Err(PluginHttpsError::new(error));
+                return Err(PluginRequestError::new(error));
             }
-            Ok(PluginHttpsResponse {
+            Ok(PluginRequestResponse {
                 status: 200,
-                headers: vec![PluginHttpsHeader {
+                headers: vec![PluginRequestHeader {
                     name: "content-type".to_string(),
                     value: "text/plain".to_string(),
                 }],
@@ -4161,12 +4362,12 @@ mod tests {
         }
     }
 
-    struct FakeHttpsResolver {
+    struct FakeRequestResolver {
         calls: Mutex<Vec<(String, u16)>>,
         addrs: Vec<SocketAddr>,
     }
 
-    impl FakeHttpsResolver {
+    impl FakeRequestResolver {
         fn new(addrs: Vec<SocketAddr>) -> Self {
             Self {
                 calls: Mutex::new(Vec::new()),
@@ -4179,8 +4380,8 @@ mod tests {
         }
     }
 
-    impl PluginHttpsResolver for FakeHttpsResolver {
-        fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginHttpsError> {
+    impl PluginRequestResolver for FakeRequestResolver {
+        fn resolve(&self, host: &str, port: u16) -> Result<Vec<SocketAddr>, PluginRequestError> {
             self.calls
                 .lock()
                 .expect("resolver calls lock")
@@ -4189,26 +4390,26 @@ mod tests {
         }
     }
 
-    fn https_request_json(method: &str, url: &str) -> String {
+    fn request_request_json(method: &str, url: &str) -> String {
         json!({ "method": method, "url": url }).to_string()
     }
 
-    fn wasm_tool_that_calls_https(request: &str) -> Vec<u8> {
-        let output = br#"{"summary":"https ok","content":"ordinary tool result path"}"#;
+    fn wasm_tool_that_calls_request(request: &str) -> Vec<u8> {
+        let output = br#"{"summary":"request ok","content":"ordinary tool result path"}"#;
         wat::parse_str(format!(
             r#"
             (module
               (import "yoi:tool" "output_write" (func $output_write (param i32 i32) (result i32)))
-              (import "yoi:https" "request" (func $https_request (param i32 i32) (result i32)))
-              (import "yoi:https" "response_len" (func $https_response_len (result i32)))
+              (import "yoi:request" "request" (func $request_request (param i32 i32) (result i32)))
+              (import "yoi:request" "response_len" (func $request_response_len (result i32)))
               (memory (export "memory") 1)
               (data (i32.const 16) "{}")
               (data (i32.const 4096) "{}")
               (func (export "yoi_tool_call")
                 (local $n i32)
-                (local.set $n (call $https_request (i32.const 16) (i32.const {})))
+                (local.set $n (call $request_request (i32.const 16) (i32.const {})))
                 (if (i32.lt_s (local.get $n) (i32.const 0)) (then unreachable))
-                (drop (call $https_response_len))
+                (drop (call $request_response_len))
                 (drop (call $output_write (i32.const 4096) (i32.const {})))
               )
             )
@@ -4295,7 +4496,7 @@ mod tests {
     }
 
     fn empty_wasm_tool() -> Vec<u8> {
-        let output = br#"{"summary":"no network","content":"no https import"}"#;
+        let output = br#"{"summary":"no network","content":"no request import"}"#;
         wat::parse_str(format!(
             r#"
             (module
@@ -4641,12 +4842,12 @@ mod tests {
     }
 
     #[test]
-    fn wasm_tool_can_call_granted_https_host_api() {
-        let (_dir, record) = runtime_record_with_https_wasm(wasm_tool_that_calls_https(
-            &https_request_json("GET", "https://api.example.test/v1/data"),
+    fn wasm_tool_can_call_granted_request_host_api() {
+        let (_dir, record) = runtime_record_with_request_wasm(wasm_tool_that_calls_request(
+            &request_request_json("GET", "https://api.example.test/v1/data"),
         ));
-        let client = Arc::new(MockHttpsClient::default());
-        let output = run_plugin_wasm_tool_with_https_client(
+        let client = Arc::new(MockRequestClient::default());
+        let output = run_plugin_wasm_tool_with_request_client(
             record,
             "PluginEcho".to_string(),
             Vec::new(),
@@ -4654,20 +4855,20 @@ mod tests {
         )
         .expect("tool output");
         assert_eq!(client.call_count(), 1);
-        assert_eq!(output.summary, "https ok");
+        assert_eq!(output.summary, "request ok");
         assert_eq!(output.content.as_deref(), Some("ordinary tool result path"));
     }
 
     #[test]
-    fn missing_https_grant_denies_before_network() {
-        let (_dir, mut record) = resolved_record_with_wasm(wasm_tool_that_calls_https(
-            &https_request_json("GET", "https://api.example.test/v1/data"),
+    fn missing_request_grant_denies_before_network() {
+        let (_dir, mut record) = resolved_record_with_wasm(wasm_tool_that_calls_request(
+            &request_request_json("GET", "https://api.example.test/v1/data"),
         ));
         record.manifest.permissions.push(PluginPermission::HostApi {
-            api: PluginHostApi::Https,
+            api: PluginHostApi::Request,
         });
-        let client = Arc::new(MockHttpsClient::default());
-        let error = run_plugin_wasm_tool_with_https_client(
+        let client = Arc::new(MockRequestClient::default());
+        let error = run_plugin_wasm_tool_with_request_client(
             record,
             "PluginEcho".to_string(),
             Vec::new(),
@@ -4675,27 +4876,26 @@ mod tests {
         )
         .expect_err("grant denied");
         assert_eq!(client.call_count(), 0);
-        assert!(error.bounded_message().contains("host_api.https"));
+        assert!(error.bounded_message().contains("host_api.request"));
     }
 
     #[test]
-    fn disallowed_https_request_targets_deny_before_network() {
-        let record = record_with_https_grant();
-        let client = MockHttpsClient::default();
+    fn disallowed_request_targets_deny_before_network() {
+        let record = record_with_request_grant();
+        let client = MockRequestClient::default();
         for (method, url, needle) in [
-            ("GET", "http://api.example.test/v1/data", "scheme"),
+            ("GET", "http://api.example.test/v1/data", "manifest"),
             ("TRACE", "https://api.example.test/v1/data", "method"),
-            ("GET", "https://other.example.test/v1/data", "grants"),
-            ("GET", "https://localhost/v1/data", "local/private"),
-            ("GET", "https://127.0.0.1/v1/data", "local/private"),
-            ("GET", "https://10.0.0.1/v1/data", "local/private"),
-            ("GET", "https://169.254.169.254/v1/data", "local/private"),
+            ("GET", "https://other.example.test/v1/data", "manifest"),
+            ("GET", "http://localhost/v1/data", "manifest"),
+            ("GET", "http://127.0.0.1/v1/data", "manifest"),
             ("GET", "file:///tmp/secret", "scheme"),
+            ("GET", "ws://api.example.test/v1/data", "WebSocket"),
         ] {
-            let error = execute_plugin_https_request(
+            let error = execute_plugin_request_request(
                 &record,
                 &client,
-                https_request_json(method, url).as_bytes(),
+                request_request_json(method, url).as_bytes(),
             )
             .expect_err("request denied");
             assert!(
@@ -4708,24 +4908,56 @@ mod tests {
     }
 
     #[test]
-    fn ipv4_mapped_ipv6_targets_deny_before_network() {
-        let record = record_with_https_grant();
-        let client = MockHttpsClient::default();
-        for url in [
-            "https://[::ffff:127.0.0.1]/v1/data",
-            "https://[::ffff:10.0.0.1]/v1/data",
-            "https://[::ffff:169.254.169.254]/v1/data",
-            "https://[::10.0.0.1]/v1/data",
+    fn loopback_request_requires_explicit_manifest_and_grant() {
+        let mut record = record_with_request_grant();
+        record.manifest.request.push(PluginRequestGrant {
+            scheme: "http".to_string(),
+            host: "localhost".to_string(),
+            port: Some(8080),
+            methods: vec!["GET".to_string()],
+            path_prefixes: vec!["/health".to_string()],
+        });
+        let client = MockRequestClient::default();
+        let denied = execute_plugin_request_request(
+            &record,
+            &client,
+            request_request_json("GET", "http://localhost:8080/health").as_bytes(),
+        )
+        .expect_err("manifest-only local target denied");
+        assert!(denied.0.contains("grants"), "{}", denied.0);
+        record.grants.request.push(PluginRequestGrant {
+            scheme: "http".to_string(),
+            host: "localhost".to_string(),
+            port: Some(8080),
+            methods: vec!["GET".to_string()],
+            path_prefixes: vec!["/health".to_string()],
+        });
+        execute_plugin_request_request(
+            &record,
+            &client,
+            request_request_json("GET", "http://localhost:8080/health").as_bytes(),
+        )
+        .expect("explicit loopback target allowed");
+        assert_eq!(client.call_count(), 1);
+    }
+
+    #[test]
+    fn upgrade_and_sse_headers_are_rejected() {
+        let record = record_with_request_grant();
+        let client = MockRequestClient::default();
+        for headers in [
+            r#"[{"name":"Upgrade","value":"websocket"}]"#,
+            r#"[{"name":"Connection","value":"keep-alive, Upgrade"}]"#,
+            r#"[{"name":"Accept","value":"text/event-stream"}]"#,
         ] {
-            let error = execute_plugin_https_request(
-                &record,
-                &client,
-                https_request_json("GET", url).as_bytes(),
-            )
-            .expect_err("mapped address denied");
+            let body = format!(
+                r#"{{"method":"GET","url":"https://api.example.test/v1/data","headers":{headers}}}"#
+            );
+            let error = execute_plugin_request_request(&record, &client, body.as_bytes())
+                .expect_err("persistent request header denied");
             assert!(
-                error.0.contains("local/private"),
-                "{url} produced {:?}",
+                error.0.contains("not supported") || error.0.contains("upgrade"),
+                "{}",
                 error.0
             );
         }
@@ -4735,8 +4967,8 @@ mod tests {
     #[test]
     fn dns_resolution_is_pinned_to_validated_public_socket_addresses() {
         let url = reqwest::Url::parse("https://api.example.test:8443/v1/data").unwrap();
-        let resolver = FakeHttpsResolver::new(vec!["93.184.216.34:8443".parse().unwrap()]);
-        let pinned = resolve_https_target_for_client(&url, &resolver)
+        let resolver = FakeRequestResolver::new(vec!["93.184.216.34:8443".parse().unwrap()]);
+        let pinned = resolve_request_target_for_client(&url, &resolver)
             .expect("resolution")
             .expect("hostname resolution is pinned");
         assert_eq!(
@@ -4754,28 +4986,29 @@ mod tests {
     }
 
     #[test]
-    fn dns_resolution_rejects_private_addresses_before_client_build() {
+    fn dns_resolution_can_pin_explicit_private_addresses() {
         let url = reqwest::Url::parse("https://api.example.test/v1/data").unwrap();
-        let resolver = FakeHttpsResolver::new(vec!["127.0.0.1:443".parse().unwrap()]);
-        let error =
-            resolve_https_target_for_client(&url, &resolver).expect_err("private DNS answer");
-        assert!(error.0.contains("local/private"));
+        let resolver = FakeRequestResolver::new(vec!["127.0.0.1:443".parse().unwrap()]);
+        let pinned = resolve_request_target_for_client(&url, &resolver)
+            .expect("explicit request grants, not ambient network policy, govern local targets")
+            .expect("hostname resolution is pinned");
+        assert_eq!(pinned.addrs, vec!["127.0.0.1:443".parse().unwrap()]);
     }
 
     #[test]
     fn timeout_and_secret_diagnostics_are_bounded_and_redacted() {
-        let record = record_with_https_grant();
-        let client = MockHttpsClient::default();
+        let record = record_with_request_grant();
+        let client = MockRequestClient::default();
         *client.error.lock().expect("mock error lock") =
             Some("timeout while using Authorization: Bearer SUPER_SECRET_TOKEN".to_string());
-        let error = execute_plugin_https_request(
+        let error = execute_plugin_request_request(
             &record,
             &client,
-            https_request_json("GET", "https://api.example.test/v1/data").as_bytes(),
+            request_request_json("GET", "https://api.example.test/v1/data").as_bytes(),
         )
         .expect_err("timeout error");
         assert!(error.0.contains("timeout"));
-        assert!(error.0.contains(PLUGIN_HTTPS_REDACTION));
+        assert!(error.0.contains(PLUGIN_REQUEST_REDACTION));
         assert!(!error.0.contains("SUPER_SECRET_TOKEN"));
         assert!(error.0.len() <= 513);
         assert_eq!(client.call_count(), 1);
@@ -4783,31 +5016,31 @@ mod tests {
 
     #[test]
     fn response_size_bound_truncates() {
-        let record = record_with_https_grant();
-        let client = MockHttpsClient {
+        let record = record_with_request_grant();
+        let client = MockRequestClient {
             calls: Mutex::new(0),
-            response_body: "x".repeat(PLUGIN_HTTPS_MAX_RESPONSE_BYTES + 8),
+            response_body: "x".repeat(PLUGIN_REQUEST_MAX_RESPONSE_BYTES + 8),
             error: Mutex::new(None),
         };
-        let response = execute_plugin_https_request(
+        let response = execute_plugin_request_request(
             &record,
             &client,
-            https_request_json("GET", "https://api.example.test/v1/data").as_bytes(),
+            request_request_json("GET", "https://api.example.test/v1/data").as_bytes(),
         )
         .expect("response");
         let value: Value = serde_json::from_slice(&response).expect("response json");
         assert_eq!(value["truncated"], true);
         assert_eq!(
             value["body"].as_str().expect("body").len(),
-            PLUGIN_HTTPS_MAX_RESPONSE_BYTES
+            PLUGIN_REQUEST_MAX_RESPONSE_BYTES
         );
     }
 
     #[test]
-    fn no_network_without_https_import() {
-        let (_dir, record) = runtime_record_with_https_wasm(empty_wasm_tool());
-        let client = Arc::new(MockHttpsClient::default());
-        let output = run_plugin_wasm_tool_with_https_client(
+    fn no_network_without_request_import() {
+        let (_dir, record) = runtime_record_with_request_wasm(empty_wasm_tool());
+        let client = Arc::new(MockRequestClient::default());
+        let output = run_plugin_wasm_tool_with_request_client(
             record,
             "PluginEcho".to_string(),
             Vec::new(),
@@ -4960,28 +5193,43 @@ mod tests {
 
     #[test]
     fn future_host_api_imports_are_permission_checked_before_unimplemented_boundary() {
-        let (_dir, mut record) = resolved_record_with_wasm(https_import_module());
+        let (_dir, mut record) = resolved_record_with_wasm(request_import_module());
         let error = run_plugin_wasm_tool(record.clone(), "PluginEcho".into(), br#"{}"#.to_vec())
             .unwrap_err()
             .bounded_message();
         assert!(
-            error.contains("requested host_api.https permission is missing"),
+            error.contains("requested host_api.request permission is missing"),
             "{error}"
         );
 
         record
             .manifest
             .permissions
-            .push(PluginPermission::host_api(PluginHostApi::Https));
+            .push(PluginPermission::host_api(PluginHostApi::Request));
         record
             .grants
             .permissions
-            .push(PluginPermission::host_api(PluginHostApi::Https));
+            .push(PluginPermission::host_api(PluginHostApi::Request));
+        let error = run_plugin_wasm_tool(record.clone(), "PluginEcho".into(), br#"{}"#.to_vec())
+            .unwrap_err()
+            .bounded_message();
+        assert!(
+            error.contains("manifest host_api.request target declaration is missing"),
+            "{error}"
+        );
+
+        record.manifest.request.push(PluginRequestGrant {
+            scheme: "https".to_string(),
+            host: "api.example.test".to_string(),
+            port: None,
+            methods: vec!["GET".to_string()],
+            path_prefixes: vec!["/".to_string()],
+        });
         let error = run_plugin_wasm_tool(record, "PluginEcho".into(), br#"{}"#.to_vec())
             .unwrap_err()
             .bounded_message();
         assert!(
-            error.contains("granted host_api.https allowlist is missing"),
+            error.contains("enabled host_api.request grants are missing"),
             "{error}"
         );
     }
@@ -5211,15 +5459,24 @@ mod tests {
         record
     }
 
-    fn runtime_record_with_https_wasm(wasm: Vec<u8>) -> (TempDir, ResolvedPluginRecord) {
+    fn runtime_record_with_request_wasm(wasm: Vec<u8>) -> (TempDir, ResolvedPluginRecord) {
         let (dir, mut record) = resolved_record_with_wasm(wasm);
-        let https_permission = PluginPermission::HostApi {
-            api: PluginHostApi::Https,
+        let request_permission = PluginPermission::HostApi {
+            api: PluginHostApi::Request,
         };
-        record.manifest.permissions.push(https_permission.clone());
-        record.grants.permissions.push(https_permission);
-        record.grants.https.push(PluginHttpsGrant {
+        record.manifest.permissions.push(request_permission.clone());
+        record.manifest.request.push(PluginRequestGrant {
+            scheme: "https".to_string(),
             host: "api.example.test".to_string(),
+            port: None,
+            methods: vec!["GET".to_string(), "POST".to_string()],
+            path_prefixes: vec!["/v1".to_string()],
+        });
+        record.grants.permissions.push(request_permission);
+        record.grants.request.push(PluginRequestGrant {
+            scheme: "https".to_string(),
+            host: "api.example.test".to_string(),
+            port: None,
             methods: vec!["GET".to_string(), "POST".to_string()],
             path_prefixes: vec!["/v1".to_string()],
         });
@@ -5255,7 +5512,7 @@ mod tests {
             version: Some(PluginExactVersion(record.version.clone())),
             digest: Some(record.digest.clone()),
             permissions: tool_permissions(&record.manifest.tools),
-            https: Vec::new(),
+            request: Vec::new(),
             fs: Vec::new(),
         };
         (dir, record)
@@ -5328,7 +5585,7 @@ input_schema = {{ type = "object", additionalProperties = true }}
             version: Some(PluginExactVersion(record.version.clone())),
             digest: Some(record.digest.clone()),
             permissions: tool_permissions(&record.manifest.tools),
-            https: Vec::new(),
+            request: Vec::new(),
             fs: Vec::new(),
         };
         (dir, record)
@@ -5474,10 +5731,10 @@ input_schema = {{ type = "object", additionalProperties = true }}
         .expect("valid component wat")
     }
 
-    fn component_tool_importing_https(output: &[u8]) -> Vec<u8> {
+    fn component_tool_importing_request(output: &[u8]) -> Vec<u8> {
         wat::parse_str(format!(
             r#"(component
-              (import "yoi:host/https@1.0.0" (instance $https (export "request" (func $request (param "request-json" string) (result string)))))
+              (import "yoi:host/request@1.0.0" (instance $request (export "request" (func $request (param "request-json" string) (result string)))))
               (core module $m
                 (memory (export "memory") 1)
                 (func (export "realloc") (param i32 i32 i32 i32) (result i32)
@@ -5570,7 +5827,7 @@ input_schema = {{ type = "object", additionalProperties = true }}
 
     #[test]
     fn component_tool_denies_host_import_without_matching_grant() {
-        let (_dir, record) = resolved_record_with_component(component_tool_importing_https(
+        let (_dir, record) = resolved_record_with_component(component_tool_importing_request(
             br#"{"summary":"component ok"}"#,
         ));
 
@@ -5655,6 +5912,101 @@ input_schema = {{ type = "object", additionalProperties = true }}
         assert_eq!(meta.name, "PluginEcho");
     }
 
+    #[test]
+    fn static_inspection_reports_covering_request_grants_as_runtime_eligible() {
+        let mut exact_manifest_broad_grant = record_with_request_grant();
+        exact_manifest_broad_grant.grants.request = vec![PluginRequestGrant {
+            scheme: "*".to_string(),
+            host: "*".to_string(),
+            port: None,
+            methods: vec!["GET".to_string()],
+            path_prefixes: Vec::new(),
+        }];
+
+        let inspection = inspect_resolved_plugin_static(&exact_manifest_broad_grant);
+        let target = inspection
+            .host_apis
+            .iter()
+            .find(|api| {
+                api.permission
+                    .starts_with("host_api.request target https://api.example.test")
+            })
+            .expect("manifest request target inspection");
+        assert!(target.requested);
+        assert!(target.granted);
+        assert!(target.eligible);
+        let diagnostic = target.diagnostic.as_deref().unwrap_or_default();
+        assert!(
+            diagnostic.contains("broad/arbitrary") || diagnostic.contains("partially covered"),
+            "{target:#?}"
+        );
+        let broad_grant = inspection
+            .host_apis
+            .iter()
+            .find(|api| api.permission.starts_with("host_api.request grant *://*"))
+            .expect("broad grant inspection");
+        assert!(broad_grant.requested);
+        assert!(broad_grant.granted);
+        assert!(broad_grant.eligible);
+        assert!(
+            !inspection
+                .host_apis
+                .iter()
+                .any(|api| api.permission.starts_with("host_api.request grant-only")),
+            "{:#?}",
+            inspection.host_apis
+        );
+    }
+
+    #[test]
+    fn static_inspection_reports_request_grant_intersections_as_runtime_eligible() {
+        let mut broad_manifest_exact_grant = record_with_request_grant();
+        broad_manifest_exact_grant.manifest.request = vec![PluginRequestGrant {
+            scheme: "*".to_string(),
+            host: "*".to_string(),
+            port: None,
+            methods: vec!["GET".to_string(), "POST".to_string()],
+            path_prefixes: Vec::new(),
+        }];
+
+        let inspection = inspect_resolved_plugin_static(&broad_manifest_exact_grant);
+        let target = inspection
+            .host_apis
+            .iter()
+            .find(|api| api.permission.starts_with("host_api.request target *://*"))
+            .expect("broad manifest target inspection");
+        assert!(target.requested);
+        assert!(target.granted);
+        assert!(target.eligible);
+        assert!(
+            target
+                .diagnostic
+                .as_deref()
+                .unwrap_or_default()
+                .contains("partially covered"),
+            "{target:#?}"
+        );
+        let exact_grant = inspection
+            .host_apis
+            .iter()
+            .find(|api| {
+                api.permission
+                    .starts_with("host_api.request grant https://api.example.test")
+            })
+            .expect("exact grant inspection");
+        assert!(exact_grant.requested);
+        assert!(exact_grant.granted);
+        assert!(exact_grant.eligible);
+        assert!(
+            !inspection
+                .host_apis
+                .iter()
+                .any(|api| api.permission.starts_with("host_api.request grant-only")),
+            "{:#?}",
+            inspection.host_apis
+        );
+    }
+
     #[test]
     fn component_static_inspection_reports_component_runtime_without_execution() {
         let mut record = record(vec![tool("Echo")]);
@@ -5802,10 +6154,10 @@ input_schema = { type = "object", additionalProperties = true }
         .unwrap()
     }
 
-    fn https_import_module() -> Vec<u8> {
+    fn request_import_module() -> Vec<u8> {
         wat::parse_str(
             r#"(module
-                (import "yoi:https" "request" (func $request))
+                (import "yoi:request" "request" (func $request))
                 (memory (export "memory") 1)
                 (func (export "yoi_tool_call"))
               )"#,
diff --git a/crates/pod/src/pod.rs b/crates/pod/src/pod.rs
index 882ee11e..010ceafc 100644
--- a/crates/pod/src/pod.rs
+++ b/crates/pod/src/pod.rs
@@ -5378,6 +5378,7 @@ permission = "read"
                 services: vec![],
                 ingresses: vec![],
                 permissions: vec![],
+                request: vec![],
             },
             enabled_surfaces: vec![manifest::plugin::PluginSurface::Hook],
             grants: manifest::plugin::PluginGrantConfig::default(),
diff --git a/crates/workspace-server/Cargo.toml b/crates/workspace-server/Cargo.toml
new file mode 100644
index 00000000..e7a6d8d8
--- /dev/null
+++ b/crates/workspace-server/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "yoi-workspace-server"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[dependencies]
+async-trait.workspace = true
+axum.workspace = true
+project-record.workspace = true
+rusqlite.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+serde_yaml.workspace = true
+thiserror.workspace = true
+ticket.workspace = true
+tokio = { workspace = true, features = ["fs", "net", "rt", "sync"] }
+tracing.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true
+tower = { workspace = true, features = ["util"] }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
diff --git a/crates/workspace-server/src/lib.rs b/crates/workspace-server/src/lib.rs
new file mode 100644
index 00000000..502ca47d
--- /dev/null
+++ b/crates/workspace-server/src/lib.rs
@@ -0,0 +1,35 @@
+//! Local workspace web control plane backend bootstrap.
+//!
+//! This crate deliberately provides backend building blocks and an HTTP router;
+//! it is not the product CLI facade. Existing `.yoi` Ticket and Objective files
+//! remain the canonical project records and are read through bounded bridge APIs.
+
+pub mod records;
+pub mod server;
+pub mod store;
+
+pub use records::{
+    LocalProjectRecordReader, ObjectiveDetail, ObjectiveSummary, TicketDetail, TicketSummary,
+};
+pub use server::{AuthConfig, ServerConfig, WorkspaceApi, build_router, serve};
+pub use store::{ControlPlaneStore, SqliteWorkspaceStore, WorkspaceRecord};
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("sqlite error: {0}")]
+    Sqlite(#[from] rusqlite::Error),
+    #[error("ticket error: {0}")]
+    Ticket(#[from] ticket::TicketError),
+    #[error("yaml error: {0}")]
+    Yaml(#[from] serde_yaml::Error),
+    #[error("invalid project record id `{0}`")]
+    InvalidRecordId(String),
+    #[error("record `{0}` is missing frontmatter")]
+    MissingFrontmatter(String),
+    #[error("store error: {0}")]
+    Store(String),
+}
diff --git a/crates/workspace-server/src/records.rs b/crates/workspace-server/src/records.rs
new file mode 100644
index 00000000..fe3e0d12
--- /dev/null
+++ b/crates/workspace-server/src/records.rs
@@ -0,0 +1,341 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use project_record::validate_record_id;
+use serde::{Deserialize, Serialize};
+use ticket::{LocalTicketBackend, TicketFilter, TicketIdOrSlug};
+
+use crate::{Error, Result};
+
+const DETAIL_BODY_LIMIT: usize = 64 * 1024;
+
+#[derive(Debug, Clone)]
+pub struct LocalProjectRecordReader {
+    workspace_root: PathBuf,
+    ticket_backend: LocalTicketBackend,
+}
+
+impl LocalProjectRecordReader {
+    pub fn new(workspace_root: impl Into<PathBuf>) -> Self {
+        let workspace_root = workspace_root.into();
+        let ticket_root = workspace_root.join(".yoi/tickets");
+        Self {
+            workspace_root,
+            ticket_backend: LocalTicketBackend::new(ticket_root),
+        }
+    }
+
+    pub fn workspace_root(&self) -> &Path {
+        self.workspace_root.as_path()
+    }
+
+    pub fn list_tickets(&self, limit: usize) -> Result<ProjectRecordList<TicketSummary>> {
+        let partial = self.ticket_backend.list_partial(TicketFilter::all())?;
+        let mut items = partial
+            .tickets
+            .into_iter()
+            .map(|item| TicketSummary {
+                id: item.id,
+                title: item.title,
+                state: item.workflow_state.as_str().to_string(),
+                priority: item.priority,
+                updated_at: item.updated_at,
+                queued_by: item.queued_by,
+                queued_at: item.queued_at,
+                record_source: "local_yoi_ticket".to_string(),
+            })
+            .collect::<Vec<_>>();
+        items.sort_by(|a, b| {
+            b.updated_at
+                .cmp(&a.updated_at)
+                .then_with(|| a.id.cmp(&b.id))
+        });
+        items.truncate(limit.min(200));
+        Ok(ProjectRecordList {
+            items,
+            invalid_records: partial
+                .invalid_records
+                .into_iter()
+                .map(|record| InvalidProjectRecord {
+                    label: record.label,
+                    reason: record.reason,
+                })
+                .collect(),
+            record_authority: "local_yoi_project_records".to_string(),
+        })
+    }
+
+    pub fn ticket(&self, id: &str) -> Result<TicketDetail> {
+        validate_project_id(id)?;
+        let partial = self
+            .ticket_backend
+            .show_partial(TicketIdOrSlug::Id(id.to_string()))?;
+        let ticket = partial.ticket;
+        let (body, body_truncated) =
+            truncate_body(ticket.document.body.as_str(), DETAIL_BODY_LIMIT);
+        Ok(TicketDetail {
+            id: ticket.meta.id,
+            title: ticket.meta.title,
+            state: ticket.meta.workflow_state.as_str().to_string(),
+            priority: ticket.meta.priority,
+            created_at: ticket.meta.created_at,
+            updated_at: ticket.meta.updated_at,
+            queued_by: ticket.meta.queued_by,
+            queued_at: ticket.meta.queued_at,
+            risk_flags: ticket.meta.risk_flags,
+            body,
+            body_truncated,
+            event_count: ticket.events.len(),
+            artifact_count: ticket.artifacts.len(),
+            record_source: "local_yoi_ticket".to_string(),
+        })
+    }
+
+    pub fn list_objectives(&self, limit: usize) -> Result<ProjectRecordList<ObjectiveSummary>> {
+        let mut items = Vec::new();
+        let mut invalid_records = Vec::new();
+        let root = self.workspace_root.join(".yoi/objectives");
+        if !root.exists() {
+            return Ok(ProjectRecordList {
+                items,
+                invalid_records,
+                record_authority: "local_yoi_project_records".to_string(),
+            });
+        }
+
+        for entry in fs::read_dir(&root)? {
+            let entry = entry?;
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+            let id = entry.file_name().to_string_lossy().to_string();
+            match read_objective_summary(&path, &id) {
+                Ok(item) => items.push(item),
+                Err(error) => invalid_records.push(InvalidProjectRecord {
+                    label: id,
+                    reason: error.to_string(),
+                }),
+            }
+        }
+        items.sort_by(|a, b| {
+            b.updated_at
+                .cmp(&a.updated_at)
+                .then_with(|| a.id.cmp(&b.id))
+        });
+        items.truncate(limit.min(200));
+        Ok(ProjectRecordList {
+            items,
+            invalid_records,
+            record_authority: "local_yoi_project_records".to_string(),
+        })
+    }
+
+    pub fn objective(&self, id: &str) -> Result<ObjectiveDetail> {
+        validate_project_id(id)?;
+        let path = self.workspace_root.join(".yoi/objectives").join(id);
+        let raw = fs::read_to_string(path.join("item.md"))?;
+        let (frontmatter, body) = split_frontmatter(&raw, id)?;
+        let meta: ObjectiveFrontmatter = serde_yaml::from_str(frontmatter)?;
+        let (body, body_truncated) = truncate_body(body, DETAIL_BODY_LIMIT);
+        Ok(ObjectiveDetail {
+            id: id.to_string(),
+            title: meta.title,
+            state: meta.state,
+            created_at: meta.created_at,
+            updated_at: meta.updated_at,
+            linked_tickets: meta.linked_tickets,
+            body,
+            body_truncated,
+            record_source: "local_yoi_objective".to_string(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ProjectRecordList<T> {
+    pub items: Vec<T>,
+    pub invalid_records: Vec<InvalidProjectRecord>,
+    pub record_authority: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct InvalidProjectRecord {
+    pub label: String,
+    pub reason: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TicketSummary {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub priority: String,
+    pub updated_at: Option<String>,
+    pub queued_by: Option<String>,
+    pub queued_at: Option<String>,
+    pub record_source: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TicketDetail {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub priority: String,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+    pub queued_by: Option<String>,
+    pub queued_at: Option<String>,
+    pub risk_flags: Vec<String>,
+    pub body: String,
+    pub body_truncated: bool,
+    pub event_count: usize,
+    pub artifact_count: usize,
+    pub record_source: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ObjectiveSummary {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub updated_at: Option<String>,
+    pub linked_tickets: Vec<String>,
+    pub record_source: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ObjectiveDetail {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+    pub linked_tickets: Vec<String>,
+    pub body: String,
+    pub body_truncated: bool,
+    pub record_source: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ObjectiveFrontmatter {
+    title: String,
+    state: String,
+    #[serde(default)]
+    created_at: Option<String>,
+    #[serde(default)]
+    updated_at: Option<String>,
+    #[serde(default)]
+    linked_tickets: Vec<String>,
+}
+
+fn read_objective_summary(path: &Path, id: &str) -> Result<ObjectiveSummary> {
+    validate_project_id(id)?;
+    let raw = fs::read_to_string(path.join("item.md"))?;
+    let (frontmatter, _) = split_frontmatter(&raw, id)?;
+    let meta: ObjectiveFrontmatter = serde_yaml::from_str(frontmatter)?;
+    Ok(ObjectiveSummary {
+        id: id.to_string(),
+        title: meta.title,
+        state: meta.state,
+        updated_at: meta.updated_at,
+        linked_tickets: meta.linked_tickets,
+        record_source: "local_yoi_objective".to_string(),
+    })
+}
+
+fn split_frontmatter<'a>(raw: &'a str, label: &str) -> Result<(&'a str, &'a str)> {
+    let rest = raw
+        .strip_prefix("---\n")
+        .ok_or_else(|| Error::MissingFrontmatter(label.to_string()))?;
+    let Some((frontmatter, body)) = rest.split_once("\n---\n") else {
+        return Err(Error::MissingFrontmatter(label.to_string()));
+    };
+    Ok((frontmatter, body))
+}
+
+fn validate_project_id(id: &str) -> Result<()> {
+    validate_record_id(id).map_err(|_| Error::InvalidRecordId(id.to_string()))
+}
+
+fn truncate_body(body: &str, limit: usize) -> (String, bool) {
+    if body.len() <= limit {
+        return (body.to_string(), false);
+    }
+    let mut end = limit;
+    while !body.is_char_boundary(end) {
+        end -= 1;
+    }
+    (body[..end].to_string(), true)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_local_yoi_ticket_and_objective_records_without_migration() {
+        let dir = tempfile::tempdir().unwrap();
+        write_ticket(dir.path(), "00000000001J2", "Read bridge", "ready");
+        write_objective(dir.path(), "00000000001J3", "Control plane", "active");
+
+        let reader = LocalProjectRecordReader::new(dir.path());
+        let tickets = reader.list_tickets(20).unwrap();
+        assert_eq!(tickets.record_authority, "local_yoi_project_records");
+        assert_eq!(tickets.items[0].id, "00000000001J2");
+        assert_eq!(tickets.items[0].state, "ready");
+
+        let ticket = reader.ticket("00000000001J2").unwrap();
+        assert!(ticket.body.contains("Ticket body"));
+
+        let objectives = reader.list_objectives(20).unwrap();
+        assert_eq!(objectives.items[0].id, "00000000001J3");
+        assert_eq!(objectives.items[0].linked_tickets, vec!["00000000001J2"]);
+
+        let objective = reader.objective("00000000001J3").unwrap();
+        assert!(objective.body.contains("Objective body"));
+    }
+
+    fn write_ticket(root: &Path, id: &str, title: &str, state: &str) {
+        let ticket_dir = root.join(".yoi/tickets").join(id);
+        fs::create_dir_all(&ticket_dir).unwrap();
+        fs::write(
+            ticket_dir.join("item.md"),
+            format!(
+                r#"---
+title: "{title}"
+state: "{state}"
+created_at: "2026-01-01T00:00:00Z"
+updated_at: "2026-01-02T00:00:00Z"
+---
+
+Ticket body.
+"#,
+            ),
+        )
+        .unwrap();
+        fs::write(ticket_dir.join("thread.md"), "").unwrap();
+    }
+
+    fn write_objective(root: &Path, id: &str, title: &str, state: &str) {
+        let objective_dir = root.join(".yoi/objectives").join(id);
+        fs::create_dir_all(&objective_dir).unwrap();
+        fs::write(
+            objective_dir.join("item.md"),
+            format!(
+                r#"---
+title: "{title}"
+state: "{state}"
+created_at: "2026-01-01T00:00:00Z"
+updated_at: "2026-01-02T00:00:00Z"
+linked_tickets: ["00000000001J2"]
+---
+
+Objective body.
+"#,
+            ),
+        )
+        .unwrap();
+    }
+}
diff --git a/crates/workspace-server/src/server.rs b/crates/workspace-server/src/server.rs
new file mode 100644
index 00000000..19d5f27d
--- /dev/null
+++ b/crates/workspace-server/src/server.rs
@@ -0,0 +1,530 @@
+use std::path::{Component, Path, PathBuf};
+use std::sync::Arc;
+
+use axum::extract::{Path as AxumPath, State};
+use axum::http::header::CONTENT_TYPE;
+use axum::http::{StatusCode, Uri};
+use axum::response::{IntoResponse, Response};
+use axum::routing::get;
+use axum::{Json, Router};
+use serde::{Deserialize, Serialize};
+use tokio::net::TcpListener;
+
+use crate::records::{LocalProjectRecordReader, ObjectiveDetail, ProjectRecordList, TicketDetail};
+use crate::store::{ControlPlaneStore, RunSummary, RunnerSummary, WorkspaceRecord};
+use crate::{Error, Result};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum AuthConfig {
+    /// Local/dev-only mode. If a token is configured by a future entrypoint, it
+    /// is a development guard only and not a production SaaS auth model.
+    LocalDevToken { token_configured: bool },
+}
+
+#[derive(Clone)]
+pub struct ServerConfig {
+    pub workspace_id: String,
+    pub workspace_root: PathBuf,
+    pub static_assets_dir: Option<PathBuf>,
+    pub auth: AuthConfig,
+    pub max_records: usize,
+}
+
+impl ServerConfig {
+    pub fn local_dev(workspace_root: impl Into<PathBuf>) -> Self {
+        let workspace_root = workspace_root.into();
+        let display = workspace_root
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("workspace");
+        Self {
+            workspace_id: format!("local:{display}"),
+            workspace_root,
+            static_assets_dir: None,
+            auth: AuthConfig::LocalDevToken {
+                token_configured: false,
+            },
+            max_records: 200,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct WorkspaceApi {
+    config: ServerConfig,
+    store: Arc<dyn ControlPlaneStore>,
+    records: LocalProjectRecordReader,
+}
+
+impl WorkspaceApi {
+    pub async fn new(config: ServerConfig, store: Arc<dyn ControlPlaneStore>) -> Result<Self> {
+        let display_name = config
+            .workspace_root
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("workspace")
+            .to_string();
+        store
+            .upsert_workspace(&WorkspaceRecord {
+                workspace_id: config.workspace_id.clone(),
+                display_name,
+                local_root: config.workspace_root.clone(),
+                record_authority: "local_yoi_project_records".to_string(),
+                created_at: "1970-01-01T00:00:00Z".to_string(),
+                updated_at: "1970-01-01T00:00:00Z".to_string(),
+            })
+            .await?;
+        Ok(Self {
+            records: LocalProjectRecordReader::new(config.workspace_root.clone()),
+            config,
+            store,
+        })
+    }
+
+    pub fn workspace_id(&self) -> &str {
+        self.config.workspace_id.as_str()
+    }
+}
+
+pub fn build_router(api: WorkspaceApi) -> Router {
+    Router::new()
+        .route("/api/workspace", get(get_workspace))
+        .route("/api/tickets", get(list_tickets))
+        .route("/api/tickets/{id}", get(get_ticket))
+        .route("/api/objectives", get(list_objectives))
+        .route("/api/objectives/{id}", get(get_objective))
+        .route("/api/runs", get(list_runs))
+        .route("/api/runners", get(list_runners))
+        .fallback(get(static_or_spa_fallback))
+        .with_state(api)
+}
+
+pub async fn serve(
+    config: ServerConfig,
+    store: Arc<dyn ControlPlaneStore>,
+    listener: TcpListener,
+) -> Result<()> {
+    let api = WorkspaceApi::new(config, store).await?;
+    axum::serve(listener, build_router(api)).await?;
+    Ok(())
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WorkspaceResponse {
+    pub workspace_id: String,
+    pub display_name: String,
+    pub local_root: PathBuf,
+    pub record_authority: String,
+    pub schema_version: i64,
+    pub auth: AuthConfig,
+    pub extension_points: ExtensionPoints,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ExtensionPoints {
+    pub store: String,
+    pub event_stream: ExtensionPointState,
+    pub runner_connection: ExtensionPointState,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ExtensionPointState {
+    pub status: String,
+    pub note: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ListResponse<T> {
+    pub workspace_id: String,
+    pub limit: usize,
+    pub items: Vec<T>,
+    pub invalid_records: Vec<crate::records::InvalidProjectRecord>,
+    pub record_authority: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RuntimeListResponse<T> {
+    pub workspace_id: String,
+    pub limit: usize,
+    pub items: Vec<T>,
+    pub source: String,
+}
+
+async fn get_workspace(State(api): State<WorkspaceApi>) -> ApiResult<Json<WorkspaceResponse>> {
+    let schema_version = api.store.schema_version().await?;
+    let stored = api.store.get_workspace(api.workspace_id()).await?;
+    let display_name = stored
+        .as_ref()
+        .map(|record| record.display_name.clone())
+        .or_else(|| {
+            api.config
+                .workspace_root
+                .file_name()
+                .and_then(|name| name.to_str())
+                .map(str::to_string)
+        })
+        .unwrap_or_else(|| "workspace".to_string());
+    Ok(Json(WorkspaceResponse {
+        workspace_id: api.config.workspace_id.clone(),
+        display_name,
+        local_root: api.config.workspace_root.clone(),
+        record_authority: "local_yoi_project_records".to_string(),
+        schema_version,
+        auth: api.config.auth.clone(),
+        extension_points: ExtensionPoints {
+            store: "sqlite".to_string(),
+            event_stream: ExtensionPointState {
+                status: "reserved".to_string(),
+                note: "No event stream is exposed in this bootstrap; route/state seams are reserved.".to_string(),
+            },
+            runner_connection: ExtensionPointState {
+                status: "reserved".to_string(),
+                note: "Runner connections are modeled, but no job dispatch or scheduler is implemented.".to_string(),
+            },
+        },
+    }))
+}
+
+async fn list_tickets(
+    State(api): State<WorkspaceApi>,
+) -> ApiResult<Json<ListResponse<crate::records::TicketSummary>>> {
+    let limit = api.config.max_records.min(200);
+    let ProjectRecordList {
+        items,
+        invalid_records,
+        record_authority,
+    } = api.records.list_tickets(limit)?;
+    Ok(Json(ListResponse {
+        workspace_id: api.config.workspace_id,
+        limit,
+        items,
+        invalid_records,
+        record_authority,
+    }))
+}
+
+async fn get_ticket(
+    State(api): State<WorkspaceApi>,
+    AxumPath(id): AxumPath<String>,
+) -> ApiResult<Json<TicketDetail>> {
+    Ok(Json(api.records.ticket(&id)?))
+}
+
+async fn list_objectives(
+    State(api): State<WorkspaceApi>,
+) -> ApiResult<Json<ListResponse<crate::records::ObjectiveSummary>>> {
+    let limit = api.config.max_records.min(200);
+    let ProjectRecordList {
+        items,
+        invalid_records,
+        record_authority,
+    } = api.records.list_objectives(limit)?;
+    Ok(Json(ListResponse {
+        workspace_id: api.config.workspace_id,
+        limit,
+        items,
+        invalid_records,
+        record_authority,
+    }))
+}
+
+async fn get_objective(
+    State(api): State<WorkspaceApi>,
+    AxumPath(id): AxumPath<String>,
+) -> ApiResult<Json<ObjectiveDetail>> {
+    Ok(Json(api.records.objective(&id)?))
+}
+
+async fn list_runs(
+    State(api): State<WorkspaceApi>,
+) -> ApiResult<Json<RuntimeListResponse<RunSummary>>> {
+    let limit = api.config.max_records.min(200);
+    let items = api.store.list_runs(api.workspace_id(), limit).await?;
+    Ok(Json(RuntimeListResponse {
+        workspace_id: api.config.workspace_id,
+        limit,
+        items,
+        source: "sqlite_runtime_tables".to_string(),
+    }))
+}
+
+async fn list_runners(
+    State(api): State<WorkspaceApi>,
+) -> ApiResult<Json<RuntimeListResponse<RunnerSummary>>> {
+    let limit = api.config.max_records.min(200);
+    let items = api.store.list_runners(api.workspace_id(), limit).await?;
+    Ok(Json(RuntimeListResponse {
+        workspace_id: api.config.workspace_id,
+        limit,
+        items,
+        source: "sqlite_runtime_tables".to_string(),
+    }))
+}
+
+async fn static_or_spa_fallback(State(api): State<WorkspaceApi>, uri: Uri) -> Response {
+    if uri.path().starts_with("/api/") || uri.path() == "/api" {
+        return (
+            StatusCode::NOT_FOUND,
+            [(CONTENT_TYPE, "application/json")],
+            Json(serde_json::json!({
+                "error": "not_found",
+                "message": "unknown api route"
+            }))
+            .to_string(),
+        )
+            .into_response();
+    }
+
+    let Some(static_root) = api.config.static_assets_dir.as_ref() else {
+        return StatusCode::NOT_FOUND.into_response();
+    };
+
+    match read_static_or_index(static_root, uri.path()).await {
+        Ok(StaticAsset {
+            bytes,
+            content_type,
+        }) => (StatusCode::OK, [(CONTENT_TYPE, content_type)], bytes).into_response(),
+        Err(error) => {
+            tracing::debug!(%error, path = %uri.path(), "failed to serve static asset");
+            StatusCode::NOT_FOUND.into_response()
+        }
+    }
+}
+
+struct StaticAsset {
+    bytes: Vec<u8>,
+    content_type: &'static str,
+}
+
+async fn read_static_or_index(root: &Path, request_path: &str) -> Result<StaticAsset> {
+    let candidate = safe_static_candidate(root, request_path)?;
+    let file = if tokio::fs::metadata(&candidate)
+        .await
+        .map(|m| m.is_file())
+        .unwrap_or(false)
+    {
+        candidate
+    } else {
+        root.join("index.html")
+    };
+    let content_type = content_type_for(&file);
+    let bytes = tokio::fs::read(file).await?;
+    Ok(StaticAsset {
+        bytes,
+        content_type,
+    })
+}
+
+fn safe_static_candidate(root: &Path, request_path: &str) -> Result<PathBuf> {
+    let mut path = root.to_path_buf();
+    let clean = request_path.trim_start_matches('/');
+    if clean.is_empty() {
+        path.push("index.html");
+        return Ok(path);
+    }
+    for component in Path::new(clean).components() {
+        match component {
+            Component::Normal(part) => path.push(part),
+            Component::CurDir => {}
+            _ => return Err(Error::Store("static path escape rejected".to_string())),
+        }
+    }
+    Ok(path)
+}
+
+fn content_type_for(path: &Path) -> &'static str {
+    match path
+        .extension()
+        .and_then(|ext| ext.to_str())
+        .unwrap_or_default()
+    {
+        "css" => "text/css; charset=utf-8",
+        "js" => "text/javascript; charset=utf-8",
+        "json" => "application/json",
+        "svg" => "image/svg+xml",
+        "html" | "" => "text/html; charset=utf-8",
+        _ => "application/octet-stream",
+    }
+}
+
+type ApiResult<T> = std::result::Result<T, ApiError>;
+
+struct ApiError(Error);
+
+impl From<Error> for ApiError {
+    fn from(error: Error) -> Self {
+        Self(error)
+    }
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        let status = match &self.0 {
+            Error::InvalidRecordId(_) | Error::MissingFrontmatter(_) => StatusCode::NOT_FOUND,
+            Error::Ticket(_) => StatusCode::NOT_FOUND,
+            _ => StatusCode::INTERNAL_SERVER_ERROR,
+        };
+        (
+            status,
+            [(CONTENT_TYPE, "application/json")],
+            Json(serde_json::json!({
+                "error": status.canonical_reason().unwrap_or("error"),
+                "message": self.0.to_string(),
+            }))
+            .to_string(),
+        )
+            .into_response()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::{Body, to_bytes};
+    use axum::http::Request;
+    use serde_json::Value;
+    use tower::ServiceExt;
+
+    use crate::store::SqliteWorkspaceStore;
+
+    #[tokio::test]
+    async fn serves_bounded_read_apis_and_static_spa_separately() {
+        let dir = tempfile::tempdir().unwrap();
+        write_ticket(dir.path(), "00000000001J2", "API Ticket", "ready");
+        write_objective(dir.path(), "00000000001J3", "API Objective", "active");
+        let static_dir = dir.path().join("static");
+        std::fs::create_dir_all(static_dir.join("assets")).unwrap();
+        std::fs::write(static_dir.join("index.html"), "<main>Yoi Workspace</main>").unwrap();
+        std::fs::write(static_dir.join("assets/app.js"), "console.log('yoi');").unwrap();
+
+        let store = SqliteWorkspaceStore::in_memory().unwrap();
+        let mut config = ServerConfig::local_dev(dir.path());
+        config.workspace_id = "local:test".to_string();
+        config.static_assets_dir = Some(static_dir);
+        let api = WorkspaceApi::new(config, Arc::new(store)).await.unwrap();
+        let app = build_router(api);
+
+        let workspace = get_json(app.clone(), "/api/workspace").await;
+        assert_eq!(workspace["workspace_id"], "local:test");
+        assert_eq!(workspace["record_authority"], "local_yoi_project_records");
+        assert_eq!(
+            workspace["extension_points"]["runner_connection"]["status"],
+            "reserved"
+        );
+
+        let tickets = get_json(app.clone(), "/api/tickets").await;
+        assert_eq!(tickets["items"][0]["id"], "00000000001J2");
+        assert_eq!(tickets["items"][0]["state"], "ready");
+
+        let objectives = get_json(app.clone(), "/api/objectives").await;
+        assert_eq!(objectives["items"][0]["id"], "00000000001J3");
+
+        let runners = get_json(app.clone(), "/api/runners").await;
+        assert!(runners["items"].as_array().unwrap().is_empty());
+
+        let static_response = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/assets/app.js")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(static_response.status(), StatusCode::OK);
+        assert_eq!(
+            static_response.headers().get(CONTENT_TYPE).unwrap(),
+            "text/javascript; charset=utf-8"
+        );
+
+        let spa_response = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/tickets/00000000001J2")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(spa_response.status(), StatusCode::OK);
+        let bytes = to_bytes(spa_response.into_body(), usize::MAX)
+            .await
+            .unwrap();
+        assert!(
+            String::from_utf8(bytes.to_vec())
+                .unwrap()
+                .contains("Yoi Workspace")
+        );
+
+        let api_miss = app
+            .oneshot(
+                Request::builder()
+                    .uri("/api/nope")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(api_miss.status(), StatusCode::NOT_FOUND);
+        let bytes = to_bytes(api_miss.into_body(), usize::MAX).await.unwrap();
+        assert!(
+            !String::from_utf8(bytes.to_vec())
+                .unwrap()
+                .contains("Yoi Workspace")
+        );
+    }
+
+    async fn get_json(app: Router, uri: &str) -> Value {
+        let response = app
+            .oneshot(Request::builder().uri(uri).body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::OK, "{uri}");
+        let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+        serde_json::from_slice(&bytes).unwrap()
+    }
+
+    fn write_ticket(root: &Path, id: &str, title: &str, state: &str) {
+        let ticket_dir = root.join(".yoi/tickets").join(id);
+        std::fs::create_dir_all(&ticket_dir).unwrap();
+        std::fs::write(
+            ticket_dir.join("item.md"),
+            format!(
+                r#"---
+title: "{title}"
+state: "{state}"
+created_at: "2026-01-01T00:00:00Z"
+updated_at: "2026-01-02T00:00:00Z"
+---
+
+Ticket body.
+"#,
+            ),
+        )
+        .unwrap();
+        std::fs::write(ticket_dir.join("thread.md"), "").unwrap();
+    }
+
+    fn write_objective(root: &Path, id: &str, title: &str, state: &str) {
+        let objective_dir = root.join(".yoi/objectives").join(id);
+        std::fs::create_dir_all(&objective_dir).unwrap();
+        std::fs::write(
+            objective_dir.join("item.md"),
+            format!(
+                r#"---
+title: "{title}"
+state: "{state}"
+created_at: "2026-01-01T00:00:00Z"
+updated_at: "2026-01-02T00:00:00Z"
+linked_tickets: ["00000000001J2"]
+---
+
+Objective body.
+"#,
+            ),
+        )
+        .unwrap();
+    }
+}
diff --git a/crates/workspace-server/src/store.rs b/crates/workspace-server/src/store.rs
new file mode 100644
index 00000000..3b4a6334
--- /dev/null
+++ b/crates/workspace-server/src/store.rs
@@ -0,0 +1,341 @@
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use async_trait::async_trait;
+use rusqlite::{Connection, OptionalExtension, params};
+use serde::{Deserialize, Serialize};
+
+use crate::{Error, Result};
+
+const MIGRATIONS: &[Migration] = &[Migration {
+    version: 1,
+    name: "bootstrap workspace control plane",
+    sql: r#"
+CREATE TABLE IF NOT EXISTS workspaces (
+    workspace_id TEXT PRIMARY KEY,
+    display_name TEXT NOT NULL,
+    local_root TEXT NOT NULL,
+    record_authority TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS repositories (
+    repository_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    local_root TEXT NOT NULL,
+    role TEXT NOT NULL,
+    created_at TEXT NOT NULL
+);
+
+-- Projection tables are intentionally empty in this bootstrap: `.yoi/tickets`
+-- and `.yoi/objectives` remain canonical, but the tables reserve a future
+-- projection/cache seam without migrating authority.
+CREATE TABLE IF NOT EXISTS ticket_projections (
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    ticket_id TEXT NOT NULL,
+    title TEXT NOT NULL,
+    state TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (workspace_id, ticket_id)
+);
+
+CREATE TABLE IF NOT EXISTS objective_projections (
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    objective_id TEXT NOT NULL,
+    title TEXT NOT NULL,
+    state TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (workspace_id, objective_id)
+);
+
+CREATE TABLE IF NOT EXISTS runners (
+    runner_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    label TEXT NOT NULL,
+    status TEXT NOT NULL,
+    last_seen_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS runs (
+    run_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    subject_kind TEXT NOT NULL,
+    subject_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS artifacts (
+    artifact_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
+    run_id TEXT REFERENCES runs(run_id) ON DELETE SET NULL,
+    path TEXT NOT NULL,
+    content_type TEXT,
+    created_at TEXT NOT NULL
+);
+"#,
+}];
+
+struct Migration {
+    version: i64,
+    name: &'static str,
+    sql: &'static str,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WorkspaceRecord {
+    pub workspace_id: String,
+    pub display_name: String,
+    pub local_root: PathBuf,
+    pub record_authority: String,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct RunSummary {
+    pub run_id: String,
+    pub workspace_id: String,
+    pub subject_kind: String,
+    pub subject_id: String,
+    pub status: String,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct RunnerSummary {
+    pub runner_id: String,
+    pub workspace_id: String,
+    pub label: String,
+    pub status: String,
+    pub last_seen_at: Option<String>,
+}
+
+#[async_trait]
+pub trait ControlPlaneStore: Send + Sync {
+    async fn schema_version(&self) -> Result<i64>;
+    async fn upsert_workspace(&self, record: &WorkspaceRecord) -> Result<()>;
+    async fn get_workspace(&self, workspace_id: &str) -> Result<Option<WorkspaceRecord>>;
+    async fn list_runs(&self, workspace_id: &str, limit: usize) -> Result<Vec<RunSummary>>;
+    async fn list_runners(&self, workspace_id: &str, limit: usize) -> Result<Vec<RunnerSummary>>;
+}
+
+#[derive(Clone)]
+pub struct SqliteWorkspaceStore {
+    conn: Arc<Mutex<Connection>>,
+}
+
+impl SqliteWorkspaceStore {
+    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
+        let conn = Connection::open(path)?;
+        Self::from_connection(conn)
+    }
+
+    pub fn in_memory() -> Result<Self> {
+        Self::from_connection(Connection::open_in_memory()?)
+    }
+
+    pub fn from_connection(conn: Connection) -> Result<Self> {
+        configure_sqlite(&conn)?;
+        apply_migrations(&conn)?;
+        Ok(Self {
+            conn: Arc::new(Mutex::new(conn)),
+        })
+    }
+
+    fn with_conn<T>(&self, f: impl FnOnce(&Connection) -> Result<T>) -> Result<T> {
+        let conn = self
+            .conn
+            .lock()
+            .map_err(|_| Error::Store("sqlite connection lock poisoned".to_string()))?;
+        f(&conn)
+    }
+}
+
+#[async_trait]
+impl ControlPlaneStore for SqliteWorkspaceStore {
+    async fn schema_version(&self) -> Result<i64> {
+        self.with_conn(current_schema_version)
+    }
+
+    async fn upsert_workspace(&self, record: &WorkspaceRecord) -> Result<()> {
+        self.with_conn(|conn| {
+            conn.execute(
+                r#"INSERT INTO workspaces (
+                    workspace_id, display_name, local_root, record_authority, created_at, updated_at
+                ) VALUES (?1, ?2, ?3, ?4, ?5, ?6)
+                ON CONFLICT(workspace_id) DO UPDATE SET
+                    display_name = excluded.display_name,
+                    local_root = excluded.local_root,
+                    record_authority = excluded.record_authority,
+                    updated_at = excluded.updated_at"#,
+                params![
+                    record.workspace_id,
+                    record.display_name,
+                    record.local_root.to_string_lossy(),
+                    record.record_authority,
+                    record.created_at,
+                    record.updated_at,
+                ],
+            )?;
+            Ok(())
+        })
+    }
+
+    async fn get_workspace(&self, workspace_id: &str) -> Result<Option<WorkspaceRecord>> {
+        self.with_conn(|conn| {
+            conn.query_row(
+                r#"SELECT workspace_id, display_name, local_root, record_authority, created_at, updated_at
+                   FROM workspaces WHERE workspace_id = ?1"#,
+                params![workspace_id],
+                |row| {
+                    Ok(WorkspaceRecord {
+                        workspace_id: row.get(0)?,
+                        display_name: row.get(1)?,
+                        local_root: PathBuf::from(row.get::<_, String>(2)?),
+                        record_authority: row.get(3)?,
+                        created_at: row.get(4)?,
+                        updated_at: row.get(5)?,
+                    })
+                },
+            )
+            .optional()
+            .map_err(Error::from)
+        })
+    }
+
+    async fn list_runs(&self, workspace_id: &str, limit: usize) -> Result<Vec<RunSummary>> {
+        self.with_conn(|conn| {
+            let limit = limit.min(200) as i64;
+            let mut stmt = conn.prepare(
+                r#"SELECT run_id, workspace_id, subject_kind, subject_id, status, created_at, updated_at
+                   FROM runs WHERE workspace_id = ?1 ORDER BY updated_at DESC, run_id DESC LIMIT ?2"#,
+            )?;
+            let rows = stmt.query_map(params![workspace_id, limit], |row| {
+                Ok(RunSummary {
+                    run_id: row.get(0)?,
+                    workspace_id: row.get(1)?,
+                    subject_kind: row.get(2)?,
+                    subject_id: row.get(3)?,
+                    status: row.get(4)?,
+                    created_at: row.get(5)?,
+                    updated_at: row.get(6)?,
+                })
+            })?;
+            rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Error::from)
+        })
+    }
+
+    async fn list_runners(&self, workspace_id: &str, limit: usize) -> Result<Vec<RunnerSummary>> {
+        self.with_conn(|conn| {
+            let limit = limit.min(200) as i64;
+            let mut stmt = conn.prepare(
+                r#"SELECT runner_id, workspace_id, label, status, last_seen_at
+                   FROM runners WHERE workspace_id = ?1 ORDER BY runner_id ASC LIMIT ?2"#,
+            )?;
+            let rows = stmt.query_map(params![workspace_id, limit], |row| {
+                Ok(RunnerSummary {
+                    runner_id: row.get(0)?,
+                    workspace_id: row.get(1)?,
+                    label: row.get(2)?,
+                    status: row.get(3)?,
+                    last_seen_at: row.get(4)?,
+                })
+            })?;
+            rows.collect::<rusqlite::Result<Vec<_>>>()
+                .map_err(Error::from)
+        })
+    }
+}
+
+fn configure_sqlite(conn: &Connection) -> Result<()> {
+    conn.busy_timeout(Duration::from_millis(5_000))?;
+    conn.execute_batch(
+        r#"
+PRAGMA foreign_keys = ON;
+PRAGMA journal_mode = WAL;
+PRAGMA busy_timeout = 5000;
+CREATE TABLE IF NOT EXISTS __yoi_schema_migrations (
+    version INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+"#,
+    )?;
+    Ok(())
+}
+
+fn current_schema_version(conn: &Connection) -> Result<i64> {
+    conn.query_row(
+        "SELECT COALESCE(MAX(version), 0) FROM __yoi_schema_migrations",
+        [],
+        |row| row.get(0),
+    )
+    .map_err(Error::from)
+}
+
+fn apply_migrations(conn: &Connection) -> Result<()> {
+    let current = current_schema_version(conn)?;
+    for migration in MIGRATIONS
+        .iter()
+        .filter(|migration| migration.version > current)
+    {
+        let tx = conn.unchecked_transaction()?;
+        tx.execute_batch(migration.sql)?;
+        tx.execute(
+            "INSERT INTO __yoi_schema_migrations (version, name) VALUES (?1, ?2)",
+            params![migration.version, migration.name],
+        )?;
+        tx.commit()?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn migrates_sqlite_and_preserves_workspace_record() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = dir.path().join("control-plane.sqlite");
+        let store = SqliteWorkspaceStore::open(&db).unwrap();
+
+        assert_eq!(store.schema_version().await.unwrap(), 1);
+
+        let record = WorkspaceRecord {
+            workspace_id: "local-dev".to_string(),
+            display_name: "Yoi Dev".to_string(),
+            local_root: dir.path().to_path_buf(),
+            record_authority: "local_yoi_project_records".to_string(),
+            created_at: "2026-01-01T00:00:00Z".to_string(),
+            updated_at: "2026-01-01T00:00:00Z".to_string(),
+        };
+        store.upsert_workspace(&record).await.unwrap();
+
+        let reopened = SqliteWorkspaceStore::open(&db).unwrap();
+        assert_eq!(reopened.schema_version().await.unwrap(), 1);
+        assert_eq!(
+            reopened.get_workspace("local-dev").await.unwrap(),
+            Some(record)
+        );
+        assert!(
+            reopened
+                .list_runs("local-dev", 20)
+                .await
+                .unwrap()
+                .is_empty()
+        );
+        assert!(
+            reopened
+                .list_runners("local-dev", 20)
+                .await
+                .unwrap()
+                .is_empty()
+        );
+    }
+}
diff --git a/crates/yoi/src/plugin_cli.rs b/crates/yoi/src/plugin_cli.rs
index 6ea65fde..b9c19036 100644
--- a/crates/yoi/src/plugin_cli.rs
+++ b/crates/yoi/src/plugin_cli.rs
@@ -292,7 +292,7 @@ fn inspect_materialized_package(
             )),
             digest: Some(materialized.package.digest.clone()),
             permissions: requested_permissions,
-            https: Vec::new(),
+            request: Vec::new(),
             fs: Vec::new(),
         },
         config: None,
@@ -723,7 +723,7 @@ fn render_show(reference: &str, args: &PluginCliArgs) -> Result<String> {
         return Ok(format!("{}\n", serde_json::to_string_pretty(item)?));
     }
 
-    render_item_human(item)
+    render_item_human(&item)
 }
 
 fn render_item_human(item: &PluginInspectionItem) -> Result<String> {
@@ -799,8 +799,8 @@ fn render_item_human(item: &PluginInspectionItem) -> Result<String> {
     )?;
     writeln!(
         out,
-        "  configured_https_grants: {}",
-        join_or_none(&item.configured_https_grants)
+        "  configured_request_grants: {}",
+        join_or_none(&item.configured_request_grants)
     )?;
     writeln!(
         out,
@@ -976,7 +976,7 @@ fn snapshot_from_resolution(
         builder.configured = true;
         builder.enabled_surfaces = surface_strings(enablement.surfaces.iter().copied());
         builder.configured_grants = permission_strings(&enablement.grants.permissions);
-        builder.configured_https_grants = https_grant_strings(&enablement.grants.https);
+        builder.configured_request_grants = request_grant_strings(&enablement.grants.request);
         builder.configured_fs_grants = fs_grant_strings(&enablement.grants.fs);
         if let Ok(identity) = SourceQualifiedPluginId::parse(&enablement.id) {
             builder
@@ -1069,7 +1069,7 @@ fn fill_resolved(builder: &mut ItemBuilder, resolved: &ResolvedPlugin) {
     builder.enabled_surfaces = surface_strings(resolved.enabled_surfaces.iter().copied());
     builder.requested_permissions = permission_strings(&resolved.manifest.permissions);
     builder.configured_grants = permission_strings(&resolved.grants.permissions);
-    builder.configured_https_grants = https_grant_strings(&resolved.grants.https);
+    builder.configured_request_grants = request_grant_strings(&resolved.grants.request);
     builder.configured_fs_grants = fs_grant_strings(&resolved.grants.fs);
 
     let record = ResolvedPluginRecord::from_resolved(resolved);
@@ -1178,7 +1178,7 @@ fn permission_strings(permissions: &[PluginPermission]) -> Vec<String> {
     values
 }
 
-fn https_grant_strings(grants: &[manifest::plugin::PluginHttpsGrant]) -> Vec<String> {
+fn request_grant_strings(grants: &[manifest::plugin::PluginRequestGrant]) -> Vec<String> {
     let mut values: Vec<_> = grants.iter().map(|grant| grant.label()).collect();
     values.sort();
     values.dedup();
@@ -1262,7 +1262,7 @@ struct PluginInspectionItem {
     enabled_surfaces: Vec<String>,
     requested_permissions: Vec<String>,
     configured_grants: Vec<String>,
-    configured_https_grants: Vec<String>,
+    configured_request_grants: Vec<String>,
     configured_fs_grants: Vec<String>,
     tools: Vec<ToolSummary>,
     static_runtime: Option<PluginStaticInspection>,
@@ -1331,7 +1331,7 @@ struct ItemBuilder {
     enabled_surfaces: Vec<String>,
     requested_permissions: Vec<String>,
     configured_grants: Vec<String>,
-    configured_https_grants: Vec<String>,
+    configured_request_grants: Vec<String>,
     configured_fs_grants: Vec<String>,
     tools: Vec<ToolSummary>,
     static_runtime: Option<PluginStaticInspection>,
@@ -1358,7 +1358,7 @@ impl ItemBuilder {
             enabled_surfaces: Vec::new(),
             requested_permissions: Vec::new(),
             configured_grants: Vec::new(),
-            configured_https_grants: Vec::new(),
+            configured_request_grants: Vec::new(),
             configured_fs_grants: Vec::new(),
             tools: Vec::new(),
             static_runtime: None,
@@ -1430,7 +1430,7 @@ impl ItemBuilder {
             enabled_surfaces: self.enabled_surfaces,
             requested_permissions: self.requested_permissions,
             configured_grants: self.configured_grants,
-            configured_https_grants: self.configured_https_grants,
+            configured_request_grants: self.configured_request_grants,
             configured_fs_grants: self.configured_fs_grants,
             tools: self.tools,
             static_runtime: self.static_runtime,
@@ -1443,6 +1443,7 @@ impl ItemBuilder {
 mod tests {
     use super::*;
     use manifest::plugin::{PluginEnablementConfig, PluginExactVersion, PluginGrantConfig};
+    use pod::feature::plugin::{PluginPermissionEligibility, PluginRuntimeEligibility};
     use tempfile::tempdir;
 
     #[test]
@@ -1494,7 +1495,7 @@ mod tests {
         assert_eq!(show_json["configured_grants"][0], "surfaces.tool");
         assert_eq!(show_json["tools"][0]["permission"], "tool.Echo");
 
-        let show = render_item_human(item).unwrap();
+        let show = render_item_human(&item).unwrap();
         assert!(show.contains("status: active"));
         assert!(show.contains("schema_version: 1"));
         assert!(show.contains("api_version: 1"));
@@ -1503,6 +1504,78 @@ mod tests {
         assert!(show.contains("configured_grants: surfaces.tool, tool.Echo"));
     }
 
+    #[test]
+    fn render_show_distinguishes_request_grant_statuses_and_broad_targets() {
+        let item = PluginInspectionItem {
+            reference: "project:req".to_string(),
+            local_ref: Some("project:req".to_string()),
+            status: "configured".to_string(),
+            source: Some("project".to_string()),
+            package: Some("req".to_string()),
+            package_path: None,
+            version: Some("0.1.0".to_string()),
+            schema_version: Some(1),
+            api_version: Some(1),
+            digest: None,
+            configured: true,
+            discovered: true,
+            resolved: true,
+            static_eligible: true,
+            declared_surfaces: vec!["tool".to_string()],
+            enabled_surfaces: vec!["tool".to_string()],
+            requested_permissions: vec!["host_api.request".to_string()],
+            configured_grants: vec!["host_api.request".to_string()],
+            configured_request_grants: vec!["*://* GET * [broad-request]".to_string()],
+            configured_fs_grants: Vec::new(),
+            tools: Vec::new(),
+            static_runtime: Some(PluginStaticInspection {
+                runtime: PluginRuntimeEligibility {
+                    eligible: true,
+                    status: "component".to_string(),
+                    diagnostic: None,
+                },
+                host_apis: vec![
+                    PluginPermissionEligibility {
+                        permission: "host_api.request target https://api.example.test GET /v1/"
+                            .to_string(),
+                        requested: true,
+                        granted: true,
+                        eligible: true,
+                        diagnostic: Some(
+                            "covered by broad/arbitrary enabled request grant".to_string(),
+                        ),
+                    },
+                    PluginPermissionEligibility {
+                        permission: "host_api.request grant *://* GET * [broad-request]"
+                            .to_string(),
+                        requested: true,
+                        granted: true,
+                        eligible: true,
+                        diagnostic: Some(
+                            "broad/arbitrary enabled request grant is constrained by manifest declarations"
+                                .to_string(),
+                        ),
+                    },
+                ],
+                tools: Vec::new(),
+                services: Vec::new(),
+                ingresses: Vec::new(),
+            }),
+            diagnostics: Vec::new(),
+        };
+
+        let json = serde_json::to_value(&item).unwrap();
+        assert_eq!(
+            json["configured_request_grants"][0],
+            "*://* GET * [broad-request]"
+        );
+        let human = render_item_human(&item).unwrap();
+        assert!(human.contains("host_api.request target https://api.example.test"));
+        assert!(human.contains("requested=true granted=true eligible=true"));
+        assert!(human.contains("host_api.request grant *://*"));
+        assert!(human.contains("broad/arbitrary"));
+    }
+
     #[test]
     fn service_only_enablement_ignores_unselected_tool_static_grants() {
         let dir = tempdir().unwrap();
@@ -1522,7 +1595,7 @@ mod tests {
                     PluginPermission::surface(PluginSurface::Service),
                     PluginPermission::service("svc"),
                 ],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -1576,7 +1649,7 @@ mod tests {
                     PluginPermission::surface(PluginSurface::Tool),
                     PluginPermission::tool("Echo"),
                 ],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -1594,7 +1667,7 @@ mod tests {
                     PluginPermission::surface(PluginSurface::Tool),
                     PluginPermission::tool("Echo"),
                 ],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -1712,7 +1785,7 @@ mod tests {
                     PluginPermission::surface(PluginSurface::Tool),
                     PluginPermission::tool("Echo"),
                 ],
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -2247,7 +2320,7 @@ lifecycle = "host-managed"
                         PluginPermission::surface(PluginSurface::Tool),
                         PluginPermission::tool("Echo"),
                     ],
-                    https: Vec::new(),
+                    request: Vec::new(),
                     fs: Vec::new(),
                 },
                 config: None,
@@ -2278,7 +2351,7 @@ lifecycle = "host-managed"
                 version: Some(PluginExactVersion(version.to_string())),
                 digest: Some(digest),
                 permissions,
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
@@ -2306,7 +2379,7 @@ lifecycle = "host-managed"
                 version: Some(PluginExactVersion(version.to_string())),
                 digest: None,
                 permissions,
-                https: Vec::new(),
+                request: Vec::new(),
                 fs: Vec::new(),
             },
             config: None,
diff --git a/docs/design/plugin-component-model.md b/docs/design/plugin-component-model.md
index bf9aa9ff..5b66ae6c 100644
--- a/docs/design/plugin-component-model.md
+++ b/docs/design/plugin-component-model.md
@@ -150,7 +150,7 @@ runtime, so registration and execution still flow through the existing
 ToolRegistry and Worker Tool-result history path.
 
 Host imports are stable names under `yoi:host/*@1.0.0`; the repository WIT files
-live in `resources/plugin/wit/`. Importing `yoi:host/https@1.0.0` or
+live in `resources/plugin/wit/`. Importing `yoi:host/request@1.0.0` or
 `yoi:host/fs@1.0.0` is not authority. The runtime checks package grants before
 component instantiation and checks again on every host call. No WASI filesystem,
 network, environment, or other ambient imports are linked.
@@ -176,7 +176,7 @@ The v1 component world intentionally keeps Tool input, Tool output, and host API
 payloads as JSON strings. This is a migration bridge that preserves the existing
 ToolOutput schema, Tool history behavior, grant checks, and raw-Wasm host API
 semantics while moving package authors onto WIT/canonical ABI bindings.
-Structured WIT records for Tool requests/responses/errors and host HTTPS/FS
+Structured WIT records for Tool requests/responses/errors and host request/FS
 payloads are deferred to a follow-up API-design step rather than accidentally
 omitted.
 
diff --git a/docs/development/plugin-development.md b/docs/development/plugin-development.md
index c6c12d25..502dc303 100644
--- a/docs/development/plugin-development.md
+++ b/docs/development/plugin-development.md
@@ -294,29 +294,46 @@ rejected  invalid manifest, incompatible API, digest mismatch, grant denial, etc
 partial   usable package with some rejected surfaces/tools
 ```
 
-## `https` host API
+## `request` host API
 
-The `https` host API is outbound-only and grant-gated. It is meant for Tool calls such as JSON POSTs or REST requests. It is not a WebSocket/Gateway or inbound HTTP surface.
+The `request` host API is a one-shot outbound HTTP request API. It is meant for bounded Tool calls such as JSON POSTs or REST requests. It is not a WebSocket, SSE/event-stream, gateway, daemon, or inbound HTTP surface; persistent transports require a separate Plugin capability.
 
-Manifest permissions should request `host_api.https` in addition to the Tool permissions. Enablement grants must then allow the API and constrain hosts/methods.
+Manifest permissions should request `host_api.request` in addition to the Tool permissions, and the package manifest must statically declare the URL targets it may call. Enablement grants must then allow the API and grant matching request targets. A grant without a matching manifest target is unsafe/unused and is shown as ineligible rather than expanding authority.
 
-Example grant shape:
+Example manifest shape:
+
+```toml
+permissions = [
+  { kind = "surface", surface = "tool" },
+  { kind = "tool", name = "http_post_json" },
+  { kind = "host_api", api = "request" },
+]
+
+[[request]]
+scheme = "https"
+host = "api.example.com"
+methods = ["POST"]
+path_prefixes = ["/v1/"]
+```
+
+Example enablement grant shape:
 
 ```toml
 [plugins.enabled.grants]
 permissions = [
   { kind = "surface", surface = "tool" },
   { kind = "tool", name = "http_post_json" },
-  { kind = "host_api", api = "https" },
+  { kind = "host_api", api = "request" },
 ]
 
-[[plugins.enabled.grants.https]]
+[[plugins.enabled.grants.request]]
+scheme = "https"
 host = "api.example.com"
 methods = ["POST"]
 path_prefixes = ["/v1/"]
 ```
 
-Yoi rejects `http://`, localhost/private/link-local targets, disallowed hosts/methods, oversize requests/responses, and missing grants. Credentials must come from explicit config/secret references, not ambient environment variables.
+Yoi checks method, scheme, host, optional port, and path prefix against both the manifest declaration and enablement grant before any network I/O. `http://localhost`, loopback, private, and other local targets are never ambient; they require an explicit manifest request target and an explicit matching grant. The explicit request target is the declared URL authority; a granted DNS hostname may resolve to a loopback/private address without requiring a separate literal-IP grant, so reviewers should grant hostnames only when that resolution behavior is intended. Broad targets such as `host = "*"` are supported only as visibly broad request permissions in inspection/diagnostics. Embedded credentials, credential-like headers, oversize requests/responses, WebSocket URLs/upgrades, and SSE/event-stream requests are rejected.
 
 ## `fs` host API
 
diff --git a/package.nix b/package.nix
index 35743036..7ac7830b 100644
--- a/package.nix
+++ b/package.nix
@@ -29,6 +29,9 @@ let
       || isExcludedTree ".worktree"
       || isExcludedTree "work-items"
       || isExcludedTree "docs/report"
+      || isExcludedTree "web/workspace/node_modules"
+      || isExcludedTree "web/workspace/.svelte-kit"
+      || isExcludedTree "web/workspace/build"
     );
 in
 rustPlatform.buildRustPackage rec {
@@ -40,7 +43,7 @@ rustPlatform.buildRustPackage rec {
     filter = sourceFilter;
   };
 
-  cargoHash = "sha256-GUqhvq+JhJokk1R4VVeVz5cZe/6oSrVMyKjcltZEWqE=";
+  cargoHash = "sha256-RER/UXd74C2VhPHAeF36u6ruNBg0oLnR4YeQ/zLag88=";
 
   depsExtraArgs = {
     # Older fetchCargoVendor utilities used crates.io's API download endpoint,
diff --git a/resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit b/resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit
index e0544a0a..e0ba30bf 100644
--- a/resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit
+++ b/resources/plugin/wit/deps/yoi-host/yoi-host-v1.wit
@@ -1,9 +1,9 @@
 package yoi:host@1.0.0;
 
-/// Grant-bound HTTPS host API. Importing this interface does not grant
+/// Grant-bound one-shot HTTP request host API. Importing this interface does not grant
 /// authority; package grants are checked before registration/execution and on
 /// every host call.
-interface https {
+interface request {
   request: func(request-json: string) -> string;
 }
 
diff --git a/resources/plugin/wit/yoi-plugin-instance-v1.wit b/resources/plugin/wit/yoi-plugin-instance-v1.wit
index e811ecd7..cd8ad0cd 100644
--- a/resources/plugin/wit/yoi-plugin-instance-v1.wit
+++ b/resources/plugin/wit/yoi-plugin-instance-v1.wit
@@ -1,7 +1,7 @@
 package yoi:plugin@1.0.0;
 
 world instance {
-  import yoi:host/https@1.0.0;
+  import yoi:host/request@1.0.0;
   import yoi:host/fs@1.0.0;
 
   export start: func(config-json: string) -> string;
diff --git a/resources/plugin/wit/yoi-plugin-tool-v1.wit b/resources/plugin/wit/yoi-plugin-tool-v1.wit
index 74286424..0e2abb58 100644
--- a/resources/plugin/wit/yoi-plugin-tool-v1.wit
+++ b/resources/plugin/wit/yoi-plugin-tool-v1.wit
@@ -1,7 +1,7 @@
 package yoi:plugin@1.0.0;
 
 world tool {
-  import yoi:host/https@1.0.0;
+  import yoi:host/request@1.0.0;
   import yoi:host/fs@1.0.0;
 
   /// Execute a manifest-declared Tool. `input-json` is the normal Tool input
diff --git a/web/workspace/.gitignore b/web/workspace/.gitignore
new file mode 100644
index 00000000..89e541ca
--- /dev/null
+++ b/web/workspace/.gitignore
@@ -0,0 +1,5 @@
+node_modules
+.svelte-kit
+build
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
diff --git a/web/workspace/README.md b/web/workspace/README.md
new file mode 100644
index 00000000..3fc3b885
--- /dev/null
+++ b/web/workspace/README.md
@@ -0,0 +1,21 @@
+# Workspace web SPA
+
+This is the static SvelteKit shell for the local Yoi Workspace control plane.
+It is intentionally a read-only UI bootstrap: `.yoi/tickets` and
+`.yoi/objectives` remain canonical, and the Rust backend owns all business/API
+semantics.
+
+Package manager: npm with `package-lock.json` committed.
+
+Commands:
+
+```sh
+npm install
+npm run check
+npm run build
+```
+
+Build output is `web/workspace/build/` and is not checked in. Point the Rust
+backend `ServerConfig.static_assets_dir` at that directory (or another static
+asset directory) to serve the SPA. `node_modules/`, `.svelte-kit/`, and `build/`
+are generated local state and must remain ignored/excluded from package sources.
diff --git a/web/workspace/package-lock.json b/web/workspace/package-lock.json
new file mode 100644
index 00000000..a218a11b
--- /dev/null
+++ b/web/workspace/package-lock.json
@@ -0,0 +1,1673 @@
+{
+  "name": "@yoi/workspace-web",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@yoi/workspace-web",
+      "version": "0.0.0",
+      "devDependencies": {
+        "@sveltejs/adapter-static": "^3.0.9",
+        "@sveltejs/kit": "^2.49.4",
+        "@sveltejs/vite-plugin-svelte": "^6.2.1",
+        "svelte": "^5.45.6",
+        "svelte-check": "^4.3.4",
+        "typescript": "^5.9.3",
+        "vite": "^7.2.7"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
+      "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
+      "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
+      "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
+      "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
+      "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
+      "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
+      "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
+      "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
+      "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
+      "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
+      "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
+      "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
+      "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
+      "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
+      "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
+      "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
+      "integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
+      "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
+      "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
+      "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
+      "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.29",
+      "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.29.tgz",
+      "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
+      "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz",
+      "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz",
+      "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz",
+      "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz",
+      "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz",
+      "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz",
+      "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz",
+      "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz",
+      "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz",
+      "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz",
+      "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz",
+      "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz",
+      "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz",
+      "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz",
+      "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz",
+      "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz",
+      "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz",
+      "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz",
+      "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz",
+      "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz",
+      "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz",
+      "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz",
+      "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sveltejs/acorn-typescript": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.10.tgz",
+      "integrity": "sha512-4WfKk68eTih+MiJD4fSbxN7E8kVBmTMPWHUPYjvl2N0rMs53YLTT8/YjKU5Dtnz5LqDjl7LEw4U7lXR2W3J5WA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^8.9.0"
+      }
+    },
+    "node_modules/@sveltejs/adapter-static": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@sveltejs/adapter-static/-/adapter-static-3.0.10.tgz",
+      "integrity": "sha512-7D9lYFWJmB7zxZyTE/qxjksvMqzMuYrrsyh1f4AlZqeZeACPRySjbC3aFiY55wb1tWUaKOQG9PVbm74JcN2Iew==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@sveltejs/kit": "^2.0.0"
+      }
+    },
+    "node_modules/@sveltejs/kit": {
+      "version": "2.66.0",
+      "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.66.0.tgz",
+      "integrity": "sha512-7nN4Ur4+nofZ36DVo83JbRe02m61Vc+I441mML/DYa1pUTZ/x26+lbrdqPen8gjmsUc6flMtHEqAtn0UfmfvAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@sveltejs/acorn-typescript": "^1.0.9",
+        "@types/cookie": "^0.6.0",
+        "acorn": "^8.16.0",
+        "cookie": "^0.6.0",
+        "devalue": "^5.8.1",
+        "esm-env": "^1.2.2",
+        "kleur": "^4.1.5",
+        "magic-string": "^0.30.5",
+        "mrmime": "^2.0.0",
+        "set-cookie-parser": "^3.0.0",
+        "sirv": "^3.0.0"
+      },
+      "bin": {
+        "svelte-kit": "svelte-kit.js"
+      },
+      "engines": {
+        "node": ">=18.13"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.0.0",
+        "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0 || ^7.0.0",
+        "svelte": "^4.0.0 || ^5.0.0-next.0",
+        "typescript": "^5.3.3 || ^6.0.0",
+        "vite": "^5.0.3 || ^6.0.0 || ^7.0.0-beta.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@sveltejs/load-config": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/@sveltejs/load-config/-/load-config-0.1.1.tgz",
+      "integrity": "sha512-BXXm+VOH/9X4N7Dd1iZ2MqA1h7M+9i2noI8QYuLDY8QcN2WHYn7D/VK/+IJNfcAmRw7ACNJ538UT9GXIhnBTiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18.0.0"
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte": {
+      "version": "6.2.4",
+      "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-6.2.4.tgz",
+      "integrity": "sha512-ou/d51QSdTyN26D7h6dSpusAKaZkAiGM55/AKYi+9AGZw7q85hElbjK3kEyzXHhLSnRISHOYzVge6x0jRZ7DXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0",
+        "deepmerge": "^4.3.1",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.0",
+        "vitefu": "^1.1.1"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte-inspector": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-5.0.2.tgz",
+      "integrity": "sha512-TZzRTcEtZffICSAoZGkPSl6Etsj2torOVrx6Uw0KpXxrec9Gg6jFWQ60Q3+LmNGfZSxHRCZL7vXVZIWmuV50Ig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "obug": "^2.1.0"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "@sveltejs/vite-plugin-svelte": "^6.0.0-next.0",
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@types/cookie": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.6.0.tgz",
+      "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/acorn": {
+      "version": "8.17.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
+      "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.1.tgz",
+      "integrity": "sha512-Z/ZeOgVl7bcSYZ/u/rh0fOpvEpq//LZmdbkXyc7syVzjPAhfOa9ebsdTSjEBDU4vs5nC98Kfduj1uFo0qyET3g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/axobject-query": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
+      "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz",
+      "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/devalue": {
+      "version": "5.8.1",
+      "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.8.1.tgz",
+      "integrity": "sha512-4CXDYRBGqN+57wVJkuXBYmpAVUSg3L6JAQa/DFqm238G73E1wuyc/JhGQJzN7vUf/CMphYau2zXbfWzDR5aTEw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
+      "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.7",
+        "@esbuild/android-arm": "0.27.7",
+        "@esbuild/android-arm64": "0.27.7",
+        "@esbuild/android-x64": "0.27.7",
+        "@esbuild/darwin-arm64": "0.27.7",
+        "@esbuild/darwin-x64": "0.27.7",
+        "@esbuild/freebsd-arm64": "0.27.7",
+        "@esbuild/freebsd-x64": "0.27.7",
+        "@esbuild/linux-arm": "0.27.7",
+        "@esbuild/linux-arm64": "0.27.7",
+        "@esbuild/linux-ia32": "0.27.7",
+        "@esbuild/linux-loong64": "0.27.7",
+        "@esbuild/linux-mips64el": "0.27.7",
+        "@esbuild/linux-ppc64": "0.27.7",
+        "@esbuild/linux-riscv64": "0.27.7",
+        "@esbuild/linux-s390x": "0.27.7",
+        "@esbuild/linux-x64": "0.27.7",
+        "@esbuild/netbsd-arm64": "0.27.7",
+        "@esbuild/netbsd-x64": "0.27.7",
+        "@esbuild/openbsd-arm64": "0.27.7",
+        "@esbuild/openbsd-x64": "0.27.7",
+        "@esbuild/openharmony-arm64": "0.27.7",
+        "@esbuild/sunos-x64": "0.27.7",
+        "@esbuild/win32-arm64": "0.27.7",
+        "@esbuild/win32-ia32": "0.27.7",
+        "@esbuild/win32-x64": "0.27.7"
+      }
+    },
+    "node_modules/esm-env": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
+      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esrap": {
+      "version": "2.2.12",
+      "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.12.tgz",
+      "integrity": "sha512-On0QbLyaiAkVC4eXtgnXK9Kh2opit+3rcUSOc45DqJ2s/X2eXAHsGOKRSJ6IDagQEW5vPyivANfXUiqgXC67Rw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.15"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/types": "^8.2.0"
+      },
+      "peerDependenciesMeta": {
+        "@typescript-eslint/types": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/is-reference": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
+      "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.6"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
+      "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/locate-character": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz",
+      "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/mri": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
+      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.14",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.14.tgz",
+      "integrity": "sha512-U9kYi5bpVMEI31yC8iw4bJJp0avcHXA0W8/wNfLfnvJYzihQo2ZRPYPvpAAd570HAcCBjCTN7vnr+v4StKl1IQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.3.tgz",
+      "integrity": "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
+      "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.2",
+        "@rollup/rollup-android-arm64": "4.62.2",
+        "@rollup/rollup-darwin-arm64": "4.62.2",
+        "@rollup/rollup-darwin-x64": "4.62.2",
+        "@rollup/rollup-freebsd-arm64": "4.62.2",
+        "@rollup/rollup-freebsd-x64": "4.62.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.2",
+        "@rollup/rollup-linux-arm64-musl": "4.62.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.2",
+        "@rollup/rollup-linux-loong64-musl": "4.62.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-musl": "4.62.2",
+        "@rollup/rollup-openbsd-x64": "4.62.2",
+        "@rollup/rollup-openharmony-arm64": "4.62.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.2",
+        "@rollup/rollup-win32-x64-gnu": "4.62.2",
+        "@rollup/rollup-win32-x64-msvc": "4.62.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/sade": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz",
+      "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mri": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/set-cookie-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-3.1.0.tgz",
+      "integrity": "sha512-kjnC1DXBHcxaOaOXBHBeRtltsDG2nUiUni+jP92M9gYdW12rsmx92UsfpH7o5tDRs7I1ZZPSQJQGv3UaRfCiuw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/sirv": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz",
+      "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/svelte": {
+      "version": "5.56.3",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.56.3.tgz",
+      "integrity": "sha512-w7JvrM5IFl5cmfbY0TLik9o7mjRUJmRMhOR51tBPu708Gr/MjbGs7VnJnr/B0CaXeI4vtnOh7RKxDr0cwhMdDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.4",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@sveltejs/acorn-typescript": "^1.0.10",
+        "@types/estree": "^1.0.5",
+        "@types/trusted-types": "^2.0.7",
+        "acorn": "^8.12.1",
+        "aria-query": "5.3.1",
+        "axobject-query": "^4.1.0",
+        "clsx": "^2.1.1",
+        "devalue": "^5.8.1",
+        "esm-env": "^1.2.1",
+        "esrap": "^2.2.11",
+        "is-reference": "^3.0.3",
+        "locate-character": "^3.0.0",
+        "magic-string": "^0.30.11",
+        "zimmerframe": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/svelte-check": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.6.0.tgz",
+      "integrity": "sha512-KhVnDFDSid57mmZtHz8gfW8AAGylOZ0vPnOIzVmAL+urzwK8sBYXRss953gD8T0OdgAQ11mdWhE6uadmtOz8TQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "@sveltejs/load-config": "0.1.1",
+        "chokidar": "^4.0.1",
+        "fdir": "^6.2.0",
+        "picocolors": "^1.0.0",
+        "sade": "^1.7.4"
+      },
+      "bin": {
+        "svelte-check": "bin/svelte-check"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "peerDependencies": {
+        "svelte": "^4.0.0 || ^5.0.0-next.0",
+        "typescript": ">=5.0.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/totalist": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+      "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.5.tgz",
+      "integrity": "sha512-KuOaNhcnGFN2zIPGA7wRmzF+lJA1sea7rHq17aiJ++9lzY1WWG6Jpwqwe1KNbRVPIqHmr8GLYx7jbrQcN/7/ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitefu": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.3.tgz",
+      "integrity": "sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg==",
+      "dev": true,
+      "license": "MIT",
+      "workspaces": [
+        "tests/deps/*",
+        "tests/projects/*",
+        "tests/projects/workspace/packages/*"
+      ],
+      "peerDependencies": {
+        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zimmerframe": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz",
+      "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}
diff --git a/web/workspace/package.json b/web/workspace/package.json
new file mode 100644
index 00000000..1f29694d
--- /dev/null
+++ b/web/workspace/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "@yoi/workspace-web",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-static": "^3.0.9",
+    "@sveltejs/kit": "^2.49.4",
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "svelte": "^5.45.6",
+    "svelte-check": "^4.3.4",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.7"
+  }
+}
diff --git a/web/workspace/src/app.html b/web/workspace/src/app.html
new file mode 100644
index 00000000..adf8bd87
--- /dev/null
+++ b/web/workspace/src/app.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    %sveltekit.head%
+  </head>
+  <body data-sveltekit-preload-data="hover">
+    <div style="display: contents">%sveltekit.body%</div>
+  </body>
+</html>
diff --git a/web/workspace/src/routes/+layout.ts b/web/workspace/src/routes/+layout.ts
new file mode 100644
index 00000000..89da957b
--- /dev/null
+++ b/web/workspace/src/routes/+layout.ts
@@ -0,0 +1,2 @@
+export const ssr = false;
+export const prerender = true;
diff --git a/web/workspace/src/routes/+page.svelte b/web/workspace/src/routes/+page.svelte
new file mode 100644
index 00000000..d905974c
--- /dev/null
+++ b/web/workspace/src/routes/+page.svelte
@@ -0,0 +1,176 @@
+<script lang="ts">
+  type WorkspaceResponse = {
+    workspace_id: string;
+    display_name: string;
+    record_authority: string;
+    extension_points: {
+      event_stream: { status: string; note: string };
+      runner_connection: { status: string; note: string };
+    };
+  };
+
+  const endpoints = [
+    { label: 'Workspace', path: '/api/workspace' },
+    { label: 'Tickets', path: '/api/tickets' },
+    { label: 'Objectives', path: '/api/objectives' },
+    { label: 'Runs', path: '/api/runs' },
+    { label: 'Runners', path: '/api/runners' }
+  ];
+
+  let workspace = $state<WorkspaceResponse | null>(null);
+  let loadError = $state<string | null>(null);
+
+  async function loadWorkspace() {
+    try {
+      const response = await fetch('/api/workspace');
+      if (!response.ok) {
+        throw new Error(`GET /api/workspace failed: ${response.status}`);
+      }
+      workspace = await response.json();
+    } catch (error) {
+      loadError = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  $effect(() => {
+    void loadWorkspace();
+  });
+</script>
+
+<svelte:head>
+  <title>Yoi Workspace Control Plane</title>
+  <meta
+    name="description"
+    content="Local single-workspace Yoi control plane bootstrap"
+  />
+</svelte:head>
+
+<main class="shell">
+  <section class="hero">
+    <p class="eyebrow">Local / single-workspace bootstrap</p>
+    <h1>Yoi Workspace Control Plane</h1>
+    <p>
+      Static SPA shell for reading canonical <code>.yoi</code> project records
+      through bounded backend APIs. Ticket and Objective lifecycle authority stays
+      in the existing local record workflow.
+    </p>
+  </section>
+
+  <section class="card">
+    <h2>Workspace</h2>
+    {#if workspace}
+      <dl>
+        <div>
+          <dt>ID</dt>
+          <dd>{workspace.workspace_id}</dd>
+        </div>
+        <div>
+          <dt>Name</dt>
+          <dd>{workspace.display_name}</dd>
+        </div>
+        <div>
+          <dt>Record authority</dt>
+          <dd>{workspace.record_authority}</dd>
+        </div>
+      </dl>
+    {:else if loadError}
+      <p class="error">{loadError}</p>
+    {:else}
+      <p>Waiting for <code>/api/workspace</code>…</p>
+    {/if}
+  </section>
+
+  <section class="grid">
+    <div class="card">
+      <h2>Read API surface</h2>
+      <ul>
+        {#each endpoints as endpoint}
+          <li><code>{endpoint.path}</code> — {endpoint.label}</li>
+        {/each}
+      </ul>
+    </div>
+
+    <div class="card">
+      <h2>Reserved seams</h2>
+      <p>
+        Event streams and runner connections are represented as extension-point
+        state in the backend response, but no scheduler, write API, or hosted
+        multi-tenant behavior is implemented in this slice.
+      </p>
+    </div>
+  </section>
+</main>
+
+<style>
+  :global(body) {
+    margin: 0;
+    background: #0f172a;
+    color: #e2e8f0;
+    font-family:
+      Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  }
+
+  .shell {
+    width: min(980px, calc(100vw - 32px));
+    margin: 0 auto;
+    padding: 48px 0;
+  }
+
+  .hero {
+    margin-bottom: 24px;
+  }
+
+  .eyebrow {
+    color: #38bdf8;
+    font-weight: 700;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+  }
+
+  h1 {
+    margin: 0 0 16px;
+    font-size: clamp(2.5rem, 8vw, 5rem);
+    line-height: 0.95;
+  }
+
+  h2 {
+    margin-top: 0;
+  }
+
+  code {
+    color: #bae6fd;
+  }
+
+  .grid {
+    display: grid;
+    gap: 16px;
+    grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+  }
+
+  .card {
+    border: 1px solid rgba(148, 163, 184, 0.25);
+    border-radius: 20px;
+    background: rgba(15, 23, 42, 0.75);
+    padding: 24px;
+    box-shadow: 0 24px 80px rgba(15, 23, 42, 0.35);
+  }
+
+  dl {
+    display: grid;
+    gap: 12px;
+  }
+
+  dt {
+    color: #94a3b8;
+    font-size: 0.85rem;
+    text-transform: uppercase;
+  }
+
+  dd {
+    margin: 0;
+  }
+
+  .error {
+    color: #fca5a5;
+  }
+</style>
diff --git a/web/workspace/svelte.config.js b/web/workspace/svelte.config.js
new file mode 100644
index 00000000..cb64985a
--- /dev/null
+++ b/web/workspace/svelte.config.js
@@ -0,0 +1,18 @@
+import adapter from '@sveltejs/adapter-static';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+  preprocess: vitePreprocess(),
+  kit: {
+    adapter: adapter({
+      pages: 'build',
+      assets: 'build',
+      fallback: 'index.html',
+      precompress: false,
+      strict: true
+    })
+  }
+};
+
+export default config;
diff --git a/web/workspace/tsconfig.json b/web/workspace/tsconfig.json
new file mode 100644
index 00000000..43447105
--- /dev/null
+++ b/web/workspace/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "moduleResolution": "bundler"
+  }
+}
diff --git a/web/workspace/vite.config.ts b/web/workspace/vite.config.ts
new file mode 100644
index 00000000..3406f32d
--- /dev/null
+++ b/web/workspace/vite.config.ts
@@ -0,0 +1,6 @@
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [sveltekit()]
+});