svamp-cli 0.2.310 → 0.2.312

package/dist/{run-CqO23ro_.mjs → run-Ccf8_4AF.mjs}

@@ -1121,7 +1121,13 @@ function buildSessionDeps(rpc, opts = {}) {
         loop: {
           task: opts2?.prompt?.trim() || "Work the ready issues in this session backlog until none remain (`svamp issue list --status ready`).",
           oracle: "svamp issue pending",
-          max_iterations: opts2?.maxIterations ?? 20,
+          // Durable backlog drainer: no forced iteration cap. A finite `?? 20` sent the loop
+          // to a terminal `gave_up` after 20 turns even with issues remaining — a concrete
+          // "loop stops easily" cause. Only an EXPLICIT user-set cap bounds it; otherwise the
+          // loop runs unbounded (real runaway guard = the rolling per-hour token rate cap) and
+          // goes DORMANT (armed) when the backlog clears. `durable:true` marks it re-arming.
+          ...opts2?.maxIterations ? { max_iterations: opts2.maxIterations } : {},
+          durable: true,
           evaluator: true
         }
       }, ctx);
@@ -3147,7 +3153,7 @@ Connection: close\r
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-DxIjZ8o_.mjs');
+      const { FrpcTunnel } = await import('./frpc-DbZDLphz.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -6280,7 +6286,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-DxIjZ8o_.mjs');
+        const { FrpcTunnel } = await import('./frpc-DbZDLphz.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -6773,7 +6779,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-Dv3qNlQN.mjs');
+          const { toolsForRole } = await import('./sideband-CDdpZAXO.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -6872,13 +6878,13 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
       hyphaWorkspace: u?.scope?.current_workspace
     });
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
-    const callId = "call_" + Math.random().toString(16).slice(2, 12);
+    const callId = "call_" + randomUUID().slice(0, 10);
     const senderKey = (r.sender.name || "anonymous").toLowerCase();
     if (!statelessLimiter.tryAcquire(senderKey)) {
       return { ok: false, call_id: callId, status: "busy", error: "channel is busy (too many concurrent requests) \u2014 retry shortly" };
     }
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-D-RsuMqs.mjs');
+    const { queryCore } = await import('./commands-C2zQmf3Y.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -7018,7 +7024,7 @@ ${d?.error || "not found"}`;
         try {
           const saved = writeUpload(dir, v.target, dec.data);
           try {
-            new ChannelStore(dir).recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId: "up_" + Math.random().toString(16).slice(2, 10), outcome: "uploaded" });
+            new ChannelStore(dir).recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId: "up_" + randomUUID().slice(0, 10), outcome: "uploaded" });
           } catch {
           }
           return { ok: true, name: saved.name, path: saved.relPath, bytes: saved.bytes };
@@ -7670,7 +7676,15 @@ async function _mintPairingCodeLocked(opts, resolver, ttlMs) {
 }
 
 const OUTPOST_STALE_MS = 9e4;
-const OUTPOST_EXEC_TIMEOUT_MS = 10 * 6e4;
+const OUTPOST_EXEC_TIMEOUT_MS = 12 * 6e4;
+const OUTPOST_MAX_OUTPUT_BYTES = 1 << 20;
+function capOutpostOutput(s) {
+  if (!s) return "";
+  if (s.length <= OUTPOST_MAX_OUTPUT_BYTES) return s;
+  const dropped = s.length - OUTPOST_MAX_OUTPUT_BYTES;
+  return `[svamp-daemon] output truncated: ${dropped} earlier characters dropped]
+${s.slice(-OUTPOST_MAX_OUTPUT_BYTES)}`;
+}
 class OutpostCoordinator {
   conns = /* @__PURE__ */ new Map();
   queue = /* @__PURE__ */ new Map();
@@ -7816,7 +7830,14 @@ class OutpostCoordinator {
       const timer = this.setTimer(() => {
         if (!this.pending.has(id)) return;
         this.pending.delete(id);
-        resolve({ id, stdout: "", stderr: `command timed out after ${Math.round(this.execTimeoutMs / 1e3)}s`, exitCode: -1, synthetic: true, ts: this.now() });
+        resolve({
+          id,
+          stdout: "",
+          stderr: `command timed out after ${Math.round(this.execTimeoutMs / 1e3)}s with no result from the outpost \u2014 it may still be running remotely, so re-running it is NOT necessarily safe`,
+          exitCode: -1,
+          synthetic: true,
+          ts: this.now()
+        });
       }, this.execTimeoutMs);
       this.pending.set(id, { machine, resolve, timer, enqueuedAt: this.now() });
     });
