svamp-cli 0.2.342 → 0.2.346

package/dist/loopVerify-B47sSjxe.mjs

@@ -0,0 +1,444 @@
+import { n as normalizeAllowedUser } from './types-57J3Re0n.mjs';
+import { c as getSvampWebBaseUrl } from './instance-CeHz5C8v.mjs';
+import { l as listIssues, i as isPendingIssue, j as isVisibleTo } from './store-Bn0ByYev.mjs';
+
+function getShareBaseUrl() {
+  return getSvampWebBaseUrl();
+}
+function buildSessionShareUrl(input) {
+  const params = new URLSearchParams();
+  if (input.workspace) params.set("ws", input.workspace);
+  if (input.machineServiceId) params.set("svc", input.machineServiceId);
+  const query = params.toString();
+  return `${getShareBaseUrl()}/share/${input.sessionId}${query ? `?${query}` : ""}`;
+}
+function buildMachineShareUrl(input) {
+  const params = new URLSearchParams();
+  if (input.workspace) params.set("ws", input.workspace);
+  const query = params.toString();
+  return `${getShareBaseUrl()}/share/machine/${input.machineId}${query ? `?${query}` : ""}`;
+}
+const DAEMON_SHARE_EMAILS_ENV = "SVAMP_SHARE_EMAILS";
+function parseDaemonShareEmails(raw) {
+  if (!raw) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const part of raw.split(",")) {
+    const email = part.trim();
+    if (!email || !email.includes("@")) continue;
+    const k = email.toLowerCase();
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(email);
+  }
+  return out;
+}
+function applyDaemonShareSeed(sharing, seedEmails, ownerEmail) {
+  const base = sharing ? { ...sharing, allowedUsers: [...sharing.allowedUsers || []] } : { enabled: true, owner: ownerEmail || "", allowedUsers: [] };
+  base.enabled = true;
+  if (!base.owner && ownerEmail) base.owner = ownerEmail;
+  const existing = new Set(base.allowedUsers.map((u) => u.email.toLowerCase()));
+  const addedEmails = [];
+  for (const email of seedEmails) {
+    if (existing.has(email.toLowerCase())) continue;
+    base.allowedUsers.push(
+      normalizeAllowedUser({ email, addedBy: "daemon-share-flag" }, base.owner || "daemon-share-flag")
+    );
+    existing.add(email.toLowerCase());
+    addedEmails.push(email);
+  }
+  return { sharing: base, addedEmails };
+}
+
+const UNBOUNDED_LOOP_ITERATIONS = 1e6;
+function loopCancelledDuringVerify(current) {
+  return !!current && (current.phase === "cancelled" || current.active === false);
+}
+function backlogOraclePending(projectRoot, sessionId) {
+  const inScope = (i) => !sessionId || isVisibleTo(i, sessionId);
+  return listIssues(projectRoot).filter(inScope).filter(isPendingIssue).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 oracleScopeSessionId(oracle, selfSessionId) {
+  if (!oracle || typeof oracle !== "string") return void 0;
+  const explicit = /(^|\s)--session[=\s]+(\S+)/.exec(oracle);
+  if (explicit) return explicit[2];
+  if (/(^|\s)--mine(\s|$)/.test(oracle)) return selfSessionId;
+  return void 0;
+}
+function resolveLoopDurable(cfg) {
+  if (typeof cfg.durable === "boolean") return cfg.durable;
+  return isBacklogDrainerOracle(cfg.oracle);
+}
+function shouldRearmDormantLoop(s, pendingCount, sessionId) {
+  if (!s || s.phase !== "dormant") return false;
+  if (typeof s.session_id === "string" && sessionId && s.session_id !== sessionId) return false;
+  if (!isBacklogDrainerOracle(typeof s.oracle === "string" ? s.oracle : void 0)) return false;
+  return pendingCount > 0;
+}
+function issuesClosedSince(projectRoot, sinceMs) {
+  const all = listIssues(projectRoot, { includeArchived: true, status: "archived" });
+  if (!sinceMs || !Number.isFinite(sinceMs)) return all;
+  return all.filter((i) => {
+    if (!i.closed) return false;
+    const t = Date.parse(i.closed);
+    return Number.isFinite(t) && t >= sinceMs;
+  });
+}
+function issuesPausedNow(projectRoot, sessionId) {
+  const inScope = (i) => !sessionId || isVisibleTo(i, sessionId);
+  return listIssues(projectRoot, { status: "paused" }).filter(inScope);
+}
+function buildEvaluatorPrompt(o) {
+  const lines = [];
+  lines.push("You are an INDEPENDENT, skeptical reviewer. You did NOT write the code under review.");
+  lines.push('A self-verifying loop has just reported its work COMPLETE. Decide whether it is GENUINELY and COMPLETELY done. Default to "continue" on ANY doubt \u2014 a false "done" is far worse than one more iteration.');
+  lines.push("");
+  if (o.task) lines.push(`LOOP TASK / GOAL:
+${o.task.trim()}`);
+  if (o.until) lines.push(`DONE-WHEN CRITERIA:
+${o.until.trim()}`);
+  lines.push("");
+  lines.push("Use your tools (Read, Bash, Grep, Glob) to inspect the ACTUAL repository state \u2014 do NOT trust the transcript. Check the working tree, git log/diff, build/test output, and whether changes were actually built/published/deployed where the request implied it.");
+  lines.push('IMPORTANT \u2014 the loop oracle only counts OPEN (ready/in_progress) issues, so an issue removed from the queue without genuine resolution is invisible to it. Run `svamp issue list --all` (or read `.svamp/issues/`) and confirm NO issue tied to this goal was sidelined merely to make the queue look empty. A PAUSED issue is FINE if it is genuinely blocked on a user answer OR clearly delegated/handed to another session (crew child or a named peer) \u2014 do NOT penalize those. Reject "done" ONLY if goal-relevant work is neither genuinely complete, nor legitimately blocked on the user, nor handed to another session.');
+  if (o.pausedIssues && o.pausedIssues.length) {
+    lines.push("");
+    lines.push('ISSUES PAUSED (removed from the oracle \u2014 a pause is a BLOCK ONLY THE USER can clear). For EACH, decide if the pause is LEGITIMATE (a real question only the user can answer, or a clear delegation to another session) or GAMING (paused to dodge work: no reason, or a "question" the agent could and should have resolved itself). Reject "done" if ANY goal-relevant pause is gaming \u2014 the agent must resume and do the work, not park it:');
+    for (const i of o.pausedIssues.slice(0, 40)) {
+      const orig = (i.original || "").trim().replace(/\s+/g, " ").slice(0, 200);
+      const q = (i.question?.text || "").trim().replace(/\s+/g, " ").slice(0, 240);
+      lines.push(`  - #${i.id} ${i.title}${orig ? ` \u2014 original: "${orig}"` : ""} \u2014 pause reason: ${q ? `"${q}"` : "(NONE GIVEN \u2014 strong sign of gaming)"}`);
+    }
+  }
+  if (o.oracle) {
+    lines.push("");
+    lines.push(`The loop oracle is \`${o.oracle.trim()}\` and it currently PASSES${o.oracleOutput ? ` (output: ${o.oracleOutput.trim().slice(0, 400)})` : ""}. A green oracle here only means "no OPEN issues" \u2014 it does NOT mean each CLOSED issue actually works.`);
+  }
+  if (o.closedIssues.length) {
+    lines.push("");
+    lines.push("ISSUES CLOSED DURING THIS LOOP \u2014 verify EACH was genuinely resolved by the real change (not closed by self-assertion). Re-read the ORIGINAL request behind each, not just its title:");
+    for (const i of o.closedIssues.slice(0, 40)) {
+      const orig = (i.original || "").trim().replace(/\s+/g, " ").slice(0, 200);
+      const vtype = i.verify?.type ? ` [verify:${i.verify.type}]` : "";
+      lines.push(`  - #${i.id} ${i.title}${vtype}${orig ? ` \u2014 original: "${orig}"` : ""}`);
+    }
+    lines.push('Reject "done" if ANY closed issue was not genuinely resolved by the actual change.');
+  } else {
+    lines.push("");
+    lines.push("No issues were closed during this loop. Judge whether the task/criteria are genuinely met from the USER's perspective, end-to-end.");
+  }
+  lines.push("");
+  lines.push("Return ONLY a JSON object on the LAST line, nothing after it:");
+  lines.push('{"verdict":"done"|"continue","reason":"<concise>","guidance":"<what to fix if continue>"}');
+  return lines.join("\n");
+}
+function buildGoalCondition(o) {
+  const parts = [];
+  if (o.task) parts.push(o.task.trim());
+  if (o.until) parts.push(`Done when: ${o.until.trim()}.`);
+  if (o.oracle) parts.push(`Verify by running \`${o.oracle.trim()}\` at the end of every turn and pasting its output; it must succeed (exit 0 / no pending work).`);
+  if (!o.until && !o.oracle && o.task) parts.push("Done when the task is fully complete and you have shown the evidence that proves it.");
+  parts.push(`Or stop after ${o.maxIterations && o.maxIterations > 0 ? o.maxIterations : 20} turns.`);
+  if (o.inboxDrain !== false) {
+    parts.push("(\u{1F4EC} Inbox: at each turn, BRIEFLY run `svamp session inbox list` and handle anything relevant (reply/triage) before continuing \u2014 but do NOT derail the task to over-service ambient chatter. This drains queued non-urgent peer mail at loop pace; urgent/VIP already interrupt separately. It is NOT a completion criterion.)");
+  }
+  return parts.join(" ");
+}
+const HOUR_MS = 36e5;
+function sumUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") return 0;
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  return n(usage.input_tokens) + n(usage.output_tokens) + n(usage.cache_creation_input_tokens) + Math.round(n(usage.cache_read_input_tokens) * 0.1);
+}
+function accumulateLedger(prev, sample) {
+  const base = prev && typeof prev === "object" ? { turns: prev.turns || 0, tokens: prev.tokens || 0, window: Array.isArray(prev.window) ? prev.window : [] } : { turns: 0, tokens: 0, window: [] };
+  const addTurns = sample.turns > 0 ? sample.turns : 0;
+  const addTokens = sample.tokens > 0 ? sample.tokens : 0;
+  const window = [...base.window, [sample.ts, addTokens]].filter(([ts]) => sample.ts - ts < HOUR_MS);
+  return { turns: base.turns + addTurns, tokens: base.tokens + addTokens, window };
+}
+function tokensInLastHour(ledger, now) {
+  if (!ledger || !Array.isArray(ledger.window)) return 0;
+  return ledger.window.filter(([ts]) => now - ts < HOUR_MS).reduce((s, [, t]) => s + (t > 0 ? t : 0), 0);
+}
+function isCostCeiling(kind) {
+  return !!kind && kind !== "iteration";
+}
+function isHardBudgetStop(kind) {
+  return isCostCeiling(kind) || kind === "iteration";
+}
+function rearmStartedAt(startedAt, completedAt, now) {
+  const fin = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  if (!fin(startedAt)) return startedAt;
+  if (!fin(completedAt)) return startedAt;
+  if (completedAt < startedAt) return startedAt;
+  const dormantMs = now - completedAt;
+  if (dormantMs <= 0) return startedAt;
+  return startedAt + dormantMs;
+}
+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)`, 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)`, 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)`, 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)`, kind: "tokens_per_hour" };
+    }
+  }
+  return { exceeded: false };
+}
+function computeSoftTurnCap(hardMax, cadence) {
+  const c = Number.isFinite(cadence) && cadence >= 1 ? Math.floor(cadence) : 25;
+  if (!Number.isFinite(hardMax) || hardMax <= 0 || hardMax >= UNBOUNDED_LOOP_ITERATIONS) return c;
+  if (hardMax <= c) return Math.floor(hardMax);
+  const chunks = Math.ceil(hardMax / c);
+  return Math.ceil(hardMax / chunks);
+}
+const DEFAULT_LOOP_MAX_EXTENSIONS = 3;
+const DEFAULT_LOOP_EXTENSION_TURNS = 25;
+function resolveMaxExtensions(envValue) {
+  if (envValue == null || envValue.trim() === "") return DEFAULT_LOOP_MAX_EXTENSIONS;
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+  return DEFAULT_LOOP_MAX_EXTENSIONS;
+}
+function resolveExtensionTurns(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  return DEFAULT_LOOP_EXTENSION_TURNS;
+}
+function grantedExtensionCount(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (!Array.isArray(extensions)) return 0;
+  const cap = Number.isFinite(maxExtensions) && maxExtensions >= 0 ? Math.floor(maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  return Math.min(extensions.filter((e) => e && typeof e === "object").length, cap);
+}
+function extensionTurns(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (!Array.isArray(extensions)) return 0;
+  const cap = Number.isFinite(maxExtensions) && maxExtensions >= 0 ? Math.floor(maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  return extensions.slice(0, cap).reduce((s, e) => {
+    const g = e && Number.isFinite(e.grantedTurns) && e.grantedTurns > 0 ? Math.floor(e.grantedTurns) : 0;
+    return s + g;
+  }, 0);
+}
+function effectiveSoftCap(baseMax, extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  if (typeof baseMax !== "number" || !Number.isFinite(baseMax) || baseMax <= 0 || baseMax >= UNBOUNDED_LOOP_ITERATIONS) return baseMax;
+  return baseMax + extensionTurns(extensions, maxExtensions);
+}
+function grantLoopExtension(prior, o) {
+  const max = Number.isFinite(o.maxExtensions) && o.maxExtensions >= 0 ? Math.floor(o.maxExtensions) : DEFAULT_LOOP_MAX_EXTENSIONS;
+  const base = Array.isArray(prior) ? prior.filter((e) => e && typeof e === "object") : [];
+  if (base.length >= max) return { granted: false, used: base.length, max };
+  const extension = {
+    reason: (o.reason || "").trim().slice(0, 500) || "(no reason given)",
+    ts: o.ts,
+    grantedTurns: Number.isFinite(o.grantedTurns) && o.grantedTurns > 0 ? Math.floor(o.grantedTurns) : DEFAULT_LOOP_EXTENSION_TURNS
+  };
+  return { granted: true, extension, extensions: [...base, extension], used: base.length + 1, max };
+}
+function summarizeExtensions(extensions, maxExtensions = DEFAULT_LOOP_MAX_EXTENSIONS) {
+  const n = grantedExtensionCount(extensions, maxExtensions);
+  if (n === 0) return "";
+  const turns = extensionTurns(extensions, maxExtensions);
+  const reasons = extensions.slice(0, maxExtensions).map((e) => (e?.reason || "").trim()).filter(Boolean).join("; ").slice(0, 300);
+  return `${n} extension${n === 1 ? "" : "s"} granted (+${turns} turns)${reasons ? `: ${reasons}` : ""}`;
+}
+const DEFAULT_LOOP_STUCK_CHECKPOINTS = 3;
+const DEFAULT_LOOP_MAX_AUTORESUMES = 3;
+const PROGRESS_HISTORY_CAP = 12;
+function resolveStuckLimit(envValue) {
+  const n = Number(envValue);
+  if (Number.isFinite(n) && n >= 1) return Math.min(Math.floor(n), PROGRESS_HISTORY_CAP - 1);
+  return DEFAULT_LOOP_STUCK_CHECKPOINTS;
+}
+function resolveMaxAutoResumes(envValue) {
+  if (envValue == null || envValue.trim() === "") return DEFAULT_LOOP_MAX_AUTORESUMES;
+  const s = envValue.trim().toLowerCase();
+  if (s === "unbounded" || s === "inf" || s === "infinity" || s === "-1") return Number.POSITIVE_INFINITY;
+  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) {
+    const label = Number.isFinite(maxAutoResumes) ? `auto-resume ${autoResumes + 1}/${maxAutoResumes}` : `auto-resume ${autoResumes + 1} (unbounded \u2014 bounded only by the cost/iteration ceiling)`;
+    return { action: "continue", kind: "autoresume", consumeAutoResume: true, reason: `no progress across ${stuckCheckpoints} checkpoints \u2014 ${label}` };
+  }
+  const tail = `no progress across ${stuckCheckpoints} checkpoints; ${maxAutoResumes} auto-resume(s) exhausted`;
+  return { action: "stop", kind: "stuck", reason: input.stuckReason ? `${input.stuckReason} \u2014 ${tail}` : tail };
+}
+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;
+  const v = envValue.trim();
+  if (!v || v.toLowerCase() === "inherit" || v.toLowerCase() === "default") return void 0;
+  return v;
+}
+function parseEvaluatorVerdict(text) {
+  if (!text) return null;
+  const candidates = [];
+  const openStack = [];
+  let inStr = false, esc = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inStr) {
+      if (esc) {
+        esc = false;
+      } else if (c === "\\") {
+        esc = true;
+      } else if (c === '"') {
+        inStr = false;
+      }
+      continue;
+    }
+    if (c === '"') {
+      inStr = true;
+    } else if (c === "{") {
+      openStack.push(i);
+    } else if (c === "}") {
+      const open = openStack.pop();
+      if (open !== void 0) {
+        candidates.push(text.slice(open, i + 1));
+      }
+    }
+  }
+  for (let i = candidates.length - 1; i >= 0; i--) {
+    try {
+      const o = JSON.parse(candidates[i]);
+      if (o && (o.verdict === "done" || o.verdict === "continue")) {
+        return { verdict: o.verdict, reason: typeof o.reason === "string" ? o.reason : void 0, guidance: typeof o.guidance === "string" ? o.guidance : void 0 };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function buildStaleSafeOracleGuidance(oracleOutput, now = /* @__PURE__ */ new Date()) {
+  const reading = (oracleOutput || "").trim().slice(0, 500);
+  return [
+    `The loop oracle reported unfinished work as of ${now.toISOString()}:`,
+    reading || "(no detail)",
+    "",
+    "That is a POINT-IN-TIME reading, not a fact about right now \u2014 the backlog may have changed",
+    "since (an item can be closed or paused out-of-band while this message was queued). RE-RUN",
+    "the oracle yourself and treat ITS CURRENT OUTPUT as the truth. If it is now empty, the goal",
+    "is complete: say so rather than chasing the items listed above. Otherwise keep working until",
+    "it is genuinely empty."
+  ].join("\n");
+}
+async function runLoopVerification(cfg, deps) {
+  const log = deps.log || (() => {
+  });
+  const maxHolds = typeof cfg.maxHolds === "number" && cfg.maxHolds > 0 ? cfg.maxHolds : 3;
+  const holds = typeof cfg.holds === "number" && cfg.holds > 0 ? cfg.holds : 0;
+  let oracleOutput = "";
+  try {
+    const o = await deps.runOracle(cfg.oracle);
+    oracleOutput = o.output || "";
+    if (!o.ok) {
+      if (holds + 1 > maxHolds) {
+        return { action: "gave_up", reason: `oracle still reports pending work after ${holds} verification hold(s): ${oracleOutput.trim().slice(0, 200)}` };
+      }
+      log(`[loopVerify] oracle reports pending work \u2014 re-kicking instead of marking done`);
+      return {
+        action: "rekick",
+        reason: "oracle reports pending work",
+        guidance: buildStaleSafeOracleGuidance(oracleOutput)
+      };
+    }
+  } catch (e) {
+    log(`[loopVerify] oracle runner error (continuing to evaluator): ${e?.message || e}`);
+  }
+  const closed = issuesClosedSince(deps.projectRoot, cfg.startedAt);
+  const paused = issuesPausedNow(deps.projectRoot, cfg.sessionId);
+  const prompt = buildEvaluatorPrompt({ task: cfg.task, until: cfg.until, oracle: cfg.oracle, oracleOutput, closedIssues: closed, pausedIssues: paused });
+  let raw = "";
+  try {
+    raw = await deps.runEvaluator(prompt);
+  } catch (e) {
+    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 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}` : ""}`);
+    return { action: "done" };
+  }
+  if (holds + 1 > maxHolds) {
+    return { action: "gave_up", reason: `evaluator held "continue" past the limit (${maxHolds})${verdict.reason ? `: ${verdict.reason}` : ""}` };
+  }
+  const guidance = [verdict.reason ? `Independent reviewer says NOT done: ${verdict.reason}` : "Independent reviewer says NOT done.", verdict.guidance ? `Fix: ${verdict.guidance}` : ""].filter(Boolean).join("\n");
+  log(`[loopVerify] evaluator says continue \u2014 re-kicking (hold ${holds + 1}/${maxHolds})`);
+  return { action: "rekick", reason: verdict.reason || "evaluator says continue", guidance };
+}
+
+export { applyDaemonShareSeed as A, recordProgressMarker as B, assessLoopProgress as C, DAEMON_SHARE_EMAILS_ENV as D, resolveExtensionTurns as E, grantLoopExtension as F, buildGoalCondition as G, computeSoftTurnCap as H, UNBOUNDED_LOOP_ITERATIONS as U, buildMachineShareUrl as a, buildSessionShareUrl as b, backlogOraclePending as c, runLoopVerification as d, resolveLoopDurable as e, decideLoopContinuation as f, resolveMaxAutoResumes as g, grantedExtensionCount as h, resolveMaxExtensions as i, resolveStuckLimit as j, decideVerifyErrorHandling as k, loopCancelledDuringVerify as l, resolveVerifyErrorRetries as m, accumulateLedger as n, effectiveSoftCap as o, checkLoopBudget as p, isHardBudgetStop as q, resolveEvaluatorModel as r, sumUsageTokens as s, terminalPhaseForDone as t, isCostCeiling as u, summarizeExtensions as v, rearmStartedAt as w, oracleScopeSessionId as x, shouldRearmDormantLoop as y, parseDaemonShareEmails as z };