svamp-cli 0.2.230 → 0.2.231

package/dist/{run-DVqhiYP9.mjs → run-BzobWMYv.mjs}

@@ -1967,6 +1967,33 @@ function savePersistedMachineMetadata(svampHomeDir, data) {
     console.error("[HYPHA MACHINE] Failed to persist machine metadata:", err);
   }
 }
+function buildSessionTunnels(handlers, sessionId) {
+  const specs = handlers.listExposedTunnels?.() ?? [];
+  const tunnels = handlers.tunnels;
+  const stateOf = (s) => {
+    if (!s) return "reconnecting";
+    if (s.probe && !s.probe.ok) return "failed";
+    if (s.connected) return "connected";
+    return s.restartAttempts > 0 ? "reconnecting" : "failed";
+  };
+  const rows = [];
+  for (const spec of specs) {
+    if (spec.sessionId !== sessionId) continue;
+    const tunnel = tunnels?.get(spec.name);
+    const status = tunnel ? tunnel.status : null;
+    const urls = {};
+    if (tunnel) for (const [port, url] of tunnel.getUrls()) urls[port] = url;
+    rows.push({
+      name: spec.name,
+      ports: spec.ports,
+      group: spec.group,
+      live: !!tunnel,
+      state: stateOf(status),
+      urls: Object.keys(urls).length ? urls : void 0
+    });
+  }
+  return rows;
+}
 async function registerMachineService(server, machineId, metadata, daemonState, handlers) {
   let currentMetadata = { ...metadata };
   let currentDaemonState = { ...daemonState };
@@ -2773,30 +2800,27 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       // user can manage their own session's tasks without machine-level
       // access.
       /**
-       * Snapshot of everything the session's Tasks panel needs to render:
+       * Snapshot of everything the session's Tasks panel needs to render.
+       * Only svamp-MANAGED processes for this session are surfaced (#0192):
        *   - supervised: ProcessSpec/state filtered to this session
-       *   - detected:   descendants of the agent PID that aren't supervised
+       *   - tunnels:    `svamp service expose` tunnels owned by this session
+       * Unsupervised ps-tree descendants of the agent are no longer shown —
+       * `detected` is kept as an empty array for wire back-compat with older
+       * app clients that read `snap.detected`.
        */
       sessionProcessList: async (params, context) => {
         await authorizeSessionAccess(params.sessionId, "view", context);
         const supervisor = handlers.supervisor;
         const all = supervisor ? supervisor.list() : [];
         const supervised = all.filter((p) => p.spec.sessionId === params.sessionId);
+        const tunnels = buildSessionTunnels(handlers, params.sessionId);
         const agentPid = handlers.getSessionPid?.(params.sessionId);
-        let detected = [];
-        if (agentPid) {
-          const supervisedPids = /* @__PURE__ */ new Set();
-          for (const info of all) {
-            if (info.state.pid) supervisedPids.add(info.state.pid);
-          }
-          detected = await detectDescendants(agentPid, supervisedPids);
-        }
-        return { supervised, detected, agentPid };
+        return { supervised, tunnels, detected: [], agentPid };
       },
       /**
-       * Cheap counts for the input-bar badge — avoids the cost of a full
-       * detection walk when the panel is closed. Counts are still
-       * accurate enough to indicate "is anything running for this session".
+       * Cheap counts for the input-bar badge. Counts only svamp-managed
+       * processes for this session (supervised specs + exposed tunnels);
+       * `detected` stays 0 for wire back-compat.
        */
       sessionProcessCounts: async (params, context) => {
         await authorizeSessionAccess(params.sessionId, "view", context);
@@ -2804,15 +2828,9 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const all = supervisor ? supervisor.list() : [];
         const supervised = all.filter((p) => p.spec.sessionId === params.sessionId);
         const supervisedRunning = supervised.filter((p) => p.state.status === "running" || p.state.status === "starting").length;
+        const tunnels = buildSessionTunnels(handlers, params.sessionId).length;
         const agentPid = handlers.getSessionPid?.(params.sessionId);
-        let detected = 0;
-        if (agentPid) {
-          const supervisedPids = /* @__PURE__ */ new Set();
-          for (const info of all) if (info.state.pid) supervisedPids.add(info.state.pid);
-          const list = await detectDescendants(agentPid, supervisedPids);
-          detected = list.length;
-        }
-        return { supervised: supervised.length, supervisedRunning, detected, agentPid };
+        return { supervised: supervised.length, supervisedRunning, tunnels, detected: 0, agentPid };
       },
       /** Logs for a supervised process, gated by session ownership. */
       sessionProcessLogs: async (params, context) => {
@@ -2916,7 +2934,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-o7YfuAtf.mjs');
+        const { FrpcTunnel } = await import('./frpc-CUBlxR7B.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -2943,6 +2961,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           healthCheckType: params.healthCheckType,
           healthCheckPath: params.healthCheckPath,
           healthCheckInterval: params.healthCheckInterval,
+          sessionId: params.sessionId,
           addedAt: Date.now()
         });
         const urls = {};
@@ -3363,7 +3382,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-BDwb3wnc.mjs');
+          const { toolsForRole } = await import('./sideband-DDCUdyBK.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3462,7 +3481,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-C-9UCf3L.mjs');
+    const { queryCore } = await import('./commands-qu4qKm64.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -10719,6 +10738,7 @@ ${o.task.trim()}`);
 ${o.until.trim()}`);
   lines.push("");
   lines.push("Use your tools (Read, Bash, Grep, Glob) to inspect the ACTUAL repository state \u2014 do NOT trust the transcript. Check the working tree, git log/diff, build/test output, and whether changes were actually built/published/deployed where the request implied it.");
+  lines.push('IMPORTANT \u2014 the loop oracle only counts OPEN (ready/in_progress) issues, so an issue removed from the queue without genuine resolution is invisible to it. Run `svamp issue list --all` (or read `.svamp/issues/`) and confirm NO issue tied to this goal was sidelined merely to make the queue look empty. A PAUSED issue is FINE if it is genuinely blocked on a user answer OR clearly delegated/handed to another session (crew child or a named peer) \u2014 do NOT penalize those. Reject "done" ONLY if goal-relevant work is neither genuinely complete, nor legitimately blocked on the user, nor handed to another session.');
   if (o.oracle) {
     lines.push("");
     lines.push(`The loop oracle is \`${o.oracle.trim()}\` and it currently PASSES${o.oracleOutput ? ` (output: ${o.oracleOutput.trim().slice(0, 400)})` : ""}. A green oracle here only means "no OPEN issues" \u2014 it does NOT mean each CLOSED issue actually works.`);
@@ -10753,6 +10773,54 @@ function buildGoalCondition(o) {
   }
   return parts.join(" ");
 }