@@ -7840,8 +7861,11 @@ class OutpostCoordinator {
     this.touch(p.machine);
     p.resolve({
       id: result.id,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
+      // #0814: the outpost caps its own output, but clamp again here — a hostile or
+      // out-of-date outpost must not be able to push an unbounded string through the
+      // daemon and out over Hypha RPC (the #0598 oversized-message class).
+      stdout: capOutpostOutput(result.stdout),
+      stderr: capOutpostOutput(result.stderr),
       exitCode: typeof result.exitCode === "number" ? result.exitCode : 0,
       ts: this.now()
     });
@@ -8273,7 +8297,9 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     const who = conn.label || conn.machine;
     const plat = [conn.os, conn.arch].filter(Boolean).join("/") || "unknown platform";
     const msg = {
-      messageId: "op_" + Math.random().toString(16).slice(2, 10),
+      // #0816: CSPRNG — this id routes `svamp session inbox reply`, so a predictable
+      // one lets a third party target another agent's reply thread.
+      messageId: "op_" + randomUUID().slice(0, 10),
       body: `A remote machine connected as an outpost: ${xmlEscape(who)} (${xmlEscape(plat)}). You can now run shell commands on it \u2014 its output returns synchronously, like a local command. Run one with: svamp outpost exec "uname -a"`,
       timestamp: Date.now(),
       read: false,
@@ -13937,6 +13963,7 @@ function shouldIsolate(input) {
 function classifyRestoreContinuation(opts) {
   if (opts.isOrphaned) return "none";
   if (opts.loopActive) return "loop-resume";
+  if (opts.loopArmed) return opts.armedHasPendingWork ? "loop-resume" : "none";
   if (opts.wasProcessing && opts.hasResumeId) return "auto-continue";
   return "none";
 }
@@ -15048,7 +15075,7 @@ function searchIssues(projectRoot, query) {
 }
 function summarize(issues) {
   const by = (s) => issues.filter((i) => i.status === s).length;
-  return { total: issues.length, ready: by("ready"), in_progress: by("in_progress"), archived: by("archived") };
+  return { total: issues.length, ready: by("ready"), in_progress: by("in_progress"), paused: by("paused"), archived: by("archived") };
 }
 
 function isWorkflowEnabled(wf) {
@@ -15606,7 +15633,15 @@ function loopCancelledDuringVerify(current) {
 }
 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 }));
+  return listIssues(projectRoot).filter(inScope).filter((i) => i.status !== "archived" && i.status !== "paused").map((i) => ({ id: i.id }));
+}
+function isBacklogDrainerOracle(oracle) {
+  if (!oracle || typeof oracle !== "string") return false;
+  return /(^|\s)svamp\s+issue\s+pending(\s|$)/.test(oracle.trim());
+}
+function resolveLoopDurable(cfg) {
+  if (typeof cfg.durable === "boolean") return cfg.durable;
+  return isBacklogDrainerOracle(cfg.oracle);
 }
 function issuesClosedSince(projectRoot, sinceMs) {
   const all = listIssues(projectRoot, { includeArchived: true, status: "archived" });
@@ -15831,6 +15866,25 @@ function decideLoopContinuation(input) {
   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 };
 }
