0sec-cli 0.24.1 → 0.26.0

package/chunks/{chunk-F2P25DJY.js → chunk-MOGWEHSC.js}

@@ -4,24 +4,23 @@ const require = __0CreateRequire(import.meta.url);
 import {
   ConsoleGateway,
   ConsoleGatewayError,
-  WebOperatorServices,
   WebWorkflowService,
-  WorkflowEngineService
-} from "./chunk-GZA7RGK7.js";
+  WorkflowEngineService,
+  buildFindingConsoleCommand,
+  createLocalConsoleSession,
+  findingFromRow,
+  loadFindingFocus
+} from "./chunk-UQS7XCBV.js";
 import {
   assertLocalEngineAvailable,
   registerLocalEngine
-} from "./chunk-RVJVM5L4.js";
-import {
-  findingFromRow as findingFromRow2
-} from "./chunk-W624J7NF.js";
+} from "./chunk-Z2VLJEQJ.js";
 import {
-  buildFindingConsoleCommand,
-  createLocalConsoleSession,
+  WebOperatorServices,
+  createRemoteJWKSet,
   createSessionPluginHostManager,
-  findingFromRow,
-  loadFindingFocus
-} from "./chunk-2XGBEH53.js";
+  jwtVerify
+} from "./chunk-ZPVSDB63.js";
 import {
   BackendConnectionRegistry,
   backendBearerFromEnv,
@@ -29,13 +28,11 @@ import {
   handleBackendConnectionRequest,
   loadManagedWorker,
   validateWorkerOptions
-} from "./chunk-Q7JKIKKF.js";
-import {
-  Option
-} from "./chunk-WUPN3D37.js";
+} from "./chunk-UGCTPKJG.js";
 import {
+  Option,
   presentationEventBus
-} from "./chunk-56UTQKXO.js";
+} from "./chunk-S4DFH2FJ.js";
 import {
   source_default
 } from "./chunk-HLFS6WV2.js";
