svamp-cli 0.2.246 → 0.2.248

package/dist/{run-BPZ_1RCI.mjs → run-CHIppB2r.mjs}

@@ -19,6 +19,7 @@ import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile, readdir, stat, readFile as readFile$1 } from 'node:fs/promises';
 import { promisify as promisify$1 } from 'node:util';
+import { parse, stringify } from 'yaml';
 
 let connectToServerFn = null;
 async function getConnectToServer() {
@@ -2984,6 +2985,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         if (!client) throw new Error(`Tunnel '${params.name}' not found`);
         client.destroy();
         tunnels.delete(params.name);
+        handlers.forgetExposedTunnel?.(params.name);
         return { name: params.name, stopped: true };
       },
       /**
@@ -2996,7 +2998,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-nvGz8fWs.mjs');
+        const { FrpcTunnel } = await import('./frpc-CsjEXBuS.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3447,7 +3449,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-C-0cCNeL.mjs');
+          const { toolsForRole } = await import('./sideband-Cs-kNLye.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3546,7 +3548,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-BhLGBhBS.mjs');
+    const { queryCore } = await import('./commands-C3TQOYUo.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -10920,6 +10922,438 @@ function summarize(issues) {
   return { total: issues.length, ready: by("ready"), in_progress: by("in_progress"), archived: by("archived") };
 }
 
+function isWorkflowEnabled(wf) {
+  return wf.enabled !== false;
+}
+function workflowSteps(wf) {
+  return Object.values(wf.jobs || {}).flatMap((j) => j?.steps || []);
+}
+function workflowCrons(wf) {
+  return (wf.on?.schedule || []).map((s) => s?.cron).filter((c) => !!c);
+}
+function workflowsDir(projectRoot) {
+  return join(projectRoot, ".svamp", "workflows");
+}
+function workflowPath(projectRoot, name) {
+  return join(workflowsDir(projectRoot), `${name}.yaml`);
+}
+function normalizeOn(on) {
+  if (!on || typeof on !== "object") {
+    return void 0;
+  }
+  const out = {};
+  if (Array.isArray(on.schedule)) {
+    const sched = on.schedule.map((s) => ({ cron: String(s?.cron ?? s ?? "") })).filter((s) => s.cron);
+    if (sched.length) out.schedule = sched;
+  } else if (typeof on.schedule === "string" && on.schedule.trim()) {
+    out.schedule = [{ cron: on.schedule.trim() }];
+  }
+  if ("workflow_dispatch" in on || on.dispatch === true) out.workflow_dispatch = true;
+  if (typeof on.channel === "string" && on.channel) out.channel = on.channel;
+  if (Array.isArray(on.issue) && on.issue.length) out.issue = on.issue.map(String);
+  if ("idle" in on && on.idle !== false || on.idle === true) out.idle = true;
+  return Object.keys(out).length ? out : void 0;
+}
+function normalizeJobs(jobs) {
+  if (Array.isArray(jobs)) {
+    const steps = jobs.map((j) => ({ run: String(j?.run ?? "") })).filter((s) => s.run);
+    return steps.length ? { run: { steps } } : {};
+  }
+  if (jobs && typeof jobs === "object") {
+    const out = {};
+    for (const [id, job] of Object.entries(jobs)) {
+      const rawSteps = Array.isArray(job?.steps) ? job.steps : job?.run ? [{ run: job.run }] : [];
+      const steps = rawSteps.map((s) => ({ run: String(s?.run ?? ""), ...s?.name ? { name: String(s.name) } : {} })).filter((s) => s.run);
+      if (steps.length) out[String(id)] = { steps };
+    }
+    return out;
+  }
+  return {};
+}
+function parseWorkflow(content) {
+  try {
+    const o = parse(content);
+    if (!o || typeof o !== "object" || !o.name) return null;
+    return {
+      name: String(o.name),
+      on: normalizeOn(o.on),
+      jobs: normalizeJobs(o.jobs),
+      session: o.session ?? null,
+      // Only `enabled: false` disables; anything else (absent/true) is active.
+      ...o.enabled === false ? { enabled: false } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function serializeWorkflow(wf) {
+  const clean = { name: wf.name };
+  if (wf.session) clean.session = wf.session;
+  if (wf.enabled === false) clean.enabled = false;
+  const on = {};
+  if (wf.on?.schedule?.length) on.schedule = wf.on.schedule.map((s) => ({ cron: s.cron }));
+  if (wf.on?.workflow_dispatch) on.workflow_dispatch = {};
+  if (wf.on?.channel) on.channel = wf.on.channel;
+  if (wf.on?.issue?.length) on.issue = wf.on.issue;
+  if (wf.on?.idle) on.idle = {};
+  if (Object.keys(on).length) clean.on = on;
+  const jobs = {};
+  for (const [id, job] of Object.entries(wf.jobs || {})) {
+    jobs[id] = { steps: (job.steps || []).map((s) => s.name ? { name: s.name, run: s.run } : { run: s.run }) };
+  }
+  clean.jobs = Object.keys(jobs).length ? jobs : { run: { steps: [] } };
+  return stringify(clean);
+}
+function listWorkflows(projectRoot) {
+  const dir = workflowsDir(projectRoot);
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".yaml") && !name.endsWith(".yml")) continue;
+    const p = join(dir, name);
+    try {
+      const wf = parseWorkflow(readFileSync(p, "utf-8"));
+      if (wf) {
+        try {
+          const st = statSync(p);
+          wf.created = new Date(st.birthtimeMs || st.mtimeMs).toISOString();
+        } catch {
+        }
+        out.push(wf);
+      }
+    } catch {
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getWorkflow(projectRoot, name) {
+  const p = workflowPath(projectRoot, name);
+  if (!existsSync(p)) return null;
+  try {
+    return parseWorkflow(readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function rawWorkflow(projectRoot, name) {
+  const p = workflowPath(projectRoot, name);
+  return existsSync(p) ? readFileSync(p, "utf-8") : null;
+}
+function saveWorkflow(projectRoot, wf) {
+  const dir = workflowsDir(projectRoot);
+  mkdirSync(dir, { recursive: true });
+  const path = workflowPath(projectRoot, wf.name);
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, serializeWorkflow(wf));
+  renameSync(tmp, path);
+}
+function setWorkflowEnabled(projectRoot, name, enabled) {
+  const wf = getWorkflow(projectRoot, name);
+  if (!wf) return null;
+  const next = { ...wf };
+  if (enabled) delete next.enabled;
+  else next.enabled = false;
+  saveWorkflow(projectRoot, next);
+  return next;
+}
+function removeWorkflow(projectRoot, name) {
+  const p = workflowPath(projectRoot, name);
+  if (!existsSync(p)) return false;
+  try {
+    unlinkSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const MAX_RUNS_PER_WORKFLOW = 50;
+function maxRunsPerWorkflow() {
+  const raw = Number(process.env.SVAMP_MAX_RUNS_PER_WORKFLOW);
+  if (Number.isFinite(raw) && raw > 0) return Math.min(Math.floor(raw), 5e3);
+  return MAX_RUNS_PER_WORKFLOW;
+}
+const MAX_STREAM_CHARS = 8e3;
+const STEP_TIMEOUT_MS = 12e4;
+function capStream(s, max = MAX_STREAM_CHARS) {
+  if (s.length <= max) return s;
+  const head = Math.floor(max * 0.6);
+  const tail = max - head;
+  const omitted = s.length - max;
+  return `${s.slice(0, head)}
+\u2026 [${omitted} chars omitted] \u2026
+${s.slice(s.length - tail)}`;
+}
+function runsDir(projectRoot) {
+  return join(workflowsDir(projectRoot), ".runs");
+}
+function runsFile(projectRoot, workflow) {
+  const safe = workflow.replace(/[^\w.-]+/g, "_");
+  return join(runsDir(projectRoot), `${safe}.jsonl`);
+}
+function shortRunId(seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(7, "0").slice(0, 7);
+}
+function recordRun(projectRoot, run) {
+  try {
+    const dir = runsDir(projectRoot);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const file = runsFile(projectRoot, run.workflow);
+    const existing = loadRuns(projectRoot, run.workflow);
+    const idx = existing.findIndex((r) => r.id === run.id);
+    if (idx >= 0) existing[idx] = run;
+    else existing.push(run);
+    const kept = existing.slice(-maxRunsPerWorkflow());
+    const tmp = `${file}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, kept.map((r) => JSON.stringify(r)).join("\n") + "\n");
+    renameSync(tmp, file);
+  } catch {
+  }
+}
+function loadRuns(projectRoot, workflow) {
+  try {
+    const file = runsFile(projectRoot, workflow);
+    if (!existsSync(file)) return [];
+    return readFileSync(file, "utf-8").split("\n").filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((r) => !!r);
+  } catch {
+    return [];
+  }
+}
+function listRuns(projectRoot, workflow, opts = {}) {
+  const o = typeof opts === "number" ? { limit: opts } : opts;
+  const all = loadRuns(projectRoot, workflow);
+  const total = all.length;
+  const newestFirst = all.slice().reverse();
+  const offset = Math.max(0, Math.floor(o.offset ?? 0));
+  const limit = o.limit != null && o.limit > 0 ? Math.floor(o.limit) : total;
+  const page = newestFirst.slice(offset, offset + limit).map((r) => {
+    const failedStep = r.steps.findIndex((s) => s.exitCode !== 0 && s.exitCode !== null || s.timedOut);
+    const { steps, ...rest } = r;
+    return { ...rest, stepCount: steps.length, failedStep: failedStep >= 0 ? failedStep : void 0 };
+  });
+  return { runs: page, total, offset, hasMore: offset + page.length < total };
+}
+function getRun(projectRoot, workflow, runId) {
+  return loadRuns(projectRoot, workflow).find((r) => r.id === runId) || null;
+}
+function defaultExecStep(root, cmd, env) {
+  return new Promise((resolve) => {
+    let stdout = "", stderr = "", timedOut = false, settled = false;
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      resolve({ exitCode, stdout, stderr, timedOut });
+    };
+    try {
+      const child = spawn("sh", ["-c", cmd], { cwd: root, env, stdio: ["ignore", "pipe", "pipe"] });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, STEP_TIMEOUT_MS);
+      child.stdout?.on("data", (d) => {
+        stdout += d.toString();
+        if (stdout.length > MAX_STREAM_CHARS * 4) stdout = capStream(stdout);
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+        if (stderr.length > MAX_STREAM_CHARS * 4) stderr = capStream(stderr);
+      });
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        stderr += `
+[spawn error] ${e.message}`;
+        finish(null);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        finish(code);
+      });
+    } catch (e) {
+      stderr += `[spawn threw] ${e?.message || e}`;
+      finish(null);
+    }
+  });
+}
+function escalateWorkflowFailure(projectRoot, wf, run) {
+  try {
+    if (process.env.SVAMP_WORKFLOW_ESCALATE === "0") return void 0;
+    const failLabel = `wf-fail:${wf.name}`;
+    const open = listIssues(projectRoot, { label: failLabel }).filter((i) => i.status !== "archived");
+    if (open.length > 0) return void 0;
+    const failed = run.steps.find((s) => s.timedOut || s.exitCode !== 0 && s.exitCode !== null) || run.steps[run.steps.length - 1];
+    const failCause = run.error ? `runner error: ${run.error}` : failed?.timedOut ? `step timed out after ${STEP_TIMEOUT_MS / 1e3}s` : `step exited with code ${failed?.exitCode ?? "null (killed/signal)"}`;
+    const defLines = workflowSteps(wf).map((s, i) => `  ${i}. ${s.run}`).join("\n") || "  (no steps)";
+    const stderrTail = failed?.stderr ? capStream(failed.stderr, 3e3) : "(none)";
+    const stdoutTail = failed?.stdout ? capStream(failed.stdout, 1500) : "(none)";
+    const body = [
+      `Workflow **${wf.name}** failed on its last run (${run.trigger} trigger${run.triggerContext ? ` \xB7 ${run.triggerContext}` : ""}). Diagnose the failure and **correct the workflow definition** so future runs succeed \u2014 edit it with \`svamp workflow\` (see \`svamp workflow --help\`), or pause/remove it if it's obsolete.`,
+      "",
+      "## Failure",
+      `- Cause: ${failCause}`,
+      `- Failed step: ${failed ? `#${failed.index} \u2014 \`${failed.cmd}\`` : "(unknown)"}`,
+      `- Run id: ${run.id}  \xB7  finished: ${run.finishedAt || "?"}`,
+      "",
+      "## Workflow definition",
+      "```",
+      `name: ${wf.name}`,
+      `steps:`,
+      defLines,
+      "```",
+      "",
+      "## Failed step stderr (tail)",
+      "```",
+      stderrTail,
+      "```",
+      "",
+      "## Failed step stdout (tail)",
+      "```",
+      stdoutTail,
+      "```"
+    ].join("\n");
+    const issue = addIssue(projectRoot, {
+      title: `Fix failing workflow "${wf.name}" (${failCause})`,
+      labels: ["workflow", "automation", "auto-escalated", failLabel],
+      verify: { type: "agent", text: `The workflow "${wf.name}" is corrected (or removed/paused) so it no longer fails with: ${failCause}` },
+      scope: wf.session ? "session" : "project",
+      session: wf.session ?? null,
+      triaged: true,
+      body
+    });
+    return issue.id;
+  } catch {
+    return void 0;
+  }
+}
+async function runWorkflow(projectRoot, wf, opts) {
+  const now = opts.now || (() => {
+    const d = /* @__PURE__ */ new Date();
+    return { iso: d.toISOString(), ms: d.getTime() };
+  });
+  const exec = opts.execStep || defaultExecStep;
+  const start = now();
+  const id = shortRunId(`${wf.name}:${start.iso}:${start.ms}`);
+  const env = wf.session ? { ...process.env, SVAMP_SESSION_ID: wf.session } : process.env;
+  const run = {
+    id,
+    workflow: wf.name,
+    trigger: opts.trigger,
+    triggerContext: opts.triggerContext,
+    actor: opts.actor ?? wf.session ?? null,
+    startedAt: start.iso,
+    status: "running",
+    steps: []
+  };
+  recordRun(projectRoot, run);
+  const steps = workflowSteps(wf);
+  try {
+    for (let i = 0; i < steps.length; i++) {
+      const s0 = now();
+      const r = await exec(projectRoot, steps[i].run, env);
+      const s1 = now();
+      run.steps.push({
+        index: i,
+        cmd: steps[i].run,
+        exitCode: r.exitCode,
+        stdout: capStream(r.stdout),
+        stderr: capStream(r.stderr),
+        durationMs: s1.ms - s0.ms,
+        timedOut: r.timedOut || void 0
+      });
+      if (r.timedOut || r.exitCode !== 0) {
+        run.status = "failed";
+        break;
+      }
+    }
+    if (run.status === "running") run.status = "success";
+  } catch (e) {
+    run.status = "failed";
+    run.error = e?.message || String(e);
+  }
+  const end = now();
+  run.finishedAt = end.iso;
+  run.durationMs = end.ms - start.ms;
+  if (run.status === "failed") {
+    const escalated = escalateWorkflowFailure(projectRoot, wf, run);
+    if (escalated) {
+      run.escalatedIssue = escalated;
+      opts.log?.(`[workflow] run ${id} "${wf.name}" failed \u2192 escalated to issue #${escalated}`);
+    }
+  }
+  recordRun(projectRoot, run);
+  opts.log?.(`[workflow] run ${id} "${wf.name}" \u2192 ${run.status} (${run.steps.length} step${run.steps.length === 1 ? "" : "s"})`);
+  return run;
+}
+
+const DEFAULT_IDLE_COOLDOWN_MS = 15e3;
+function idleCooldownMs() {
+  const raw = Number(process.env.SVAMP_WORKFLOW_IDLE_COOLDOWN_MS);
+  if (Number.isFinite(raw) && raw >= 0) return Math.floor(raw);
+  return DEFAULT_IDLE_COOLDOWN_MS;
+}
+function shouldFireIdle(prevActive, event, lastFireMs, now, cooldownMs) {
+  if (prevActive !== true) return false;
+  if (event.active !== false) return false;
+  if (lastFireMs != null && now - lastFireMs < cooldownMs) return false;
+  return true;
+}
+class IdleTriggerTracker {
+  constructor(cooldownMs = idleCooldownMs()) {
+    this.cooldownMs = cooldownMs;
+  }
+  prevActive = /* @__PURE__ */ new Map();
+  lastFire = /* @__PURE__ */ new Map();
+  observe(event, now) {
+    if (!event || event.type !== "activity" || !event.sessionId || typeof event.active !== "boolean") return false;
+    const sid = event.sessionId;
+    const fire = shouldFireIdle(this.prevActive.get(sid), event, this.lastFire.get(sid), now, this.cooldownMs);
+    this.prevActive.set(sid, event.active);
+    if (fire) this.lastFire.set(sid, now);
+    return fire;
+  }
+  /** Drop tracked state for a session (e.g. when it is archived/removed) so its memory is reclaimed. */
+  forget(sessionId) {
+    this.prevActive.delete(sessionId);
+    this.lastFire.delete(sessionId);
+  }
+}
+function fireIdleWorkflows(root, sessionId, deps = {}) {
+  let workflows;
+  try {
+    workflows = listWorkflows(root);
+  } catch {
+    return [];
+  }
+  const matches = workflows.filter((wf) => wf.on?.idle === true && isWorkflowEnabled(wf));
+  return matches.map((wf) => {
+    deps.log?.(`[workflow] idle fired "${wf.name}" in ${root} for session ${sessionId}`);
+    return runWorkflow(root, wf, {
+      trigger: "idle",
+      triggerContext: sessionId,
+      actor: wf.session || null,
+      execStep: deps.execStep,
+      now: deps.now,
+      log: deps.log
+    }).catch((e) => {
+      deps.log?.(`[workflow] idle run threw for "${wf.name}": ${e?.message || e}`);
+      return void 0;
+    });
+  });
+}
+
 const UNBOUNDED_LOOP_ITERATIONS = 1e6;
 function backlogOraclePending(projectRoot, sessionId) {
   const inScope = (i) => !sessionId || isVisibleTo(i, sessionId);
@@ -11010,30 +11444,84 @@ 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 isCostCeiling(kind) {
+  return !!kind && kind !== "iteration";
+}
 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) && L.max_iterations < UNBOUNDED_LOOP_ITERATIONS && led.turns >= L.max_iterations) {
-    return { exceeded: true, reason: `iteration budget reached (${led.turns}/${L.max_iterations} turns)` };
+    return { exceeded: true, reason: `iteration budget reached (${led.turns}/${L.max_iterations} turns)`, kind: "iteration" };
   }
   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)` };
+      return { exceeded: true, reason: `runtime budget reached (${Math.round(elapsed)}s/${L.max_runtime_sec}s)`, kind: "runtime" };
     }
   }
   if (pos(L.max_tokens) && led.tokens >= L.max_tokens) {
-    return { exceeded: true, reason: `token budget reached (${led.tokens}/${L.max_tokens} tokens)` };
+    return { exceeded: true, reason: `token budget reached (${led.tokens}/${L.max_tokens} tokens)`, kind: "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: true, reason: `token-rate budget reached (${rate}/${L.max_tokens_per_hour} tokens in the last hour)`, kind: "tokens_per_hour" };
     }
   }
   return { exceeded: false };
 }
+const DEFAULT_LOOP_STUCK_CHECKPOINTS = 3;
+const DEFAULT_LOOP_MAX_AUTORESUMES = 3;
+const PROGRESS_HISTORY_CAP = 12;
+function resolveStuckLimit(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  return DEFAULT_LOOP_STUCK_CHECKPOINTS;
+}
+function resolveMaxAutoResumes(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  return DEFAULT_LOOP_MAX_AUTORESUMES;
+}
+function recordProgressMarker(history, marker, cap = PROGRESS_HISTORY_CAP) {
+  const base = Array.isArray(history) ? history : [];
+  const next = [...base, marker];
+  return next.length > cap ? next.slice(next.length - cap) : next;
+}
+function assessLoopProgress(history, opts) {
+  const stuckLimit = opts && typeof opts.stuckLimit === "number" && opts.stuckLimit >= 1 ? Math.floor(opts.stuckLimit) : DEFAULT_LOOP_STUCK_CHECKPOINTS;
+  const h = (Array.isArray(history) ? history : []).filter((m) => m && typeof m.pending === "number" && Number.isFinite(m.pending));
+  if (h.length === 0) return { progressing: true, stuckCheckpoints: 0 };
+  let best = Infinity;
+  let stuck = 0;
+  for (const m of h) {
+    if (m.pending < best) {
+      best = m.pending;
+      stuck = 0;
+    } else {
+      stuck++;
+    }
+  }
+  return { progressing: stuck < stuckLimit, stuckCheckpoints: stuck };
+}
+function decideLoopContinuation(input) {
+  if (input.costCeilingBreached) {
+    return { action: "stop", kind: "cost", reason: input.costReason || "cost budget exhausted" };
+  }
+  const stuckLimit = typeof input.stuckLimit === "number" && input.stuckLimit >= 1 ? Math.floor(input.stuckLimit) : DEFAULT_LOOP_STUCK_CHECKPOINTS;
+  const maxAutoResumes = typeof input.maxAutoResumes === "number" && input.maxAutoResumes >= 0 ? Math.floor(input.maxAutoResumes) : DEFAULT_LOOP_MAX_AUTORESUMES;
+  const autoResumes = typeof input.autoResumes === "number" && input.autoResumes > 0 ? Math.floor(input.autoResumes) : 0;
+  const { progressing, stuckCheckpoints } = assessLoopProgress(input.progressHistory, { stuckLimit });
+  if (progressing) {
+    return { action: "continue", kind: "progress", consumeAutoResume: false, reason: `still making progress (${stuckCheckpoints}/${stuckLimit} stuck checkpoints)` };
+  }
+  if (autoResumes < maxAutoResumes) {
+    return { action: "continue", kind: "autoresume", consumeAutoResume: true, reason: `no progress across ${stuckCheckpoints} checkpoints \u2014 auto-resume ${autoResumes + 1}/${maxAutoResumes}` };
+  }
+  const tail = `no progress across ${stuckCheckpoints} checkpoints; ${maxAutoResumes} auto-resume(s) exhausted`;
+  return { action: "stop", kind: "stuck", reason: input.stuckReason ? `${input.stuckReason} \u2014 ${tail}` : tail };
+}
 const DEFAULT_LOOP_EVALUATOR_MODEL = "claude-haiku-4-5-20251001";
 function resolveEvaluatorModel(envValue) {
   if (envValue === void 0) return DEFAULT_LOOP_EVALUATOR_MODEL;
@@ -11852,6 +12340,30 @@ const SVAMP_HOME = process.env.SVAMP_HOME || join$1(os$1.homedir(), ".svamp");
 const DAEMON_STATE_FILE = join$1(SVAMP_HOME, "daemon.state.json");
 const DAEMON_LOCK_FILE = join$1(SVAMP_HOME, "daemon.lock");
 const DAEMON_STOP_MARKER_FILE = join$1(SVAMP_HOME, "daemon.stop");
+const PENDING_RESTART_FILE = join$1(SVAMP_HOME, "pending-restart.json");
+function writePendingRestart(p) {
+  try {
+    if (!existsSync$1(SVAMP_HOME)) mkdirSync$1(SVAMP_HOME, { recursive: true });
+    const rec = { scheduledAt: Date.now(), ...p };
+    writeFileSync$1(PENDING_RESTART_FILE, JSON.stringify(rec), "utf-8");
+  } catch {
+  }
+}
+function readPendingRestart() {
+  try {
+    if (!existsSync$1(PENDING_RESTART_FILE)) return null;
+    const rec = JSON.parse(readFileSync$1(PENDING_RESTART_FILE, "utf-8"));
+    return rec && typeof rec.scheduledAt === "number" ? rec : null;
+  } catch {
+    return null;
+  }
+}
+function clearPendingRestart() {
+  try {
+    if (existsSync$1(PENDING_RESTART_FILE)) unlinkSync$1(PENDING_RESTART_FILE);
+  } catch {
+  }
+}
 function writeStopMarker(reason) {
   try {
     writeFileSync$1(DAEMON_STOP_MARKER_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${reason}
@@ -11988,6 +12500,19 @@ function writeGoalLoopState(directory, sessionId, state) {
   } catch {
   }
 }
+function safeBacklogPendingCount(projectRoot, sessionId) {
+  try {
+    return backlogOraclePending(projectRoot, sessionId).length;
+  } catch {
+    return 0;
+  }
+}
+function updateLoopProgress(ls, pending, now) {
+  const progress_history = recordProgressMarker(ls?.progress_history, { ts: now, pending });
+  const madeProgress = assessLoopProgress(progress_history).stuckCheckpoints === 0;
+  const prev = typeof ls?.auto_resumes === "number" && ls.auto_resumes > 0 ? ls.auto_resumes : 0;
+  return { progress_history, auto_resumes: madeProgress ? 0 : prev };
+}
 function loopResumeMessage(directory, sessionId) {
   try {
     const ls = readLoopState(directory, sessionId);
@@ -12194,7 +12719,14 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       }
     }
     if (Array.isArray(config.session_links)) {
-      const links = config.session_links.filter((l) => l && typeof l.url === "string" && l.url.trim()).map((l) => ({ id: String(l.id || ""), label: String(l.label || "View"), url: String(l.url).trim(), ...l.icon ? { icon: String(l.icon) } : {} }));
+      const links = config.session_links.filter((l) => l && typeof l.url === "string" && l.url.trim()).map((l) => ({
+        id: String(l.id || ""),
+        label: String(l.label || "View"),
+        url: String(l.url).trim(),
+        ...l.icon ? { icon: String(l.icon) } : {},
+        // #0266: carry the service backing ({kind,name}) so the Launch Pad can decommission it.
+        ...l.service && typeof l.service.name === "string" && (l.service.kind === "tunnel" || l.service.kind === "process") ? { service: { kind: l.service.kind, name: String(l.service.name) } } : {}
+      }));
       const cur = meta.sessionLinks;
       if (JSON.stringify(cur || []) !== JSON.stringify(links)) {
         setMetadata((m) => ({ ...m, sessionLinks: links }));
@@ -12246,7 +12778,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
       const gaveUpCfg = readLoopJson(directory, sessionId, "loop.config.json") || {};
       const curMax = typeof gaveUpCfg.max_iterations === "number" ? gaveUpCfg.max_iterations : iter;
       const nextMax = Math.max(curMax * 2, iter + 10);
-      const msg = s.phase === "done" ? `\u{1F501} Loop complete \u2705 \u2014 finished after ${iter} iteration${plural}.` : `\u{1F501} Loop paused \u{1F6D1} \u2014 hit its iteration limit (${iter}/${curMax}) and did NOT finish${s.gave_up_reason ? ` (${s.gave_up_reason})` : ""}. Resume & extend with:  svamp session loop-resume ${sessionId} --max ${nextMax}`;
+      const msg = s.phase === "done" ? `\u{1F501} Loop complete \u2705 \u2014 finished after ${iter} iteration${plural}.` : `\u{1F501} Loop paused \u{1F6D1} \u2014 did NOT finish after ${iter} iteration${plural}${s.gave_up_reason ? ` (${s.gave_up_reason})` : ""}. Resume & extend with:  svamp session loop-resume ${sessionId} --max ${nextMax}`;
       sessionService.pushMessage(
         s.phase === "gave_up" ? { type: "message", message: msg, level: "warning" } : { type: "message", message: msg },
         "event"
@@ -12379,7 +12911,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
           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: [] } });
+        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 });
         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?.();
@@ -12827,8 +13359,30 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
+  async function reconcileTunnelSessionLinks(sessionId, tunnelName, urls) {
+    if (!sessionId || urls.size === 0) return;
+    try {
+      const dir = loadSessionIndex()[sessionId]?.directory;
+      if (!dir) return;
+      const { reconcileServiceLinks } = await import('./agentCommands-B_ozIVKT.mjs');
+      const configPath = getSvampConfigPath(dir, sessionId);
+      const config = readSvampConfig(configPath);
+      const entries = Array.from(urls.entries());
+      const incoming = entries.map(([port, url]) => ({
+        url: String(url),
+        label: entries.length > 1 ? `${tunnelName}:${port}` : tunnelName,
+        service: { kind: "tunnel", name: tunnelName }
+      }));
+      if (reconcileServiceLinks(config, incoming)) {
+        writeSvampConfig(configPath, config);
+        logger.log(`[exposed-tunnels] Reconciled Launch Pad link(s) for ${tunnelName} \u2192 session ${sessionId}`);
+      }
+    } catch (err) {
+      logger.log(`[exposed-tunnels] Link reconcile failed for ${tunnelName}: ${err?.message || err}`);
+    }
+  }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-nvGz8fWs.mjs');
+    const { FrpcTunnel } = await import('./frpc-CsjEXBuS.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -12848,7 +13402,7 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-DGRpRAFM.mjs');
+  const { ServeManager } = await import('./serveManager-Di3xrvG2.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -13053,6 +13607,22 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
       return taken;
     };
     let machineServiceRef = null;
+    const idleTriggerTracker = new IdleTriggerTracker();
+    const routeSessionEventForIdle = (update, dir) => {
+      try {
+        if (!update || update.type !== "activity") return;
+        if (!idleTriggerTracker.observe(update, Date.now())) return;
+        let root;
+        try {
+          root = resolveProjectRoot(dir);
+        } catch {
+          return;
+        }
+        fireIdleWorkflows(root, String(update.sessionId), { log: (m) => logger.log(m) });
+      } catch (e) {
+        logger.log(`[workflow] idle trigger error: ${e?.message || e}`);
+      }
+    };
     const spawnSession = async (options2) => {
       logger.log("Spawning session:", JSON.stringify(options2));
       const { directory, approvedNewDirectoryCreation = true, resumeSessionId } = options2;
@@ -13512,6 +14082,7 @@ ${parts.join("\n")}`);
             );
             const ledger = ls.ledger;
             const budget = ls.budget;