+const HOUR_MS = 36e5;
+function sumUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") return 0;
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  return n(usage.input_tokens) + n(usage.output_tokens) + n(usage.cache_creation_input_tokens);
+}
+function accumulateLedger(prev, sample) {
+  const base = prev && typeof prev === "object" ? { turns: prev.turns || 0, tokens: prev.tokens || 0, window: Array.isArray(prev.window) ? prev.window : [] } : { turns: 0, tokens: 0, window: [] };
+  const addTurns = sample.turns > 0 ? sample.turns : 0;
+  const addTokens = sample.tokens > 0 ? sample.tokens : 0;
+  const window = [...base.window, [sample.ts, addTokens]].filter(([ts]) => sample.ts - ts < HOUR_MS);
+  return { turns: base.turns + addTurns, tokens: base.tokens + addTokens, window };
+}
+function tokensInLastHour(ledger, now) {
+  if (!ledger || !Array.isArray(ledger.window)) return 0;
+  return ledger.window.filter(([ts]) => now - ts < HOUR_MS).reduce((s, [, t]) => s + (t > 0 ? t : 0), 0);
+}
+function checkLoopBudget(ledger, limits, now, startedAt) {
+  const L = limits || {};
+  const led = ledger || { turns: 0, tokens: 0, window: [] };
+  const pos = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  if (pos(L.max_iterations) && led.turns >= L.max_iterations) {
+    return { exceeded: true, reason: `iteration budget reached (${led.turns}/${L.max_iterations} turns)` };
+  }
+  if (pos(L.max_runtime_sec) && pos(startedAt)) {
+    const elapsed = (now - startedAt) / 1e3;
+    if (elapsed >= L.max_runtime_sec) {
+      return { exceeded: true, reason: `runtime budget reached (${Math.round(elapsed)}s/${L.max_runtime_sec}s)` };
+    }
+  }
+  if (pos(L.max_tokens) && led.tokens >= L.max_tokens) {
+    return { exceeded: true, reason: `token budget reached (${led.tokens}/${L.max_tokens} tokens)` };
+  }
+  if (pos(L.max_tokens_per_hour)) {
+    const rate = tokensInLastHour(led, now);
+    if (rate >= L.max_tokens_per_hour) {
+      return { exceeded: true, reason: `token-rate budget reached (${rate}/${L.max_tokens_per_hour} tokens in the last hour)` };
+    }
+  }
+  return { exceeded: false };
+}
+const DEFAULT_LOOP_EVALUATOR_MODEL = "claude-haiku-4-5-20251001";
+function resolveEvaluatorModel(envValue) {
+  if (envValue === void 0) return DEFAULT_LOOP_EVALUATOR_MODEL;
+  const v = envValue.trim();
+  if (!v || v.toLowerCase() === "inherit" || v.toLowerCase() === "default") return void 0;
+  return v;
+}
 function parseEvaluatorVerdict(text) {
   if (!text) return null;
   const candidates = [];
@@ -11636,6 +11704,7 @@ function writeSvampConfig(configPath, config) {
   renameSync$1(tmpPath, configPath);
   return content;
 }
+const DEFAULT_LOOP_MAX_ITERATIONS = 1e3;
 function getLoopDir(directory, sessionId) {
   if (sessionId) {
     const scoped = join$1(directory, ".svamp", sessionId, "loop");
@@ -11739,6 +11808,91 @@ function stripOldLoopHooks(directory) {
     return false;
   }
 }
+function spawnHeadlessEvaluator(prompt, opts) {
+  return new Promise((resolve2, reject) => {
+    const evalArgs = [
+      "--print",
+      prompt,
+      // Read-only reviewer (mirrors .claude/agents/loop-evaluator.md): it inspects real repo
+      // state but must not mutate the working tree it's judging. The allowedTools whitelist
+      // already excludes mutation tools; --disallowedTools is belt-and-suspenders. Kept to
+      // Write/Edit only — MultiEdit/NotebookEdit aren't known tool names on some claude builds
+      // and emit a noisy "matches no known tool" warning (#0191 canary).
+      "--allowedTools",
+      "Read",
+      "Bash",
+      "Grep",
+      "Glob",
+      "--disallowedTools",
+      "Write",
+      "Edit",
+      "--permission-mode",
+      "bypassPermissions",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      ...opts.model ? ["--model", opts.model] : []
+    ];
+    const evalEnv = { ...process.env };
+    applyClaudeProxyEnv(evalEnv);
+    delete evalEnv.CLAUDECODE;
+    let proc;
+    try {
+      proc = spawn$1("claude", evalArgs, { cwd: opts.cwd, env: evalEnv, stdio: ["pipe", "pipe", "pipe"] });
+    } catch (e) {
+      reject(e);
+      return;
+    }
+    let out = "", buf = "", stderr = "", settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      reject(new Error("evaluator timeout"));
+    }, opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 3e5);
+    proc.stderr?.on("data", (c) => {
+      stderr += c.toString();
+    });
+    proc.stdout.on("data", (chunk) => {
+      buf += chunk.toString();
+      let nl;
+      while ((nl = buf.indexOf("\n")) !== -1) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (!line.trim()) continue;
+        try {
+          const m = JSON.parse(line);
+          if (m.type === "assistant" && m.message?.content) {
+            for (const b of m.message.content) if (b.type === "text" && b.text) out += b.text;
+          } else if (m.type === "result") {
+            if (settled) continue;
+            settled = true;
+            clearTimeout(timer);
+            if (m.is_error) reject(new Error(String(m.result || "evaluator error")));
+            else resolve2(out || String(m.result || ""));
+          }
+        } catch {
+        }
+      }
+    });
+    proc.on("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) resolve2(out);
+      else reject(new Error(stderr.trim() || `evaluator exited with code ${code}`));
+    });
+    proc.on("error", (e) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
 function deactivateLoop(directory, sessionId) {
   try {
     const p = join$1(getLoopDir(directory, sessionId), "loop-state.json");
@@ -11939,6 +12093,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
           } catch {
           }
           const wasStopped = existing.active === false || existing.phase === "done" || existing.phase === "gave_up" || existing.phase === "cancelled";
+          const bumpedBudget = parseLoopBudget(cfg.budget);
           if (wasStopped) {
             try {
               const sp = join$1(getLoopDir(directory, sessionId), "loop-state.json");
@@ -11947,6 +12102,8 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
                 active: true,
                 phase: "continue",
                 iteration: 0,
+                ...newMax != null ? { max_iterations: newMax } : {},
+                ...bumpedBudget ? { budget: { ...existing.budget || {}, ...bumpedBudget } } : {},
                 completed_at: void 0,
                 gave_up_reason: void 0,
                 stall_hinted: false,
@@ -11958,18 +12115,33 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
             setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID$1(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop", createdAt: Date.now() }] }));
             onLoopActivated?.();
           }
+          if (!wasStopped && (newMax != null || bumpedBudget)) {
+            try {
+              const cur = readLoopState(directory, sessionId);
+              if (cur) writeGoalLoopState(directory, sessionId, {
+                ...cur,
+                ...newMax != null ? { max_iterations: newMax } : {},
+                ...bumpedBudget ? { budget: { ...cur.budget || {}, ...bumpedBudget } } : {}
+              });
+            } catch {
+            }
+          }
           sessionService.pushMessage({ type: "message", message: `\u{1F501} Loop limit updated${newMax != null ? ` \u2192 max ${newMax} iterations` : ""}${wasStopped ? " \u2014 resuming" : ""}.` }, "event");
           logger.log(`[svampConfig] Loop limit modified (max=${newMax}, resumed=${wasStopped}, restarted=${wasStopped})`);
         }
       } else if (cfg && typeof cfg === "object" && (task || until)) {
         const oracle = typeof cfg.oracle === "string" && cfg.oracle.trim() ? cfg.oracle.trim() : void 0;
-        const maxIterations = typeof cfg.max_iterations === "number" ? cfg.max_iterations : typeof cfg.max_rounds === "number" ? cfg.max_rounds : 20;
-        const condition = buildGoalCondition({ task, until, oracle, maxIterations });
+        const explicitMax = typeof cfg.max_iterations === "number" ? cfg.max_iterations : typeof cfg.max_rounds === "number" ? cfg.max_rounds : void 0;
+        const hasExplicitMax = typeof explicitMax === "number" && explicitMax > 0;
+        const hardMax = hasExplicitMax ? explicitMax : DEFAULT_LOOP_MAX_ITERATIONS;
+        const softTurnCap = hasExplicitMax ? explicitMax : 20;
+        const condition = buildGoalCondition({ task, until, oracle, maxIterations: softTurnCap });
+        const budget = parseLoopBudget(cfg.budget);
         try {
           stripOldLoopHooks(directory);
         } catch {
         }
-        writeGoalLoopState(directory, sessionId, { active: true, phase: "running", iteration: 0, task: condition, goal_task: task, until, oracle, max_iterations: maxIterations, started_at: Date.now(), holds: 0 });
+        writeGoalLoopState(directory, sessionId, { active: true, phase: "running", iteration: 0, task: condition, goal_task: task, until, oracle, max_iterations: hardMax, budget, started_at: Date.now(), holds: 0, ledger: { turns: 0, tokens: 0, window: [] } });
         const existingQueue = getMetadata().messageQueue || [];
         setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID$1(), text: `/goal ${condition}`, displayText: `\u{1F3AF} Goal: ${(task || until || "").slice(0, 100)}`, createdAt: Date.now() }] }));
         onLoopActivated?.();
