@rynx-ai/server 0.1.10 → 0.1.11-beta.10

package/dist/control-api.js

@@ -1,32 +1,21 @@
 /**
  * Control-plane HTTP surface: a JSON + SSE API (and the static console) for
- * managing **channels** (a plugin type + its credentials) and **instances** (a
- * channel bound to an agent), plus declarative agents. Mounted by
+ * managing plugins, declarative agents, skills, and sessions. Mounted by
  * {@link import("./server.js").createApp} only when control deps are injected.
  *
- * Channel and instance are separate objects:
- *  - a **channel** is configured/authorized on its own (`/api/channels` +
- *    `/api/channels/:id/authorize`); credentials live in its `options`.
- *  - an **instance** binds a channel to an agent (`/api/instances`); it's what
- *    the daemon mounts and runs.
- *
- * The server is channel-agnostic: available channel *types* (with their declared
- * config schema / authorize capability) come from {@link ControlPlaneDeps.listChannelTypes},
- * which the daemon derives from loaded plugins. Plugins themselves are managed
- * via the CLI, not here. The daemon owns the db-backed mutators (injected as
- * {@link ControlPlaneDeps}); the server owns the {@link ChannelManager}.
+ * Channel configuration and instances are deliberately absent: each plugin
+ * owns that state and exposes its own management application.
  */
 import { timingSafeEqual } from "node:crypto";
 import Router from "@koa/router";
-import { agentSpecSchema, newSessionId, skillInstallRecipeSchema, } from "@rynx-ai/core";
-import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactInstallInput, parseDaemonBrowserArtifactUpdateInput, parseDaemonChromeInspectionConfigureInput, parseDaemonCleanupSessionsInput, } from "@rynx-ai/protocol/control";
+import { skillInstallRecipeSchema, } from "@rynx-ai/core";
+import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_MAINTENANCE_LEASE_HEADER, DAEMON_MAINTENANCE_LEASE_RELEASE_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactInstallInput, parseDaemonBrowserArtifactUpdateInput, parseDaemonChromeInspectionConfigureInput, parseDaemonCleanupSessionsInput, } from "@rynx-ai/protocol/control";
 import { DIRECT_RUNTIME_CONTROL_PATH, encodePairingCode, } from "@rynx-ai/protocol/direct-runtime";
