@rynx-ai/server 0.1.0 → 0.1.9

package/dist/control-api.js

@@ -16,25 +16,1507 @@
  * via the CLI, not here. The daemon owns the db-backed mutators (injected as
  * {@link ControlPlaneDeps}); the server owns the {@link ChannelManager}.
  */
-import { randomUUID } from "node:crypto";
+import { timingSafeEqual } from "node:crypto";
 import Router from "@koa/router";
-import { agentSpecSchema, newSessionId, persistSessionEvent, skillInstallRecipeSchema, } from "@rynx-ai/core";
+import { agentSpecSchema, newSessionId, skillInstallRecipeSchema, } from "@rynx-ai/core";
+import { DIRECT_RUNTIME_CONTROL_PATH, encodePairingCode, } from "@rynx-ai/protocol/direct-runtime";
+import { parseDaemonStatus } from "@rynx-ai/protocol/remote-runtime";
+import { materializeRemoteRuntimeSessionEvent, materializeRemoteRuntimeSessionRuntimeSnapshot, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { RUNTIME_BROWSER_BOOTSTRAP_PATH, RUNTIME_BROWSER_CAPABILITY_HEADER, RUNTIME_BROWSER_MANAGEMENT_PATH_PREFIX, RUNTIME_BROWSER_RPC_PATH, RUNTIME_BROWSER_SESSION_ID_HEADER, parseRuntimeBrowserBootstrapCredential, } from "@rynx-ai/protocol/runtime-browser-bootstrap";
+import { parseRuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
 import { ensureCodexResumeRollout } from "@rynx-ai/runtime";
+import { encodeDaemonStatus } from "./remote-runtime.js";
+import { SessionRuntimeIndex } from "./session-runtime-index.js";
+import { authorizeRuntimeWebRequest, RUNTIME_WEB_CAPABILITY, RUNTIME_WEB_CAPABILITY_HEADER, } from "./runtime-web-auth.js";
+const PLUGIN_CLI_BODY_MAX_BYTES = 512 * 1024;
+const PLUGIN_CLI_STDIN_MAX_BYTES = 256 * 1024;
+const PLUGIN_CLI_ARG_MAX_BYTES = 4 * 1024;
+const PLUGIN_CLI_ARGS_TOTAL_MAX_BYTES = 32 * 1024;
+const PLUGIN_CLI_ARGS_MAX_COUNT = 64;
+const PLUGIN_CLI_ERROR_MAX_BYTES = 16 * 1024;
+const PLUGIN_CLI_TIMEOUT_MS = 120_000;
+const REMOTE_RUNTIME_ADMIN_BODY_MAX_BYTES = 4 * 1024;
+const RUNTIME_TARGET_PAIR_BODY_MAX_BYTES = 64 * 1024;
+const REMOTE_RUNTIME_EMULATOR_CONTROL_TIMEOUT_MS = 30_000;
+const REMOTE_RUNTIME_EMULATOR_ATTACH_TIMEOUT_MS = 120_000;
+const REMOTE_RUNTIME_BROWSER_CONTROL_TIMEOUT_MS = 30_000;
+const REMOTE_RUNTIME_BROWSER_OPEN_TIMEOUT_MS = 120_000;
+const REMOTE_RUNTIME_SESSION_TIMEOUT_MS = 30_000;
+const REMOTE_RUNTIME_SESSION_BFF_MAX_PAGES = 128;
+const REMOTE_RUNTIME_SESSION_BFF_MAX_SESSIONS = 20_000;
+const REMOTE_RUNTIME_SESSION_BFF_MAX_ITEMS = 20_000;
+const REMOTE_RUNTIME_SESSION_BFF_MAX_SNAPSHOT_BYTES = 32 * 1024 * 1024;
+const RUNTIME_TARGET_SELECTOR_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/;
+// A resolved interaction is duplicated in the canonical event and its durable
+// item. Keep the accepted body comfortably below the 512 KiB plugin event cap.
+const SESSION_INTERACTION_RESOLUTION_MAX_BYTES = 128 * 1024;
+const RUNTIME_BROWSER_RPC_METHODS = new Set([
+    "browser.state.get",
+    "browser.open",
+    "browser.close",
+    "browser.page.create",
+    "browser.page.close",
+    "browser.page.activate",
+    "browser.page.navigate",
+    "browser.page.back",
+    "browser.page.forward",
+    "browser.page.reload",
+]);
 export function createControlRouter(opts) {
-    const { manager, deps, runtime, sessionBus, sessionLog, runnerManager, sessionStore } = opts;
+    const { manager, deps, runtime, sessionBus, sessionLog, runnerManager, sessionStore, pluginRuntimeStatus, pluginRuntimeReload, pluginRuntimeEnsure, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, sessionEmulators, shutdownSignal, sessionRuntimeIndex = new SessionRuntimeIndex(), sessionLifecycle, runtimeLocalBrowser, providerClis, } = opts;
     const router = new Router();
-    // claude-native PermissionRequest long-polls: approvalId → resolve the held
-    // hook response with claude's verdict. The hook POST blocks until the web user
-    // answers via `/approvals/:approvalId`, or the hook client disconnects.
-    const claudeApprovals = new Map();
     /** The instance (if any) bound to a channel — used to reload after a config change. */
     const instanceForChannel = (channelId) => deps.listInstancesConfig().find((i) => i.channelId === channelId);
+    const listRuntimeTargets = async (ctx) => {
+        if (!runtimeTargetControl)
+            return notFound(ctx, "Runtime target control is not configured");
+        try {
+            const targets = await runtimeTargetControl.list();
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = { runtimes: targets.map(redactRuntimeTargetView) };
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+    };
+    const pairRuntimeTarget = async (ctx) => {
+        if (!runtimeTargetControl)
+            return notFound(ctx, "Runtime target control is not configured");
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "unsupported_media_type" };
+            return;
+        }
+        let body;
+        try {
+            body = await readBoundedJson(ctx, RUNTIME_TARGET_PAIR_BODY_MAX_BYTES);
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: "request_too_large" };
+            }
+            else {
+                ctx.status = 400;
+                ctx.body = { error: "invalid_offer" };
+            }
+            return;
+        }
+        if (!Object.hasOwn(body, "offer") ||
+            Object.keys(body).some((key) => key !== "offer" && key !== "displayName")) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_offer" };
+            return;
+        }
+        const displayName = body.displayName;
+        if (displayName !== undefined && !isRuntimeDisplayName(displayName)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
+        try {
+            const result = await runtimeTargetControl.pair({
+                offer: body.offer,
+                ...(displayName === undefined ? {} : { displayName }),
+            });
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = redactRuntimeTargetPairResult(result);
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+    };
+    const testRuntimeTarget = async (ctx) => {
+        if (!runtimeTargetControl)
+            return notFound(ctx, "Runtime target control is not configured");
+        const selector = ctx.params.selector;
+        if (!isRuntimeTargetSelector(selector)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
+        try {
+            const result = await runtimeTargetControl.test(selector);
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = redactRuntimeTargetTestResult(result, selector);
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+    };
+    const forgetRuntimeTarget = async (ctx) => {
+        if (!runtimeTargetControl)
+            return notFound(ctx, "Runtime target control is not configured");
+        const daemonId = ctx.params.daemonId;
+        if (!isRuntimeTargetSelector(daemonId)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
+        try {
+            ctx.set("Cache-Control", "no-store");
+            const result = await runtimeTargetControl.forget(daemonId);
+            if (result.forgotten !== true)
+                throw new Error("Runtime target host returned an invalid result");
+            ctx.body = { forgotten: true };
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+    };
+    const createRuntimePairingOffer = async (ctx, response) => {
+        ctx.set("Cache-Control", "no-store");
+        if (!remoteRuntimeAdmin) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "pairing offer creation requires application/json" };
+            return;
+        }
+        try {
+            const body = await readBoundedJson(ctx, REMOTE_RUNTIME_ADMIN_BODY_MAX_BYTES);
+            if (Object.keys(body).some((key) => key !== "clientLabel" && key !== "address")) {
+                throw new Error("pairing offer request contains unknown fields");
+            }
+            const clientLabel = optionalBoundedLabel(body.clientLabel);
+            const address = optionalAdvertiseAddress(body.address);
+            const offer = remoteRuntimeAdmin.createPairingOffer({
+                ...(clientLabel ? { clientLabel } : {}),
+                ...(address ? { address } : {}),
+            });
+            ctx.body = response === "offer"
+                ? offer
+                : { pairingCode: encodePairingCode(offer) };
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+            }
+            else {
+                ctx.status = 409;
+            }
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const listRuntimeShareAddresses = (ctx) => {
+        ctx.set("Cache-Control", "no-store");
+        if (!remoteRuntimeAdmin) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        try {
+            ctx.body = { addresses: remoteRuntimeAdmin.listShareAddresses() };
+        }
+        catch (error) {
+            ctx.status = 500;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const listRuntimeAccess = (ctx) => {
+        ctx.set("Cache-Control", "no-store");
+        if (!remoteRuntimeAdmin) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        try {
+            ctx.body = { clients: remoteRuntimeAdmin.listClientGrants() };
+        }
+        catch (error) {
+            ctx.status = 500;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const revokeRuntimeAccess = (ctx) => {
+        ctx.set("Cache-Control", "no-store");
+        if (!remoteRuntimeAdmin) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/.test(ctx.params.grantId)) {
+            return bad(ctx, "invalid Remote Runtime grant id");
+        }
+        try {
+            const result = remoteRuntimeAdmin.revokeClientGrant(ctx.params.grantId);
+            if (!result.revoked) {
+                return notFound(ctx, "Remote Runtime client grant not found or already revoked");
+            }
+            ctx.body = result;
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const authorizePublicRuntimeTargetRequest = (ctx, options = {}) => {
+        ctx.set("Cache-Control", "no-store");
+        const failure = authorizeRuntimeWebRequest(ctx.req, {
+            mutation: options.mutation,
+            capability: ctx.get(RUNTIME_WEB_CAPABILITY_HEADER),
+        });
+        if (!failure)
+            return true;
+        ctx.status = failure.status;
+        ctx.body = { error: failure.error };
+        return false;
+    };
+    const authorizeInternalRuntimeTargetRequest = (ctx) => {
+        if (!runtimeTargetControl || !isConfiguredDaemonManagement(daemonManagement)) {
+            notFound(ctx, "Runtime target control is not configured");
+            return false;
+        }
+        return authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken);
+    };
+    router.get("/api/runtimes/capability", (ctx) => {
+        if (!authorizePublicRuntimeTargetRequest(ctx))
+            return;
+        if (!runtimeTargetControl)
+            return notFound(ctx, "Runtime target control is not configured");
+        ctx.set("Cross-Origin-Resource-Policy", "same-origin");
+        ctx.body = { capability: RUNTIME_WEB_CAPABILITY };
+    });
+    router.get("/api/runtimes", async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx))
+            await listRuntimeTargets(ctx);
+    });
+    router.post("/api/runtimes/pair", async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true }))
+            await pairRuntimeTarget(ctx);
+    });
+    router.post("/api/runtimes/:selector/test", async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true }))
+            await testRuntimeTarget(ctx);
+    });
+    router.delete("/api/runtimes/:daemonId", async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true }))
+            await forgetRuntimeTarget(ctx);
+    });
+    router.get("/api/runtime-server/share-addresses", (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx))
+            listRuntimeShareAddresses(ctx);
+    });
+    router.post("/api/runtime-server/share", async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true })) {
+            await createRuntimePairingOffer(ctx, "pairing_code");
+        }
+    });
+    router.get("/api/runtime-server/access", (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx))
+            listRuntimeAccess(ctx);
+    });
+    router.delete("/api/runtime-server/access/:grantId", (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true })) {
+            revokeRuntimeAccess(ctx);
+        }
+    });
+    router.get("/api/internal/runtimes", async (ctx) => {
+        if (authorizeInternalRuntimeTargetRequest(ctx))
+            await listRuntimeTargets(ctx);
+    });
+    router.post("/api/internal/runtimes/pair", async (ctx) => {
+        if (authorizeInternalRuntimeTargetRequest(ctx))
+            await pairRuntimeTarget(ctx);
+    });
+    router.post("/api/internal/runtimes/:selector/test", async (ctx) => {
+        if (authorizeInternalRuntimeTargetRequest(ctx))
+            await testRuntimeTarget(ctx);
+    });
+    router.delete("/api/internal/runtimes/:daemonId", async (ctx) => {
+        if (authorizeInternalRuntimeTargetRequest(ctx))
+            await forgetRuntimeTarget(ctx);
+    });
+    const emulatorSessionOf = (ctx) => ctx.get("x-rynx-session")?.trim() || undefined;
+    // ── Runtime-scoped emulator unary control ───────────────────────────────
+    // Media, screenshots, low-latency touch, and raw exec deliberately remain on
+    // the local-only /api/emulator surface until their stream/security contracts
+    // exist. Every route below carries an explicit selector and never falls back.
+    const authorizeInternalRuntimeCall = (ctx) => {
+        if (!runtimeConnectionResolver || !isConfiguredDaemonManagement(daemonManagement)) {
+            notFound(ctx, "Runtime connection resolver is not configured");
+            return false;
+        }
+        return authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken);
+    };
+    const runtimeCall = async (ctx, method, params) => {
+        if (!runtimeConnectionResolver) {
+            notFound(ctx, "Runtime connection resolver is not configured");
+            return { ok: false };
+        }
+        const selector = ctx.params.selector;
+        if (!isRuntimeTargetSelector(selector)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return { ok: false };
+        }
+        let validatedParams;
+        try {
+            validatedParams = parseRemoteRuntimeRpcRequest({
+                type: "rpc.request",
+                id: "control-plane-bff",
+                method,
+                params,
+            }).params;
+        }
+        catch {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return { ok: false };
+        }
+        let lease;
+        try {
+            lease = await runtimeConnectionResolver.acquire(selector);
+            if (lease.target.selector !== selector ||
+                !isRuntimeTargetSelector(lease.target.daemonId)) {
+                throw new Error("Runtime resolver returned a mismatched target");
+            }
+        }
+        catch (error) {
+            lease?.release();
+            runtimeTargetHostError(ctx, error, "not_started");
+            return { ok: false };
+        }
+        if (!lease) {
+            runtimeTargetHostError(ctx, new Error("Runtime resolver did not return a lease"), "not_started");
+            return { ok: false };
+        }
+        try {
+            const result = await lease.call(method, validatedParams, {
+                timeoutMs: remoteRuntimeRpcTimeoutMs(method, validatedParams),
+            });
+            ctx.set("Cache-Control", "no-store");
+            return { ok: true, result };
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+            return { ok: false };
+        }
+        finally {
+            lease.release();
+        }
+    };
+    /**
+     * Management-only typed Runtime gateway for short-lived local clients.
+     * Target resolution, protocol validation, timeout policy, lease ownership,
+     * and no-fallback behavior remain centralized in runtimeCall.
+     */
+    const internalRuntimeRpc = async (ctx) => {
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "unsupported_media_type" };
+            return;
+        }
+        let body;
+        try {
+            body = await readBoundedJson(ctx, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES);
+        }
+        catch (error) {
+            ctx.status = error instanceof RequestBodyTooLargeError ? 413 : 400;
+            ctx.body = {
+                error: error instanceof RequestBodyTooLargeError ? "request_too_large" : "invalid_request",
+            };
+            return;
+        }
+        if (!Object.hasOwn(body, "method") ||
+            !Object.hasOwn(body, "params") ||
+            Object.keys(body).some((key) => key !== "method" && key !== "params")) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        }
+        let request;
+        try {
+            request = parseRemoteRuntimeRpcRequest({
+                type: "rpc.request",
+                id: "control-plane-bff",
+                method: body.method,
+                params: body.params,
+            });
+        }
+        catch {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        }
+        const outcome = await runtimeCall(ctx, request.method, request.params);
+        if (outcome.ok)
+            ctx.body = { result: outcome.result };
+    };
+    const acquireRuntimeLease = async (ctx, signal) => {
+        if (!runtimeConnectionResolver) {
+            notFound(ctx, "Runtime connection resolver is not configured");
+            return undefined;
+        }
+        const selector = ctx.params.selector;
+        if (!isRuntimeTargetSelector(selector)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return undefined;
+        }
+        try {
+            const lease = signal === undefined
+                ? await runtimeConnectionResolver.acquire(selector)
+                : await runtimeConnectionResolver.acquire(selector, { signal });
+            if (lease.target.selector !== selector || !isRuntimeTargetSelector(lease.target.daemonId)) {
+                lease.release();
+                throw runtimeProtocolError("Runtime resolver returned a mismatched target");
+            }
+            return lease;
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error, "not_started");
+            return undefined;
+        }
+    };
+    const runtimeSessions = async (ctx) => {
+        const lease = await acquireRuntimeLease(ctx);
+        if (!lease)
+            return;
+        const sessions = [];
+        const ids = new Set();
+        const cursors = new Set();
+        let cursor;
+        try {
+            for (let pageIndex = 0; pageIndex < REMOTE_RUNTIME_SESSION_BFF_MAX_PAGES; pageIndex += 1) {
+                const page = await lease.call("session.list", {
+                    ...(cursor === undefined ? {} : { cursor }),
+                    limit: REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE,
+                }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS });
+                for (const session of page.sessions) {
+                    if (ids.has(session.id)) {
+                        throw runtimeProtocolError("Runtime Session list repeated a session");
+                    }
+                    ids.add(session.id);
+                    sessions.push(session);
+                    if (sessions.length > REMOTE_RUNTIME_SESSION_BFF_MAX_SESSIONS) {
+                        throw runtimeCapacityError("Runtime Session list exceeds the Control Plane bound");
+                    }
+                }
+                if (!page.hasMore) {
+                    ctx.set("Cache-Control", "no-store");
+                    ctx.body = { sessions };
+                    return;
+                }
+                const nextCursor = page.nextCursor;
+                if (!nextCursor || cursors.has(nextCursor)) {
+                    throw runtimeProtocolError("Runtime Session list cursor did not advance");
+                }
+                cursors.add(nextCursor);
+                cursor = nextCursor;
+            }
+            throw runtimeCapacityError("Runtime Session list exceeds the page bound");
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+        finally {
+            lease.release();
+        }
+    };
+    const runtimeSessionSnapshot = async (ctx) => {
+        const lease = await acquireRuntimeLease(ctx);
+        if (!lease)
+            return;
+        const sessionId = ctx.params.id;
+        const items = [];
+        const ids = new Set();
+        let afterId;
+        let bytes = 0;
+        let runtime;
+        try {
+            for (let pageIndex = 0; pageIndex < REMOTE_RUNTIME_SESSION_BFF_MAX_PAGES; pageIndex += 1) {
+                const page = await lease.call("session.snapshot.get", {
+                    sessionId,
+                    ...(afterId === undefined ? {} : { afterId }),
+                    limit: REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE,
+                }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS });
+                if (page.sessionId !== sessionId) {
+                    throw runtimeProtocolError("Runtime Session snapshot identity changed");
+                }
+                runtime = page.runtime;
+                for (const item of page.items) {
+                    if (ids.has(item.id)) {
+                        throw runtimeProtocolError("Runtime Session snapshot repeated an item");
+                    }
+                    ids.add(item.id);
+                    items.push(item);
+                    bytes += Buffer.byteLength(JSON.stringify(item), "utf8");
+                    if (items.length > REMOTE_RUNTIME_SESSION_BFF_MAX_ITEMS ||
+                        bytes > REMOTE_RUNTIME_SESSION_BFF_MAX_SNAPSHOT_BYTES) {
+                        throw runtimeCapacityError("Runtime Session snapshot exceeds the Control Plane bound");
+                    }
+                }
+                if (!page.hasMore) {
+                    if (!runtime)
+                        throw runtimeProtocolError("Runtime Session snapshot omitted runtime state");
+                    ctx.set("Cache-Control", "no-store");
+                    ctx.body = {
+                        sessionId,
+                        items,
+                        runtime: materializeRemoteRuntimeSessionRuntimeSnapshot(runtime, items),
+                    };
+                    return;
+                }
+                if (!page.nextAfterId || page.nextAfterId === afterId) {
+                    throw runtimeProtocolError("Runtime Session snapshot cursor did not advance");
+                }
+                afterId = page.nextAfterId;
+            }
+            throw runtimeCapacityError("Runtime Session snapshot exceeds the page bound");
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+        finally {
+            lease.release();
+        }
+    };
+    const runtimeSessionInterrupt = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.interrupt", { sessionId: ctx.params.id });
+        if (outcome.ok)
+            ctx.body = { ok: true, interrupted: outcome.result.interrupted };
+    };
+    const runtimeSessionAgentOptions = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.agentOptions.list", {});
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionLaunchOptions = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.launchOptions.list", {});
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionCreate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        const outcome = await runtimeCall(ctx, "session.create", body);
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionMessage = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["message"]))
+            return;
+        const outcome = await runtimeCall(ctx, "session.message.send", {
+            sessionId: ctx.params.id,
+            message: body.message,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionTerminalStart = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.terminal.start", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionDelete = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.delete", { sessionId: ctx.params.id });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionResolveInteraction = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["resolution"]))
+            return;
+        const outcome = await runtimeCall(ctx, "session.interaction.resolve", {
+            sessionId: ctx.params.id,
+            interactionId: ctx.params.interactionId,
+            resolution: body.resolution,
+        });
+        if (!outcome.ok)
+            return;
+        const result = outcome.result;
+        if (result.disposition === "invalid") {
+            return bad(ctx, "interaction resolution is invalid");
+        }
+        if (result.disposition === "not_found") {
+            return notFound(ctx, "interaction is not pending");
+        }
+        if (result.disposition === "already_resolved") {
+            ctx.status = 409;
+            ctx.body = { error: "interaction was already resolved", ...result };
+            return;
+        }
+        ctx.body = result;
+    };
+    const runtimeBrowserState = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "browser.state.get", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeBrowserOpen = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["url"]))
+            return;
+        const outcome = await runtimeCall(ctx, "browser.open", {
+            sessionId: ctx.params.id,
+            ...(body.url === undefined ? {} : { url: body.url }),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeBrowserClose = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["browserGeneration"]))
+            return;
+        const outcome = await runtimeCall(ctx, "browser.close", {
+            sessionId: ctx.params.id,
+            browserGeneration: body.browserGeneration,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeBrowserPageCreate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["browserGeneration", "url"]))
+            return;
+        const outcome = await runtimeCall(ctx, "browser.page.create", {
+            sessionId: ctx.params.id,
+            browserGeneration: body.browserGeneration,
+            ...(body.url === undefined ? {} : { url: body.url }),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeBrowserPageMutation = async (ctx, method) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["browserGeneration"]))
+            return;
+        const params = {
+            sessionId: ctx.params.id,
+            browserGeneration: body.browserGeneration,
+            pageId: ctx.params.pageId,
+        };
+        const outcome = await runtimeCall(ctx, method, params);
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeBrowserPageNavigate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["browserGeneration", "url"]))
+            return;
+        const outcome = await runtimeCall(ctx, "browser.page.navigate", {
+            sessionId: ctx.params.id,
+            browserGeneration: body.browserGeneration,
+            pageId: ctx.params.pageId,
+            url: body.url,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const streamRuntimeSession = async (ctx, selector, sessionId) => {
+        if (!runtimeConnectionResolver) {
+            return notFound(ctx, "Runtime connection resolver is not configured");
+        }
+        if (!isRuntimeTargetSelector(selector)) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
+        await streamEvents(ctx, async (send, signal) => {
+            let lease;
+            let subscription;
+            try {
+                lease = await runtimeConnectionResolver.acquire(selector, { signal });
+                if (lease.target.selector !== selector || !isRuntimeTargetSelector(lease.target.daemonId)) {
+                    throw runtimeProtocolError("Runtime resolver returned a mismatched target");
+                }
+                subscription = await lease.subscribeSessionEvents(sessionId, {
+                    signal,
+                    timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS,
+                });
+                if (subscription.sessionId !== sessionId) {
+                    throw runtimeProtocolError("Runtime Session subscription identity changed");
+                }
+                if (!send("ready", { sessionId, daemonInstanceId: subscription.daemonInstanceId })) {
+                    if (!(await waitForSseDrain(ctx, signal)))
+                        return;
+                }
+                const iterator = subscription[Symbol.asyncIterator]();
+                const disconnected = abortAsNull(signal);
+                for (;;) {
+                    const next = await Promise.race([iterator.next(), disconnected]);
+                    if (next === null || next.done)
+                        return;
+                    const event = materializeRemoteRuntimeSessionEvent(next.value);
+                    if (!send("event", event) && !(await waitForSseDrain(ctx, signal)))
+                        return;
+                }
+            }
+            catch (error) {
+                if (!signal.aborted) {
+                    send("error", { message: publicRuntimeStreamError(error) });
+                }
+            }
+            finally {
+                await subscription?.close().catch(() => undefined);
+                lease?.release();
+            }
+        }, shutdownSignal);
+    };
+    const runtimeSessionStream = async (ctx) => streamRuntimeSession(ctx, ctx.params.selector, ctx.params.id);
+    const readRuntimeBody = async (ctx) => {
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "unsupported_media_type" };
+            return undefined;
+        }
+        try {
+            return await readBoundedJson(ctx, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES);
+        }
+        catch (error) {
+            ctx.status = error instanceof RequestBodyTooLargeError ? 413 : 400;
+            ctx.body = {
+                error: error instanceof RequestBodyTooLargeError ? "request_too_large" : "invalid_request",
+            };
+            return undefined;
+        }
+    };
+    const acceptRuntimeBodyKeys = (ctx, body, allowed) => {
+        const allowedSet = new Set(allowed);
+        if (Object.keys(body).every((key) => allowedSet.has(key)))
+            return true;
+        ctx.status = 400;
+        ctx.body = { error: "invalid_request" };
+        return false;
+    };
+    const runtimeScopedDevice = (_ctx, body) => optionalRuntimeDevice(body);
+    const runtimeDevices = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "emulator.devices.list", {});
+        if (outcome.ok)
+            ctx.body = { devices: outcome.result };
+    };
+    const runtimeActiveEmulator = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "emulator.active.get", runtimeScopedDevice(ctx, {}));
+        if (outcome.ok)
+            ctx.body = { active: outcome.result };
+    };
+    const runtimeAttachEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["device"]))
+            return;
+        const outcome = await runtimeCall(ctx, "emulator.attach", optionalRuntimeDevice(body));
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeTapEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["x", "y", "device"]))
+            return;
+        const x = asNumber(body.x);
+        const y = asNumber(body.y);
+        if (x == null || y == null)
+            return bad(ctx, "tap requires numeric x and y");
+        const outcome = await runtimeCall(ctx, "emulator.tap", {
+            x,
+            y,
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeTypeEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["text", "mode", "device"]))
+            return;
+        if (typeof body.text !== "string" || body.text.length === 0) {
+            return bad(ctx, "type requires text");
+        }
+        const mode = body.mode;
+        if (mode !== undefined && mode !== "paste" && mode !== "keys") {
+            return bad(ctx, "type mode must be paste or keys");
+        }
+        const outcome = await runtimeCall(ctx, "emulator.type", {
+            text: body.text,
+            ...(mode === undefined ? {} : { mode }),
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeButtonEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["name", "device"]))
+            return;
+        const name = body.name;
+        const outcome = await runtimeCall(ctx, "emulator.button", {
+            ...(name === undefined ? {} : { name: name }),
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeRotateEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["orientation", "device"]))
+            return;
+        const orientation = optionalRuntimeString(body.orientation);
+        if (!orientation)
+            return bad(ctx, "rotate requires orientation");
+        const outcome = await runtimeCall(ctx, "emulator.rotate", {
+            orientation,
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeLaunchEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["appId", "device"]))
+            return;
+        const appId = optionalRuntimeString(body.appId);
+        if (!appId)
+            return bad(ctx, "launch requires appId");
+        const outcome = await runtimeCall(ctx, "emulator.launch", {
+            appId,
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeGestureEmulator = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["points", "device"]))
+            return;
+        if (!Array.isArray(body.points))
+            return bad(ctx, "gesture requires points");
+        const outcome = await runtimeCall(ctx, "emulator.gesture", {
+            points: body.points,
+            ...runtimeScopedDevice(ctx, body),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeDeviceCommand = async (ctx, method) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["device"]))
+            return;
+        const params = runtimeScopedDevice(ctx, body);
+        const outcome = method === "emulator.kill"
+            ? await runtimeCall(ctx, "emulator.kill", params)
+            : await runtimeCall(ctx, "emulator.shutdown", params);
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorState = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.emulator.state.get", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = { binding: outcome.result };
+    };
+    const runtimeSessionEmulatorDevices = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.emulator.devices.list", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = { devices: outcome.result };
+    };
+    const runtimeSessionEmulatorAttach = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["device"]))
+            return;
+        const device = optionalRuntimeString(body.device);
+        if (!device)
+            return bad(ctx, "attach requires device");
+        const outcome = await runtimeCall(ctx, "session.emulator.attach", {
+            sessionId: ctx.params.id,
+            device,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorDetach = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        if (!bindingId)
+            return bad(ctx, "detach requires bindingId");
+        const outcome = await runtimeCall(ctx, "session.emulator.detach", {
+            sessionId: ctx.params.id,
+            bindingId,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorTap = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "x", "y"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        const x = asNumber(body.x);
+        const y = asNumber(body.y);
+        if (!bindingId || x == null || y == null)
+            return bad(ctx, "tap requires bindingId, x, and y");
+        const outcome = await runtimeCall(ctx, "session.emulator.tap", {
+            sessionId: ctx.params.id,
+            bindingId,
+            x,
+            y,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorButton = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "name"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        if (!bindingId)
+            return bad(ctx, "button requires bindingId");
+        const name = optionalRuntimeString(body.name);
+        const outcome = await runtimeCall(ctx, "session.emulator.button", {
+            sessionId: ctx.params.id,
+            bindingId,
+            ...(name ? { name } : {}),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorType = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "text", "mode"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        const text = typeof body.text === "string" ? body.text : undefined;
+        const mode = body.mode;
+        if (!bindingId || !text)
+            return bad(ctx, "type requires bindingId and text");
+        if (mode !== undefined && mode !== "paste" && mode !== "keys") {
+            return bad(ctx, "type mode must be paste or keys");
+        }
+        const outcome = await runtimeCall(ctx, "session.emulator.type", {
+            sessionId: ctx.params.id,
+            bindingId,
+            text,
+            ...(mode === undefined ? {} : { mode }),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorRotate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "orientation"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        const orientation = optionalRuntimeString(body.orientation);
+        if (!bindingId || !orientation)
+            return bad(ctx, "rotate requires bindingId and orientation");
+        const outcome = await runtimeCall(ctx, "session.emulator.rotate", {
+            sessionId: ctx.params.id,
+            bindingId,
+            orientation,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorLaunch = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "appId"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        const appId = optionalRuntimeString(body.appId);
+        if (!bindingId || !appId)
+            return bad(ctx, "launch requires bindingId and appId");
+        const outcome = await runtimeCall(ctx, "session.emulator.launch", {
+            sessionId: ctx.params.id,
+            bindingId,
+            appId,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorGesture = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["bindingId", "points"]))
+            return;
+        const bindingId = optionalRuntimeString(body.bindingId);
+        if (!bindingId || !Array.isArray(body.points)) {
+            return bad(ctx, "gesture requires bindingId and points");
+        }
+        const outcome = await runtimeCall(ctx, "session.emulator.gesture", {
+            sessionId: ctx.params.id,
+            bindingId,
+            points: body.points,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionEmulatorFrame = async (ctx) => {
+        if (ctx.params.selector !== "local") {
+            ctx.status = 426;
+            ctx.body = { error: "emulator_surface_upgrade_required" };
+            return;
+        }
+        if (!sessionEmulators)
+            return notFound(ctx, "Session Emulator service is unavailable");
+        const bindingId = optionalRuntimeString(ctx.query.bindingId);
+        if (!bindingId)
+            return bad(ctx, "frame requires bindingId");
+        try {
+            const frame = await sessionEmulators.frame({
+                sessionId: ctx.params.id,
+                bindingId,
+            });
+            ctx.type = frame.contentType;
+            ctx.set("Cache-Control", "no-store");
+            ctx.set("X-Content-Type-Options", "nosniff");
+            ctx.body = frame.data;
+        }
+        catch (error) {
+            bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+    };
+    const runtimeProviderCliStatuses = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "provider.cli.status.list", {});
+        if (!outcome.ok)
+            return;
+        ctx.body = {
+            ...outcome.result,
+            management: ctx.params.selector === "local" ? "read_write" : "read_only",
+        };
+    };
+    const runtimeProviderCliOperation = async (ctx) => {
+        if (ctx.params.selector !== "local") {
+            ctx.status = 403;
+            ctx.body = { error: "remote_provider_cli_management_disabled" };
+            return;
+        }
+        if (!providerClis)
+            return notFound(ctx, "Provider CLI management is unavailable");
+        const provider = parseProviderCliId(ctx.params.provider);
+        const operation = parseProviderCliOperation(ctx.params.operation);
+        if (!provider || !operation)
+            return bad(ctx, "invalid Provider CLI operation");
+        try {
+            const job = await providerClis.startOperation(provider, operation);
+            ctx.status = 202;
+            ctx.body = { job };
+        }
+        catch (error) {
+            ctx.status = providerCliOperationErrorCode(error) === "failed_precondition" ? 409 : 500;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const runtimeProviderCliJob = async (ctx) => {
+        if (ctx.params.selector !== "local") {
+            ctx.status = 403;
+            ctx.body = { error: "remote_provider_cli_management_disabled" };
+            return;
+        }
+        if (!providerClis)
+            return notFound(ctx, "Provider CLI management is unavailable");
+        const job = providerClis.getJob(ctx.params.jobId);
+        if (!job)
+            return notFound(ctx, "Provider CLI job not found");
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = { job };
+    };
+    const publicRuntimeRead = (handler) => async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx))
+            await handler(ctx);
+    };
+    const publicRuntimeMutation = (handler) => async (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true }))
+            await handler(ctx);
+    };
+    const internalRuntimeCall = (handler) => async (ctx) => {
+        if (authorizeInternalRuntimeCall(ctx))
+            await handler(ctx);
+    };
+    router.get("/api/runtimes/:selector/emulator/devices", publicRuntimeRead(runtimeDevices));
+    router.get("/api/runtimes/:selector/provider-clis", publicRuntimeRead(runtimeProviderCliStatuses));
+    router.post("/api/runtimes/:selector/provider-clis/:provider/:operation", publicRuntimeMutation(runtimeProviderCliOperation));
+    router.get("/api/runtimes/:selector/provider-clis/jobs/:jobId", publicRuntimeRead(runtimeProviderCliJob));
+    router.get("/api/runtimes/:selector/emulator/active", publicRuntimeRead(runtimeActiveEmulator));
+    router.post("/api/runtimes/:selector/emulator/attach", publicRuntimeMutation(runtimeAttachEmulator));
+    router.post("/api/runtimes/:selector/emulator/tap", publicRuntimeMutation(runtimeTapEmulator));
+    router.post("/api/runtimes/:selector/emulator/type", publicRuntimeMutation(runtimeTypeEmulator));
+    router.post("/api/runtimes/:selector/emulator/button", publicRuntimeMutation(runtimeButtonEmulator));
+    router.post("/api/runtimes/:selector/emulator/rotate", publicRuntimeMutation(runtimeRotateEmulator));
+    router.post("/api/runtimes/:selector/emulator/launch", publicRuntimeMutation(runtimeLaunchEmulator));
+    router.post("/api/runtimes/:selector/emulator/gesture", publicRuntimeMutation(runtimeGestureEmulator));
+    router.post("/api/runtimes/:selector/emulator/kill", publicRuntimeMutation((ctx) => runtimeDeviceCommand(ctx, "emulator.kill")));
+    router.post("/api/runtimes/:selector/emulator/shutdown", publicRuntimeMutation((ctx) => runtimeDeviceCommand(ctx, "emulator.shutdown")));
+    router.get("/api/runtimes/:selector/sessions/:id/emulator", publicRuntimeRead(runtimeSessionEmulatorState));
+    router.get("/api/runtimes/:selector/sessions/:id/emulator/devices", publicRuntimeRead(runtimeSessionEmulatorDevices));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/attach", publicRuntimeMutation(runtimeSessionEmulatorAttach));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/detach", publicRuntimeMutation(runtimeSessionEmulatorDetach));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/tap", publicRuntimeMutation(runtimeSessionEmulatorTap));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/button", publicRuntimeMutation(runtimeSessionEmulatorButton));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/type", publicRuntimeMutation(runtimeSessionEmulatorType));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/rotate", publicRuntimeMutation(runtimeSessionEmulatorRotate));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/launch", publicRuntimeMutation(runtimeSessionEmulatorLaunch));
+    router.post("/api/runtimes/:selector/sessions/:id/emulator/gesture", publicRuntimeMutation(runtimeSessionEmulatorGesture));
+    router.get("/api/runtimes/:selector/sessions/:id/emulator/frame", publicRuntimeRead(runtimeSessionEmulatorFrame));
+    // Session workbench routes always target the explicitly selected Runtime.
+    // The browser talks only to this loopback BFF; Local and Direct both enter the
+    // target daemon through the same typed application service.
+    router.get("/api/runtimes/:selector/sessions", publicRuntimeRead(runtimeSessions));
+    router.get("/api/runtimes/:selector/sessions/agent-options", publicRuntimeRead(runtimeSessionAgentOptions));
+    router.get("/api/runtimes/:selector/sessions/launch-options", publicRuntimeRead(runtimeSessionLaunchOptions));
+    router.post("/api/runtimes/:selector/sessions", publicRuntimeMutation(runtimeSessionCreate));
+    router.get("/api/runtimes/:selector/sessions/:id/snapshot", publicRuntimeRead(runtimeSessionSnapshot));
+    router.get("/api/runtimes/:selector/sessions/:id/stream", publicRuntimeRead(runtimeSessionStream));
+    router.post("/api/runtimes/:selector/sessions/:id/interrupt", publicRuntimeMutation(runtimeSessionInterrupt));
+    router.post("/api/runtimes/:selector/sessions/:id/messages", publicRuntimeMutation(runtimeSessionMessage));
+    router.post("/api/runtimes/:selector/sessions/:id/terminal/start", publicRuntimeMutation(runtimeSessionTerminalStart));
+    router.post("/api/runtimes/:selector/sessions/:id/interactions/:interactionId/resolve", publicRuntimeMutation(runtimeSessionResolveInteraction));
+    router.delete("/api/runtimes/:selector/sessions/:id", publicRuntimeMutation(runtimeSessionDelete));
+    router.get("/api/runtimes/:selector/sessions/:id/browser", publicRuntimeRead(runtimeBrowserState));
+    router.post("/api/runtimes/:selector/sessions/:id/browser/open", publicRuntimeMutation(runtimeBrowserOpen));
+    router.post("/api/runtimes/:selector/sessions/:id/browser/close", publicRuntimeMutation(runtimeBrowserClose));
+    router.post("/api/runtimes/:selector/sessions/:id/browser/pages", publicRuntimeMutation(runtimeBrowserPageCreate));
+    for (const action of ["close", "activate", "back", "forward", "reload"]) {
+        router.post(`/api/runtimes/:selector/sessions/:id/browser/pages/:pageId/${action}`, publicRuntimeMutation((ctx) => runtimeBrowserPageMutation(ctx, `browser.page.${action}`)));
+    }
+    router.post("/api/runtimes/:selector/sessions/:id/browser/pages/:pageId/navigate", publicRuntimeMutation(runtimeBrowserPageNavigate));
+    router.post("/api/internal/runtimes/:selector/rpc", internalRuntimeCall(internalRuntimeRpc));
+    router.get("/api/internal/runtimes/:selector/emulator/devices", internalRuntimeCall(runtimeDevices));
+    router.get("/api/internal/runtimes/:selector/emulator/active", internalRuntimeCall(runtimeActiveEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/attach", internalRuntimeCall(runtimeAttachEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/tap", internalRuntimeCall(runtimeTapEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/type", internalRuntimeCall(runtimeTypeEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/button", internalRuntimeCall(runtimeButtonEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/rotate", internalRuntimeCall(runtimeRotateEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/launch", internalRuntimeCall(runtimeLaunchEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/gesture", internalRuntimeCall(runtimeGestureEmulator));
+    router.post("/api/internal/runtimes/:selector/emulator/kill", internalRuntimeCall((ctx) => runtimeDeviceCommand(ctx, "emulator.kill")));
+    router.post("/api/internal/runtimes/:selector/emulator/shutdown", internalRuntimeCall((ctx) => runtimeDeviceCommand(ctx, "emulator.shutdown")));
+    router.get(RUNTIME_BROWSER_BOOTSTRAP_PATH, async (ctx) => {
+        if (!runtimeLocalBrowser) {
+            return notFound(ctx, "Runtime-local Browser automation is not configured");
+        }
+        if (!isLoopbackRequest(ctx)) {
+            ctx.status = 403;
+            ctx.body = { error: "Runtime-local Browser bootstrap is loopback-only" };
+            return;
+        }
+        let credential;
+        try {
+            credential = parseRuntimeBrowserBootstrapCredential({
+                sessionId: ctx.get(RUNTIME_BROWSER_SESSION_ID_HEADER),
+                capability: ctx.get(RUNTIME_BROWSER_CAPABILITY_HEADER),
+            });
+        }
+        catch {
+            ctx.status = 401;
+            ctx.body = { error: "invalid Runtime Browser Session capability" };
+            return;
+        }
+        try {
+            const descriptor = await runtimeLocalBrowser.endpointForCredential(credential);
+            if (!descriptor) {
+                ctx.status = 401;
+                ctx.body = { error: "invalid Runtime Browser Session capability" };
+                return;
+            }
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = descriptor;
+        }
+        catch (error) {
+            runtimeLocalBrowserError(ctx, error);
+        }
+    });
+    router.post(RUNTIME_BROWSER_RPC_PATH, async (ctx) => {
+        if (!runtimeLocalBrowser || !runtimeConnectionResolver) {
+            return notFound(ctx, "Runtime-local Browser automation is not configured");
+        }
+        if (!isLoopbackRequest(ctx)) {
+            ctx.status = 403;
+            ctx.body = { error: "Runtime-local Browser control is loopback-only" };
+            return;
+        }
+        let credential;
+        try {
+            credential = parseRuntimeBrowserBootstrapCredential({
+                sessionId: ctx.get(RUNTIME_BROWSER_SESSION_ID_HEADER),
+                capability: ctx.get(RUNTIME_BROWSER_CAPABILITY_HEADER),
+            });
+        }
+        catch {
+            ctx.status = 401;
+            ctx.body = { error: "invalid Runtime Browser Session capability" };
+            return;
+        }
+        let authorized = false;
+        try {
+            authorized = await runtimeLocalBrowser.authorizeCredential(credential);
+        }
+        catch {
+            authorized = false;
+        }
+        if (!authorized) {
+            ctx.status = 401;
+            ctx.body = { error: "invalid Runtime Browser Session capability" };
+            return;
+        }
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "unsupported_media_type" };
+            return;
+        }
+        let body;
+        try {
+            body = await readBoundedJson(ctx, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES);
+        }
+        catch (error) {
+            ctx.status = error instanceof RequestBodyTooLargeError ? 413 : 400;
+            ctx.body = {
+                error: error instanceof RequestBodyTooLargeError ? "request_too_large" : "invalid_request",
+            };
+            return;
+        }
+        if (!Object.hasOwn(body, "method") ||
+            !Object.hasOwn(body, "params") ||
+            Object.keys(body).some((key) => key !== "method" && key !== "params")) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        }
+        let request;
+        try {
+            request = parseRemoteRuntimeRpcRequest({
+                type: "rpc.request",
+                id: "runtime-local-browser",
+                method: body.method,
+                params: body.params,
+            });
+        }
+        catch {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        }
+        if (!RUNTIME_BROWSER_RPC_METHODS.has(request.method) ||
+            !("sessionId" in request.params) ||
+            request.params.sessionId !== credential.sessionId) {
+            ctx.status = 403;
+            ctx.body = { error: "forbidden" };
+            return;
+        }
+        ctx.params.selector = "local";
+        const outcome = await runtimeCall(ctx, request.method, request.params);
+        if (outcome.ok)
+            ctx.body = { result: outcome.result };
+    });
+    router.get(`${RUNTIME_BROWSER_MANAGEMENT_PATH_PREFIX}/:sessionId/endpoint`, async (ctx) => {
+        if (!runtimeLocalBrowser || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Runtime-local Browser automation is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        let sessionId;
+        try {
+            sessionId = parseRuntimeBrowserStateGetParams({
+                sessionId: ctx.params.sessionId,
+            }).sessionId;
+        }
+        catch {
+            return bad(ctx, "invalid Session id");
+        }
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await runtimeLocalBrowser.endpointForSession(sessionId);
+        }
+        catch (error) {
+            runtimeLocalBrowserError(ctx, error);
+        }
+    });
     router.get("/api/meta", (ctx) => {
         const meta = {
             channelTypes: deps.listChannelTypes().map((t) => t.type),
         };
         ctx.body = meta;
     });
+    router.get("/api/plugin-runtime", (ctx) => {
+        if (!pluginRuntimeStatus)
+            return notFound(ctx, "plugin runtime is not configured");
+        ctx.body = pluginRuntimeStatus();
+    });
+    router.get("/api/internal/daemon/identity", (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "daemon management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        ctx.body = daemonManagement.identity();
+    });
+    router.get("/api/internal/daemon/runtime-status", (ctx) => {
+        if (!remoteRuntime || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Remote Runtime status is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        ctx.body = encodeDaemonStatus(remoteRuntime.status());
+    });
+    router.post("/api/internal/remote-runtime/pairing-offers", async (ctx) => {
+        if (!remoteRuntimeAdmin || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        await createRuntimePairingOffer(ctx, "offer");
+    });
+    router.get("/api/internal/remote-runtime/clients", (ctx) => {
+        if (!remoteRuntimeAdmin || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        listRuntimeAccess(ctx);
+    });
+    router.delete("/api/internal/remote-runtime/clients/:grantId", (ctx) => {
+        if (!remoteRuntimeAdmin || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        revokeRuntimeAccess(ctx);
+    });
+    router.post("/api/internal/plugins/:pluginId/cli", async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "daemon management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
+            return bad(ctx, "invalid plugin id");
+        }
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "plugin CLI invocation requires application/json" };
+            return;
+        }
+        let body;
+        try {
+            body = await readBoundedJson(ctx, PLUGIN_CLI_BODY_MAX_BYTES);
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const input = parsePluginCliInvocation(pluginId, body);
+        if (typeof input === "string")
+            return bad(ctx, input);
+        const invocation = pluginCliInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.body = await daemonManagement.invokePluginCli(input, { signal: invocation.signal });
+        }
+        catch (error) {
+            if (!ctx.res.destroyed) {
+                ctx.status = invocation.signal.aborted
+                    ? invocation.signal.reason instanceof Error && invocation.signal.reason.name === "TimeoutError"
+                        ? 504
+                        : 499
+                    : 409;
+                ctx.body = {
+                    error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_CLI_ERROR_MAX_BYTES),
+                };
+            }
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.post("/api/internal/plugin-runtimes/:pluginId/reload", async (ctx) => {
+        if (!pluginRuntimeReload || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin runtime management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
+            return bad(ctx, "invalid plugin id");
+        }
+        try {
+            ctx.body = await pluginRuntimeReload(pluginId);
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+    router.post("/api/internal/plugin-runtimes/:pluginId/ensure", async (ctx) => {
+        if (!pluginRuntimeEnsure || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin runtime management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
+            return bad(ctx, "invalid plugin id");
+        }
+        try {
+            ctx.body = await pluginRuntimeEnsure(pluginId);
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+    router.get("/control/link", (ctx) => {
+        const token = asString(ctx.query.token);
+        if (!token || !deps.consumeControlLink)
+            return notFound(ctx, "control link not found");
+        const link = deps.consumeControlLink(token);
+        if (!link)
+            return notFound(ctx, "control link expired or already used");
+        ctx.redirect(`/sessions/${encodeURIComponent(link.sessionId)}`);
+    });
     router.get("/api/channel-types", (ctx) => {
         ctx.body = { channelTypes: deps.listChannelTypes() };
     });
@@ -57,16 +1539,27 @@ export function createControlRouter(opts) {
             return bad(ctx, "missing channel name");
         if (!type)
             return bad(ctx, "missing channel type");
-        const { id } = deps.createChannel({ name, type, options: asRecord(body.options) });
+        let id;
+        try {
+            ({ id } = deps.createChannel({ name, type, options: asRecord(body.options) }));
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
         ctx.body = { ok: true, id };
     });
     router.put("/api/channels/:id", async (ctx) => {
         const id = ctx.params.id;
         const body = await readJson(ctx);
-        deps.setChannel(id, {
-            ...(body.name !== undefined ? { name: asString(body.name) } : {}),
-            ...(body.options !== undefined ? { options: asRecord(body.options) } : {}),
-        });
+        try {
+            deps.setChannel(id, {
+                ...(body.name !== undefined ? { name: asString(body.name) } : {}),
+                ...(body.options !== undefined ? { options: asRecord(body.options) } : {}),
+            });
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
         const bound = instanceForChannel(id);
         if (bound)
             await manager.reloadInstance(bound.id);
@@ -89,13 +1582,16 @@ export function createControlRouter(opts) {
             return notFound(ctx, "channel not found");
         await streamEvents(ctx, async (send, signal) => {
             send("status", { text: `authorizing ${channel.type}…` });
-            const options = await deps.authorizeChannel(channel.type, (m) => send(m.kind, m), signal);
-            deps.setChannel(id, { options });
             const bound = instanceForChannel(id);
+            const options = await deps.authorizeChannel(channel.type, {
+                ...(bound ? { instanceId: bound.id } : {}),
+                config: channel.options ?? {},
+            }, (m) => send(m.kind, m), signal);
+            deps.setChannel(id, { options });
             if (bound)
                 await manager.reloadInstance(bound.id);
             send("done", { id });
-        });
+        }, shutdownSignal);
     });
     // ── instances ──────────────────────────────────────────────────────────
     router.get("/api/instances", (ctx) => {
@@ -260,27 +1756,24 @@ export function createControlRouter(opts) {
             bad(ctx, error instanceof Error ? error.message : String(error));
         }
     };
-    // Per-session device scoping (orca's per-worktree active emulator, keyed by
-    // rynx session id riding the `x-rynx-session` header): an attach from a
-    // session binds it to the attached device; later session commands without an
-    // explicit `device` resolve against the binding. Sharing is allowed (N
-    // sessions → one device); explicit `device` always wins; sessions without a
-    // binding fall back to the global active. In-memory by design: on a daemon
-    // restart agents just re-attach (the skill mandates attach-before-use).
-    const emulatorSessionDevices = new Map();
-    const emulatorSessionOf = (ctx) => ctx.get("x-rynx-session")?.trim() || undefined;
-    const emulatorScopedDevice = (ctx, body) => {
-        const explicit = asString(body.device);
-        if (explicit)
-            return explicit;
+    const localSessionEmulatorBinding = async (ctx, body) => {
         const sessionId = emulatorSessionOf(ctx);
-        return sessionId ? emulatorSessionDevices.get(sessionId) : undefined;
-    };
-    const emulatorUnbindDevice = (device) => {
-        for (const [sessionId, bound] of emulatorSessionDevices) {
-            if (bound === device)
-                emulatorSessionDevices.delete(sessionId);
+        if (!sessionId)
+            return undefined;
+        if (!sessionEmulators)
+            throw new Error("Session Emulator service is unavailable");
+        const binding = await sessionEmulators.getState({ sessionId });
+        if (!binding)
+            throw new Error("Session has no attached Emulator");
+        const explicit = asString(body.device);
+        if (explicit && explicit !== binding.deviceId) {
+            throw new Error("Explicit device does not match the Session Emulator binding");
         }
+        return binding;
+    };
+    const localEmulatorDevice = async (ctx, body) => {
+        const binding = await localSessionEmulatorBinding(ctx, body);
+        return binding?.deviceId ?? asString(body.device);
     };
     router.get("/api/emulator/doctor", async (ctx) => {
         await emulatorResult(ctx, (emulator) => emulator.doctor());
@@ -290,7 +1783,16 @@ export function createControlRouter(opts) {
     });
     router.get("/api/emulator/active", async (ctx) => {
         await emulatorResult(ctx, async (emulator) => {
-            const device = emulatorScopedDevice(ctx, {});
+            const sessionId = emulatorSessionOf(ctx);
+            let device;
+            if (sessionId) {
+                if (!sessionEmulators)
+                    throw new Error("Session Emulator service is unavailable");
+                const binding = await sessionEmulators.getState({ sessionId });
+                if (!binding)
+                    return { active: null };
+                device = binding.deviceId;
+            }
             if (device && emulator.deviceSession) {
                 return { active: await emulator.deviceSession({ device }) };
             }
@@ -301,11 +1803,21 @@ export function createControlRouter(opts) {
         const body = await readJson(ctx);
         const sessionId = emulatorSessionOf(ctx);
         await emulatorResult(ctx, async (emulator) => {
-            const session = (await emulator.attach(asString(body.device)));
-            if (sessionId && typeof session?.deviceUdid === "string") {
-                emulatorSessionDevices.set(sessionId, session.deviceUdid);
+            if (!sessionId)
+                return emulator.attach(asString(body.device));
+            if (!sessionEmulators)
+                throw new Error("Session Emulator service is unavailable");
+            let device = asString(body.device);
+            if (!device) {
+                const devices = await sessionEmulators.listDevices({ sessionId });
+                device = devices.find((candidate) => candidate.isDefault)?.id ?? devices[0]?.id;
             }
-            return session;
+            if (!device)
+                throw new Error("No Emulator is available for this Session");
+            const binding = await sessionEmulators.attach({ sessionId, device });
+            return emulator.deviceSession
+                ? await emulator.deviceSession({ device: binding.deviceId }) ?? binding
+                : binding;
         });
     });
     router.post("/api/emulator/tap", async (ctx) => {
@@ -314,50 +1826,95 @@ export function createControlRouter(opts) {
         const y = asNumber(body.y);
         if (x == null || y == null)
             return bad(ctx, "tap requires numeric x and y");
-        await emulatorResult(ctx, (emulator) => emulator.tap({ x, y, device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            return binding && sessionEmulators
+                ? sessionEmulators.tap({ sessionId: binding.sessionId, bindingId: binding.bindingId, x, y })
+                : emulator.tap({ x, y, device: asString(body.device) });
+        });
     });
     router.post("/api/emulator/type", async (ctx) => {
         const body = await readJson(ctx);
         const text = asString(body.text);
         if (!text)
             return bad(ctx, "type requires text");
-        await emulatorResult(ctx, (emulator) => emulator.type({ text, device: emulatorScopedDevice(ctx, body), mode: asString(body.mode) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            const mode = asString(body.mode);
+            return binding && sessionEmulators
+                ? sessionEmulators.type({
+                    sessionId: binding.sessionId,
+                    bindingId: binding.bindingId,
+                    text,
+                    ...(mode === "paste" || mode === "keys" ? { mode } : {}),
+                })
+                : emulator.type({ text, device: asString(body.device), mode });
+        });
     });
     router.post("/api/emulator/button", async (ctx) => {
         const body = await readJson(ctx);
-        await emulatorResult(ctx, (emulator) => emulator.button({ name: asString(body.name), device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            const name = asString(body.name);
+            return binding && sessionEmulators
+                ? sessionEmulators.button({
+                    sessionId: binding.sessionId,
+                    bindingId: binding.bindingId,
+                    ...(name ? { name } : {}),
+                })
+                : emulator.button({ name, device: asString(body.device) });
+        });
     });
     router.post("/api/emulator/rotate", async (ctx) => {
         const body = await readJson(ctx);
         const orientation = asString(body.orientation);
         if (!orientation)
             return bad(ctx, "rotate requires orientation");
-        await emulatorResult(ctx, (emulator) => emulator.rotate({ orientation, device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            return binding && sessionEmulators
+                ? sessionEmulators.rotate({ sessionId: binding.sessionId, bindingId: binding.bindingId, orientation })
+                : emulator.rotate({ orientation, device: asString(body.device) });
+        });
     });
     router.post("/api/emulator/launch", async (ctx) => {
         const body = await readJson(ctx);
         const appId = asString(body.appId) ?? asString(body.bundleId) ?? asString(body.packageName);
         if (!appId)
             return bad(ctx, "launch requires appId");
-        await emulatorResult(ctx, (emulator) => emulator.launch({ appId, device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            return binding && sessionEmulators
+                ? sessionEmulators.launch({ sessionId: binding.sessionId, bindingId: binding.bindingId, appId })
+                : emulator.launch({ appId, device: asString(body.device) });
+        });
     });
     router.post("/api/emulator/gesture", async (ctx) => {
         const body = await readJson(ctx);
         const points = body.points;
         if (!Array.isArray(points))
             return bad(ctx, "gesture requires points");
-        await emulatorResult(ctx, (emulator) => emulator.gesture({ points, device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => {
+            const binding = await localSessionEmulatorBinding(ctx, body);
+            return binding && sessionEmulators
+                ? sessionEmulators.gesture({
+                    sessionId: binding.sessionId,
+                    bindingId: binding.bindingId,
+                    points: points,
+                })
+                : emulator.gesture({ points, device: asString(body.device) });
+        });
     });
     router.post("/api/emulator/exec", async (ctx) => {
         const body = await readJson(ctx);
         const command = asString(body.command);
         if (!command)
             return bad(ctx, "exec requires command");
-        await emulatorResult(ctx, (emulator) => emulator.exec({ command, device: emulatorScopedDevice(ctx, body) }));
+        await emulatorResult(ctx, async (emulator) => emulator.exec({ command, device: await localEmulatorDevice(ctx, body) }));
     });
     router.post("/api/emulator/screenshot", async (ctx) => {
         const body = await readJson(ctx);
-        await emulatorResult(ctx, (emulator) => emulator.screenshot({ device: emulatorScopedDevice(ctx, body), out: asString(body.out) }));
+        await emulatorResult(ctx, async (emulator) => emulator.screenshot({ device: await localEmulatorDevice(ctx, body), out: asString(body.out) }));
     });
     router.get("/api/emulator/frame", async (ctx) => {
         const emulator = emulatorOr404(ctx);
@@ -368,7 +1925,7 @@ export function createControlRouter(opts) {
         }
         const body = { device: asString(ctx.query.device) };
         try {
-            const frame = await emulator.frame({ device: emulatorScopedDevice(ctx, body) });
+            const frame = await emulator.frame({ device: await localEmulatorDevice(ctx, body) });
             ctx.type = frame.contentType;
             ctx.set("Cache-Control", "no-store");
             ctx.body = frame.data;
@@ -386,7 +1943,7 @@ export function createControlRouter(opts) {
         }
         const body = { device: asString(ctx.query.device) };
         try {
-            const video = await emulator.video({ device: emulatorScopedDevice(ctx, body) });
+            const video = await emulator.video({ device: await localEmulatorDevice(ctx, body) });
             let stopped = false;
             const stop = () => {
                 if (stopped)
@@ -401,6 +1958,17 @@ export function createControlRouter(opts) {
             res.setHeader("Cache-Control", "no-store");
             res.setHeader("X-Content-Type-Options", "nosniff");
             res.on("close", stop);
+            const stopForShutdown = () => {
+                stop();
+                if (!res.writableEnded)
+                    res.end();
+            };
+            if (shutdownSignal?.aborted) {
+                stopForShutdown();
+                return;
+            }
+            shutdownSignal?.addEventListener("abort", stopForShutdown, { once: true });
+            res.on("close", () => shutdownSignal?.removeEventListener("abort", stopForShutdown));
             video.stream.on("end", stop);
             video.stream.on("error", (error) => {
                 stop();
@@ -438,25 +2006,25 @@ export function createControlRouter(opts) {
     router.post("/api/emulator/kill", async (ctx) => {
         const body = await readJson(ctx);
         await emulatorResult(ctx, async (emulator) => {
-            const result = (await emulator.kill({ device: emulatorScopedDevice(ctx, body) }));
-            if (typeof result?.device === "string")
-                emulatorUnbindDevice(result.device);
-            return result;
+            const device = await localEmulatorDevice(ctx, body);
+            return sessionEmulators
+                ? sessionEmulators.stopDevice({ action: "kill", ...(device ? { device } : {}) })
+                : emulator.kill({ device });
         });
     });
     router.post("/api/emulator/shutdown", async (ctx) => {
         const body = await readJson(ctx);
         await emulatorResult(ctx, async (emulator) => {
-            const result = (await emulator.shutdown({ device: emulatorScopedDevice(ctx, body) }));
-            if (typeof result?.device === "string")
-                emulatorUnbindDevice(result.device);
-            return result;
+            const device = await localEmulatorDevice(ctx, body);
+            return sessionEmulators
+                ? sessionEmulators.stopDevice({ action: "shutdown", ...(device ? { device } : {}) })
+                : emulator.shutdown({ device });
         });
     });
     // ── sessions (channel-agnostic agent runs) ───────────────────────────────
     // Create a session bound to a preset agent (`agent`) or an inline spec
     // (`config`, the config-driven / remote-ready path), then drive it with
-    // messages over SSE. omnigent-style: create carries no message.
+    // messages over SSE. reference implementation-style: create carries no message.
     // One unified list: every session is a machine-session record. The registry
     // (console + every channel) supplies identity — `source` is a plain field, not
     // parsed from the id — and the canonical log supplies recency. A legacy session
@@ -474,9 +2042,10 @@ export function createControlRouter(opts) {
             const updatedAt = log ? new Date(log.updatedAt).toISOString() : (meta?.updatedAt ?? createdAt);
             return {
                 id,
+                provider: meta?.provider,
                 agent: meta?.agent,
                 title: meta?.title,
-                status: "idle",
+                status: sessionRuntimeIndex.snapshot(id).status,
                 createdAt,
                 updatedAt,
                 source: meta?.source ?? "unknown",
@@ -531,7 +2100,7 @@ export function createControlRouter(opts) {
         const bound = consoleMeta ? null : ((await sessionStore?.get(id)) ?? null);
         if (!meta && !bound)
             return notFound(ctx, "session not found");
-        // First message names a console session (omnigent-style: the message,
+        // First message names a console session (reference implementation-style: the message,
         // truncated). Channel sessions keep their own title elsewhere — skip.
         if (consoleMeta && !consoleMeta.title)
             deps.setSessionTitle(id, synthesizeSessionTitle(message));
@@ -548,7 +2117,7 @@ export function createControlRouter(opts) {
             const liveRuntime = await runtime.resolveRuntime({
                 agentName: consoleMeta?.agent,
                 agentSpec: consoleMeta?.config,
-                provider: bound?.runtime,
+                provider: meta?.provider ?? bound?.runtime,
             });
             // codex RESUME with a missing local rollout (fork / cross-machine): synthesize
             // one from the session log so the app-server's thread/resume finds it. No-op
@@ -570,8 +2139,13 @@ export function createControlRouter(opts) {
                 }
             }
             const live = await runnerManager.ensureLiveSession(id, {
-                ...(bound?.cwd ? { cwd: bound.cwd } : {}),
+                ...(bound?.cwd
+                    ? { cwd: bound.cwd }
+                    : consoleMeta?.config?.osEnv?.cwd
+                        ? { cwd: consoleMeta.config.osEnv.cwd }
+                        : {}),
                 runtime: liveRuntime,
+                ...(consoleMeta?.reasoningEffort ? { reasoningEffort: consoleMeta.reasoningEffort } : {}),
                 // Carry the agent identity so the live launch applies the agent spec's
                 // model / skills / instructions (not just the runtime). A preset agent
                 // rides its id; an inline-config console session rides its spec.
@@ -580,11 +2154,15 @@ export function createControlRouter(opts) {
             });
             if (!live) {
                 // A live-runtime (codex/claude-native) session whose forwarder couldn't come
-                // up. omnigent reports this as a failure and NEVER falls through to a second
+                // up. reference implementation reports this as a failure and NEVER falls through to a second
                 // output path — falling through would run+persist the turn while the forwarder
                 // also mirrors it (the double-write). Report + stop.
+                const detail = runnerManager.lastLiveSessionError?.(id);
                 ctx.status = 503;
-                ctx.body = { error: `live session unavailable (${liveRuntime})` };
+                ctx.body = {
+                    error: `live session unavailable (${liveRuntime})`,
+                    ...(detail ? { detail } : {}),
+                };
                 return;
             }
             const outcome = await runnerManager.injectMessage(id, message);
@@ -594,7 +2172,7 @@ export function createControlRouter(opts) {
             }
             // notLive / notReady / failed → hard error. NEVER fall through to run+stream:
             // the second path would double-write the turn alongside the forwarder
-            // (omnigent: inject failure ⇒ response.failed, no local re-run).
+            // (reference implementation: inject failure ⇒ response.failed, no local re-run).
             ctx.status = 503;
             ctx.body = { error: `live injection ${outcome}` };
             return;
@@ -623,6 +2201,14 @@ export function createControlRouter(opts) {
         const id = ctx.params.id;
         ctx.body = { sessionId: id, items: sessionLog ? await sessionLog.snapshot(id) : [] };
     });
+    router.get("/api/sessions/:id/snapshot", async (ctx) => {
+        const id = ctx.params.id;
+        ctx.body = {
+            sessionId: id,
+            items: sessionLog ? await sessionLog.snapshot(id) : [],
+            runtime: sessionRuntimeIndex.snapshot(id),
+        };
+    });
     // Persistent live event stream (codex-native): one SSE per session, held for
     // its whole lifetime, tailing the canonical bus. Sees EVERY turn — web-injected
     // AND co-driving-TUI-initiated — since the forwarder is the single writer. The
@@ -630,10 +2216,25 @@ export function createControlRouter(opts) {
     // + item-id dedupe. Ends when the client disconnects.
     router.get("/api/sessions/:id/stream", async (ctx) => {
         const id = ctx.params.id;
+        // Production daemon composition owns a binding-neutral Local connection.
+        // Keep this legacy URL compatible while routing it through the same bounded
+        // subscription adapter as `/api/runtimes/local/...`.
+        if (runtimeConnectionResolver) {
+            await streamRuntimeSession(ctx, "local", id);
+            return;
+        }
         if (!sessionBus)
             return bad(ctx, "session streaming is not available on this server");
         await streamEvents(ctx, async (send, signal) => {
             const iterator = sessionBus.subscribe(id)[Symbol.asyncIterator]();
+            // Headers are flushed before this callback runs, so a client cannot use
+            // the HTTP response alone as proof that SessionBus subscription exists.
+            // This frame is the ordering barrier for subscribe → snapshot → replay.
+            // This compatibility fallback has no binding adapter queue. End the
+            // subscription as soon as the HTTP consumer applies backpressure instead
+            // of letting either Node or SessionBus accumulate an unbounded tail.
+            if (!send("ready", { sessionId: id }))
+                return;
             const disconnected = new Promise((resolve) => {
                 if (signal.aborted)
                     resolve(null);
@@ -647,79 +2248,54 @@ export function createControlRouter(opts) {
                         break; // client went away
                     if (next.done)
                         break; // bus closed for this session
-                    send("event", next.value);
+                    if (!send("event", next.value))
+                        break;
                 }
             }
             finally {
                 await iterator.return?.();
             }
-        });
-    });
-    // claude-native approvals: the PermissionRequest hook POSTs here and BLOCKS.
-    // Surface a `response.approval.requested` (the same event + ApprovalCard the
-    // codex path uses), hold the response until the web user answers, then relay
-    // claude's `{hookSpecificOutput:{decision:{behavior}}}` verdict to the hook.
-    router.post("/api/sessions/:id/hooks/permission-request", async (ctx) => {
-        const id = ctx.params.id;
-        if (!sessionBus)
-            return bad(ctx, "session streaming is not available on this server");
-        const payload = await readJson(ctx);
-        const toolName = asString(payload.tool_name) ?? "tool";
-        const toolInput = payload.tool_input && typeof payload.tool_input === "object"
-            ? payload.tool_input
-            : {};
-        const cwd = asString(payload.cwd);
-        const approvalId = `claude_${randomUUID()}`;
-        const kind = /edit|write|patch|apply|notebook/i.test(toolName)
-            ? "patch"
-            : "exec";
-        const command = asString(toolInput.command) ?? asString(toolInput.file_path) ?? toolName;
-        const event = {
-            type: "response.approval.requested",
-            responseId: `resp_claude_permission_${approvalId}`,
-            approvalId,
-            kind,
-            ...(command ? { command } : {}),
-            ...(cwd ? { cwd } : {}),
-        };
-        await persistSessionEvent(id, event, { sessionLog, sessionBus });
-        const verdict = await new Promise((resolve) => {
-            claudeApprovals.set(approvalId, resolve);
-            ctx.req.on("close", () => {
-                if (claudeApprovals.delete(approvalId))
-                    resolve({ behavior: "deny" });
-            });
-        });
-        ctx.body = { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: verdict } };
+        }, shutdownSignal);
     });
-    // Resolve an interactive approval (Phase D): the user's decision for a
-    // `response.approval.requested` event, routed to the session's runner (codex)
-    // or the held claude PermissionRequest long-poll.
-    router.post("/api/sessions/:id/approvals/:approvalId", async (ctx) => {
+    // Provider-neutral interaction response. The runtime owns the pending waiter
+    // and first-writer-wins decision; HTTP only validates and routes the generic
+    // resolution. The canonical resolved event is emitted by the runtime after
+    // the provider accepts it, so every observer converges on the same winner.
+    router.post("/api/sessions/:id/interactions/:interactionId/resolve", async (ctx) => {
         const id = ctx.params.id;
-        const approvalId = ctx.params.approvalId;
+        const interactionId = ctx.params.interactionId;
         const body = await readJson(ctx);
-        const decision = asString(body.decision);
-        if (decision !== "acceptForSession" &&
-            decision !== "accept" &&
-            decision !== "decline" &&
-            decision !== "cancel") {
-            ctx.status = 400;
-            ctx.body = { error: "decision must be acceptForSession | accept | decline | cancel" };
-            return;
+        const resolution = parseInteractionResolution(body.resolution);
+        if (!resolution) {
+            return bad(ctx, "resolution must contain actionId and bounded string answers");
+        }
+        if (!runnerManager?.resolveInteraction) {
+            return notFound(ctx, "session interaction resolution is not available");
+        }
+        const result = await runnerManager.resolveInteraction(id, interactionId, resolution);
+        if (result.disposition === "invalid") {
+            return bad(ctx, "interaction resolution is invalid");
         }
-        const claudeResolve = claudeApprovals.get(approvalId);
-        if (claudeResolve) {
-            claudeApprovals.delete(approvalId);
-            claudeResolve(decision === "decline" || decision === "cancel" ? { behavior: "deny" } : { behavior: "allow" });
-            ctx.body = { ok: true };
+        if (result.disposition === "not_found") {
+            return notFound(ctx, "interaction is not pending");
+        }
+        if (result.disposition === "already_resolved") {
+            ctx.status = 409;
+            ctx.body = { error: "interaction was already resolved", ...result };
             return;
         }
-        runnerManager?.resolveApproval?.(id, approvalId, decision);
-        ctx.body = { ok: true };
+        ctx.body = result;
     });
     router.delete("/api/sessions/:id", async (ctx) => {
         const id = ctx.params.id;
+        try {
+            await sessionLifecycle?.beforeDelete?.(id);
+        }
+        catch {
+            ctx.status = 409;
+            ctx.body = { error: "session_resource_cleanup_failed" };
+            return;
+        }
         runnerManager?.stopRunner(id);
         sessionBus?.close(id);
         deps.removeSessionMeta(id);
@@ -727,9 +2303,15 @@ export function createControlRouter(opts) {
         // dropping only the meta would leave the session showing as an UNKNOWN
         // ghost. Both together make it fully disappear.
         await sessionLog?.deleteSession(id);
-        // Unbind only the scope mapping — the device (and its helper) stays attached
-        // for the web panel / other sessions sharing it (orca's unregisterWorktree).
-        emulatorSessionDevices.delete(id);
+        sessionRuntimeIndex.remove(id);
+        try {
+            await sessionLifecycle?.afterDelete?.(id);
+        }
+        catch {
+            ctx.status = 500;
+            ctx.body = { error: "session_resource_finalize_failed", outcome: "unknown" };
+            return;
+        }
         ctx.body = { ok: true };
     });
     return router;
@@ -739,20 +2321,39 @@ export function createControlRouter(opts) {
  * `signal` aborts when the client disconnects. Takes over the raw response so
  * frames flush immediately; a thrown error is reported as an `error` event.
  */
-async function streamEvents(ctx, run) {
+async function streamEvents(ctx, run, shutdownSignal) {
     ctx.status = 200;
     ctx.set("Content-Type", "text/event-stream");
-    ctx.set("Cache-Control", "no-cache, no-transform");
+    // Session streams may contain source code, prompts and tool output. `no-cache`
+    // still permits storage after revalidation; keep transcript bytes out of
+    // browser/proxy caches entirely and prohibit intermediary transformations.
+    ctx.set("Cache-Control", "private, no-store, no-transform");
     ctx.set("Connection", "keep-alive");
+    ctx.set("X-Accel-Buffering", "no");
     ctx.respond = false;
+    ctx.req.socket.setTimeout(0);
     const res = ctx.res;
     res.flushHeaders?.();
     const controller = new AbortController();
     ctx.req.on("close", () => controller.abort());
+    const abortForShutdown = () => controller.abort(shutdownSignal?.reason);
+    if (shutdownSignal?.aborted)
+        abortForShutdown();
+    else
+        shutdownSignal?.addEventListener("abort", abortForShutdown, { once: true });
     const send = (event, data) => {
-        if (!res.writableEnded)
-            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        if (res.writableEnded)
+            return false;
+        return res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
     };
+    // Keep idle chat streams alive through reverse proxies and NATs. Without a
+    // frame, an otherwise healthy session is often closed after a few minutes and
+    // the web console has to rebuild its transcript subscription.
+    const keepalive = setInterval(() => {
+        if (!res.writableEnded && !res.writableNeedDrain)
+            res.write(": keepalive\n\n");
+    }, 25_000);
+    keepalive.unref?.();
     try {
         await run(send, controller.signal);
     }
@@ -760,12 +2361,39 @@ async function streamEvents(ctx, run) {
         send("error", { message: error instanceof Error ? error.message : String(error) });
     }
     finally {
+        clearInterval(keepalive);
+        shutdownSignal?.removeEventListener("abort", abortForShutdown);
         if (!res.writableEnded)
             res.end();
     }
 }
+function waitForSseDrain(ctx, signal) {
+    if (signal.aborted || ctx.res.writableEnded)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const settle = (drained) => {
+            ctx.res.removeListener("drain", onDrain);
+            ctx.res.removeListener("close", onClose);
+            signal.removeEventListener("abort", onAbort);
+            resolve(drained);
+        };
+        const onDrain = () => settle(true);
+        const onClose = () => settle(false);
+        const onAbort = () => settle(false);
+        ctx.res.once("drain", onDrain);
+        ctx.res.once("close", onClose);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function abortAsNull(signal) {
+    if (signal.aborted)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        signal.addEventListener("abort", () => resolve(null), { once: true });
+    });
+}
 /** Derive a one-line session title from the first user message: collapse
- *  whitespace, trim, and truncate to `limit` chars + an ellipsis (omnigent's
+ *  whitespace, trim, and truncate to `limit` chars + an ellipsis (reference implementation's
  *  rule — no LLM call). */
 export function synthesizeSessionTitle(message, limit = 60) {
     const collapsed = message.replace(/\s+/g, " ").trim();
@@ -810,6 +2438,459 @@ function redact(deps, type, options) {
 function asString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function parseProviderCliId(value) {
+    return value === "codex" || value === "claude" || value === "traex"
+        ? value
+        : undefined;
+}
+function parseProviderCliOperation(value) {
+    return value === "install" || value === "update" ? value : undefined;
+}
+function providerCliOperationErrorCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    return "code" in error && typeof error.code === "string" ? error.code : undefined;
+}
+function optionalRuntimeString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function optionalRuntimeDevice(body) {
+    return body.device === undefined ? {} : { device: body.device };
+}
+function remoteRuntimeRpcTimeoutMs(method, params) {
+    if (method === "session.emulator.attach")
+        return REMOTE_RUNTIME_EMULATOR_ATTACH_TIMEOUT_MS;
+    if (method === "session.emulator.type") {
+        const text = params.text;
+        return Math.min(REMOTE_RUNTIME_EMULATOR_ATTACH_TIMEOUT_MS, Math.max(REMOTE_RUNTIME_EMULATOR_CONTROL_TIMEOUT_MS, text.length * 40 + 5_000));
+    }
+    if (method.startsWith("session."))
+        return REMOTE_RUNTIME_SESSION_TIMEOUT_MS;
+    if (method === "browser.open")
+        return REMOTE_RUNTIME_BROWSER_OPEN_TIMEOUT_MS;
+    if (method.startsWith("browser."))
+        return REMOTE_RUNTIME_BROWSER_CONTROL_TIMEOUT_MS;
+    if (method === "emulator.attach")
+        return REMOTE_RUNTIME_EMULATOR_ATTACH_TIMEOUT_MS;
+    if (method === "emulator.type") {
+        const text = params.text;
+        return Math.min(REMOTE_RUNTIME_EMULATOR_ATTACH_TIMEOUT_MS, Math.max(REMOTE_RUNTIME_EMULATOR_CONTROL_TIMEOUT_MS, text.length * 40 + 5_000));
+    }
+    return REMOTE_RUNTIME_EMULATOR_CONTROL_TIMEOUT_MS;
+}
+function parseInteractionResolution(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const input = value;
+    if (Object.keys(input).some((key) => key !== "actionId" && key !== "answers"))
+        return null;
+    const actionId = asString(input.actionId);
+    if (!actionId || actionId.length > 256)
+        return null;
+    if (input.answers === undefined)
+        return { actionId };
+    if (!input.answers || typeof input.answers !== "object" || Array.isArray(input.answers)) {
+        return null;
+    }
+    const entries = Object.entries(input.answers);
+    if (entries.length > 64)
+        return null;
+    const answers = {};
+    for (const [fieldId, answer] of entries) {
+        if (!fieldId || fieldId.length > 256)
+            return null;
+        if (typeof answer === "string") {
+            if (answer.length > 65_536)
+                return null;
+            answers[fieldId] = answer;
+            continue;
+        }
+        if (!Array.isArray(answer) ||
+            answer.length > 64 ||
+            answer.some((entry) => typeof entry !== "string" || entry.length > 65_536))
+            return null;
+        answers[fieldId] = [...answer];
+    }
+    const resolution = { actionId, answers };
+    if (Buffer.byteLength(JSON.stringify(resolution), "utf8") > SESSION_INTERACTION_RESOLUTION_MAX_BYTES) {
+        return null;
+    }
+    return resolution;
+}
+function safeTokenEquals(actual, expected) {
+    const left = Buffer.from(actual, "utf8");
+    const right = Buffer.from(expected, "utf8");
+    return left.byteLength === right.byteLength && timingSafeEqual(left, right);
+}
+function optionalBoundedLabel(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 128 ||
+        value.trim() !== value ||
+        /[\u0000-\u001f\u007f]/.test(value)) {
+        throw new Error("clientLabel is invalid");
+    }
+    return value;
+}
+function optionalAdvertiseAddress(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 2_048 ||
+        value.trim() !== value ||
+        /[\u0000-\u0020\u007f]/.test(value)) {
+        throw new Error("address is invalid");
+    }
+    return value;
+}
+function isConfiguredDaemonManagement(value) {
+    if (!value || typeof value.managementToken !== "string")
+        return false;
+    const bytes = Buffer.byteLength(value.managementToken, "utf8");
+    return bytes >= 32 && bytes <= 256;
+}
+function pluginCliInvocationAbortScope(ctx, shutdownSignal) {
+    const controller = new AbortController();
+    const abort = (reason) => {
+        if (!controller.signal.aborted)
+            controller.abort(reason);
+    };
+    const onRequestAborted = () => abort(namedError("plugin CLI request aborted", "AbortError"));
+    const onResponseClose = () => {
+        if (!ctx.res.writableEnded)
+            abort(namedError("plugin CLI client disconnected", "AbortError"));
+    };
+    const onShutdown = () => abort(shutdownSignal?.reason ?? namedError("daemon is shutting down", "AbortError"));
+    const timeout = setTimeout(() => abort(namedError("plugin CLI invocation timed out", "TimeoutError")), PLUGIN_CLI_TIMEOUT_MS);
+    timeout.unref?.();
+    ctx.req.once("aborted", onRequestAborted);
+    ctx.res.once("close", onResponseClose);
+    if (shutdownSignal?.aborted)
+        onShutdown();
+    else
+        shutdownSignal?.addEventListener("abort", onShutdown, { once: true });
+    if (ctx.req.aborted)
+        onRequestAborted();
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timeout);
+            ctx.req.removeListener("aborted", onRequestAborted);
+            ctx.res.removeListener("close", onResponseClose);
+            shutdownSignal?.removeEventListener("abort", onShutdown);
+        },
+    };
+}
+function namedError(message, name) {
+    const error = new Error(message);
+    error.name = name;
+    return error;
+}
+function authorizeLoopbackManagementRequest(ctx, expectedToken) {
+    if (!isLoopbackRequest(ctx)) {
+        ctx.status = 403;
+        ctx.body = { error: "daemon management is loopback-only" };
+        return false;
+    }
+    if (!safeTokenEquals(ctx.get("x-rynx-management-token"), expectedToken)) {
+        ctx.status = 401;
+        ctx.body = { error: "invalid daemon management token" };
+        return false;
+    }
+    return true;
+}
+function isLoopbackRequest(ctx) {
+    const address = normalizeSocketAddress(ctx.req.socket.remoteAddress);
+    return address === "127.0.0.1" || address === "::1";
+}
+function normalizeSocketAddress(value) {
+    if (!value)
+        return undefined;
+    return value.startsWith("::ffff:") ? value.slice("::ffff:".length) : value;
+}
+function isRuntimeTargetSelector(value) {
+    return typeof value === "string" && RUNTIME_TARGET_SELECTOR_PATTERN.test(value);
+}
+function isRuntimeDisplayName(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 128 &&
+        value.trim() === value &&
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+/** Whitelist only fields that are explicitly safe for the browser and local CLI. */
+function redactRuntimeTargetView(target) {
+    if (!target ||
+        !isRuntimeTargetSelector(target.selector) ||
+        !isRuntimeTargetSelector(target.daemonId) ||
+        !isRuntimeDisplayName(target.displayName) ||
+        (target.binding !== "local" && target.binding !== "direct")) {
+        throw new Error("Runtime target host returned an invalid target");
+    }
+    if (target.binding === "local") {
+        if (target.selector !== "local" ||
+            target.endpoint !== undefined ||
+            target.identityKeyFingerprint !== undefined ||
+            target.createdAt !== undefined) {
+            throw new Error("Runtime target host returned an invalid local target binding");
+        }
+    }
+    else if (target.selector !== target.daemonId ||
+        target.selector === "local" ||
+        target.endpoint === undefined ||
+        target.identityKeyFingerprint === undefined ||
+        target.createdAt === undefined) {
+        throw new Error("Runtime target host returned an invalid direct target binding");
+    }
+    if (target.endpoint !== undefined && !isSafeRuntimeEndpoint(target.endpoint)) {
+        throw new Error("Runtime target host returned an invalid endpoint");
+    }
+    if (target.identityKeyFingerprint !== undefined &&
+        !/^SHA256:[A-Za-z0-9_-]{43}$/.test(target.identityKeyFingerprint)) {
+        throw new Error("Runtime target host returned an invalid identity fingerprint");
+    }
+    if (target.createdAt !== undefined &&
+        (!isBoundedPublicString(target.createdAt, 64) || !Number.isFinite(Date.parse(target.createdAt)))) {
+        throw new Error("Runtime target host returned an invalid creation timestamp");
+    }
+    return {
+        selector: target.selector,
+        daemonId: target.daemonId,
+        displayName: target.displayName,
+        binding: target.binding,
+        ...(target.endpoint === undefined ? {} : { endpoint: target.endpoint }),
+        ...(target.identityKeyFingerprint === undefined
+            ? {}
+            : { identityKeyFingerprint: target.identityKeyFingerprint }),
+        ...(target.createdAt === undefined ? {} : { createdAt: target.createdAt }),
+    };
+}
+function redactRuntimeTargetTestResult(result, requestedSelector) {
+    const target = redactRuntimeTargetView(result.target);
+    const status = redactDaemonStatus(result.status);
+    if (target.selector !== requestedSelector || target.daemonId !== status.daemonId) {
+        throw new Error("Runtime target host returned a mismatched test result");
+    }
+    return { target, status };
+}
+function redactRuntimeTargetPairResult(result) {
+    const target = redactRuntimeTargetView(result.target);
+    const status = redactDaemonStatus(result.status);
+    if (target.binding !== "direct" || target.daemonId !== status.daemonId) {
+        throw new Error("Runtime target host returned a mismatched pairing result");
+    }
+    return { target, status };
+}
+function redactDaemonStatus(status) {
+    return parseDaemonStatus(status);
+}
+function isSafeRuntimeEndpoint(value) {
+    if (!isBoundedPublicString(value, 2_048))
+        return false;
+    try {
+        const endpoint = new URL(value);
+        return ((endpoint.protocol === "ws:" || endpoint.protocol === "wss:") &&
+            Boolean(endpoint.hostname) &&
+            !endpoint.username &&
+            !endpoint.password &&
+            !endpoint.search &&
+            !endpoint.hash &&
+            endpoint.pathname === DIRECT_RUNTIME_CONTROL_PATH);
+    }
+    catch {
+        return false;
+    }
+}
+function isBoundedPublicString(value, maxChars) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= maxChars &&
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+function runtimeTargetHostError(ctx, error, forcedOutcome) {
+    const code = runtimeTargetErrorCode(error);
+    const status = runtimeTargetHttpStatus(code);
+    ctx.status = status;
+    const outcome = forcedOutcome ?? runtimeTargetErrorOutcome(error);
+    ctx.body = {
+        error: status === 500 ? "internal_error" : code,
+        ...(outcome === undefined ? {} : { outcome }),
+    };
+}
+function runtimeLocalBrowserError(ctx, error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? error.code
+        : undefined;
+    switch (code) {
+        case "invalid_request":
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        case "not_found":
+            ctx.status = 404;
+            ctx.body = { error: "not_found" };
+            return;
+        case "unavailable":
+        case "shutting_down":
+            ctx.status = 503;
+            ctx.body = { error: "unavailable" };
+            return;
+        case "host_failure":
+        case "outcome_unknown":
+            ctx.status = 502;
+            ctx.body = { error: "operation_failed" };
+            return;
+        default:
+            ctx.status = 500;
+            ctx.body = { error: "internal_error" };
+    }
+}
+function runtimeTargetHttpStatus(code) {
+    switch (code) {
+        case "invalid_offer":
+        case "invalid_target":
+        case "invalid_request":
+            return 400;
+        case "not_found":
+            return 404;
+        case "conflict":
+        case "failed_precondition":
+            return 409;
+        case "method_not_found":
+            return 501;
+        case "deadline_exceeded":
+            return 504;
+        case "unreachable":
+        case "tls_error":
+        case "identity_mismatch":
+        case "incompatible":
+        case "authentication_failed":
+        case "protocol_error":
+        case "operation_failed":
+        case "outcome_unknown":
+        case "unauthorized":
+        case "closed":
+        case "internal":
+            return 502;
+        default:
+            return 500;
+    }
+}
+function runtimeTargetErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return undefined;
+    return typeof error.code === "string" ? error.code : undefined;
+}
+function runtimeTargetErrorOutcome(error) {
+    if (!error || typeof error !== "object" || !("outcome" in error))
+        return undefined;
+    return error.outcome === "not_started" || error.outcome === "unknown"
+        ? error.outcome
+        : undefined;
+}
+function runtimeProtocolError(message) {
+    return Object.assign(new Error(message), { code: "protocol_error" });
+}
+function runtimeCapacityError(message) {
+    return Object.assign(new Error(message), { code: "operation_failed" });
+}
+function publicRuntimeStreamError(error) {
+    return runtimeTargetErrorCode(error) ?? "internal_error";
+}
+class RequestBodyTooLargeError extends Error {
+}
+async function readBoundedJson(ctx, maxBytes) {
+    const declaredLength = Number(ctx.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+        throw new RequestBodyTooLargeError(`request body exceeds ${maxBytes} bytes`);
+    }
+    const chunks = [];
+    let bytes = 0;
+    let tooLarge = false;
+    await new Promise((resolve, reject) => {
+        ctx.req.on("data", (chunk) => {
+            const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += data.byteLength;
+            if (bytes > maxBytes) {
+                tooLarge = true;
+                chunks.length = 0;
+                return;
+            }
+            if (!tooLarge)
+                chunks.push(data);
+        });
+        ctx.req.once("end", resolve);
+        ctx.req.once("error", reject);
+    });
+    if (tooLarge)
+        throw new RequestBodyTooLargeError(`request body exceeds ${maxBytes} bytes`);
+    if (bytes === 0)
+        throw new Error("request body is required");
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+    }
+    catch {
+        throw new Error("request body must be valid JSON");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("request body must be a JSON object");
+    }
+    return parsed;
+}
+function parsePluginCliInvocation(pluginId, body) {
+    const unknownFields = Object.keys(body).filter((key) => key !== "args" && key !== "stdin");
+    if (unknownFields.length > 0)
+        return "request body contains unknown fields";
+    if (!Array.isArray(body.args) || body.args.length === 0)
+        return "args must be a non-empty array";
+    if (body.args.length > PLUGIN_CLI_ARGS_MAX_COUNT) {
+        return `args exceeds ${PLUGIN_CLI_ARGS_MAX_COUNT} entries`;
+    }
+    let totalBytes = 0;
+    const args = [];
+    for (const value of body.args) {
+        if (typeof value !== "string" || value.includes("\0")) {
+            return "every arg must be a string without NUL bytes";
+        }
+        const bytes = Buffer.byteLength(value, "utf8");
+        if (bytes > PLUGIN_CLI_ARG_MAX_BYTES) {
+            return `one arg exceeds ${PLUGIN_CLI_ARG_MAX_BYTES} bytes`;
+        }
+        totalBytes += bytes;
+        if (totalBytes > PLUGIN_CLI_ARGS_TOTAL_MAX_BYTES) {
+            return `args exceed ${PLUGIN_CLI_ARGS_TOTAL_MAX_BYTES} bytes`;
+        }
+        args.push(value);
+    }
+    if (body.stdin !== undefined && typeof body.stdin !== "string")
+        return "stdin must be a string";
+    if (typeof body.stdin === "string" && Buffer.byteLength(body.stdin, "utf8") > PLUGIN_CLI_STDIN_MAX_BYTES) {
+        return `stdin exceeds ${PLUGIN_CLI_STDIN_MAX_BYTES} bytes`;
+    }
+    return {
+        pluginId,
+        args,
+        ...(typeof body.stdin === "string" ? { stdin: body.stdin } : {}),
+    };
+}
+function boundedUtf8(value, maxBytes) {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes)
+        return value;
+    const chars = [];
+    let bytes = 0;
+    for (const char of value) {
+        const next = Buffer.byteLength(char, "utf8");
+        if (bytes + next > maxBytes)
+            break;
+        chars.push(char);
+        bytes += next;
+    }
+    return chars.join("");
+}
 function asNumber(value) {
     if (typeof value === "number" && Number.isFinite(value))
         return value;