@@ -12418,7 +12590,7 @@ async function startDaemon(options) {
     saveExposedTunnels(list);
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-o7YfuAtf.mjs');
+    const { FrpcTunnel } = await import('./frpc-CUBlxR7B.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -12438,7 +12610,7 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-J2VwaLs1.mjs');
+  const { ServeManager } = await import('./serveManager-CkfMDcNQ.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -13069,87 +13241,7 @@ ${parts.join("\n")}`);
           };
           sessionService.updateMetadata(sessionMetadata);
         };
-        const runHeadlessEvaluator = (prompt) => new Promise((resolve2, reject) => {
-          const evalArgs = [
-            "--print",
-            prompt,
-            // Read-only reviewer (mirrors .claude/agents/loop-evaluator.md): it inspects
-            // real repo state but must not mutate the working tree it's judging.
-            "--allowedTools",
-            "Read",
-            "Bash",
-            "Grep",
-            "Glob",
-            "--disallowedTools",
-            "Write",
-            "Edit",
-            "MultiEdit",
-            "NotebookEdit",
-            "--permission-mode",
-            "bypassPermissions",
-            "--output-format",
-            "stream-json",
-            "--verbose"
-          ];
-          const evalEnv = { ...process.env };
-          applyClaudeProxyEnv(evalEnv);
-          delete evalEnv.CLAUDECODE;
-          let proc;
-          try {
-            proc = spawn$1("claude", evalArgs, { cwd: directory, env: evalEnv, stdio: ["pipe", "pipe", "pipe"] });
-          } catch (e) {
-            reject(e);
-            return;
-          }
-          let out = "", buf = "", stderr = "", settled = false;
-          const timer = setTimeout(() => {
-            if (settled) return;
-            settled = true;
-            try {
-              proc.kill("SIGTERM");
-            } catch {
-            }
-            reject(new Error("evaluator timeout"));
-          }, 3e5);
-          proc.stderr?.on("data", (c) => {
-            stderr += c.toString();
-          });
-          proc.stdout.on("data", (chunk) => {
-            buf += chunk.toString();
-            let nl;
-            while ((nl = buf.indexOf("\n")) !== -1) {
-              const line = buf.slice(0, nl);
-              buf = buf.slice(nl + 1);
-              if (!line.trim()) continue;
-              try {
-                const m = JSON.parse(line);
-                if (m.type === "assistant" && m.message?.content) {
-                  for (const b of m.message.content) if (b.type === "text" && b.text) out += b.text;
-                } else if (m.type === "result") {
-                  if (settled) continue;
-                  settled = true;
-                  clearTimeout(timer);
-                  if (m.is_error) reject(new Error(String(m.result || "evaluator error")));
-                  else resolve2(out || String(m.result || ""));
-                }
-              } catch {
-              }
-            }
-          });
-          proc.on("exit", (code) => {
-            if (settled) return;
-            settled = true;
-            clearTimeout(timer);
-            if (code === 0) resolve2(out);
-            else reject(new Error(stderr.trim() || `evaluator exited with code ${code}`));
-          });
-          proc.on("error", (e) => {
-            if (settled) return;
-            settled = true;
-            clearTimeout(timer);
-            reject(e);
-          });
-        });
+        const runHeadlessEvaluator = (prompt) => spawnHeadlessEvaluator(prompt, { cwd: directory, model: resolveEvaluatorModel(process.env.SVAMP_LOOP_EVALUATOR_MODEL) });
         let goalVerifyInFlight = false;
         const verifyGoalCompletion = async (ls) => {
           if (goalVerifyInFlight) return;
@@ -13180,6 +13272,8 @@ ${parts.join("\n")}`);
                 log: (m) => logger.log(`[Session ${sessionId}] ${m}`)
               }
             );
+            const ledger = ls.ledger;
+            const budget = ls.budget;
             if (result.action === "rekick") {
               const cond = ls.task || "";
               writeGoalLoopState(directory, sessionId, {
@@ -13191,18 +13285,20 @@ ${parts.join("\n")}`);
                 until: ls.until,
                 oracle: oracleCmd,
                 max_iterations: ls.max_iterations,