+            const progress_history = ls.progress_history;
             if (result.action === "rekick") {
               const cond = ls.task || "";
               writeGoalLoopState(directory, sessionId, {
@@ -13526,17 +14097,55 @@ ${parts.join("\n")}`);
                 budget,
                 started_at: startedAt,
                 holds: holds + 1,
-                ledger
+                ledger,
+                progress_history,
+                auto_resumes: ls.auto_resumes
               });
               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, ledger });
-              checkSvampConfig?.();
+              const decision = decideLoopContinuation({
+                costCeilingBreached: false,
+                progressHistory: progress_history || [],
+                stuckLimit: resolveStuckLimit(process.env.SVAMP_LOOP_STUCK_CHECKPOINTS),
+                autoResumes: typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0,
+                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES),
+                stuckReason: result.reason
+              });
+              if (decision.action === "continue") {
+                const cond = ls.task || "";
+                const nextAuto = (typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0) + (decision.consumeAutoResume ? 1 : 0);
+                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: nextAuto
+                });
+                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");
+                logger.log(`[Session ${sessionId}] [loop-persist] ${decision.kind}: ${decision.reason}`);
+                const push = decision.kind === "autoresume" ? `/goal ${cond} \u2014 AUTO-RESUME after an apparent stall (${decision.reason}). Re-verify the remaining work and PUSH IT TO COMPLETION; do not stop early. Prior reviewer note: ${result.reason}` : `/goal ${cond} \u2014 still making progress; KEEP GOING until genuinely done. Prior reviewer note: ${result.reason}`;
+                enqueueLoopMessage(push, label);
+                if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
+              } else {
+                writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger, progress_history, auto_resumes: ls.auto_resumes });
+                logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
+                checkSvampConfig?.();
+              }
             } else {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger });
+              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes });
               checkSvampConfig?.();
             }
           } catch (e) {
@@ -14005,22 +14614,28 @@ ${parts.join("\n")}`);
                         });
                         ls.ledger = ledger;
                         const startedAt = typeof ls.started_at === "number" ? ls.started_at : typeof ls.resumed_at === "number" ? ls.resumed_at : void 0;
