svamp-cli 0.2.275 → 0.2.276

package/dist/{run-C3Fcbk-H.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';
@@ -1506,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;
@@ -1710,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');
@@ -2210,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) {
@@ -2249,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`);
     }
@@ -2269,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();
     }
   }
@@ -2708,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);
             });
@@ -2955,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-D3faR6iR.mjs');
+      const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -4350,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
@@ -4360,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() {
@@ -4388,6 +4416,7 @@ class ChannelOutbox {
     this.byChannel.clear();
     this.seqByChannel.clear();
     this._load();
+    this._loadHighWater();
     return true;
   }
   _load() {
@@ -4410,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 {
@@ -4437,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);
@@ -4448,8 +4502,10 @@ class ChannelOutbox {
   /** Append a reply addressed to `to`. Assigns seq + ts, persists, and wakes waiters. */
   append(channelId, r) {
     this.reload();
-    const seq = (this.seqByChannel.get(channelId) || 0) + 1;
+    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);
@@ -5760,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-D3faR6iR.mjs');
+        const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -5908,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.
@@ -6234,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-CYqmMG_m.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);
         }
@@ -6333,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-D7fIWAgz.mjs');
+    const { queryCore } = await import('./commands-DINv6746.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -7142,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
@@ -7525,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,
@@ -8771,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;
@@ -12135,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"]),
@@ -12625,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);
@@ -12683,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;
@@ -12914,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, {
@@ -13018,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);
@@ -13046,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);
@@ -13055,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) {
@@ -13069,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(
@@ -13099,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;
@@ -14031,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;
@@ -14039,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) {
@@ -14097,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) {
@@ -14113,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));
       }
     }
   }
@@ -15387,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;
@@ -16015,7 +16133,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DGT-1wjo.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DYduijxc.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -16033,7 +16151,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-D3faR6iR.mjs');
+    const { FrpcTunnel } = await import('./frpc-BkGcc69x.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -16061,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}`);
@@ -16743,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, {
@@ -16875,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;
@@ -16982,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 };
           }
@@ -17030,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"],
@@ -17046,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;
@@ -18223,18 +18367,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-BQ8zLSUc.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-xlV-4-BG.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 {
@@ -18838,18 +18983,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-BQ8zLSUc.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-xlV-4-BG.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 {
@@ -19734,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 {
       }
@@ -19931,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-DaFZY2ob.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-D1JpZ5m8.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();

package/dist/{scheduler-DaFZY2ob.mjs → scheduler-D1JpZ5m8.mjs}

@@ -1,4 +1,4 @@
-import { j as resolveProjectRoot, D as listWorkflows, E as isWorkflowEnabled, F as workflowCrons, y as runWorkflow, G as cronMatches } from './run-C3Fcbk-H.mjs';
+import { j as resolveProjectRoot, D as listWorkflows, E as isWorkflowEnabled, F as workflowCrons, y as runWorkflow, G as cronMatches } from './run-DjThStDG.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{serveCommands-B9Yhx1fl.mjs → serveCommands-D-3LtTUy.mjs}

@@ -54,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-D7fIWAgz.mjs');
+  const { connectAndGetMachine } = await import('./commands-DINv6746.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -93,7 +93,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-D7fIWAgz.mjs');
+  const { connectAndGetMachine } = await import('./commands-DINv6746.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -182,7 +182,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-D7fIWAgz.mjs');
+  const { connectAndGetMachine } = await import('./commands-DINv6746.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -202,7 +202,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-D7fIWAgz.mjs');
+  const { connectAndGetMachine } = await import('./commands-DINv6746.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -235,7 +235,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-D7fIWAgz.mjs');
+  const { connectAndGetMachine } = await import('./commands-DINv6746.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{sideband-CYqmMG_m.mjs → sideband-DdcXgJHf.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, J as loadMachineContext, K as buildMachineInstructions, L as machineToolsForRole, M as buildMachineTools } from './run-C3Fcbk-H.mjs';
+import { R as READ_ONLY_TOOLS, J as loadMachineContext, K as buildMachineInstructions, L as machineToolsForRole, M as buildMachineTools } from './run-DjThStDG.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';