-import { PLUGIN_INSTALL_PREPARATIONS_PATH, parsePluginInstallCommitInput, parsePluginInstallPrepareInput, } from "@rynx-ai/protocol/plugin-management";
+import { PLUGIN_CONSOLE_INSTALL_PREPARATIONS_PATH, PLUGIN_CONSOLE_MARKETPLACES_PATH, PLUGIN_INSTALL_PREPARATIONS_PATH, PLUGIN_MARKETPLACES_PATH, parsePluginInstallCommitInput, parsePluginInstallPrepareInput, parsePluginMarketplaceAddInput, } from "@rynx-ai/protocol/plugin-management";
 import { parseDaemonStatus } from "@rynx-ai/protocol/remote-runtime";
 import { materializeRemoteRuntimeSessionEvent, materializeRemoteRuntimeSessionRuntimeSnapshot, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, SESSION_IMAGE_MEDIA_TYPES, SESSION_RESOURCE_MAX_IMAGE_BYTES, SESSION_RESOURCE_MAX_FILENAME_CHARS, SESSION_RESOURCE_TRANSFER_CHUNK_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";
@@ -40,6 +29,8 @@ const PLUGIN_CLI_TIMEOUT_MS = 120_000;
 const PLUGIN_INSTALL_BODY_MAX_BYTES = 16 * 1024;
 const PLUGIN_INSTALL_OPERATION_TIMEOUT_MS = 15 * 60_000;
 const PLUGIN_INSTALL_ERROR_MAX_BYTES = 16 * 1024;
+const PLUGIN_SETTINGS_UI_BODY_MAX_BYTES = 1024 * 1024;
+const CANONICAL_PLUGIN_ID_PATTERN = /^[a-z][a-z0-9-]{0,62}@[a-z0-9][a-z0-9-]{0,62}(?:\/[a-z0-9][a-z0-9._-]{0,99})?$/;
 const BROWSER_ARTIFACT_BODY_MAX_BYTES = 4 * 1024;
 const BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS = 15 * 60_000;
 const BROWSER_ARTIFACT_ERROR_MAX_BYTES = 16 * 1024;
@@ -74,7 +65,7 @@ const RUNTIME_BROWSER_RPC_METHODS = new Set([
     "browser.page.reload",
 ]);
 export function createControlRouter(opts) {
-    const { manager, deps, runtime, sessionBus, sessionLog, runnerManager, sessionStore, pluginRuntimeStatus, pluginRuntimeReload, pluginRuntimeEnsure, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeWebAccess, runtimeConnectionResolver, localSessionResources, sessionEmulators, shutdownSignal, sessionRuntimeIndex = new SessionRuntimeIndex(), sessionLifecycle, runtimeLocalBrowser, providerClis, } = opts;
+    const { deps, runtime, sessionBus, sessionLog, runnerManager, pluginRuntimeStatus, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeWebAccess, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, shutdownSignal, sessionRuntimeIndex = new SessionRuntimeIndex(), sessionLifecycle, runtimeLocalBrowser, providerClis, } = opts;
     const router = new Router();
     const mutateBrowserArtifact = async (ctx, operation) => {
         const host = daemonManagement?.browserArtifacts;
@@ -137,8 +128,6 @@ export function createControlRouter(opts) {
             invocation.dispose();
         }
     };
-    /** 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");
@@ -689,6 +678,37 @@ export function createControlRouter(opts) {
             lease.release();
         }
     };
+    const runtimeSessionSnapshotPage = async (ctx) => {
+        const lease = await acquireRuntimeLease(ctx);
+        if (!lease)
+            return;
+        const sessionId = ctx.params.id;
+        const afterId = optionalRuntimeString(ctx.query.afterId);
+        if (ctx.query.afterId !== undefined && afterId === undefined) {
+            lease.release();
+            ctx.status = 400;
+            ctx.body = { error: "invalid_request" };
+            return;
+        }
+        try {
+            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");
+            }
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = page;
+        }
+        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)
@@ -704,6 +724,27 @@ export function createControlRouter(opts) {
         if (outcome.ok)
             ctx.body = outcome.result;
     };
+    const runtimeSessionExecutionSettings = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "session.execution.get", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionExecutionSettingsUpdate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["model", "reasoningEffort"]))
+            return;
+        const outcome = await runtimeCall(ctx, "session.execution.update", {
+            sessionId: ctx.params.id,
+            model: body.model,
+            reasoningEffort: body.reasoningEffort,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
     const runtimeSessionCreate = async (ctx) => {
         const body = await readRuntimeBody(ctx);
         if (!body)
@@ -712,6 +753,68 @@ export function createControlRouter(opts) {
         if (outcome.ok)
             ctx.body = outcome.result;
     };
+    const runtimeSessionFork = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["operationId", "title"]))
+            return;
+        const outcome = await runtimeCall(ctx, "session.fork", {
+            sourceSessionId: ctx.params.id,
+            operationId: body.operationId,
+            ...(typeof body.title === "string" ? { title: body.title } : {}),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeProjects = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "project.list", {});
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeProject = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "project.get", {
+            projectId: ctx.params.projectId,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeProjectCreate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["name", "directories", "primary"]))
+            return;
+        const outcome = await runtimeCall(ctx, "project.create", {
+            name: body.name,
+            directories: body.directories,
+            primary: body.primary,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeProjectUpdate = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["name", "directories", "primary"]))
+            return;
+        const outcome = await runtimeCall(ctx, "project.update", {
+            projectId: ctx.params.projectId,
+            name: body.name,
+            directories: body.directories,
+            primary: body.primary,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeProjectDelete = async (ctx) => {
+        const outcome = await runtimeCall(ctx, "project.delete", {
+            projectId: ctx.params.projectId,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
     const runtimeSessionMessage = async (ctx) => {
         const body = await readRuntimeBody(ctx);
         if (!body)
@@ -1623,10 +1726,19 @@ export function createControlRouter(opts) {
     // 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/projects", publicRuntimeRead(runtimeProjects));
+    router.get("/api/runtimes/:selector/projects/:projectId", publicRuntimeRead(runtimeProject));
+    router.post("/api/runtimes/:selector/projects", publicRuntimeMutation(runtimeProjectCreate));
+    router.put("/api/runtimes/:selector/projects/:projectId", publicRuntimeMutation(runtimeProjectUpdate));
+    router.delete("/api/runtimes/:selector/projects/:projectId", publicRuntimeMutation(runtimeProjectDelete));
     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.post("/api/runtimes/:selector/sessions/:id/fork", publicRuntimeMutation(runtimeSessionFork));
+    router.get("/api/runtimes/:selector/sessions/:id/execution", publicRuntimeRead(runtimeSessionExecutionSettings));
+    router.put("/api/runtimes/:selector/sessions/:id/execution", publicRuntimeMutation(runtimeSessionExecutionSettingsUpdate));
     router.get("/api/runtimes/:selector/sessions/:id/snapshot", publicRuntimeRead(runtimeSessionSnapshot));
+    router.get("/api/runtimes/:selector/sessions/:id/snapshot-page", publicRuntimeRead(runtimeSessionSnapshotPage));
     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));
@@ -1801,7 +1913,6 @@ export function createControlRouter(opts) {
     });
     router.get("/api/meta", (ctx) => {
         const meta = {
-            channelTypes: deps.listChannelTypes().map((t) => t.type),
             ...(daemonManagement?.buildStatus
                 ? { daemonBuild: daemonManagement.buildStatus() }
                 : {}),
@@ -1830,18 +1941,42 @@ export function createControlRouter(opts) {
             return;
         ctx.body = encodeDaemonStatus(remoteRuntime.status());
     });
-    router.post(DAEMON_SHUTDOWN_IF_IDLE_PATH, (ctx) => {
+    router.post(DAEMON_SHUTDOWN_IF_IDLE_PATH, async (ctx) => {
         if (!isConfiguredDaemonManagement(daemonManagement) ||
             !daemonManagement.shutdownIfIdle) {
             return notFound(ctx, "daemon shutdown management is not configured");
         }
         if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
             return;
-        const result = daemonManagement.shutdownIfIdle();
+        const maintenanceLeaseToken = ctx.get(DAEMON_MAINTENANCE_LEASE_HEADER).trim() || undefined;
+        let result;
+        try {
+            result = await daemonManagement.shutdownIfIdle(maintenanceLeaseToken);
+        }
+        catch (error) {
+            ctx.set("Cache-Control", "no-store");
+            ctx.status = 409;
+            ctx.body = {
+                error: error instanceof Error ? error.message : String(error),
+            };
+            return;
+        }
         ctx.set("Cache-Control", "no-store");
         ctx.status = result.outcome === "accepted" ? 202 : 409;
         ctx.body = result;
     });
+    router.post(DAEMON_MAINTENANCE_LEASE_RELEASE_PATH, (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement)
+            || !daemonManagement.releaseMaintenanceLease) {
+            return notFound(ctx, "daemon maintenance lease management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const result = daemonManagement.releaseMaintenanceLease(ctx.get(DAEMON_MAINTENANCE_LEASE_HEADER).trim());
+        ctx.set("Cache-Control", "no-store");
+        ctx.status = result.outcome === "denied" ? 403 : 200;
+        ctx.body = result;
+    });
     router.post(DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, async (ctx) => {
         await mutateBrowserArtifact(ctx, "install");
     });
@@ -2014,6 +2149,360 @@ export function createControlRouter(opts) {
         ctx.set("Cache-Control", "no-store");
         ctx.body = await daemonManagement.pluginManagement.listPlugins();
     });
+    // Public same-origin console view. It contains metadata only; package paths,
+    // source URLs, package-private metadata, and credentials are not exposed.
+    router.get("/api/plugins", async (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleReadRequest(ctx, runtimeWebAccess))
+            return;
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = await daemonManagement.pluginManagement.listPlugins();
+    });
+    router.get(PLUGIN_CONSOLE_MARKETPLACES_PATH, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!requireConsoleReadRequest(ctx, runtimeWebAccess))
+            return;
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = { marketplaces: await daemonManagement.pluginMarketplaces.list() };
+    });
+    router.post(PLUGIN_CONSOLE_MARKETPLACES_PATH, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!requireConsoleJsonRequest(ctx, "Market registration", runtimeWebAccess))
+            return;
+        let input;
+        try {
+            input = parsePluginMarketplaceAddInput(await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.status = 201;
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await daemonManagement.pluginMarketplaces.add(input, {
+                signal: invocation.signal,
+            });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.post(`${PLUGIN_CONSOLE_MARKETPLACES_PATH}/:id/refresh`, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!requireConsoleJsonRequest(ctx, "Market refresh", runtimeWebAccess))
+            return;
+        try {
+            await readBoundedJson(ctx, 1024);
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await daemonManagement.pluginMarketplaces.refresh(ctx.params.id, { signal: invocation.signal });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.delete(`${PLUGIN_CONSOLE_MARKETPLACES_PATH}/:id`, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!requireConsoleRequest(ctx, "Market removal", runtimeWebAccess))
+            return;
+        try {
+            const removed = await daemonManagement.pluginMarketplaces.remove(ctx.params.id);
+            if (!removed)
+                return notFound(ctx, `marketplace "${ctx.params.id}" not found`);
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = { removed: true };
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+    });
+    router.post(PLUGIN_CONSOLE_INSTALL_PREPARATIONS_PATH, async (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleJsonRequest(ctx, "Plugin installation preparation", runtimeWebAccess))
+            return;
+        let input;
+        try {
+            input = parsePluginInstallPrepareInput(await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.status = 201;
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await daemonManagement.pluginManagement.prepareInstallation(input, { signal: invocation.signal });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.post(`${PLUGIN_CONSOLE_INSTALL_PREPARATIONS_PATH}/:token/commit`, async (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleJsonRequest(ctx, "Plugin installation commit", runtimeWebAccess))
+            return;
+        const token = ctx.params.token;
+        if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) {
+            return bad(ctx, "invalid plugin preparation token");
+        }
+        let input;
+        try {
+            input = parsePluginInstallCommitInput(await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await daemonManagement.pluginManagement.commitInstallation(token, input, { signal: invocation.signal });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.delete(`${PLUGIN_CONSOLE_INSTALL_PREPARATIONS_PATH}/:token`, async (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleRequest(ctx, "Plugin installation cancellation", runtimeWebAccess))
+            return;
+        const token = ctx.params.token;
+        if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) {
+            return bad(ctx, "invalid plugin preparation token");
+        }
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = {
+            cancelled: await daemonManagement.pluginManagement.cancelPreparation(token),
+        };
+    });
+    for (const [action, enabled] of [["enable", true], ["disable", false]]) {
+        router.post(`/api/plugins/:pluginId/${action}`, async (ctx) => {
+            if (!daemonManagement?.pluginManagement) {
+                return notFound(ctx, "plugin management is not configured");
+            }
+            const pluginId = ctx.params.pluginId;
+            if (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId))
+                return bad(ctx, "invalid plugin identity");
+            if (!requireConsoleJsonRequest(ctx, `Plugin ${action}`, runtimeWebAccess))
+                return;
+            try {
+                await readBoundedJson(ctx, 1024);
+                const plugin = await daemonManagement.pluginManagement.setPluginEnabled(pluginId, enabled);
+                if (!plugin)
+                    return notFound(ctx, `plugin "${pluginId}" not found`);
+                ctx.set("Cache-Control", "no-store");
+                ctx.body = { plugin };
+            }
+            catch (error) {
+                ctx.status = 409;
+                ctx.body = {
+                    error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES),
+                };
+            }
+        });
+    }
+    router.get("/api/plugins/:pluginId/settings-ui", (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleReadRequest(ctx, runtimeWebAccess))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId))
+            return bad(ctx, "invalid plugin identity");
+        try {
+            const ui = daemonManagement.pluginManagement.settingsUi(pluginId);
+            if (!ui)
+                return notFound(ctx, `plugin "${pluginId}" has no settings UI`);
+            const assetBasePath = `/api/plugins/${encodeURIComponent(pluginId)}/settings-ui-assets/` +
+                `${ui.assetGeneration}/`;
+            const assetBaseUrl = new URL(assetBasePath, ctx.href).href;
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = {
+                generation: ui.generation,
+                html: withSettingsUiDocumentSecurity(ui.html, assetBaseUrl),
+            };
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+    router.get("/api/plugins/:pluginId/settings-ui-assets/:assetGeneration/*assetPath", (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleReadRequest(ctx, runtimeWebAccess))
+            return;
+        const pluginId = ctx.params.pluginId;
+        const assetGeneration = ctx.params.assetGeneration;
+        const assetPath = ctx.params.assetPath;
+        if (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId)) {
+            return bad(ctx, "invalid plugin identity");
+        }
+        if (!/^[A-Za-z0-9_-]{43}$/.test(assetGeneration) || typeof assetPath !== "string") {
+            return bad(ctx, "invalid plugin settings UI asset");
+        }
+        try {
+            const asset = daemonManagement.pluginManagement.settingsUiAsset(pluginId, assetGeneration, assetPath);
+            if (!asset)
+                return notFound(ctx, "plugin settings UI asset not found");
+            ctx.set("Access-Control-Allow-Origin", "*");
+            ctx.set("Cache-Control", "private, max-age=31536000, immutable");
+            ctx.set("Cross-Origin-Resource-Policy", "cross-origin");
+            ctx.set("X-Content-Type-Options", "nosniff");
+            ctx.set("Content-Type", asset.contentType);
+            ctx.body = asset.data;
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    });
+    router.post("/api/plugins/:pluginId/settings", async (ctx) => {
+        if (!daemonManagement?.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!requireConsoleJsonRequest(ctx, "Plugin settings call", runtimeWebAccess))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId))
+            return bad(ctx, "invalid plugin identity");
+        let body;
+        try {
+            body = await readBoundedJson(ctx, PLUGIN_SETTINGS_UI_BODY_MAX_BYTES);
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const generation = asString(body.generation);
+        const method = asString(body.method);
+        if (!generation || !method || !/^[A-Za-z][A-Za-z0-9._:-]{0,127}$/.test(method)) {
+            return bad(ctx, "plugin settings generation and method are required");
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            const result = await daemonManagement.pluginManagement.callSettings(pluginId, generation, method, body.params, { signal: invocation.signal });
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = { result };
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.get(PLUGIN_MARKETPLACES_PATH, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces ||
+            !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        ctx.body = { marketplaces: await daemonManagement.pluginMarketplaces.list() };
+    });
+    router.post(PLUGIN_MARKETPLACES_PATH, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces ||
+            !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const body = await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES);
+        const source = asString(body.source);
+        const alias = asString(body.alias);
+        if (!source)
+            return bad(ctx, "marketplace source is required");
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.status = 201;
+            ctx.body = await daemonManagement.pluginMarketplaces.add({ source, ...(alias ? { alias } : {}) }, { signal: invocation.signal });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.post(`${PLUGIN_MARKETPLACES_PATH}/:id/refresh`, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces ||
+            !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.body = await daemonManagement.pluginMarketplaces.refresh(ctx.params.id, { signal: invocation.signal });
+        }
+        catch (error) {
+            ctx.status = invocation.signal.aborted ? 504 : 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.delete(`${PLUGIN_MARKETPLACES_PATH}/:id`, async (ctx) => {
+        if (!daemonManagement?.pluginMarketplaces ||
+            !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "plugin marketplace management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        try {
+            const removed = await daemonManagement.pluginMarketplaces.remove(ctx.params.id);
+            if (!removed)
+                return notFound(ctx, `marketplace "${ctx.params.id}" not found`);
+            ctx.body = { removed: true };
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES) };
+        }
+    });
     router.post(PLUGIN_INSTALL_PREPARATIONS_PATH, async (ctx) => {
         if (!isConfiguredDaemonManagement(daemonManagement) ||
             !daemonManagement.pluginManagement) {
@@ -2140,8 +2629,8 @@ export function createControlRouter(opts) {
         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 (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId)) {
+            return bad(ctx, "invalid plugin identity");
         }
         try {
             const uninstalled = await daemonManagement.pluginManagement.uninstallPlugin(pluginId);
@@ -2162,8 +2651,8 @@ export function createControlRouter(opts) {
         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 (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId)) {
+            return bad(ctx, "invalid plugin identity");
         }
         if (!ctx.is("application/json")) {
             ctx.status = 415;
@@ -2214,8 +2703,8 @@ export function createControlRouter(opts) {
         if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
             return;
         const pluginId = ctx.params.pluginId;
-        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
-            bad(ctx, "invalid plugin id");
+        if (!CANONICAL_PLUGIN_ID_PATTERN.test(pluginId)) {
+            bad(ctx, "invalid plugin identity");
             return;
         }
         try {
@@ -2232,42 +2721,6 @@ export function createControlRouter(opts) {
             ctx.body = { error: error instanceof Error ? error.message : String(error) };
         }
     }
-    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)
@@ -2277,153 +2730,18 @@ export function createControlRouter(opts) {
             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() };
-    });
-    // ── channels ───────────────────────────────────────────────────────────
-    router.get("/api/channels", (ctx) => {
-        ctx.body = {
-            channels: deps.listChannels().map((c) => ({
-                id: c.id,
-                name: c.name,
-                type: c.type,
-                options: redact(deps, c.type, c.options),
-            })),
-        };
-    });
-    router.post("/api/channels", async (ctx) => {
-        const body = await readJson(ctx);
-        const name = asString(body.name);
-        const type = asString(body.type);
-        if (!name)
-            return bad(ctx, "missing channel name");
-        if (!type)
-            return bad(ctx, "missing channel type");
-        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);
-        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);
-        ctx.body = { ok: true };
-    });
-    router.delete("/api/channels/:id", async (ctx) => {
-        const id = ctx.params.id;
-        const bound = instanceForChannel(id);
-        if (bound)
-            await manager.stopInstance(bound.id); // its row cascades on channel delete
-        deps.removeChannel(id);
-        ctx.body = { ok: true };
-    });
-    // Authorize (config mode 2): run the channel type's flow over SSE, persist the
-    // resolved options on the channel, reload the bound instance (if any).
-    router.post("/api/channels/:id/authorize", async (ctx) => {
-        const id = ctx.params.id;
-        const channel = deps.listChannels().find((c) => c.id === id);
-        if (!channel)
-            return notFound(ctx, "channel not found");
-        await streamEvents(ctx, async (send, signal) => {
-            send("status", { text: `authorizing ${channel.type}…` });
-            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) => {
-        const statuses = new Map(manager.list().map((status) => [status.instanceId, status]));
-        const instances = deps.listInstancesConfig().map((inst) => {
-            const status = statuses.get(inst.id);
-            return {
-                id: inst.id,
-                channelId: inst.channelId,
-                channelName: inst.channelName,
-                type: inst.type,
-                agent: inst.agent,
-                enabled: inst.enabled,
-                running: status?.running ?? false,
-                connected: status?.connected ?? null,
-                lastError: status?.lastError ?? null,
-                lastEventAt: status?.lastEventAt ?? null,
-            };
-        });
-        ctx.body = { instances };
-    });
-    router.post("/api/instances", async (ctx) => {
-        const body = await readJson(ctx);
-        const channelId = asString(body.channelId);
-        if (!channelId)
-            return bad(ctx, "missing channelId");
-        let id;
-        try {
-            ({ id } = deps.createInstance({ channelId, agent: asString(body.agent) }));
-        }
-        catch (error) {
-            return bad(ctx, error instanceof Error ? error.message : String(error));
-        }
-        await manager.reloadInstance(id);
-        ctx.body = { ok: true, id };
-    });
-    router.put("/api/instances/:id", async (ctx) => {
-        const id = ctx.params.id;
-        const body = await readJson(ctx);
-        deps.setInstance(id, {
-            ...(body.agent !== undefined ? { agent: asString(body.agent) } : {}),
-            ...(body.enabled !== undefined ? { enabled: Boolean(body.enabled) } : {}),
-        });
-        await manager.reloadInstance(id);
-        ctx.body = { ok: true };
-    });
-    router.post("/api/instances/:id/enable", async (ctx) => {
-        const id = ctx.params.id;
-        deps.setInstance(id, { enabled: true });
-        await manager.startInstance(id);
-        ctx.body = { ok: true };
-    });
-    router.post("/api/instances/:id/disable", async (ctx) => {
-        const id = ctx.params.id;
-        deps.setInstance(id, { enabled: false });
-        await manager.stopInstance(id);
-        ctx.body = { ok: true };
-    });
-    router.post("/api/instances/:id/restart", async (ctx) => {
-        await manager.reloadInstance(ctx.params.id);
-        ctx.body = { ok: true };
-    });
-    router.delete("/api/instances/:id", async (ctx) => {
-        const id = ctx.params.id;
-        await manager.stopInstance(id);
-        deps.removeInstance(id);
-        ctx.body = { ok: true };
-    });
     // ── agents ─────────────────────────────────────────────────────────────
     router.get("/api/agents", async (ctx) => {
         ctx.body = { agents: await deps.listAgents() };
     });
+    router.get("/api/agents/runtime-options", async (ctx) => {
+        if (!deps.listAgentRuntimeOptions)
+            return notFound(ctx, "local runtime discovery is unavailable");
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = {
+            runtimes: await deps.listAgentRuntimeOptions({ refresh: asString(ctx.query.refresh) === "1" }),
+        };
+    });
     router.get("/api/agents/:id", async (ctx) => {
         const spec = await deps.getAgent(ctx.params.id);
         if (!spec)
@@ -2436,6 +2754,11 @@ export function createControlRouter(opts) {
         if (!id)
             return bad(ctx, "missing agent id");
         try {
+            if (await deps.getAgent(id)) {
+                ctx.status = 409;
+                ctx.body = { error: "agent id already exists" };
+                return;
+            }
             deps.writeAgent(id, body);
         }
         catch (error) {
@@ -2443,6 +2766,19 @@ export function createControlRouter(opts) {
         }
         ctx.body = { ok: true };
     });
+    router.put("/api/agents/:id", async (ctx) => {
+        const id = ctx.params.id;
+        const body = await readJson(ctx);
+        if (!await deps.getAgent(id))
+            return notFound(ctx, "agent not found");
+        try {
+            deps.writeAgent(id, { ...body, id });
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        ctx.body = { ok: true };
+    });
     router.delete("/api/agents/:id", (ctx) => {
         ctx.body = { ok: deps.removeAgent(ctx.params.id) };
     });
@@ -2482,6 +2818,64 @@ export function createControlRouter(opts) {
             return bad(ctx, error instanceof Error ? error.message : String(error));
         }
     });
+    router.post("/api/skills/local-scan", async (ctx) => {
+        if (!deps.scanLocalSkills)
+            return notFound(ctx, "local Skill discovery is unavailable");
+        const body = await readJson(ctx);
+        const runtime = parseProviderCliId(body.runtime);
+        if (!runtime)
+            return bad(ctx, "runtime must be codex, traex, or claude");
+        try {
+            ctx.body = { candidates: await deps.scanLocalSkills(runtime) };
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+    });
+    router.post("/api/skills/local-import", async (ctx) => {
+        if (!deps.importLocalSkills)
+            return notFound(ctx, "local Skill import is unavailable");
+        const body = await readJson(ctx);
+        const runtime = parseProviderCliId(body.runtime);
+        const rawKeys = Array.isArray(body.keys) ? body.keys : [];
+        const keys = rawKeys.length > 0
+            ? rawKeys.filter((value) => typeof value === "string" && value.length > 0)
+            : [];
+        if (!runtime)
+            return bad(ctx, "runtime must be codex, traex, or claude");
+        if (keys.length === 0 || keys.length !== rawKeys.length || keys.length > 100) {
+            return bad(ctx, "keys must contain 1-100 non-empty candidate keys");
+        }
+        try {
+            ctx.body = { results: await deps.importLocalSkills(runtime, keys) };
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+    });
+    router.post("/api/skills/import-archive", async (ctx) => {
+        if (!deps.importSkillArchive)
+            return notFound(ctx, "Skill archive import is unavailable");
+        let body;
+        try {
+            body = await readJson(ctx, 29 * 1024 * 1024);
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const filename = asString(body.filename);
+        const contentBase64 = asString(body.contentBase64);
+        if (!filename || !contentBase64)
+            return bad(ctx, "filename and contentBase64 are required");
+        if (contentBase64.length > 28 * 1024 * 1024)
+            return bad(ctx, "archive payload is too large");
+        try {
+            ctx.body = { results: await deps.importSkillArchive(filename, contentBase64) };
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+    });
     router.delete("/api/skills/:name", async (ctx) => {
         try {
             ctx.body = { ok: await deps.removeSkill(ctx.params.name) };
@@ -2802,8 +3196,7 @@ export function createControlRouter(opts) {
             const updatedAt = log ? new Date(log.updatedAt).toISOString() : (meta?.updatedAt ?? createdAt);
             return {
                 id,
-                provider: meta?.provider,
-                agent: meta?.agent,
+                provider: meta?.execution?.provider,
                 title: meta?.title,
                 status: sessionRuntimeIndex.snapshot(id).status,
                 createdAt,
@@ -2815,134 +3208,90 @@ export function createControlRouter(opts) {
         ctx.body = { sessions };
     });
     router.post("/api/sessions", async (ctx) => {
-        if (!runtime)
-            return bad(ctx, "session runs are not available on this server");
+        if (!localMachineSessions) {
+            return bad(ctx, "session creation is unavailable on this server");
+        }
         const body = await readJson(ctx);
         const agent = asString(body.agent);
-        let config;
+        const provider = asString(body.provider);
+        const permissionPreset = parseSessionPermissionPreset(body.permissionPreset);
         if (body.config != null) {
-            const parsed = agentSpecSchema.safeParse(body.config);
-            if (!parsed.success) {
-                return bad(ctx, `invalid config: ${parsed.error.issues.map((i) => i.message).join("; ")}`);
-            }
-            config = parsed.data;
-        }
-        if (!agent && !config)
-            return bad(ctx, "provide an agent id or an inline config");
-        const id = newSessionId();
-        deps.createSessionMeta({
-            id,
-            source: "console",
-            agent,
-            config,
-            model: asString(body.model),
-            reasoningEffort: asString(body.reasoningEffort),
-            title: asString(body.title),
-            createdAt: new Date().toISOString(),
-        });
-        ctx.body = { sessionId: id };
+            return bad(ctx, "inline Agent configs are no longer supported; save an Agent first");
+        }
+        if (Boolean(agent) === Boolean(provider)) {
+            return bad(ctx, "provide exactly one Agent or Provider");
+        }
+        if (body.permissionPreset !== undefined && !permissionPreset) {
+            return bad(ctx, "permissionPreset must be default, read-only, workspace-write, or full-access");
+        }
+        try {
+            ctx.body = await localMachineSessions.create({
+                ...(agent ? { agent } : { provider: provider }),
+                ...(asString(body.model) ? { model: asString(body.model) } : {}),
+                ...(asString(body.reasoningEffort)
+                    ? { reasoningEffort: asString(body.reasoningEffort) }
+                    : {}),
+                ...(permissionPreset ? { permissionPreset } : {}),
+                ...(asString(body.title) ? { title: asString(body.title) } : {}),
+                ...(asString(body.projectId) ? { projectId: asString(body.projectId) } : {}),
+            });
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
     });
     router.post("/api/sessions/:id/messages", async (ctx) => {
         const id = ctx.params.id;
-        if (!runtime)
-            return bad(ctx, "session runs are not available on this server");
         const body = await readJson(ctx);
         const message = asString(body.message);
         if (!message)
             return bad(ctx, "missing message");
-        const meta = deps.getSessionMeta(id);
-        // A console session carries its agent/config inline. Any other session — a
-        // channel session, or one only in the canonical log — resumes on the runtime
-        // binding recorded in the shared store (its original runtime/model/cwd). The
-        // turn lands in the same canonical log + LLM session, so the channel sees it
-        // in history — but no card is pushed (channels don't subscribe to the bus).
-        const consoleMeta = meta?.source === "console" ? meta : undefined;
-        const bound = consoleMeta ? null : ((await sessionStore?.get(id)) ?? null);
-        if (!meta && !bound)
-            return notFound(ctx, "session not found");
-        // 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));
-        // codex-native live mode (single writer): bring up the session's persistent
-        // forwarder + TUI, then INJECT this turn into the shared app-server thread
-        // (turn/start | turn/steer) and return immediately. The forwarder mirrors the
-        // output onto the bus; the web renders it from the persistent `/stream`. No
-        // per-`/messages` normalize/persist here — that would double-write the turn.
-        if (runnerManager?.ensureLiveSession && runnerManager.injectMessage) {
-            // Resolve the session's runtime from its agent spec (as the run path does),
-            // so live co-drive picks the right backend PER AGENT — the live path
-            // bypasses ConversationRuntime's own resolution, so without this it would
-            // fall back to the global default and mis-route (e.g. a claude agent onto codex).
-            const liveRuntime = await runtime.resolveRuntime({
-                agentName: consoleMeta?.agent,
-                agentSpec: consoleMeta?.config,
-                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
-            // when the rollout already exists (the normal single-machine case). The bound
-            // thread record is fetched directly — `bound` above is null for console
-            // sessions, but a console session still resumes a stored codex thread.
-            if ((liveRuntime === "codex" || liveRuntime === "traex") && sessionLog) {
-                const codexRecord = await sessionStore?.get(id);
-                if (codexRecord?.codexSessionId) {
-                    ensureCodexResumeRollout({
-                        // `id` (the rynx localThreadId) resolves the per-session CODEX_HOME —
-                        // the SAME id the runner child gets via `RYNX_RUNNER_SESSION`, so the
-                        // synthesized rollout lands where that session's app-server reads.
-                        sessionId: id,
-                        runtime: liveRuntime,
-                        threadId: codexRecord.codexSessionId,
-                        cwd: codexRecord.cwd ?? process.cwd(),
-                        items: await sessionLog.snapshot(id),
-                    });
-                }
+        if (localMachineSessions) {
+            try {
+                ctx.body = await localMachineSessions.sendMessage(id, message);
             }
-            const live = await runnerManager.ensureLiveSession(id, {
-                ...(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.
-                ...(consoleMeta?.agent ? { agentName: consoleMeta.agent } : {}),
-                ...(consoleMeta?.config ? { agentSpec: consoleMeta.config } : {}),
-            });
-            if (!live) {
-                // A live-runtime (codex/claude-native) session whose forwarder couldn't come
-                // 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);
+            catch (error) {
                 ctx.status = 503;
-                ctx.body = {
-                    error: `live session unavailable (${liveRuntime})`,
-                    ...(detail ? { detail } : {}),
-                };
-                return;
-            }
-            const outcome = await runnerManager.injectMessage(id, message);
-            if (outcome === "injected") {
-                ctx.body = { ok: true, injected: true };
-                return;
+                ctx.body = { error: error instanceof Error ? error.message : String(error) };
             }
-            // notLive / notReady / failed → hard error. NEVER fall through to run+stream:
-            // the second path would double-write the turn alongside the forwarder
-            // (reference implementation: inject failure ⇒ response.failed, no local re-run).
+            return;
+        }
+        const meta = deps.getSessionMeta(id);
+        if (!meta)
+            return notFound(ctx, "session not found");
+        if (!meta.title)
+            deps.setSessionTitle(id, synthesizeSessionTitle(message));
+        if (!runnerManager?.ensureLiveSession || !runnerManager.injectMessage) {
             ctx.status = 503;
-            ctx.body = { error: `live injection ${outcome}` };
+            ctx.body = { error: "session runs require a live runner" };
+            return;
+        }
+        const live = await runnerManager.ensureLiveSession(id, {
+            workspace: structuredClone(meta.workspace),
+            execution: structuredClone(meta.execution),
+        });
+        if (!live) {
+            ctx.status = 503;
+            ctx.body = {
+                error: `live session unavailable (${meta.execution.provider})`,
+                ...(runnerManager.lastLiveSessionError?.(id)
+                    ? { detail: runnerManager.lastLiveSessionError(id) }
+                    : {}),
+            };
+            return;
+        }
+        const outcome = await runnerManager.injectMessage(id, message);
+        if (outcome === "injected") {
+            ctx.body = { ok: true, injected: true };
             return;
         }
-        // Native-only: a turn can only run on a live runner (codex app-server / claude
-        // TUI). With no runner there is nothing to inject into, and there is no non-live
-        // programmatic fallback (that path was removed) — report + stop.
         ctx.status = 503;
-        ctx.body = { error: "session runs require a live runner" };
+        ctx.body = {
+            error: `live injection ${outcome}`,
+            ...(runnerManager.lastLiveSessionError?.(id)
+                ? { detail: runnerManager.lastLiveSessionError(id) }
+                : {}),
+        };
     });
     // Stop the session's active turn (the web Stop button). For a live native
     // session this interrupts the running turn at its source — codex app-server
@@ -3162,11 +3511,28 @@ export function synthesizeSessionTitle(message, limit = 60) {
         return collapsed;
     return `${collapsed.slice(0, limit - 1).trimEnd()}…`;
 }
-async function readJson(ctx) {
+async function readJson(ctx, maxBytes) {
     const raw = await new Promise((resolve, reject) => {
         let data = "";
-        ctx.req.on("data", (chunk) => (data += chunk));
-        ctx.req.on("end", () => resolve(data));
+        let bytes = 0;
+        let exceeded = false;
+        ctx.req.on("data", (chunk) => {
+            if (exceeded)
+                return;
+            bytes += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.byteLength;
+            if (maxBytes !== undefined && bytes > maxBytes) {
+                exceeded = true;
+                data = "";
+                return;
+            }
+            data += chunk;
+        });
+        ctx.req.on("end", () => {
+            if (exceeded)
+                reject(new Error("request body is too large"));
+            else
+                resolve(data);
+        });
         ctx.req.on("error", reject);
     });
     if (!raw.trim())
@@ -3179,23 +3545,6 @@ async function readJson(ctx) {
         return {};
     }
 }
-/**
- * Mask secret-ish option values so the page never echoes credentials back. A
- * value is masked when its key is a `type: "secret"` field in the channel type's
- * declared schema, or matches the secret-name heuristic as a fallback.
- */
-function redact(deps, type, options) {
-    if (!options)
-        return undefined;
-    const schema = deps.listChannelTypes().find((t) => t.type === type)?.configSchema;
-    const secretKeys = new Set((schema ?? []).filter((f) => f.type === "secret").map((f) => f.key));
-    const out = {};
-    for (const [key, value] of Object.entries(options)) {
-        const secret = secretKeys.has(key) || /secret|token|key/i.test(key);
-        out[key] = secret && value ? "***" : value;
-    }
-    return out;
-}
 function asString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -3204,6 +3553,14 @@ function parseProviderCliId(value) {
         ? value
         : undefined;
 }
+function parseSessionPermissionPreset(value) {
+    return value === "default" ||
+        value === "read-only" ||
+        value === "workspace-write" ||
+        value === "full-access"
+        ? value
+        : undefined;
+}
 function parseProviderCliOperation(value) {
     return value === "install" || value === "update" ? value : undefined;
 }
@@ -3359,6 +3716,63 @@ function namedError(message, name) {
     error.name = name;
     return error;
 }
+function withSettingsUiDocumentSecurity(html, assetBaseUrl) {
+    const source = assetBaseUrl.replace(/["&<>]/g, encodeURIComponent);
+    const csp = [
+        "default-src 'none'",
+        `script-src 'unsafe-inline' ${source}`,
+        `style-src 'unsafe-inline' ${source}`,
+        `img-src data: ${source}`,
+        `font-src data: ${source}`,
+        `media-src ${source}`,
+        "connect-src 'none'",
+        "worker-src 'none'",
+        "object-src 'none'",
+        "frame-src 'none'",
+        "form-action 'none'",
+        "navigate-to 'none'",
+        `base-uri ${source}`,
+    ].join("; ");
+    const prefix = `<meta http-equiv="Content-Security-Policy" content="${csp}">` +
+        `<base href="${source}">`;
+    return /<head(?:\s[^>]*)?>/i.test(html)
+        ? html.replace(/<head(?:\s[^>]*)?>/i, (head) => `${head}${prefix}`)
+        : `${prefix}${html}`;
+}
+function requireConsoleReadRequest(ctx, access) {
+    const failure = authorizeRuntimeWebRequest(ctx.req, { access });
+    if (!failure)
+        return true;
+    ctx.status = failure.status;
+    ctx.body = { error: failure.error };
+    return false;
+}
+function requireConsoleRequest(ctx, operation, access) {
+    const failure = authorizeRuntimeWebRequest(ctx.req, {
+        mutation: true,
+        capability: ctx.get(RUNTIME_WEB_CAPABILITY_HEADER),
+        access,
+    });
+    if (failure) {
+        ctx.status = failure.status;
+        ctx.body = { error: failure.error };
+        return false;
+    }
+    if (ctx.get("x-rynx-console") === "1")
+        return true;
+    ctx.status = 403;
+    ctx.body = { error: `${operation} requires the Rynx console` };
+    return false;
+}
+function requireConsoleJsonRequest(ctx, operation, access) {
+    if (!requireConsoleRequest(ctx, operation, access))
+        return false;
+    if (ctx.is("application/json"))
+        return true;
+    ctx.status = 415;
+    ctx.body = { error: `${operation} requires application/json` };
+    return false;
+}
 function authorizeLoopbackManagementRequest(ctx, expectedToken) {
     if (!isLoopbackRequest(ctx)) {
         ctx.status = 403;