svamp-cli 0.2.252 → 0.2.254

package/dist/{run-BNxaekWa.mjs → run-BqqMOMZN.mjs}

@@ -2985,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-DoUUUoZn.mjs');
+        const { FrpcTunnel } = await import('./frpc-BBkDE65f.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3452,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-D6vgqNiq.mjs');
+          const { toolsForRole } = await import('./sideband-c7SyYkOC.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3551,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-BkroIJOC.mjs');
+    const { queryCore } = await import('./commands-Bz3xxhDd.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3813,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 };
@@ -4177,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)}"`];
@@ -5305,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");
@@ -6279,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();
@@ -10127,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;
@@ -10458,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";
@@ -10620,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 ───────────────────────────────────────────────────────────────────
@@ -10668,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;
@@ -11379,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 }));
@@ -11505,8 +11542,55 @@ function computeSoftTurnCap(hardMax, cadence) {
   const chunks = Math.ceil(hardMax / c);
   return Math.ceil(hardMax / chunks);
 }
+const DEFAULT_LOOP_MAX_EXTENSIONS = 3;
+const DEFAULT_LOOP_EXTENSION_TURNS = 25;
+function resolveMaxExtensions(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  return DEFAULT_LOOP_MAX_EXTENSIONS;
+}
+function resolveExtensionTurns(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  return DEFAULT_LOOP_EXTENSION_TURNS;
+}
+function grantedExtensionCount(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (!Array.isArray(extensions)) return 0;
+  const cap = Number.isFinite(maxExtensions) && maxExtensions >= 0 ? Math.floor(maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  return Math.min(extensions.filter((e) => e && typeof e === "object").length, cap);
+}
+function extensionTurns(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (!Array.isArray(extensions)) return 0;
+  const cap = Number.isFinite(maxExtensions) && maxExtensions >= 0 ? Math.floor(maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  return extensions.slice(0, cap).reduce((s, e) => {
+    const g = e && Number.isFinite(e.grantedTurns) && e.grantedTurns > 0 ? Math.floor(e.grantedTurns) : 0;
+    return s + g;
+  }, 0);
+}
+function effectiveSoftCap(baseMax, extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (typeof baseMax !== "number" || !Number.isFinite(baseMax) || baseMax <= 0 || baseMax >= UNBOUNDED_LOOP_ITERATIONS) return baseMax;
+  return baseMax + extensionTurns(extensions, maxExtensions);
+}
+function grantLoopExtension(prior, o) {
+  const max = Number.isFinite(o.maxExtensions) && o.maxExtensions >= 0 ? Math.floor(o.maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  const base = Array.isArray(prior) ? prior.filter((e) => e && typeof e === "object") : [];
+  if (base.length >= max) return { granted: false, used: base.length, max };
+  const extension = {
+    reason: (o.reason || "").trim().slice(0, 500) || "(no reason given)",
+    ts: o.ts,
+    grantedTurns: Number.isFinite(o.grantedTurns) && o.grantedTurns > 0 ? Math.floor(o.grantedTurns) : DEFAULT_LOOP_EXTENSION_TURNS
+  };
+  return { granted: true, extension, extensions: [...base, extension], used: base.length + 1, max };
+}
+function summarizeExtensions(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  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);
+  return `${n} extension${n === 1 ? "" : "s"} granted (+${turns} turns)${reasons ? `: ${reasons}` : ""}`;
+}
 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);
@@ -11551,7 +11635,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 };
@@ -12523,9 +12608,17 @@ 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);
@@ -12870,8 +12963,45 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       }
       const task = cfg && typeof cfg.task === "string" && cfg.task.trim() ? cfg.task.trim() : void 0;
       const until = cfg && typeof cfg.until === "string" && cfg.until.trim() ? cfg.until.trim() : cfg && typeof cfg.criteria === "string" && cfg.criteria.trim() ? cfg.criteria.trim() : void 0;