@@ -61,43 +58,47 @@ import {
   validateWorkbenchSourceLesson,
   workbenchConfigPath,
   workbenchNetworkEnabled
-} from "./chunk-X2IPO5JO.js";
+} from "./chunk-V2KJQVYE.js";
 import {
   connectServicePlugins,
   createConsoleRuntime,
   exportReport,
   isReportExportFormat
-} from "./chunk-ZM6ANQZJ.js";
+} from "./chunk-3MWQNNJU.js";
 import {
   HuntMemoryStore,
   TOOL_DEFINITIONS,
   discoverAgentSkills,
+  listBrowserViews,
   loadSkillRegistry,
+  parseImpactAssessment,
   readToolCallNames,
+  subscribeBrowserView,
   validateAgentSkillContent
-} from "./chunk-5WAHHZBF.js";
+} from "./chunk-SIR7XW2S.js";
 import {
   SecurityWorkflowStore,
   WorkflowTriggerStore,
   findingStatuses,
   nextWorkflowTriggerFire,
   osecDB,
-  resolveOsecDbPath
-} from "./chunk-BMDG6T7D.js";
+  resolveOsecDbPath,
+  restoreFindingReviewFields
+} from "./chunk-72PU46MS.js";
 import {
   LlmApiRuntime
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-HS2NQ7K6.js";
 import {
   DEFAULT_WORKBENCH_BROKER_LIMITS,
   approveSmolvmWorkbenchImage,
   getSmolvmWorkbenchStatus,
   isAdmittedSmolvmWorkbench,
   resolveSmolvmRuntime
-} from "./chunk-PVJUPIQG.js";
+} from "./chunk-XOVYV7TT.js";
 import {
   ScopePolicy,
   withScopeEnforcement
-} from "./chunk-QNRYOJEB.js";
+} from "./chunk-RZZ6VPRY.js";
 import {
   BackendDescriptorSchema,
   BackendRequestIdSchema,
@@ -106,14 +107,14 @@ import {
   VERSION,
   createPresentationEvent,
   homeStateDir
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.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 +133,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 +195,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 +214,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");
     }
@@ -205,6 +244,7 @@ async function runGuest(cli) {
       tools: session.tools,
       messages: session.messages,
       autonomyMode: session.autonomyMode,
+      webSearchEnabled: session.webSearchEnabled,
       target: session.target,
       scope: session.scope?.raw,
       localScopePath: session.localScopePath,
@@ -212,7 +252,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 +413,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,15 +456,22 @@ 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;
             break;
           }
-          case "autonomy":
+          case "autonomy": {
+            if (typeof frame.value !== "string" || !["standard", "recon", "copilot", "yolo"].includes(frame.value)) throw new Error("Invalid autonomy mode");
             session.setAutonomyMode(frame.value);
             break;
+          }
+          case "webSearch": {
+            if (typeof frame.value !== "boolean") throw new Error("Invalid web search setting");
+            await session.setWebSearchEnabled(frame.value);
+            break;
+          }
           case "configure": {
             const value2 = frame.value;
             session.configureEngagement({ target: value2.target, ...value2.scope === void 0 ? {} : { scope: value2.scope ? new ScopePolicy(value2.scope) : null } });
@@ -514,7 +578,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 +638,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 +670,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,10 +720,775 @@ 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-JOCREEBA.js"),
+    import("./dist-ONIRKDH6.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 decoder = new TextDecoder();
+  let buffer = "", completed = false;
+  return (chunk) => {
+    if (completed) return true;
+    buffer += decoder.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 epoch = peer.handshake?.serverInstanceId;
+  if (peer.backend.status !== "connected" || !id(epoch)) 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, provider: local.grant.provider, models: local.grant.models, model: local.info.model }, signal }));
+    const candidate = object(response.grant);
+    if (!id(candidate.id) || candidate.epoch !== epoch || 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, 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 !== epoch || 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 !== epoch || 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(message, statusCode = 400) {
+    super(message);
+    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(message, statusCode = 400) {
+    super(message);
+    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) {
-    super(message2);
+  constructor(message, statusCode) {
+    super(message);
     this.statusCode = statusCode;
   }
   statusCode;
@@ -711,13 +1540,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 +1592,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";
 
@@ -771,724 +1600,6 @@ import { join } from "node:path";
 import { readFileSync } from "node:fs";
 import { createHash, randomBytes, scrypt as scryptCallback, timingSafeEqual } from "node:crypto";
 import { promisify } from "node:util";
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/buffer_utils.js
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var strictDecoder = new TextDecoder("utf-8", { fatal: true });
-var MAX_INT32 = 2 ** 32;
-function concat(...buffers) {
-  const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size);
-  let i = 0;
-  for (const buffer of buffers)
-    buf.set(buffer, i), i += buffer.length;
-  return buf;
-}
-var NON_ASCII = /[^\x00-\x7f]/;
-function encode(string) {
-  if (typeof string == "string" && string.length >= 128) {
-    if (NON_ASCII.test(string))
-      throw new TypeError("non-ASCII string encountered in encode()");
-    return encoder.encode(string);
-  }
-  const bytes = new Uint8Array(string.length);
-  for (let i = 0; i < string.length; i++) {
-    const code = string.charCodeAt(i);
-    if (code > 127)
-      throw new TypeError("non-ASCII string encountered in encode()");
-    bytes[i] = code;
-  }
-  return bytes;
-}
-function decodeBase64(encoded, url = false) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(encoded, { alphabet: url ? "base64url" : "base64" });
-  if (url) {
-    if (encoded.includes("+") || encoded.includes("/"))
-      throw new TypeError("Invalid base64url");
-    encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
-  }
-  const binary = atob(encoded), bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++)
-    bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/util/errors.js
-var JOSEError = class extends Error {
-  static code = "ERR_JOSE_GENERIC";
-  code = "ERR_JOSE_GENERIC";
-  constructor(message2, options) {
-    super(message2, options), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor);
-  }
-};
-var JWTClaimValidationFailed = class extends JOSEError {
-  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
-  }
-};
-var JWTExpired = class extends JOSEError {
-  static code = "ERR_JWT_EXPIRED";
-  code = "ERR_JWT_EXPIRED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
-  }
-};
-var JOSEAlgNotAllowed = class extends JOSEError {
-  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
-  code = "ERR_JOSE_ALG_NOT_ALLOWED";
-};
-var JOSENotSupported = class extends JOSEError {
-  static code = "ERR_JOSE_NOT_SUPPORTED";
-  code = "ERR_JOSE_NOT_SUPPORTED";
-};
-var JWSInvalid = class extends JOSEError {
-  static code = "ERR_JWS_INVALID";
-  code = "ERR_JWS_INVALID";
-};
-var JWTInvalid = class extends JOSEError {
-  static code = "ERR_JWT_INVALID";
-  code = "ERR_JWT_INVALID";
-};
-var JWKSInvalid = class extends JOSEError {
-  static code = "ERR_JWKS_INVALID";
-  code = "ERR_JWKS_INVALID";
-};
-var JWKSNoMatchingKey = class extends JOSEError {
-  static code = "ERR_JWKS_NO_MATCHING_KEY";
-  code = "ERR_JWKS_NO_MATCHING_KEY";
-  constructor(message2 = "no applicable key found in the JSON Web Key Set", options) {
-    super(message2, options);
-  }
-};
-var JWKSMultipleMatchingKeys = class extends JOSEError {
-  [Symbol.asyncIterator] = async function* () {
-  };
-  static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
-  code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
-  constructor(message2 = "multiple matching keys found in the JSON Web Key Set", options) {
-    super(message2, options);
-  }
-};
-var JWKSTimeout = class extends JOSEError {
-  static code = "ERR_JWKS_TIMEOUT";
-  code = "ERR_JWKS_TIMEOUT";
-  constructor(message2 = "request timed out", options) {
-    super(message2, options);
-  }
-};
-var JWSSignatureVerificationFailed = class extends JOSEError {
-  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  constructor(message2 = "signature verification failed", options) {
-    super(message2, options);
-  }
-};
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/util/base64url.js
-var invalid = "The input to be decoded is not correctly encoded.";
-function decode(input) {
-  try {
-    return decodeBase64(typeof input == "string" ? input : decoder.decode(input), true);
-  } catch (cause) {
-    throw new TypeError(invalid, { cause });
-  }
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/validate.js
-function isObject(input) {
-  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]")
-    return false;
-  const prototype = Object.getPrototypeOf(input);
-  return prototype === null || Object.getPrototypeOf(prototype) === null;
-}
-function isJwkSet(input) {
-  return isObject(input) && Array.isArray(input.keys) && Array.from(input.keys).every(isObject);
-}
-function isDisjoint(...headers) {
-  const parameters = /* @__PURE__ */ new Set();
-  for (const header of headers)
-    if (header)
-      for (const parameter of Object.keys(header)) {
-        if (parameters.has(parameter))
-          return false;
-        parameters.add(parameter);
-      }
-  return true;
-}
-function decodeBase64url(value, label, ErrorClass) {
-  try {
-    return decode(value);
-  } catch {
-    throw new ErrorClass(`Failed to base64url decode the ${label}`);
-  }
-}
-function encodeBase64url(value, label, ErrorClass) {
-  try {
-    return encode(value);
-  } catch {
-    throw new ErrorClass(`The ${label} is not a valid base64url string`);
-  }
-}
-function parseJoseHeader(b64, ErrorClass, message2) {
-  let parsed;
-  try {
-    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-  } catch {
-    throw new ErrorClass(message2);
-  }
-  if (!isObject(parsed))
-    throw new ErrorClass(message2);
-  return parsed;
-}
-var JWS_RECOGNIZED = { __proto__: null, b64: true };
-function validateAlgorithms(option, algorithms) {
-  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s != "string")))
-    throw new TypeError(`"${option}" option must be an array of strings`);
-  return algorithms === void 0 ? void 0 : new Set(algorithms);
-}
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-  if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0)
-    throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-  if (!protectedHeader || protectedHeader.crit === void 0)
-    return [];
-  if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input != "string" || input.length === 0))
-    throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  const recognized = recognizedOption === void 0 ? recognizedDefault : { __proto__: null, ...recognizedOption, ...recognizedDefault };
-  for (const parameter of protectedHeader.crit) {
-    if (!(parameter in recognized))
-      throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-    if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === void 0)
-      throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-    if (recognized[parameter] && (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === void 0))
-      throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-  }
-  return protectedHeader.crit;
-}
-function validateB64(protectedHeader, extensions) {
-  if (extensions.includes("b64")) {
-    const b64 = protectedHeader.b64;
-    if (typeof b64 != "boolean")
-      throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
-    return b64;
-  }
-  return true;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/key.js
-var tag = (key) => key[Symbol.toStringTag];
-var jwkMatchesOp = (entry, key, usage) => {
-  const { alg } = entry;
-  if (key.use !== void 0) {
-    const expected = usage === "sign" || usage === "verify" ? "sig" : "enc";
-    if (key.use !== expected)
-      throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`);
-  }
-  if (key.alg !== void 0 && key.alg !== alg)
-    throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`);
-  if (Array.isArray(key.key_ops)) {
-    const expectedKeyOp = usage === "encrypt" || usage === "decrypt" ? entry.ops?.[usage === "encrypt" ? 0 : 1] : usage;
-    if (expectedKeyOp && !key.key_ops.includes(expectedKeyOp))
-      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
-  }
-};
-async function prepareKey(entry, key, usage) {
-  const { alg, secret } = entry, privateKey = usage === "decrypt" || usage === "sign";
-  if (secret && key instanceof Uint8Array)
-    return key;
-  let normalized, keyObject;
-  if (isObject(key)) {
-    if (normalized = normalizeJwk(key), typeof normalized.kty != "string")
-      throw invalidKeyType(alg, key, secret);
-    if (!(secret ? normalized.kty === "oct" && typeof normalized.k == "string" : normalized.kty !== "oct" && (privateKey ? normalized.kty === "AKP" && typeof normalized.priv == "string" || typeof normalized.d == "string" : normalized.d === void 0 && normalized.priv === void 0)))
-      throw new TypeError(secret ? 'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present' : `JSON Web Key for this operation must be a ${privateKey ? "private" : "public"} JWK`);
-    if (jwkMatchesOp(entry, normalized, usage), normalized.kty === "oct")
-      return decode(normalized.k);
-    if (!Object.isFrozen(key)) {
-      const { key_ops } = key;
-      Array.isArray(key_ops) && Object.freeze(key_ops), Object.freeze(key);
-    }
-  } else {
-    if (!isKeyLike(key))
-      throw invalidKeyType(alg, key, secret);
-    const expectedType = secret ? "secret" : privateKey ? "private" : "public";
-    if (key.type !== expectedType && (secret || ["secret", "public", "private"].includes(key.type)))
-      throw new TypeError(`${tag(key)} instances must be of type "${expectedType}" for the ${alg} algorithm`);
-    if (isCryptoKey(key))
-      return key;
-    if (keyObject = key, keyObject.type === "secret")
-      return keyObject.export();
-  }
-  cache ||= /* @__PURE__ */ new WeakMap();
-  const cacheKey = key;
-  let cached = cache.get(cacheKey);
-  if (cached?.[alg])
-    return cached[alg];
-  if (cached || cache.set(cacheKey, cached = {}), keyObject && typeof keyObject.toCryptoKey == "function") {
-    const isPublic = keyObject.type === "public", crv = nist[keyObject.asymmetricKeyDetails?.namedCurve], params = entry.resolve?.({ crv, asymmetricKeyType: keyObject.asymmetricKeyType }) ?? entry.subtle;
-    return cached[alg] = keyObject.toCryptoKey(params, isPublic, entry.usages[isPublic ? 0 : 1]);
-  }
-  return normalized ??= keyObject.export({ format: "jwk" }), normalized.alg = alg, cached[alg] = await jwkToKey(entry, normalized);
-}
-var cache;
-var nist = {
-  __proto__: null,
-  prime256v1: "P-256",
-  secp384r1: "P-384",
-  secp521r1: "P-521"
-};
-var isCryptoKey = (key) => {
-  if (key?.[Symbol.toStringTag] === "CryptoKey")
-    return true;
-  try {
-    return key instanceof CryptoKey;
-  } catch {
-    return false;
-  }
-};
-var isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject";
-var isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
-function message(msg, actual, ...types) {
-  if (types.length > 2) {
-    const last = types.pop();
-    msg += `one of type ${types.join(", ")}, or ${last}.`;
-  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
-  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
-}
-function invalidKeyType(alg, actual, secret) {
-  const types = ["CryptoKey", "KeyObject", "JSON Web Key"];
-  return secret && types.push("Uint8Array"), new TypeError(message(`Key for the ${alg} algorithm must be `, actual, ...types));
-}
-var unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-function checkUsage(key, usage) {
-  if (usage && !key.usages.includes(usage))
-    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-}
-function checkModulusLength(alg, key) {
-  const { modulusLength } = key.algorithm;
-  if (typeof modulusLength != "number" || modulusLength < 2048)
-    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-}
-function checkCryptoKey(key, expected, usage) {
-  const algorithm = key.algorithm;
-  if (algorithm.name !== expected.name)
-    throw unusable(expected.name);
-  if (expected.hash && algorithm.hash?.name !== expected.hash)
-    throw unusable(expected.hash, "algorithm.hash");
-  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
-    throw unusable(expected.namedCurve, "algorithm.namedCurve");
-  if (expected.length !== void 0 && algorithm.length !== expected.length)
-    throw unusable(expected.length, "algorithm.length");
-  checkUsage(key, usage);
-}
-function snapshotJwk(jwk) {
-  return { __proto__: null, ...jwk };
-}
-function normalizeJwk(jwk) {
-  const normalized = snapshotJwk(jwk);
-  if (normalized.ext !== void 0 && typeof normalized.ext != "boolean")
-    throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
-  if (normalized.key_ops !== void 0) {
-    const value = normalized.key_ops, keyOps = Array.isArray(value) ? [...value] : void 0;
-    if (!keyOps || keyOps.some((operation) => typeof operation != "string") || new Set(keyOps).size !== keyOps.length)
-      throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
-    normalized.key_ops = keyOps;
-  }
-  return normalized;
-}
-async function jwkToKey(entry, jwk, extractable) {
-  if (!entry.kty.includes(jwk.kty))
-    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-  const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle, isPrivate = !!(jwk.d || jwk.priv), keyData = { ...jwk, ext: extractable ?? jwk.ext };
-  return keyData.kty !== "AKP" && delete keyData.alg, delete keyData.use, crypto.subtle.importKey("jwk", keyData, algorithm, keyData.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
-}
-async function rawKey(key, expected, usage, extractable = false) {
-  return key instanceof Uint8Array && (key = await crypto.subtle.importKey("raw", key, expected, extractable, [usage])), checkCryptoKey(key, expected, usage), key;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/key_descriptor.js
-function table(entries) {
-  const out = { __proto__: null };
-  for (const alg in entries)
-    out[alg] = { ...entries[alg], alg };
-  return out;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jws_algorithms.js
-var sig = [["verify"], ["sign"]];
-function hmac(bits) {
-  const subtle = { name: "HMAC", hash: `SHA-${bits}` };
-  return { kty: ["oct"], secret: true, subtle, signing: subtle, usages: sig };
-}
-function rsa(bits, saltLength) {
-  const subtle = { name: saltLength ? "RSA-PSS" : "RSASSA-PKCS1-v1_5", hash: `SHA-${bits}` };
-  return {
-    kty: ["RSA"],
-    subtle,
-    signing: saltLength ? { ...subtle, saltLength } : subtle,
-    usages: sig,
-    minRsaBits: 2048
-  };
-}
-function ecdsa(crv, bits) {
-  return {
-    kty: ["EC"],
-    crv,
-    subtle: { name: "ECDSA", namedCurve: crv },
-    signing: { name: "ECDSA", hash: `SHA-${bits}` },
-    usages: sig
-  };
-}
-function eddsa() {
-  const subtle = { name: "Ed25519" };
-  return {
-    kty: ["OKP"],
-    crv: "Ed25519",
-    subtle,
-    signing: subtle,
-    usages: sig
-  };
-}
-function mldsa(bits) {
-  const subtle = { name: `ML-DSA-${bits}` };
-  return {
-    kty: ["AKP"],
-    subtle,
-    signing: subtle,
-    usages: sig
-  };
-}
-var JWS = table({
-  HS256: hmac(256),
-  HS384: hmac(384),
-  HS512: hmac(512),
-  RS256: rsa(256),
-  RS384: rsa(384),
-  RS512: rsa(512),
-  PS256: rsa(256, 32),
-  PS384: rsa(384, 48),
-  PS512: rsa(512, 64),
-  ES256: ecdsa("P-256", 256),
-  ES384: ecdsa("P-384", 384),
-  ES512: ecdsa("P-521", 512),
-  EdDSA: eddsa(),
-  Ed25519: eddsa(),
-  "ML-DSA-44": mldsa(44),
-  "ML-DSA-65": mldsa(65),
-  "ML-DSA-87": mldsa(87)
-});
-function jwsAlgorithm(alg) {
-  const entry = typeof alg == "string" ? JWS[alg] : void 0;
-  if (!entry)
-    throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-  return entry;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jws_verify.js
-function prepareVerify(options) {
-  return [options && validateAlgorithms("algorithms", options.algorithms), options?.crit];
-}
-function parseProtectedHeader(encodedProtected) {
-  return encodedProtected === void 0 ? {} : parseJoseHeader(encodedProtected, JWSInvalid, "JWS Protected Header is invalid");
-}
-function encodeCompactUnencodedPayload(payload) {
-  try {
-    return encode(payload);
-  } catch {
-    throw new JWSInvalid("JWS Compact Serialization payload must use only ASCII characters");
-  }
-}
-async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedProtected) {
-  const { protected: encodedProtected, header, payload: inputPayload } = jws, parsedProt = parsedProtected ?? parseProtectedHeader(encodedProtected);
-  if (!isDisjoint(parsedProt, header))
-    throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
-  const joseHeader = { ...parsedProt, ...header }, b64 = validateB64(parsedProt, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader)), { alg } = joseHeader;
-  if (typeof alg != "string" || !alg)
-    throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
-  if (shared[0] && !shared[0].has(alg))
-    throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
-  if (b64) {
-    if (typeof inputPayload != "string")
-      throw new JWSInvalid("JWS Payload must be a string");
-  } else if (typeof inputPayload != "string" && !(inputPayload instanceof Uint8Array))
-    throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
-  const signingPayload = b64 || typeof inputPayload != "string" ? inputPayload : encodeUnencodedPayload(inputPayload);
-  let resolvedKey = false;
-  typeof key == "function" && (key = await key(parsedProt, jws), resolvedKey = true);
-  const entry = jwsAlgorithm(alg), data = concat(encodedProtected !== void 0 ? encode(encodedProtected) : new Uint8Array(), encode("."), typeof signingPayload == "string" ? shared[2] ??= encodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload), signature = decodeBase64url(jws.signature, "signature", JWSInvalid), k = await prepareKey(entry, key, "verify"), cryptoKey = await rawKey(k, entry.subtle, "verify");
-  entry.minRsaBits && checkModulusLength(entry.alg, cryptoKey);
-  let verified = false;
-  try {
-    verified = await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-  } catch {
-  }
-  if (!verified)
-    throw new JWSSignatureVerificationFailed();
-  const result = { payload: typeof signingPayload == "string" ? decodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload };
-  return encodedProtected !== void 0 && (result.protectedHeader = parsedProt), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? [{ ...result, key: k }, b64] : [result, b64];
-}
-async function verifyCompact(jws, shared, key) {
-  if (jws instanceof Uint8Array && (jws = decoder.decode(jws)), typeof jws != "string")
-    throw new JWSInvalid("Compact JWS must be a string or Uint8Array");
-  const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split(".");
-  if (length !== 3)
-    throw new JWSInvalid("Invalid Compact JWS");
-  return verifySignature({ payload, protected: protectedHeader, signature }, shared, key, encodeCompactUnencodedPayload);
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/jwt_claims_set.js
-var epoch = (date) => Math.floor(date.getTime() / 1e3);
-var multipliers = {
-  s: 1,
-  m: 60,
-  h: 3600,
-  d: 86400,
-  w: 604800,
-  y: 31557600
-};
-var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-var checkFailed = "check_failed";
-function invalidDuration() {
-  throw new TypeError("Invalid time period format");
-}
-function secs(str) {
-  typeof str != "string" && invalidDuration();
-  const matched = REGEX.exec(str);
-  (!matched || matched[4] && matched[1]) && invalidDuration();
-  const value = parseFloat(matched[2]), numericDate2 = Math.round(value * multipliers[matched[3][0].toLowerCase()]);
-  return Number.isFinite(numericDate2) || invalidDuration(), matched[1] === "-" || matched[4] === "ago" ? -numericDate2 : numericDate2;
-}
-function validateInput(label, input) {
-  if (!Number.isFinite(input))
-    throw new TypeError(`Invalid ${label} input`);
-  return input;
-}
-var normalizeTyp = (value) => {
-  const normalized = value.toLowerCase();
-  return value.includes("/") ? normalized : `application/${normalized}`;
-};
-var checkAudiencePresence = (audPayload, audOption) => typeof audPayload == "string" ? audOption.includes(audPayload) : Array.isArray(audPayload) ? audOption.some((aud) => audPayload.includes(aud)) : false;
-function validateNumericDate(payload, claim, required = false) {
-  const value = payload[claim];
-  if (!(value === void 0 && !required)) {
-    if (typeof value != "number")
-      throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid");
-    return value;
-  }
-}
-function unexpectedClaim(payload, claim) {
-  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed);
-}
-function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
-  let payload;
-  try {
-    payload = JSON.parse(strictDecoder.decode(encodedPayload));
-  } catch {
-  }
-  if (!isObject(payload))
-    throw new JWTInvalid("JWT Claims Set must be a top-level JSON object");
-  const { typ } = options;
-  if (typ !== void 0 && (typeof protectedHeader.typ != "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ)))
-    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed);
-  const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options, presenceCheck = [...requiredClaims];
-  maxTokenAge !== void 0 && presenceCheck.push("iat"), audience !== void 0 && presenceCheck.push("aud"), subject !== void 0 && presenceCheck.push("sub"), issuer !== void 0 && presenceCheck.push("iss");
-  for (const claim of new Set(presenceCheck.reverse()))
-    if (!Object.hasOwn(payload, claim))
-      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
-  issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss) && unexpectedClaim(payload, "iss"), subject !== void 0 && payload.sub !== subject && unexpectedClaim(payload, "sub"), audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(payload, "aud");
-  const { clockTolerance } = options;
-  let tolerance = 0;
-  if (typeof clockTolerance == "string")
-    tolerance = secs(clockTolerance);
-  else if (clockTolerance !== void 0) {
-    if (typeof clockTolerance != "number")
-      throw new TypeError("Invalid clockTolerance option type");
-    tolerance = clockTolerance;
-  }
-  validateInput("clockTolerance option", tolerance);
-  const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(payload, "nbf");
-  if (nbf !== void 0 && nbf > now + tolerance)
-    throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed);
-  const exp = validateNumericDate(payload, "exp");
-  if (exp !== void 0 && exp <= now - tolerance)
-    throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed);
-  if (maxTokenAge !== void 0) {
-    const age = now - iat, max = validateInput("maxTokenAge option", typeof maxTokenAge == "number" ? maxTokenAge : secs(maxTokenAge));
-    if (age - tolerance > max)
-      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed);
-    if (age < -tolerance)
-      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed);
-  }
-  return payload;
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwt/verify.js
-async function jwtVerify(jwt, key, options) {
-  const [verified, b64] = await verifyCompact(jwt, prepareVerify(options), key);
-  if (!b64)
-    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
-  const payload = validateClaimsSet(verified.protectedHeader, verified.payload, options);
-  return { ...verified, payload };
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwks/local.js
-function isUsableJWK(jwk, entry, alg, kid) {
-  const { kty, key_ops: keyOps, ext, kid: jwkKid, alg: jwkAlg, use, crv } = jwk;
-  return (ext === void 0 || typeof ext == "boolean") && (keyOps === void 0 || Array.isArray(keyOps) && keyOps.every((operation, index) => typeof operation == "string" && keyOps.indexOf(operation) === index) && keyOps.includes("verify")) && entry.kty.includes(kty) && (kid === void 0 || typeof kid == "string" && kid === jwkKid) && (jwkAlg === void 0 ? kty !== "AKP" : alg === jwkAlg) && (use === void 0 || use === "sig") && (!entry.crv || crv === entry.crv);
-}
-async function importWithAlgCache(cache2, jwk, entry) {
-  const cached = cache2.get(jwk) || cache2.set(jwk, {}).get(jwk), { alg } = entry;
-  if (cached[alg] === void 0) {
-    const pending = jwkToKey(entry, jwk, true).then((key) => {
-      if (key.type !== "public")
-        throw new JWKSInvalid("JSON Web Key Set members must be public keys");
-      return cached[alg] = key, key;
-    }).catch((error2) => {
-      throw cached[alg] === pending && delete cached[alg], error2;
-    });
-    cached[alg] = pending;
-  }
-  return cached[alg];
-}
-function createLocalJWKSet(jwks) {
-  let snapshot;
-  try {
-    snapshot = structuredClone(jwks);
-  } catch {
-  }
-  if (!isJwkSet(snapshot))
-    throw new JWKSInvalid("JSON Web Key Set malformed");
-  const metadata = snapshot.keys.map((jwk) => {
-    const normalized = snapshotJwk(jwk);
-    return Array.isArray(normalized.key_ops) && (normalized.key_ops = [...normalized.key_ops]), normalized;
-  }), cached = /* @__PURE__ */ new WeakMap();
-  return Object.defineProperty(async (protectedHeader, token) => {
-    const { alg, kid } = { ...protectedHeader, ...token?.header }, entry = typeof alg == "string" ? JWS[alg] : void 0;
-    if (!entry || entry.secret)
-      throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
-    const candidates = snapshot.keys.filter((_, index) => isUsableJWK(metadata[index], entry, alg, kid)), { 0: jwk, length } = candidates;
-    if (!length)
-      throw new JWKSNoMatchingKey();
-    if (length !== 1) {
-      const error2 = new JWKSMultipleMatchingKeys();
-      throw error2[Symbol.asyncIterator] = async function* () {
-        for (const jwk2 of candidates)
-          try {
-            yield await importWithAlgCache(cached, jwk2, entry);
-          } catch {
-          }
-      }, error2;
-    }
-    return importWithAlgCache(cached, jwk, entry);
-  }, "jwks", {
-    value: () => structuredClone(snapshot)
-  });
-}
-
-// node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/jwks/remote.js
-function isCloudflareWorkers() {
-  return typeof WebSocketPair < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime < "u" && EdgeRuntime === "vercel";
-}
-var USER_AGENT;
-(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.12");
-var customFetch = /* @__PURE__ */ Symbol();
-async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
-  const response = await fetchImpl(url, {
-    method: "GET",
-    signal,
-    redirect: "manual",
-    headers
-  }).catch((err) => {
-    throw err.name === "TimeoutError" ? new JWKSTimeout() : err;
-  });
-  if (response.status !== 200)
-    throw new JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
-  try {
-    return await response.json();
-  } catch {
-    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
-  }
-}
-var jwksCache = /* @__PURE__ */ Symbol();
-function isFreshFor(timestamp, duration) {
-  return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
-}
-function validateDuration(value, fallback, option) {
-  if (Number.isNaN(value))
-    throw new TypeError(`"${option}" option must not be NaN`);
-  return typeof value == "number" ? value : fallback;
-}
-function createRemoteJWKSet(url, options) {
-  if (!(url instanceof URL))
-    throw new TypeError("url must be an instance of URL");
-  const href = new URL(url.href).href, opts = options ?? {}, timeoutOption = opts.timeoutDuration;
-  if (typeof timeoutOption == "number" && (!Number.isInteger(timeoutOption) || timeoutOption < 0))
-    throw new TypeError('"timeoutDuration" option must be a non-negative integer');
-  const timeoutDuration = typeof timeoutOption == "number" ? timeoutOption : 5e3, cooldownDuration = validateDuration(opts.cooldownDuration, 3e4, "cooldownDuration"), cacheMaxAge = validateDuration(opts.cacheMaxAge, 6e5, "cacheMaxAge"), headers = new Headers(opts.headers);
-  USER_AGENT && !headers.has("User-Agent") && headers.set("User-Agent", USER_AGENT), headers.has("accept") || headers.set("accept", "application/json, application/jwk-set+json");
-  const fetchImpl = opts[customFetch], cache2 = opts[jwksCache];
-  let jwksTimestamp, pendingFetch, reloadSequence = 0, appliedSequence = 0, local;
-  if (cache2 && typeof cache2 == "object") {
-    const { uat, jwks } = cache2;
-    isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks) && (jwksTimestamp = uat, local = createLocalJWKSet(jwks));
-  }
-  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);
-        if (sequence <= appliedSequence)
-          return;
-        local = next;
-        const updatedAt = Date.now();
-        cache2 && (cache2.uat = updatedAt, cache2.jwks = json2), jwksTimestamp = updatedAt, appliedSequence = sequence;
-      }).finally(() => {
-        pendingFetch === current && (pendingFetch = void 0);
-      });
-    }
-    await pendingFetch;
-  };
-  return Object.defineProperties(async (protectedHeader, token) => {
-    (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) && await reload();
-    try {
-      return await local(protectedHeader, token);
-    } catch (err) {
-      if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration))
-        return await reload(), local(protectedHeader, token);
-      throw err;
-    }
-  }, {
-    coolingDown: {
-      get: () => isFreshFor(jwksTimestamp, cooldownDuration),
-      enumerable: true
-    },
-    fresh: {
-      get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
-      enumerable: true
-    },
-    reload: {
-      value: reload,
-      enumerable: true
-    },
-    reloading: {
-      get: () => !!pendingFetch,
-      enumerable: true
-    },
-    jwks: {
-      value: () => local?.jwks(),
-      enumerable: true
-    }
-  });
-}
-
-// packages/cli/src/web/team-auth.ts
 var scrypt = promisify(scryptCallback);
 var COOKIE = "zero_team_session";
 var SSO_COOKIE = "zero_team_sso";