+function terminalPhaseForDone(durable) {
+  return durable ? "dormant" : "done";
+}
+const DEFAULT_LOOP_VERIFY_ERROR_RETRIES = 3;
+function resolveVerifyErrorRetries(envValue) {
+  if (envValue == null || envValue.trim() === "") return DEFAULT_LOOP_VERIFY_ERROR_RETRIES;
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  return DEFAULT_LOOP_VERIFY_ERROR_RETRIES;
+}
+function decideVerifyErrorHandling(input) {
+  const maxRetries = typeof input.maxRetries === "number" && input.maxRetries >= 0 ? Math.floor(input.maxRetries) : DEFAULT_LOOP_VERIFY_ERROR_RETRIES;
+  const attempt = (typeof input.priorErrors === "number" && input.priorErrors > 0 ? Math.floor(input.priorErrors) : 0) + 1;
+  const why = input.reason ? String(input.reason).slice(0, 200) : "verification error";
+  if (attempt <= maxRetries) {
+    return { action: "retry", attempt, reason: `${why} \u2014 retry ${attempt}/${maxRetries} (keeping the loop running, not declaring done)` };
+  }
+  return { action: "park", attempt, reason: `${why} \u2014 ${maxRetries} verification retries exhausted; parking safely instead of a false "done"` };
+}
 const DEFAULT_LOOP_EVALUATOR_MODEL = "claude-haiku-4-5-20251001";
 function resolveEvaluatorModel(envValue) {
   if (envValue === void 0) return DEFAULT_LOOP_EVALUATOR_MODEL;
@@ -15905,13 +15959,13 @@ Keep working until it is genuinely empty.` };
   try {
     raw = await deps.runEvaluator(prompt);
   } catch (e) {
-    log(`[loopVerify] evaluator spawn failed \u2014 failing OPEN (marking done): ${e?.message || e}`);
-    return { action: "done" };
+    log(`[loopVerify] evaluator spawn failed \u2014 signalling verify_error (fail-closed, will retry): ${e?.message || e}`);
+    return { action: "verify_error", reason: `evaluator spawn failed: ${e?.message || e}` };
   }
   const verdict = parseEvaluatorVerdict(raw);
   if (!verdict) {
-    log(`[loopVerify] could not parse evaluator verdict \u2014 failing OPEN (marking done)`);
-    return { action: "done" };
+    log(`[loopVerify] could not parse evaluator verdict \u2014 signalling verify_error (fail-closed, will retry)`);
+    return { action: "verify_error", reason: "could not parse evaluator verdict" };
   }
   if (verdict.verdict === "done") {
     log(`[loopVerify] evaluator confirms done${verdict.reason ? `: ${verdict.reason}` : ""}`);
@@ -16358,6 +16412,28 @@ async function writeSessionFileChunk(directory, sessionMetadata, path, content,
   }
 }
 
+function isStdinWritable(proc) {
+  if (!proc || proc.exitCode !== null) return false;
+  const stdin = proc.stdin;
+  if (!stdin) return false;
+  if (stdin.destroyed === true) return false;
+  if (stdin.writable === false) return false;
+  return true;
+}
+function serializeUserFrame(text) {
+  return JSON.stringify({ type: "user", message: { role: "user", content: text } }) + "\n";
+}
+function writeUserFrame(proc, text, onError) {
+  if (!isStdinWritable(proc)) return false;
+  try {
+    proc.stdin.write(serializeUserFrame(text));
+    return true;
+  } catch (err) {
+    onError?.(err);
+    return false;
+  }
+}
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname$1(__filename$1);
 const CLAUDE_SKILLS_DIR = join(os$1.homedir(), ".claude", "skills");
@@ -16900,18 +16976,27 @@ function readLoopState(directory, sessionId) {
     return null;
   }
 }
+function isTerminalLoopPhase(phase) {
+  return phase === "done" || phase === "gave_up" || phase === "cancelled";
+}
 function isLoopActive(directory, sessionId) {
   const s = readLoopState(directory, sessionId);
-  return !!s && s.active !== false && s.phase !== "done" && s.phase !== "gave_up" && s.phase !== "cancelled";
+  return !!s && s.active !== false && s.phase !== "dormant" && !isTerminalLoopPhase(s.phase);
 }
 function loopOwnerSession(directory, sessionId) {
   const s = readLoopState(directory, sessionId);
-  if (!s || s.active === false || s.phase === "done" || s.phase === "gave_up" || s.phase === "cancelled") return null;
+  if (!s || s.active === false || s.phase === "dormant" || isTerminalLoopPhase(s.phase)) return null;
   return typeof s.session_id === "string" ? s.session_id : null;
 }
 function isLoopActiveForSession(directory, sessionId) {
   const s = readLoopState(directory, sessionId);
-  if (!s || s.active === false || s.phase === "done" || s.phase === "gave_up" || s.phase === "cancelled") return false;
+  if (!s || s.active === false || s.phase === "dormant" || isTerminalLoopPhase(s.phase)) return false;
+  if (typeof s.session_id !== "string") return true;
+  return s.session_id === sessionId;
+}
+function isLoopArmedForSession(directory, sessionId) {
+  const s = readLoopState(directory, sessionId);
+  if (!s || s.active === false || s.phase !== "dormant") return false;
   if (typeof s.session_id !== "string") return true;
   return s.session_id === sessionId;
 }
@@ -16980,6 +17065,14 @@ function loopResumeMessage(directory, sessionId) {
 function stripOldLoopHooks(directory) {
   try {
     const p = join(directory, ".claude", "settings.json");
+    if (!existsSync$1(p)) return false;
+    return withFileLock(p + ".svamp-lock", () => stripOldLoopHooksLocked(p));
+  } catch {
+    return false;
+  }
+}
+function stripOldLoopHooksLocked(p) {
+  try {
     if (!existsSync$1(p)) return false;
     const cfg = JSON.parse(readFileSync$1(p, "utf-8"));
     if (!cfg || typeof cfg.hooks !== "object" || !cfg.hooks) return false;
@@ -17003,13 +17096,31 @@ function stripOldLoopHooks(directory) {
     }
     if (changed) {
       if (Object.keys(cfg.hooks).length === 0) delete cfg.hooks;
-      writeFileSync(p, JSON.stringify(cfg, null, 2));
+      const tmp = `${p}.${process.pid}.tmp`;
+      writeFileSync(tmp, JSON.stringify(cfg, null, 2));
+      renameSync$1(tmp, p);
     }
     return changed;
   } catch {
     return false;
   }
 }
+const HELPER_KILL_GRACE_MS = 3e3;
+const BTW_TIMEOUT_MS = Number(process.env.SVAMP_BTW_TIMEOUT_MS) > 0 ? Number(process.env.SVAMP_BTW_TIMEOUT_MS) : 10 * 6e4;
+function killHelperTree(proc, graceMs = HELPER_KILL_GRACE_MS) {
+  const pid = proc.pid;
+  if (!pid) return;
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+  }
+  setTimeout(() => {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+    }
+  }, graceMs).unref();
+}
 function spawnHeadlessEvaluator(prompt, opts) {
   return new Promise((resolve2, reject) => {
     const evalArgs = [
@@ -17040,7 +17151,7 @@ function spawnHeadlessEvaluator(prompt, opts) {
     delete evalEnv.CLAUDECODE;
     let proc;
     try {
-      proc = spawn("claude", evalArgs, { cwd: opts.cwd, env: evalEnv, stdio: ["pipe", "pipe", "pipe"] });
+      proc = spawn("claude", evalArgs, { cwd: opts.cwd, env: evalEnv, stdio: ["pipe", "pipe", "pipe"], detached: true });
     } catch (e) {
       reject(e);
       return;
@@ -17049,10 +17160,7 @@ function spawnHeadlessEvaluator(prompt, opts) {
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      try {
-        proc.kill("SIGTERM");
-      } catch {
-      }
+      killHelperTree(proc);
       reject(new Error("evaluator timeout"));
     }, opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 3e5);
     proc.stderr?.on("data", (c) => {
@@ -17398,11 +17506,12 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         const softTurnCap = computeSoftTurnCap(hardMax, LOOP_CHECKPOINT_CADENCE);
         const condition = buildGoalCondition({ task, until, oracle, maxIterations: softTurnCap });
         const budget = parseLoopBudget(cfg.budget);
+        const durable = resolveLoopDurable({ durable: cfg.durable, oracle });
         try {
           stripOldLoopHooks(directory);
         } catch {
         }
-        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: [] }, progress_history: [], auto_resumes: 0 });
+        writeGoalLoopState(directory, sessionId, { active: true, phase: "running", durable, 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: [] }, progress_history: [], auto_resumes: 0, verify_errors: 0 });
         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?.();
@@ -17855,7 +17964,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-9GHpj3mp.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-hLTce38n.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -17873,7 +17982,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DxIjZ8o_.mjs');
+    const { FrpcTunnel } = await import('./frpc-DbZDLphz.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -17901,7 +18010,7 @@ async function startDaemon(options) {
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-zDzkOTi2.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-mM9Q6Q2G.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -18396,12 +18505,16 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
               "json",
               "--max-turns",
               "6"
-            ], { cwd, timeout: 6e4, stdio: ["ignore", "pipe", "pipe"], env: forkEnv });
+              // #0820: detached → own process group. Node's `timeout` option kills only
+              // the direct child, so without this a tool grandchild survives the 60s cap
+              // and reparents to init. The exit/error handlers below kill the group.
+            ], { cwd, timeout: 6e4, stdio: ["ignore", "pipe", "pipe"], env: forkEnv, detached: true });
             let stdout = "";
             child.stdout?.on("data", (d) => {
               stdout += d.toString();
             });
             child.on("close", () => {
+              killHelperTree(child);
               try {
                 const r = JSON.parse(stdout);
                 resolve2(r.result || r.text || null);
@@ -18409,7 +18522,10 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
                 resolve2(null);
               }
             });
-            child.on("error", () => resolve2(null));
+            child.on("error", () => {
+              killHelperTree(child);
+              resolve2(null);
+            });
           } catch {
             resolve2(null);
           }
@@ -18492,6 +18608,13 @@ ${parts.join("\n")}`);
         let startupRetryMessage;
         let startupNonJsonLines = [];
         let errorOutputLines = [];
