svamp-cli 0.2.229 → 0.2.231-canary.0

package/dist/{fleet-DkANyXBc.mjs → fleet-Dkm9EQW-.mjs}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import { c as connectToHypha } from './run-CXQ-NEsY.mjs';
+import { c as connectToHypha } from './run-CiJNUuye.mjs';
 import { PINNED_CLAUDE_CODE_VERSION } from './pinnedClaudeCode-VIupR1NK.mjs';
 import 'os';
 import 'fs/promises';

package/dist/{frpc-DLHENjxp.mjs → frpc-D4I-1CO9.mjs}

@@ -4,7 +4,7 @@ import { mkdirSync, writeFileSync, unlinkSync, existsSync, chmodSync, readFileSy
 import { join } from 'path';
 import { homedir, platform, arch } from 'os';
 import { randomUUID, createHash } from 'crypto';
-import { h as getFrpsSubdomainHost, i as getFrpsServerPort, j as getFrpsServerAddr } from './run-CXQ-NEsY.mjs';
+import { h as getFrpsSubdomainHost, i as getFrpsServerPort, j as getFrpsServerAddr } from './run-CiJNUuye.mjs';
 import 'fs/promises';
 import 'url';
 import 'node:crypto';

package/dist/{headlessCli-DDJv4_nj.mjs → headlessCli-DufjFViU.mjs}

@@ -1,5 +1,5 @@
-import { P as resolveModel, a2 as describeMisconfiguration, a3 as buildMachineDeps } from './run-CXQ-NEsY.mjs';
-import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-BFQr64jf.mjs';
+import { P as resolveModel, a2 as describeMisconfiguration, a3 as buildMachineDeps } from './run-CiJNUuye.mjs';
+import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-HXnqgHgt.mjs';
 import { WebSocket } from 'ws';
 import { execSync, spawn } from 'child_process';
 import 'os';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-CXQ-NEsY.mjs';
+export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-CiJNUuye.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{package-D8QFNzpX.mjs → package-DkfV_XZC.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.2.229";
+var version = "0.2.231-canary.0";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/dist/{rpc-DBDPUPj4.mjs → rpc-DQ2uhpLR.mjs}

@@ -1,4 +1,4 @@
-import { m as resolveProjectRoot } from './run-CXQ-NEsY.mjs';
+import { m as resolveProjectRoot } from './run-CiJNUuye.mjs';
 import { g as getWorkflow, s as setWorkflowEnabled, r as removeWorkflow, a as saveWorkflow, b as rawWorkflow, l as listWorkflows } from './store-BTs0H_y0.mjs';
 import { g as getRun, l as listRuns, r as runWorkflow } from './runStore-CtptN7US.mjs';
 import 'os';

package/dist/{rpc-D1_ae6MP.mjs → rpc-qgv0GNgV.mjs}

@@ -1,4 +1,4 @@
-import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as resumeIssue, p as pauseIssue, q as addComment, t as addIssue, v as listIssues, w as searchIssues, x as isVisibleTo } from './run-CXQ-NEsY.mjs';
+import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as resumeIssue, p as pauseIssue, q as addComment, t as addIssue, v as listIssues, w as searchIssues, x as isVisibleTo } from './run-CiJNUuye.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{run-CXQ-NEsY.mjs → run-CiJNUuye.mjs}

@@ -2916,7 +2916,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-DLHENjxp.mjs');
+        const { FrpcTunnel } = await import('./frpc-D4I-1CO9.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3363,7 +3363,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-BFQr64jf.mjs');
+          const { toolsForRole } = await import('./sideband-HXnqgHgt.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3462,7 +3462,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-Cb4O-FK1.mjs');
+    const { queryCore } = await import('./commands--XkWfxcR.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -10719,6 +10719,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 left PAUSED without a real pending user question, or otherwise sidelined, merely to make the queue look empty. Reject "done" if any goal-relevant work is neither genuinely complete nor legitimately blocked on the user.');
   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.`);
@@ -10749,10 +10750,58 @@ function buildGoalCondition(o) {
   if (!o.until && !o.oracle && o.task) parts.push("Done when the task is fully complete and you have shown the evidence that proves it.");
   parts.push(`Or stop after ${o.maxIterations && o.maxIterations > 0 ? o.maxIterations : 20} turns.`);
   if (o.inboxDrain !== false) {
-    parts.push("(\u{1F4EC} Inbox: at the start of each turn, run `svamp session inbox list` and handle any unread peer message \u2014 reply/triage/merge \u2014 before continuing the task above. This is how a long loop drains queued non-urgent mail; it is NOT a completion criterion.)");
+    parts.push("(\u{1F4EC} Inbox: at each turn, BRIEFLY run `svamp session inbox list` and handle anything relevant (reply/triage) before continuing \u2014 but do NOT derail the task to over-service ambient chatter. This drains queued non-urgent peer mail at loop pace; urgent/VIP already interrupt separately. It is NOT a completion criterion.)");
   }
   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 +11685,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 +11789,90 @@ 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.
+      "--allowedTools",
+      "Read",
+      "Bash",
+      "Grep",
+      "Glob",
+      "--disallowedTools",
+      "Write",
+      "Edit",
+      "MultiEdit",
+      "NotebookEdit",
+      "--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 +12073,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 +12082,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 +12095,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 +12570,7 @@ async function startDaemon(options) {
     saveExposedTunnels(list);
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DLHENjxp.mjs');
+    const { FrpcTunnel } = await import('./frpc-D4I-1CO9.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -12438,7 +12590,7 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-BKTiO1hi.mjs');
+  const { ServeManager } = await import('./serveManager-ChzwgiY_.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -13069,87 +13221,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 +13252,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 +13265,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 +13739,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 +14599,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D1_ae6MP.mjs');
+              const { issueRpc } = await import('./rpc-qgv0GNgV.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DBDPUPj4.mjs');
+              const { workflowRpc } = await import('./rpc-DQ2uhpLR.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15039,11 +15136,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D1_ae6MP.mjs');
+              const { issueRpc } = await import('./rpc-qgv0GNgV.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DBDPUPj4.mjs');
+              const { workflowRpc } = await import('./rpc-DQ2uhpLR.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15211,6 +15308,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 +15437,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   sessionService.sendSessionEnd();
                 }
               });
+            } else if (isLoopActiveForSession(directory, sessionId)) {
+              void verifyAcpLoopCompletion();
             }
           } finally {
             insideOnTurnEnd = false;
@@ -15817,7 +16010,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-DPwwX1fQ.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-BvwDI3YR.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();

package/dist/{run-DBB1tUY1.mjs → run-Dehv9lrA.mjs}

@@ -1,4 +1,4 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { a4 as applyClaudeProxyEnv, a5 as composeSessionId, a6 as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, a7 as generateHookSettings } from './run-CXQ-NEsY.mjs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { a4 as applyClaudeProxyEnv, a5 as composeSessionId, a6 as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, a7 as generateHookSettings } from './run-CiJNUuye.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync, watch } from 'node:fs';

package/dist/{scheduler-DPwwX1fQ.mjs → scheduler-BvwDI3YR.mjs}

@@ -1,4 +1,4 @@
-import { m as resolveProjectRoot, y as cronMatches } from './run-CXQ-NEsY.mjs';
+import { m as resolveProjectRoot, y as cronMatches } from './run-CiJNUuye.mjs';
 import { l as listWorkflows, i as isWorkflowEnabled, w as workflowCrons } from './store-BTs0H_y0.mjs';
 import { r as runWorkflow } from './runStore-CtptN7US.mjs';
 import 'os';