+                budget,
                 started_at: startedAt,
-                holds: holds + 1
+                holds: holds + 1,
+                ledger
               });
               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");
               enqueueLoopMessage(`/goal ${cond} \u2014 INDEPENDENT REVIEW FEEDBACK (resolve before declaring done): ${guidance}`, "\u{1F501} Re-verifying loop");
               if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
             } else if (result.action === "gave_up") {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: result.reason, holds });
+              writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: result.reason, holds, ledger });
               checkSvampConfig?.();
             } else {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds });
+              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger });
               checkSvampConfig?.();
             }
           } catch (e) {
@@ -13663,9 +13759,30 @@ ${parts.join("\n")}`);
                     try {
                       const ls = readLoopState(directory, sessionId);
                       if (ls && ls.engine === "goal" && ls.active !== false && ls.phase !== "done" && ls.phase !== "gave_up" && ls.phase !== "cancelled") {
-                        if (process.env.SVAMP_LOOP_VERIFY === "0") {
-                          writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now() });
+                        const now = Date.now();
+                        const ledger = accumulateLedger(ls.ledger, {
+                          turns: Number(msg.num_turns) || 0,
+                          tokens: sumUsageTokens(msg.usage),
+                          ts: now
+                        });
+                        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 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+                        if (budgetCheck.exceeded) {
+                          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}. Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
+                          checkSvampConfig?.();
+                        } else if (process.env.SVAMP_LOOP_VERIFY === "0") {
+                          writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: now, ledger });
                         } else {
+                          writeGoalLoopState(directory, sessionId, { ...ls, ledger });
                           void verifyGoalCompletion(ls);
                         }
                       }
@@ -14502,11 +14619,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-RpVqDF8O.mjs');
+              const { issueRpc } = await import('./rpc-Cm2Uy3Hf.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-D_Suxu2Q.mjs');
+              const { workflowRpc } = await import('./rpc-CPHva9-3.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15039,11 +15156,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-RpVqDF8O.mjs');
+              const { issueRpc } = await import('./rpc-Cm2Uy3Hf.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-D_Suxu2Q.mjs');
+              const { workflowRpc } = await import('./rpc-CPHva9-3.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15211,6 +15328,100 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
         }
         let acpStopped = false;
         let acpBackendReady = false;
+        let acpVerifyInFlight = false;
+        const dispatchAcpPrompt = (text, displayText) => {
+          if (acpStopped) return;
+          sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
+          sessionService.updateMetadata(sessionMetadata);
+          sessionService.sendKeepAlive(true);
+          sessionService.pushMessage(displayText, "user");
+          agentBackend.sendPrompt(sessionId, text).catch((err) => {
+            logger.error(`[Session ${sessionId}] ACP loop re-kick send failed: ${err.message}`);
+            if (!acpStopped) {
+              sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+              sessionService.updateMetadata(sessionMetadata);
+              sessionService.sendSessionEnd();
+            }
+          });
+        };
+        const verifyAcpLoopCompletion = async () => {
+          if (acpVerifyInFlight || acpStopped) return;
+          const ls = readLoopState(directory, sessionId);
+          if (!ls || ls.engine !== "goal" || ls.active === false || ls.phase === "done" || ls.phase === "gave_up" || ls.phase === "cancelled") return;
+          if (!isLoopActiveForSession(directory, sessionId)) return;
+          acpVerifyInFlight = true;
+          const now = Date.now();
+          const projectRoot = resolveProjectRoot(directory);
+          const startedAt = typeof ls.started_at === "number" ? ls.started_at : typeof ls.resumed_at === "number" ? ls.resumed_at : void 0;
+          const oracleCmd = typeof ls.oracle === "string" && ls.oracle.trim() ? ls.oracle.trim() : void 0;
+          const ledger = accumulateLedger(ls.ledger, { turns: 1, tokens: 0, ts: now });
+          ls.ledger = ledger;
+          const holds = typeof ls.holds === "number" ? ls.holds : 0;
+          const runOracle = async () => {
+            if (oracleCmd) {
+              return await new Promise((resolve2) => {
+                exec$1(oracleCmd, { cwd: directory, timeout: 12e4, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+                  if (err) resolve2({ ok: false, output: (String(stdout || "") + String(stderr || "")).slice(-500) });
+                  else resolve2({ ok: true, output: "" });
+                });
+              });
+            }
+            const pending = backlogOraclePending(projectRoot, sessionId);
+            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 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+            if (budgetCheck.exceeded) {
+              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}. Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
+              checkSvampConfig?.();
+              return;
+            }
+            const oracle = await runOracle();
+            if (!oracle.ok) {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", ledger });
+              dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. Not done yet \u2014 the loop oracle still reports pending work:
+${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
+              return;
+            }
+            if (process.env.SVAMP_LOOP_VERIFY === "0") {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: now, ledger });
+              checkSvampConfig?.();
+              return;
+            }
+            sessionService.pushMessage({ type: "message", message: "\u{1F50D} Verifying loop completion (independent review)\u2026" }, "event");
+            const result = await runLoopVerification(
+              { task: ls.goal_task || ls.task, until: ls.until, oracle: oracleCmd, startedAt, holds, maxHolds: 3 },
+              {
+                projectRoot,
+                runOracle: async () => ({ ok: true, output: oracle.output }),
+                runEvaluator: (prompt) => spawnHeadlessEvaluator(prompt, { cwd: directory, model: resolveEvaluatorModel(process.env.SVAMP_LOOP_EVALUATOR_MODEL) }),
+                log: (m) => logger.log(`[Session ${sessionId}] ${m}`)
+              }
+            );
+            if (result.action === "rekick") {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", holds: holds + 1, started_at: startedAt, ledger });
+              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");
+              dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. INDEPENDENT REVIEW FEEDBACK (resolve before declaring done): ${guidance}`, "\u{1F501} Re-verifying loop");
+            } else if (result.action === "gave_up") {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: result.reason, holds, ledger });
+              checkSvampConfig?.();
+            } else {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger });
+              checkSvampConfig?.();
+            }
+          } catch (e) {
+            logger.log(`[Session ${sessionId}] verifyAcpLoopCompletion error \u2014 failing open (done): ${e?.message || e}`);
+            try {
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), ledger });
+              checkSvampConfig?.();
+            } catch {
+            }
+          } finally {
+            acpVerifyInFlight = false;
+          }
+        };
         const onTurnEnd = (lastAssistantText) => {
           if (acpStopped) return;
           insideOnTurnEnd = true;
@@ -15246,6 +15457,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   sessionService.sendSessionEnd();
                 }
               });
+            } else if (isLoopActiveForSession(directory, sessionId)) {
+              void verifyAcpLoopCompletion();
             }
           } finally {
             insideOnTurnEnd = false;
@@ -15521,7 +15734,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
       sharingNotificationSync,
       persistExposedTunnel,
       forgetExposedTunnel,
-      listExposedTunnels: () => loadExposedTunnels().map((t) => ({ name: t.name, ports: t.ports, group: t.group, addedAt: t.addedAt }))
+      listExposedTunnels: () => loadExposedTunnels().map((t) => ({ name: t.name, ports: t.ports, group: t.group, sessionId: t.sessionId, addedAt: t.addedAt }))
     });
     const machineService = await registerMachineService(
       server,
@@ -15817,7 +16030,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-B2ZHfyig.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-CwyAdWQa.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();