+        const MAX_ERROR_OUTPUT_LINES = 200;
+        const pushErrorOutputLine = (line) => {
+          errorOutputLines.push(line);
+          if (errorOutputLines.length > MAX_ERROR_OUTPUT_LINES) {
+            errorOutputLines.splice(0, errorOutputLines.length - MAX_ERROR_OUTPUT_LINES);
+          }
+        };
         const STUCK_PROCESS_TIMEOUT_MS = 30 * 60 * 1e3;
         const STUCK_CHECK_INTERVAL_MS = 2 * 60 * 1e3;
         let lastOutputTime = Date.now();
@@ -18598,6 +18721,7 @@ ${parts.join("\n")}`);
             const budget = ls.budget;
             const progress_history = curLs.progress_history ?? ls.progress_history;
             const extensions = curLs.extensions ?? ls.extensions;
+            const durable = resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd });
             if (result.action === "rekick") {
               const cond = ls.task || "";
               writeGoalLoopState(directory, sessionId, {
@@ -18615,7 +18739,9 @@ ${parts.join("\n")}`);
                 ledger,
                 progress_history,
                 auto_resumes: ls.auto_resumes,
-                extensions
+                extensions,
+                durable: ls.durable,
+                verify_errors: 0
               });
               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");
@@ -18652,7 +18778,9 @@ ${parts.join("\n")}`);
                   ledger,
                   progress_history,
                   auto_resumes: nextAuto,
-                  extensions
+                  extensions,
+                  durable: ls.durable,
+                  verify_errors: 0
                 });
                 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");
@@ -18665,15 +18793,75 @@ ${parts.join("\n")}`);
                 logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
                 checkSvampConfig?.();
               }
