svamp-cli 0.2.274 → 0.2.276

package/dist/{run-l_8UB-9h.mjs → run-DjThStDG.mjs}

@@ -3,7 +3,7 @@ import fs$1, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as wr
 import * as fs from 'fs';
 import fs__default, { existsSync as existsSync$1, rmSync, readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync as renameSync$1, realpathSync as realpathSync$1, copyFileSync, unlinkSync as unlinkSync$1, readdirSync as readdirSync$1, watch, rmdirSync } from 'fs';
 import * as path from 'path';
-import path__default, { join, resolve as resolve$1, dirname as dirname$1, basename as basename$1 } from 'path';
+import path__default, { join, delimiter, resolve as resolve$1, dirname as dirname$1, basename as basename$1 } from 'path';
 import { fileURLToPath } from 'url';
 import { execFile, spawn, execSync, exec as exec$1 } from 'child_process';
 import * as crypto from 'crypto';
@@ -1158,8 +1158,14 @@ async function readProcessTable() {
   let stdout;
   try {
     const result = await execFileAsync$1("ps", ["-A", "-o", "pid=,ppid=,etime=,%cpu=,rss=,command="], {
-      maxBuffer: 8 * 1024 * 1024
+      maxBuffer: 8 * 1024 * 1024,
       // 8MB — plenty for any realistic process table
+      // Hard wall-clock deadline: on a wedged host (D-state / stuck FS) `ps` can block
+      // forever; maxBuffer bounds size, not time. Without this the awaited promise never
+      // settles and callers (killDescendant admin RPC, Tasks-panel detectDescendants) hang.
+      // On timeout execFile rejects → the catch below returns [] (best-effort, no crash).
+      timeout: 5e3,
+      killSignal: "SIGKILL"
     });
     stdout = result.stdout;
   } catch {
@@ -1500,6 +1506,9 @@ const COOKIE_NAME = "svamp_serve_token";
 const SVAMP_SERVE_TOKEN_PARAM = "__svamp_serve_token";
 const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
 const DEFAULT_CACHE_MAX_SIZE = 1e3;
+function jsStringLiteral(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
 class TokenCache {
   cache = /* @__PURE__ */ new Map();
   ttlMs;
@@ -1602,16 +1611,19 @@ function isStructurallyLiveJwt(token) {
 async function verifyTokenViaHypha(token, hyphaServerUrl) {
   try {
     const baseUrl = hyphaServerUrl.replace(/\/$/, "");
-    const url = `${baseUrl}/public/services/ws/get_user_info`;
+    const url = `${baseUrl}/public/services/ws/parse_token`;
     const resp = await fetch(url, {
-      method: "GET",
+      method: "POST",
       headers: {
-        Authorization: `Bearer ${token}`
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
       },
+      body: JSON.stringify({ token }),
       signal: AbortSignal.timeout(1e4)
     });
     if (!resp.ok) return null;
     const data = await resp.json();
+    if (data?.is_anonymous === true) return null;
     const email = data?.email;
     if (typeof email === "string" && email) return email.toLowerCase();
     return null;
@@ -1701,10 +1713,10 @@ a:hover{text-decoration:underline}
   <div class="status" id="status"></div>
 </div>
 <script>
-const hyphaServer = ${JSON.stringify(this.hyphaServerUrl)};
-const redirectUrl = ${JSON.stringify(redirectUrl)};
-const cookieName = ${JSON.stringify(COOKIE_NAME)};
-const tokenParam = ${JSON.stringify(SVAMP_SERVE_TOKEN_PARAM)};
+const hyphaServer = ${jsStringLiteral(this.hyphaServerUrl)};
+const redirectUrl = ${jsStringLiteral(redirectUrl)};
+const cookieName = ${jsStringLiteral(COOKIE_NAME)};
+const tokenParam = ${jsStringLiteral(SVAMP_SERVE_TOKEN_PARAM)};
 
 const btn = document.getElementById('login-btn');
 const statusEl = document.getElementById('status');
@@ -2201,7 +2213,7 @@ class ServeManager {
       throw new Error(`Path does not exist: ${resolvedDir}`);
     }
     if (this.mounts.has(spec.name)) {
-      await this.removeMount(spec.name);
+      await this.removeMount(spec.name, { replacing: true });
     }
     const access = spec.access ?? "link";
     if (access === "owner" && !spec.ownerEmail) {
@@ -2240,7 +2252,7 @@ class ServeManager {
   /**
    * Remove a mount. If no mounts remain, stop Caddy + auth proxy.
    */
-  async removeMount(name) {
+  async removeMount(name, opts) {
     if (!this.mounts.has(name)) {
       throw new Error(`Mount '${name}' not found`);
     }
@@ -2260,7 +2272,7 @@ class ServeManager {
     }
     this.persist();
     this.log(`Mount removed: ${name}`);
-    if (this.mounts.size === 0) {
+    if (this.mounts.size === 0 && !opts?.replacing) {
       await this.shutdown();
     }
   }
@@ -2403,7 +2415,12 @@ class ServeManager {
       cwd: cfg.workdir ?? process.cwd(),
       env: { ...process.env, ...cfg.env ?? {} },
       stdio: ["ignore", "pipe", "pipe"],
-      detached: false
+      // #0483: run in its OWN process group so we can kill the whole tree. Managed mounts
+      // are typically wrappers (npm start / npm run dev / python -m …) whose real listener
+      // is a GRANDCHILD; killing only the direct pid leaves the grandchild holding the port
+      // → next warmup hits EADDRINUSE → mount permanently broken + orphan accumulation.
+      // killManagedTree() below signals -pid (the group).
+      detached: true
     });
     child.stdout?.on("data", (d) => {
       const line = d.toString().trimEnd();
@@ -2429,10 +2446,7 @@ class ServeManager {
       this.log(`Managed process '${name}' ready on 127.0.0.1:${cfg.port}`);
     }).catch((err) => {
       this.log(`Managed process '${name}' warmup failed: ${err.message}`);
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
+      this.killManagedTree(child, "SIGTERM");
       this.managedProcs.delete(name);
       throw err;
     });
@@ -2440,12 +2454,33 @@ class ServeManager {
       child,
       pid: child.pid ?? 0,
       lastRequestAt: Date.now(),
+      activeConns: 0,
       warmupPromise
     };
     this.managedProcs.set(name, newHandle);
     this.log(`Managed process '${name}' starting: ${cfg.command} ${(cfg.args ?? []).join(" ")} (port ${cfg.port})`);
     return warmupPromise;
   }
+  /**
+   * #0483: kill the managed child's whole PROCESS GROUP (it was spawned detached, so it leads
+   * its own group). This reaps grandchildren (the real listener behind an npm/python wrapper)
+   * that a direct child.kill() would orphan, leaving the port bound. Falls back to a direct
+   * child.kill() if the group signal fails (e.g. pid already gone).
+   */
+  killManagedTree(child, signal) {
+    const pid = child.pid;
+    if (pid && pid > 0) {
+      try {
+        process.kill(-pid, signal);
+        return;
+      } catch {
+      }
+    }
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
   /** Poll a URL until it returns <500 or the deadline passes. */
   async warmupProbe(url, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
@@ -2478,17 +2513,11 @@ class ServeManager {
     const h = this.managedProcs.get(name);
     if (!h) return;
     this.managedProcs.delete(name);
-    try {
-      h.child.kill("SIGTERM");
-    } catch {
-    }
     const child = h.child;
+    this.killManagedTree(child, "SIGTERM");
     await new Promise((resolve) => {
       const t = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
+        this.killManagedTree(child, "SIGKILL");
         resolve();
       }, 5e3);
       child.once("exit", () => {
@@ -2508,6 +2537,10 @@ class ServeManager {
         if (!cfg || !cfg.idleTimeoutSec || cfg.idleTimeoutSec <= 0) continue;
         const h = this.managedProcs.get(name);
         if (!h || h.warmupPromise) continue;
+        if (h.activeConns > 0) {
+          h.lastRequestAt = now;
+          continue;
+        }
         if (now - h.lastRequestAt >= cfg.idleTimeoutSec * 1e3) {
           this.log(`Idle eviction: stopping '${name}' (idle ${Math.round((now - h.lastRequestAt) / 1e3)}s \u2265 ${cfg.idleTimeoutSec}s)`);
           this.stopManagedProcess(name).catch(() => {
@@ -2538,7 +2571,9 @@ class ServeManager {
       ...this.port > 0 ? { port: this.port } : {}
     };
     try {
-      fs.writeFileSync(this.persistFile, JSON.stringify(state, null, 2));
+      const tmp = `${this.persistFile}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+      fs.renameSync(tmp, this.persistFile);
     } catch (err) {
       this.log(`Error persisting serve state: ${err.message}`);
     }
@@ -2676,12 +2711,27 @@ a{color:#0969da;text-decoration:none;font-weight:500}a:hover{text-decoration:und
           if (req.method === "PUT") {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             const ws = fs.createWriteStream(filePath);
+            let done = false;
+            const cleanupPartial = () => {
+              if (done) return;
+              done = true;
+              ws.destroy();
+              fs.unlink(filePath, () => {
+              });
+            };
+            req.on("aborted", cleanupPartial);
+            req.on("close", () => {
+              if (!ws.writableFinished) cleanupPartial();
+            });
             req.pipe(ws);
             ws.on("finish", () => {
+              done = true;
               res.writeHead(201);
               res.end();
             });
             ws.on("error", (err) => {
+              if (done) return;
+              done = true;
               res.writeHead(500);
               res.end(err.message);
             });
@@ -2709,7 +2759,18 @@ a{color:#0969da;text-decoration:none;font-weight:500}a:hover{text-decoration:und
             }
           }
           const handle = this.managedProcs.get(mount.name);
-          if (handle) handle.lastRequestAt = Date.now();
+          if (handle) {
+            handle.lastRequestAt = Date.now();
+            handle.activeConns++;
+            let released = false;
+            const release = () => {
+              if (released) return;
+              released = true;
+              handle.activeConns = Math.max(0, handle.activeConns - 1);
+              handle.lastRequestAt = Date.now();
+            };
+            res.on("close", release);
+          }
           const targetPath = mountResolvedByHost ? req.url || "/" : (basePath || "/") + (url.search || "");
           const proxyReq = http.request({
             hostname: "127.0.0.1",
@@ -2810,7 +2871,17 @@ Connection: close\r
               }
             }
             const handle = this.managedProcs.get(mount.name);
-            if (handle) handle.lastRequestAt = Date.now();
+            if (handle) {
+              handle.lastRequestAt = Date.now();
+              handle.activeConns++;
+              let released = false;
+              clientSocket.on("close", () => {
+                if (released) return;
+                released = true;
+                handle.activeConns = Math.max(0, handle.activeConns - 1);
+                handle.lastRequestAt = Date.now();
+              });
+            }
             const targetPath = mountResolvedByHost ? req.url || "/" : (url.pathname.slice(`/${mountName}`.length) || "/") + (url.search || "");
             const upstream = net.connect(cfg.port, "127.0.0.1", () => {
               const lines = [`${req.method} ${targetPath} HTTP/1.1`];
@@ -2902,7 +2973,7 @@ Connection: close\r
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-Dzhtizmd.mjs');
+      const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -4297,6 +4368,14 @@ class ChannelOutbox {
   file;
   byChannel = /* @__PURE__ */ new Map();
   seqByChannel = /* @__PURE__ */ new Map();
+  // #0500: per-channel MONOTONIC high-water seq that survives TTL eviction/compaction. seqByChannel
+  // is rebuilt from RETAINED records on every reload, so once a channel's replies all age out (>1h
+  // idle) its seq would reset to 1 — a long-poll receiver holding a pre-eviction cursor N would then
+  // silently drop the new seq=1..N replies (since() filters seq > cursor). highWater is never lowered
+  // and is persisted to a small sidecar (_outbox_seq.json) so seq stays monotonic across eviction AND
+  // daemon restarts. Cross-process safe: re-read + max before each bump (via reload()).
+  highWater = /* @__PURE__ */ new Map();
+  seqFile;
   emitter = new EventEmitter();
   appendsSinceCompact = 0;
   // #0362: change-detection for reload() — a long-poll receiver reuses ONE instance and only
@@ -4307,12 +4386,14 @@ class ChannelOutbox {
   constructor(projectDir) {
     const dir = join$1(projectDir, ".svamp", "channels");
     this.file = join$1(dir, "_outbox.jsonl");
+    this.seqFile = join$1(dir, "_outbox_seq.json");
     this.emitter.setMaxListeners(0);
     try {
       mkdirSync$1(dir, { recursive: true });
     } catch {
     }
     this._load();
+    this._loadHighWater();
   }
   /** Current on-disk (mtimeMs, size), or (0, -1) if the file does not exist. */
   _stat() {
@@ -4335,6 +4416,7 @@ class ChannelOutbox {
     this.byChannel.clear();
     this.seqByChannel.clear();
     this._load();
+    this._loadHighWater();
     return true;
   }
   _load() {
@@ -4357,6 +4439,7 @@ class ChannelOutbox {
         arr.push(reply);
         this.byChannel.set(channelId, arr);
         this.seqByChannel.set(channelId, Math.max(this.seqByChannel.get(channelId) || 0, reply.seq));
+        this.highWater.set(channelId, Math.max(this.highWater.get(channelId) || 0, reply.seq));
       }
       for (const [ch, arr] of this.byChannel) if (arr.length > MAX_PER_CHANNEL) this.byChannel.set(ch, arr.slice(-MAX_PER_CHANNEL));
     } catch {
@@ -4384,6 +4467,30 @@ class ChannelOutbox {
     } catch {
     }
   }
+  /** #0500: merge the durable per-channel high-water sidecar into memory (never lowers a value). */
+  _loadHighWater() {
+    try {
+      if (!existsSync(this.seqFile)) return;
+      const obj = JSON.parse(readFileSync(this.seqFile, "utf8"));
+      for (const [ch, seq] of Object.entries(obj)) {
+        if (typeof seq === "number" && Number.isFinite(seq)) {
+          this.highWater.set(ch, Math.max(this.highWater.get(ch) || 0, seq));
+        }
+      }
+    } catch {
+    }
+  }
+  /** #0500: atomically persist the high-water map so seq survives eviction + restart. Best-effort. */
+  _persistHighWater() {
+    try {
+      const obj = {};
+      for (const [ch, seq] of this.highWater) obj[ch] = seq;
+      const tmp = `${this.seqFile}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+      writeFileSync$1(tmp, JSON.stringify(obj));
+      renameSync(tmp, this.seqFile);
+    } catch {
+    }
+  }
   _evict(channelId) {
     const cutoff = Date.now() - TTL_MS;
     let arr = this.byChannel.get(channelId);
@@ -4394,8 +4501,11 @@ class ChannelOutbox {
   }
   /** Append a reply addressed to `to`. Assigns seq + ts, persists, and wakes waiters. */
   append(channelId, r) {
-    const seq = (this.seqByChannel.get(channelId) || 0) + 1;
+    this.reload();
+    const seq = Math.max(this.highWater.get(channelId) || 0, this.seqByChannel.get(channelId) || 0) + 1;
     this.seqByChannel.set(channelId, seq);
+    this.highWater.set(channelId, seq);
+    this._persistHighWater();
     const reply = { seq, ts: Date.now(), to: r.to, body: r.body, ...r.correlationId ? { correlationId: r.correlationId } : {} };
     const arr = this.byChannel.get(channelId) || [];
     arr.push(reply);
@@ -4412,6 +4522,7 @@ class ChannelOutbox {
     }
     if (++this.appendsSinceCompact >= COMPACT_EVERY) {
       this.appendsSinceCompact = 0;
+      this.reload();
       this._compact();
     }
     this.emitter.emit(channelId, reply);
@@ -4469,6 +4580,7 @@ class ChannelOutbox {
   }
   /** Drop a channel's outbox (on channel delete) — best-effort rewrite of the log. */
   purge(channelId) {
+    if (existsSync(this.file)) this.reload();
     this.byChannel.delete(channelId);
     this.seqByChannel.delete(channelId);
     if (!existsSync(this.file)) return;
@@ -5704,7 +5816,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-Dzhtizmd.mjs');
+        const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -5852,7 +5964,9 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         authorizeRequest(context, currentMetadata.sharing, "view");
         const sm = handlers.serveManager;
         if (!sm) throw new Error("Serve manager not available");
-        return sm.getInfo();
+        const info = sm.getInfo();
+        const isAdmin = serveCallerTrusted(context);
+        return { ...info, mounts: (info.mounts || []).map((m) => sanitizeMountForRole(m, isAdmin)) };
       },
       /**
        * Aggregate frpc tunnel health for all serve mounts.
@@ -6178,7 +6292,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-C8myzP2c.mjs');
+          const { toolsForRole } = await import('./sideband-DdcXgJHf.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -6277,7 +6391,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-D606feNR.mjs');
+    const { queryCore } = await import('./commands-DINv6746.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -6372,7 +6486,9 @@ ${d?.error || "not found"}`;
         });
         if (r.error || !r.sender) return { error: r.error || "unauthorized" };
         const cursor = Math.max(0, Number(kwargs.cursor) || 0);
-        const waitMs = Math.min(Math.max(0, Number(kwargs.wait ?? 25) * 1e3), 6e4);
+        const waitRaw = Number(kwargs.wait ?? 25);
+        const waitSec = Number.isFinite(waitRaw) ? waitRaw : 25;
+        const waitMs = Math.min(Math.max(0, waitSec * 1e3), 6e4);
         const outbox = new ChannelOutbox(dir);
         const deadline = Date.now() + waitMs;
         for (; ; ) {
@@ -6483,7 +6599,7 @@ function writeInboundContext(sessionId, ctx) {
   try {
     const p = ctxPath(sessionId);
     mkdirSync$1(join$1(SVAMP_HOME$2, "inbound"), { recursive: true });
-    const tmp = p + ".tmp";
+    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
     writeFileSync$1(tmp, JSON.stringify({ ...ctx, deliveredAt: Date.now() }));
     renameSync(tmp, p);
   } catch {
@@ -7084,7 +7200,13 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
   const skillCtxFor = (c) => ({
     channelsServiceId,
     baseUrl: channelsBaseUrl,
-    key: c.identity?.shared_key || c.identity?.callers?.[0]?.key,
+    // #0512: embed ONLY the channel-wide shared_key. The previous `|| callers?.[0]?.key`
+    // fallback leaked one specific caller's PRIVATE per-key credential into the skill body,
+    // which is served by the UNAUTHENTICATED channelDescribe (and view-tier getChannelSkill) —
+    // an anonymous reader could then impersonate that caller (send as them + read their outbox).
+    // For a per-key channel (no shared_key) key is undefined and generateSkillBody renders the
+    // <your-key> placeholder, which is the correct instruction for a per-key caller.
+    key: c.identity?.shared_key,
     // The session this skill is being copied FROM — baked into `dynamic` channel
     // instructions as the routing target so the copied link lands in THIS session.
     session: sessionId
@@ -7467,7 +7589,9 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
         name: c.name,
         skillUrl,
         sendUrl,
-        key: c.identity?.shared_key || c.identity?.callers?.[0]?.key,
+        // #0512: only the channel-wide shared_key — never an individual caller's private key
+        // (this getChannelSkill result is reachable at view tier).
+        key: c.identity?.shared_key,
         hyphaKeyless: (c.identity?.hypha_allow || []).length > 0,
         bind: c.bind,
         bindMode: mode,
@@ -8713,6 +8837,23 @@ function handleClaudeMessage(ctx, msg) {
   }
 }
 
+const KNOWN_AGENT_LAUNCHERS = ["claude", "codex", "gemini"];
+function agentLauncherExists(cmd, env = process.env) {
+  if (!cmd) return false;
+  if (cmd.includes("/") || cmd.includes("\\")) return existsSync$1(cmd);
+  const dirs = (env.PATH || "").split(delimiter).filter(Boolean);
+  const exts = process.platform === "win32" ? ["", ...(env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)] : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      if (existsSync$1(join(dir, cmd + ext))) return true;
+    }
+  }
+  return false;
+}
+function detectAvailableAgents(env = process.env) {
+  return KNOWN_AGENT_LAUNCHERS.filter((c) => agentLauncherExists(c, env));
+}
+
 const INLINE_ARTIFACT_MAX_BYTES = 512 * 1024;
 const MAX_STORED_MESSAGE_BYTES = 2 * 1024 * 1024;
 const MIN_DATA_URI_SCAN_CHARS = INLINE_ARTIFACT_MAX_BYTES;
@@ -12077,7 +12218,31 @@ async function verifyIsolation(method, binaryPath) {
       return { passed: false, error: `${method} is not supported for external isolation` };
   }
 }
+function isolationDisabledByEnv(env = process.env) {
+  const v = (env.SVAMP_ISOLATION || "").trim().toLowerCase();
+  if (v && ["none", "off", "disabled", "0", "false", "no"].includes(v)) return true;
+  const truthy = (s) => !!s && !["", "0", "false", "no", "off"].includes(s.trim().toLowerCase());
+  return truthy(env.SVAMP_NO_ISOLATION) || truthy(env.SVAMP_SKIP_NONO);
+}
 async function detectIsolationCapabilities() {
+  if (isolationDisabledByEnv()) {
+    console.log(
+      "[isolation] Disabled via env (SVAMP_ISOLATION=none) \u2014 skipping nono auto-install + runtime detection. Sessions run WITHOUT per-session sandboxing; session sharing is allowed (rely on the container/host boundary)."
+    );
+    const notFound = () => ({ found: false });
+    return {
+      available: [],
+      preferred: null,
+      disabled: true,
+      details: {
+        nono: notFound(),
+        docker: notFound(),
+        podman: notFound(),
+        srt: notFound(),
+        bwrap: notFound()
+      }
+    };
+  }
   const checks = {
     nono: checkCommand("nono", ["--version"]),
     docker: checkCommand("docker", ["--version"]),
@@ -12567,6 +12732,7 @@ class ProcessSupervisor {
       throw new Error(`Process '${entry.spec.name}' is already running`);
     }
     entry.stopping = false;
+    this.clearTimers(entry);
     if (entry.spec.desiredStopped) {
       entry.spec.desiredStopped = false;
       await this.persistSpec(entry.spec);
@@ -12625,6 +12791,8 @@ class ProcessSupervisor {
           this.clearTimers(entry);
           await this.killChild(entry.child);
           entry.child = void 0;
+        } else {
+          this.clearTimers(entry);
         }
         if (entry.deleted) return;
         entry.stopping = false;
@@ -12856,6 +13024,7 @@ class ProcessSupervisor {
   spawnProcess(entry) {
     const { spec, state } = entry;
     if (entry.deleted) return;
+    state.consecutiveProbeFailures = 0;
     try {
       const env = { ...process.env, ...spec.env ?? {} };
       const child = spawn(spec.command, spec.args, {
@@ -12960,6 +13129,7 @@ class ProcessSupervisor {
     );
     entry.restartTimer = setTimeout(() => {
       if (entry.deleted || entry.stopping) return;
+      if (entry.child) return;
       state.restartCount++;
       state.status = "starting";
       this.spawnProcess(entry);
@@ -12988,6 +13158,8 @@ class ProcessSupervisor {
     const timeoutMs = (probe.timeout ?? DEFAULT_PROBE_TIMEOUT_S) * 1e3;
     const threshold = probe.failureThreshold ?? DEFAULT_PROBE_FAILURE_THRESHOLD;
     const url = `http://localhost:${probe.port}${urlPath}`;
+    const probedChild = entry.child;
+    const stillSameChild = () => !entry.deleted && !entry.stopping && entry.child === probedChild && entry.state.status === "running";
     try {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -12997,6 +13169,7 @@ class ProcessSupervisor {
       } finally {
         clearTimeout(timer);
       }
+      if (!stillSameChild()) return;
       const ok = resp.ok;
       entry.state.lastProbe = { ok, timestamp: Date.now(), statusCode: resp.status };
       if (ok) {
@@ -13011,6 +13184,7 @@ class ProcessSupervisor {
         }
       }
     } catch (err) {
+      if (!stillSameChild()) return;
       entry.state.lastProbe = { ok: false, timestamp: Date.now(), error: err.message };
       entry.state.consecutiveProbeFailures++;
       console.warn(
@@ -13041,7 +13215,12 @@ class ProcessSupervisor {
       return;
     }
     console.log(`[SUPERVISOR] Process '${entry.spec.name}' TTL: expires in ${remainingS.toFixed(0)}s`);
-    entry.ttlTimer = setTimeout(() => this.expireProcess(entry), remainingS * 1e3);
+    const MAX_DELAY = 2147483647;
+    const delayMs = remainingS * 1e3;
+    entry.ttlTimer = setTimeout(
+      () => delayMs > MAX_DELAY ? this.setupTTL(entry) : this.expireProcess(entry),
+      Math.min(delayMs, MAX_DELAY)
+    );
   }
   expireProcess(entry) {
     if (entry.deleted) return;
@@ -13973,7 +14152,7 @@ function summarizeExtensions(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENS
   const n = grantedExtensionCount(extensions, maxExtensions);
   if (n === 0) return "";
   const turns = extensionTurns(extensions, maxExtensions);
-  const reasons = extensions.slice(0, maxExtensions).map((e) => (e.reason || "").trim()).filter(Boolean).join("; ").slice(0, 300);
+  const reasons = extensions.slice(0, maxExtensions).map((e) => (e?.reason || "").trim()).filter(Boolean).join("; ").slice(0, 300);
   return `${n} extension${n === 1 ? "" : "s"} granted (+${turns} turns)${reasons ? `: ${reasons}` : ""}`;
 }
 const DEFAULT_LOOP_STUCK_CHECKPOINTS = 3;
@@ -13981,7 +14160,7 @@ const DEFAULT_LOOP_MAX_AUTORESUMES = Number.POSITIVE_INFINITY;
 const PROGRESS_HISTORY_CAP = 12;
 function resolveStuckLimit(envValue) {
   const n = Number(envValue);
-  if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  if (Number.isFinite(n) && n >= 1) return Math.min(Math.floor(n), PROGRESS_HISTORY_CAP - 1);
   return DEFAULT_LOOP_STUCK_CHECKPOINTS;
 }
 function resolveMaxAutoResumes(envValue) {
@@ -14039,7 +14218,8 @@ function resolveEvaluatorModel(envValue) {
 function parseEvaluatorVerdict(text) {
   if (!text) return null;
   const candidates = [];
-  let depth = 0, start = -1, inStr = false, esc = false;
+  const openStack = [];
+  let inStr = false, esc = false;
   for (let i = 0; i < text.length; i++) {
     const c = text[i];
     if (inStr) {
@@ -14055,15 +14235,11 @@ function parseEvaluatorVerdict(text) {
     if (c === '"') {
       inStr = true;
     } else if (c === "{") {
-      if (depth === 0) start = i;
-      depth++;
+      openStack.push(i);
     } else if (c === "}") {
-      if (depth > 0) {
-        depth--;
-        if (depth === 0 && start >= 0) {
-          candidates.push(text.slice(start, i + 1));
-          start = -1;
-        }
+      const open = openStack.pop();
+      if (open !== void 0) {
+        candidates.push(text.slice(open, i + 1));
       }
     }
   }
@@ -15329,7 +15505,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       const key = s.started_at ?? "\u2205";
       if (key === announcedLoopStart) return;
       announcedLoopStart = key;
-      const iter = typeof s.iteration === "number" ? s.iteration : 0;
+      const iter = s.ledger && typeof s.ledger.turns === "number" && s.ledger.turns > 0 ? s.ledger.turns : typeof s.iteration === "number" ? s.iteration : 0;
       const plural = iter === 1 ? "" : "s";
       const gaveUpCfg = readLoopJson(directory, sessionId, "loop.config.json") || {};
       const curMax = typeof gaveUpCfg.max_iterations === "number" ? gaveUpCfg.max_iterations : iter;
@@ -15957,7 +16133,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-iom4Qnpt.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DYduijxc.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -15975,7 +16151,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-Dzhtizmd.mjs');
+    const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -16003,7 +16179,7 @@ async function startDaemon(options) {
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-CgEtGkX2.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-D8Tbz32G.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -16685,10 +16861,11 @@ ${parts.join("\n")}`);
               logger.log(`[Session ${sessionId}] loop was cancelled during verification \u2014 not re-kicking (#0308)`);
               return;
             }
-            const ledger = ls.ledger;
+            const curLs = readLoopState(directory, sessionId) || ls;
+            const ledger = curLs.ledger ?? ls.ledger;
             const budget = ls.budget;
-            const progress_history = ls.progress_history;
-            const extensions = ls.extensions;
+            const progress_history = curLs.progress_history ?? ls.progress_history;
+            const extensions = curLs.extensions ?? ls.extensions;
             if (result.action === "rekick") {
               const cond = ls.task || "";
               writeGoalLoopState(directory, sessionId, {
@@ -16817,6 +16994,7 @@ ${parts.join("\n")}`);
         let consecutiveOverloadRetries = 0;
         let overloadBailedThisTurn = false;
         let pendingCompactTurn = false;
+        let noIsolationWarned = false;
         const RATELIMIT_CFG = getRateLimitRetryConfig();
         let currentTurnMessage;
         let rateLimitRetryCount = 0;
@@ -16924,6 +17102,14 @@ ${parts.join("\n")}`);
           } else if (shouldIsolateSession()) {
             logger.log(`[Session ${sessionId}] WARNING: No isolation runtime (nono/docker/podman) available. Session is NOT sandboxed.`);
             sessionMetadata = { ...sessionMetadata, isolationMethod: void 0 };
+            if (!isolationCapabilities.disabled && !noIsolationWarned) {
+              noIsolationWarned = true;
+              sessionService.pushMessage({
+                type: "message",
+                level: "warning",
+                message: "This session requested sandboxing (a security context / --isolate) but no isolation runtime (nono, docker, or podman) is available on this machine \u2014 it is running WITHOUT a sandbox. Install a runtime, or set SVAMP_ISOLATION=none to run unsandboxed intentionally (e.g. when the machine is already a container)."
+              }, "event");
+            }
           } else {
             sessionMetadata = { ...sessionMetadata, isolationMethod: void 0 };
           }
@@ -16972,6 +17158,22 @@ ${parts.join("\n")}`);
             spawnEnv.SVAMP_SANDBOXED = "1";
             logger.log(`[Session ${sessionId}] Credential staging: HOME=${stagedCredentials.homePath}, SVAMP_SANDBOXED=1`);
           }
+          if (!agentLauncherExists("claude")) {
+            const others = detectAvailableAgents().filter((a) => a !== "claude");
+            const hint = others.length ? ` This machine has: ${others.join(", ")} \u2014 start a ${others[0]} session instead.` : " No agent launchers were found on this machine.";
+            logger.log(`[Session ${sessionId}] Claude launcher ('claude') not found on PATH \u2014 aborting spawn (available: ${detectAvailableAgents().join(", ") || "none"})`);
+            sessionService.pushMessage({
+              type: "message",
+              level: "error",
+              message: `Claude Code (\`claude\`) isn't installed on this machine (${os$1.hostname()}), so this Claude session can't run.${hint}`
+            }, "event");
+            sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+            sessionService.updateMetadata(sessionMetadata);
+            sessionWasProcessing = false;
+            signalProcessing(false);
+            sessionService.sendSessionEnd();
+            return void 0;
+          }
           const child = spawn(spawnCommand, spawnArgs, {
             cwd: directory,
             stdio: ["pipe", "pipe", "pipe"],
@@ -16988,7 +17190,7 @@ ${parts.join("\n")}`);
           child.on("error", (err) => {
             logger.log(`[Session ${sessionId}] Claude process error: ${err.message}`);
             sessionService.pushMessage(
-              { type: "message", message: `Agent process exited unexpectedly: ${err.message}. Please ensure Claude Code CLI is installed.` },
+              { type: "message", level: "error", message: `Agent process failed to start: ${err.message}. Please ensure the Claude Code CLI is installed on this machine.` },
               "event"
             );
             sessionWasProcessing = false;
@@ -18165,18 +18367,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-CIs3wZAu.mjs');
+              const { issueRpc } = await import('./rpc-HiJYPcOU.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BMoQLUTg.mjs');
+              const { workflowRpc } = await import('./rpc-CBa5WaBD.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
-              const { exec: exec2 } = await import('child_process');
+              const { execFile } = await import('child_process');
               const rgCwd = cwd || directory;
+              const argv = Array.isArray(args) ? args : String(args).split(/\s+/).filter(Boolean);
               return new Promise((resolve2, reject) => {
-                exec2(`rg ${args}`, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+                execFile("rg", argv, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
                   if (err && !stdout) {
                     reject(new Error(err.message));
                   } else {
@@ -18780,18 +18983,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-CIs3wZAu.mjs');
+              const { issueRpc } = await import('./rpc-HiJYPcOU.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BMoQLUTg.mjs');
+              const { workflowRpc } = await import('./rpc-CBa5WaBD.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
-              const { exec: exec2 } = await import('child_process');
+              const { execFile } = await import('child_process');
               const rgCwd = cwd || directory;
+              const argv = Array.isArray(args) ? args : String(args).split(/\s+/).filter(Boolean);
               return new Promise((resolve2, reject) => {
-                exec2(`rg ${args}`, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+                execFile("rg", argv, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
                   if (err && !stdout) {
                     reject(new Error(err.message));
                   } else {
@@ -19676,7 +19880,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-CgEtGkX2.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-D8Tbz32G.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -19873,7 +20077,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-uZ__o3N7.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-D1JpZ5m8.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();