-                        const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
-                        if (budgetCheck.exceeded) {
+                        const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+                        const pending = safeBacklogPendingCount(resolveProjectRoot(directory), sessionId);
+                        const prog = updateLoopProgress(ls, pending, now);
+                        ls.progress_history = prog.progress_history;
+                        ls.auto_resumes = prog.auto_resumes;
+                        if (budgetCheck.exceeded && isCostCeiling(budgetCheck.kind)) {
                           writeGoalLoopState(directory, sessionId, {
                             ...ls,
                             active: false,
                             phase: "gave_up",
                             completed_at: now,
                             gave_up_reason: `resource budget exhausted \u2014 ${budgetCheck.reason}`,
-                            ledger
+                            ledger,
+                            progress_history: prog.progress_history,
+                            auto_resumes: prog.auto_resumes
                           });
-                          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");
+                          sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${budgetCheck.reason} (hard cost ceiling \u2014 will not auto-resume). 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 });
+                          writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: now, ledger, progress_history: prog.progress_history, auto_resumes: prog.auto_resumes });
                         } else {
-                          writeGoalLoopState(directory, sessionId, { ...ls, ledger });
+                          writeGoalLoopState(directory, sessionId, { ...ls, ledger, progress_history: prog.progress_history, auto_resumes: prog.auto_resumes });
                           void verifyGoalCompletion(ls);
                         }
                       }