+            } else if (result.action === "verify_error") {
+              const decision = decideVerifyErrorHandling({
+                priorErrors: ls.verify_errors,
+                maxRetries: resolveVerifyErrorRetries(process.env.SVAMP_LOOP_VERIFY_ERROR_RETRIES),
+                reason: result.reason
+              });
+              if (decision.action === "retry") {
+                const cond = ls.task || "";
+                writeGoalLoopState(directory, sessionId, {
+                  active: true,
+                  phase: "continue",
+                  iteration: ls.iteration || 0,
+                  task: ls.task,
+                  goal_task: ls.goal_task,
+                  until: ls.until,
+                  oracle: oracleCmd,
+                  max_iterations: ls.max_iterations,
+                  budget,
+                  started_at: startedAt,
+                  holds,
+                  ledger,
+                  progress_history,
+                  auto_resumes: ls.auto_resumes,
+                  extensions,
+                  durable: ls.durable,
+                  verify_errors: decision.attempt
+                });
+                sessionService.pushMessage({ type: "message", message: `\u26A0\uFE0F Loop verification hit a transient error \u2014 ${decision.reason}`, level: "warning" }, "event");
+                logger.log(`[Session ${sessionId}] [loop-verify-error] ${decision.reason}`);
+                enqueueLoopMessage(`/goal ${cond} \u2014 the independent completion check could not run (${result.reason}); CONTINUE the remaining work and it will be re-verified. Do NOT treat this as done.`, "\u26A0\uFE0F Re-verifying loop");
+                if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
+              } else {
+                const parkPhase = terminalPhaseForDone(durable);
+                writeGoalLoopState(directory, sessionId, { ...ls, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions, durable: ls.durable, verify_errors: 0 });
+                sessionService.pushMessage({ type: "message", message: parkPhase === "dormant" ? `\u{1F319} Loop parked (armed) after repeated verification errors \u2014 it will re-arm when new work arrives. ${decision.reason}` : `\u26A0\uFE0F Loop stopped after repeated verification errors \u2014 ${decision.reason}`, level: "warning" }, "event");
+                logger.log(`[Session ${sessionId}] [loop-verify-error] park ${parkPhase}: ${decision.reason}`);
+                checkSvampConfig?.();
+              }
             } else {
-              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
+              const donePhase = terminalPhaseForDone(durable);
+              if (donePhase === "dormant") {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "dormant", durable: true, completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions, verify_errors: 0 });
+                sessionService.pushMessage({ type: "message", message: "\u{1F319} Backlog clear \u2014 loop is armed and watching for new issues (auto-resumes when work arrives)." }, "event");
+                logger.log(`[Session ${sessionId}] [loop] backlog drained \u2192 dormant (armed)`);
+              } else {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions, verify_errors: 0 });
+              }
               checkSvampConfig?.();
             }
           } catch (e) {
-            logger.log(`[Session ${sessionId}] verifyGoalCompletion error \u2014 failing open (done): ${e?.message || e}`);
+            logger.log(`[Session ${sessionId}] verifyGoalCompletion threw \u2014 failing closed (retry/park): ${e?.message || e}`);
             try {
-              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now() });
-              checkSvampConfig?.();
+              const durable2 = resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd });
+              const decision = decideVerifyErrorHandling({
+                priorErrors: ls.verify_errors,
+                maxRetries: resolveVerifyErrorRetries(process.env.SVAMP_LOOP_VERIFY_ERROR_RETRIES),
+                reason: `verify threw: ${e?.message || e}`
+              });
+              if (decision.action === "retry") {
+                const cond = ls.task || "";
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", started_at: startedAt, verify_errors: decision.attempt });
+                sessionService.pushMessage({ type: "message", message: `\u26A0\uFE0F Loop verification error \u2014 ${decision.reason}`, level: "warning" }, "event");
+                enqueueLoopMessage(`/goal ${cond} \u2014 the completion check could not run; CONTINUE and it will be re-verified. Not done.`, "\u26A0\uFE0F Re-verifying loop");
+                if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
+              } else {
+                const parkPhase = terminalPhaseForDone(durable2);
+                writeGoalLoopState(directory, sessionId, { ...ls, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), verify_errors: 0 });
+                checkSvampConfig?.();
+              }
             } catch {
             }
           } finally {
@@ -19191,7 +19379,7 @@ ${parts.join("\n")}`);
                     clearInboundContext(sessionId);
                     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 (ls && ls.engine === "goal" && ls.active !== false && ls.phase !== "dormant" && ls.phase !== "done" && ls.phase !== "gave_up" && ls.phase !== "cancelled") {
                         const now = Date.now();
                         const ledger = accumulateLedger(ls.ledger, {
                           turns: Number(msg.num_turns) || 0,
@@ -19225,7 +19413,8 @@ ${parts.join("\n")}`);
                           sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${detail}`, level: "warning" }, "event");
                           checkSvampConfig?.();
                         } else if (process.env.SVAMP_LOOP_VERIFY === "0") {
-                          writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: now, ledger, progress_history: prog.progress_history, auto_resumes: prog.auto_resumes });
+                          const donePhase = terminalPhaseForDone(resolveLoopDurable({ durable: ls.durable, oracle: ls.oracle }));
+                          writeGoalLoopState(directory, sessionId, { ...ls, active: donePhase === "dormant", phase: donePhase, completed_at: now, ledger, progress_history: prog.progress_history, auto_resumes: prog.auto_resumes });
                         } else {
                           writeGoalLoopState(directory, sessionId, { ...ls, ledger, progress_history: prog.progress_history, auto_resumes: prog.auto_resumes });
                           void verifyGoalCompletion(ls);
@@ -19361,7 +19550,7 @@ ${parts.join("\n")}`);
                   startupNonJsonLines.push(line.slice(0, 500));
                 }
                 if (looksLikeClaudeError(line)) {
-                  errorOutputLines.push(line.slice(0, 500));
+                  pushErrorOutputLine(line.slice(0, 500));
                 }
               }
             }