-      const onlyLimit = cfg && typeof cfg === "object" && !task && !until && (typeof cfg.max_iterations === "number" || typeof cfg.max_rounds === "number" || cfg.budget);
-      if (onlyLimit) {
+      const extendReq = cfg && typeof cfg === "object" && cfg.extend && typeof cfg.extend === "object" ? cfg.extend : null;
+      const onlyLimit = cfg && typeof cfg === "object" && !task && !until && !extendReq && (typeof cfg.max_iterations === "number" || typeof cfg.max_rounds === "number" || cfg.budget);
+      if (extendReq) {
+        const existing = readLoopState(directory, sessionId);
+        if (!existing) {
+          sessionService.pushMessage({ type: "message", message: 'No loop to extend \u2014 start one with: svamp session loop <id> "<task>" --until "<criteria>" --max N', level: "warning" }, "event");
+        } else {
+          const maxExtensions = resolveMaxExtensions(process.env.SVAMP_LOOP_MAX_EXTENSIONS);
+          const grantTurns = typeof extendReq.grantedTurns === "number" && extendReq.grantedTurns > 0 ? Math.floor(extendReq.grantedTurns) : resolveExtensionTurns(process.env.SVAMP_LOOP_EXTENSION_TURNS);
+          const grant = grantLoopExtension(existing.extensions, {
+            reason: typeof extendReq.reason === "string" ? extendReq.reason : "",
+            ts: Date.now(),
+            grantedTurns: grantTurns,
+            maxExtensions
+          });
+          if (!grant.granted) {
+            sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Extension refused \u2014 this loop already used all ${grant.max} allowed extension${grant.max === 1 ? "" : "s"} (${grant.used}/${grant.max}). A hard cap is a hard cap; do the remaining work or raise the limit manually: svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
+            logger.log(`[svampConfig] loop-extend refused (bounded ${grant.used}/${grant.max})`);
+          } else {
+            const wasStopped = existing.active === false || existing.phase === "done" || existing.phase === "gave_up" || existing.phase === "cancelled";
+            try {
+              const sp = join$1(getLoopDir(directory, sessionId), "loop-state.json");
+              atomicWriteLoopState(sp, {
+                ...existing,
+                extensions: grant.extensions,
+                ...wasStopped ? { active: true, phase: "continue", iteration: 0, completed_at: void 0, gave_up_reason: void 0, stall_hinted: false, resumed_at: Date.now() } : {}
+              });
+            } catch {
+            }
+            if (wasStopped) {
+              const eq = getMetadata().messageQueue || [];
+              setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID$1(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop (extended)", createdAt: Date.now() }] }));
+              onLoopActivated?.();
+            }
+            sessionService.pushMessage({ type: "message", message: `\u{1F501} Loop extended (+${grant.extension.grantedTurns} turns, ${grant.used}/${grant.max} used)${wasStopped ? " \u2014 resuming" : ""}. Reason: ${grant.extension.reason}`, level: "warning" }, "event");
+            logger.log(`[svampConfig] loop-extend granted (+${grant.extension.grantedTurns}, ${grant.used}/${grant.max}, resumed=${wasStopped}): ${grant.extension.reason}`);
+          }
+        }
+      } else if (onlyLimit) {
         const existing = readLoopState(directory, sessionId);
         if (!existing) {
           sessionService.pushMessage({ type: "message", message: 'No loop to modify \u2014 start one with: svamp session loop <id> "<task>" --until "<criteria>" --max N', level: "warning" }, "event");
@@ -13403,7 +13533,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-BfK_xRcZ.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-Dtd2mICX.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13421,7 +13551,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DoUUUoZn.mjs');
+    const { FrpcTunnel } = await import('./frpc-BBkDE65f.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13441,14 +13571,14 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-DAuIjPuV.mjs');
+  const { ServeManager } = await import('./serveManager-BBRgdCJp.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}`);
@@ -14119,9 +14249,14 @@ ${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;
+            const extensions = ls.extensions;
             if (result.action === "rekick") {
               const cond = ls.task || "";
               writeGoalLoopState(directory, sessionId, {
@@ -14138,7 +14273,8 @@ ${parts.join("\n")}`);
                 holds: holds + 1,
                 ledger,
                 progress_history,
-                auto_resumes: ls.auto_resumes
+                auto_resumes: ls.auto_resumes,
+                extensions
               });
               const guidance = result.guidance.replace(/\s+/g, " ").slice(0, 1200);
               sessionService.pushMessage({ type: "message", message: `\u{1F501} Loop not done \u2014 independent review: ${result.reason}`, level: "warning" }, "event");
@@ -14150,7 +14286,9 @@ ${parts.join("\n")}`);
                 progressHistory: progress_history || [],
                 stuckLimit: resolveStuckLimit(process.env.SVAMP_LOOP_STUCK_CHECKPOINTS),
                 autoResumes: typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0,
-                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES),
+                // #0320: extensions also raise a FINITE auto-resume cap (one extra resume each). With
+                // the unbounded #0319 default this is a no-op (Infinity + n = Infinity).
+                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES) + grantedExtensionCount(ls.extensions, resolveMaxExtensions(process.env.SVAMP_LOOP_MAX_EXTENSIONS)),
                 stuckReason: result.reason
               });
               if (decision.action === "continue") {
@@ -14167,10 +14305,13 @@ ${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
+                  auto_resumes: nextAuto,
+                  extensions
                 });
                 const label = decision.kind === "autoresume" ? "\u{1F501} Auto-resuming stalled loop" : "\u{1F501} Loop still progressing";
                 sessionService.pushMessage({ type: "message", message: `${label} \u2014 ${decision.reason}` }, "event");
@@ -14179,12 +14320,12 @@ ${parts.join("\n")}`);
                 enqueueLoopMessage(push, label);
                 if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
               } else {
-                writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger, progress_history, auto_resumes: ls.auto_resumes });
+                writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
                 logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
                 checkSvampConfig?.();
               }
             } else {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes });
+              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
               checkSvampConfig?.();
             }
           } catch (e) {
@@ -14653,7 +14794,9 @@ ${parts.join("\n")}`);
                         });
                         ls.ledger = ledger;
                         const startedAt = typeof ls.started_at === "number" ? ls.started_at : typeof ls.resumed_at === "number" ? ls.resumed_at : void 0;
-                        const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+                        const maxExt = resolveMaxExtensions(process.env.SVAMP_LOOP_MAX_EXTENSIONS);
+                        const effMaxIters = effectiveSoftCap(ls.max_iterations, ls.extensions, maxExt);
+                        const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: effMaxIters, ...ls.budget || {} }, now, startedAt);
                         const pending = safeBacklogPendingCount(resolveProjectRoot(directory), sessionId);
                         const prog = updateLoopProgress(ls, pending, now);
                         ls.progress_history = prog.progress_history;