@@ -14873,11 +15488,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-s_Hibfpl.mjs');
+              const { issueRpc } = await import('./rpc-C1DI7HfZ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CDI7i151.mjs');
+              const { workflowRpc } = await import('./rpc-BGFgegj5.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -14956,7 +15571,10 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               return { success: !!tree, tree };
             }
           },
-          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => machineServiceRef?.notifySessionEvent(update) }
+          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => {
+            machineServiceRef?.notifySessionEvent(update);
+            routeSessionEventForIdle(update, directory);
+          } }
         );
         const svampConfig = createSvampConfigChecker(
           directory,
@@ -15410,11 +16028,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-s_Hibfpl.mjs');
+              const { issueRpc } = await import('./rpc-C1DI7HfZ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-CDI7i151.mjs');
+              const { workflowRpc } = await import('./rpc-BGFgegj5.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -15493,7 +16111,10 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               return { success: !!tree, tree };
             }
           },
-          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => machineServiceRef?.notifySessionEvent(update) }
+          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => {
+            machineServiceRef?.notifySessionEvent(update);
+            routeSessionEventForIdle(update, directory);
+          } }
         );
         let insideOnTurnEnd = false;
         const svampConfigChecker = createSvampConfigChecker(
@@ -15624,10 +16245,14 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             return { ok: pending.length === 0, output: pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues." };
           };
           try {
-            const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
-            if (budgetCheck.exceeded) {
+            const budgetCheck = process.env.SVAMP_LOOP_BUDGET === "0" ? { exceeded: false, kind: void 0 } : checkLoopBudget(ledger, { max_iterations: ls.max_iterations, ...ls.budget || {} }, now, startedAt);
+            const acpPending = safeBacklogPendingCount(projectRoot, sessionId);
+            const acpProg = updateLoopProgress(ls, acpPending, now);
+            ls.progress_history = acpProg.progress_history;
+            ls.auto_resumes = acpProg.auto_resumes;
+            if (budgetCheck.exceeded && isCostCeiling(budgetCheck.kind)) {
               writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "gave_up", completed_at: now, gave_up_reason: `resource budget exhausted \u2014 ${budgetCheck.reason}`, ledger });
-              sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${budgetCheck.reason}. Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
+              sessionService.pushMessage({ type: "message", message: `\u{1F6D1} Loop stopped \u2014 ${budgetCheck.reason} (hard cost ceiling \u2014 will not auto-resume). Resume & extend with:  svamp session loop-resume ${sessionId} --max <N>`, level: "warning" }, "event");
               checkSvampConfig?.();
               return;
             }
@@ -15659,8 +16284,26 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
               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?.();
+              const decision = decideLoopContinuation({
+                costCeilingBreached: false,
+                progressHistory: ls.progress_history || [],
+                stuckLimit: resolveStuckLimit(process.env.SVAMP_LOOP_STUCK_CHECKPOINTS),
+                autoResumes: typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0,
+                maxAutoResumes: resolveMaxAutoResumes(process.env.SVAMP_LOOP_MAX_AUTORESUMES),
+                stuckReason: result.reason
+              });
+              if (decision.action === "continue") {
+                const nextAuto = (typeof ls.auto_resumes === "number" ? ls.auto_resumes : 0) + (decision.consumeAutoResume ? 1 : 0);
+                writeGoalLoopState(directory, sessionId, { ...ls, active: true, phase: "continue", holds, started_at: startedAt, ledger, auto_resumes: nextAuto });
+                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");
+                logger.log(`[Session ${sessionId}] [loop-persist] ${decision.kind}: ${decision.reason}`);
+                dispatchAcpPrompt(`Continue toward the goal: ${ls.goal_task || ls.until || "the task"}. ${decision.kind === "autoresume" ? `AUTO-RESUME after an apparent stall (${decision.reason}) \u2014 re-verify the remaining work and PUSH IT TO COMPLETION.` : "Still making progress \u2014 KEEP GOING until genuinely done."} Prior reviewer note: ${result.reason}`, label);
+              } else {
+                writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger });
+                logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
+                checkSvampConfig?.();
+              }
             } else {
               writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger });
               checkSvampConfig?.();
@@ -16058,6 +16701,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
           const tunnel = await createExposedTunnel(spec);
           tunnels.set(spec.name, tunnel);
           logger.log(`[exposed-tunnels] Restored: ${spec.name} \u2192 ports ${spec.ports.join(",")}`);
+          if (spec.sessionId) await reconcileTunnelSessionLinks(spec.sessionId, spec.name, tunnel.getUrls());
         } catch (err) {
           logger.log(`[exposed-tunnels] Failed to restore ${spec.name}: ${err.message}`);
         }
@@ -16208,6 +16852,61 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       );
       logger.log(`Restored ${persistedSessions.length} session(s) in ${Date.now() - t0}ms (concurrency ${restoreConcurrency})`);
     }
+    {
+      const anySessionBusy = () => {
+        let n = 0;
+        for (const s of pidToTrackedSession.values()) {
+          if (s.stopped || !s.hyphaService) continue;
+          try {
+            if (s.hyphaService.getMetadata()?.lifecycleState === "running") n++;
+          } catch {
+          }
+        }
+        return { busy: n > 0, n };
+      };
+      const triggerSelfRestart = (why) => {
+        logger.log(`[graceful-restart] ${why} \u2014 restarting daemon now`);
+        clearPendingRestart();
+        try {
+          const supPidFile = join$1(SVAMP_HOME, "supervisor.pid");
+          const supPid = existsSync$1(supPidFile) ? parseInt(readFileSync$1(supPidFile, "utf-8").trim(), 10) : NaN;
+          if (supPid && !isNaN(supPid)) {
+            process.kill(supPid, "SIGUSR2");
+            return;
+          }
+        } catch {
+        }
+        logger.log("[graceful-restart] no supervisor to signal \u2014 exiting for KeepAlive respawn");
+        process.exit(0);
+      };
+      let lastDeferLog = 0;
+      const GRACEFUL_RESTART_POLL_MS = 15e3;
+      const DEFAULT_MAX_WAIT_MS = 60 * 60 * 1e3;
+      const gracefulTimer = setInterval(() => {
+        const pending = readPendingRestart();
+        if (!pending) return;
+        if (pending.force) {
+          triggerSelfRestart("force requested");
+          return;
+        }
+        const { busy, n } = anySessionBusy();
+        if (!busy) {
+          triggerSelfRestart("all sessions idle");
+          return;
+        }
+        const maxWait = typeof pending.maxWaitMs === "number" && pending.maxWaitMs > 0 ? pending.maxWaitMs : DEFAULT_MAX_WAIT_MS;
+        if (Date.now() - pending.scheduledAt > maxWait) {
+          triggerSelfRestart(`max-wait ${Math.round(maxWait / 6e4)}m elapsed (${n} still busy)`);
+          return;
+        }
+        const now = Date.now();
+        if (now - lastDeferLog > 6e4) {
+          lastDeferLog = now;
+          logger.log(`[graceful-restart] deferring \u2014 ${n} session(s) actively thinking`);
+        }
+      }, GRACEFUL_RESTART_POLL_MS);
+      gracefulTimer.unref?.();
+    }
     if (sessionsToAutoContinue.length > 0 && !options?.noAutoContinue) {
       logger.log(`Auto-continuing ${sessionsToAutoContinue.length} interrupted session(s)...`);
       for (const sessionId of sessionsToAutoContinue) {
@@ -16291,7 +16990,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-E1Bw4HUY.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-Csp21zzg.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -16861,13 +17560,18 @@ function daemonStatus() {
 var run = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DAEMON_STOP_MARKER_FILE: DAEMON_STOP_MARKER_FILE,
+    PENDING_RESTART_FILE: PENDING_RESTART_FILE,
+    clearPendingRestart: clearPendingRestart,
     clearStopMarker: clearStopMarker,
     daemonStatus: daemonStatus,
+    isDaemonAlive: isDaemonAlive,
+    readPendingRestart: readPendingRestart,
     restartDaemon: restartDaemon,
     startDaemon: startDaemon,
     stopDaemon: stopDaemon,
     stopMarkerExists: stopMarkerExists,
+    writePendingRestart: writePendingRestart,
     writeStopMarker: writeStopMarker
 });
 
-export { buildMachineShareUrl as $, shortId as A, loadMachineContext as B, buildMachineInstructions as C, machineToolsForRole as D, buildMachineTools as E, parseFrontmatter as F, getSkillsServer as G, getSkillsWorkspaceName as H, getSkillsCollectionName as I, fetchWithTimeout as J, searchSkills as K, SKILLS_DIR as L, getSkillInfo as M, downloadSkillFile as N, listSkillFiles as O, resolveModel as P, formatHandle as Q, READ_ONLY_TOOLS as R, ServeAuth as S, normalizeAllowedUser as T, loadSecurityContextConfig as U, resolveSecurityContext as V, buildSecurityContextFromFlags as W, mergeSecurityContexts as X, buildSessionShareUrl as Y, computeOutboundHop as Z, registerAwaitingReply as _, createSessionStore as a, parseHandle as a0, handleMatchesMetadata as a1, describeMisconfiguration as a2, buildMachineDeps as a3, applyClaudeProxyEnv as a4, composeSessionId as a5, generateFriendlyName as a6, generateHookSettings as a7, claudeAuth as a8, projectInfo as a9, DefaultTransport$1 as aa, acpBackend as ab, acpAgentConfig as ac, codexMcpBackend as ad, GeminiTransport$1 as ae, instanceConfig as af, api as ag, run as ah, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, getHyphaServerUrl as k, hasCookieToken as l, resolveProjectRoot as m, getIssue as n, resumeIssue as o, pauseIssue as p, addComment as q, registerMachineService as r, startDaemon as s, addIssue as t, updateIssue as u, listIssues as v, searchIssues as w, isVisibleTo as x, cronMatches as y, summarize as z };
+export { downloadSkillFile as $, listRuns as A, getWorkflow as B, runWorkflow as C, setWorkflowEnabled as D, removeWorkflow as E, saveWorkflow as F, rawWorkflow as G, listWorkflows as H, isWorkflowEnabled as I, workflowCrons as J, cronMatches as K, summarize as L, workflowSteps as M, loadMachineContext as N, buildMachineInstructions as O, machineToolsForRole as P, buildMachineTools as Q, READ_ONLY_TOOLS as R, ServeAuth as S, parseFrontmatter as T, getSkillsServer as U, getSkillsWorkspaceName as V, getSkillsCollectionName as W, fetchWithTimeout as X, searchSkills as Y, SKILLS_DIR as Z, getSkillInfo as _, createSessionStore as a, listSkillFiles as a0, resolveModel as a1, formatHandle as a2, normalizeAllowedUser as a3, loadSecurityContextConfig as a4, resolveSecurityContext as a5, buildSecurityContextFromFlags as a6, mergeSecurityContexts as a7, buildSessionShareUrl as a8, computeOutboundHop as a9, registerAwaitingReply as aa, buildMachineShareUrl as ab, parseHandle as ac, handleMatchesMetadata as ad, describeMisconfiguration as ae, buildMachineDeps as af, applyClaudeProxyEnv as ag, composeSessionId as ah, generateFriendlyName as ai, generateHookSettings as aj, claudeAuth as ak, projectInfo as al, DefaultTransport$1 as am, acpBackend as an, acpAgentConfig as ao, codexMcpBackend as ap, GeminiTransport$1 as aq, instanceConfig as ar, api as as, run as at, stopDaemon as b, connectToHypha as c, daemonStatus as d, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, shortId as k, getHyphaServerUrl as l, hasCookieToken as m, resolveProjectRoot as n, getIssue as o, resumeIssue as p, pauseIssue as q, registerMachineService as r, startDaemon as s, addComment as t, updateIssue as u, addIssue as v, listIssues as w, searchIssues as x, isVisibleTo as y, getRun as z };