@@ -19379,14 +19568,12 @@ ${parts.join("\n")}`);
               stdoutBuffer = "";
             }
           });
-          let stderrBuffer = "";
           child.stderr?.on("data", (chunk) => {
             const text = chunk.toString();
             logger.log(`[Session ${sessionId}] Claude stderr: ${text.trim()}`);
-            stderrBuffer += text;
             for (const line of text.split("\n")) {
               if (looksLikeClaudeError(line)) {
-                errorOutputLines.push(line.trim().slice(0, 500));
+                pushErrorOutputLine(line.trim().slice(0, 500));
               }
             }
           });
@@ -19472,6 +19659,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           }
           return child;
         };
+        const writeUserFrameToClaude = (text) => writeUserFrame(claudeProcess, text, (err) => {
+          logger.log(`[Session ${sessionId}] Claude stdin write failed: ${err?.message || err}`);
+        });
         const restartClaudeHandler = async (opts) => {
           logger.log(`[Session ${sessionId}] Restart Claude requested`);
           if (isRestartingClaude || isSwitchingMode) {
@@ -19510,6 +19700,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               spawnClaude(void 0, { permissionMode: currentPermissionMode });
               sessionService.updateMetadata(sessionMetadata);
               logger.log(`[Session ${sessionId}] Claude respawned with --resume ${claudeResumeId}`);
+              if ((sessionMetadata.messageQueue?.length ?? 0) > 0 && !trackedSession?.stopped) {
+                setTimeout(() => processMessageQueueRef?.(), 300);
+              }
               if (beforeRespawnError) {
                 return { success: false, message: `Edit failed (session restored): ${beforeRespawnError}` };
               }
@@ -19635,12 +19828,28 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   const btwProcess = spawn("claude", btwArgs, {
                     cwd: directory,
                     env: btwEnv,
-                    stdio: ["pipe", "pipe", "pipe"]
+                    stdio: ["pipe", "pipe", "pipe"],
+                    detached: true
+                    // #0820: own process group so the timeout can kill grandchildren
                   });
                   let btwResult = "";
                   let btwBuffer = "";
                   let btwStderr = "";
                   let settled = false;
+                  const btwTimer = setTimeout(() => {
+                    if (settled) return;
+                    settled = true;
+                    killHelperTree(btwProcess);
+                    const err = new Error(`/btw timed out after ${Math.round(BTW_TIMEOUT_MS / 1e3)}s`);
+                    err.retryable = false;
+                    reject(err);
+                  }, BTW_TIMEOUT_MS);
+                  const settleBtw = () => {
+                    if (settled) return false;
+                    settled = true;
+                    clearTimeout(btwTimer);
+                    return true;
+                  };
                   btwProcess.stderr?.on("data", (chunk) => {
                     btwStderr += chunk.toString();
                   });
@@ -19660,8 +19869,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                             }
                           }
                         } else if (msg.type === "result") {
-                          if (settled) continue;
-                          settled = true;
+                          if (!settleBtw()) continue;
                           if (msg.is_error) {
                             const err = new Error(String(msg.result || "error"));
                             err.retryable = isRetryableRateLimit(String(msg.result || ""), msg.api_error_status);
@@ -19675,8 +19883,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     }
                   });
                   btwProcess.on("exit", (code) => {
-                    if (settled) return;
-                    settled = true;
+                    if (!settleBtw()) return;
                     if (code === 0) {
                       resolve2(btwResult || "(no response)");
                       return;
@@ -19687,8 +19894,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     reject(err);
                   });
                   btwProcess.on("error", (e) => {
-                    if (settled) return;
-                    settled = true;
+                    if (!settleBtw()) return;
                     const err = new Error(e.message);
                     err.retryable = false;
                     reject(err);
@@ -19734,15 +19940,26 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               pendingCompactTurn = isCompactCommand(text);
               if (!claudeProcess || claudeProcess.exitCode !== null) {
                 spawnClaude(text, msgMeta);
+                signalProcessing(true);
+                sessionWasProcessing = true;
+              } else if (writeUserFrameToClaude(text)) {
+                signalProcessing(true);
+                sessionWasProcessing = true;
               } else {
-                const stdinMsg = JSON.stringify({
-                  type: "user",
-                  message: { role: "user", content: text }
-                });
-                claudeProcess.stdin?.write(stdinMsg + "\n");
+                logger.log(`[Session ${sessionId}] Claude stdin unwritable \u2014 requeueing message for respawn delivery`);
+                const existingQueue = sessionMetadata.messageQueue || [];
+                sessionMetadata = {
+                  ...sessionMetadata,
+                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now(), alreadyStored: true }]
+                };
+                sessionService.updateMetadata(sessionMetadata);
+                signalProcessing(true);
+                sessionWasProcessing = true;
+                try {
+                  claudeProcess.kill("SIGTERM");
+                } catch {
+                }
               }
-              signalProcessing(true);
-              sessionWasProcessing = true;
             },
             onAbort: () => {
               logger.log(`[Session ${sessionId}] Abort requested`);
@@ -19844,6 +20061,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   isKillingClaude = false;
                   if (trackedSession?.stopped) return;
                   spawnClaude(void 0, { permissionMode: normalizedMode });
+                  if ((sessionMetadata.messageQueue?.length ?? 0) > 0 && !trackedSession?.stopped) {
+                    setTimeout(() => processMessageQueueRef?.(), 300);
+                  }
                 } finally {
                   isKillingClaude = false;
                   isSwitchingMode = false;
@@ -20107,11 +20327,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D7_Gj0Kt.mjs');
+              const { issueRpc } = await import('./rpc-Q4PWHeNn.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BVw8Tv9l.mjs');
+              const { workflowRpc } = await import('./rpc-C7uDtxFw.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -20257,12 +20477,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             try {
               if (!claudeProcess || claudeProcess.exitCode !== null) {
                 spawnClaude(next.text);
-              } else {
-                const stdinMsg = JSON.stringify({
-                  type: "user",
-                  message: { role: "user", content: next.text }
-                });
-                claudeProcess.stdin?.write(stdinMsg + "\n");
+              } else if (writeUserFrameToClaude(next.text)) {
                 if (claudeResumeId && !trackedSession?.stopped) {
                   saveSession({
                     sessionId,
@@ -20276,6 +20491,15 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     wasProcessing: true
                   });
                 }
+              } else {
+                logger.log(`[Session ${sessionId}] Claude stdin unwritable during queue drain \u2014 restoring head + respawning`);
+                sessionMetadata = { ...sessionMetadata, messageQueue: [next, ...remaining] };
+                sessionService.updateMetadata(sessionMetadata);
+                sessionWasProcessing = false;
+                try {
+                  claudeProcess.kill("SIGTERM");
+                } catch {
+                }
               }
             } catch (err) {
               logger.log(`[Session ${sessionId}] Error in processMessageQueue spawn: ${err.message}`);
@@ -20316,7 +20540,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             logger.log(`[Session ${sessionId}] re-kick skipped \u2014 loop is resource-limit-stalled; human must run \`loop --max N\``);
             return;
           }