@@ -1510,8 +1621,8 @@ function parseTeamConfig(input) {
   return configSchema.parse(input);
 }
 var TeamAuthError = class extends Error {
-  constructor(message2, statusCode = 401) {
-    super(message2);
+  constructor(message, statusCode = 401) {
+    super(message);
     this.statusCode = statusCode;
   }
   statusCode;
@@ -1534,8 +1645,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 +1703,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 +1728,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 +1744,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 +1755,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 +1766,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 +1791,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 });
@@ -1719,8 +1830,8 @@ var TeamAuth = class {
 
 // packages/cli/src/web/findings-access-tokens.ts
 var FindingsAccessError = class extends Error {
-  constructor(message2, statusCode = 400) {
-    super(message2);
+  constructor(message, statusCode = 400) {
+    super(message);
     this.statusCode = statusCode;
     this.name = "FindingsAccessError";
   }
@@ -1739,7 +1850,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 +1899,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 +1933,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 +2005,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 +2045,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 +2057,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,14 +2134,17 @@ 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";
 var SkillsError = class extends Error {
-  constructor(message2, statusCode = 400) {
-    super(message2);
+  constructor(message, statusCode = 400) {
+    super(message);
     this.statusCode = statusCode;
   }
   statusCode;
@@ -2121,12 +2235,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 +2250,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 +2282,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 +2355,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 +2394,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 +2433,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 +2463,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,12 +2491,12 @@ ${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 {
-  constructor(message2, statusCode = 400) {
-    super(message2);
+  constructor(message, statusCode = 400) {
+    super(message);
     this.statusCode = statusCode;
     this.name = "EngagementError";
   }
@@ -2438,7 +2552,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 +2568,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 +2628,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 +2640,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 +2659,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 +2682,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 +2720,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 +2746,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 +2768,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 +2811,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;
@@ -2732,8 +2903,8 @@ var WorkflowTriggerService = class {
     this.#workflows.close();
   }
 };
-function error(status, message2) {
-  return { status, data: { error: message2 } };
+function error(status, message) {
+  return { status, data: { error: message } };
 }
 function isProcessAlive(pid) {
   try {
@@ -2852,7 +3023,10 @@ 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({
+    allowChatGptPlan: !options.auth.enabled,
+    remoteProviderRelays,
     dbPath: options.dbPath,
     projectPath: options.workspace,
     skillAuthoring: (author, workspaceRoot) => {
@@ -2863,13 +3037,13 @@ async function createWorkspaceServices(options) {
     ...options.stateDir ? { homeDir: options.stateDir } : {}
   });
   const engagements = new EngagementStore({ workspace: options.workspace ?? process.cwd(), dbPath: options.dbPath, ...options.stateDir ? { stateDir: options.stateDir } : {} });
-  const operator = new WebOperatorServices({ isTurnActive: () => gateway.hasActiveTurns() });
+  const operator = new WebOperatorServices({ allowChatGptPlan: !options.auth.enabled, isTurnActive: () => gateway.hasActiveTurns() });
   let workflows;
   let engine;
   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 +3074,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 +3087,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 +3153,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 +3210,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,12 +3263,12 @@ 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 {
-  constructor(message2, statusCode = 400) {
-    super(message2);
+  constructor(message, statusCode = 400) {
+    super(message);
     this.statusCode = statusCode;
     this.name = "CollaborationError";
   }
@@ -3172,9 +3348,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 +3377,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 +3392,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 +3454,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 +3480,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 +3508,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 +3524,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 +3533,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 +3550,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 +3574,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 +3633,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
@@ -3643,8 +3923,8 @@ function discoverSshHosts(configPath = join6(homedir3(), ".ssh", "config")) {
 
 // packages/cli/src/commands/dashboard.ts
 var WebRequestError = class extends Error {
-  constructor(message2, statusCode) {
-    super(message2);
+  constructor(message, statusCode) {
+    super(message);
     this.statusCode = statusCode;
   }
   statusCode;
@@ -3701,7 +3981,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"
@@ -4364,7 +4644,11 @@ function resolveDashboardAssetDir(explicitAssetDir) {
   }
   const embedded = materializeEmbeddedDashboardAssets(DASHBOARD_ASSETS);
   if (embedded) return embedded;
+  const checkoutPackage = resolve4(moduleDir, "..", "..");
   for (const candidate of [
+    // A source-built CLI can run from a different project directory. Resolve
+    // its sibling app from the checkout, never from an unrelated installed CLI.
+    ...existsSync2(join7(checkoutPackage, "src", "index.ts")) ? [join7(checkoutPackage, "..", "dashboard", "dist")] : [],
     join7(process.cwd(), "packages", "dashboard", "dist"),
     join7(process.cwd(), "dist", "dashboard")
   ]) {
@@ -4387,7 +4671,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;
@@ -4407,59 +4691,59 @@ async function handleWebConsoleApiRequest(req, res, requestUrl, gateway, operato
   const input = method === "GET" || method === "HEAD" ? void 0 : await readJson(req);
   const member = team?.auth.resolveSession(req);
   const author = member ? { userId: member.userId, displayName: member.displayName } : void 0;
-  if (team && method !== "GET" && method !== "HEAD") {
+  if (team?.auth.enabled && method !== "GET" && method !== "HEAD") {
     const readResume = /^saved\/[^/]+\/resume$/.test(path) && input !== null && typeof input === "object" && Object.keys(input).length === 0;
     if (/^saved\/[^/]+\/resume$/.test(path) && team.auth.resolveSession(req)?.role !== "owner" && !readResume) throw new WebRequestError("Only workspace owners can override a saved conversation's configuration.", 403);
     const liveId = /^sessions\/([^/]+)/.exec(path)?.[1];
     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 +4751,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 message = author && input && typeof input === "object" && !("workerId" in input) && (!("mode" in input) || input.mode === "send") ? { ...input, mode: "queue" } : input;
+      const { queuedMessageId, ...session } = await gateway.send(id2, message, 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 +4871,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-QLMPTFT7.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 +4918,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-ZF6ZTSIQ.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 +4952,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 +4963,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-QLMPTFT7.js");
+      const { seedVerificationWorkbench } = await import("./db-FU3OIGQK.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 +4986,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 +4996,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 +5032,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 +5048,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 +5082,7 @@ async function handleApiRequest(req, res, pathname, dbPath, controlToken, engine
           presentation
         };
       });
-      json(res, 200, { events });
+      json2(res, 200, { events });
     } finally {
       db.close();
     }
@@ -4795,7 +5094,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 +5102,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 +5112,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 +5123,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 +5143,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 +5156,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 +5203,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 +5271,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 +5281,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 +5336,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 +5357,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 +5370,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 +5382,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 +5394,7 @@ function registerDashboardCommand(program) {
             startupWorkflows = workflows;
             startupTriggers = triggers;
             startupGitHub = github;
+            stopHostReconnect = watchManagedHosts();
           } catch (cause) {
             nextBackends?.dispose();
             nextUnregister?.();
@@ -5064,12 +5412,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 +5426,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 +5437,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 +5446,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 +5459,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 +5470,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 +5518,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 +5540,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 +5580,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 +5610,7 @@ function registerDashboardCommand(program) {
                   }
                 });
               });
-              json(res, 200, result);
+              json2(res, 200, result);
               return;
             }
             if (requestUrl.pathname === "/api/workers/deploy") {
@@ -5257,7 +5643,7 @@ function registerDashboardCommand(program) {
                 });
               });
               backends.reload();
-              json(res, 202, result);
+              json2(res, 202, result);
               return;
             }
             if (requestUrl.pathname === "/api/control/launch-run") {
@@ -5267,15 +5653,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 +5669,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 +5695,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 +5716,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 +5769,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(() => {
       });