0sec-cli 0.24.1 → 0.26.0

package/chunks/{chunk-BD7WULFS.js → chunk-SSPP64FF.js}

@@ -3,14 +3,14 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   eventBus
-} from "./chunk-5PFRE522.js";
+} from "./chunk-ULRLUXSS.js";
 import {
   compareFindingsByBusinessPriority,
   estimateCost,
   modelProvider,
   splitCost,
   validateScanPlan
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
 
 // packages/core/dist/agent/cost-ledger.js
 var recordedResults = /* @__PURE__ */ new WeakMap();
@@ -209,6 +209,7 @@ function budgetNativeRuntime(runtime, ledger, signal, ceiling, plan) {
     resolvedProvider: runtime.resolvedProvider?.bind(runtime),
     resolvedPricingModel: runtime.resolvedPricingModel?.bind(runtime),
     accessibleModels: runtime.accessibleModels?.bind(runtime),
+    modelSelection: runtime.modelSelection?.bind(runtime),
     reconfigure: runtime.reconfigure?.bind(runtime),
     forkForSubagent: runtime.forkForSubagent ? async (timeout, selection) => budgetNativeRuntime(await runtime.forkForSubagent(timeout, selection), ledger, signal, ceiling, plan) : void 0,
     async executeNative(system, messages, tools, callbacks, callSignal) {

package/chunks/{chunk-BOBIAHKA.js → chunk-STPHTPSD.js}

@@ -2,335 +2,9 @@
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
-  jitterFor
-} from "./chunk-X2ZMSRTP.js";
-import {
-  scanExecutionSignal
-} from "./chunk-BD7WULFS.js";
-
-// packages/core/dist/scope/rate-limit.js
-var TokenBucket = class {
-  state;
-  nowFn;
-  sleepFn;
-  jitter;
-  constructor(rps, capacity = rps, nowFn = () => Date.now(), sleepFn = defaultSleep, jitter) {
-    if (!Number.isFinite(rps) || rps <= 0) {
-      throw new Error(`TokenBucket: rps must be a positive finite number, got ${rps}`);
-    }
-    if (!Number.isFinite(capacity) || capacity <= 0) {
-      throw new Error(`TokenBucket: capacity must be a positive finite number, got ${capacity}`);
-    }
-    this.nowFn = nowFn;
-    this.sleepFn = sleepFn;
-    this.jitter = jitter && jitter.baseMs > 0 ? jitter : void 0;
-    this.state = {
-      tokens: capacity,
-      refillRatePerMs: rps / 1e3,
-      capacity,
-      lastRefill: nowFn(),
-      retryUntil: 0
-    };
-  }
-  refill() {
-    const now = this.nowFn();
-    const elapsed = now - this.state.lastRefill;
-    if (elapsed > 0) {
-      this.state.tokens = Math.min(this.state.capacity, this.state.tokens + elapsed * this.state.refillRatePerMs);
-      this.state.lastRefill = now;
-    }
-  }
-  /**
-   * Non-blocking. Returns true and consumes `n` tokens if available;
-   * returns false and consumes nothing otherwise. Blocked during 429
-   * cool-off (returns false until park expires).
-   */
-  tryConsume(n = 1) {
-    if (this.nowFn() < this.state.retryUntil)
-      return false;
-    this.refill();
-    if (this.state.tokens >= n) {
-      this.state.tokens -= n;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Block until `n` tokens are available, then consume them. Honours
-   * the 429 park deadline first, then refill-and-spin with sleeps
-   * sized to the exact next-token-available time.
-   */
-  async acquire(n = 1, signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    if (n > this.state.capacity) {
-      n = this.state.capacity;
-    }
-    while (this.nowFn() < this.state.retryUntil) {
-      const wait = this.state.retryUntil - this.nowFn();
-      await this.sleepFn(Math.max(1, Math.min(wait, 1e3)), signal);
-    }
-    while (true) {
-      signal?.throwIfAborted();
-      this.refill();
-      if (this.state.tokens >= n) {
-        this.state.tokens -= n;
-        await this.pace(signal);
-        return;
-      }
-      const tokensNeeded = n - this.state.tokens;
-      const waitMs = Math.max(1, Math.ceil(tokensNeeded / this.state.refillRatePerMs));
-      await this.sleepFn(waitMs, signal);
-    }
-  }
-  /**
-   * Sleep the configured full-jitter delay. No-op (and no `await`-visible
-   * sleep) when no jitter is configured, so the default path is unchanged.
-   *
-   * Reuses `jitterFor` from `waf-detect.ts` — attempt 0 with an injected rng
-   * yields full jitter in `[0, baseMs]` — rather than growing a second
-   * jitter implementation.
-   */
-  async pace(signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    if (!this.jitter)
-      return;
-    const ms = jitterFor(0, this.jitter.baseMs, this.jitter.rng ?? Math.random);
-    if (ms > 0)
-      await this.sleepFn(ms, signal);
-  }
-  /**
-   * Park the bucket until `deadline` (ms since epoch). Subsequent
-   * `acquire`/`tryConsume` calls block until the deadline passes.
-   * Idempotent in the "later wins" sense: a longer park overrides a
-   * shorter one, but a shorter park does NOT shorten an existing one.
-   */
-  markRetryUntil(deadline) {
-    if (deadline > this.state.retryUntil) {
-      this.state.retryUntil = deadline;
-    }
-  }
-  /** Test introspection. */
-  _peek() {
-    this.refill();
-    return {
-      tokens: this.state.tokens,
-      retryUntil: this.state.retryUntil,
-      capacity: this.state.capacity
-    };
-  }
-};
-var RateLimiter = class _RateLimiter {
-  buckets = /* @__PURE__ */ new Map();
-  defaultCfg;
-  perHost;
-  jitter;
-  nowFn;
-  sleepFn;
-  /**
-   * Conservative cool-off floor when a 429 lands without a useful
-   * `Retry-After`, or with a tiny one. 60s matches the PoC-runtime
-   * precedent in #206 — a target that just told us to slow down has
-   * earned more than a one-second pause.
-   */
-  static RETRY_AFTER_FLOOR_MS = 6e4;
-  /**
-   * Optional observer invoked once whenever a fetch is actually throttled:
-   * either an `acquire` that had to block because the bucket was dry, or a
-   * 429 response parking the host. Used by the http_audit enforcement
-   * tracker to populate `rate_limited_count`. No-op when unset, so the
-   * normal scan path is unaffected.
-   */
-  onThrottle;
-  constructor(config, opts = {}) {
-    this.defaultCfg = config.default;
-    this.jitter = config.jitter;
-    this.perHost = {};
-    if (config.perHost) {
-      for (const [host, cfg] of Object.entries(config.perHost)) {
-        this.perHost[host.toLowerCase()] = cfg;
-      }
-    }
-    this.nowFn = opts.nowFn ?? (() => Date.now());
-    this.sleepFn = opts.sleepFn ?? defaultSleep;
-    this.onThrottle = opts.onThrottle;
-  }
-  /**
-   * Normalize a URL or host string to a bucket key. Lowercased,
-   * port-stripped, IPv6 brackets retained on the literal but dropped
-   * from the port suffix (e.g. `[::1]:443` → `[::1]`).
-   */
-  hostKey(urlOrHost) {
-    let host;
-    try {
-      host = new URL(urlOrHost).hostname;
-    } catch {
-      const trimmed = urlOrHost.trim();
-      if (!trimmed)
-        return null;
-      if (trimmed.startsWith("[")) {
-        const close = trimmed.indexOf("]");
-        if (close < 0)
-          return null;
-        host = trimmed.slice(0, close + 1);
-      } else {
-        host = trimmed.split(":")[0];
-      }
-    }
-    return host.toLowerCase();
-  }
-  getBucket(host) {
-    let bucket = this.buckets.get(host);
-    if (!bucket) {
-      const cfg = this.perHost[host] ?? this.defaultCfg;
-      bucket = new TokenBucket(cfg.rps, cfg.burst ?? cfg.rps, this.nowFn, this.sleepFn, this.jitter);
-      this.buckets.set(host, bucket);
-    }
-    return bucket;
-  }
-  /**
-   * Block until a token is available for `urlOrHost`'s host, then
-   * consume it. Unparseable input is treated as a no-op (returns
-   * immediately) — callers should not rely on rate-limiting unknowable
-   * hosts. The fetch sites that wire this up always pass full URLs.
-   */
-  async acquire(urlOrHost, n = 1, signal = scanExecutionSignal()) {
-    signal?.throwIfAborted();
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return;
-    const bucket = this.getBucket(host);
-    if (bucket.tryConsume(n)) {
-      await bucket.pace(signal);
-      return;
-    }
-    this.onThrottle?.();
-    await bucket.acquire(n, signal);
-  }
-  /**
-   * Non-blocking variant. Returns true and consumes if available,
-   * false otherwise. Used by callers that want to fall through to a
-   * fast-path / degrade rather than wait.
-   */
-  tryAcquire(urlOrHost, n = 1) {
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return true;
-    return this.getBucket(host).tryConsume(n);
-  }
-  /**
-   * Inspect a fetch response and, if it's a 429, park the host's
-   * bucket until `Retry-After` (or 60s, whichever is longer). The
-   * parsed value supports both delta-seconds (RFC 7231 §7.1.3) and
-   * HTTP-date forms; anything else falls back to the floor.
-   *
-   * No-ops on non-429 responses, or on hosts with no bucket yet
-   * (which can't happen if the caller acquired before fetching, but
-   * we don't depend on that).
-   */
-  noteResponse(urlOrHost, res) {
-    if (res.status !== 429)
-      return;
-    const host = this.hostKey(urlOrHost);
-    if (!host)
-      return;
-    this.onThrottle?.();
-    const bucket = this.getBucket(host);
-    const retryAfter = readHeader(res.headers, "retry-after");
-    const delayMs = parseRetryAfter(retryAfter, this.nowFn());
-    const deadline = this.nowFn() + Math.max(delayMs, _RateLimiter.RETRY_AFTER_FLOOR_MS);
-    bucket.markRetryUntil(deadline);
-  }
-  /** Test-only. Reset all buckets. */
-  _reset() {
-    this.buckets.clear();
-  }
-};
-function defaultSleep(ms, signal) {
-  signal?.throwIfAborted();
-  const { promise, resolve, reject } = Promise.withResolvers();
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", abort);
-    resolve();
-  }, ms);
-  const abort = () => {
-    clearTimeout(timer);
-    reject(signal?.reason ?? new Error("Rate-limit wait cancelled."));
-  };
-  signal?.addEventListener("abort", abort, { once: true });
-  return promise;
-}
-function readHeader(headers, name) {
-  if (typeof headers.get === "function") {
-    return headers.get(name);
-  }
-  return null;
-}
-function parseRetryAfter(value, now) {
-  if (!value)
-    return 0;
-  const trimmed = value.trim();
-  if (!trimmed)
-    return 0;
-  if (/^\d+$/.test(trimmed)) {
-    const seconds = parseInt(trimmed, 10);
-    return Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : 0;
-  }
-  const date = Date.parse(trimmed);
-  if (Number.isFinite(date)) {
-    return Math.max(0, date - now);
-  }
-  return 0;
-}
-function parseRateLimitFlag(spec, fallbackRps = 5) {
-  const trimmed = spec.trim();
-  if (!trimmed) {
-    return { default: { rps: fallbackRps } };
-  }
-  const parts = trimmed.split(",").map((p) => p.trim()).filter(Boolean);
-  let defaultCfg = null;
-  const perHost = {};
-  for (const part of parts) {
-    const eq = part.indexOf("=");
-    if (eq < 0) {
-      const cfg = parseRpsBurst(part);
-      defaultCfg = cfg;
-    } else {
-      const host = part.slice(0, eq).trim().toLowerCase();
-      const cfg = parseRpsBurst(part.slice(eq + 1));
-      if (!host) {
-        throw new Error(`--rate-limit: empty host in "${part}"`);
-      }
-      perHost[host] = cfg;
-    }
-  }
-  return {
-    default: defaultCfg ?? { rps: fallbackRps },
-    perHost: Object.keys(perHost).length > 0 ? perHost : void 0
-  };
-}
-function parseRpsBurst(s) {
-  const trimmed = s.trim();
-  if (!trimmed) {
-    throw new Error(`--rate-limit: empty rps value`);
-  }
-  const colon = trimmed.indexOf(":");
-  if (colon < 0) {
-    const rps2 = Number(trimmed);
-    if (!Number.isFinite(rps2) || rps2 <= 0) {
-      throw new Error(`--rate-limit: invalid rps "${trimmed}"`);
-    }
-    return { rps: rps2 };
-  }
-  const rps = Number(trimmed.slice(0, colon));
-  const burst = Number(trimmed.slice(colon + 1));
-  if (!Number.isFinite(rps) || rps <= 0) {
-    throw new Error(`--rate-limit: invalid rps "${trimmed.slice(0, colon)}"`);
-  }
-  if (!Number.isFinite(burst) || burst <= 0) {
-    throw new Error(`--rate-limit: invalid burst "${trimmed.slice(colon + 1)}"`);
-  }
-  return { rps, burst };
-}
+  RateLimiter,
+  parseRateLimitFlag
+} from "./chunk-6SNOKNCS.js";
 
 // packages/core/dist/stages/web.js
 import { randomUUID } from "node:crypto";
@@ -923,10 +597,6 @@ function summarizeWebStackFingerprint(result) {
 }
 
 export {
-  TokenBucket,
-  RateLimiter,
-  parseRetryAfter,
-  parseRateLimitFlag,
   runWebDiscoveryProbe,
   runBaselineWebChecks,
   fingerprintWebStack,

package/chunks/{chunk-Q7JKIKKF.js → chunk-UGCTPKJG.js}

@@ -3,7 +3,7 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   resolveOsecDbPath
-} from "./chunk-BMDG6T7D.js";
+} from "./chunk-72PU46MS.js";
 import {
   BACKEND_PROTOCOL_VERSION,
   BackendDescriptorSchema,
@@ -12,10 +12,10 @@ import {
   backendCapabilitiesForApiPath,
   homeStateDir,
   parseBackendHandshake
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
 import {
   external_exports
-} from "./chunk-VIT5ALXF.js";
+} from "./chunk-5XOYTAOK.js";
 
 // packages/cli/src/worker-deploy.ts
 import { execFileSync, spawn, spawnSync } from "node:child_process";
@@ -30,12 +30,8 @@ var REMOTE_DEPS = {
   "node-sqlite3-wasm": "^0.8.55",
   "pdfkit": "^0.15.2",
   "playwright": "1.60.0",
-  "react": "^19.2.4",
-  "react-dom": "^19.2.4",
   "tree-sitter": `file:${REMOTE_DIR}/vendor/tree-sitter-0.21.1-node24.tgz`,
-  "tree-sitter-c": "0.21.4",
-  "@opentui/core": "0.5.4",
-  "@opentui/react": "0.5.4"
+  "tree-sitter-c": "0.21.4"
 };
 var SSH_HOST_PATTERN = /^[A-Za-z0-9._@-]+$/;
 var LIMA_NAME_PATTERN = /^[\w.-]+$/;
@@ -50,6 +46,9 @@ function resolveWorkerRepoRoot(moduleUrl = import.meta.url) {
     directory = parent;
   }
 }