-          if (s.active === false || s.phase === "done") {
+          if (s.active === false || s.phase === "done" || s.phase === "dormant") {
             try {
               const lp = join(getLoopDir(directory, sessionId), "loop-state.json");
               atomicWriteLoopState(lp, {
@@ -20326,6 +20550,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 iteration: 0,
                 completed_at: void 0,
                 gave_up_reason: void 0,
+                verify_errors: 0,
+                // fresh verification budget on re-arm
                 stall_hinted: false,
                 resumed_at: Date.now()
                 // #0156: re-arm the stall hint
@@ -20333,7 +20559,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             } catch {
             }
           }
-          logger.log(`[Session ${sessionId}] issue change \u2192 re-kicking loop (budget remaining)`);
+          logger.log(`[Session ${sessionId}] issue change \u2192 re-kicking loop (${s.phase === "dormant" ? "was dormant/armed" : "budget remaining"})`);
           enqueueLoopContinue();
           processMessageQueueRef?.();
         };
@@ -20781,11 +21007,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D7_Gj0Kt.mjs');
+              const { issueRpc } = await import('./rpc-Q4PWHeNn.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BVw8Tv9l.mjs');
+              const { workflowRpc } = await import('./rpc-C7uDtxFw.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -21129,7 +21355,9 @@ ${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 });
+              const killPhase = terminalPhaseForDone(resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd }));
+              writeGoalLoopState(directory, sessionId, { ...ls, active: killPhase === "dormant", phase: killPhase, completed_at: now, ledger, verify_errors: 0 });
+              if (killPhase === "dormant") sessionService.pushMessage({ type: "message", message: "\u{1F319} Backlog clear \u2014 loop is armed and watching for new issues." }, "event");
               checkSvampConfig?.();
               return;
             }
@@ -21171,15 +21399,48 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
                 logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
                 checkSvampConfig?.();
               }
+            } else if (result.action === "verify_error") {
+              const decision = decideVerifyErrorHandling({
+                priorErrors: ls.verify_errors,
+                maxRetries: resolveVerifyErrorRetries(process.env.SVAMP_LOOP_VERIFY_ERROR_RETRIES),
+                reason: result.reason
+              });
+              if (decision.action === "retry") {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", holds, started_at: startedAt, ledger, verify_errors: decision.attempt });
+                sessionService.pushMessage({ type: "message", message: `\u26A0\uFE0F Loop verification hit a transient error \u2014 ${decision.reason}`, level: "warning" }, "event");
+                dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. The independent completion check could not run (${result.reason}); keep working \u2014 it will be re-verified. Do NOT treat this as done.`, "\u26A0\uFE0F Re-verifying loop");
+              } else {
+                const parkPhase = terminalPhaseForDone(resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd }));
+                writeGoalLoopState(directory, sessionId, { ...ls, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), holds, ledger, verify_errors: 0 });
+                sessionService.pushMessage({ type: "message", message: parkPhase === "dormant" ? `\u{1F319} Loop parked (armed) after repeated verification errors \u2014 re-arms on new work. ${decision.reason}` : `\u26A0\uFE0F Loop stopped after repeated verification errors \u2014 ${decision.reason}`, level: "warning" }, "event");
+                checkSvampConfig?.();
+              }
             } else {
-              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger });
+              const donePhase = terminalPhaseForDone(resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd }));
+              if (donePhase === "dormant") {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "dormant", durable: true, completed_at: Date.now(), holds, ledger, verify_errors: 0 });
+                sessionService.pushMessage({ type: "message", message: "\u{1F319} Backlog clear \u2014 loop is armed and watching for new issues." }, "event");
+              } else {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger, verify_errors: 0 });
+              }
               checkSvampConfig?.();
             }
           } catch (e) {
-            logger.log(`[Session ${sessionId}] verifyAcpLoopCompletion error \u2014 failing open (done): ${e?.message || e}`);
+            logger.log(`[Session ${sessionId}] verifyAcpLoopCompletion error \u2014 failing closed (retry/park): ${e?.message || e}`);
             try {
-              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), ledger });
-              checkSvampConfig?.();
+              const decision = decideVerifyErrorHandling({
+                priorErrors: ls.verify_errors,
+                maxRetries: resolveVerifyErrorRetries(process.env.SVAMP_LOOP_VERIFY_ERROR_RETRIES),
+                reason: `verify threw: ${e?.message || e}`
+              });
+              if (decision.action === "retry") {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", holds, started_at: startedAt, ledger, verify_errors: decision.attempt });
+                dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. The completion check could not run; keep working \u2014 it will be re-verified. Not done.`, "\u26A0\uFE0F Re-verifying loop");
+              } else {
+                const parkPhase = terminalPhaseForDone(resolveLoopDurable({ durable: ls.durable, oracle: oracleCmd }));
+                writeGoalLoopState(directory, sessionId, { ...ls, active: parkPhase === "dormant", phase: parkPhase, completed_at: Date.now(), ledger, verify_errors: 0 });
+                checkSvampConfig?.();
+              }
             } catch {
             }
           } finally {
@@ -21743,7 +22004,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-zDzkOTi2.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-mM9Q6Q2G.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -21776,12 +22037,26 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
                 break;
               }
             }
