0sec-cli 0.24.1 → 0.25.0

package/chunks/{chunk-F2P25DJY.js → chunk-3HMO42M2.js}

@@ -4,24 +4,21 @@ const require = __0CreateRequire(import.meta.url);
 import {
   ConsoleGateway,
   ConsoleGatewayError,
-  WebOperatorServices,
   WebWorkflowService,
-  WorkflowEngineService
-} from "./chunk-GZA7RGK7.js";
-import {
-  assertLocalEngineAvailable,
-  registerLocalEngine
-} from "./chunk-RVJVM5L4.js";
-import {
-  findingFromRow as findingFromRow2
-} from "./chunk-W624J7NF.js";
-import {
+  WorkflowEngineService,
   buildFindingConsoleCommand,
   createLocalConsoleSession,
-  createSessionPluginHostManager,
   findingFromRow,
   loadFindingFocus
-} from "./chunk-2XGBEH53.js";
+} from "./chunk-BWUW6ZQR.js";
+import {
+  assertLocalEngineAvailable,
+  registerLocalEngine
+} from "./chunk-DMDWIW3E.js";
+import {
+  WebOperatorServices,
+  createSessionPluginHostManager
+} from "./chunk-EQBC2ZWL.js";
 import {
   BackendConnectionRegistry,
   backendBearerFromEnv,
@@ -29,13 +26,11 @@ import {
   handleBackendConnectionRequest,
   loadManagedWorker,
   validateWorkerOptions
-} from "./chunk-Q7JKIKKF.js";
-import {
-  Option
-} from "./chunk-WUPN3D37.js";
+} from "./chunk-SEWZ76MN.js";
 import {
+  Option,
   presentationEventBus
-} from "./chunk-56UTQKXO.js";
+} from "./chunk-S4DFH2FJ.js";
 import {
   source_default
 } from "./chunk-HLFS6WV2.js";