@@ -14670,7 +14813,9 @@ ${parts.join("\n")}`);
                             progress_history: prog.progress_history,
                             auto_resumes: prog.auto_resumes
                           });
-                          const detail = iterStop ? `${budgetCheck.reason} (hard iteration ceiling \u2014 will not auto-resume). Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>` : `${budgetCheck.reason} (hard cost ceiling \u2014 will not auto-resume). Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`;
+                          const extNote = summarizeExtensions(ls.extensions, maxExt);
+                          const resumeHint = iterStop ? `Extend with a reason:  svamp session loop-extend ${sessionId} --reason "<why>"  \xB7 or set a new cap:  svamp session loop-resume ${sessionId} --max <N>` : `Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`;
+                          const detail = `${budgetCheck.reason} (hard ${iterStop ? "iteration ceiling" : "cost ceiling"} \u2014 will not auto-resume)${extNote ? ` [${extNote}]` : ""}. ${resumeHint}`;
                           sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${detail}`, level: "warning" }, "event");
                           checkSvampConfig?.();
                         } else if (process.env.SVAMP_LOOP_VERIFY === "0") {
@@ -15433,7 +15578,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.`);
@@ -15460,6 +15605,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 }
                 signalProcessing(true);
                 sessionWasProcessing = true;
+                if (claudeResumeId && !trackedSession?.stopped) {
+                  saveSession({
+                    sessionId,
+                    directory,
+                    claudeResumeId,
+                    permissionMode: currentPermissionMode,
+                    spawnMeta: lastSpawnMeta,
+                    metadata: sessionMetadata,
+                    createdAt: sessionCreatedAt,
+                    machineId,
+                    wasProcessing: true
+                  });
+                }
               } else {
                 logger.log(`[Session ${sessionId}] Queuing inbox message for idle processing`);
                 const existingQueue = sessionMetadata.messageQueue || [];
@@ -15529,11 +15687,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-_rwZwiHD.mjs');
+              const { issueRpc } = await import('./rpc-CMS1F7Qu.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-665-sPRQ.mjs');
+              const { workflowRpc } = await import('./rpc-DTU-aE0V.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15672,6 +15830,19 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   message: { role: "user", content: next.text }
                 });
                 claudeProcess.stdin?.write(stdinMsg + "\n");
+                if (claudeResumeId && !trackedSession?.stopped) {
+                  saveSession({
+                    sessionId,
+                    directory,
+                    claudeResumeId,
+                    permissionMode: currentPermissionMode,
+                    spawnMeta: lastSpawnMeta,
+                    metadata: sessionMetadata,
+                    createdAt: sessionCreatedAt,
+                    machineId,
+                    wasProcessing: true
+                  });
+                }
               }
             } catch (err) {
               logger.log(`[Session ${sessionId}] Error in processMessageQueue spawn: ${err.message}`);
@@ -15942,7 +16113,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.`);
@@ -16069,11 +16240,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-_rwZwiHD.mjs');
+              const { issueRpc } = await import('./rpc-CMS1F7Qu.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-665-sPRQ.mjs');
+              const { workflowRpc } = await import('./rpc-DTU-aE0V.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16286,7 +16457,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             return { ok: pending.length === 0, output: pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues." };
           };
           try {
-            const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+            const acpMaxExt = resolveMaxExtensions(process.env.SVAMP_LOOP_MAX_EXTENSIONS);
+            const acpEffMax = effectiveSoftCap(ls.max_iterations, ls.extensions, acpMaxExt);
+            const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: acpEffMax, ...ls.budget || {} }, now, startedAt);
             const acpPending = safeBacklogPendingCount(projectRoot, sessionId);
             const acpProg = updateLoopProgress(ls, acpPending, now);
             ls.progress_history = acpProg.progress_history;