+            const _loopArmed = !isOrphaned && isLoopArmedForSession(persisted.directory, persisted.sessionId);
             const _restoreAction = classifyRestoreContinuation({
               wasProcessing: !!persisted.wasProcessing,
               hasResumeId: !!persisted.claudeResumeId,
               isOrphaned: !!isOrphaned,
-              loopActive: isLoopActiveForSession(persisted.directory, persisted.sessionId)
+              loopActive: isLoopActiveForSession(persisted.directory, persisted.sessionId),
+              loopArmed: _loopArmed,
+              armedHasPendingWork: _loopArmed ? safeBacklogPendingCount(persisted.directory, persisted.sessionId) > 0 : false
             });
+            if (_loopArmed) {
+              logger.log(`[loop] Restored DORMANT loop for ${persisted.sessionId} \u2192 ${_restoreAction === "loop-resume" ? "re-arming (pending work found)" : "staying dormant/watching (backlog empty)"}`);
+              if (_restoreAction === "loop-resume") {
+                try {
+                  const lp = join(getLoopDir(persisted.directory, persisted.sessionId), "loop-state.json");
+                  const cur = readLoopState(persisted.directory, persisted.sessionId);
+                  if (cur) atomicWriteLoopState(lp, { ...cur, active: true, phase: "continue", completed_at: void 0, verify_errors: 0, resumed_at: Date.now() });
+                } catch {
+                }
+              }
+            }
             if (_restoreAction === "auto-continue") {
               sessionsToAutoContinue.push(persisted.sessionId);
             } else if (_restoreAction === "loop-resume") {
@@ -21899,18 +22174,44 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
             logger.log(`Session ${sessionId} RPC handlers not found for loop resume`);
             continue;
           }
+          const loopTurnFingerprint = () => {
+            try {
+              const s = readLoopState(sessDir, sessionId);
+              return `${s?.phase || ""}|${s?.holds || 0}|${s?.ledger?.turns || 0}`;
+            } catch {
+              return "";
+            }
+          };
+          const sendResume = async (tag) => {
+            const prompt = loopResumeMessage(sessDir, sessionId);
+            await rpc.sendMessage(
+              JSON.stringify({
+                role: "user",
+                content: { type: "text", text: prompt },
+                meta: { sentFrom: "svamp-daemon-loop-resume" }
+              })
+            );
+            logger.log(`Resumed loop for session ${sessionId}${tag}`);
+          };
           setTimeout(async () => {
             try {
               if (!isLoopActiveForSession(sessDir, sessionId)) return;
-              const prompt = loopResumeMessage(sessDir, sessionId);
-              await rpc.sendMessage(
-                JSON.stringify({
-                  role: "user",
-                  content: { type: "text", text: prompt },
-                  meta: { sentFrom: "svamp-daemon-loop-resume" }
-                })
-              );
-              logger.log(`Resumed loop for session ${sessionId}`);
+              const fpBefore = loopTurnFingerprint();
+              await sendResume("");
+              const graceMs = Math.max(5e3, Number(process.env.SVAMP_LOOP_RESUME_WATCHDOG_MS) || 45e3);
+              setTimeout(() => {
+                try {
+                  if (!isLoopActiveForSession(sessDir, sessionId)) return;
+                  const live = Array.from(pidToTrackedSession.values()).find((s) => s.svampSessionId === sessionId && !s.stopped);
+                  const lifecycle = live?.hyphaService?.getMetadata()?.lifecycleState;
+                  if (lifecycle && lifecycle !== "idle") return;
+                  if (loopTurnFingerprint() !== fpBefore) return;
+                  logger.log(`[loop] resume watchdog: session ${sessionId} loop still active but never advanced after ${graceMs}ms \u2014 re-issuing /goal once`);
+                  void sendResume(" (watchdog re-issue)").catch(() => {
+                  });
+                } catch {
+                }
+              }, graceMs);
             } catch (err) {
               logger.log(`Failed to resume loop for session ${sessionId}: ${err.message}`);
             }
@@ -21948,7 +22249,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-q7Refevo.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-B1xThM3A.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {