@bybrawe/opencode-loop 0.5.36 → 0.5.38

package/src/index.js

@@ -926,9 +926,9 @@ function loopOwnedUserMessageGuardActive(sessionID, messageID) {
   const entry = loopOwnedUserMessageGuards.get(sessionID);
   if (!entry || typeof entry !== "object")
     return false;
-  for (const [id2, expiresAt] of entry.messageIDs.entries())
+  for (const [id, expiresAt] of entry.messageIDs.entries())
     if (expiresAt < now())
-      entry.messageIDs.delete(id2);
+      entry.messageIDs.delete(id);
   const id = typeof messageID === "string" ? messageID : "";
   if (id && entry.messageIDs.has(id))
     return true;
@@ -1086,6 +1086,19 @@ var NEXT_WORK_PATTERNS = [
   /\bremaining (?:work|task|todo|step)/i,
   /devam (?:edece\u011Fim|ediyorum|etmek gerek)(?=\s|[.,;:!\u2014-]|$)/i
 ];
+var WAITING_USER_PATTERNS = [
+  /(?:^|\n)\s*onay bekleyenler\s*:/i,
+  /(?:^|\n)\s*(?:kullan\u0131c\u0131|user) (?:onay\u0131|onayi|aksiyonu|i\u015Flemi|islemi|eri\u015Fimi|erisimi) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:senin|sizin) (?:onay\u0131n|onay\u0131n\u0131z|onayiniz|aksiyonun|aksiyonunuz|eri\u015Fimin|erisimin) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:onay|eri\u015Fim|erisim|yetki) olmadan (?:devam edemem|ilerleyemem|i\u015Flem yapamam|islem yapamam)\b/i,
+  /(?:^|\n)\s*(?:waiting (?:for|on) (?:your|user) (?:approval|input|action|access|credentials?)|(?:approval|user action|access) (?:required|pending))\s*:?/i,
+  /\b(?:requires?|needs?) (?:your|user) (?:approval|input|action|access|credentials?)\b/i,
+  /\bblocked (?:pending|until|on) (?:your|user|approval|access|credentials?)\b/i
+];
+var WAITING_USER_NEGATIONS = [
+  /\b(?:onay|eri\u015Fim|erisim|yetki) (?:gerekmiyor|gerekli de\u011Fil|gerekli degil|beklenmiyor)\b/i,
+  /\bno (?:user )?(?:approval|input|action|access|credentials?) (?:is )?(?:needed|required|pending)\b/i
+];
 function isContinuationShorthand(value) {
   return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "));
 }
@@ -1093,6 +1106,16 @@ function isCompletionBoundedContinuation(value) {
   const text = String(value || "").trim();
   return COMPLETION_BOUNDED_PATTERNS.some((pattern) => pattern.test(text));
 }
+function isWaitingUserReply(value) {
+  const text = String(value || "").trim();
+  if (!text)
+    return false;
+  if (WAITING_USER_NEGATIONS.some((pattern) => pattern.test(text)))
+    return false;
+  if (NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text)))
+    return false;
+  return WAITING_USER_PATTERNS.some((pattern) => pattern.test(text));
+}
 function isTerminalNoWorkReply(value) {
   const text = String(value || "").trim();
   if (!text || NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text)))
