svamp-cli 0.2.251 → 0.2.253

package/dist/{run-CRe59VaY.mjs → run-hYUl-Fln.mjs}

@@ -1869,20 +1869,7 @@ class ChannelOutbox {
     this.byChannel.delete(channelId);
     this.seqByChannel.delete(channelId);
     if (!existsSync(this.file)) return;
-    try {
-      const kept = readFileSync(this.file, "utf8").split("\n").filter((l) => {
-        if (!l.trim()) return false;
-        try {
-          return JSON.parse(l).channelId !== channelId;
-        } catch {
-          return false;
-        }
-      });
-      const tmp = this.file + ".tmp";
-      writeFileSync(tmp, kept.join("\n") + (kept.length ? "\n" : ""));
-      renameSync(tmp, this.file);
-    } catch {
-    }
+    this._compact();
   }
 }
 
@@ -2998,7 +2985,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-DshAO_N4.mjs');
+        const { FrpcTunnel } = await import('./frpc-CLQB-GM1.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3223,6 +3210,11 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         };
         let wired = false;
         if (sid) {
+          try {
+            await authorizeSessionAccess(sid, "admin", context);
+          } catch {
+            return { success: false, error: `Not authorized: launching a meeting agent for session ${sid} requires admin access to that session.` };
+          }
           const sessionRpc = handlers.getSessionRPCHandlers?.(sid);
           if (sessionRpc?.saveChannel) {
             try {
@@ -3304,10 +3296,12 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       },
       // Drives the title-bar "WISE in a meeting" indicator (poll per session).
       wiseMeetingStatus: async (params, context) => {
-        if (!roleAtLeast(getEffectiveRole(context, currentMetadata.sharing), "view")) {
-          return { active: false, error: "Not authorized to view meeting status on this machine." };
-        }
         if (params?.sessionId) {
+          try {
+            await authorizeSessionAccess(params.sessionId, "view", context);
+          } catch {
+            return { active: false, error: `Not authorized to view meeting status for session ${params.sessionId}.` };
+          }
           const rec = activeMeetingAgents.get(params.sessionId);
           let transcript = [];
           try {
@@ -3317,6 +3311,9 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           }
           return { active: !!rec, meeting: rec || null, transcript };
         }
+        if (!roleAtLeast(getEffectiveRole(context, currentMetadata.sharing), "view")) {
+          return { active: false, error: "Not authorized to view meeting status on this machine." };
+        }
         return { active: activeMeetingAgents.size > 0, meetings: Array.from(activeMeetingAgents.values()) };
       },
       // GAP 3 — post a chat message into the live meeting. The deep coding agent
@@ -3455,7 +3452,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-CiE3Nqih.mjs');
+          const { toolsForRole } = await import('./sideband-C0qzprWp.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3554,7 +3551,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-hPm8AYNG.mjs');
+    const { queryCore } = await import('./commands-YPQSZ4Qx.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3816,14 +3813,19 @@ function registerAwaitingReply(sessionId, threadId, now = Date.now()) {
   }
   writeAwaiting(sessionId, map);
 }
-function takeAwaitingReply(sessionId, threadId, now = Date.now()) {
+function peekAwaitingReply(sessionId, threadId, now = Date.now()) {
   if (!sessionId || !threadId) return false;
   const map = readAwaiting(sessionId);
   const at = map[threadId];
   if (typeof at !== "number") return false;
+  return now - at <= AWAIT_TTL_MS;
+}
+function consumeAwaitingReply(sessionId, threadId) {
+  if (!sessionId || !threadId) return;
+  const map = readAwaiting(sessionId);
+  if (!(threadId in map)) return;
   delete map[threadId];
   writeAwaiting(sessionId, map);
-  return now - at <= AWAIT_TTL_MS;
 }
 function computeOutboundHop(sessionId) {
   if (!sessionId) return { hopCount: 0, fromInboxTurn: false };
@@ -4180,6 +4182,26 @@ function isStructuredMessage(msg) {
 function escapeXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
+function sanitizeInboundInboxMessage(message, opts) {
+  if (opts.trusted) return message;
+  const email = opts.callerEmail;
+  return {
+    ...message,
+    // Attribute to the SERVER-KNOWN identity, never the caller's self-asserted `from`.
+    // An authenticated collaborator is an honest verified human (`user:<email>` → may
+    // wake, attributed to THEM not the owner); an anonymous caller cannot claim human.
+    from: email ? `user:${email}` : "agent:anonymous",
+    verified: !!email,
+    // Strip self-asserted channel provenance + async-reply routing a direct caller
+    // has no business setting (legit channel ingress goes via the trusted channel path).
+    channel: void 0,
+    channelId: void 0,
+    correlationId: void 0,
+    // Escape the body so a nested </svamp-message> can't break out and forge a second
+    // attributed envelope in the agent's transcript.
+    body: xmlEscape(String(message.body ?? "").slice(0, 16 * 1024))
+  };
+}
 function formatInboxMessageXml(msg) {
   if (!isStructuredMessage(msg)) return msg.body;
   const attrs = [`message-id="${escapeXml(msg.messageId)}"`];
@@ -5308,12 +5330,14 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     // ── Inbox ──
     sendInboxMessage: async (message, context) => {
       authorizeRequest(context, metadata.sharing, "interact");
-      inbox.push(message);
+      const trusted = getEffectiveRole(context, metadata.sharing) === "admin";
+      const msg = sanitizeInboundInboxMessage(message, { trusted, callerEmail: context?.user?.email });
+      inbox.push(msg);
       while (inbox.length > INBOX_MAX) inbox.shift();
       syncInboxToMetadata();
-      callbacks.onInboxMessage?.(message);
-      notifyListeners({ type: "inbox-update", sessionId, message });
-      return { success: true, messageId: message.messageId };
+      callbacks.onInboxMessage?.(msg);
+      notifyListeners({ type: "inbox-update", sessionId, message: msg });
+      return { success: true, messageId: msg.messageId };
     },
     getInbox: async (opts, context) => {
       authorizeRequest(context, metadata.sharing, "view");
@@ -6282,12 +6306,10 @@ async function registerDebugService(server, machineId, deps) {
       // require_context: true → Hypha injects the caller context as the last arg of every
       // method, which the authorize() gate below enforces. 'unlisted' only hides discovery.
       config: { visibility: "unlisted", require_context: true },
-      healthCheck: async () => ({
-        ok: true,
-        machineId,
-        uptime: process.uptime(),
-        timestamp: Date.now()
-      }),
+      healthCheck: async (context) => {
+        authorize(context, "view");
+        return { ok: true, machineId, uptime: process.uptime(), timestamp: Date.now() };
+      },
       getSessionStates: async (context) => {
         authorize(context, "view");
         const sessions = deps.getTrackedSessions();
@@ -10130,6 +10152,18 @@ var api = /*#__PURE__*/Object.freeze({
     searchSkills: searchSkills
 });
 
+function signalProcessTree(child, signal) {
+  const pid = child.pid;
+  if (pid === void 0) return;
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
 const DEFAULT_PROBE_INTERVAL_S = 10;
 const DEFAULT_PROBE_TIMEOUT_S = 5;
 const DEFAULT_PROBE_FAILURE_THRESHOLD = 3;
@@ -10153,7 +10187,7 @@ class ProcessSupervisor {
   /** Stop all managed processes (called on daemon shutdown). */
   async stopAll() {
     const ids = Array.from(this.entries.keys());
-    await Promise.all(ids.map((id) => this.stop(id).catch(() => {
+    await Promise.all(ids.map((id) => this.stop(id, { markDesiredStopped: false }).catch(() => {
     })));
   }
   // ── Public API ────────────────────────────────────────────────────────────
@@ -10191,11 +10225,20 @@ class ProcessSupervisor {
       throw new Error(`Process '${entry.spec.name}' is already running`);
     }
     entry.stopping = false;
+    if (entry.spec.desiredStopped) {
+      entry.spec.desiredStopped = false;
+      await this.persistSpec(entry.spec);
+    }
     this.resetFailureTracking(entry);
     await this.startEntry(entry, false);
   }
-  /** Stop a running process. Does NOT remove it from supervision. */
-  async stop(idOrName) {
+  /**
+   * Stop a running process. Does NOT remove it from supervision.
+   * @param opts.markDesiredStopped When true (default — an EXPLICIT user `stop`), persist
+   *   a desired-stopped intent so a daemon restart does not resurrect it. `stopAll` (a daemon
+   *   shutdown, not a user action) passes false so keepAlive processes auto-restore (#nightly).
+   */
+  async stop(idOrName, opts) {
     const entry = this.require(idOrName);
     entry.stopping = true;
     this.clearTimers(entry);
@@ -10206,6 +10249,10 @@ class ProcessSupervisor {
     entry.state.status = "stopped";
     entry.state.stoppedAt = Date.now();
     entry.state.pid = void 0;
+    if (opts?.markDesiredStopped !== false && !entry.deleted && !entry.spec.desiredStopped) {
+      entry.spec.desiredStopped = true;
+      await this.persistSpec(entry.spec);
+    }
   }
   /** Restart a process (stop if running, then start again). */
   async restart(idOrName) {
@@ -10223,6 +10270,10 @@ class ProcessSupervisor {
       if (entry.deleted) return;
       entry.stopping = false;
       this.resetFailureTracking(entry);
+      if (entry.spec.desiredStopped) {
+        entry.spec.desiredStopped = false;
+        await this.persistSpec(entry.spec);
+      }
       entry.state.restartCount++;
       await this.startEntry(entry, false);
     } finally {
@@ -10357,12 +10408,17 @@ class ProcessSupervisor {
         const spec = JSON.parse(raw);
         const entry = this.makeEntry(spec);
         this.entries.set(spec.id, entry);
-        if (spec.keepAlive) {
+        if (spec.keepAlive && !spec.desiredStopped) {
           await this.startEntry(
             entry,
             true
             /* onRestore */
           );
+        } else if (spec.keepAlive && spec.desiredStopped) {
+          entry.state.status = "stopped";
+          if (spec.ttl !== void 0 && spec.ttl > 0) this.setupTTL(entry);
+        } else if (spec.ttl !== void 0 && spec.ttl > 0) {
+          this.setupTTL(entry);
         }
         loaded++;
       } catch (err) {
@@ -10439,7 +10495,13 @@ class ProcessSupervisor {
       const child = spawn$1(spec.command, spec.args, {
         cwd: spec.workdir,
         env,
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", "pipe", "pipe"],
+        // #0316: run each supervised process in its OWN process group (setsid) so a
+        // shell-wrapping spec (`bash -c …`, `npm start`) can be torn down with the whole
+        // tree — otherwise stop/restart/TTL only kills the direct PID and leaks
+        // grandchildren. Kills below signal the group (negative PID). POSIX only; on
+        // Windows `detached` just decouples the console and the group-kill falls back.
+        detached: process.platform !== "win32"
       });
       entry.child = child;
       state.status = "running";
@@ -10489,7 +10551,6 @@ class ProcessSupervisor {
     const uptime = state.startedAt ? Date.now() - state.startedAt : 0;
     const now = Date.now();
     if (uptime > BACKOFF_RESET_WINDOW_MS) {
-      state.restartCount = 0;
       state.consecutiveFailures = 0;
       entry.failureWindowStart = void 0;
     } else {
@@ -10602,10 +10663,7 @@ class ProcessSupervisor {
     console.warn(`[SUPERVISOR] Probe failed for '${entry.spec.name}' \u2014 killing to trigger restart`);
     entry.state.consecutiveProbeFailures = 0;
     if (entry.child) {
-      try {
-        entry.child.kill("SIGTERM");
-      } catch {
-      }
+      signalProcessTree(entry.child, "SIGTERM");
     }
   }
   // ── TTL ───────────────────────────────────────────────────────────────────
@@ -10650,15 +10708,9 @@ class ProcessSupervisor {
       };
       child.once("exit", done);
       child.once("close", done);
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
+      signalProcessTree(child, "SIGTERM");
       forceKillTimer = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
+        signalProcessTree(child, "SIGKILL");
         hardDeadlineTimer = setTimeout(() => {
           if (!resolved) {
             resolved = true;
@@ -11361,6 +11413,9 @@ function fireIdleWorkflows(root, sessionId, deps = {}) {
 }
 
 const UNBOUNDED_LOOP_ITERATIONS = 1e6;
+function loopCancelledDuringVerify(current) {
+  return !!current && (current.phase === "cancelled" || current.active === false);
+}
 function backlogOraclePending(projectRoot, sessionId) {
   const inScope = (i) => !sessionId || isVisibleTo(i, sessionId);
   return listIssues(projectRoot).filter(inScope).filter((i) => i.status === "ready" || i.status === "in_progress").map((i) => ({ id: i.id }));
@@ -11488,7 +11543,7 @@ function computeSoftTurnCap(hardMax, cadence) {
   return Math.ceil(hardMax / chunks);
 }
 const DEFAULT_LOOP_STUCK_CHECKPOINTS = 3;
-const DEFAULT_LOOP_MAX_AUTORESUMES = 3;
+const DEFAULT_LOOP_MAX_AUTORESUMES = Number.POSITIVE_INFINITY;
 const PROGRESS_HISTORY_CAP = 12;
 function resolveStuckLimit(envValue) {
   const n = Number(envValue);
@@ -11533,7 +11588,8 @@ function decideLoopContinuation(input) {
     return { action: "continue", kind: "progress", consumeAutoResume: false, reason: `still making progress (${stuckCheckpoints}/${stuckLimit} stuck checkpoints)` };
   }
   if (autoResumes < maxAutoResumes) {
-    return { action: "continue", kind: "autoresume", consumeAutoResume: true, reason: `no progress across ${stuckCheckpoints} checkpoints \u2014 auto-resume ${autoResumes + 1}/${maxAutoResumes}` };
+    const label = Number.isFinite(maxAutoResumes) ? `auto-resume ${autoResumes + 1}/${maxAutoResumes}` : `auto-resume ${autoResumes + 1} (unbounded \u2014 bounded only by the cost/iteration ceiling)`;
+    return { action: "continue", kind: "autoresume", consumeAutoResume: true, reason: `no progress across ${stuckCheckpoints} checkpoints \u2014 ${label}` };
   }
   const tail = `no progress across ${stuckCheckpoints} checkpoints; ${maxAutoResumes} auto-resume(s) exhausted`;
   return { action: "stop", kind: "stuck", reason: input.stuckReason ? `${input.stuckReason} \u2014 ${tail}` : tail };
@@ -12505,17 +12561,30 @@ function classifyOptsForMessage(sessionId, message, ownerEmail) {
   const fromVal = message.from || "";
   const senderEmail = message.verified && fromVal.includes("@") ? fromVal.replace(/^user:/, "").toLowerCase() : void 0;
   const self = !!(ownerEmail && senderEmail && senderEmail === String(ownerEmail).toLowerCase());
-  const openThreadReply = takeAwaitingReply(sessionId, message.threadId);
+  const openThreadReply = peekAwaitingReply(sessionId, message.threadId);
   return { self, openThreadReply };
 }
+function classifyInboundForSession(sessionId, message, ownerEmail) {
+  const opts = classifyOptsForMessage(sessionId, message, ownerEmail);
+  const decision = classifyInbound(message, Date.now(), opts);
+  if (opts.openThreadReply && decision.action === "wake") {
+    consumeAwaitingReply(sessionId, message.threadId);
+  }
+  return decision;
+}
 function writeGoalLoopState(directory, sessionId, state) {
   try {
     const dir = getLoopDir(directory, sessionId);
     mkdirSync$1(dir, { recursive: true });
-    writeFileSync$1(join$1(dir, "loop-state.json"), JSON.stringify({ session_id: sessionId, engine: "goal", ...state }, null, 2));
+    atomicWriteLoopState(join$1(dir, "loop-state.json"), { session_id: sessionId, engine: "goal", ...state });
   } catch {
   }
 }
+function atomicWriteLoopState(path, obj) {
+  const tmp = path + ".tmp";
+  writeFileSync$1(tmp, JSON.stringify(obj, null, 2));
+  renameSync$1(tmp, path);
+}
 function safeBacklogPendingCount(projectRoot, sessionId) {
   try {
     return backlogOraclePending(projectRoot, sessionId).length;
@@ -12881,7 +12950,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
           if (wasStopped) {
             try {
               const sp = join$1(getLoopDir(directory, sessionId), "loop-state.json");
-              writeFileSync$1(sp, JSON.stringify({
+              atomicWriteLoopState(sp, {
                 ...existing,
                 active: true,
                 phase: "continue",
@@ -12893,7 +12962,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
                 gave_up_reason: void 0,
                 stall_hinted: false,
                 resumed_at: Date.now()
-              }, null, 2));
+              });
             } catch {
             }
             const eq = getMetadata().messageQueue || [];
@@ -13380,7 +13449,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-Bcqo8iMs.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DYoNzX4K.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13398,7 +13467,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DshAO_N4.mjs');
+    const { FrpcTunnel } = await import('./frpc-CLQB-GM1.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13418,14 +13487,14 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-CL0QrW7Z.mjs');
+  const { ServeManager } = await import('./serveManager-BK5OjhXU.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-ivV7xAp3.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-DuLXaoGP.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -14096,6 +14165,10 @@ ${parts.join("\n")}`);
                 log: (m) => logger.log(`[Session ${sessionId}] ${m}`)
               }
             );
+            if (loopCancelledDuringVerify(readLoopState(directory, sessionId))) {
+              logger.log(`[Session ${sessionId}] loop was cancelled during verification \u2014 not re-kicking (#0308)`);
+              return;
+            }
             const ledger = ls.ledger;
             const budget = ls.budget;
             const progress_history = ls.progress_history;
@@ -14144,7 +14217,9 @@ ${parts.join("\n")}`);
                   max_iterations: ls.max_iterations,
                   budget,
                   started_at: startedAt,
-                  holds,
+                  // #0319: a PROGRESSING loop resets its hold counter so the evaluator-guided re-kick
+                  // mechanism re-engages fresh (it's making headway, not stuck); an auto-resume keeps it.
+                  holds: decision.kind === "progress" ? 0 : holds,
                   ledger,
                   progress_history,
                   auto_resumes: nextAuto
@@ -15410,7 +15485,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             },
             onInboxMessage: (message) => {
               if (trackedSession?.stopped) return;
-              const decision = classifyInbound(message, Date.now(), classifyOptsForMessage(sessionId, message, sessionMetadata?.sharing?.owner));
+              const decision = classifyInboundForSession(sessionId, message, sessionMetadata?.sharing?.owner);
               logger.log(`[Session ${sessionId}] Inbox message (urgency: ${message.urgency || "normal"}, hop: ${message.hopCount ?? 0}, from: ${message.from || "unknown"}) \u2192 ${decision.action} (${decision.reason})`);
               if (decision.breakerTripped) {
                 logger.error(`[Session ${sessionId}] Inbox circuit breaker TRIPPED \u2014 cross-agent wake rate too high; auto-waking paused.`);
@@ -15506,11 +15581,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-B2BhUPgt.mjs');
+              const { issueRpc } = await import('./rpc-0HSLhpCb.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CtfcD14b.mjs');
+              const { workflowRpc } = await import('./rpc-BB-AxQa_.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15692,7 +15767,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           if (s.active === false || s.phase === "done") {
             try {
               const lp = join$1(getLoopDir(directory, sessionId), "loop-state.json");
-              writeFileSync$1(lp, JSON.stringify({
+              atomicWriteLoopState(lp, {
                 ...s,
                 active: true,
                 phase: "continue",
@@ -15702,7 +15777,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 stall_hinted: false,
                 resumed_at: Date.now()
                 // #0156: re-arm the stall hint
-              }, null, 2));
+              });
             } catch {
             }
           }
@@ -15919,7 +15994,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             },
             onInboxMessage: (message) => {
               if (acpStopped) return;
-              const decision = classifyInbound(message, Date.now(), classifyOptsForMessage(sessionId, message, sessionMetadata?.sharing?.owner));
+              const decision = classifyInboundForSession(sessionId, message, sessionMetadata?.sharing?.owner);
               logger.log(`[${agentName} Session ${sessionId}] Inbox message (urgency: ${message.urgency || "normal"}, hop: ${message.hopCount ?? 0}, from: ${message.from || "unknown"}) \u2192 ${decision.action} (${decision.reason})`);
               if (decision.breakerTripped) {
                 logger.error(`[${agentName} Session ${sessionId}] Inbox circuit breaker TRIPPED \u2014 auto-waking paused.`);
@@ -16046,11 +16121,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-B2BhUPgt.mjs');
+              const { issueRpc } = await import('./rpc-0HSLhpCb.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CtfcD14b.mjs');
+              const { workflowRpc } = await import('./rpc-BB-AxQa_.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16812,7 +16887,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-ivV7xAp3.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-DuLXaoGP.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -17009,7 +17084,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-CW_l0_B6.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-DaFydJPf.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();

package/dist/{scheduler-CW_l0_B6.mjs → scheduler-DaFydJPf.mjs}

@@ -1,4 +1,4 @@
-import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-CRe59VaY.mjs';
+import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-hYUl-Fln.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{serveCommands-JgPmRokC.mjs → serveCommands-BgtRllaY.mjs}

@@ -54,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-hPm8AYNG.mjs');
+  const { connectAndGetMachine } = await import('./commands-YPQSZ4Qx.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-hPm8AYNG.mjs');
+  const { connectAndGetMachine } = await import('./commands-YPQSZ4Qx.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-hPm8AYNG.mjs');
+  const { connectAndGetMachine } = await import('./commands-YPQSZ4Qx.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-hPm8AYNG.mjs');
+  const { connectAndGetMachine } = await import('./commands-YPQSZ4Qx.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-hPm8AYNG.mjs');
+  const { connectAndGetMachine } = await import('./commands-YPQSZ4Qx.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{serveManager-CL0QrW7Z.mjs → serveManager-BK5OjhXU.mjs}

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
 import * as path from 'path';
-import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-CRe59VaY.mjs';
+import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-hYUl-Fln.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
@@ -751,7 +751,7 @@ class ServeManager {
     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-DshAO_N4.mjs');
+      const { FrpcTunnel } = await import('./frpc-CLQB-GM1.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,

package/dist/{sideband-CiE3Nqih.mjs → sideband-C0qzprWp.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-CRe59VaY.mjs';
+import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-hYUl-Fln.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.251",
+  "version": "0.2.253",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",