@@ -16294,7 +16467,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             if (budgetCheck.exceeded && isHardBudgetStop(budgetCheck.kind)) {
               const iterStop = !isCostCeiling(budgetCheck.kind);
               writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "gave_up", completed_at: now, gave_up_reason: `resource budget exhausted \u2014 ${budgetCheck.reason}`, ledger });
-              sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${budgetCheck.reason} (hard ${iterStop ? "iteration ceiling" : "cost ceiling"} \u2014 will not auto-resume). Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
+              const acpExtNote = summarizeExtensions(ls.extensions, acpMaxExt);
+              const acpResumeHint = iterStop ? `Extend with a reason:  svamp session loop-extend ${sessionId} --reason "<why>"  \xB7 or set a new cap:  svamp session loop-resume ${sessionId} --max <N>` : `Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`;
+              sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${budgetCheck.reason} (hard ${iterStop ? "iteration ceiling" : "cost ceiling"} \u2014 will not auto-resume)${acpExtNote ? ` [${acpExtNote}]` : ""}. ${acpResumeHint}`, level: "warning" }, "event");
               checkSvampConfig?.();
               return;
             }
@@ -16331,7 +16506,8 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
                 progressHistory: ls.progress_history || [],
                 stuckLimit: resolveStuckLimit(process.env.SVAMP_LOOP_STUCK_CHECKPOINTS),
                 autoResumes: typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0,
-                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES),
+                // #0320: extensions also raise a FINITE auto-resume cap (no-op under the unbounded default).
+                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES) + grantedExtensionCount(ls.extensions, acpMaxExt),
                 stuckReason: result.reason
               });
               if (decision.action === "continue") {
@@ -16835,7 +17011,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 {
       }
@@ -17032,7 +17208,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-DjMTCoWS.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-B92Z_kox.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();

package/dist/{scheduler-DjMTCoWS.mjs → scheduler-B92Z_kox.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-BNxaekWa.mjs';
+import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-BqqMOMZN.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{serveCommands-Bc6fchAf.mjs → serveCommands-BEJg71HK.mjs}

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

package/dist/{serveManager-DAuIjPuV.mjs → serveManager-BBRgdCJp.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-BNxaekWa.mjs';
+import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-BqqMOMZN.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-DoUUUoZn.mjs');
+      const { FrpcTunnel } = await import('./frpc-BBkDE65f.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,