@@ -1617,8 +1640,8 @@ function createGoalCommandHandlers(options = {}) {
   const addLoop = requireFunction2(options.addLoop, "addLoop");
   const scheduleDueWork = requireFunction2(options.scheduleDueWork, "scheduleDueWork");
   const scheduleIdleWork = requireFunction2(options.scheduleIdleWork, "scheduleIdleWork");
-  const toast2 = requireFunction2(options.toast, "toast");
-  const say2 = requireFunction2(options.say, "say");
+  const toast = requireFunction2(options.toast, "toast");
+  const say = requireFunction2(options.say, "say");
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
   const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
   const setGoalComplete2 = typeof options.setGoalComplete === "function" ? options.setGoalComplete : setGoalComplete;
@@ -1635,8 +1658,8 @@ function createGoalCommandHandlers(options = {}) {
       const rejected = job.goalCompletionRejectedReason ? " | completion-rejected" : "";
       return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${status} | turns=${job.runCount || 0} | objective=${String(job.action || job.goalFile || "").slice(0, 220)}${checks}${acceptance}${progress}${noProgress}${rejected}`;
     }) : ["No experimental goal jobs."];
-    await toast2(client, goals.length ? `${goals.length} experimental goal(s).` : "No experimental goal jobs.", goals.length ? "info" : "warning");
-    await say2(client, sessionID, `OpenCode Loop experimental goal status:
+    await toast(client, goals.length ? `${goals.length} experimental goal(s).` : "No experimental goal jobs.", goals.length ? "info" : "warning");
+    await say(client, sessionID, `OpenCode Loop experimental goal status:
 ` + lines.join(`
 `));
   }
@@ -1647,7 +1670,7 @@ function createGoalCommandHandlers(options = {}) {
     state.jobs = (state.jobs || []).map((job, index) => isGoalJob(job) && matchJob(job, target, index) ? (count++, { ...job, paused: true }) : job);
     await writeState2(directory, sessionID, state);
     await scheduleDueWork(directory, client, sessionID);
-    await toast2(client, `Paused ${count} experimental goal(s).`, count ? "success" : "warning");
+    await toast(client, `Paused ${count} experimental goal(s).`, count ? "success" : "warning");
   }
   async function resumeGoal(directory, client, sessionID, args) {
     const target = String(args || "").trim() || "goal";
@@ -1660,7 +1683,7 @@ function createGoalCommandHandlers(options = {}) {
       return { ...job, paused: false, enabled: true, goalStatus: job.goalStatus === "blocked" ? "active" : job.goalStatus || "active", lastRunAt: 0, noProgressCount: 0, goalNoProgressReason: "", goalInterruptedReason: "" };
     });
     await writeState2(directory, sessionID, state);
-    await toast2(client, `Resumed ${count} experimental goal(s).`, count ? "success" : "warning");
+    await toast(client, `Resumed ${count} experimental goal(s).`, count ? "success" : "warning");
     if (count) {
       await scheduleDueWork(directory, client, sessionID);
       scheduleIdleWork(directory, client, sessionID);
@@ -1673,15 +1696,15 @@ function createGoalCommandHandlers(options = {}) {
     state.jobs = (state.jobs || []).filter((job, index) => !isGoalJob(job) || target && !matchJob(job, target, index));
     await writeState2(directory, sessionID, state);
     await scheduleDueWork(directory, client, sessionID);
-    await toast2(client, `Cleared ${before - state.jobs.length} experimental goal(s).`, before !== state.jobs.length ? "success" : "warning");
+    await toast(client, `Cleared ${before - state.jobs.length} experimental goal(s).`, before !== state.jobs.length ? "success" : "warning");
   }
   async function completeGoalCommand(directory, client, sessionID, args) {
     const result = await setGoalComplete2(directory, sessionID, { summary: String(args || "").trim() || "Goal manually marked complete.", evidence: "Marked complete by /loop-goal-done.", manual: true });
-    await toast2(client, result.message, result.ok ? "success" : "warning");
+    await toast(client, result.message, result.ok ? "success" : "warning");
   }
   async function blockGoalCommand(directory, client, sessionID, args) {
     const result = await setGoalBlocked2(directory, sessionID, { reason: String(args || "").trim() || "Goal manually marked blocked.", needed: "User input or manual intervention." });
-    await toast2(client, result.message, "warning");
+    await toast(client, result.message, "warning");
   }
   async function addGoal(directory, client, sessionID, args) {
     const text = String(args || "").trim();
@@ -1930,8 +1953,8 @@ function createLoopCommandHandlers(options = {}) {
   const stopWatchdog = requireFunction3(options.stopWatchdog, "stopWatchdog");
   const scheduleDueWork = requireFunction3(options.scheduleDueWork, "scheduleDueWork");
   const maybeRunDueJobs = requireFunction3(options.maybeRunDueJobs, "maybeRunDueJobs");
-  const toast2 = requireFunction3(options.toast, "toast");
-  const say2 = requireFunction3(options.say, "say");
+  const toast = requireFunction3(options.toast, "toast");
+  const say = requireFunction3(options.say, "say");
   const now2 = typeof options.now === "function" ? options.now : now;
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
   const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
@@ -1951,7 +1974,7 @@ function createLoopCommandHandlers(options = {}) {
       clearActiveRun(sessionID);
       cancelDueWork(sessionID);
       stopWatchdog(sessionID);
-      await toast2(client, "All loops stopped for this session.", "success");
+      await toast(client, "All loops stopped for this session.", "success");
       return;
     }
     const state = await readState2(directory, sessionID);
@@ -1959,7 +1982,7 @@ function createLoopCommandHandlers(options = {}) {
     state.jobs = state.jobs.filter((job, index) => !matchJob(job, target, index));
     await writeState2(directory, sessionID, state);
     await scheduleDueWork(directory, client, sessionID);
-    await toast2(client, `Stopped ${before - state.jobs.length} loop(s).`, "success");
+    await toast(client, `Stopped ${before - state.jobs.length} loop(s).`, "success");
   }
   async function updateJobState(directory, client, sessionID, args, updater, message) {
     const target = String(args || "").trim() || "all";
@@ -1968,7 +1991,7 @@ function createLoopCommandHandlers(options = {}) {
     state.jobs = (state.jobs || []).map((job, index) => matchJob(job, target, index) ? (count++, updater(job)) : job);
     await writeState2(directory, sessionID, state);
     await scheduleDueWork(directory, client, sessionID);
-    await toast2(client, `${message}: ${count} loop(s).`, count ? "success" : "warning");
+    await toast(client, `${message}: ${count} loop(s).`, count ? "success" : "warning");
   }
   async function statusLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
@@ -1979,8 +2002,8 @@ function createLoopCommandHandlers(options = {}) {
       const flags = [isGoalJob(job) ? `goal:${goalStatusText(job)}` : undefined, job.paused ? "paused" : "active", Number(job.runNowRequestedAt || 0) > 0 ? "run-now" : undefined, job.safe ? "safe" : undefined, job.askNever ? "ask-never" : undefined, job.noOverlap ? "no-overlap" : undefined, job.checkpointOnly ? "checkpoint-only" : undefined, job.gitCheckpoint ? "git-checkpoint" : undefined].filter(Boolean).join(",");
       return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${jobLabel(job)} | schedule=${scheduling.schedule} | state=${scheduling.state} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | ${flags}`;
     }) : ["No active loop jobs."];
-    await toast2(client, jobs.length ? `${jobs.length} loop job(s).` : "No active loop jobs.", jobs.length ? "info" : "warning");
-    await say2(client, sessionID, `OpenCode loop status:
+    await toast(client, jobs.length ? `${jobs.length} loop job(s).` : "No active loop jobs.", jobs.length ? "info" : "warning");
+    await say(client, sessionID, `OpenCode loop status:
 ` + lines.join(`
 `));
   }
@@ -1990,11 +2013,11 @@ function createLoopCommandHandlers(options = {}) {
       text = (await readFile(path7.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join(`
 `) || text;
     } catch {}
-    await say2(client, sessionID, `OpenCode loop logs:
+    await say(client, sessionID, `OpenCode loop logs:
 ` + text);
   }
   async function helpLoop(client, sessionID) {
-    await say2(client, sessionID, [
+    await say(client, sessionID, [
       "OpenCode Loop help:",
       "/loop continue the project                           auto-continue forever whenever the session becomes idle",
       "/loop idle continue the project                      explicit form of the same idle loop",
@@ -2028,7 +2051,7 @@ function createLoopCommandHandlers(options = {}) {
       count += 1;
     }
     await writeState2(directory, sessionID, state);
-    await toast2(client, `Marked ${count} loop job(s) due now.`, count ? "success" : "warning");
+    await toast(client, `Marked ${count} loop job(s) due now.`, count ? "success" : "warning");
     if (count)
       await scheduleDueWork(directory, client, sessionID);
   }
@@ -2058,23 +2081,23 @@ function createLoopCommandHandlers(options = {}) {
     }
     if (otherSessions.length > 8)
       lines.push(`- ... ${otherSessions.length - 8} more persisted session(s)`);
-    await say2(client, sessionID, lines.join(`
+    await say(client, sessionID, lines.join(`
 `));
   }
   async function initLoop(directory, client, sessionID, args) {
     const target = String(args || "").trim() || "progress.md";
     const full = path7.resolve(directory, target);
     if (await pathExists2(full)) {
-      await toast2(client, `${target} already exists.`, "warning");
+      await toast(client, `${target} already exists.`, "warning");
       return;
     }
     await writeFile(full, DEFAULT_PROGRESS_MD, "utf8");
-    await toast2(client, `Created ${target}.`, "success");
+    await toast(client, `Created ${target}.`, "success");
     await appendLoopLog2(directory, "init", { sessionID, file: target });
   }
   async function exportLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
-    await say2(client, sessionID, "OpenCode loop state export:\n```json\n" + JSON.stringify(state, null, 2) + "\n```");
+    await say(client, sessionID, "OpenCode loop state export:\n```json\n" + JSON.stringify(state, null, 2) + "\n```");
   }
   return {
     stopLoop,
@@ -2184,8 +2207,8 @@ function createLoopRegistration(options = {}) {
   const snapshotPaths = requireFunction4(options.snapshotPaths, "snapshotPaths");
   const scheduleDueWork = requireFunction4(options.scheduleDueWork, "scheduleDueWork");
   const scheduleIdleWork = requireFunction4(options.scheduleIdleWork, "scheduleIdleWork");
-  const toast2 = requireFunction4(options.toast, "toast");
-  const say2 = requireFunction4(options.say, "say");
+  const toast = requireFunction4(options.toast, "toast");
+  const say = requireFunction4(options.say, "say");
   const parseLoopArgs2 = typeof options.parseLoopArgs === "function" ? options.parseLoopArgs : parseLoopArgs;
   const normalizeLoopScheduleArgs2 = typeof options.normalizeLoopScheduleArgs === "function" ? options.normalizeLoopScheduleArgs : normalizeLoopScheduleArgs;
   const readState2 = typeof options.readState === "function" ? options.readState : readState;
@@ -2199,12 +2222,12 @@ function createLoopRegistration(options = {}) {
   async function addLoop(directory, client, sessionID, args, defaults = {}) {
     const normalized = normalizeLoopScheduleArgs2(args, defaults);
     if (!normalized.ok) {
-      await toast2(client, normalized.error, "warning");
+      await toast(client, normalized.error, "warning");
       return;
     }
     const parsed = parseLoopArgs2(normalized.args, normalized.defaults);
     if (!parsed.ok) {
-      await toast2(client, parsed.error, "warning");
+      await toast(client, parsed.error, "warning");
       return;
     }
     parsed.job.scheduleMode = normalized.scheduleMode;
@@ -2243,13 +2266,13 @@ function createLoopRegistration(options = {}) {
           job: parsed.job.name || parsed.job.id,
           goal: dedicatedGoal.id
         });
-        await toast2(client, "Prompt loop not added: dedicated /goal already owns continuation in this session. Pause/finish the Goal, use another session, or pass --allow-goal-overlap intentionally.", "warning");
+        await toast(client, "Prompt loop not added: dedicated /goal already owns continuation in this session. Pause/finish the Goal, use another session, or pass --allow-goal-overlap intentionally.", "warning");
         return;
       }
     }
     if (parsed.job.dryRun) {
-      await toast2(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info");
-      await say2(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```");
+      await toast(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info");
+      await say(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```");
       return;
     }
     const state = await readState2(directory, sessionID);
@@ -2273,7 +2296,7 @@ function createLoopRegistration(options = {}) {
     await scheduleDueWork(directory, client, sessionID);
     if (parsed.job.immediate)
       scheduleIdleWork(directory, client, sessionID);
-    await toast2(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success");
+    await toast(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success");
     await appendLoopLog2(directory, replaced ? "replace" : "add", {
       sessionID,
       job: parsed.job.name || parsed.job.id,
@@ -2400,19 +2423,19 @@ function clearSessionActivity(sessionID) {
 // src/source/runtime/scheduler-diagnostics.js
 var DEFAULT_DEFERRAL_LOG_THROTTLE_MS = 30000;
 function createSchedulerDiagnostics(options = {}) {
-  const now2 = typeof options.now === "function" ? options.now : Date.now;
-  const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : async () => {};
+  const now = typeof options.now === "function" ? options.now : Date.now;
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : async () => {};
   const configured = Number(options.throttleMs);
   const throttleMs = Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_DEFERRAL_LOG_THROTTLE_MS;
   const lastLogged = new Map;
   async function logDeferral(directory, sessionID, reason, extra = {}) {
     const key = `${sessionID || "unknown"}:${reason || "deferred"}:${extra.source || "runtime"}`;
-    const current = now2();
+    const current = now();
     const previous = Number(lastLogged.get(key) || 0);
     if (previous > 0 && current - previous < throttleMs)
       return false;
     lastLogged.set(key, current);
-    await appendLoopLog2(directory, "deferred", {
+    await appendLoopLog(directory, "deferred", {
       sessionID,
       reason,
       ...extra
@@ -2458,7 +2481,7 @@ function createSchedulerRuntime(options = {}) {
     if (options.appendLoopLog)
       await options.appendLoopLog(directory, event, extra);
   };
-  const toast2 = async (client, message, level) => {
+  const toast = async (client, message, level) => {
     if (options.toast)
       await options.toast(client, message, level);
   };
@@ -2522,7 +2545,7 @@ function createSchedulerRuntime(options = {}) {
         }
         await options.maybeRunDueJobs?.(directory, client, sessionID);
       }).catch((error) => {
-        toast2(client, `Loop idle handler failed: ${errorMessage(error)}`, "error").catch(() => {});
+        toast(client, `Loop idle handler failed: ${errorMessage(error)}`, "error").catch(() => {});
         appendLog(directory, "idle-error", { sessionID, error: errorMessage(error) }).catch(() => {});
       });
     }, idleDebounceMs);
@@ -2534,13 +2557,13 @@ function createSchedulerRuntime(options = {}) {
     const timer = setIntervalFn(() => {
       Promise.resolve().then(async () => {
         const state = await readStateFn(directory, sessionID);
-        const delay2 = nextDueDelay(state, clock());
+        const delay = nextDueDelay(state, clock());
         const hasJobs = (state.jobs || []).some((job) => job.enabled !== false && !job.paused && (!isGoalJob(job) || !["completed", "blocked", "cleared"].includes(job.goalStatus)));
-        if (!hasJobs || !Number.isFinite(delay2)) {
+        if (!hasJobs || !Number.isFinite(delay)) {
           stopWatchdog(sessionID);
           return;
         }
-        if (delay2 <= 0)
+        if (delay <= 0)
           await options.maybeRunDueJobs?.(directory, client, sessionID);
         else
           await scheduleDueWork(directory, client, sessionID);
@@ -2557,10 +2580,10 @@ function createSchedulerRuntime(options = {}) {
   async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
     cancelDueWork(sessionID);
     const state = await readStateFn(directory, sessionID);
-    const delay2 = nextDueDelay(state, clock());
-    if (!Number.isFinite(delay2))
+    const delay = nextDueDelay(state, clock());
+    if (!Number.isFinite(delay))
       return;
-    const wait = Math.min(Math.max(delay2, minDelayMs, minDueTimerMs), maxDueTimerMs);
+    const wait = Math.min(Math.max(delay, minDelayMs, minDueTimerMs), maxDueTimerMs);
     const timer = setTimeoutFn(() => {
       dueTimers.delete(sessionID);
       Promise.resolve().then(async () => {
@@ -2577,7 +2600,7 @@ function createSchedulerRuntime(options = {}) {
         }
         await options.maybeRunDueJobs?.(directory, client, sessionID);
       }).catch((error) => {
-        toast2(client, `Loop due timer failed: ${errorMessage(error)}`, "error").catch(() => {});
+        toast(client, `Loop due timer failed: ${errorMessage(error)}`, "error").catch(() => {});
         appendLog(directory, "due-timer-error", { sessionID, error: errorMessage(error) }).catch(() => {});
       });
     }, wait);
@@ -2616,9 +2639,9 @@ function requireFunction5(value, name) {
   return value;
 }
 function createGoalExecutionPolicy(options = {}) {
-  const runShellCommand2 = requireFunction5(options.runShellCommand, "runShellCommand");
+  const runShellCommand = requireFunction5(options.runShellCommand, "runShellCommand");
   const dangerousShell = requireFunction5(options.dangerousShell, "dangerousShell");
-  const toast2 = requireFunction5(options.toast, "toast");
+  const toast = requireFunction5(options.toast, "toast");
   const now2 = typeof options.now === "function" ? options.now : now;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
   async function applyGoalNoProgressGuard(directory, client, sessionID, job, beforeJob) {
@@ -2639,7 +2662,7 @@ function createGoalExecutionPolicy(options = {}) {
       job.paused = true;
       job.goalNoProgressPausedAt = now2();
       job.goalNoProgressReason = `Paused after ${job.noProgressCount} turn(s) without recorded progress. Resume with /loop-goal-resume after adjusting the goal or evidence.`;
-      await toast2(client, job.goalNoProgressReason, "warning");
+      await toast(client, job.goalNoProgressReason, "warning");
       await appendLoopLog2(directory, "goal-no-progress-paused", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit });
     }
     return job;
@@ -2653,7 +2676,7 @@ function createGoalExecutionPolicy(options = {}) {
         results.push({ command, code: -1, output: "Blocked dangerous command in safe mode." });
         continue;
       }
-      const result = await runShellCommand2(command, directory, job.timeoutMs || 300000);
+      const result = await runShellCommand(command, directory, job.timeoutMs || 300000);
       results.push({ command, code: result.code, output: (result.stdout + `
 ` + result.stderr).slice(0, 1200) });
     }
@@ -2663,7 +2686,7 @@ function createGoalExecutionPolicy(options = {}) {
     if (allPassed) {
       job.goalChecksPassedAt = now2();
       job.failureCount = 0;
-      await toast2(client, "Goal checks passed.", "success");
+      await toast(client, "Goal checks passed.", "success");
       if (job.goalCompleteWhenChecksPass) {
         job.goalStatus = "completed";
         job.enabled = false;
@@ -2681,7 +2704,7 @@ exit=${item.code}
 ${item.output}`).join(`
 
 `).slice(0, 4000);
-      await toast2(client, "Goal checks still failing; goal will continue on next idle turn.", "warning");
+      await toast(client, "Goal checks still failing; goal will continue on next idle turn.", "warning");
     }
     await appendLoopLog2(directory, "goal-checks", { sessionID, job: job.name || job.id, results: results.map((item) => ({ command: item.command, code: item.code })) });
     return job;
@@ -2716,7 +2739,7 @@ function dangerousShell(command) {
   ].some((pattern) => pattern.test(text));
 }
 function createJobWorkspaceRuntime(options = {}) {
-  const toast2 = requireFunction6(options.toast, "toast");
+  const toast = requireFunction6(options.toast, "toast");
   const runProcess2 = typeof options.runProcess === "function" ? options.runProcess : runProcess;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
   const readSmallTextFile2 = typeof options.readSmallTextFile === "function" ? options.readSmallTextFile : readSmallTextFile;
@@ -2760,7 +2783,7 @@ ${text.trim().slice(0, 20000)}`);
     if (result.code !== 0)
       result = await runProcess2("git", ["switch", "-c", branch], directory, 30000);
     job.branchDone = true;
-    await toast2(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning");
+    await toast(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning");
     await appendLoopLog2(directory, "branch", { sessionID, branch, code: result.code });
     return job;
   }
@@ -2854,7 +2877,7 @@ ${staged.stdout}`);
       await runProcess2("git", ["add", "-A"], directory, 120000);
       await runProcess2("git", ["commit", "-m", `chore: opencode loop checkpoint ${timestamp}`], directory, 120000);
     }
-    await toast2(client, `Loop checkpoint saved: ${prefix}`, "success");
+    await toast(client, `Loop checkpoint saved: ${prefix}`, "success");
   }
   return {
     buildPrompt,
@@ -2968,15 +2991,15 @@ function createSessionStatusRuntime(options = {}) {
     }
     return attempted ? { type: "unknown", source: "sdk-error" } : undefined;
   }
-  async function canFinalizeActiveRun(directory, client, sessionID, active, options2 = {}) {
+  async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
       return false;
-    if (!options2.requireIdle && !options2.forceStale)
+    if (!options.requireIdle && !options.forceStale)
       return true;
-    const completion = options2.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
+    const completion = options.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
     if (settledAssistantCompletion(completion))
       return true;
-    if (!options2.requireIdle)
+    if (!options.requireIdle)
       return completion === "unknown" && staleActiveRun(sessionID);
     const cached = sessionStatuses.get(sessionID);
     const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
@@ -2988,11 +3011,11 @@ function createSessionStatusRuntime(options = {}) {
       return true;
     }
     if (live?.type) {
-      if (live.type === "busy" && options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
+      if (live.type === "busy" && options.forceStale && completion === "unknown" && staleActiveRun(sessionID))
         return true;
       return false;
     }
-    if (options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
+    if (options.forceStale && completion === "unknown" && staleActiveRun(sessionID))
       return true;
     return cachedIdleAfterRun;
   }
@@ -3015,7 +3038,7 @@ function createSessionStatusRuntime(options = {}) {
     });
     return true;
   }
-  async function sessionStatusType(client, sessionID, directory, options2 = {}) {
+  async function sessionStatusType(client, sessionID, directory, options = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
       markSessionStatus(sessionID, "busy");
       return "busy";
@@ -3035,7 +3058,7 @@ function createSessionStatusRuntime(options = {}) {
     if (live?.type) {
       if (await recoverCompletedTailWithoutActiveRun(directory, client, sessionID, live.type, seenAt))
         return "idle";
-      if ((live.type === "busy" || live.type === "retry") && options2.recoverStaleActive !== false) {
+      if ((live.type === "busy" || live.type === "retry") && options.recoverStaleActive !== false) {
         const active = activeRuns.get(sessionID);
         if (active) {
           const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
@@ -3048,7 +3071,11 @@ function createSessionStatusRuntime(options = {}) {
               ...completion === "completed" ? {} : { staleStatus: live.type }
             };
             const recoveryEvent = completion === "empty" ? "status-message-empty-recovery" : completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery";
-            await appendLoopLog2(directory, recoveryEvent, logDetails);
+            active.statusRecoveryLogEvents ??= new Set;
+            if (!active.statusRecoveryLogEvents.has(recoveryEvent)) {
+              active.statusRecoveryLogEvents.add(recoveryEvent);
+              await appendLoopLog2(directory, recoveryEvent, logDetails);
+            }
             return "idle";
           }
         }
@@ -3060,8 +3087,8 @@ function createSessionStatusRuntime(options = {}) {
     markSessionStatus(sessionID, fallback);
     return fallback;
   }
-  async function sessionIsIdle(client, sessionID, directory, options2 = {}) {
-    return await sessionStatusType(client, sessionID, directory, options2) === "idle";
+  async function sessionIsIdle(client, sessionID, directory, options = {}) {
+    return await sessionStatusType(client, sessionID, directory, options) === "idle";
   }
   return {
     markSessionStatus,
@@ -3247,8 +3274,8 @@ function createActionDispatcher(options = {}) {
       const shellBody = { command, agent };
       if (model)
         shellBody.model = model;
-      const dispatch2 = fireSdk2(client, "session.shell", client.session.shell.bind(client.session), { path: { id: sessionID }, body: shellBody }, { path: { sessionID }, body: shellBody }, { sessionID, ...shellBody });
-      return { startsAssistantTurn: true, dispatch: dispatch2 };
+      const dispatch = fireSdk2(client, "session.shell", client.session.shell.bind(client.session), { path: { id: sessionID }, body: shellBody }, { path: { sessionID }, body: shellBody }, { sessionID, ...shellBody });
+      return { startsAssistantTurn: true, dispatch };
     }
     const prompt = await buildPrompt(directory, job);
     const prefix = kind === "goal" ? "EXPERIMENTAL GOAL MODE CONTINUATION. Continue pursuing the active goal. Do not explain the /loop-goal command. Use the goal tools only when progress/completion/block state is real." : "AUTONOMOUS OPENCODE LOOP ITERATION. Continue the configured task now. Do not explain the /loop command. Do not search for documentation about this plugin. Do not create scheduler files. Do not ask questions. Make reasonable assumptions and work directly.";
@@ -3280,8 +3307,10 @@ function messageText(message) {
   return "";
 }
 async function applyTerminalContinuationGuard(directory, client, sessionID, job, options = {}) {
-  if (job?.scheduleMode !== "idle" || !isCompletionBoundedContinuation(job?.action)) {
-    return { job, terminal: false, pausedNow: false };
+  const completionBounded = isCompletionBoundedContinuation(job?.action);
+  const continuation = completionBounded || isContinuationShorthand(job?.action);
+  if (job?.scheduleMode !== "idle" || !continuation) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false };
   }
   const messages = await readRecentSessionMessages(client, sessionID, directory, options.messageLimit || 8);
   if (!messages)
@@ -3299,11 +3328,31 @@ async function applyTerminalContinuationGuard(directory, client, sessionID, job,
     return { job, terminal: false, pausedNow: false };
   }
   const text = messageText(tail);
+  const waitingUser = isWaitingUserReply(text);
+  if (waitingUser) {
+    if (job.terminalNoWorkCount)
+      job.terminalNoWorkCount = 0;
+    job.waitingUserCount = (job.waitingUserCount || 0) + 1;
+    job.lastWaitingUserAt = Date.now();
+    job.lastWaitingUserSummary = text.slice(0, 1000);
+    const threshold = Math.max(2, Number(options.waitingUserThreshold) || 2);
+    const waitingUserPausedNow = job.waitingUserCount >= threshold && !job.paused;
+    if (waitingUserPausedNow) {
+      job.paused = true;
+      job.lastFailureReason = "waiting_user";
+    }
+    return { job, terminal: false, pausedNow: false, waitingUser: true, waitingUserPausedNow, text };
+  }
+  if (job.waitingUserCount)
+    job.waitingUserCount = 0;
+  if (!completionBounded) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text };
+  }
   const terminal = isTerminalNoWorkReply(text);
   if (!terminal) {
     if (job.terminalNoWorkCount)
       job.terminalNoWorkCount = 0;
-    return { job, terminal: false, pausedNow: false, text };
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text };
   }
   job.terminalNoWorkCount = (job.terminalNoWorkCount || 0) + 1;
   job.lastTerminalNoWorkAt = Date.now();
@@ -3314,7 +3363,7 @@ async function applyTerminalContinuationGuard(directory, client, sessionID, job,
     job.paused = true;
     job.lastFailureReason = "terminal_no_work";
   }
-  return { job, terminal: true, pausedNow, text };
+  return { job, terminal: true, pausedNow, waitingUser: false, waitingUserPausedNow: false, text };
 }
 
 // src/source/runtime/run-finalization.js
@@ -3408,6 +3457,16 @@ exit=` + postrun.code + `
     }
     const terminal = await applyTerminalContinuationGuard2(directory, client, sessionID, job);
     job = terminal.job;
+    if (terminal.waitingUserPausedNow) {
+      await appendLoopLog2(directory, "waiting-user", {
+        sessionID,
+        job: job.name || job.id,
+        count: job.waitingUserCount,
+        summary: String(terminal.text || "").slice(0, 1000)
+      });
+      await notifyJob2(directory, job, "waiting_user");
+      await toast2(client, "Loop paused: autonomous continuation is waiting for explicit user approval, access, or action.", "warning");
+    }
     if (terminal.pausedNow) {
       await appendLoopLog2(directory, "terminal-no-work", {
         sessionID,
@@ -3615,6 +3674,25 @@ function requireFunction10(value, label) {
     throw new TypeError(`createLoopExecutor requires ${label}`);
   return value;
 }
+function sessionErrorDetails(event, fallbackMessage) {
+  if (event?.type !== "session.error")
+    return;
+  const sessionID = event?.properties?.sessionID;
+  if (typeof sessionID !== "string" || !sessionID)
+    return;
+  const error = event?.properties?.error;
+  const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "SessionError";
+  const data = error && typeof error === "object" && error.data && typeof error.data === "object" ? error.data : undefined;
+  const message = typeof data?.message === "string" && data.message.trim() ? data.message.trim() : fallbackMessage(error);
+  return {
+    sessionID,
+    error,
+    name,
+    message,
+    aborted: name === "MessageAbortedError",
+    retryable: name === "APIError" && data?.isRetryable === true
+  };
+}
 function createLoopExecutor(options = {}) {
   const workspace = options.workspace || {};
   const goalPolicy = options.goalPolicy || {};
@@ -3711,7 +3789,7 @@ function createLoopExecutor(options = {}) {
     toast: toast2,
     dangerousShell: dangerousShell2
   });
-  const dueJobs2 = admissionRuntime.dueJobs;
+  const dueJobs = admissionRuntime.dueJobs;
   function clearActiveRun(sessionID) {
     const active = activeRuns.get(sessionID);
     if (active?.timer)
@@ -3793,6 +3871,56 @@ function createLoopExecutor(options = {}) {
     await scheduleDueWork(directory, client, sessionID, retryDelay);
     return true;
   }
+  async function handleSessionError(directory, client, event) {
+    const details = sessionErrorDetails(event, errorMessage);
+    if (!details || details.aborted)
+      return false;
+    const active = activeRuns.get(details.sessionID);
+    if (!active || active.compactionOnly)
+      return false;
+    const snapshot = active;
+    clearActiveRun(details.sessionID);
+    clearSessionStatus(details.sessionID);
+    if (details.retryable) {
+      const refunded = await persistInfrastructureRefund(directory, details.sessionID, snapshot, {
+        reason: "session_error_retryable",
+        error: details.message
+      });
+      await appendLoopLog2(directory, "provider-session-error-retry", {
+        sessionID: details.sessionID,
+        job: refunded.job?.name || snapshot.jobId,
+        errorName: details.name,
+        error: details.message,
+        retryInMs: refunded.delayMs
+      });
+      await toast2(client, `Loop provider turn failed after OpenCode retries; the logical run was refunded and will retry with backoff: ${details.message}`, "warning");
+      await scheduleDueWork(directory, client, details.sessionID, refunded.delayMs);
+      return true;
+    }
+    const state = await readState2(directory, details.sessionID);
+    const job = (state.jobs || []).find((candidate) => candidate.id === snapshot.jobId);
+    if (job) {
+      job.failureCount = (job.failureCount || 0) + 1;
+      job.paused = true;
+      job.lastFailureReason = "session_error";
+      job.lastSessionErrorName = details.name;
+      job.lastSessionError = details.message.slice(0, 4000);
+      job.lastSessionErrorAt = now2();
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+      await writeState2(directory, details.sessionID, state);
+      await notifyJob2(directory, job, "session_error");
+    }
+    await appendLoopLog2(directory, "session-error", {
+      sessionID: details.sessionID,
+      job: job?.name || snapshot.jobId,
+      errorName: details.name,
+      error: details.message,
+      paused: Boolean(job?.paused)
+    });
+    await toast2(client, `Loop paused after a terminal OpenCode session error: ${details.message}`, "error");
+    await scheduleDueWork(directory, client, details.sessionID);
+    return true;
+  }
   async function recoverStuckProviderRetry(directory, client, sessionID) {
     const active = activeRuns.get(sessionID);
     if (!active || active.compactionOnly) {
@@ -3934,7 +4062,7 @@ function createLoopExecutor(options = {}) {
           candidate.watchTriggered = true;
         }
       }
-      const due = dueJobs2(state, Boolean(runOptions.force));
+      const due = dueJobs(state, Boolean(runOptions.force));
       if (!due.length) {
         await writeState2(directory, sessionID, state);
         await reschedule();
@@ -4063,10 +4191,11 @@ function createLoopExecutor(options = {}) {
     }
   }
   return {
-    dueJobs: dueJobs2,
+    dueJobs,
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    handleSessionError,
     recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
@@ -4288,6 +4417,7 @@ var executorRuntime = createLoopExecutor({
 });
 var {
   clearActiveRun,
+  handleSessionError,
   finalizeActiveRun,
   maybeRunDueJobs: runDueJobs,
   sessionIsIdle,
@@ -4400,47 +4530,73 @@ function steeringToolRejection(sessionID) {
     output: "Goal lifecycle update deferred because queued user steering is pending. The experimental Goal remains active and unchanged."
   };
 }
+async function dedicatedGoalToolRejection(directory, sessionID) {
+  const goal = await findDedicatedGoalForSession(directory, sessionID);
+  if (!goal || goal.status === "completed")
+    return;
+  return {
+    title: "Dedicated Goal owns lifecycle",
+    output: [
+      `A dedicated OpenCode Goal is persisted for this session (status=${String(goal.status || "unknown")}).`,
+      "The opencode_loop_goal_* tools control only experimental /loop-goal jobs and will not mutate the dedicated Goal.",
+      "Use opencode_goal_progress for checkpoints, opencode_goal_wait_for_user when user/manual input is required, opencode_goal_blocked for a genuine blocker, or opencode_goal_complete for verified completion."
+    ].join(`
+`)
+  };
+}
 function goalTools(defaultDirectory) {
   return {
     opencode_loop_goal_complete: tool({
-      description: "Mark the current OpenCode Loop experimental goal as completed. Use only after acceptance criteria are satisfied and you have evidence from tests, typecheck, build, or code inspection.",
+      description: "Experimental /loop-goal ONLY: mark the current OpenCode Loop experimental goal as completed. Never use this tool to control a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_complete there. Use only after acceptance criteria are satisfied and you have evidence from tests, typecheck, build, or code inspection.",
       args: {
         summary: tool.schema.string().describe("Short human-readable summary of what was completed."),
         evidence: tool.schema.string().describe("Concrete evidence that the goal is complete, such as commands run, passing checks, files changed, and important results.")
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory;
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID);
+        if (dedicated)
+          return dedicated;
         const steering = steeringToolRejection(context.sessionID);
         if (steering)
           return steering;
-        const result = await setGoalComplete(context.directory || defaultDirectory, context.sessionID, args);
+        const result = await setGoalComplete(directory, context.sessionID, args);
         return { title: result.ok ? "Goal completed" : result.rejected ? "Goal completion rejected" : "Goal not found", output: result.message };
       }
     }),
     opencode_loop_goal_blocked: tool({
-      description: "Mark the current OpenCode Loop experimental goal as blocked when user input or manual intervention is required.",
+      description: "Experimental /loop-goal ONLY: mark the current OpenCode Loop experimental goal as blocked. Never use this tool for a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_wait_for_user for user/manual input or opencode_goal_blocked for a genuine dedicated-Goal blocker.",
       args: {
         reason: tool.schema.string().describe("Why the goal is blocked."),
         needed: tool.schema.string().describe("What user input, credential, decision, or manual action is needed to continue.")
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory;
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID);
+        if (dedicated)
+          return dedicated;
         const steering = steeringToolRejection(context.sessionID);
         if (steering)
           return steering;
-        const result = await setGoalBlocked(context.directory || defaultDirectory, context.sessionID, args);
+        const result = await setGoalBlocked(directory, context.sessionID, args);
         return { title: result.ok ? "Goal blocked" : "Goal not found", output: result.message };
       }
     }),
     opencode_loop_goal_progress: tool({
-      description: "Record meaningful progress on the current OpenCode Loop experimental goal without completing it.",
+      description: "Experimental /loop-goal ONLY: record meaningful progress on the current OpenCode Loop experimental goal. Never use this tool for a dedicated @bybrawe/opencode-goal Goal; use opencode_goal_progress there.",
       args: {
         summary: tool.schema.string().describe("What useful progress was made."),
         next: tool.schema.string().describe("The next step toward completing the goal.")
       },
       execute: async (args, context) => {
+        const directory = context.directory || defaultDirectory;
+        const dedicated = await dedicatedGoalToolRejection(directory, context.sessionID);
+        if (dedicated)
+          return dedicated;
         const steering = steeringToolRejection(context.sessionID);
         if (steering)
           return steering;
-        const result = await setGoalProgress(context.directory || defaultDirectory, context.sessionID, args);
+        const result = await setGoalProgress(directory, context.sessionID, args);
         return { title: result.ok ? "Goal progress" : "Goal not found", output: result.message };
       }
     })
@@ -4491,6 +4647,11 @@ var OpenCodeLoopPlugin = async ({ client, directory }) => {
       const steering = await goalSteeringRuntime.handleEvent(directory, client, event);
       if (steering?.handled && steering.sessionID)
         rememberSession(directory, client, steering.sessionID);
+      if (event.type === "session.error") {
+        const handledError = await handleSessionError(directory, client, event);
+        if (handledError && event?.properties?.sessionID)
+          rememberSession(directory, client, event.properties.sessionID);
+      }
       const statusUpdate = updateSessionStatusFromEvent(event);
       if (statusUpdate?.sessionID)
         rememberSession(directory, client, statusUpdate.sessionID);
@@ -4507,8 +4668,8 @@ var DEFAULT_SESSION_STALE_MS = 12 * 60 * 60 * 1000;
 function sessionKey(sessionID) {
   return String(sessionID || "").trim();
 }
-function createSessionRegistry({ now: now2 = Date.now, staleAfterMs = DEFAULT_SESSION_STALE_MS } = {}) {
-  if (typeof now2 !== "function")
+function createSessionRegistry({ now = Date.now, staleAfterMs = DEFAULT_SESSION_STALE_MS } = {}) {
+  if (typeof now !== "function")
     throw new TypeError("session registry requires a clock function");
   if (!Number.isFinite(staleAfterMs) || staleAfterMs < 0)
     throw new TypeError("session registry requires a non-negative staleAfterMs");
@@ -4517,7 +4678,7 @@ function createSessionRegistry({ now: now2 = Date.now, staleAfterMs = DEFAULT_SE
     const key = sessionKey(sessionID);
     if (!key)
       throw new TypeError("session registry requires a session ID");
-    const seenAt = Number(now2());
+    const seenAt = Number(now());
     if (!Number.isFinite(seenAt))
       throw new TypeError("session registry clock must return a finite number");
     const entry = Object.freeze({ sessionID: key, runtime, seenAt });
@@ -4536,7 +4697,7 @@ function createSessionRegistry({ now: now2 = Date.now, staleAfterMs = DEFAULT_SE
       return false;
     return sessions.delete(key);
   }
-  function pruneStale(at = now2()) {
+  function pruneStale(at = now()) {
     const timestamp = Number(at);
     if (!Number.isFinite(timestamp))
       throw new TypeError("session registry prune time must be finite");
@@ -4620,7 +4781,7 @@ function createRuntimeScope() {
 }
 
 // src/source/runtime/timers.js
-function createOwnedTimer(scope, callback, delay2, repeat, api, ref) {
+function createOwnedTimer(scope, callback, delay, repeat, api, ref) {
   if (!scope?.isActive?.())
     return;
   let active = true;
@@ -4635,7 +4796,7 @@ function createOwnedTimer(scope, callback, delay2, repeat, api, ref) {
     }
     callback(...args);
   });
-  handle = repeat ? api.setInterval(invoke, delay2) : api.setTimeout(invoke, delay2);
+  handle = repeat ? api.setInterval(invoke, delay) : api.setTimeout(invoke, delay);
   release = scope.track(() => {
     if (repeat)
       api.clearInterval(handle);
@@ -4661,11 +4822,11 @@ function createOwnedTimer(scope, callback, delay2, repeat, api, ref) {
 }
 function createRuntimeTimers(scope, api = globalThis) {
   return Object.freeze({
-    timeout(callback, delay2, options = {}) {
-      return createOwnedTimer(scope, callback, delay2, false, api, options.ref !== false);
+    timeout(callback, delay, options = {}) {
+      return createOwnedTimer(scope, callback, delay, false, api, options.ref !== false);
     },
-    interval(callback, delay2, options = {}) {
-      return createOwnedTimer(scope, callback, delay2, true, api, options.ref !== false);
+    interval(callback, delay, options = {}) {
+      return createOwnedTimer(scope, callback, delay, true, api, options.ref !== false);
     }
   });
 }
@@ -4690,14 +4851,14 @@ function validateRuntime(runtime, sessionID) {
   return runtime;
 }
 function createSessionRuntimeManager({
-  now: now2 = Date.now,
+  now = Date.now,
   staleAfterMs = DEFAULT_SESSION_STALE_MS,
   timerAPI = globalThis,
   runtimeFactory = defaultRuntimeFactory
 } = {}) {
   if (typeof runtimeFactory !== "function")
     throw new TypeError("session runtime manager requires a runtime factory");
-  const registry = createSessionRegistry({ now: now2, staleAfterMs });
+  const registry = createSessionRegistry({ now, staleAfterMs });
   let disposed = false;
   function observeExternal(sessionID) {
     if (disposed)
@@ -4727,7 +4888,7 @@ function createSessionRuntimeManager({
     current.runtime.dispose(reason);
     return true;
   }
-  function pruneStale(at = now2()) {
+  function pruneStale(at = now()) {
     const before = new Map(registry.entries().map((entry) => [entry.sessionID, entry.runtime]));
     const removed = registry.pruneStale(at);
     const errors = [];
@@ -4928,12 +5089,12 @@ function scopedClient(client) {
   });
 }
 function scheduleLegacyCleanup(dispose, isCurrentGeneration) {
-  for (const delay2 of [0, 25, 100, 500, 2000, 1e4, 30000]) {
+  for (const delay of [0, 25, 100, 500, 2000, 1e4, 30000]) {
     const timer = setTimeout(() => {
       if (!isCurrentGeneration())
         return;
       Promise.resolve(dispose()).catch(() => {});
-    }, delay2);
+    }, delay);
     timer.unref?.();
   }
 }