+function resolveWorkerDemoRoot(repoRoot, bundleRoot) {
+  return existsSync(join(bundleRoot, "dist/worker-assets/demo-target")) ? join(bundleRoot, "dist/worker-assets") : join(repoRoot, "assets/worker-demo");
+}
 function validateWorkerOptions(options) {
   if (options.enginePort !== void 0 && (!Number.isInteger(options.enginePort) || options.enginePort < 1 || options.enginePort > 65535)) throw new Error("enginePort must be 1-65535");
   if (options.ssh && (!SSH_HOST_PATTERN.test(options.ssh) || options.ssh.startsWith("-"))) {
@@ -64,10 +63,10 @@ function createRunner(options) {
     const configArgs = options.sshConfig ? ["-F", options.sshConfig] : [];
     return {
       label: host,
-      shell: (command, timeout = 3e5) => execFileSync("ssh", ["-o", "BatchMode=yes", "-o", "ConnectTimeout=15", ...configArgs, "--", host, "bash", "-s"], { input: command, encoding: "utf8", timeout }),
+      shell: (command, timeout = 3e5) => execFileSync("ssh", ["-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes", "-o", "ConnectTimeout=15", ...configArgs, "--", host, "bash", "-s"], { input: command, encoding: "utf8", timeout }),
       copy: (local, remote) => execFileSync("scp", ["-q", "-o", "BatchMode=yes", ...configArgs, "--", local, `${host}:${remote}`], { stdio: "inherit", timeout: 6e5 }),
       tunnel: (port) => {
-        const child = spawn("ssh", ["-o", "BatchMode=yes", ...configArgs, "-N", "-L", `${port}:127.0.0.1:${port}`, "--", host], { stdio: "ignore", detached: true });
+        const child = spawn("ssh", ["-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes", "-o", "ExitOnForwardFailure=yes", ...configArgs, "-N", "-L", `${port}:127.0.0.1:${port}`, "--", host], { stdio: "ignore", detached: true });
         child.unref();
         return child.pid;
       }
@@ -120,7 +119,7 @@ async function deployWorker(options, runner = createRunner(options)) {
       }
     }
     execFileSync("tar", ["-czf", join(staging, "bundle.tar.gz"), "-C", bundleRoot, "dist"], { stdio: "inherit", env: { ...process.env, COPYFILE_DISABLE: "1" } });
-    const demoRoot = existsSync(join(bundleRoot, "dist/worker-assets/demo-target")) ? join(bundleRoot, "dist/worker-assets") : join(repoRoot, "research/counterexample-decoder");
+    const demoRoot = resolveWorkerDemoRoot(repoRoot, bundleRoot);
     if (!options.targetGit) execFileSync("tar", ["-czf", join(staging, "demo-target.tar.gz"), "-C", demoRoot, "demo-target"], { stdio: "inherit", env: { ...process.env, COPYFILE_DISABLE: "1" } });
     shell(`for entry in /proc/[0-9]*/cwd; do
     test "$(readlink "$entry" 2>/dev/null)" = "${REMOTE_DIR}" || continue
@@ -168,7 +167,12 @@ async function deployWorker(options, runner = createRunner(options)) {
     writeFileSync(backendsConfig, JSON.stringify(registry, null, 2) + "\n", { mode: 384 });
     writeFileSync(join(stateDir, `${backendId}.env`), `${tokenEnv}=${token}
 `, { mode: 384 });
-    writeFileSync(join(stateDir, `${backendId}.json`), JSON.stringify({ schemaVersion: 1, backendId, ssh: options.ssh, lima: options.ssh ? void 0 : options.lima ?? "zero-worker", sshConfig: options.sshConfig, port, tunnelPid, remoteDir: REMOTE_DIR }, null, 2) + "\n", { mode: 384 });
+    let previousMetadata = {};
+    try {
+      previousMetadata = JSON.parse(readFileSync(join(stateDir, `${backendId}.json`), "utf8"));
+    } catch {
+    }
+    writeFileSync(join(stateDir, `${backendId}.json`), JSON.stringify({ ...previousMetadata, schemaVersion: 1, backendId, autoReconnect: true, ssh: options.ssh, lima: options.ssh ? void 0 : options.lima ?? "zero-worker", sshConfig: options.sshConfig, port, tunnelPid, remoteDir: REMOTE_DIR }, null, 2) + "\n", { mode: 384 });
     process.env[tokenEnv] = token;
     return { backendId, engine: `http://127.0.0.1:${port}/`, target: targetPath, backendsConfig, tokenEnv };
   } finally {
@@ -183,7 +187,7 @@ function loadManagedWorker(backendId) {
   } catch {
     throw new Error("This connection has no managed deployment metadata. Stop its engine directly on the host.");
   }
-  if (worker.schemaVersion !== 1 || worker.backendId !== backendId || worker.remoteDir !== REMOTE_DIR || !!worker.ssh === !!worker.lima) throw new Error("Invalid managed deployment metadata.");
+  if (worker.schemaVersion !== 1 || worker.backendId !== backendId || worker.remoteDir !== REMOTE_DIR || !!worker.ssh === !!worker.lima || worker.autoReconnect !== void 0 && typeof worker.autoReconnect !== "boolean") throw new Error("Invalid managed deployment metadata.");
   validateWorkerOptions({ ...worker, enginePort: worker.port });
   return worker;
 }
@@ -202,6 +206,7 @@ function stopManagedTunnel(worker) {
 }
 async function stopWorker(backendId, suppliedRunner) {
   const worker = loadManagedWorker(backendId);
+  writeFileSync(join(homeStateDir(), "workers", `${backendId}.json`), JSON.stringify({ ...worker, autoReconnect: false }, null, 2) + "\n", { mode: 384 });
   const runner = suppliedRunner ?? createRunner(worker);
   runner.shell(`set -eu
 if test ! -f ${REMOTE_DIR}/engine.pid; then echo 'Managed engine PID is unavailable; engine was not stopped.' >&2; exit 1; fi
@@ -216,6 +221,64 @@ fi
 rm -f ${REMOTE_DIR}/engine.pid`, 3e4);
   return { stopped: true, tunnelStopped: stopManagedTunnel(worker), remoteFilesRemoved: false };
 }
+async function repairWorker(backendId, suppliedRunner, probe = (port) => {
+  try {
+    execFileSync("curl", ["-sf", "--connect-timeout", "2", "--max-time", "3", `http://127.0.0.1:${port}/`], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}) {
+  const worker = loadManagedWorker(backendId);
+  const credential = readFileSync(join(homeStateDir(), "workers", `${backendId}.env`), "utf8").trim();
+  const match = /^(ZERO_WORKER_[A-F0-9]+_TOKEN)=([a-f0-9]{64})$/.exec(credential);
+  if (!match) throw new Error("Managed worker credential is unavailable. Deploy this host again.");
+  writeFileSync(join(homeStateDir(), "workers", `${backendId}.json`), JSON.stringify({ ...worker, autoReconnect: true }, null, 2) + "\n", { mode: 384 });
+  const runner = suppliedRunner ?? createRunner(worker);
+  const result = runner.shell(`set -eu
+cd ${REMOTE_DIR}
+test -f dist/0.js && test -d work || { echo 'Managed engine files are missing. Deploy this host again.' >&2; exit 1; }
+command -v node >/dev/null || { echo 'Node is unavailable on this host.' >&2; exit 1; }
+running=0
+if test -f engine.pid; then
+  pid=$(cat engine.pid)
+  case "$pid" in ''|*[!0-9]*) echo 'Invalid managed engine PID.' >&2; exit 1;; esac
+  if test "$pid" -gt 1 && kill -0 "$pid" 2>/dev/null; then
+    test "$(readlink /proc/$pid/cwd)" = "${REMOTE_DIR}" || { echo 'Managed engine PID belongs to another process.' >&2; exit 1; }
+    command=$(tr '\\000' ' ' < /proc/$pid/cmdline)
+    case "$command" in 'node dist/0.js dashboard '*|'node /tmp/zero-engine/dist/0.js dashboard '*) running=1;; *) echo 'Managed engine PID does not match Zero.' >&2; exit 1;; esac
+  fi
+fi
+if test "$running" = 0; then
+  if ss -ltn 2>/dev/null | grep -q ':${worker.port} '; then echo 'Engine port is occupied. No process was replaced.' >&2; exit 1; fi
+  ZERO_WORKER_TOKEN=${match[2]} setsid nohup node dist/0.js dashboard --host 127.0.0.1 --port ${worker.port} --no-open --ready-json --engine-token-env ZERO_WORKER_TOKEN --engine-workspace ${REMOTE_DIR}/work > engine.log 2>&1 < /dev/null &
+  echo $! > engine.pid
+  echo ENGINE_STARTED
+fi
+for i in $(seq 1 20); do
+  if curl -sf --max-time 1 http://127.0.0.1:${worker.port}/ >/dev/null; then echo ENGINE_READY; exit 0; fi
+  sleep 1
+done
+echo 'Managed engine did not become ready.' >&2; exit 1`, 3e4);
+  if (!result.includes("ENGINE_READY")) throw new Error("Managed engine did not become ready.");
+  process.env[match[1]] = match[2];
+  if (!probe(worker.port)) {
+    stopManagedTunnel(worker);
+    const tunnelPid = runner.tunnel(worker.port);
+    if (!Number.isSafeInteger(tunnelPid) || tunnelPid <= 1) throw new Error("Could not start the SSH tunnel.");
+    writeFileSync(join(homeStateDir(), "workers", `${backendId}.json`), JSON.stringify({ ...loadManagedWorker(backendId), tunnelPid }, null, 2) + "\n", { mode: 384 });
+    let ready = false;
+    for (let attempt = 0; attempt < 12; attempt++) {
+      if (probe(worker.port)) {
+        ready = true;
+        break;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 250));
+    }
+    if (!ready) throw new Error("Remote engine is ready, but its SSH tunnel could not reconnect.");
+  }
+  return { backendId, reconnected: true, engineStarted: result.includes("ENGINE_STARTED") };
+}
 
 // packages/cli/src/web/backend-connections.ts
 import { randomUUID } from "node:crypto";
@@ -365,6 +428,9 @@ var BackendConnectionRegistry = class {
   #descriptors = /* @__PURE__ */ new Map();
   #pins = /* @__PURE__ */ new Map();
   #handshakes = /* @__PURE__ */ new Map();
+  // Bind the safe classification to the exact returned view, so concurrent
+  // reprobes cannot replace another caller's failure. No cause crosses the API.
+  #disconnectedStatuses = /* @__PURE__ */ new WeakMap();
   #pending = /* @__PURE__ */ new Map();
   #env;
   #fetch;
@@ -469,7 +535,7 @@ var BackendConnectionRegistry = class {
     delete descriptor.error;
     try {
       const response = await this.#send(row, "/api/backend/handshake", {});
-      if (!response.ok) throw new BackendConnectionError("Backend handshake was rejected.", response.status === 401 || response.status === 403 ? 403 : 502);
+      if (!response.ok) throw new BackendConnectionError("Backend handshake was rejected.", response.status);
       const raw = BackendHandshakeSchema.parse(await response.json());
       descriptor.protocolVersion = raw.protocolVersion;
       if (raw.protocolVersion !== BACKEND_PROTOCOL_VERSION) {
@@ -489,7 +555,9 @@ var BackendConnectionRegistry = class {
       if (descriptor.status !== "incompatible") descriptor.status = "disconnected";
       descriptor.error = error instanceof BackendConnectionError ? error.message : "Backend connection failed.";
       this.#handshakes.delete(id);
-      return { backend: structuredClone(descriptor), error: descriptor.error };
+      const backend = structuredClone(descriptor);
+      this.#disconnectedStatuses.set(backend, error instanceof BackendConnectionError ? error.statusCode : 502);
+      return { backend, error: descriptor.error };
     }
   }
   async request(id, path, options = {}) {
@@ -499,7 +567,7 @@ var BackendConnectionRegistry = class {
     const canonical = apiPath(path);
     const cached = this.#handshakes.get(id);
     const view = cached && Date.now() - cached.at < 5e3 ? { backend: this.#descriptors.get(id) } : await this.handshake(id);
-    if (view.backend.status !== "connected") throw new BackendConnectionError(view.backend.error ?? "Backend is disconnected.", view.backend.status === "incompatible" ? 409 : 503);
+    if (view.backend.status !== "connected") throw new BackendConnectionError(view.backend.error ?? "Backend is disconnected.", this.#disconnectedStatuses.get(view.backend) ?? (view.backend.status === "incompatible" ? 409 : 503));
     for (const required of capabilities(canonical)) if (!view.backend.capabilities.includes(required)) throw new BackendConnectionError(`Backend does not support ${required}.`, 409);
     try {
       return await this.#send(row, canonical, options);
@@ -642,7 +710,7 @@ function json(res, status, value) {
   res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
   res.end(JSON.stringify(value));
 }
-async function handleBackendConnectionRequest(req, res, url, registry) {
+async function handleBackendConnectionRequest(req, res, url, registry, onSessionClosed) {
   if (url.pathname === "/api/backends") {
     if (req.method !== "GET") throw new BackendConnectionError("Backend registry is read-only.", 405);
     registry.reload();
@@ -670,6 +738,7 @@ async function handleBackendConnectionRequest(req, res, url, registry) {
     return { handled: true };
   }
   const path = apiPath(`${url.pathname.slice(url.pathname.indexOf("/proxy/") + "/proxy".length)}${url.search}`);
+  if (new URL(path, "http://backend.invalid").pathname.startsWith("/api/console/provider-relays")) throw new BackendConnectionError("Provider relay grants are managed by the local engine.", 403);
   if (id === "local") return { handled: false, localPath: path };
   const abort = new AbortController();
   const disconnect = () => abort.abort();
@@ -679,6 +748,8 @@ async function handleBackendConnectionRequest(req, res, url, registry) {
     const body = ["GET", "HEAD"].includes(req.method ?? "GET") ? void 0 : await requestJson(req);
     const stream = req.headers.accept?.includes("text/event-stream") === true;
     const response = await registry.request(id, path, { method: req.method, body, stream, signal: abort.signal, lastEventId: typeof req.headers["last-event-id"] === "string" ? req.headers["last-event-id"] : void 0, requestId: typeof req.headers["x-0-request-id"] === "string" ? req.headers["x-0-request-id"] : void 0 });
+    const closedSession = /^\/api\/console\/sessions\/([^/]+)(\/delete)?$/.exec(new URL(path, "http://backend.invalid").pathname);
+    if (response.ok && closedSession && (req.method === "DELETE" && !closedSession[2] || req.method === "POST" && closedSession[2])) await onSessionClosed?.(id, decodeURIComponent(closedSession[1]));
     if (res.destroyed) return { handled: true };
     res.writeHead(response.status, { "Content-Type": response.headers.get("content-type") ?? "application/json", ...attachmentHeaders(response.headers), "Cache-Control": "no-store", "X-0-Request-ID": response.headers.get("x-0-request-id") ?? randomUUID(), ...response.headers.get("x-0-engine-id") ? { "X-0-Engine-ID": response.headers.get("x-0-engine-id") } : {}, "X-Content-Type-Options": "nosniff", ...stream ? { "X-Accel-Buffering": "no" } : {} });
     if (!response.body) {
@@ -727,6 +798,7 @@ export {
   deployWorker,
   loadManagedWorker,
   stopWorker,
+  repairWorker,
   BackendConnectionError,
   loadBackendConnectionConfig,
   createBackendHandshake,

package/chunks/{chunk-5PFRE522.js → chunk-ULRLUXSS.js}

@@ -3,7 +3,7 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   createPresentationEvent
-} from "./chunk-GXXX7AGH.js";
+} from "./chunk-GYEYTNHK.js";
 
 // packages/core/dist/events/bus.js
 function presentationEventSink(sink, options = {}) {