@@ -61,43 +56,47 @@ import {
   validateWorkbenchSourceLesson,
   workbenchConfigPath,
   workbenchNetworkEnabled
-} from "./chunk-X2IPO5JO.js";
+} from "./chunk-6TA3CWND.js";
 import {
   connectServicePlugins,
   createConsoleRuntime,
   exportReport,
   isReportExportFormat
-} from "./chunk-ZM6ANQZJ.js";
+} from "./chunk-EEP6GBUO.js";
 import {
   HuntMemoryStore,
   TOOL_DEFINITIONS,
   discoverAgentSkills,
+  listBrowserViews,
   loadSkillRegistry,
+  parseImpactAssessment,
   readToolCallNames,
+  subscribeBrowserView,
   validateAgentSkillContent
-} from "./chunk-5WAHHZBF.js";
+} from "./chunk-HFUOUT2B.js";
 import {
   SecurityWorkflowStore,
   WorkflowTriggerStore,
   findingStatuses,
   nextWorkflowTriggerFire,
   osecDB,
-  resolveOsecDbPath
-} from "./chunk-BMDG6T7D.js";
+  resolveOsecDbPath,
+  restoreFindingReviewFields
+} from "./chunk-YXTV2FRE.js";
 import {
   LlmApiRuntime
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-EIONVEFN.js";
 import {
   DEFAULT_WORKBENCH_BROKER_LIMITS,
   approveSmolvmWorkbenchImage,
   getSmolvmWorkbenchStatus,
   isAdmittedSmolvmWorkbench,
   resolveSmolvmRuntime
-} from "./chunk-PVJUPIQG.js";
+} from "./chunk-3T5R7P4T.js";
 import {
   ScopePolicy,
   withScopeEnforcement
-} from "./chunk-QNRYOJEB.js";
+} from "./chunk-27SXCYWH.js";
 import {
   BackendDescriptorSchema,
   BackendRequestIdSchema,
@@ -106,14 +105,14 @@ import {
   VERSION,
   createPresentationEvent,
   homeStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-S3B6HFSM.js";
 import {
   external_exports
-} from "./chunk-VIT5ALXF.js";
+} from "./chunk-5XOYTAOK.js";
 
 // packages/cli/src/commands/dashboard.ts
 import { createServer as createServer2 } from "node:http";
-import { createHash as createHash8, randomUUID as randomUUID7, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID9, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync2, mkdirSync as mkdirSync6, mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname2, extname, join as join7, resolve as resolve4, sep } from "node:path";
@@ -132,6 +131,44 @@ import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { mkdir, writeFile } from "node:fs/promises";
+
+// packages/cli/src/tui/findings-data.ts
+function parseJsonColumn(raw) {
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function findingFromRow2(row) {
+  const impactAssessment = parseJsonColumn(row.impactAssessment) === void 0 ? void 0 : parseImpactAssessment(row.impactAssessment) ?? void 0;
+  const record = {
+    id: row.id,
+    templateId: row.templateId,
+    title: row.title,
+    description: row.description,
+    severity: row.severity,
+    cvssScore: row.cvssScore ?? void 0,
+    cvssVector: row.cvssVector ?? void 0,
+    category: row.category,
+    status: row.status,
+    fingerprint: row.fingerprint ?? void 0,
+    triageStatus: row.triageStatus ?? void 0,
+    timestamp: row.timestamp,
+    evidence: {
+      request: row.evidenceRequest,
+      response: row.evidenceResponse,
+      analysis: row.evidenceAnalysis ?? void 0
+    },
+    verificationSpec: parseJsonColumn(row.verificationSpec),
+    impactAssessment,
+    ...restoreFindingReviewFields(row)
+  };
+  return record;
+}
+
+// packages/cli/src/workbench-console-guest.ts
 var CALLBACKS = ["requestScope", "requestLocalScope", "approveTool", "escalateScopedAudit", "askOperator"];
 var EVENTS = ["onHarnessUpdate", "onAssistantDelta", "onReasoningDelta", "onToolStart", "onToolResult", "onUsage", "onNotice", "onCompaction"];
 async function runGuest(cli) {
@@ -156,9 +193,9 @@ async function runGuest(cli) {
   let policy;
   const callback = (name, args) => {
     if (decisions.size >= WORKBENCH_MAX_PENDING) return Promise.reject(new Error("Workbench decision limit reached"));
-    const id = randomUUID();
-    emit({ type: "decision", id, name, args });
-    return new Promise((resolve5, reject) => decisions.set(id, { resolve: resolve5, reject }));
+    const id2 = randomUUID();
+    emit({ type: "decision", id: id2, name, args });
+    return new Promise((resolve5, reject) => decisions.set(id2, { resolve: resolve5, reject }));
   };
   const server = createServer(async (request, response) => {
     if (request.method !== "POST" || request.url !== "/provider/request" || providers.size >= 4) {
@@ -175,12 +212,12 @@ async function runGuest(cli) {
       }
       const envelope = JSON.parse(Buffer.concat(chunks).toString("utf8"));
       if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) throw new Error("Invalid provider request");
-      const id = randomUUID();
-      providers.set(id, response);
+      const id2 = randomUUID();
+      providers.set(id2, response);
       response.once("close", () => {
-        if (providers.delete(id)) emit({ type: "provider-cancel", id });
+        if (providers.delete(id2)) emit({ type: "provider-cancel", id: id2 });
       });
-      emit({ type: "provider", id, envelope });
+      emit({ type: "provider", id: id2, envelope });
     } catch {
       response.writeHead(400).end("Invalid provider request");
     }
@@ -212,7 +249,7 @@ async function runGuest(cli) {
     };
     await mkdir("/home/zero/.0/controller", { recursive: true, mode: 448 });
     await writeFile("/home/zero/.0/controller/session.json", JSON.stringify(scrub(snapshot)), { mode: 384 });
-    emit({ type: "state", snapshot: checkpoint?.harnessRoot ? { ...snapshot, checkpoint: void 0 } : snapshot });
+    emit({ type: "state", snapshot: { ...snapshot, ...checkpoint?.harnessRoot ? { checkpoint: void 0 } : {}, sourceContext: session.sourceContext } });
     const db = new osecDB("/home/zero/.0/controller.sqlite");
     try {
       const rows = db.getFindings(session.scanId);
@@ -373,6 +410,23 @@ async function runGuest(cli) {
               }
             });
           };
+          if (frame.callbacks.includes("skillRead")) callbacks.skillAuthoring = {
+            read: (id2) => callback("skillRead", [id2]),
+            create: (content) => callback("skillCreate", [content]),
+            update: (id2, input) => callback("skillSave", [id2, input]),
+            copy: (id2, input) => callback("skillCopy", [id2, input])
+          };
+          if (frame.callbacks.includes("skillEditorRead")) callbacks.skillEditor = { read: () => callback("skillEditorRead", []) };
+          if (frame.callbacks.includes("workflowList")) callbacks.workflowAuthoring = {
+            list: () => callback("workflowList", []),
+            save: (input) => callback("workflowSave", [input]),
+            ...frame.callbacks.includes("workflowEditorRead") && typeof frame.workflowEditorId === "string" ? {
+              editor: { id: frame.workflowEditorId, read: () => callback("workflowEditorRead", []) }
+            } : {}
+          };
+          if (frame.callbacks.includes("workflowInvoke")) callbacks.workflowLifecycle = {
+            invoke: (name, args) => callback("workflowInvoke", [name, args])
+          };
           if (frame.callbacks.includes("historyList")) callbacks.conversationHistory = { list: (...args) => callback("historyList", args), read: (...args) => callback("historyRead", args) };
           pluginManager = await createSessionPluginHostManager({ projectPath: "/workspace", reservedToolNames: Object.values(TOOL_DEFINITIONS).map((tool) => tool.name), coreVersion: VERSION });
           const unavailable = pluginManager.current().status().filter((entry) => entry.state !== "ready");
@@ -399,7 +453,7 @@ async function runGuest(cli) {
             if (typeof frame.text !== "string") throw new Error("Invalid operator message");
             turn = new AbortController();
             const callbacks = Object.fromEntries(EVENTS.map((name) => [name, (...args) => emit({ type: "event", name, args })]));
-            const result = withScopeEnforcement(policy, () => session.send(frame.text, callbacks, { signal: turn.signal, generateTitle: frame.generateTitle === true }));
+            const result = withScopeEnforcement(policy, () => session.send(frame.text, callbacks, { signal: turn.signal, generateTitle: frame.generateTitle === true, images: frame.images }));
             await state();
             value = await result;
             turn = void 0;
@@ -514,7 +568,7 @@ async function setupWorkbench(options, home = process.env.HOME || homedir()) {
   const workspaceRoot = options.workspace === void 0 ? previous?.workspaceRoot : realpathSync(resolve(options.workspace));
   if (workspaceRoot !== void 0 && !lstatSync(workspaceRoot).isDirectory()) throw new Error("Workbench workspace must be a directory.");
   const providers = options.provider ?? previous?.providers ?? [];
-  for (const id of providers) if (!PROVIDERS.some((provider) => provider.id === id)) throw new Error(`Unknown provider grant: ${id}. Use 0 workbench providers.`);
+  for (const id2 of providers) if (!PROVIDERS.some((provider) => provider.id === id2)) throw new Error(`Unknown provider grant: ${id2}. Use 0 workbench providers.`);
   const imageArchive = options.image ? resolve(options.image) : previous?.image;
   if (!imageArchive) throw new Error("No approved workbench image is available. Supply a locally provisioned archive with 0 workbench setup --image <archive>. Docker is only needed to build an image, never to run this profile.");
   const cpus = resource(options.cpus, previous?.cpus ?? 2, 64, "CPUs");
@@ -574,7 +628,7 @@ function registerWorkbenchCommand(program) {
   workbench.command("console-agent", { hidden: true }).action(async () => {
     await runWorkbenchConsoleGuest();
   });
-  workbench.command("setup").description("Verify/provision the signed native runtime, approve a local image, and select SmolVM execution").option("--image <archive>", "Local OCI/Docker archive to digest-pin and approve; never a mutable registry tag").option("--state <directory>", "Private VM state directory (defaults to ~/.0/workbench)").option("--workspace <directory>", "Explicit workspace mount; otherwise each invocation mounts its current directory").option("--provider <id>", "Grant chatgpt-codex requests through the host provider broker; credentials stay on the host", (id, ids = []) => [...ids, id]).option("--github", "Unsupported: GitHub credential forwarding is refused").option("--no-github", "Revoke the GitHub token grant").option("--cpus <count>", "Guest virtual CPUs").option("--memory <MiB>", "Guest RAM in MiB").option("--storage <GiB>", "Guest private writable storage in GiB").option("--sandbox-image <reference=archive>", "Approve an immutable image reference for brokered isolated container actions; repeat for multiple images", (selection, selections = []) => [...selections, selection]).action(async (options) => {
+  workbench.command("setup").description("Verify/provision the signed native runtime, approve a local image, and select SmolVM execution").option("--image <archive>", "Local OCI/Docker archive to digest-pin and approve; never a mutable registry tag").option("--state <directory>", "Private VM state directory (defaults to ~/.0/workbench)").option("--workspace <directory>", "Explicit workspace mount; otherwise each invocation mounts its current directory").option("--provider <id>", "Grant chatgpt-codex requests through the host provider broker; credentials stay on the host", (id2, ids = []) => [...ids, id2]).option("--github", "Unsupported: GitHub credential forwarding is refused").option("--no-github", "Revoke the GitHub token grant").option("--cpus <count>", "Guest virtual CPUs").option("--memory <MiB>", "Guest RAM in MiB").option("--storage <GiB>", "Guest private writable storage in GiB").option("--sandbox-image <reference=archive>", "Approve an immutable image reference for brokered isolated container actions; repeat for multiple images", (selection, selections = []) => [...selections, selection]).action(async (options) => {
     try {
       const config = await setupWorkbench(options);
       console.log(`SmolVM workbench selected. Approved image: ${config.imageDigest}`);
@@ -606,7 +660,7 @@ function registerWorkbenchCommand(program) {
     try {
       const config = loadWorkbenchConfig();
       if (!config) throw new Error("No workbench is configured. Run 0 workbench setup first.");
-      if (options.provider !== void 0) config.providers = options.provider === "none" ? [] : options.provider.split(",").map((id) => id.trim());
+      if (options.provider !== void 0) config.providers = options.provider === "none" ? [] : options.provider.split(",").map((id2) => id2.trim());
       if (options.github !== void 0) config.github = options.github;
       if (options.currentWorkspace) delete config.workspaceRoot;
       if (options.clearSandboxImages) delete config.approvedImages;
@@ -656,6 +710,771 @@ function findDashboardInstance(origin) {
   });
 }
 
+// packages/cli/src/web/managed-host-reconnect.ts
+function startManagedHostReconnect(options) {
+  const metadata = options.getMetadata ?? loadManagedWorker;
+  const now = options.now ?? Date.now;
+  const attempts = /* @__PURE__ */ new Map();
+  const controller = new AbortController();
+  let busy = false;
+  const tick = async () => {
+    if (busy || controller.signal.aborted) return;
+    busy = true;
+    try {
+      const registry2 = options.getRegistry();
+      const hosts = registry2.list().filter((host) => host.id !== "local");
+      for (const id2 of attempts.keys()) if (!hosts.some((host) => host.id === id2)) attempts.delete(id2);
+      for (const host of hosts) {
+        if (controller.signal.aborted) break;
+        try {
+          if (metadata(host.id).autoReconnect === false || (attempts.get(host.id)?.next ?? 0) > now()) continue;
+          const view = await registry2.handshake(host.id).catch(() => null);
+          if (view?.backend.status === "connected") {
+            attempts.delete(host.id);
+            continue;
+          }
+          if (controller.signal.aborted || !registry2.list().some((item) => item.id === host.id) || metadata(host.id).autoReconnect === false) continue;
+          try {
+            await options.repair(host.id, controller.signal);
+            if (!controller.signal.aborted) await options.onRecovered?.(host.id);
+            attempts.delete(host.id);
+          } catch {
+            const count = (attempts.get(host.id)?.count ?? 0) + 1;
+            attempts.set(host.id, { count, next: now() + [6e4, 12e4, 3e5][Math.min(count - 1, 2)] });
+          }
+          break;
+        } catch {
+        }
+      }
+    } catch {
+    } finally {
+      busy = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void tick();
+  }, 3e4);
+  timer.unref?.();
+  void tick();
+  return () => {
+    clearInterval(timer);
+    controller.abort();
+  };
+}
+
+// packages/cli/src/web/local-provider-relay.ts
+async function createLocalRelayProvider(selection = {}, signal) {
+  const [{ createWebConsoleRuntime }, { createWorkbenchProviderBroker }] = await Promise.all([
+    import("./operator-services-E2NONBQS.js"),
+    import("./dist-6RNAVFAY.js")
+  ]);
+  signal?.throwIfAborted();
+  if (selection.providerId && selection.providerId !== "chatgpt-codex") throw new Error("Local model relay currently supports ChatGPT Codex only. Choose the local ChatGPT connection.");
+  const { runtime, info } = await createWebConsoleRuntime({ ...selection, providerId: "chatgpt-codex" });
+  signal?.throwIfAborted();
+  const provider = runtime.resolvedProvider();
+  const model = runtime.resolvedModel();
+  if (provider !== "chatgpt-codex" || !model || !info.configured || !info.diagnostics.valid) throw new Error("Local model relay requires a connected ChatGPT Codex account and an explicit model.");
+  const routing = runtime.modelSelection();
+  const models = [.../* @__PURE__ */ new Set([model, ...Object.values(routing.agentModels).filter((value) => value !== "auto")])];
+  const broker = createWorkbenchProviderBroker({ provider, models, resolveCredentials: runtime.workbenchCredentialResolver(), signal });
+  return { info, grant: broker.grant, transport: { provider, models: broker.grant.models, request: (request, requestSignal) => broker.request(request, requestSignal), close: broker.close } };
+}
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function id(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 160 && !/[\x00-\x20\x7f]/.test(value);
+}
+var RelayResponseError = class extends Error {
+  constructor(code, status) {
+    super("Provider relay transport failed.");
+    this.code = code;
+    this.status = status;
+    this.name = "RelayResponseError";
+  }
+  code;
+  status;
+};
+function safeRelayFailure(error2) {
+  if (error2 instanceof RelayResponseError) return { name: error2.name, code: error2.code };
+  const name = error2 instanceof Error && ["Error", "TypeError", "SyntaxError", "AbortError", "TimeoutError", "BackendConnectionError"].includes(error2.name) ? error2.name : "OtherError";
+  const known = {
+    "Provider request cancelled or timed out": "provider_timeout_or_cancel",
+    "Provider response stream failed": "provider_stream_failed",
+    "Host provider request failed": "provider_request_failed",
+    "Provider broker concurrency limit reached": "provider_concurrency",
+    "Provider broker session budget exhausted": "provider_budget",
+    "Provider broker is closed": "provider_closed",
+    "Provider or model is not granted to this workbench": "provider_grant_rejected",
+    "Provider request exceeds its byte limit": "provider_input_limit",
+    "Invalid provider request JSON": "provider_input_json",
+    "Provider broker permits only stateless streamed Responses requests": "provider_body_shape",
+    "Provider broker refuses hosted tools and external tool destinations": "provider_tool_destination",
+    "Unsupported provider input item": "provider_input_type",
+    "Provider broker permits text input only": "provider_text_only",
+    "Remote provider relay scope changed.": "remote_scope_changed",
+    "Invalid provider cancellation.": "remote_cancel_invalid",
+    "Remote provider request exceeds its approval.": "remote_request_not_approved",
+    "Remote provider relay exceeded its request budget.": "relay_budget",
+    "Provider output exceeds approval.": "provider_output_limit",
+    "Provider SSE event exceeds response limit.": "provider_sse_limit",
+    "Backend response identity does not match the registered engine.": "remote_identity_changed",
+    "Backend response exceeds the transport limit.": "remote_response_limit",
+    "Backend request timed out.": "remote_timeout",
+    "Backend transport failed.": "remote_transport_failed",
+    "Backend request capacity exceeded.": "remote_capacity"
+  };
+  return { name, code: error2 instanceof Error ? Object.hasOwn(known, error2.message) ? known[error2.message] : "unclassified" : "unclassified" };
+}
+async function json(response) {
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new RelayResponseError("remote_http_rejected", response.status);
+  }
+  try {
+    return object(await response.json());
+  } catch {
+    throw new RelayResponseError("remote_invalid_json", response.status);
+  }
+}
+async function pause(signal, delayMs = 500) {
+  if (signal.aborted) return;
+  await new Promise((resolve5) => {
+    const abort = () => {
+      clearTimeout(timer);
+      resolve5();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve5();
+    }, delayMs);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+}
+function retryablePollFailure(error2) {
+  if (error2 instanceof RelayResponseError) return [408, 425, 429, 500, 502, 503, 504].includes(error2.status);
+  if (!(error2 instanceof Error) || error2.name !== "BackendConnectionError") return false;
+  const status = error2.statusCode;
+  return status === 504 && error2.message === "Backend request timed out." || status === 502 && error2.message === "Backend transport failed." || status === 429 && error2.message === "Backend request capacity exceeded.";
+}
+function failureTransportStatus(error2, fallback) {
+  if (error2 instanceof RelayResponseError) return error2.status;
+  if (error2 instanceof Error && error2.name === "BackendConnectionError" && typeof error2.statusCode === "number") return error2.statusCode;
+  return fallback;
+}
+function providerSseCompletion(maximumBytes = 8 * 1024 * 1024) {
+  const decoder2 = new TextDecoder();
+  let buffer = "", completed = false;
+  return (chunk) => {
+    if (completed) return true;
+    buffer += decoder2.decode(chunk, { stream: true });
+    let boundary;
+    while (boundary = /\r?\n\r?\n/.exec(buffer)) {
+      const block = buffer.slice(0, boundary.index);
+      if (Buffer.byteLength(block) > maximumBytes) throw new Error("Provider SSE event exceeds response limit.");
+      buffer = buffer.slice(boundary.index + boundary[0].length);
+      const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+      if (!data) continue;
+      if (data === "[DONE]") {
+        completed = true;
+        break;
+      }
+      try {
+        const event = JSON.parse(data);
+        if (event && ["response.completed", "response.failed", "response.incomplete", "error"].includes(String(event.type))) {
+          completed = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (Buffer.byteLength(buffer) > maximumBytes) throw new Error("Provider SSE event exceeds response limit.");
+    return completed;
+  };
+}
+async function createLocalProviderRelay(options) {
+  if (options.backendId === "local" || !id(options.backendId)) throw new Error("Provider relay requires a registered remote host.");
+  const lifetime = new AbortController();
+  const signal = options.signal ? AbortSignal.any([lifetime.signal, options.signal]) : lifetime.signal;
+  signal.throwIfAborted();
+  const peer = await options.registry.handshake(options.backendId);
+  const epoch2 = peer.handshake?.serverInstanceId;
+  if (peer.backend.status !== "connected" || !id(epoch2)) throw new Error("Provider relay requires a connected, identified host.");
+  const local = await (options.createProvider ?? createLocalRelayProvider)(options.selection ?? {}, signal);
+  const base = "/api/console/provider-relays";
+  let grant;
+  try {
+    const response = await json(await options.registry.request(options.backendId, base, { method: "POST", body: { epoch: epoch2, provider: local.grant.provider, models: local.grant.models, model: local.info.model }, signal }));
+    const candidate = object(response.grant);
+    if (!id(candidate.id) || candidate.epoch !== epoch2 || candidate.provider !== local.grant.provider || !Array.isArray(candidate.models) || candidate.models.length !== local.grant.models.length || new Set(candidate.models).size !== candidate.models.length || candidate.models.some((model) => typeof model !== "string" || !local.grant.models.includes(model)) || candidate.model !== local.info.model || typeof candidate.expiresAt !== "string" || !Number.isFinite(Date.parse(candidate.expiresAt))) throw new Error("Remote provider relay grant does not match the local approval.");
+    grant = candidate;
+  } catch (error2) {
+    await local.transport.close?.();
+    throw error2;
+  }
+  const diagnostic = { phase: "registered", lastPollAt: null, seenRequests: 0, activeRequests: 0, bytesForwarded: 0 };
+  const grantPath = `${base}/${encodeURIComponent(grant.id)}`;
+  let revocation;
+  const revokeGrant = () => revocation ??= options.registry.request(options.backendId, grantPath, { method: "DELETE", signal: AbortSignal.timeout(5e3) }).then(async (response) => {
+    await response.body?.cancel();
+  }).catch(() => {
+  });
+  const active = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const tasks = /* @__PURE__ */ new Set();
+  let boundSession, polling, closing;
+  const abortActive = () => {
+    for (const controller of active.values()) controller.abort();
+  };
+  signal.addEventListener("abort", abortActive, { once: true });
+  const remoteRequest = async (path, optionsValue) => {
+    const response = await options.registry.request(options.backendId, path, optionsValue);
+    diagnostic.lastTransportStatus = response.status;
+    return response;
+  };
+  const send = (request, events, callerSignal) => remoteRequest(`${grantPath}/requests/${encodeURIComponent(request.requestId)}/events`, { method: "POST", body: { epoch: epoch2, sessionId: boundSession, events }, signal: callerSignal }).then(json);
+  async function service(request) {
+    const controller = new AbortController();
+    active.set(request.requestId, controller);
+    diagnostic.phase = "requesting";
+    diagnostic.activeRequests = active.size;
+    delete diagnostic.error;
+    const requestSignal = AbortSignal.any([signal, controller.signal, AbortSignal.timeout(local.grant.limits.timeoutMs)]);
+    let reader;
+    const cancelReader = () => {
+      void reader?.cancel().catch(() => {
+      });
+    };
+    requestSignal.addEventListener("abort", cancelReader, { once: true });
+    let stage = "provider_request";
+    try {
+      const response = await local.transport.request({ provider: request.provider, model: request.model, body: request.body }, requestSignal);
+      diagnostic.lastUpstreamStatus = response.status;
+      stage = "headers_post";
+      await send(request, [{ kind: "headers", status: response.status, contentType: response.headers.get("content-type") || "text/event-stream" }], requestSignal);
+      diagnostic.phase = "streaming";
+      if (response.body) {
+        reader = response.body.getReader();
+        let bytes = 0;
+        const completed = response.headers.get("content-type")?.toLowerCase().includes("text/event-stream") ? providerSseCompletion(local.grant.limits.maxResponseBytes) : void 0;
+        while (!requestSignal.aborted) {
+          stage = "reader_read";
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          bytes += chunk.value.byteLength;
+          if (bytes > local.grant.limits.maxResponseBytes) throw new Error("Provider output exceeds approval.");
+          stage = "chunk_post";
+          for (let offset = 0; offset < chunk.value.byteLength; offset += 32 * 1024) {
+            const portion = chunk.value.subarray(offset, offset + 32 * 1024);
+            await send(request, [{ kind: "chunk", data: Buffer.from(portion).toString("base64") }], requestSignal);
+            diagnostic.bytesForwarded += portion.byteLength;
+          }
+          stage = "sse_parse";
+          if (completed?.(chunk.value)) break;
+        }
+        requestSignal.throwIfAborted();
+      }
+      stage = "end_post";
+      await send(request, [{ kind: "end" }], requestSignal);
+    } catch (error2) {
+      if (!signal.aborted && !controller.signal.aborted) {
+        const failure = safeRelayFailure(error2);
+        diagnostic.lastFailureStage = stage;
+        diagnostic.lastFailureName = failure.name;
+        diagnostic.lastFailureCode = failure.code;
+        diagnostic.lastFailureTransportStatus = failureTransportStatus(error2, diagnostic.lastTransportStatus);
+        diagnostic.error = diagnostic.phase === "requesting" ? "upstream_failed" : "response_rejected";
+        await send(request, [{ kind: "error" }], AbortSignal.any([signal, AbortSignal.timeout(5e3)])).catch(() => {
+        });
+      }
+    } finally {
+      requestSignal.removeEventListener("abort", cancelReader);
+      controller.abort();
+      if (reader) {
+        await reader.cancel().catch(() => {
+        });
+        reader.releaseLock();
+      }
+      active.delete(request.requestId);
+      diagnostic.activeRequests = active.size;
+      if (!signal.aborted && !active.size) diagnostic.phase = "polling";
+    }
+  }
+  async function poll() {
+    let failureCategory = "poll_rejected";
+    try {
+      if (!active.size) diagnostic.phase = "polling";
+      while (!signal.aborted) {
+        failureCategory = "poll_rejected";
+        let body;
+        try {
+          body = await json(await remoteRequest(`${grantPath}/requests`, { method: "GET", signal }));
+        } catch (error2) {
+          if (signal.aborted || !retryablePollFailure(error2)) throw error2;
+          const failure = safeRelayFailure(error2);
+          diagnostic.phase = "reconnecting";
+          diagnostic.error = "poll_rejected";
+          diagnostic.lastFailureStage = "poll";
+          diagnostic.lastFailureName = failure.name;
+          diagnostic.lastFailureCode = failure.code;
+          diagnostic.lastFailureTransportStatus = failureTransportStatus(error2, diagnostic.lastTransportStatus);
+          diagnostic.consecutivePollFailures = (diagnostic.consecutivePollFailures ?? 0) + 1;
+          await pause(signal, Math.min(5e3, 500 * 2 ** Math.min(diagnostic.consecutivePollFailures - 1, 4)));
+          continue;
+        }
+        diagnostic.consecutivePollFailures = 0;
+        if (diagnostic.error === "poll_rejected") delete diagnostic.error;
+        diagnostic.phase = active.size ? "streaming" : "polling";
+        diagnostic.lastPollAt = (/* @__PURE__ */ new Date()).toISOString();
+        failureCategory = "scope_changed";
+        if (body.grantId !== grant.id || body.epoch !== epoch2 || body.sessionId !== void 0 && body.sessionId !== boundSession || !Array.isArray(body.requests) || !Array.isArray(body.cancelled) || body.requests.length > 4 || body.cancelled.length > 256) throw new Error("Remote provider relay scope changed.");
+        for (const requestId of body.cancelled) {
+          if (!id(requestId)) throw new Error("Invalid provider cancellation.");
+          active.get(requestId)?.abort();
+        }
+        for (const value of body.requests) {
+          const request = object(value);
+          failureCategory = "request_rejected";
+          if (!id(request.requestId) || request.grantId !== grant.id || request.epoch !== epoch2 || request.sessionId !== boundSession || request.provider !== local.grant.provider || typeof request.model !== "string" || !local.grant.models.includes(request.model) || typeof request.body !== "string" || Buffer.byteLength(request.body) > local.grant.limits.maxRequestBytes) throw new Error("Remote provider request exceeds its approval.");
+          if (seen.has(request.requestId)) continue;
+          if (seen.size >= local.grant.limits.maxRequests || active.size >= Math.min(4, local.grant.limits.maxConcurrent)) throw new Error("Remote provider relay exceeded its request budget.");
+          seen.add(request.requestId);
+          diagnostic.seenRequests = seen.size;
+          const task = service(request);
+          tasks.add(task);
+          void task.finally(() => tasks.delete(task));
+        }
+        await pause(signal);
+      }
+    } catch (error2) {
+      if (!signal.aborted) {
+        diagnostic.phase = "failed";
+        diagnostic.error = failureCategory;
+        const failure = safeRelayFailure(error2);
+        diagnostic.lastFailureStage = "poll";
+        diagnostic.lastFailureName = failure.name;
+        diagnostic.lastFailureCode = failure.code;
+        diagnostic.lastFailureTransportStatus = failureTransportStatus(error2, diagnostic.lastTransportStatus);
+      }
+      if (!signal.aborted) options.onError?.("The local model connection to this host ended. Reconnect the host before continuing.");
+      lifetime.abort();
+    } finally {
+      if (signal.aborted && diagnostic.phase !== "failed") diagnostic.phase = "closed";
+      abortActive();
+      await local.transport.close?.();
+      await revokeGrant();
+    }
+  }
+  return {
+    grant,
+    info: local.info,
+    status: () => ({ ...diagnostic }),
+    start(sessionId) {
+      if (!id(sessionId) || signal.aborted || boundSession) throw new Error("Provider relay must bind once to an active remote session.");
+      boundSession = sessionId;
+      polling = poll();
+    },
+    close() {
+      return closing ??= (async () => {
+        diagnostic.phase = "closed";
+        lifetime.abort();
+        abortActive();
+        signal.removeEventListener("abort", abortActive);
+        await local.transport.close?.();
+        await Promise.allSettled([...tasks, ...polling ? [polling] : []]);
+        await revokeGrant();
+      })();
+    }
+  };
+}
+
+// packages/cli/src/web/local-provider-sessions.ts
+var LocalProviderSessionError = class extends Error {
+  constructor(message2, statusCode = 400) {
+    super(message2);
+    this.statusCode = statusCode;
+  }
+  statusCode;
+};
+var resourceId = external_exports.string().min(1).max(160).regex(/^[^\x00-\x20\x7f]+$/);
+var runtimeSchema = external_exports.object({ providerId: external_exports.string().min(1).max(256).optional(), model: external_exports.string().min(1).max(256).optional(), reasoningEffort: external_exports.string().min(1).max(256).optional(), agentModels: external_exports.record(external_exports.string().min(1).max(64), external_exports.string().min(1).max(256)).refine((value) => Object.keys(value).length <= 32).optional(), singleModel: external_exports.boolean().optional(), autoRoute: external_exports.boolean().optional() }).strict();
+var createSchema = external_exports.object({ workflowId: external_exports.string().min(1).max(128).optional(), target: external_exports.string().max(4096).optional(), title: external_exports.string().max(200).optional(), role: external_exports.enum(["discovery", "attack", "verify", "report", "audit", "review"]).optional(), autonomyMode: external_exports.enum(["standard", "recon", "copilot", "yolo"]).optional(), scope: external_exports.record(external_exports.string(), external_exports.unknown()).nullable().optional(), runtime: runtimeSchema.optional(), findingId: external_exports.string().max(256).optional(), findingIntent: external_exports.enum(["investigate", "verify", "draft_fix", "impact"]).optional() }).strict();
+var LocalProviderSessions = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  lifetime = new AbortController();
+  creating = 0;
+  reconnecting = /* @__PURE__ */ new Set();
+  key(backendId, sessionId) {
+    return JSON.stringify([backendId, sessionId]);
+  }
+  signal() {
+    return this.options.signal ? AbortSignal.any([this.lifetime.signal, this.options.signal]) : this.lifetime.signal;
+  }
+  assertBackend(backendId) {
+    if (!resourceId.safeParse(backendId).success || backendId === "local") throw new LocalProviderSessionError("Choose a registered remote host.");
+    this.signal().throwIfAborted();
+  }
+  async request(backendId, path, method, body) {
+    const response = await this.options.registry.request(backendId, path, { method, body, signal: this.signal() });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new LocalProviderSessionError("The remote host rejected this conversation change.", response.status);
+    }
+    const value = await response.json();
+    if (!value?.session || !resourceId.safeParse(value.session.id).success) throw new LocalProviderSessionError("The remote host returned an invalid conversation.", 502);
+    return value.session;
+  }
+  async create(backendId, input, ownerId = "local") {
+    this.assertBackend(backendId);
+    const parsed = createSchema.safeParse(input);
+    if (!parsed.success) throw new LocalProviderSessionError("Invalid remote conversation configuration; model grants are issued locally.");
+    if (this.sessions.size + this.creating >= 32) throw new LocalProviderSessionError("Close a local model connection before creating another remote conversation.", 429);
+    this.creating++;
+    let relay;
+    try {
+      relay = await (this.options.createRelay ?? createLocalProviderRelay)({ registry: this.options.registry, backendId, selection: parsed.data.runtime, signal: this.signal() });
+      const session = await this.request(backendId, "/api/console/sessions", "POST", { ...parsed.data, runtime: { ...parsed.data.runtime, providerId: relay.info.providerId, model: relay.info.model }, modelSource: { kind: "local", grantId: relay.grant.id } });
+      this.signal().throwIfAborted();
+      const key = this.key(backendId, session.id);
+      if (this.sessions.has(key)) throw new LocalProviderSessionError("The host reused an existing conversation ID.", 409);
+      relay.start(session.id);
+      this.sessions.set(key, { owner: ownerId, relay, selection: parsed.data.runtime ?? {}, configuring: false });
+      return { session };
+    } catch (error2) {
+      await relay?.close();
+      throw error2;
+    } finally {
+      this.creating--;
+    }
+  }
+  async configure(backendId, sessionId, runtime, ownerId = "local") {
+    this.assertBackend(backendId);
+    if (!resourceId.safeParse(sessionId).success) throw new LocalProviderSessionError("Invalid conversation ID.");
+    const managed = this.sessions.get(this.key(backendId, sessionId));
+    if (!managed) return this.reconnect(backendId, sessionId, runtime, ownerId);
+    if (managed.owner !== ownerId) throw new LocalProviderSessionError("This local model connection does not belong to the current workspace.", 404);
+    const parsed = runtimeSchema.safeParse(runtime);
+    if (!parsed.success) throw new LocalProviderSessionError("Invalid local model selection.");
+    if (managed.configuring) throw new LocalProviderSessionError("Wait for the current model change.", 409);
+    managed.configuring = true;
+    let replacement;
+    try {
+      const selection = { ...managed.selection, ...parsed.data };
+      replacement = await (this.options.createRelay ?? createLocalProviderRelay)({ registry: this.options.registry, backendId, selection, signal: this.signal() });
+      const session = await this.request(backendId, `/api/console/sessions/${encodeURIComponent(sessionId)}/configuration`, "PATCH", { runtime: { ...selection, providerId: replacement.info.providerId, model: replacement.info.model }, modelSource: { kind: "local", grantId: replacement.grant.id } });
+      if (session.id !== sessionId) throw new LocalProviderSessionError("The host returned a different conversation.", 409);
+      this.signal().throwIfAborted();
+      replacement.start(sessionId);
+      const previous = managed.relay;
+      managed.relay = replacement;
+      managed.selection = selection;
+      replacement = void 0;
+      await previous.close();
+      return { session };
+    } finally {
+      managed.configuring = false;
+      await replacement?.close();
+    }
+  }
+  /** Explicitly restore a saved local-model marker after either engine restarted. */
+  async reconnect(backendId, sessionId, runtime, ownerId = "local") {
+    this.assertBackend(backendId);
+    if (!resourceId.safeParse(sessionId).success) throw new LocalProviderSessionError("Invalid conversation ID.");
+    const key = this.key(backendId, sessionId), existing = this.sessions.get(key);
+    if (existing) return this.configure(backendId, sessionId, runtime, ownerId);
+    const parsed = runtimeSchema.safeParse(runtime);
+    if (!parsed.success) throw new LocalProviderSessionError("Invalid local model selection.");
+    if (this.reconnecting.has(key)) throw new LocalProviderSessionError("Wait for this conversation to reconnect.", 409);
+    if (this.sessions.size + this.creating >= 32) throw new LocalProviderSessionError("Close a local model connection before reconnecting another conversation.", 429);
+    this.reconnecting.add(key);
+    this.creating++;
+    let replacement;
+    try {
+      const response = await this.options.registry.request(backendId, `/api/console/sessions/${encodeURIComponent(sessionId)}`, { method: "GET", signal: this.signal() });
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new LocalProviderSessionError("This remote conversation could not be reopened.", response.status);
+      }
+      const snapshot = (await response.json()).snapshot;
+      if (snapshot?.session?.id !== sessionId || snapshot.runtime?.modelSource !== "local") throw new LocalProviderSessionError("Only an existing local-model conversation can reconnect through this route.", 409);
+      if (snapshot.session.status !== "ready") throw new LocalProviderSessionError("Wait until this remote conversation is idle before reconnecting its model.", 409);
+      const selection = runtimeSchema.parse({ providerId: "chatgpt-codex", ...snapshot.runtime.model ? { model: snapshot.runtime.model } : {}, ...parsed.data });
+      replacement = await (this.options.createRelay ?? createLocalProviderRelay)({ registry: this.options.registry, backendId, selection, signal: this.signal() });
+      const session = await this.request(backendId, `/api/console/sessions/${encodeURIComponent(sessionId)}/configuration`, "PATCH", { runtime: { ...selection, providerId: replacement.info.providerId, model: replacement.info.model }, modelSource: { kind: "local", grantId: replacement.grant.id } });
+      if (session.id !== sessionId) throw new LocalProviderSessionError("The host returned a different conversation.", 409);
+      this.signal().throwIfAborted();
+      replacement.start(sessionId);
+      this.sessions.set(key, { owner: ownerId, relay: replacement, selection, configuring: false });
+      replacement = void 0;
+      return { session };
+    } finally {
+      this.creating--;
+      this.reconnecting.delete(key);
+      await replacement?.close();
+    }
+  }
+  async status(backendId, sessionId, ownerId = "local") {
+    this.assertBackend(backendId);
+    const managed = this.sessions.get(this.key(backendId, sessionId));
+    if (!managed || managed.owner !== ownerId) throw new LocalProviderSessionError("This local model connection does not belong to the current workspace.", 404);
+    const local = managed.relay.status();
+    try {
+      const response = await this.options.registry.request(backendId, `/api/console/provider-relays/${encodeURIComponent(managed.relay.grant.id)}/status`, { method: "GET", signal: AbortSignal.any([this.signal(), AbortSignal.timeout(5e3)]) });
+      if (!response.ok) {
+        await response.body?.cancel();
+        return { local, remote: { available: false, status: response.status } };
+      }
+      const body = await response.json();
+      if (body.grantId !== managed.relay.grant.id || body.epoch !== managed.relay.grant.epoch || body.sessionId !== sessionId) throw new Error("scope");
+      const pending = external_exports.array(external_exports.object({ delivered: external_exports.boolean(), headers: external_exports.boolean(), receivedBytes: external_exports.number().finite().nonnegative(), bufferedBytes: external_exports.number().finite().nonnegative(), ageMs: external_exports.number().finite().nonnegative() }).strip()).max(4).parse(body.pending);
+      const cancelledCount = external_exports.number().int().nonnegative().parse(body.cancelledCount);
+      return { local, remote: { available: true, pending, cancelledCount } };
+    } catch {
+      return { local, remote: { available: false } };
+    }
+  }
+  async release(backendId, sessionId, ownerId = "local") {
+    const key = this.key(backendId, sessionId), managed = this.sessions.get(key);
+    if (!managed || managed.owner !== ownerId) return;
+    this.sessions.delete(key);
+    await managed.relay.close();
+  }
+  async dispose() {
+    this.lifetime.abort();
+    const entries = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.allSettled(entries.map((entry) => entry.relay.close()));
+  }
+};
+
+// packages/cli/src/web/remote-provider-relay.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var ProviderRelayError = class extends Error {
+  constructor(message2, statusCode = 400) {
+    super(message2);
+    this.statusCode = statusCode;
+  }
+  statusCode;
+};
+var GRANT_IDLE_MS = 30 * 6e4;
+var REDELIVER_UNACKNOWLEDGED_MS = 5e3;
+var modelId = external_exports.string().regex(/^[A-Za-z0-9._-]{1,128}$/);
+var grantInput = external_exports.object({ epoch: external_exports.string().min(1).max(256), provider: external_exports.literal("chatgpt-codex"), models: external_exports.array(modelId).min(1).max(16), model: modelId }).strict();
+var eventsInput = external_exports.object({ epoch: external_exports.string(), sessionId: external_exports.string().min(1).max(256), events: external_exports.array(external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("headers"), status: external_exports.number().int().min(200).max(599).refine((status) => ![204, 205, 304].includes(status)), contentType: external_exports.string().max(128).regex(/^(text\/event-stream|application\/json)(?:;[^\r\n]*)?$/i).transform((value) => value.split(";")[0].toLowerCase()) }).strict(),
+  external_exports.object({ kind: external_exports.literal("chunk"), data: external_exports.string().max(65536).regex(/^[A-Za-z0-9+/]*={0,2}$/) }).strict(),
+  external_exports.object({ kind: external_exports.literal("end") }).strict(),
+  external_exports.object({ kind: external_exports.literal("error") }).strict()
+])).min(1).max(16) }).strict();
+var RemoteProviderRelayBroker = class {
+  epoch;
+  #grants = /* @__PURE__ */ new Map();
+  #disposed = false;
+  constructor(options) {
+    this.epoch = options.epoch;
+  }
+  create(input) {
+    const value = grantInput.parse(input);
+    if (this.#disposed || value.epoch !== this.epoch) throw new ProviderRelayError("Provider relay engine epoch changed.", 409);
+    if (!value.models.includes(value.model) || new Set(value.models).size !== value.models.length) throw new ProviderRelayError("Provider relay requires an exact model allowlist.");
+    for (const [id2, state] of this.#grants) if (Date.parse(state.grant.expiresAt) <= Date.now()) this.close(id2);
+    if (this.#grants.size >= 32) throw new ProviderRelayError("Provider relay grant limit reached.", 429);
+    const grant = { id: randomUUID2(), epoch: this.epoch, provider: value.provider, models: value.models, model: value.model, expiresAt: new Date(Date.now() + GRANT_IDLE_MS).toISOString() };
+    this.#grants.set(grant.id, { grant, requests: /* @__PURE__ */ new Map(), cancelled: [] });
+    return structuredClone(grant);
+  }
+  #get(id2) {
+    const state = this.#grants.get(id2);
+    if (!state || this.#disposed) throw new ProviderRelayError("Provider relay grant is unavailable. Reconnect the local model source.", 410);
+    if (Date.parse(state.grant.expiresAt) <= Date.now()) {
+      this.close(id2);
+      throw new ProviderRelayError("Provider relay grant expired. Reconnect the local model source.", 410);
+    }
+    return state;
+  }
+  bind(id2, sessionId) {
+    const state = this.#get(id2);
+    if (state.sessionId && state.sessionId !== sessionId) throw new ProviderRelayError("Provider relay grant belongs to another conversation.", 409);
+    state.sessionId = sessionId;
+    return structuredClone(state.grant);
+  }
+  transport(id2, sessionId) {
+    const grant = this.bind(id2, sessionId);
+    return { provider: grant.provider, models: grant.models, identity: `relay:${grant.epoch}:${grant.id}`, request: (envelope, signal) => this.request(id2, sessionId, envelope, signal) };
+  }
+  runtime(id2, sessionId, selection = {}) {
+    const grant = this.bind(id2, sessionId);
+    if (selection.providerId && selection.providerId !== grant.provider) throw new ProviderRelayError("Provider is outside the local model grant.", 403);
+    return new LlmApiRuntime({
+      type: "api",
+      timeout: 12e4,
+      model: selection.model ?? grant.model,
+      provider: "chatgpt-codex",
+      singleModel: selection.singleModel,
+      agentModels: selection.agentModels,
+      autoRoute: selection.autoRoute,
+      providerTransport: this.transport(id2, sessionId)
+    });
+  }
+  request(id2, sessionId, envelope, signal) {
+    const state = this.#get(id2);
+    if (state.sessionId !== sessionId || envelope.provider !== state.grant.provider || !state.grant.models.includes(envelope.model)) throw new ProviderRelayError("Request is outside the local model grant.", 403);
+    signal?.throwIfAborted();
+    if (state.requests.size >= 4) throw new ProviderRelayError("Local model request limit reached.", 429);
+    if (Buffer.byteLength(envelope.body) > 4 * 1024 * 1024) throw new ProviderRelayError("Local model request exceeds 4 MiB.", 413);
+    const body = JSON.parse(envelope.body);
+    if (body.model !== envelope.model || body.background === true || body.store === true || !Array.isArray(body.input)) throw new ProviderRelayError("Invalid granted Responses request.");
+    return new Promise((resolve5, reject) => {
+      const requestId = randomUUID2();
+      const cancel = () => this.#finish(state, pending, new Error("Local provider request cancelled."));
+      const pending = {
+        ...envelope,
+        requestId,
+        grantId: id2,
+        epoch: this.epoch,
+        sessionId,
+        startedAt: Date.now(),
+        delivered: false,
+        received: 0,
+        buffered: 0,
+        ended: false,
+        headers: false,
+        queue: [],
+        resolve: resolve5,
+        reject,
+        timer: setTimeout(() => this.#finish(state, pending, new Error("Local provider relay timed out.")), 12e4),
+        cleanup: () => signal?.removeEventListener("abort", cancel)
+      };
+      signal?.addEventListener("abort", cancel, { once: true });
+      state.requests.set(requestId, pending);
+      if (signal?.aborted) cancel();
+    });
+  }
+  status(id2) {
+    const state = this.#get(id2);
+    return {
+      grantId: id2,
+      epoch: this.epoch,
+      sessionId: state.sessionId,
+      expiresAt: state.grant.expiresAt,
+      pending: [...state.requests.values()].map((request) => ({ id: request.requestId, delivered: request.delivered, headers: request.headers, receivedBytes: request.received, bufferedBytes: request.buffered, ageMs: Math.max(0, Date.now() - request.startedAt) })),
+      cancelledCount: state.cancelled.length
+    };
+  }
+  poll(id2) {
+    const state = this.#get(id2);
+    state.grant.expiresAt = new Date(Date.now() + GRANT_IDLE_MS).toISOString();
+    const requests = [...state.requests.values()];
+    const next = requests.find((request) => !request.delivered) ?? requests.find((request) => !request.headers && Date.now() - (request.deliveredAt ?? request.startedAt) >= REDELIVER_UNACKNOWLEDGED_MS);
+    if (next) {
+      next.delivered = true;
+      next.deliveredAt = Date.now();
+    }
+    const cancelled = state.cancelled.splice(0);
+    return { grantId: id2, epoch: this.epoch, sessionId: state.sessionId, expiresAt: state.grant.expiresAt, requests: next ? [{ requestId: next.requestId, grantId: id2, epoch: this.epoch, sessionId: next.sessionId, provider: next.provider, model: next.model, body: next.body }] : [], cancelled };
+  }
+  #finish(state, request, error2) {
+    if (request.ended) return;
+    request.ended = true;
+    clearTimeout(request.timer);
+    request.cleanup();
+    state.requests.delete(request.requestId);
+    if (error2) {
+      state.cancelled.push(request.requestId);
+      state.cancelled = state.cancelled.slice(-64);
+      if (!request.headers) request.reject(error2);
+      request.controller?.error(error2);
+    } else if (!request.headers) request.reject(new Error("Provider relay ended without response headers."));
+    else if (request.queue.length === 0) request.controller?.close();
+  }
+  events(id2, requestId, input) {
+    if (Buffer.byteLength(JSON.stringify(input)) > 512 * 1024) throw new ProviderRelayError("Provider event batch exceeds 512 KiB.", 413);
+    const state = this.#get(id2);
+    const value = eventsInput.parse(input);
+    if (value.epoch !== this.epoch || value.sessionId !== state.sessionId) throw new ProviderRelayError("Provider relay ownership or epoch changed.", 409);
+    const pending = state.requests.get(requestId);
+    if (!pending) throw new ProviderRelayError("Provider request is no longer pending.", 410);
+    for (const event of value.events) {
+      if (pending.ended) throw new ProviderRelayError("Provider response has ended.", 409);
+      if (event.kind === "headers") {
+        if (pending.headers) throw new ProviderRelayError("Duplicate provider response headers.", 409);
+        pending.headers = true;
+        const stream = new ReadableStream({ start: (controller) => {
+          pending.controller = controller;
+        }, pull: (controller) => {
+          const chunk = pending.queue.shift();
+          if (chunk) {
+            pending.buffered -= chunk.byteLength;
+            controller.enqueue(chunk);
+          } else if (pending.ended) controller.close();
+        }, cancel: () => this.#finish(state, pending, new Error("Provider response reader cancelled.")) });
+        pending.resolve(new Response(stream, { status: event.status, headers: { "content-type": event.contentType } }));
+      } else if (event.kind === "chunk") {
+        if (!pending.headers) throw new ProviderRelayError("Provider headers must precede body chunks.", 409);
+        const bytes = Buffer.from(event.data, "base64");
+        if (bytes.toString("base64") !== event.data || bytes.byteLength > 49152) throw new ProviderRelayError("Invalid provider body chunk.");
+        pending.received += bytes.byteLength;
+        if (pending.received > 16 * 1024 * 1024 || pending.buffered + bytes.byteLength > 2 * 1024 * 1024) {
+          this.#finish(state, pending, new Error("Provider response exceeded relay limits."));
+          throw new ProviderRelayError("Provider response exceeded relay limits.", 413);
+        }
+        if ((pending.controller?.desiredSize ?? 0) > 0 && pending.queue.length === 0) pending.controller.enqueue(bytes);
+        else {
+          pending.queue.push(bytes);
+          pending.buffered += bytes.byteLength;
+        }
+      } else this.#finish(state, pending, event.kind === "error" ? new Error("Local model source disconnected or failed.") : void 0);
+    }
+    return { accepted: true };
+  }
+  close(id2) {
+    const state = this.#grants.get(id2);
+    if (!state) return;
+    for (const pending of [...state.requests.values()]) this.#finish(state, pending, new Error("Local model source disconnected."));
+    this.#grants.delete(id2);
+  }
+  dispose() {
+    for (const id2 of [...this.#grants.keys()]) this.close(id2);
+    this.#disposed = true;
+  }
+};
+async function handleRemoteProviderRelayRequest(req, res, url, broker, readBody) {
+  const base = "/api/console/provider-relays";
+  if (url.pathname !== base && !url.pathname.startsWith(`${base}/`)) return false;
+  const send = (status, value) => {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(value));
+  };
+  try {
+    if (url.pathname === base && req.method === "POST") {
+      send(201, { grant: broker.create(await readBody()) });
+      return true;
+    }
+    const status = /^\/api\/console\/provider-relays\/([a-f0-9-]{36})\/status$/.exec(url.pathname);
+    if (status) {
+      if (req.method !== "GET") throw new ProviderRelayError("Method not allowed.", 405);
+      send(200, broker.status(status[1]));
+      return true;
+    }
+    const match = /^\/api\/console\/provider-relays\/([a-f0-9-]{36})(?:\/requests(?:\/([a-f0-9-]{36})\/events)?)?$/.exec(url.pathname);
+    if (!match) throw new ProviderRelayError("Unknown provider relay route.", 404);
+    if (req.method === "DELETE" && !url.pathname.endsWith("/requests") && !match[2]) {
+      broker.close(match[1]);
+      send(200, { closed: true });
+    } else if (req.method === "GET" && url.pathname.endsWith("/requests")) send(200, broker.poll(match[1]));
+    else if (req.method === "POST" && match[2]) send(200, broker.events(match[1], match[2], await readBody()));
+    else throw new ProviderRelayError("Method not allowed.", 405);
+  } catch (error2) {
+    send(error2 instanceof ProviderRelayError ? error2.statusCode : 400, { error: error2 instanceof ProviderRelayError ? error2.message : "Invalid provider relay request." });
+  }
+  return true;
+}
+
 // packages/cli/src/web/report-artifacts.ts
 var ReportArtifactError = class extends Error {
   constructor(message2, statusCode) {
@@ -711,13 +1530,13 @@ function retainedFindingSnapshot(ids, dbPath) {
   try {
     const findings = [];
     const scanIds = /* @__PURE__ */ new Set();
-    for (const id of new Set(ids)) {
-      const row = db.getFinding(id);
+    for (const id2 of new Set(ids)) {
+      const row = db.getFinding(id2);
       if (!row) throw new ReportArtifactError("A selected finding was not found in this engine.", 404);
       scanIds.add(row.scanId);
-      findings.push(loadFindingFocus(id, { dbPath }).finding);
+      findings.push(loadFindingFocus(id2, { dbPath }).finding);
     }
-    const scans = [...scanIds].map((id) => db.getScan(id)).filter((scan) => scan !== void 0);
+    const scans = [...scanIds].map((id2) => db.getScan(id2)).filter((scan) => scan !== void 0);
     return {
       target: scans.length === 1 ? scans[0].target : "Selected findings from multiple runs",
       scanDepth: "default",
@@ -763,7 +1582,7 @@ function handleFindingImpactRequest(pathname, method, input, options) {
 }
 
 // packages/cli/src/web/findings-access-tokens.ts
-import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes2, randomUUID as randomUUID3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { closeSync, constants, fstatSync, mkdirSync, openSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -1442,13 +2261,13 @@ function createRemoteJWKSet(url, options) {
   }
   const reload = async () => {
     if (pendingFetch && isCloudflareWorkers() && (pendingFetch = void 0), !pendingFetch) {
-      const sequence = ++reloadSequence, current = pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl).then((json2) => {
-        const next = createLocalJWKSet(json2);
+      const sequence = ++reloadSequence, current = pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl).then((json3) => {
+        const next = createLocalJWKSet(json3);
         if (sequence <= appliedSequence)
           return;
         local = next;
         const updatedAt = Date.now();
-        cache2 && (cache2.uat = updatedAt, cache2.jwks = json2), jwksTimestamp = updatedAt, appliedSequence = sequence;
+        cache2 && (cache2.uat = updatedAt, cache2.jwks = json3), jwksTimestamp = updatedAt, appliedSequence = sequence;
       }).finally(() => {
         pendingFetch === current && (pendingFetch = void 0);
       });
@@ -1534,8 +2353,8 @@ function parseCookies(header) {
   return cookies;
 }
 function getSessionId(req) {
-  const id = parseCookies(req.headers.cookie)[COOKIE];
-  return id && /^[\w-]{43}$/.test(id) ? id : void 0;
+  const id2 = parseCookies(req.headers.cookie)[COOKIE];
+  return id2 && /^[\w-]{43}$/.test(id2) ? id2 : void 0;
 }
 async function hashTeamPassword(password) {
   if (!password || password.length > 1024) throw new TeamAuthError("Password must contain 1\u20131024 characters", 400);
@@ -1592,8 +2411,8 @@ var TeamAuth = class {
   cookie(name, value, seconds) {
     return `${name}=${value}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${seconds}${this.origin.startsWith("https:") ? "; Secure" : ""}`;
   }
-  lookupUser(id) {
-    const user = this.config?.users.find((row) => row.id === id);
+  lookupUser(id2) {
+    const user = this.config?.users.find((row) => row.id === id2);
     return user ? { workspaceId: this.config.workspace.id, userId: user.id, displayName: user.name, role: user.role } : null;
   }
   /** Trusted server configuration only; never serialize this through a browser API. */
@@ -1617,11 +2436,11 @@ var TeamAuth = class {
     this.config.users.push(member);
     return this.lookupUser(member.id);
   }
-  resolveSessionId(id) {
-    if (!id) return null;
-    const session = this.sessions.get(id);
+  resolveSessionId(id2) {
+    if (!id2) return null;
+    const session = this.sessions.get(id2);
     if (!session || session.expires <= this.now()) {
-      this.sessions.delete(id);
+      this.sessions.delete(id2);
       return null;
     }
     return this.lookupUser(session.userId);
@@ -1633,7 +2452,7 @@ var TeamAuth = class {
     return { enabled: this.enabled, ...this.config ? { workspace: this.config.workspace } : {}, user: this.resolveSession(req), sso: !!this.config?.oidc };
   }
   issueSession(userId) {
-    for (const [id, session] of this.sessions) if (session.expires <= this.now()) this.sessions.delete(id);
+    for (const [id2, session] of this.sessions) if (session.expires <= this.now()) this.sessions.delete(id2);
     if (this.sessions.size >= 1e4) throw new TeamAuthError("Session capacity reached", 503);
     const sessionId = opaque();
     this.sessions.set(sessionId, { userId, expires: this.now() + SESSION_MS });
@@ -1644,7 +2463,7 @@ var TeamAuth = class {
     const parsed = external_exports.object({ userId: external_exports.string().min(1).max(160), password: external_exports.string().min(1).max(1024) }).strict().safeParse(input);
     if (!parsed.success) throw new TeamAuthError("User ID and password are required", 400);
     const key = rateKey;
-    for (const [id, row] of this.attempts) if (row.expires <= this.now()) this.attempts.delete(id);
+    for (const [id2, row] of this.attempts) if (row.expires <= this.now()) this.attempts.delete(id2);
     const attempt = this.attempts.get(key) ?? { count: 0, expires: this.now() + 6e4 };
     if (attempt.count >= 10 || this.attempts.size >= 1e4) throw new TeamAuthError("Too many sign-in attempts; try again shortly", 429);
     attempt.count++;
@@ -1655,8 +2474,8 @@ var TeamAuth = class {
     return this.issueSession(user.id);
   }
   logout(req) {
-    const id = getSessionId(req);
-    if (id) this.sessions.delete(id);
+    const id2 = getSessionId(req);
+    if (id2) this.sessions.delete(id2);
     return { setCookie: this.cookie(COOKIE, "", 0) };
   }
   requireProviderURL(value) {
@@ -1680,7 +2499,7 @@ var TeamAuth = class {
   async beginSSO() {
     const discovery = await this.getDiscovery();
     const oidc = this.config.oidc;
-    for (const [id, pending] of this.pending) if (pending.expires <= this.now()) this.pending.delete(id);
+    for (const [id2, pending] of this.pending) if (pending.expires <= this.now()) this.pending.delete(id2);
     if (this.pending.size >= 1e3) throw new TeamAuthError("Too many pending sign-ins", 429);
     const state = opaque(), nonce = opaque(), verifier = opaque(), browser = opaque();
     this.pending.set(state, { nonce, verifier, browser, expires: this.now() + SSO_MS });
@@ -1739,7 +2558,7 @@ var publicTokenSchema = external_exports.object({
 }).strict();
 var tokenSchema = publicTokenSchema.extend({ tokenHash: external_exports.string().regex(/^[a-f0-9]{64}$/) }).strict();
 var stateSchema = external_exports.object({ schemaVersion: external_exports.literal(1), workspaceId: external_exports.string(), tokens: external_exports.array(tokenSchema).max(1e3) }).strict();
-var createSchema = external_exports.object({
+var createSchema2 = external_exports.object({
   name: external_exports.string().trim().min(1).max(160),
   scopes: scopesSchema.optional(),
   expiresAt: external_exports.string().datetime().nullable().optional()
@@ -1788,7 +2607,7 @@ var FindingsAccessTokenStore = class {
   #write(records) {
     const state = stateSchema.safeParse({ schemaVersion: 1, workspaceId: this.workspaceId, tokens: records });
     if (!state.success) throw new FindingsAccessError("API credential limit reached.", 409);
-    const temporary = this.#path + "." + randomUUID2() + ".tmp";
+    const temporary = this.#path + "." + randomUUID3() + ".tmp";
     try {
       writeFileSync(temporary, JSON.stringify(state.data), { flag: "wx", mode: 384 });
       renameSync(temporary, this.#path);
@@ -1822,22 +2641,22 @@ var FindingsAccessTokenStore = class {
   /** Caller supplies a verified owner identity, never createdBy from the HTTP body. */
   create(input, createdBy) {
     return this.#mutate(() => {
-      const parsed = createSchema.safeParse(input);
+      const parsed = createSchema2.safeParse(input);
       if (!parsed.success || !createdBy || createdBy.length > 256) throw new FindingsAccessError("Use a name, optional read:findings scope and future expiry.");
       const records = this.#read();
       const now = this.#now();
       const expiresAt = parsed.data.expiresAt === void 0 ? new Date(now + 90 * 864e5).toISOString() : parsed.data.expiresAt;
       if (expiresAt !== null && Date.parse(expiresAt) <= now) throw new FindingsAccessError("API credential expiry must be in the future.");
       const token = "0_find_" + randomBytes2(32).toString("base64url");
-      const record = { id: randomUUID2(), workspaceId: this.workspaceId, name: parsed.data.name, scopes: ["read:findings"], createdBy, createdAt: new Date(now).toISOString(), expiresAt, revokedAt: null, tokenHash: createHash2("sha256").update(token).digest("hex") };
+      const record = { id: randomUUID3(), workspaceId: this.workspaceId, name: parsed.data.name, scopes: ["read:findings"], createdBy, createdAt: new Date(now).toISOString(), expiresAt, revokedAt: null, tokenHash: createHash2("sha256").update(token).digest("hex") };
       this.#write([...records, record]);
       return { credential: redact(record), token };
     });
   }
-  revoke(id) {
+  revoke(id2) {
     return this.#mutate(() => {
       const records = this.#read();
-      const record = records.find((token) => token.id === id);
+      const record = records.find((token) => token.id === id2);
       if (!record) throw new FindingsAccessError("API credential not found.", 404);
       record.revokedAt ??= new Date(this.#now()).toISOString();
       this.#write(records);
@@ -1894,12 +2713,12 @@ var FindingsReadApi = class {
     this.#dbPath = resolveOsecDbPath(options.dbPath);
     this.workspaceId = options.workspaceId;
   }
-  #item(db, id) {
-    const row = db.getFinding(id);
+  #item(db, id2) {
+    const row = db.getFinding(id2);
     if (!row) throw new FindingsAccessError("Finding not found.", 404);
     const scan = db.getScan(row.scanId);
     if (!scan) throw new FindingsAccessError("Finding source scan was not retained.", 404);
-    return { scanId: row.scanId, target: scan.target, finding: findingFromRow(row, { ...db.getFindingReviewFields(id) }) };
+    return { scanId: row.scanId, target: scan.target, finding: findingFromRow(row, { ...db.getFindingReviewFields(id2) }) };
   }
   list(query) {
     const raw = {};
@@ -1934,11 +2753,11 @@ var FindingsReadApi = class {
       db.close();
     }
   }
-  detail(id) {
-    if (!boundedId.safeParse(id).success) throw new FindingsAccessError("Invalid finding ID.");
+  detail(id2) {
+    if (!boundedId.safeParse(id2).success) throw new FindingsAccessError("Invalid finding ID.");
     const db = new osecDB(this.#dbPath, { readOnly: true });
     try {
-      return { schemaVersion: 1, workspaceId: this.workspaceId, ...this.#item(db, id) };
+      return { schemaVersion: 1, workspaceId: this.workspaceId, ...this.#item(db, id2) };
     } finally {
       db.close();
     }
@@ -1946,7 +2765,7 @@ var FindingsReadApi = class {
   export(query) {
     if ([...query.keys()].some((key) => key !== "id")) throw new FindingsAccessError("Use repeated id parameters to select export findings.");
     const ids = query.getAll("id");
-    if (!ids.length || ids.length > 500 || ids.some((id) => !boundedId.safeParse(id).success) || new Set(ids).size !== ids.length) throw new FindingsAccessError("Select 1\u2013500 distinct exact finding IDs.");
+    if (!ids.length || ids.length > 500 || ids.some((id2) => !boundedId.safeParse(id2).success) || new Set(ids).size !== ids.length) throw new FindingsAccessError("Select 1\u2013500 distinct exact finding IDs.");
     return { schemaVersion: 1, workspaceId: this.workspaceId, coverage: "selected-retained-findings", report: retainedFindingSnapshot(ids, this.#dbPath) };
   }
 };
@@ -2023,8 +2842,11 @@ function engagementMarkdown(report) {
   return lines.filter((line, index) => line !== "" || lines[index - 1] !== "").join("\n");
 }
 
+// packages/cli/src/web/workspace-services.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+
 // packages/cli/src/web/skills.ts
-import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
 import { constants as constants2, closeSync as closeSync2, fstatSync as fstatSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync2, renameSync as renameSync2, rmSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join2, resolve as resolve2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
@@ -2121,12 +2943,12 @@ var SkillsStore = class _SkillsStore {
   #discovery() {
     return discoverAgentSkills(this.discoveryOptions());
   }
-  #builtin(id) {
-    const builtinId = id.startsWith("builtin/") ? id.slice(8) : id.includes("/") ? void 0 : id;
+  #builtin(id2) {
+    const builtinId = id2.startsWith("builtin/") ? id2.slice(8) : id2.includes("/") ? void 0 : id2;
     if (!builtinId) return;
     const skill = loadSkillRegistry().get(builtinId);
     if (!skill) return;
-    id = `builtin/${builtinId}`;
+    id2 = `builtin/${builtinId}`;
     const name = skill.id;
     const content = `---
 name: ${name}
@@ -2136,20 +2958,20 @@ description: ${JSON.stringify(skill.description)}
 ${skill.content}
 `;
     const files = [{ path: "SKILL.md", bytes: Buffer.from(content) }];
-    return { metadata: { id, name, description: skill.description, scope: "builtin", revision: revision(files), writable: false, fileCount: 1, source: "Built in" }, files };
+    return { metadata: { id: id2, name, description: skill.description, scope: "builtin", revision: revision(files), writable: false, fileCount: 1, source: "Built in" }, files };
   }
-  #entry(id) {
-    const built = this.#builtin(id);
+  #entry(id2) {
+    const built = this.#builtin(id2);
     if (built) return built;
-    const skill = this.#discovery().skills.find((row) => row.id === id);
+    const skill = this.#discovery().skills.find((row) => row.id === id2);
     if (!skill) throw new SkillsError("Skill not found.", 404);
     return this.#describe(skill);
   }
   #describe(skill) {
-    const id = skill.id;
+    const id2 = skill.id;
     const files = readFiles(skill.directory);
     const shared = skill.root === this.#shared || skill.directory.startsWith(this.#shared + "/");
-    return { metadata: { id, name: skill.name, description: skill.description, scope: shared ? "workspace" : skill.source === "mount" ? "mounted" : skill.source, revision: revision(files), writable: shared, fileCount: files.length, source: shared ? "Workspace" : skill.directory }, files, directory: skill.directory };
+    return { metadata: { id: id2, name: skill.name, description: skill.description, scope: shared ? "workspace" : skill.source === "mount" ? "mounted" : skill.source, revision: revision(files), writable: shared, fileCount: files.length, source: shared ? "Workspace" : skill.directory }, files, directory: skill.directory };
   }
   #access(metadata, access = {}) {
     return { ...metadata, writable: access.canWrite !== false && metadata.scope !== "builtin" && (metadata.scope === "workspace" || access.allowHostEdits === true) };
@@ -2168,12 +2990,12 @@ ${skill.content}
     for (const skill of loadSkillRegistry().values()) skills.push(this.#builtin(`builtin/${skill.id}`).metadata);
     return { skills, mounts: this.mounts(), diagnostics, workspacePath: this.workspacePath };
   }
-  get(id, access = {}) {
-    const row = this.#entry(id);
+  get(id2, access = {}) {
+    const row = this.#entry(id2);
     return { ...this.#access(row.metadata, access), content: row.files.find((file) => file.path === "SKILL.md").bytes.toString("utf8"), files: row.files.map((file) => ({ path: file.path, size: file.bytes.length })) };
   }
-  export(id) {
-    const row = this.#entry(id);
+  export(id2) {
+    const row = this.#entry(id2);
     return { format: "agent-skill", version: 1, name: row.metadata.name, files: row.files.map((file) => ({ path: file.path, encoding: "base64", content: file.bytes.toString("base64") })) };
   }
   #validate(content, name) {
@@ -2241,7 +3063,7 @@ ${skill.content}
     } catch (cause) {
       if (cause.code !== "ENOENT") throw cause;
     }
-    const temporary = join2(this.#state, `.import-${randomUUID3()}`);
+    const temporary = join2(this.#state, `.import-${randomUUID4()}`);
     mkdirSync2(temporary, { mode: 448 });
     try {
       for (const file of files) {
@@ -2280,31 +3102,31 @@ ${skill.content}
     if (!names.has("SKILL.md")) throw new SkillsError("Skill bundle needs SKILL.md.");
     return this.get(this.#write(files, bundle.name));
   }
-  update(id, input, access = {}) {
-    return this.#transaction(() => this.#update(id, input, access));
+  update(id2, input, access = {}) {
+    return this.#transaction(() => this.#update(id2, input, access));
   }
-  #update(id, input, access) {
+  #update(id2, input, access) {
     const { content, expectedRevision } = parse(external_exports.object({ content: external_exports.string().min(1).max(MAX_BYTES), expectedRevision: external_exports.string().regex(/^[a-f0-9]{64}$/) }).strict(), input);
-    const row = this.#entry(id);
+    const row = this.#entry(id2);
     if (!this.#access(row.metadata, access).writable) throw new SkillsError(row.metadata.scope === "builtin" ? "Save a workspace copy to edit this built-in skill." : "This account cannot edit this skill folder. Save a workspace copy instead.", 403);
     if (row.metadata.revision !== expectedRevision) throw new SkillsError("This skill changed. Reload it before saving.", 409);
     this.#validate(content, row.metadata.name);
     if (row.files.reduce((total, file) => total + (file.path === "SKILL.md" ? Buffer.byteLength(content) : file.bytes.length), 0) > MAX_BYTES) throw new SkillsError("Skill bundle exceeds its size limit.");
     const target = join2(row.directory, "SKILL.md");
-    const pending = join2(row.directory, `.skill-edit-${randomUUID3()}.tmp`);
+    const pending = join2(row.directory, `.skill-edit-${randomUUID4()}.tmp`);
     try {
       writeFileSync2(pending, content, { flag: "wx", mode: lstatSync2(target).mode & 511 });
       renameSync2(pending, target);
     } finally {
       rmSync(pending, { force: true });
     }
-    return this.get(id, access);
+    return this.get(id2, access);
   }
-  copy(id, input, access = {}) {
+  copy(id2, input, access = {}) {
     if (access.canWrite === false) throw new SkillsError("This account has read-only workspace access.", 403);
     return this.#transaction(() => {
       const { content, expectedRevision } = parse(external_exports.object({ content: external_exports.string().min(1).max(MAX_BYTES), expectedRevision: external_exports.string().regex(/^[a-f0-9]{64}$/) }).strict(), input);
-      const row = this.#entry(id);
+      const row = this.#entry(id2);
       if (row.metadata.revision !== expectedRevision) throw new SkillsError("This skill changed. Reload it before copying.", 409);
       const { name } = this.#validate(content);
       const files = row.files.map((file) => file.path === "SKILL.md" ? { path: file.path, bytes: Buffer.from(content) } : file);
@@ -2319,18 +3141,18 @@ ${skill.content}
     };
     return {
       list: () => this.list(access),
-      read: (id) => this.get(id, access),
+      read: (id2) => this.get(id2, access),
       create: (content) => {
         assertWrite();
         return this.create({ content });
       },
-      update: (id, input) => {
+      update: (id2, input) => {
         assertWrite();
-        return this.update(id, input, access);
+        return this.update(id2, input, access);
       },
-      copy: (id, input) => {
+      copy: (id2, input) => {
         assertWrite();
-        return this.copy(id, input, access);
+        return this.copy(id2, input, access);
       }
     };
   }
@@ -2349,24 +3171,24 @@ ${skill.content}
     const mounts = this.mounts();
     if (mounts.length >= 100) throw new SkillsError("At most 100 folders can be mounted.", 409);
     if (mounts.some((item) => item.path === canonical)) throw new SkillsError("This folder is already mounted.", 409);
-    const mount = { id: randomUUID3(), path: canonical };
+    const mount = { id: randomUUID4(), path: canonical };
     const found = discoverAgentSkills({ homeDir: null, mounts: [mount] });
     if (!found.skills.length) throw new SkillsError("No valid SKILL.md folders found.");
     mounts.push(mount);
     this.#saveMounts(mounts);
     return mount;
   }
-  unmount(id) {
-    return this.#transaction(() => this.#unmount(id));
+  unmount(id2) {
+    return this.#transaction(() => this.#unmount(id2));
   }
-  #unmount(id) {
+  #unmount(id2) {
     const mounts = this.mounts();
-    if (!mounts.some((item) => item.id === id)) throw new SkillsError("Mount not found.", 404);
-    this.#saveMounts(mounts.filter((item) => item.id !== id));
+    if (!mounts.some((item) => item.id === id2)) throw new SkillsError("Mount not found.", 404);
+    this.#saveMounts(mounts.filter((item) => item.id !== id2));
   }
   #saveMounts(mounts) {
     mkdirSync2(this.#state, { recursive: true, mode: 448 });
-    const temporary = join2(this.#state, `.mounts-${randomUUID3()}`);
+    const temporary = join2(this.#state, `.mounts-${randomUUID4()}`);
     try {
       writeFileSync2(temporary, JSON.stringify(mounts), { flag: "wx", mode: 384 });
       renameSync2(temporary, join2(this.#state, "mounts.json"));
@@ -2377,7 +3199,7 @@ ${skill.content}
 };
 
 // packages/cli/src/web/engagements.ts
-import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
 import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync3, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync4, realpathSync as realpathSync3, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
 var EngagementError = class extends Error {
@@ -2438,7 +3260,7 @@ var EngagementStore = class {
     const body = JSON.stringify({ schemaVersion: 1, workspace: this.workspace, engagements });
     if (Buffer.byteLength(body) > MAX_STATE_BYTES) throw new EngagementError("Engagement storage limit reached.", 409);
     mkdirSync3(this.#directory, { recursive: true, mode: 448 });
-    const temporary = `${this.#path}.${randomUUID4()}.tmp`;
+    const temporary = `${this.#path}.${randomUUID5()}.tmp`;
     try {
       writeFileSync3(temporary, body, { flag: "wx", mode: 384 });
       renameSync3(temporary, this.#path);
@@ -2454,7 +3276,7 @@ var EngagementStore = class {
     if (!ids.length) return;
     const db = new osecDB(this.#dbPath);
     try {
-      for (const id of ids) if (!db.getScan(id)) throw new EngagementError(`Selected scan was not found: ${id}`, 404);
+      for (const id2 of ids) if (!db.getScan(id2)) throw new EngagementError(`Selected scan was not found: ${id2}`, 404);
     } finally {
       db.close();
     }
@@ -2514,8 +3336,8 @@ var EngagementStore = class {
   list() {
     return this.#read().sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   }
-  get(id) {
-    const row = this.#read().find((item) => item.id === id);
+  get(id2) {
+    const row = this.#read().find((item) => item.id === id2);
     if (!row) throw new EngagementError("Engagement not found in this workspace.", 404);
     return row;
   }
@@ -2526,17 +3348,17 @@ var EngagementStore = class {
     return this.#transaction((rows) => {
       if (rows.length >= 200) throw new EngagementError("Engagement limit reached.", 409);
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const row = { ...fields, id: randomUUID4(), revision: 1, createdAt: now, updatedAt: now, ...attribution ? { createdBy: attribution, updatedBy: attribution } : {} };
+      const row = { ...fields, id: randomUUID5(), revision: 1, createdAt: now, updatedAt: now, ...attribution ? { createdBy: attribution, updatedBy: attribution } : {} };
       rows.push(row);
       return structuredClone(row);
     });
   }
-  update(id, input, actor) {
+  update(id2, input, actor) {
     const { expectedRevision, ...patch } = parse2(updateSchema, input);
     const attribution = actor ? parse2(actorSchema, actor) : void 0;
     if (patch.scanIds) this.#validateScans(patch.scanIds);
     return this.#transaction((rows) => {
-      const index = rows.findIndex((row2) => row2.id === id);
+      const index = rows.findIndex((row2) => row2.id === id2);
       if (index < 0) throw new EngagementError("Engagement not found in this workspace.", 404);
       if (attribution && expectedRevision === void 0) throw new EngagementError("Review the latest report before saving. Your draft has been kept.", 409);
       if (expectedRevision !== void 0 && rows[index].revision !== expectedRevision) throw new EngagementError("Report changed. Your draft has been kept. Reload the latest version before saving.", 409);
@@ -2545,8 +3367,8 @@ var EngagementStore = class {
       return structuredClone(row);
     });
   }
-  report(id) {
-    const engagement = this.get(id);
+  report(id2) {
+    const engagement = this.get(id2);
     const db = new osecDB(this.#dbPath);
     try {
       const sources = engagement.scanIds.map((scanId) => {
@@ -2568,22 +3390,22 @@ function reviewStatus(finding) {
 function assembleEngagementReport(engagement, sources) {
   const record = parse2(recordSchema, engagement);
   const byScan = new Map(sources.map((source) => [source.scan.id, source]));
-  if (byScan.size !== sources.length || sources.length !== record.scanIds.length || record.scanIds.some((id) => !byScan.has(id))) throw new EngagementError("Report sources must match exactly the selected scan IDs.", 404);
+  if (byScan.size !== sources.length || sources.length !== record.scanIds.length || record.scanIds.some((id2) => !byScan.has(id2))) throw new EngagementError("Report sources must match exactly the selected scan IDs.", 404);
   const groups = /* @__PURE__ */ new Map();
   let findingCount = 0;
-  const scans = record.scanIds.map((id) => {
-    const source = byScan.get(id);
+  const scans = record.scanIds.map((id2) => {
+    const source = byScan.get(id2);
     for (const finding of source.report.findings) {
       findingCount++;
       const fingerprint = finding.fingerprint?.trim();
-      const key = fingerprint ? `fingerprint:${fingerprint}` : `source:${id}:${finding.id}`;
+      const key = fingerprint ? `fingerprint:${fingerprint}` : `source:${id2}:${finding.id}`;
       const status = reviewStatus(finding);
       let group = groups.get(key);
       if (!group) {
         group = { key, ...fingerprint ? { fingerprint } : {}, reviewStatus: status, occurrences: [] };
         groups.set(key, group);
       } else if (group.reviewStatus !== status) group.reviewStatus = "unreviewed";
-      group.occurrences.push({ scanId: id, findingId: finding.id, finding: structuredClone(finding) });
+      group.occurrences.push({ scanId: id2, findingId: finding.id, finding: structuredClone(finding) });
     }
     return { ...source.scan, warnings: structuredClone(source.report.warnings), executionSuccessful: source.report.executionSuccessful, exitReason: source.report.exitReason, ...source.report.error ? { error: source.report.error } : {} };
   });
@@ -2606,8 +3428,8 @@ function assembleEngagementReport(engagement, sources) {
 }
 
 // packages/cli/src/web/workflow-triggers.ts
-var createSchema2 = external_exports.object({ workflowId: external_exports.string().min(1).max(160), workflowRevision: external_exports.number().int().positive(), sessionId: external_exports.string().min(1).max(160), cadence: external_exports.enum(["hourly", "daily", "weekly"]), startAt: external_exports.string().datetime({ offset: true }), timezone: external_exports.string().min(1).max(100), enabled: external_exports.boolean(), approval: external_exports.literal("enable-reviewed-trigger").optional() }).strict();
-var toggleSchema = external_exports.object({ enabled: external_exports.boolean(), approval: external_exports.literal("enable-reviewed-trigger").optional() }).strict();
+var createSchema3 = external_exports.object({ workflowId: external_exports.string().min(1).max(160), workflowRevision: external_exports.number().int().positive(), sessionId: external_exports.string().min(1).max(160), cadence: external_exports.enum(["hourly", "daily", "weekly"]), startAt: external_exports.string().datetime({ offset: true }), timezone: external_exports.string().min(1).max(100), enabled: external_exports.boolean(), approval: external_exports.literal("enable-reviewed-trigger").optional() }).strict();
+var toggleSchema = external_exports.object({ enabled: external_exports.boolean().optional(), cadence: external_exports.enum(["hourly", "daily", "weekly"]).optional(), startAt: external_exports.string().datetime({ offset: true }).optional(), timezone: external_exports.string().min(1).max(100).optional(), workflowRevision: external_exports.number().int().positive().optional(), expectedVersion: external_exports.number().int().positive().optional(), approval: external_exports.literal("enable-reviewed-trigger").optional() }).strict().refine((value) => ["enabled", "cadence", "startAt", "timezone", "workflowRevision"].some((key) => key in value), "Provide a schedule change.");
 var PREFIX = "/api/console/workflow-triggers";
 var terminal = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "interrupted"]);
 var WorkflowTriggerService = class {
@@ -2632,10 +3454,10 @@ var WorkflowTriggerService = class {
   async handle(method, url, input) {
     if (url.pathname !== PREFIX && !url.pathname.startsWith(`${PREFIX}/`)) return null;
     try {
-      const id = url.pathname.slice(PREFIX.length + 1);
+      const id2 = url.pathname.slice(PREFIX.length + 1);
       if (url.pathname === PREFIX && method === "GET") return { status: 200, data: { triggers: this.#store.list(url.searchParams.get("workflowId") ?? void 0).map(publicTrigger) } };
       if (url.pathname === PREFIX && method === "POST") {
-        const parsed = createSchema2.parse(input);
+        const parsed = createSchema3.parse(input);
         try {
           new Intl.DateTimeFormat("en", { timeZone: parsed.timezone });
         } catch {
@@ -2654,22 +3476,42 @@ var WorkflowTriggerService = class {
         }
         return { status: 201, data: { trigger: publicTrigger(this.#store.create({ ...fields, reviewedConnectionIdentity: identity?.connectionIdentity, reviewedModel: identity?.model, reviewedProviderId: identity?.providerId })) } };
       }
-      const trigger = this.#store.get(id);
+      const trigger = this.#store.get(id2);
       if (!trigger) return error(404, "Schedule not found.");
       if (method === "PATCH") {
         const patch = toggleSchema.parse(input);
+        if (patch.expectedVersion !== void 0 && patch.expectedVersion !== (trigger.version ?? 1)) return error(409, "Schedule changed. Review it again before enabling.");
+        if (trigger.activeClaim && ["cadence", "startAt", "timezone", "workflowRevision"].some((key) => key in patch)) return error(409, "Pause the schedule and wait for its active execution before editing.");
+        const changedTiming = patch.cadence !== void 0 || patch.startAt !== void 0 || patch.timezone !== void 0 || patch.workflowRevision !== void 0;
+        const enabled = patch.enabled ?? (changedTiming ? false : trigger.enabled);
+        const next = { ...trigger, ...patch, enabled };
+        try {
+          new Intl.DateTimeFormat("en", { timeZone: next.timezone });
+        } catch {
+          return error(400, "Choose a valid timezone.");
+        }
         let identity = void 0;
-        if (patch.enabled) {
+        if (enabled) {
           if (!patch.approval) return error(400, "Review this schedule before enabling it.");
           const definition = this.#workflows.get(trigger.workflowId);
-          if (definition?.revision !== trigger.workflowRevision) return error(409, "Workflow changed. Create a schedule for its current revision.");
-          identity = await this.#adapter.validate(trigger);
-          this.#verifyIdentity(trigger, identity);
+          if (definition?.revision !== next.workflowRevision) return error(409, "Workflow changed. Review its current revision before scheduling.");
+          identity = await this.#adapter.validate(next);
+          if (!changedTiming) this.#verifyIdentity(trigger, identity);
         }
-        return { status: 200, data: { trigger: publicTrigger(this.#store.update(id, { ...patch.enabled ? { reviewedModel: trigger.reviewedModel ?? identity?.model, reviewedProviderId: trigger.reviewedProviderId ?? identity?.providerId, reviewedConnectionIdentity: trigger.reviewedConnectionIdentity ?? identity?.connectionIdentity } : {}, enabled: patch.enabled, lastStatus: patch.enabled ? "scheduled" : "paused", lastError: void 0, nextFireAt: nextWorkflowTriggerFire(trigger.startAt, trigger.cadence, Date.now()) }, patch.enabled ? trigger.version ?? 1 : void 0)) } };
+        return { status: 200, data: { trigger: publicTrigger(this.#store.update(id2, {
+          cadence: next.cadence,
+          startAt: next.startAt,
+          timezone: next.timezone,
+          workflowRevision: next.workflowRevision,
+          ...enabled ? { reviewedModel: identity?.model, reviewedProviderId: identity?.providerId, reviewedConnectionIdentity: identity?.connectionIdentity } : {},
+          enabled,
+          lastStatus: enabled ? "scheduled" : "paused",
+          lastError: void 0,
+          nextFireAt: nextWorkflowTriggerFire(next.startAt, next.cadence, Date.now())
+        }, enabled ? trigger.version ?? 1 : patch.expectedVersion)) } };
       }
       if (method === "DELETE") {
-        if (!this.#store.delete(id)) return error(409, "Pause the schedule and wait for its active execution before deleting.");
+        if (!this.#store.delete(id2)) return error(409, "Pause the schedule and wait for its active execution before deleting.");
         return { status: 200, data: { deleted: true } };
       }
       return error(405, "Unsupported schedule action.");
@@ -2677,6 +3519,43 @@ var WorkflowTriggerService = class {
       return error(cause instanceof external_exports.ZodError ? 400 : 409, cause instanceof Error ? cause.message.slice(0, 1e3) : "Schedule could not be updated.");
     }
   }
+  /** Chat transport shares the same validation and scheduler as the HTTP editor. */
+  async invokeLifecycle(sessionId, name, args, context) {
+    const identifier = external_exports.string().min(1).max(160);
+    if (name === "list_schedules") {
+      const request = external_exports.object({ workflowId: identifier.optional() }).strict().parse(args);
+      if (context?.workflowId && request.workflowId && context.workflowId !== request.workflowId) throw new Error("This editor is bound to another workflow.");
+      return { schedules: this.#store.list(context?.workflowId ?? request.workflowId).filter((trigger) => context?.workflowId || trigger.sessionId === sessionId).map(publicTrigger) };
+    }
+    let method;
+    let path = PREFIX;
+    let input;
+    if (name === "create_schedule") {
+      const request = createSchema3.omit({ sessionId: true, approval: true }).extend({ enabled: external_exports.boolean().default(false) }).parse(args);
+      if (context?.workflowId && context.workflowId !== request.workflowId) throw new Error("This editor is bound to another workflow.");
+      if (request.enabled && !context?.activationApproved) throw new Error("Schedule activation requires operator approval.");
+      method = "POST";
+      input = { ...request, sessionId, ...request.enabled ? { approval: "enable-reviewed-trigger" } : {} };
+    } else if (name === "update_schedule" || name === "delete_schedule") {
+      const { id: id2, ...fields } = external_exports.object({ id: identifier }).passthrough().parse(args);
+      const trigger = this.#store.get(id2);
+      if (!trigger || (context?.workflowId ? trigger.workflowId !== context.workflowId : trigger.sessionId !== sessionId)) throw new Error("Schedule not found for this editor.");
+      path += `/${encodeURIComponent(id2)}`;
+      if (name === "delete_schedule") {
+        external_exports.object({}).strict().parse(fields);
+        method = "DELETE";
+        input = void 0;
+      } else {
+        const patch = toggleSchema.parse(fields);
+        if (patch.enabled && !context?.activationApproved) throw new Error("Schedule activation requires operator approval.");
+        method = "PATCH";
+        input = { ...patch, ...patch.enabled ? { approval: "enable-reviewed-trigger" } : {} };
+      }
+    } else throw new Error("Unknown schedule action.");
+    const result = await this.handle(method, new URL(path, "http://localhost"), input);
+    if (!result || result.status >= 400) throw new Error(result?.data?.error ?? "Schedule could not be updated.");
+    return result.data;
+  }
   async tick(now = Date.now()) {
     if (this.#closed || this.#polling) return;
     this.#polling = true;
@@ -2852,7 +3731,9 @@ var GitHubPublicationAuth = class {
 // packages/cli/src/web/workspace-services.ts
 async function createWorkspaceServices(options) {
   const skills = new SkillsStore({ workspace: options.workspace ?? process.cwd(), stateDir: options.stateDir ?? homeStateDir(), team: options.auth.enabled });
+  const remoteProviderRelays = new RemoteProviderRelayBroker({ epoch: options.relayEpoch ?? randomUUID6() });
   const gateway = new ConsoleGateway({
+    remoteProviderRelays,
     dbPath: options.dbPath,
     projectPath: options.workspace,
     skillAuthoring: (author, workspaceRoot) => {
@@ -2869,7 +3750,7 @@ async function createWorkspaceServices(options) {
   let triggers;
   let github;
   const dispose = async () => {
-    const actions = [() => engine?.dispose(), () => triggers?.dispose(), () => gateway.closeAll(), () => workflows?.dispose(), () => operator.dispose(), () => github?.dispose()];
+    const actions = [() => remoteProviderRelays.dispose(), () => engine?.dispose(), () => triggers?.dispose(), () => gateway.closeAll(), () => workflows?.dispose(), () => operator.dispose(), () => github?.dispose()];
     let failure;
     for (const action of actions) {
       try {
@@ -2900,8 +3781,10 @@ async function createWorkspaceServices(options) {
         return { executionId: result.execution.id };
       }
     } });
+    const schedules = triggers;
+    gateway.attachScheduleLifecycle({ invoke: (sessionId, name, args, context) => schedules.invokeLifecycle(sessionId, name, args, context) });
     github = new GitHubPublicationAuth();
-    return { skills, gateway, engagements, operator, workflows: workflow, engine, triggers, github, dispose };
+    return { remoteProviderRelays, skills, gateway, engagements, operator, workflows: workflow, engine, triggers, github, dispose };
   } catch (cause) {
     await dispose().catch(() => {
     });
@@ -2911,7 +3794,7 @@ async function createWorkspaceServices(options) {
 
 // packages/cli/src/web/team-setup.ts
 import { closeSync as closeSync4, constants as constants4, existsSync, fstatSync as fstatSync4, fsyncSync, mkdirSync as mkdirSync4, openSync as openSync4, readFileSync as readFileSync5, realpathSync as realpathSync4, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { createHash as createHash6, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
 import { dirname, join as join4, resolve as resolve3 } from "node:path";
 var setupSchema = external_exports.object({
   workspaceName: external_exports.string().trim().min(1).max(160),
@@ -2977,7 +3860,7 @@ var TeamSetupService = class {
     if (auth.members().length >= 1e3) throw new TeamAuthError("Workspace member limit reached", 409);
     this.busy = true;
     const lockPath = `${this.configPath}.lock`;
-    const tempPath = `${this.configPath}.${randomUUID5()}.tmp`;
+    const tempPath = `${this.configPath}.${randomUUID7()}.tmp`;
     let lockFD;
     let temporaryFD;
     try {
@@ -3034,7 +3917,7 @@ var TeamSetupService = class {
     try {
       const data = parsed.data;
       const config = {
-        workspace: { id: randomUUID5(), name: data.workspaceName },
+        workspace: { id: randomUUID7(), name: data.workspaceName },
         users: [{ id: data.userId, name: data.displayName, role: "owner", passwordHash: await hashTeamPassword(data.password) }]
       };
       const auth = new TeamAuth({ config, origin: this.options.origin() });
@@ -3087,7 +3970,7 @@ async function handleTeamSetupRequest(req, url, setup, readBody) {
 }
 
 // packages/cli/src/web/collaboration.ts
-import { createHash as createHash7, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID8 } from "node:crypto";
 import { closeSync as closeSync5, constants as constants5, fstatSync as fstatSync5, mkdirSync as mkdirSync5, openSync as openSync5, readFileSync as readFileSync6, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join5 } from "node:path";
 var CollaborationError = class extends Error {
@@ -3172,9 +4055,9 @@ var CollaborationService = class {
     });
   }
   /** Trusted post-write adapter only: the caller proves this resource exists in its workspace. */
-  notifyChanged(kind, id) {
-    if (!external_exports.object({ kind: resourceKindSchema, id: external_exports.string().min(1).max(160) }).safeParse({ kind, id }).success) throw new CollaborationError("Invalid changed resource.");
-    this.#publish({ type: "changed", kind, id });
+  notifyChanged(kind, id2) {
+    if (!external_exports.object({ kind: resourceKindSchema, id: external_exports.string().min(1).max(160) }).safeParse({ kind, id: id2 }).success) throw new CollaborationError("Invalid changed resource.");
+    this.#publish({ type: "changed", kind, id: id2 });
   }
   #actor(sessionId) {
     if (typeof sessionId !== "string" || !sessionId || sessionId.length > 4096) throw new CollaborationError("An authenticated team session is required.", 401);
@@ -3201,7 +4084,7 @@ var CollaborationService = class {
       if (bytes.length > 32 * 1024 * 1024) throw new Error("size");
       let source = JSON.parse(bytes.toString("utf8"));
       const legacy = external_exports.object({ schemaVersion: external_exports.literal(1), workspaceId: external_exports.string(), conversations: external_exports.array(external_exports.object({ id: external_exports.string(), revision: external_exports.number(), createdBy: attributionSchema, createdAt: external_exports.number(), members: external_exports.array(memberSchema2) }).passthrough()).max(1e3) }).strict().safeParse(source);
-      if (legacy.success) source = { schemaVersion: 2, workspaceId: legacy.data.workspaceId, rooms: legacy.data.conversations.map(({ id, revision: revision2, createdBy, createdAt, members }) => ({ kind: "conversation", id, revision: revision2, createdBy, createdAt, members })) };
+      if (legacy.success) source = { schemaVersion: 2, workspaceId: legacy.data.workspaceId, rooms: legacy.data.conversations.map(({ id: id2, revision: revision2, createdBy, createdAt, members }) => ({ kind: "conversation", id: id2, revision: revision2, createdBy, createdAt, members })) };
       const parsed = stateSchema3.parse(source);
       if (parsed.workspaceId !== this.#options.workspaceId || new Set(parsed.rooms.map((row) => this.#roomKey(row.kind, row.id))).size !== parsed.rooms.length) throw new Error("workspace");
       return parsed.rooms;
@@ -3216,7 +4099,7 @@ var CollaborationService = class {
     if (!state.success) throw new CollaborationError("Collaboration record limit reached.", 409);
     const data = JSON.stringify(state.data);
     if (Buffer.byteLength(data) > 32 * 1024 * 1024) throw new CollaborationError("Collaboration storage limit reached.", 409);
-    const temporary = this.#path + "." + randomUUID6() + ".tmp";
+    const temporary = this.#path + "." + randomUUID8() + ".tmp";
     try {
       writeFileSync5(temporary, data, { flag: "wx", mode: 384 });
       renameSync5(temporary, this.#path);
@@ -3278,11 +4161,11 @@ var CollaborationService = class {
       unlinkSync5(this.#lock);
     }
   }
-  #roomKey(kind, id) {
-    return kind + ":" + id;
+  #roomKey(kind, id2) {
+    return kind + ":" + id2;
   }
-  #room(rows, kind, id) {
-    const row = rows.find((item) => item.kind === kind && item.id === id);
+  #room(rows, kind, id2) {
+    const row = rows.find((item) => item.kind === kind && item.id === id2);
     if (!row) throw new CollaborationError("Shared resource room not found.", 404);
     return row;
   }
@@ -3304,8 +4187,8 @@ var CollaborationService = class {
     const { workspaceId: _workspace, ...viewer } = actor;
     return viewer;
   }
-  #presenceFor(kind, id) {
-    const entries = this.#presence.get(this.#roomKey(kind, id));
+  #presenceFor(kind, id2) {
+    const entries = this.#presence.get(this.#roomKey(kind, id2));
     const presence = /* @__PURE__ */ new Map();
     for (const [key, entry] of entries ?? []) {
       if (!entry.viewing || entry.updatedAt + this.#presenceMs <= this.#now()) {
@@ -3332,15 +4215,15 @@ var CollaborationService = class {
     return [...presence.values()];
   }
   /** Routing must validate that the underlying resource exists before registration. */
-  registerRoom(kind, id, sessionId) {
+  registerRoom(kind, id2, sessionId) {
     const actor = this.#actor(sessionId);
-    const valid = external_exports.object({ kind: resourceKindSchema, id: external_exports.string().min(1).max(160) }).safeParse({ kind, id });
+    const valid = external_exports.object({ kind: resourceKindSchema, id: external_exports.string().min(1).max(160) }).safeParse({ kind, id: id2 });
     if (!valid.success) throw new CollaborationError("Invalid resource room.");
     let joined = false;
     this.#transaction((rows) => {
-      let row = rows.find((item) => item.kind === kind && item.id === id);
+      let row = rows.find((item) => item.kind === kind && item.id === id2);
       if (!row) {
-        row = { kind, id, revision: 0, createdBy: this.#attribution(actor), createdAt: this.#now(), members: [] };
+        row = { kind, id: id2, revision: 0, createdBy: this.#attribution(actor), createdAt: this.#now(), members: [] };
         rows.push(row);
       }
       const revision2 = row.revision;
@@ -3348,7 +4231,7 @@ var CollaborationService = class {
       joined = row.revision !== revision2;
     });
     if (joined) this.#notifyPresence();
-    return this.roomSnapshot(kind, id, sessionId);
+    return this.roomSnapshot(kind, id2, sessionId);
   }
   register(conversationId, sessionId) {
     this.registerRoom("conversation", conversationId, sessionId);
@@ -3357,10 +4240,10 @@ var CollaborationService = class {
   hasConversation(conversationId) {
     return this.#read().some((row) => row.kind === "conversation" && row.id === conversationId);
   }
-  roomSnapshot(kind, id, sessionId) {
+  roomSnapshot(kind, id2, sessionId) {
     const actor = this.#actor(sessionId);
-    const row = this.#room(this.#read(), kind, id);
-    return { kind, id, workspaceId: this.#options.workspaceId, revision: row.revision, viewer: this.#viewer(actor), canWrite: actor.role !== "viewer", members: structuredClone(row.members), presence: this.#presenceFor(kind, id) };
+    const row = this.#room(this.#read(), kind, id2);
+    return { kind, id: id2, workspaceId: this.#options.workspaceId, revision: row.revision, viewer: this.#viewer(actor), canWrite: actor.role !== "viewer", members: structuredClone(row.members), presence: this.#presenceFor(kind, id2) };
   }
   snapshot(conversationId, sessionId) {
     const { kind: _kind, id: _id, ...snapshot } = this.roomSnapshot("conversation", conversationId, sessionId);
@@ -3374,19 +4257,19 @@ var CollaborationService = class {
     });
     return { workspaceId: this.#options.workspaceId, viewer: this.#viewer(actor), rooms };
   }
-  heartbeatRoom(kind, id, sessionId, input) {
+  heartbeatRoom(kind, id2, sessionId, input) {
     const actor = this.#actor(sessionId);
     const parsed = external_exports.object({ typing: external_exports.boolean(), viewing: external_exports.boolean().default(true), clientId: external_exports.string().uuid().optional() }).strict().safeParse(input);
     if (!parsed.success) throw new CollaborationError("Invalid presence update.");
-    this.#presenceFor(kind, id);
+    this.#presenceFor(kind, id2);
     let joined = false;
     this.#transaction((rows) => {
-      const row = this.#room(rows, kind, id);
+      const row = this.#room(rows, kind, id2);
       const revision2 = row.revision;
       this.#join(row, actor);
       joined = row.revision !== revision2;
     });
-    const key = this.#roomKey(kind, id);
+    const key = this.#roomKey(kind, id2);
     let entries = this.#presence.get(key);
     if (!entries) {
       entries = /* @__PURE__ */ new Map();
@@ -3398,7 +4281,7 @@ var CollaborationService = class {
     if (parsed.data.viewing) entries.set(entryKey, { ...this.#attribution(actor), sessionId, viewing: true, typing: parsed.data.typing, updatedAt: this.#now() });
     else entries.delete(entryKey);
     if (joined || previous?.typing !== (parsed.data.viewing ? parsed.data.typing : void 0) || previous?.displayName !== (parsed.data.viewing ? actor.displayName : void 0)) this.#notifyPresence();
-    return this.roomSnapshot(kind, id, sessionId);
+    return this.roomSnapshot(kind, id2, sessionId);
   }
   heartbeat(conversationId, sessionId, input) {
     this.heartbeatRoom("conversation", conversationId, sessionId, input);
@@ -3457,29 +4340,133 @@ async function handleTeamRequest(req, url, auth, collaboration, gateway, readBod
   if (resource2) {
     if (method !== "POST") throw new TeamAuthError("Method not allowed.", 405);
     const kind = resource2[1];
-    const id2 = resource2[2];
-    if (kind === "conversation") gateway.get(id2);
-    else if (validateResource) await validateResource(kind, id2);
+    const id3 = resource2[2];
+    if (kind === "conversation") gateway.get(id3);
+    else if (validateResource) await validateResource(kind, id3);
     else throw new TeamAuthError("Resource presence is not configured for this engine.", 404);
-    collaboration.registerRoom(kind, id2, session);
-    return { status: 200, data: collaboration.heartbeatRoom(kind, id2, session, await readBody()) };
+    collaboration.registerRoom(kind, id3, session);
+    return { status: 200, data: collaboration.heartbeatRoom(kind, id3, session, await readBody()) };
   }
   const match = /^conversations\/([A-Za-z0-9_.:-]+)(?:\/(presence))?$/.exec(path);
   if (!match) throw new TeamAuthError("Team resource not found.", 404);
-  const id = match[1];
-  gateway.get(id);
-  if (!collaboration.hasConversation(id)) collaboration.register(id, session);
-  if (!match[2] && method === "GET") return { status: 200, data: collaboration.snapshot(id, session) };
-  if (match[2] === "presence" && method === "POST") return { status: 200, data: collaboration.heartbeat(id, session, await readBody()) };
+  const id2 = match[1];
+  gateway.get(id2);
+  if (!collaboration.hasConversation(id2)) collaboration.register(id2, session);
+  if (!match[2] && method === "GET") return { status: 200, data: collaboration.snapshot(id2, session) };
+  if (match[2] === "presence" && method === "POST") return { status: 200, data: collaboration.heartbeat(id2, session, await readBody()) };
   throw new TeamAuthError("Method not allowed.", 405);
 }
-function assertTeamConsoleMutation(req, id, auth, collaboration, gateway) {
+function assertTeamConsoleMutation(req, id2, auth, collaboration, gateway) {
   if (!auth.enabled) return;
-  gateway.get(id);
+  gateway.get(id2);
   const session = getSessionId(req);
   if (!session || !collaboration) throw new TeamAuthError("Sign in to this workspace.");
-  if (!collaboration.hasConversation(id)) collaboration.register(id, session);
-  collaboration.assertWriter(id, session);
+  if (!collaboration.hasConversation(id2)) collaboration.register(id2, session);
+  collaboration.assertWriter(id2, session);
+}
+
+// packages/cli/src/web/browser-live-routes.ts
+var registry = { list: listBrowserViews, subscribe: subscribeBrowserView };
+var HEARTBEAT_MS = 15e3;
+var STREAM_LIFETIME_MS = 5 * 6e4;
+async function handleBrowserLiveRequest(req, res, url, ownerId, pageId, source = registry) {
+  const reply = (status, body) => {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  };
+  if (url.search) {
+    reply(400, { error: "Browser view endpoints do not accept query parameters." });
+    return;
+  }
+  if (req.method !== "GET") {
+    reply(405, { error: "Use GET for browser views." });
+    return;
+  }
+  const views = source.list(ownerId);
+  if (!pageId) {
+    reply(200, { views });
+    return;
+  }
+  const view = views.find((item) => item.pageId === pageId);
+  if (!view) {
+    reply(404, { error: "Browser view was closed or does not belong to this conversation." });
+    return;
+  }
+  if (!view.liveAvailable) {
+    reply(409, { error: "Live browser view is unavailable for this execution backend." });
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-store, no-transform",
+    "X-Accel-Buffering": "no",
+    Connection: "keep-alive"
+  });
+  res.flushHeaders?.();
+  let closed = false;
+  let blocked = false;
+  let unsubscribe;
+  let heartbeat;
+  let lifetime;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(heartbeat);
+    clearTimeout(lifetime);
+    unsubscribe?.();
+    unsubscribe = void 0;
+    res.off("drain", drain);
+    res.off("close", cleanup);
+    res.off("error", cleanup);
+    req.off("aborted", cleanup);
+  };
+  const drain = () => {
+    blocked = false;
+  };
+  const write = (event, data) => {
+    if (closed || blocked || res.destroyed || res.writableEnded) return;
+    blocked = !res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  };
+  const finish = (status) => {
+    write("state", { status });
+    cleanup();
+    if (!res.destroyed && !res.writableEnded) res.end();
+  };
+  res.on("drain", drain);
+  res.on("close", cleanup);
+  res.on("error", cleanup);
+  req.on("aborted", cleanup);
+  write("state", { status: "connecting" });
+  heartbeat = setInterval(() => {
+    try {
+      if (!source.list(ownerId).some((item) => item.pageId === pageId)) {
+        finish("closed");
+        return;
+      }
+      if (!closed && !blocked) blocked = !res.write(": heartbeat\n\n");
+    } catch {
+      finish("unavailable");
+    }
+  }, HEARTBEAT_MS);
+  lifetime = setTimeout(() => finish("expired"), STREAM_LIFETIME_MS);
+  heartbeat.unref?.();
+  lifetime.unref?.();
+  try {
+    const stop = await source.subscribe(ownerId, pageId, (frame) => {
+      if (closed || blocked || frame.mimeType !== "image/jpeg" || frame.data.length > 4 * 1024 * 1024) return;
+      write("frame", frame);
+    });
+    if (closed) stop();
+    else {
+      unsubscribe = stop;
+      write("state", { status: "live" });
+    }
+  } catch {
+    finish("unavailable");
+  }
 }
 
 // packages/cli/src/web/team-presence-stream.ts
@@ -3701,7 +4688,7 @@ function openBrowser(url) {
   execFile2(cmd, args, () => {
   });
 }
-function json(res, status, body) {
+function json2(res, status, body) {
   res.writeHead(status, {
     "Content-Type": "application/json; charset=utf-8",
     "Cache-Control": "no-store"
@@ -4387,7 +5374,7 @@ function requireControlToken(req, res, controlToken, engineBearer) {
   const matches = (a, b) => typeof a === "string" && Buffer.byteLength(a) === Buffer.byteLength(b) && timingSafeEqual3(Buffer.from(a), Buffer.from(b));
   const bearer = typeof req.headers.authorization === "string" && req.headers.authorization.startsWith("Bearer ") ? req.headers.authorization.slice(7) : void 0;
   if (!matches(provided, controlToken) && !matches(bearer, controlToken) && !(engineBearer && matches(bearer, engineBearer))) {
-    json(res, 403, { error: "Invalid or missing control token" });
+    json2(res, 403, { error: "Invalid or missing control token" });
     return false;
   }
   return true;
@@ -4414,52 +5401,52 @@ async function handleWebConsoleApiRequest(req, res, requestUrl, gateway, operato
     const bodyId = input && typeof input === "object" && "sessionId" in input && typeof input.sessionId === "string" ? input.sessionId : void 0;
     const savedId = /^saved\/([^/]+)/.exec(path)?.[1];
     const savedLiveId = savedId ? gateway.list().find((item) => item.id === savedId || item.savedId === savedId)?.id : void 0;
-    const id = liveId ?? bodyId ?? savedLiveId;
-    if (id && !readResume) assertTeamConsoleMutation(req, id, team.auth, team.collaboration, gateway);
+    const id2 = liveId ?? bodyId ?? savedLiveId;
+    if (id2 && !readResume) assertTeamConsoleMutation(req, id2, team.auth, team.collaboration, gateway);
   }
   try {
     if (path === "execution" && method === "GET") {
-      json(res, 200, await workbenchStatus());
+      json2(res, 200, await workbenchStatus());
       return true;
     }
     if (path === "github" && method === "GET") {
-      json(res, 200, { github: await github.status() });
+      json2(res, 200, { github: await github.status() });
       return true;
     }
     if (path === "github/connect" && method === "POST") {
-      json(res, 200, { github: await github.connect(input) });
+      json2(res, 200, { github: await github.connect(input) });
       return true;
     }
     if (path === "github/device-auth" && method === "POST") {
-      json(res, 202, { github: await github.start() });
+      json2(res, 202, { github: await github.start() });
       return true;
     }
     if (path === "github/device-auth" && method === "DELETE") {
-      json(res, 200, { github: await github.cancel() });
+      json2(res, 200, { github: await github.cancel() });
       return true;
     }
     const trigger = await triggers.handle(method, requestUrl, input);
     if (trigger) {
-      json(res, trigger.status, trigger.data);
+      json2(res, trigger.status, trigger.data);
       return true;
     }
     const workflow = await workflows.handle(requestUrl.pathname, method, input, requestUrl.searchParams);
     if (workflow) {
       if (team?.collaboration && method !== "GET" && method !== "HEAD" && workflow.status >= 200 && workflow.status < 300) {
         const definition = workflow.data && typeof workflow.data === "object" && "definition" in workflow.data ? workflow.data.definition : void 0;
-        const id2 = definition && typeof definition === "object" && "id" in definition && typeof definition.id === "string" ? definition.id : /^\/api\/console\/workflow-definitions\/([^/]+)/.exec(requestUrl.pathname)?.[1];
-        if (id2) team.collaboration.notifyChanged("workflow", decodeURIComponent(id2));
+        const id3 = definition && typeof definition === "object" && "id" in definition && typeof definition.id === "string" ? definition.id : /^\/api\/console\/workflow-definitions\/([^/]+)/.exec(requestUrl.pathname)?.[1];
+        if (id3) team.collaboration.notifyChanged("workflow", decodeURIComponent(id3));
       }
-      json(res, workflow.status, workflow.data);
+      json2(res, workflow.status, workflow.data);
       return true;
     }
     const service = await operator.handle(requestUrl.pathname, method, input, requestUrl.searchParams);
     if (service) {
-      json(res, service.status, service.data);
+      json2(res, service.status, service.data);
       return true;
     }
     if (path === "search" && method === "GET") {
-      json(res, 200, await gateway.search({
+      json2(res, 200, await gateway.search({
         q: requestUrl.searchParams.get("q") ?? "",
         ...requestUrl.searchParams.has("limit") ? { limit: Number(requestUrl.searchParams.get("limit")) } : {},
         ...requestUrl.searchParams.has("offset") ? { offset: Number(requestUrl.searchParams.get("offset")) } : {}
@@ -4467,84 +5454,99 @@ async function handleWebConsoleApiRequest(req, res, requestUrl, gateway, operato
       return true;
     }
     if (path === "sessions") {
-      if (method === "GET") json(res, 200, { sessions: gateway.list() });
+      if (method === "GET") json2(res, 200, { sessions: gateway.list() });
       else if (method === "POST") {
         const session = gateway.create(input);
         if (team?.auth.enabled && team.collaboration) team.collaboration.register(session.id, getSessionId(req));
-        json(res, 201, { session });
-      } else json(res, 405, { error: "Method not allowed." });
+        json2(res, 201, { session });
+      } else json2(res, 405, { error: "Method not allowed." });
       return true;
     }
     const parts = path.split("/").map((part) => decodeURIComponent(part));
     if (parts.some((part) => !/^[A-Za-z0-9_.:-]+$/.test(part))) throw new ConsoleGatewayError("Invalid resource identifier.", 400);
     if (parts[0] === "saved") {
-      const id2 = parts[1];
-      if (!id2 && method === "GET") {
+      const id3 = parts[1];
+      if (!id3 && method === "GET") {
         const limit = requestUrl.searchParams.get("limit");
-        json(res, 200, { sessions: gateway.listSaved({
+        json2(res, 200, { sessions: gateway.listSaved({
           ...requestUrl.searchParams.get("cwd") ? { cwd: requestUrl.searchParams.get("cwd") } : {},
           ...limit ? { limit: Number(limit) } : {}
         }) });
-      } else if (id2 && parts.length === 2 && method === "GET") json(res, 200, gateway.loadSaved(id2));
-      else if (id2 && parts.length === 2 && method === "DELETE") {
-        gateway.deleteSaved(id2);
-        json(res, 200, { ok: true });
-      } else if (id2 && parts[2] === "archive" && method === "POST") json(res, 200, { session: gateway.archiveSaved(id2, input) });
-      else if (id2 && parts[2] === "resume" && method === "POST") json(res, 201, { session: await gateway.resume(id2, input) });
-      else if (id2 && parts[2] === "export" && method === "GET") json(res, 200, gateway.exportSaved(id2));
-      else json(res, 405, { error: "Method not allowed." });
+      } else if (id3 && parts.length === 2 && method === "GET") json2(res, 200, gateway.loadSaved(id3));
+      else if (id3 && parts.length === 2 && method === "DELETE") {
+        gateway.deleteSaved(id3);
+        json2(res, 200, { ok: true });
+      } else if (id3 && parts[2] === "archive" && method === "POST") json2(res, 200, { session: gateway.archiveSaved(id3, input) });
+      else if (id3 && parts[2] === "resume" && method === "POST") json2(res, 201, { session: await gateway.resume(id3, input) });
+      else if (id3 && parts[2] === "export" && method === "GET") json2(res, 200, gateway.exportSaved(id3));
+      else json2(res, 405, { error: "Method not allowed." });
       return true;
     }
     if (parts[0] !== "sessions" || !parts[1]) return false;
-    const id = parts[1];
+    const id2 = parts[1];
     const action = parts[2];
-    if (!action && method === "GET") json(res, 200, { snapshot: gateway.get(id) });
+    if (action === "browser" && parts[3] === "views" && (parts.length === 4 || parts.length === 6 && parts[5] === "stream")) {
+      gateway.get(id2);
+      if (team?.auth.enabled) {
+        const sessionId = getSessionId(req);
+        if (!sessionId || !team.collaboration) throw new WebRequestError("Sign in to this workspace.", 403);
+        if (!team.collaboration.hasConversation(id2)) team.collaboration.register(id2, sessionId);
+        team.collaboration.snapshot(id2, sessionId);
+      }
+      await handleBrowserLiveRequest(req, res, requestUrl, id2, parts[4]);
+      return true;
+    }
+    if (!action && method === "GET") json2(res, 200, { snapshot: gateway.get(id2) });
     else if (!action && method === "DELETE") {
-      workflows.cancelSession(id);
-      await gateway.close(id);
-      json(res, 200, { ok: true });
+      workflows.cancelSession(id2);
+      await gateway.close(id2);
+      json2(res, 200, { ok: true });
     } else if (action === "events" && method === "GET") {
-      json(res, 200, gateway.eventsAfter(id, consoleEventsAfter(requestUrl.searchParams.get("after"))));
+      json2(res, 200, gateway.eventsAfter(id2, consoleEventsAfter(requestUrl.searchParams.get("after"))));
     } else if (action === "messages" && method === "POST") {
       const message2 = author && input && typeof input === "object" && !("workerId" in input) && (!("mode" in input) || input.mode === "send") ? { ...input, mode: "queue" } : input;
-      json(res, 202, { session: await gateway.send(id, message2, author) });
-    } else if (action === "cancel" && method === "POST") json(res, 200, { session: await gateway.cancel(id) });
+      const { queuedMessageId, ...session } = await gateway.send(id2, message2, author);
+      json2(res, 202, { session, ...queuedMessageId ? { queuedMessageId } : {} });
+    } else if (action === "cancel" && method === "POST") json2(res, 200, { session: await gateway.cancel(id2) });
     else if (action === "connection" && parts[3] === "reload" && parts.length === 4 && method === "POST") {
       external_exports.object({}).strict().parse(input ?? {});
-      json(res, 200, { session: await gateway.reloadConnection(id) });
-    } else if (action === "configuration" && method === "PATCH") json(res, 200, { session: await gateway.configure(id, input) });
-    else if (action === "clear" && method === "POST") json(res, 200, { session: await gateway.clear(id) });
-    else if (action === "continue" && method === "POST") json(res, 202, { session: await gateway.continue(id, input, author) });
-    else if (action === "harness" && method === "POST") json(res, 200, await gateway.harness(id, input));
-    else if (action === "save" && method === "POST") json(res, 200, { session: gateway.save(id) });
+      json2(res, 200, { session: await gateway.reloadConnection(id2) });
+    } else if (action === "configuration" && method === "PATCH") json2(res, 200, { session: await gateway.configure(id2, input) });
+    else if (action === "clear" && method === "POST") json2(res, 200, { session: await gateway.clear(id2) });
+    else if (action === "continue" && method === "POST") json2(res, 202, { session: await gateway.continue(id2, input, author) });
+    else if (action === "harness" && method === "POST") json2(res, 200, await gateway.harness(id2, input));
+    else if (action === "save" && method === "POST") json2(res, 200, { session: gateway.save(id2) });
     else if (action === "archive" && method === "POST") {
-      workflows.cancelSession(id);
-      json(res, 200, { session: await gateway.archive(id) });
+      workflows.cancelSession(id2);
+      json2(res, 200, { session: await gateway.archive(id2) });
     } else if (action === "delete" && method === "POST") {
-      workflows.cancelSession(id);
-      json(res, 200, await gateway.delete(id));
-    } else if (action === "export" && method === "GET") json(res, 200, gateway.export(id));
-    else if (action === "queue" && method === "DELETE") json(res, 200, { session: gateway.removeQueued(id, parts[3]) });
-    else if (action === "decisions" && parts[3] && method === "POST") json(res, 200, { session: gateway.resolveDecision(id, parts[3], input) });
+      workflows.cancelSession(id2);
+      json2(res, 200, await gateway.delete(id2));
+    } else if (action === "export" && method === "GET") json2(res, 200, gateway.export(id2));
+    else if (action === "queue" && parts[3] && parts[4] === "send" && parts.length === 5 && method === "POST") {
+      external_exports.object({}).strict().parse(input ?? {});
+      json2(res, 202, { session: gateway.sendQueuedNow(id2, parts[3]) });
+    } else if (action === "queue" && method === "DELETE") json2(res, 200, { session: gateway.removeQueued(id2, parts[3]) });
+    else if (action === "decisions" && parts[3] && method === "POST") json2(res, 200, { session: gateway.resolveDecision(id2, parts[3], input) });
     else if (action === "workers") {
       const workerId = parts[3];
-      if (!workerId && method === "GET") json(res, 200, { workers: gateway.workers(id) });
-      else if (workerId === "stop" && method === "POST") json(res, 200, { session: await gateway.drainWorkers(id) });
-      else if (workerId && parts[4] === "export" && method === "GET") json(res, 200, gateway.exportWorker(id, workerId));
-      else if (workerId && parts[4] === "stop" && method === "POST") json(res, 200, { worker: await gateway.stopWorker(id, workerId) });
+      if (!workerId && method === "GET") json2(res, 200, { workers: gateway.workers(id2) });
+      else if (workerId === "stop" && method === "POST") json2(res, 200, { session: await gateway.drainWorkers(id2) });
+      else if (workerId && parts[4] === "export" && method === "GET") json2(res, 200, gateway.exportWorker(id2, workerId));
+      else if (workerId && parts[4] === "stop" && method === "POST") json2(res, 200, { worker: await gateway.stopWorker(id2, workerId) });
       else if (workerId && parts[4] === "messages" && method === "POST") {
         const body = external_exports.object({ text: external_exports.unknown() }).strict().parse(input);
-        json(res, 202, { session: gateway.sendWorker(id, workerId, body.text, author) });
-      } else json(res, 405, { error: "Method not allowed." });
-    } else json(res, 405, { error: "Method not allowed." });
+        json2(res, 202, { session: gateway.sendWorker(id2, workerId, body.text, author) });
+      } else json2(res, 405, { error: "Method not allowed." });
+    } else json2(res, 405, { error: "Method not allowed." });
     return true;
   } catch (error2) {
     if (error2 instanceof external_exports.ZodError) {
-      json(res, 400, { error: "Invalid console request payload." });
+      json2(res, 400, { error: "Invalid console request payload." });
       return true;
     }
     if (error2 instanceof ConsoleGatewayError) {
-      json(res, error2.statusCode, { error: error2.message });
+      json2(res, error2.statusCode, { error: error2.message });
       return true;
     }
     throw error2;
@@ -4572,10 +5574,10 @@ data: ${JSON.stringify(event)}
 `);
 }
 async function handleApiRequest(req, res, pathname, dbPath, controlToken, engineBearer) {
-  const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+  const { osecDB: osecDB2 } = await import("./dist-OLGNKDB2.js");
   if (isPresentationEventsStreamPath(pathname)) {
     if (req.method !== "GET") {
-      json(res, 405, { error: "Method not allowed" });
+      json2(res, 405, { error: "Method not allowed" });
       return true;
     }
     const db = new osecDB2(dbPath);
@@ -4619,27 +5621,27 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
   const controlPath = parseControlPath(pathname);
   if (controlPath) {
     if (req.method !== "POST") {
-      json(res, 405, { error: "Method not allowed" });
+      json2(res, 405, { error: "Method not allowed" });
       return true;
     }
     if (!requireControlToken(req, res, controlToken, engineBearer)) {
       return true;
     }
     if (controlPath.action === "recover-stale-workers") {
-      const { recoverStaleWorkers } = await import("./orchestrate-OBS37FWQ.js");
+      const { recoverStaleWorkers } = await import("./orchestrate-Z3DW265M.js");
       const body = await readJson(req);
       const recovered = recoverStaleWorkers(
         dbPath,
         typeof body.staleAfterMs === "number" ? body.staleAfterMs : 3e4
       );
-      json(res, 200, { ok: true, recovered });
+      json2(res, 200, { ok: true, recovered });
       return true;
     }
     if (controlPath.action === "prune-stopped-workers") {
       const db = new osecDB2(dbPath);
       try {
         const deleted = db.deleteWorkersByStatus("stopped");
-        json(res, 200, { ok: true, deleted });
+        json2(res, 200, { ok: true, deleted });
       } finally {
         db.close();
       }
@@ -4653,7 +5655,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           (worker) => worker.status !== "stopped" && Date.now() - Date.parse(worker.heartbeatAt) < 2e4
         );
         if (activeWorkers.length > 0) {
-          json(res, 409, { error: "An active daemon is already heartbeating. Stop it before starting another local daemon." });
+          json2(res, 409, { error: "An active daemon is already heartbeating. Stop it before starting another local daemon." });
           return true;
         }
       } finally {
@@ -4664,21 +5666,21 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
         label: typeof body.label === "string" && body.label.trim() ? body.label.trim() : "control-plane-1",
         pollIntervalMs: typeof body.pollIntervalMs === "number" ? body.pollIntervalMs : 2e3
       });
-      json(res, 200, { ok: true, ...started });
+      json2(res, 200, { ok: true, ...started });
       return true;
     }
     if (controlPath.action === "stop-daemon") {
       const stopped = stopDaemonWorkers(osecDB2, dbPath);
-      json(res, 200, { ok: true, stopped });
+      json2(res, 200, { ok: true, stopped });
       return true;
     }
     if (controlPath.action === "reset-database") {
-      const { resetOsecDatabase } = await import("./dist-RKLQIXDT.js");
-      const { seedVerificationWorkbench } = await import("./db-BXJNWUYJ.js");
+      const { resetOsecDatabase } = await import("./dist-OLGNKDB2.js");
+      const { seedVerificationWorkbench } = await import("./db-R2AQSESC.js");
       const body = await readJson(req);
       const seed = typeof body.seed === "string" ? body.seed.trim().toLowerCase() : "verification";
       if (!["verification", "empty"].includes(seed)) {
-        json(res, 400, { error: `Unsupported seed preset: ${seed}` });
+        json2(res, 400, { error: `Unsupported seed preset: ${seed}` });
         return true;
       }
       const activeWorkerDb = new osecDB2(dbPath);
@@ -4687,7 +5689,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           (worker) => ["idle", "claiming", "running", "sleeping"].includes(worker.status) && Date.now() - Date.parse(worker.heartbeatAt) < 2e4 && (worker.pid ? isLiveLocalPid(worker.pid) : true)
         );
         if (hasActiveWorker) {
-          json(res, 409, { error: "Stop active orchestration daemons before resetting the local database." });
+          json2(res, 409, { error: "Stop active orchestration daemons before resetting the local database." });
           return true;
         }
       } finally {
@@ -4697,7 +5699,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
       const resetDb = new osecDB2(dbPath);
       try {
         const seeded = seed === "verification" ? seedVerificationWorkbench(resetDb) : { scans: 0, families: 0, workers: 0 };
-        json(res, 200, { ok: true, path, seed, ...seeded });
+        json2(res, 200, { ok: true, path, seed, ...seeded });
       } finally {
         resetDb.close();
       }
@@ -4733,7 +5735,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
       });
       const casesById = new Map(cases.map((item) => [item.id, item]));
       const workItemsById = new Map(workItems.map((item) => [item.id, item]));
-      json(res, 200, {
+      json2(res, 200, {
         scans: scans.map(summarizeScan),
         cases,
         groups,
@@ -4749,7 +5751,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
     const db = new osecDB2(dbPath);
     try {
       const scans = db.listScans(100);
-      json(res, 200, { scans: scans.map(summarizeScan) });
+      json2(res, 200, { scans: scans.map(summarizeScan) });
     } finally {
       db.close();
     }
@@ -4783,7 +5785,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           presentation
         };
       });
-      json(res, 200, { events });
+      json2(res, 200, { events });
     } finally {
       db.close();
     }
@@ -4795,7 +5797,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
     try {
       const scan = db.getScan(scanPath.scanId);
       if (!scan) {
-        json(res, 404, { error: "Scan not found" });
+        json2(res, 404, { error: "Scan not found" });
         return true;
       }
       if (scanPath.suffix === "events") {
@@ -4803,7 +5805,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           ...event,
           payload: parsePayload(event.payload)
         }));
-        json(res, 200, { scan: summarizeScan(scan), events });
+        json2(res, 200, { scan: summarizeScan(scan), events });
         return true;
       }
       if (scanPath.suffix === "findings") {
@@ -4813,7 +5815,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           scanIds: [scanPath.scanId],
           status: "running"
         });
-        json(res, 200, {
+        json2(res, 200, {
           scan: summarizeScan(scan),
           findings,
           groups: groupFindings(
@@ -4824,7 +5826,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
         });
         return true;
       }
-      json(res, 200, { scan: summarizeScan(scan) });
+      json2(res, 200, { scan: summarizeScan(scan) });
     } finally {
       db.close();
     }
@@ -4844,7 +5846,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           normalizeTriageStatus(body.triageStatus),
           typeof body.triageNote === "string" ? body.triageNote : void 0
         );
-        json(res, 200, { ok: true });
+        json2(res, 200, { ok: true });
         return true;
       }
       if (req.method === "POST" && familyPath.action === "workflow") {
@@ -4857,12 +5859,12 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           normalizeWorkflowStatus(body.workflowStatus),
           typeof body.workflowAssignee === "string" ? body.workflowAssignee.trim() : null
         );
-        json(res, 200, { ok: true });
+        json2(res, 200, { ok: true });
         return true;
       }
       const rows = db.getRelatedFindings(familyPath.fingerprint).map(normalizeFinding);
       if (rows.length === 0) {
-        json(res, 404, { error: "Not found" });
+        json2(res, 404, { error: "Not found" });
         return true;
       }
       const verdicts = db.listVerdicts(rows.map((row) => row.id));
@@ -4904,7 +5906,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
         sessions,
         events: allEvents
       });
-      json(res, 200, {
+      json2(res, 200, {
         consoleCommand: buildFindingConsoleCommand(rows[0], dbPath),
         fingerprint: familyPath.fingerprint,
         case: familyCase,
@@ -4972,7 +5974,7 @@ function registerDashboardCommand(program) {
     const timeCapMs = opts.engineTimeCap === void 0 ? 6e5 : Number(opts.engineTimeCap);
     const costCapUsd = opts.engineCostCap === void 0 ? 5 : Number(opts.engineCostCap);
     if (!Number.isInteger(timeCapMs) || timeCapMs < 1 || timeCapMs > 864e5 || !Number.isFinite(costCapUsd) || costCapUsd <= 0 || costCapUsd > 1e3) throw new Error("Engine limits must be positive, with time at most 86400000 ms and cost at most $1000.");
-    const controlToken = randomUUID7();
+    const controlToken = randomUUID9();
     let teamAuth = new TeamAuth({ configPath: teamConfigPath, origin });
     let teamDirectory = teamAuth.enabled ? join7(homeStateDir(), "teams", createHash8("sha256").update(teamAuth.workspaceId).digest("hex")) : void 0;
     if (teamDirectory) {
@@ -4982,9 +5984,51 @@ function registerDashboardCommand(program) {
     }
     let collaboration = teamAuth.enabled ? new CollaborationService({ workspaceId: teamAuth.workspaceId, stateDir: join7(teamDirectory, "collaboration"), resolveSession: (sessionId) => teamAuth.resolveSessionId(sessionId) }) : void 0;
     assertLocalEngineAvailable(opts.dbPath);
-    const capabilities = ["sessions", "workflows", "schedules", "approvals", "events", "workspaces", "artifacts", "model-connections", "operator-services", "process-controls", "learning", "workflow-engine"];
+    const capabilities = ["sessions", "workflows", "schedules", "approvals", "events", "workspaces", "artifacts", "model-connections", "provider-relay", "operator-services", "process-controls", "learning", "workflow-engine"];
     let localHandshake = createBackendHandshake(opts.dbPath, capabilities);
     let backends = new BackendConnectionRegistry({ configPath: opts.backendsConfig, localHandshake });
+    let modelBackends = new BackendConnectionRegistry({ configPath: opts.backendsConfig, localHandshake });
+    const modelRegistry = {
+      handshake: (id2) => {
+        modelBackends.reload();
+        return modelBackends.handshake(id2);
+      },
+      request: (...args) => {
+        modelBackends.reload();
+        return modelBackends.request(...args);
+      }
+    };
+    let localProviderSessions = new LocalProviderSessions({ registry: modelRegistry });
+    const hostRepairs = /* @__PURE__ */ new Map();
+    const hostRepairAbort = new AbortController();
+    const repairManagedHost = (backendId, signal) => {
+      const pending = hostRepairs.get(backendId);
+      if (pending) return pending;
+      const compiled = import.meta.url.startsWith("file:///$bunfs/") || import.meta.url.startsWith("/$bunfs/");
+      const args = [...compiled ? [] : [resolveCliEntrypoint()], "worker", "repair", backendId];
+      const task = new Promise((resolveRepair, reject) => {
+        execFile2(process.execPath, args, { timeout: 75e3, maxBuffer: 65536, signal: signal ? AbortSignal.any([signal, hostRepairAbort.signal]) : hostRepairAbort.signal }, (error2, stdout) => {
+          if (error2) {
+            reject(new WebRequestError("This host could not reconnect. Check its SSH connection and managed engine installation.", 409));
+            return;
+          }
+          try {
+            resolveRepair(JSON.parse(stdout));
+          } catch {
+            reject(new WebRequestError("Host reconnect returned an invalid result.", 502));
+          }
+        });
+      }).finally(() => {
+        hostRepairs.delete(backendId);
+      });
+      hostRepairs.set(backendId, task);
+      return task;
+    };
+    let stopHostReconnect;
+    const watchManagedHosts = () => startManagedHostReconnect({ getRegistry: () => backends, repair: repairManagedHost, onRecovered: async (id2) => {
+      backends.reload();
+      await backends.handshake(id2);
+    } });
     let engine;
     let startupGateway;
     let startupOperator;
@@ -4995,8 +6039,9 @@ function registerDashboardCommand(program) {
     try {
       const { path: assetDir, cleanup: cleanupAssetDir } = resolveDashboardAssetDir(opts.assetDir);
       startupAssetCleanup = cleanupAssetDir;
-      const buildServices = (auth, dbPath = opts.dbPath, stateDir = teamDirectory) => createWorkspaceServices({ auth, dbPath, stateDir, workspace: opts.engineWorkspace, scopePath: opts.engineScope, target: opts.engineTarget, allowApply: opts.engineAllowApply, controlToken, engineBearer, timeCapMs, costCapUsd });
+      const buildServices = (auth, dbPath = opts.dbPath, stateDir = teamDirectory, relayEpoch = localHandshake.serverInstanceId) => createWorkspaceServices({ relayEpoch, auth, dbPath, stateDir, workspace: opts.engineWorkspace, scopePath: opts.engineScope, target: opts.engineTarget, allowApply: opts.engineAllowApply, controlToken, engineBearer, timeCapMs, costCapUsd });
       let services = await buildServices(teamAuth);
+      stopHostReconnect = watchManagedHosts();
       let { skills, gateway: consoleGateway, engagements, operator, workflows, triggers, github } = services;
       engine = services.engine;
       startupGateway = consoleGateway;
@@ -5015,11 +6060,11 @@ function registerDashboardCommand(program) {
         currentAuth: () => teamAuth,
         activate: async (prepared) => {
           if (consoleGateway.hasActiveTurns() || workflows.hasActiveWork()) throw new TeamAuthError("Finish active work before creating a team workspace.", 409);
-          const next = await buildServices(prepared.auth, prepared.dbPath, prepared.stateDir);
+          const nextHandshake = createBackendHandshake(prepared.dbPath, capabilities);
+          const next = await buildServices(prepared.auth, prepared.dbPath, prepared.stateDir, nextHandshake.serverInstanceId);
           let nextBackends;
           let nextUnregister;
           try {
-            const nextHandshake = createBackendHandshake(prepared.dbPath, capabilities);
             nextBackends = new BackendConnectionRegistry({ configPath: opts.backendsConfig, localHandshake: nextHandshake });
             const nextAccess = new FindingsAccessTokenStore({ workspaceId: prepared.workspaceId, stateDir: join7(prepared.stateDir, "findings-api-access") });
             const nextRead = new FindingsReadApi({ workspaceId: prepared.workspaceId, dbPath: prepared.dbPath });
@@ -5028,6 +6073,9 @@ function registerDashboardCommand(program) {
             if (consoleGateway.hasActiveTurns() || workflows.hasActiveWork()) throw new TeamAuthError("Finish active work before creating a team workspace.", 409);
             await services.dispose();
             for (const response of activeResponses) if (response !== setupResponse) response.end();
+            stopHostReconnect?.();
+            await localProviderSessions.dispose();
+            modelBackends.dispose();
             backends.dispose();
             unregisterLocalEngine?.();
             services = next;
@@ -5037,6 +6085,8 @@ function registerDashboardCommand(program) {
             collaboration = nextCollaboration;
             localHandshake = nextHandshake;
             backends = nextBackends;
+            modelBackends = new BackendConnectionRegistry({ configPath: opts.backendsConfig, localHandshake: nextHandshake });
+            localProviderSessions = new LocalProviderSessions({ registry: modelRegistry });
             unregisterLocalEngine = nextUnregister;
             ({ skills, gateway: consoleGateway, engagements, operator, workflows, triggers, github } = next);
             engine = next.engine;
@@ -5047,6 +6097,7 @@ function registerDashboardCommand(program) {
             startupWorkflows = workflows;
             startupTriggers = triggers;
             startupGitHub = github;
+            stopHostReconnect = watchManagedHosts();
           } catch (cause) {
             nextBackends?.dispose();
             nextUnregister?.();
@@ -5064,12 +6115,12 @@ function registerDashboardCommand(program) {
         try {
           authorizeWebRequest(req, origin);
         } catch (error2) {
-          json(res, error2 instanceof WebRequestError ? error2.statusCode : 403, { error: error2 instanceof Error ? error2.message : "Invalid request origin." });
+          json2(res, error2 instanceof WebRequestError ? error2.statusCode : 403, { error: error2 instanceof Error ? error2.message : "Invalid request origin." });
           return;
         }
         let requestUrl = new URL2(req.url ?? "/", origin);
         const requestId = BackendRequestIdSchema.safeParse(req.headers["x-0-request-id"]);
-        res.setHeader("X-0-Request-ID", requestId.success ? requestId.data : randomUUID7());
+        res.setHeader("X-0-Request-ID", requestId.success ? requestId.data : randomUUID9());
         try {
           if (requestUrl.pathname.startsWith("/api/")) {
             const findingsCredential = findingsAccess.authenticate(req, requestUrl);
@@ -5078,7 +6129,7 @@ function registerDashboardCommand(program) {
               if (!findingsCredential) throw new FindingsAccessError("A findings API key is required in the Authorization header.", 401);
               const reply = handleFindingsReadRequest(req, requestUrl, findingsRead);
               if (!reply) throw new FindingsAccessError("Findings API route was not found.", 404);
-              json(res, reply.status, reply.data);
+              json2(res, reply.status, reply.data);
               return;
             }
             const ssoNavigation = requestUrl.pathname === "/api/team/auth/sso" || requestUrl.pathname === "/api/team/auth/callback";
@@ -5089,7 +6140,7 @@ function registerDashboardCommand(program) {
                 const reply = await handleTeamSetupRequest(req, requestUrl, setup, () => readJson(req));
                 if (reply) {
                   for (const [name, value] of Object.entries(reply.headers ?? {})) res.setHeader(name, value);
-                  json(res, reply.status, reply.data);
+                  json2(res, reply.status, reply.data);
                   return;
                 }
               } finally {
@@ -5098,12 +6149,12 @@ function registerDashboardCommand(program) {
             }
             if (setup.status().pending && requestUrl.pathname !== "/api/team/session") throw new WebRequestError("Workspace setup is in progress. Try again shortly.", 503);
             if (handleTeamPresenceStream(req, res, requestUrl, teamAuth, collaboration)) return;
-            const teamReply = await handleTeamRequest(req, requestUrl, teamAuth, collaboration, consoleGateway, () => readJson(req), async (kind, id) => {
+            const teamReply = await handleTeamRequest(req, requestUrl, teamAuth, collaboration, consoleGateway, () => readJson(req), async (kind, id2) => {
               if (kind === "report") {
-                engagements.get(id);
+                engagements.get(id2);
                 return;
               }
-              const definition = await workflows.handle(`/api/console/workflow-definitions/${encodeURIComponent(id)}`, "GET", void 0, new URLSearchParams());
+              const definition = await workflows.handle(`/api/console/workflow-definitions/${encodeURIComponent(id2)}`, "GET", void 0, new URLSearchParams());
               if (!definition || definition.status !== 200) throw new WebRequestError("Workflow was not found.", 404);
             });
             if (teamReply) {
@@ -5111,7 +6162,7 @@ function registerDashboardCommand(program) {
               if (teamReply.redirect) {
                 res.writeHead(teamReply.status, { Location: teamReply.redirect, "Cache-Control": "no-store" });
                 res.end();
-              } else json(res, teamReply.status, teamReply.data);
+              } else json2(res, teamReply.status, teamReply.data);
               return;
             }
             const bearer = req.headers.authorization;
@@ -5122,11 +6173,41 @@ function registerDashboardCommand(program) {
             if (expectedEngineId !== void 0 && expectedEngineId !== localHandshake.engineId) throw new WebRequestError("Request belongs to a different engine identity.", 409);
             const findingsAccessReply = await handleFindingsAccessTokenRequest(req, requestUrl, teamAuth, findingsAccess, () => readJson(req));
             if (findingsAccessReply) {
-              json(res, findingsAccessReply.status, findingsAccessReply.data);
+              json2(res, findingsAccessReply.status, findingsAccessReply.data);
+              return;
+            }
+            const remoteSessionRoute = /^\/api\/console\/remote-sessions(?:\/([^/]+)\/(configuration|status))?$/.exec(requestUrl.pathname);
+            if (remoteSessionRoute) {
+              const ownerId = engineRequest ? "engine" : teamAuth.resolveSession(req)?.userId ?? "local";
+              try {
+                if (remoteSessionRoute[1] && remoteSessionRoute[2] === "status" && req.method === "GET") {
+                  const backendId = BackendDescriptorSchema.shape.id.parse(requestUrl.searchParams.get("backendId"));
+                  json2(res, 200, await localProviderSessions.status(backendId, decodeURIComponent(remoteSessionRoute[1]), ownerId));
+                } else if (!remoteSessionRoute[1] && req.method === "POST") {
+                  const body = external_exports.object({ backendId: external_exports.string().min(1).max(128), configuration: external_exports.unknown() }).strict().parse(await readJson(req));
+                  json2(res, 201, await localProviderSessions.create(body.backendId, body.configuration, ownerId));
+                } else if (remoteSessionRoute[1] && remoteSessionRoute[2] === "configuration" && req.method === "PATCH") {
+                  const body = external_exports.object({ backendId: external_exports.string().min(1).max(128), runtime: external_exports.unknown() }).strict().parse(await readJson(req));
+                  json2(res, 200, await localProviderSessions.configure(body.backendId, decodeURIComponent(remoteSessionRoute[1]), body.runtime, ownerId));
+                } else throw new WebRequestError("Method not allowed.", 405);
+              } catch (error2) {
+                if (error2 instanceof LocalProviderSessionError) {
+                  json2(res, error2.statusCode, { error: error2.message });
+                  return;
+                }
+                throw error2;
+              }
+              return;
+            }
+            if (requestUrl.pathname === "/api/console/provider-relays" || requestUrl.pathname.startsWith("/api/console/provider-relays/")) {
+              if (!engineRequest) throw new WebRequestError("Provider relay transport requires an authenticated engine connection.", 403);
+              if (await handleRemoteProviderRelayRequest(req, res, requestUrl, services.remoteProviderRelays, () => readJson(req))) return;
+            }
+            const backendRoute = await handleBackendConnectionRequest(req, res, requestUrl, backends, (backendId, sessionId) => localProviderSessions.release(backendId, sessionId, engineRequest ? "engine" : teamAuth.resolveSession(req)?.userId ?? "local"));
+            if (backendRoute.handled) {
+              modelBackends.reload();
               return;
             }
-            const backendRoute = await handleBackendConnectionRequest(req, res, requestUrl, backends);
-            if (backendRoute.handled) return;
             if (backendRoute.localPath) requestUrl = new URL2(backendRoute.localPath, origin);
             const skillsRoute = requestUrl.pathname.match(/^\/api\/skills(?:\/(.*))?$/);
             if (skillsRoute) {
@@ -5140,21 +6221,21 @@ function registerDashboardCommand(program) {
                 throw new WebRequestError("Invalid skill identifier.", 400);
               }
               const method = req.method ?? "GET";
-              if (!path && method === "GET") json(res, 200, skills.list(access));
-              else if (!path && method === "POST") json(res, 201, { skill: skills.create(await readJson(req)) });
-              else if (path === "import" && method === "POST") json(res, 201, { skill: skills.import(await readJson(req, 12 * 1024 * 1024)) });
-              else if (path === "mounts" && method === "POST") json(res, 201, { mount: skills.mount(await readJson(req)) });
+              if (!path && method === "GET") json2(res, 200, skills.list(access));
+              else if (!path && method === "POST") json2(res, 201, { skill: skills.create(await readJson(req)) });
+              else if (path === "import" && method === "POST") json2(res, 201, { skill: skills.import(await readJson(req, 12 * 1024 * 1024)) });
+              else if (path === "mounts" && method === "POST") json2(res, 201, { mount: skills.mount(await readJson(req)) });
               else if (path.startsWith("mounts/") && method === "DELETE") {
                 skills.unmount(decodedPath.slice(7));
-                json(res, 200, { ok: true });
-              } else if (path.endsWith("/copy") && method === "POST") json(res, 201, { skill: skills.copy(decodedPath.slice(0, -5), await readJson(req), access) });
+                json2(res, 200, { ok: true });
+              } else if (path.endsWith("/copy") && method === "POST") json2(res, 201, { skill: skills.copy(decodedPath.slice(0, -5), await readJson(req), access) });
               else if (path.endsWith("/export") && method === "GET") {
-                const id = decodedPath.slice(0, -7);
-                const bundle = skills.export(id);
+                const id2 = decodedPath.slice(0, -7);
+                const bundle = skills.export(id2);
                 res.setHeader("Content-Disposition", `attachment; filename="${bundle.name}.skill.json"`);
-                json(res, 200, bundle);
-              } else if (path && method === "GET") json(res, 200, { skill: skills.get(decodedPath, access) });
-              else if (path && method === "PUT") json(res, 200, { skill: skills.update(decodedPath, await readJson(req), access) });
+                json2(res, 200, bundle);
+              } else if (path && method === "GET") json2(res, 200, { skill: skills.get(decodedPath, access) });
+              else if (path && method === "PUT") json2(res, 200, { skill: skills.update(decodedPath, await readJson(req), access) });
               else throw new WebRequestError("Method not allowed.", 405);
               return;
             }
@@ -5162,34 +6243,34 @@ function registerDashboardCommand(program) {
             if (engagementRoute) {
               const member = teamAuth.resolveSession(req);
               const engagementActor = member ? { userId: member.userId, displayName: member.displayName } : void 0;
-              const id = engagementRoute[1] ? decodeURIComponent(engagementRoute[1]) : void 0;
+              const id2 = engagementRoute[1] ? decodeURIComponent(engagementRoute[1]) : void 0;
               if (engagementRoute[2]) {
                 if (req.method !== "GET") throw new WebRequestError("Use GET to read an engagement report.", 405);
                 const format = requestUrl.searchParams.get("format") ?? "json";
                 if (format !== "json" && format !== "markdown") throw new WebRequestError("Use json or markdown for an engagement report.", 400);
-                const report = engagements.report(id);
+                const report = engagements.report(id2);
                 if (format === "json") {
-                  res.setHeader("Content-Disposition", `attachment; filename="engagement-${id}.json"`);
-                  json(res, 200, report);
+                  res.setHeader("Content-Disposition", `attachment; filename="engagement-${id2}.json"`);
+                  json2(res, 200, report);
                 } else {
-                  res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Content-Disposition": `attachment; filename="engagement-${id}.md"`, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+                  res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Content-Disposition": `attachment; filename="engagement-${id2}.md"`, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
                   res.end(engagementMarkdown(report));
                 }
-              } else if (req.method === "GET") json(res, 200, id ? { engagement: engagements.get(id) } : { engagements: engagements.list() });
-              else if (req.method === "POST" && !id) {
+              } else if (req.method === "GET") json2(res, 200, id2 ? { engagement: engagements.get(id2) } : { engagements: engagements.list() });
+              else if (req.method === "POST" && !id2) {
                 const engagement = engagements.create(await readJson(req), engagementActor);
                 collaboration?.notifyChanged("report", engagement.id);
-                json(res, 201, { engagement });
-              } else if (req.method === "PATCH" && id) {
-                const engagement = engagements.update(id, await readJson(req), engagementActor);
+                json2(res, 201, { engagement });
+              } else if (req.method === "PATCH" && id2) {
+                const engagement = engagements.update(id2, await readJson(req), engagementActor);
                 collaboration?.notifyChanged("report", engagement.id);
-                json(res, 200, { engagement });
+                json2(res, 200, { engagement });
               } else throw new WebRequestError("Method not allowed.", 405);
               return;
             }
             if (requestUrl.pathname === "/api/workers/hosts") {
               if (req.method !== "GET") throw new WebRequestError("Method not allowed.", 405);
-              json(res, 200, { hosts: discoverSshHosts() });
+              json2(res, 200, { hosts: discoverSshHosts() });
               return;
             }
             if (requestUrl.pathname === "/api/workers/managed") {
@@ -5202,7 +6283,15 @@ function registerDashboardCommand(program) {
                   return [];
                 }
               });
-              json(res, 200, { workers });
+              json2(res, 200, { workers });
+              return;
+            }
+            if (requestUrl.pathname === "/api/control/repair-worker") {
+              if (req.method !== "POST") throw new WebRequestError("Use POST to reconnect a host.", 405);
+              const body = external_exports.object({ backendId: BackendDescriptorSchema.shape.id }).strict().parse(await readJson(req));
+              const repaired = await repairManagedHost(body.backendId);
+              backends.reload();
+              json2(res, 200, repaired);
               return;
             }
             const workerStop = requestUrl.pathname.match(/^\/api\/workers\/([^/]+)\/stop$/);
@@ -5224,7 +6313,7 @@ function registerDashboardCommand(program) {
                   }
                 });
               });
-              json(res, 200, result);
+              json2(res, 200, result);
               return;
             }
             if (requestUrl.pathname === "/api/workers/deploy") {
@@ -5257,7 +6346,7 @@ function registerDashboardCommand(program) {
                 });
               });
               backends.reload();
-              json(res, 202, result);
+              json2(res, 202, result);
               return;
             }
             if (requestUrl.pathname === "/api/control/launch-run") {
@@ -5267,15 +6356,15 @@ function registerDashboardCommand(program) {
               if (body.ensureDaemon) throw new WebRequestError("Engine runs do not require a separate orchestration daemon. Configure a workflow schedule for recurring work.", 400);
               const session = await engine.invoke("create_session", { config: { target: body.target, title: `Assessment: ${body.target}` } });
               const execution = await engine.invoke("start_assessment", { sessionId: session.id, target: body.target, plan: { goal: "unknown-vulnerabilities", depth: body.depth ?? "default", runCount: 1, executionMode: "sequential", timeCapMs, costCapUsd } });
-              json(res, 202, { ok: true, engineOwned: true, sessionId: session.id, runId: execution.id, jobId: execution.jobId });
+              json2(res, 202, { ok: true, engineOwned: true, sessionId: session.id, runId: execution.id, jobId: execution.jobId });
               return;
             }
             if (requestUrl.pathname === "/api/workflow-engine/call") {
               if (!engine) throw new WebRequestError("This engine does not admit persistent workflow calls.", 403);
               if (req.method !== "POST") throw new WebRequestError("Method not allowed.", 405);
-              const input = external_exports.object({ name: external_exports.string().min(1).max(128), args: external_exports.record(external_exports.unknown()) }).strict().parse(await readJson(req));
+              const input = external_exports.object({ name: external_exports.string().min(1).max(128), args: external_exports.record(external_exports.string(), external_exports.unknown()) }).strict().parse(await readJson(req));
               if (!engineRequest && typeof input.args.sessionId === "string") assertTeamConsoleMutation(req, input.args.sessionId, teamAuth, collaboration, consoleGateway);
-              json(res, 200, await engine.invoke(input.name, input.args));
+              json2(res, 200, await engine.invoke(input.name, input.args));
               return;
             }
             const resumeScan = requestUrl.pathname.match(/^\/api\/scans\/([^/]+)\/resume$/);
@@ -5283,14 +6372,14 @@ function registerDashboardCommand(program) {
               if (req.method !== "POST") throw new WebRequestError("Use POST to resume a scan.", 405);
               const request = ScanResumeRequestSchema.parse(await readJson(req));
               const result = await workflows.resumeScan(decodeURIComponent(resumeScan[1]), { ...request, timeCapMs: Math.min(request.timeCapMs ?? timeCapMs, timeCapMs), costCapUsd: Math.min(request.costCapUsd ?? costCapUsd, costCapUsd) });
-              json(res, result.status, result.data);
+              json2(res, result.status, result.data);
               return;
             }
             if (/^\/api\/findings\/[^/]+\/impact-assessment$/.test(requestUrl.pathname)) {
               const input = req.method === "POST" || req.method === "DELETE" ? await readJson(req) : void 0;
               const result = handleFindingImpactRequest(requestUrl.pathname, req.method ?? "GET", input, { dbPath: opts.dbPath });
               if (result) {
-                json(res, result.status, result.data);
+                json2(res, result.status, result.data);
                 return;
               }
             }
@@ -5309,7 +6398,7 @@ function registerDashboardCommand(program) {
             const consoleHandled = await handleWebConsoleApiRequest(req, res, requestUrl, consoleGateway, operator, workflows, triggers, github, engineRequest ? void 0 : { auth: teamAuth, collaboration });
             if (consoleHandled) return;
             const handled = await handleApiRequest(req, res, requestUrl.pathname, opts.dbPath, controlToken, engineBearer);
-            if (!handled) json(res, 404, { error: "Not found" });
+            if (!handled) json2(res, 404, { error: "Not found" });
             return;
           }
           if (devUrl) {
@@ -5330,12 +6419,12 @@ function registerDashboardCommand(program) {
             return;
           }
           if (extname(requestUrl.pathname)) {
-            json(res, 404, { error: "Asset not found" });
+            json2(res, 404, { error: "Asset not found" });
             return;
           }
           sendFile(res, join7(assetDir, "index.html"), controlToken);
         } catch (err) {
-          json(res, errorStatusCode(err), { error: err instanceof Error ? err.message : "Web application request failed." });
+          json2(res, errorStatusCode(err), { error: err instanceof Error ? err.message : "Web application request failed." });
         }
       });
       let dashboardAssetsCleaned = false;
@@ -5383,19 +6472,31 @@ function registerDashboardCommand(program) {
       const shutdown = () => {
         if (shuttingDown) return;
         shuttingDown = true;
-        backends.dispose();
-        void Promise.resolve(engine?.dispose()).then(() => triggers.dispose()).then(() => consoleGateway.closeAll()).then(() => workflows.dispose()).finally(() => {
+        stopHostReconnect?.();
+        hostRepairAbort.abort();
+        services.remoteProviderRelays.dispose();
+        void localProviderSessions.dispose().then(() => {
+          modelBackends.dispose();
+          backends.dispose();
+          return engine?.dispose();
+        }).then(() => triggers.dispose()).then(() => consoleGateway.closeAll()).then(() => workflows.dispose()).finally(() => {
           operator.dispose();
           github.dispose();
+          for (const response of activeResponses) response.end();
           server.close(() => {
             cleanupDashboardAssets();
             process.exit(0);
           });
+          server.closeAllConnections();
         });
       };
       process.once("SIGINT", shutdown);
       process.once("SIGTERM", shutdown);
     } catch (error2) {
+      stopHostReconnect?.();
+      hostRepairAbort.abort();
+      await localProviderSessions.dispose();
+      modelBackends.dispose();
       backends.dispose();
       await startupTriggers?.dispose().catch(() => {
       });