@bybrawe/opencode-loop 0.5.33 → 0.5.35

package/src/index.js

@@ -1021,6 +1021,69 @@ function commandArgsText(args) {
   return String(args);
 }
 
+// src/source/core/continuation.js
+var CONTINUATION_SHORTHANDS = new Set([
+  "continue",
+  "continue.",
+  "continue working",
+  "keep going",
+  "go on",
+  "devam",
+  "devam et",
+  "devam et.",
+  "devam et bakal\u0131m"
+]);
+var COMPLETION_BOUNDED_PATTERNS = [
+  /\bbitene kadar\b/i,
+  /\b(?:tamamen|komple) projeyi bitir\b/i,
+  /\bi\u015Fi bitir\b/i,
+  /\buntil (?:it(?:'s| is) )?(?:done|complete|completed|finished)\b/i,
+  /\bfinish (?:the )?(?:project|task|work)\b/i,
+  /\bkeep going until\b/i
+];
+var TERMINAL_COMPLETION_PATTERNS = [
+  /proje tamamland[\u0131i](?=\s|[.,;:!\u2014-]|$)/i,
+  /\bproject (?:is )?(?:complete|completed|finished|done)\b/i,
+  /\b(?:task|work) (?:is )?(?:complete|completed|finished|done)\b/i
+];
+var TERMINAL_NO_WORK_PATTERNS = [
+  /yap[\u0131i]lacak (?:ba\u015Fka )?i\u015F yok(?=\s|[.,;:!\u2014-]|$)/i,
+  /ba\u015Fka (?:bir )?i\u015F (?:kalmad[\u0131i]|yok)(?=\s|[.,;:!\u2014-]|$)/i,
+  /\bnothing (?:else )?left to do\b/i,
+  /\bno (?:more|remaining) work\b/i,
+  /\bno known (?:bugs|issues)\b/i,
+  /\bzero known (?:bugs|issues)\b/i
+];
+var NEXT_WORK_PATTERNS = [
+  /\bnext(?: step| task)?\b/i,
+  /s[\u0131i]radaki(?=\s|[.,;:!\u2014-]|$)/i,
+  /sonraki(?=\s|[.,;:!\u2014-]|$)/i,
+  /kalan (?:i\u015F|i\u015Fler|todo|ad\u0131m)(?=\s|[.,;:!\u2014-]|$)/i,
+  /\bremaining (?:work|task|todo|step)/i,
+  /devam (?:edece\u011Fim|ediyorum|etmek gerek)(?=\s|[.,;:!\u2014-]|$)/i
+];
+function isContinuationShorthand(value) {
+  return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "));
+}
+function isCompletionBoundedContinuation(value) {
+  const text = String(value || "").trim();
+  return COMPLETION_BOUNDED_PATTERNS.some((pattern) => pattern.test(text));
+}
+function isTerminalNoWorkReply(value) {
+  const text = String(value || "").trim();
+  if (!text || NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text)))
+    return false;
+  const completed = TERMINAL_COMPLETION_PATTERNS.some((pattern) => pattern.test(text));
+  const noWork = TERMINAL_NO_WORK_PATTERNS.some((pattern) => pattern.test(text));
+  return completed && noWork;
+}
+function continuationProjectInstruction(value) {
+  if (!isContinuationShorthand(value) && !isCompletionBoundedContinuation(value))
+    return "";
+  const finish = isCompletionBoundedContinuation(value) ? " If you believe the project is finished, perform a fresh verification pass before declaring completion; report both that the project is complete and that no work remains only when you have concrete current evidence." : "";
+  return `Treat this as continuation of the current project and conversation, not a fresh task. Inspect the repository state, relevant files, TODO/progress notes, recent changes, and git status as needed to identify the next unfinished step. Continue from existing work, do not redo completed work, and verify meaningful changes when practical.${finish}`;
+}
+
 // src/source/core/jobs.js
 function presetDefaults(name) {
   if (name === "loop-compact")
@@ -1086,6 +1149,9 @@ function actionKind(action, job = {}) {
 }
 function decoratePrompt(job) {
   const additions = [];
+  const continuation = continuationProjectInstruction(job.action);
+  if (continuation)
+    additions.push(continuation);
   if (job.progressFile)
     additions.push(`Use ${job.progressFile} as the main progress/TODO state file. Read it before choosing the next task and update it after work.`);
   if (job.lastVerifyFailure)
@@ -1623,8 +1689,185 @@ function createGoalCommandHandlers(options = {}) {
 }
 
 // src/source/opencode/loop-commands.js
+import { promises as fs6 } from "fs";
+import path7 from "path";
+
+// src/source/runtime/companion-goal.js
 import { promises as fs4 } from "fs";
 import path5 from "path";
+function goalRoot(directory) {
+  return path5.join(directory, ".opencode", "goals");
+}
+async function findDedicatedGoalForSession(directory, sessionID) {
+  if (!directory || !sessionID)
+    return;
+  let names;
+  try {
+    names = await fs4.readdir(goalRoot(directory));
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return;
+    return;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    try {
+      const value = JSON.parse(await fs4.readFile(path5.join(goalRoot(directory), name), "utf8"));
+      if (value?.sessionID === sessionID)
+        return value;
+    } catch {}
+  }
+  return;
+}
+function dedicatedGoalOwnsContinuation(goal) {
+  return goal?.status === "active";
+}
+function dedicatedGoalSummary(goal) {
+  if (!goal)
+    return "not detected";
+  const id = String(goal.id || "unknown").slice(0, 12);
+  const status = String(goal.status || "unknown");
+  return `${status} (${id})`;
+}
+
+// src/source/runtime/loop-diagnostics.js
+import { promises as fs5 } from "fs";
+import path6 from "path";
+
+// src/source/runtime/schedule-policy.js
+var TERMINAL_GOAL_STATUSES = new Set(["completed", "blocked", "cleared"]);
+function inferredScheduleMode(job) {
+  const explicit = String(job?.scheduleMode || "").toLowerCase();
+  if (["idle", "interval", "once", "watch"].includes(explicit))
+    return explicit;
+  if (job?.watchPaths?.length)
+    return "watch";
+  if (Number(job?.maxRuns || 0) === 1 && job?.immediate === false && Number(job?.intervalMs || 0) > 0)
+    return "once";
+  return Number(job?.intervalMs || 0) === 0 ? "idle" : "interval";
+}
+function jobRunnable(job) {
+  if (!job)
+    return false;
+  if (isGoalJob(job) && TERMINAL_GOAL_STATUSES.has(job.goalStatus))
+    return false;
+  if (!job.enabled || job.paused)
+    return false;
+  if (Number(job.maxRuns || 0) > 0 && Number(job.runCount || 0) >= Number(job.maxRuns || 0))
+    return false;
+  return true;
+}
+function jobDueAt(job, current = Date.now()) {
+  if (!jobRunnable(job))
+    return Infinity;
+  if (Number(job.runNowRequestedAt || 0) > 0)
+    return current;
+  const created = Date.parse(job.createdAt || "");
+  if (Number(job.maxRuntimeMs || 0) > 0 && Number.isFinite(created) && current - created >= Number(job.maxRuntimeMs || 0))
+    return current;
+  if (job.watchPaths?.length)
+    return job.watchTriggered === true ? current : Infinity;
+  const intervalMs = Number(job.intervalMs || 0);
+  if (intervalMs === 0)
+    return current;
+  const lastRunAt = Number(job.lastRunAt || 0);
+  if (!lastRunAt) {
+    if (job.immediate === false)
+      return (Number.isFinite(created) ? created : current) + intervalMs;
+    return current;
+  }
+  return lastRunAt + intervalMs;
+}
+function jobIsDue(job, current = Date.now(), force = false) {
+  if (!jobRunnable(job))
+    return false;
+  if (force)
+    return true;
+  return jobDueAt(job, current) <= current;
+}
+function dueJobs(state, current = Date.now(), force = false) {
+  return (state?.jobs || []).filter((job) => jobIsDue(job, current, force)).sort((a, b) => Number(Number(b.runNowRequestedAt || 0) > 0) - Number(Number(a.runNowRequestedAt || 0) > 0));
+}
+function nextDueDelay(state, current = Date.now()) {
+  let soonest = Infinity;
+  for (const job of state?.jobs || [])
+    soonest = Math.min(soonest, jobDueAt(job, current));
+  if (!Number.isFinite(soonest))
+    return Infinity;
+  return Math.max(0, soonest - current);
+}
+function scheduleDescription(job) {
+  const mode = inferredScheduleMode(job);
+  const intervalMs = Number(job?.intervalMs || 0);
+  if (mode === "idle")
+    return "every idle";
+  if (mode === "watch")
+    return `on watch: ${(job.watchPaths || []).join(", ")}`;
+  if (mode === "once")
+    return intervalMs > 0 ? `once after ${durationToText(intervalMs)}` : "once on next idle";
+  if (job?.immediate === false)
+    return `every ${durationToText(intervalMs)}, first after ${durationToText(intervalMs)}`;
+  return `every ${durationToText(intervalMs)}, starts on next idle`;
+}
+function scheduleState(job, current = Date.now()) {
+  if (!job?.enabled)
+    return "stopped";
+  if (job?.paused)
+    return "paused";
+  if (Number(job?.runNowRequestedAt || 0) > 0)
+    return "due now; waiting for idle";
+  const mode = inferredScheduleMode(job);
+  const dueAt = jobDueAt(job, current);
+  if (!Number.isFinite(dueAt))
+    return mode === "watch" ? "waiting for watched change" : "not scheduled";
+  if (dueAt <= current)
+    return mode === "idle" ? "waiting for idle" : "due; waiting for idle";
+  return `due in ${durationToText(dueAt - current)}`;
+}
+
+// src/source/runtime/loop-diagnostics.js
+function describeJobScheduling(job, current = Date.now()) {
+  return {
+    schedule: scheduleDescription(job),
+    state: scheduleState(job, current)
+  };
+}
+async function listPersistedLoopSessions(directory, currentSessionID) {
+  const root = stateDir(directory);
+  let names;
+  try {
+    names = await fs5.readdir(root);
+  } catch (error) {
+    if (error?.code === "ENOENT")
+      return [];
+    return [];
+  }
+  const sessions = [];
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const sessionID = name.slice(0, -5);
+    try {
+      const parsed = JSON.parse(await fs5.readFile(path6.join(root, name), "utf8"));
+      const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+      const enabled = jobs.filter((job) => job?.enabled !== false && !job?.paused).length;
+      const neverRan = jobs.filter((job) => Number(job?.runCount || 0) === 0).length;
+      sessions.push({
+        sessionID,
+        current: sessionID === currentSessionID,
+        jobs: jobs.length,
+        enabled,
+        neverRan
+      });
+    } catch {
+      sessions.push({ sessionID, current: sessionID === currentSessionID, jobs: 0, enabled: 0, neverRan: 0, corrupt: true });
+    }
+  }
+  return sessions.sort((a, b) => Number(b.current) - Number(a.current) || b.enabled - a.enabled || a.sessionID.localeCompare(b.sessionID));
+}
+
+// src/source/opencode/loop-commands.js
 var SERVICE2 = "opencode-loop";
 var DEFAULT_PROGRESS_MD = `# Progress
 
@@ -1671,8 +1914,10 @@ function createLoopCommandHandlers(options = {}) {
   const removeState2 = typeof options.removeState === "function" ? options.removeState : removeState;
   const pathExists2 = typeof options.pathExists === "function" ? options.pathExists : pathExists;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
-  const readFile = typeof options.readFile === "function" ? options.readFile : (...args) => fs4.readFile(...args);
-  const writeFile = typeof options.writeFile === "function" ? options.writeFile : (...args) => fs4.writeFile(...args);
+  const readFile = typeof options.readFile === "function" ? options.readFile : (...args) => fs6.readFile(...args);
+  const writeFile = typeof options.writeFile === "function" ? options.writeFile : (...args) => fs6.writeFile(...args);
+  const listPersistedLoopSessions2 = typeof options.listPersistedLoopSessions === "function" ? options.listPersistedLoopSessions : listPersistedLoopSessions;
+  const findDedicatedGoalForSession2 = typeof options.findDedicatedGoalForSession === "function" ? options.findDedicatedGoalForSession : findDedicatedGoalForSession;
   const runtimeVersion = options.runtimeVersion || process.version;
   const runtimePlatform = options.runtimePlatform || process.platform;
   async function stopLoop(directory, client, sessionID, args) {
@@ -1704,15 +1949,11 @@ function createLoopCommandHandlers(options = {}) {
   async function statusLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
     const jobs = state.jobs || [];
+    const current = now2();
     const lines = jobs.length ? jobs.map((job, index) => {
-      const current = now2();
-      const intervalMs = Number(job.intervalMs || 0);
-      const lastRunAt = Number(job.lastRunAt || 0);
-      const createdAt = Date.parse(job.createdAt || "");
-      const dueAt = Number(job.runNowRequestedAt || 0) > 0 ? current : lastRunAt > 0 ? lastRunAt + intervalMs : job.immediate === false && Number.isFinite(createdAt) ? createdAt + intervalMs : current;
-      const dueIn = Math.max(0, dueAt - current);
+      const scheduling = describeJobScheduling(job, current);
       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)} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | due in ${durationToText(dueIn)} | ${flags}`;
+      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:
@@ -1722,7 +1963,7 @@ function createLoopCommandHandlers(options = {}) {
   async function logsLoop(directory, client, sessionID) {
     let text = "No loop log found.";
     try {
-      text = (await readFile(path5.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join(`
+      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:
@@ -1731,18 +1972,20 @@ function createLoopCommandHandlers(options = {}) {
   async function helpLoop(client, sessionID) {
     await say2(client, sessionID, [
       "OpenCode Loop help:",
-      "/loop 0s <prompt>                                Claude Code style auto-continue",
-      "/loop 5m --ask-never --safe <prompt>              interval autonomous prompt loop",
-      "/loop-command 200m /compact                       OpenCode slash-command loop, waits for idle",
-      "/loop-ask 1h did you run tests and tsc --noEmit?   scheduled question/check prompt",
-      "/loop-shell 10m npm test                           shell loop, waits for idle",
-      "/loop-goal finish the feature and keep tests green  experimental persistent goal mode",
-      '/loop-goal --check "npm run build" --check "npm test" --complete-when-checks-pass ship it',
-      "/loop-goal status | pause | resume | clear          manage experimental goals",
-      "/loop 200m --command /compact                     same as command loop",
-      '/loop 0s --verify "npm test" <prompt>            verify after each assistant turn',
-      "/loop 0s --prompt-file loop-prompt.md             load prompt from a file",
-      "/loop 0s --max-runtime 6h --max-failures 3 <task> stop safely after limits",
+      "/loop continue the project                           auto-continue forever whenever the session becomes idle",
+      "/loop idle continue the project                      explicit form of the same idle loop",
+      "/loop every 5m continue the project                  recurring timer; first run after 5m, always waits for idle",
+      "/loop after 5m continue the project                  one-shot delayed prompt; runs once when 5m has passed and session is idle",
+      "/loop 5m continue the project                        legacy compact form: starts on next idle, then every 5m",
+      "/loop 5m --no-now continue the project               legacy recurring form with first run delayed 5m",
+      "/loop-command 200m /compact                          OpenCode slash-command loop, waits for idle",
+      "/loop-ask 1h did you run tests and tsc --noEmit?      scheduled question/check prompt",
+      "/loop-shell 10m npm test                              shell loop, waits for idle",
+      "/loop-goal finish the feature and keep tests green    experimental persistent goal mode",
+      '/loop 0s --verify "npm test" <prompt>               verify after each assistant turn',
+      "/loop --prompt-file loop-prompt.md                    idle loop loading its prompt from a file",
+      "/loop 0s --max-runtime 6h --max-failures 3 <task>     stop safely after limits",
+      "Prompt-producing /loop jobs are blocked while dedicated /goal owns the same session; use another session or --allow-goal-overlap only intentionally.",
       "/loop-doctor | /loop-init | /loop-export"
     ].join(`
 `));
@@ -1767,22 +2010,36 @@ function createLoopCommandHandlers(options = {}) {
   }
   async function doctorLoop(directory, client, sessionID) {
     const state = await readState2(directory, sessionID);
-    await say2(client, sessionID, [
+    const persisted = await listPersistedLoopSessions2(directory, sessionID);
+    const otherSessions = persisted.filter((entry) => !entry.current && entry.enabled > 0);
+    const dedicatedGoal = await findDedicatedGoalForSession2(directory, sessionID);
+    const lines = [
       "OpenCode Loop doctor:",
       `- plugin: ${SERVICE2}`,
       `- project directory: ${directory}`,
       `- state directory: ${stateDir(directory)}`,
-      `- active jobs: ${(state.jobs || []).length}`,
+      `- current session: ${sessionID}`,
+      `- current-session jobs: ${(state.jobs || []).length}`,
+      `- dedicated /goal: ${dedicatedGoalSummary(dedicatedGoal)}`,
+      `- other persisted sessions with enabled jobs: ${otherSessions.length}`,
       `- node: ${runtimeVersion}`,
       `- platform: ${runtimePlatform}`,
-      "- smoke test: /loop 0s --max-runs 1 --dry-run continue from progress.md",
+      "- smoke test: /loop --max-runs 1 --dry-run continue from progress.md",
+      "- delayed smoke test: /loop after 5m --dry-run continue from progress.md",
+      "- recurring smoke test: /loop every 5m --dry-run continue from progress.md",
       "- experimental goal smoke test: /loop-goal --dry-run finish the current task and verify it"
-    ].join(`
+    ];
+    for (const entry of otherSessions.slice(0, 8)) {
+      lines.push(`- other session ${entry.sessionID}: jobs=${entry.jobs}, enabled=${entry.enabled}, never-ran=${entry.neverRan}`);
+    }
+    if (otherSessions.length > 8)
+      lines.push(`- ... ${otherSessions.length - 8} more persisted session(s)`);
+    await say2(client, sessionID, lines.join(`
 `));
   }
   async function initLoop(directory, client, sessionID, args) {
     const target = String(args || "").trim() || "progress.md";
-    const full = path5.resolve(directory, target);
+    const full = path7.resolve(directory, target);
     if (await pathExists2(full)) {
       await toast2(client, `${target} already exists.`, "warning");
       return;
@@ -1808,6 +2065,81 @@ function createLoopCommandHandlers(options = {}) {
   };
 }
 
+// src/source/core/schedule-syntax.js
+function removeBooleanFlag(input, flag) {
+  const pattern = new RegExp(`(^|\\s)${flag.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}(?=\\s|$)`, "i");
+  const found = pattern.test(input);
+  return {
+    found,
+    value: String(input || "").replace(pattern, " ").replace(/\s+/g, " ").trim()
+  };
+}
+function firstToken(input) {
+  const match = String(input || "").trim().match(/^(\S+)(?:\s+([\s\S]*))?$/);
+  return match ? { token: match[1], rest: String(match[2] || "").trim() } : { token: "", rest: "" };
+}
+function inferredMode(intervalMs, maxRuns) {
+  if (Number(maxRuns || 0) === 1 && Number(intervalMs || 0) > 0)
+    return "once";
+  return Number(intervalMs || 0) === 0 ? "idle" : "interval";
+}
+function normalizeLoopScheduleArgs(raw, defaults = {}) {
+  const overlap = removeBooleanFlag(String(raw || "").trim(), "--allow-goal-overlap");
+  let input = overlap.value;
+  const nextDefaults = { ...defaults };
+  let scheduleMode = defaults.scheduleMode;
+  let scheduleSyntax = "legacy";
+  const first = firstToken(input);
+  const keyword = first.token.toLowerCase();
+  if (keyword === "idle") {
+    nextDefaults.intervalMs = 0;
+    nextDefaults.immediate = true;
+    scheduleMode = "idle";
+    scheduleSyntax = "idle";
+    input = first.rest;
+  } else if (keyword === "every" || keyword === "after" || keyword === "in") {
+    const duration = firstToken(first.rest);
+    const intervalMs = parseDuration(duration.token);
+    if (intervalMs === null) {
+      return {
+        ok: false,
+        error: `Invalid ${keyword} schedule. Example: /loop ${keyword === "every" ? "every" : "after"} 5m continue the project`
+      };
+    }
+    nextDefaults.intervalMs = intervalMs;
+    nextDefaults.immediate = false;
+    input = duration.rest;
+    if (keyword === "every") {
+      scheduleMode = intervalMs === 0 ? "idle" : "interval";
+      scheduleSyntax = "every";
+    } else {
+      nextDefaults.maxRuns = 1;
+      scheduleMode = "once";
+      scheduleSyntax = "after";
+    }
+  } else {
+    const duration = parseDuration(first.token);
+    if (duration !== null) {
+      scheduleMode = duration === 0 ? "idle" : "interval";
+    } else if (nextDefaults.intervalMs === undefined || nextDefaults.intervalMs === null) {
+      nextDefaults.intervalMs = 0;
+      nextDefaults.immediate = nextDefaults.immediate ?? true;
+      scheduleMode = "idle";
+      scheduleSyntax = "idle-shorthand";
+    } else {
+      scheduleMode = scheduleMode || inferredMode(nextDefaults.intervalMs, nextDefaults.maxRuns);
+    }
+  }
+  return {
+    ok: true,
+    args: input,
+    defaults: nextDefaults,
+    scheduleMode: scheduleMode || inferredMode(nextDefaults.intervalMs, nextDefaults.maxRuns),
+    scheduleSyntax,
+    allowGoalOverlap: overlap.found || defaults.allowGoalOverlap === true
+  };
+}
+
 // src/source/opencode/loop-registration.js
 var DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180000;
 var FALLBACK_ACTIVE_GUARD_MS = 45000;
@@ -1831,19 +2163,34 @@ function createLoopRegistration(options = {}) {
   const toast2 = requireFunction4(options.toast, "toast");
   const say2 = 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;
   const writeState2 = typeof options.writeState === "function" ? options.writeState : writeState;
   const appendLoopLog2 = typeof options.appendLoopLog === "function" ? options.appendLoopLog : appendLoopLog;
   const normalizedModelRef2 = typeof options.normalizedModelRef === "function" ? options.normalizedModelRef : normalizedModelRef;
   const getSessionExecutionContext2 = typeof options.getSessionExecutionContext === "function" ? options.getSessionExecutionContext : getSessionExecutionContext;
+  const findDedicatedGoalForSession2 = typeof options.findDedicatedGoalForSession === "function" ? options.findDedicatedGoalForSession : findDedicatedGoalForSession;
   const configuredGuard = Number(options.defaultActiveGuardMs);
   const defaultActiveGuardMs = Number.isFinite(configuredGuard) && configuredGuard > 0 ? configuredGuard : FALLBACK_ACTIVE_GUARD_MS;
   async function addLoop(directory, client, sessionID, args, defaults = {}) {
-    const parsed = parseLoopArgs2(args, defaults);
+    const normalized = normalizeLoopScheduleArgs2(args, defaults);
+    if (!normalized.ok) {
+      await toast2(client, normalized.error, "warning");
+      return;
+    }
+    const parsed = parseLoopArgs2(normalized.args, normalized.defaults);
     if (!parsed.ok) {
       await toast2(client, parsed.error, "warning");
       return;
     }
+    parsed.job.scheduleMode = normalized.scheduleMode;
+    parsed.job.scheduleSyntax = normalized.scheduleSyntax;
+    parsed.job.allowGoalOverlap = normalized.allowGoalOverlap === true;
+    if (normalized.scheduleSyntax === "after") {
+      parsed.job.immediate = false;
+      parsed.job.maxRuns = 1;
+      parsed.job.lastRunAt = Date.parse(parsed.job.createdAt || "") || Date.now();
+    }
     const executionContext = getSessionExecutionContext2(sessionID) || { agent: "build" };
     parsed.job.agent = defaults.agent || executionContext.agent || "build";
     parsed.job.model = normalizedModelRef2(defaults.model) || executionContext.model;
@@ -1863,6 +2210,19 @@ function createLoopRegistration(options = {}) {
     if (!parsed.job.activeRecoveryMs) {
       parsed.job.activeRecoveryMs = isGoalJob(parsed.job) ? DEFAULT_GOAL_ACTIVE_RECOVERY_MS : Math.max(defaultActiveGuardMs, Math.min(90000, (parsed.job.intervalMs || 0) + 1e4));
     }
+    const promptProducing = actionKind(parsed.job.action, parsed.job) === "prompt";
+    if (promptProducing && !parsed.job.allowGoalOverlap) {
+      const dedicatedGoal = await findDedicatedGoalForSession2(directory, sessionID);
+      if (dedicatedGoalOwnsContinuation(dedicatedGoal)) {
+        await appendLoopLog2(directory, "goal-overlap-blocked", {
+          sessionID,
+          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");
+        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```");
@@ -1890,7 +2250,13 @@ function createLoopRegistration(options = {}) {
     if (parsed.job.immediate)
       scheduleIdleWork(directory, client, sessionID);
     await toast2(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success");
-    await appendLoopLog2(directory, replaced ? "replace" : "add", { sessionID, job: parsed.job.name || parsed.job.id, label: jobLabel(parsed.job) });
+    await appendLoopLog2(directory, replaced ? "replace" : "add", {
+      sessionID,
+      job: parsed.job.name || parsed.job.id,
+      label: jobLabel(parsed.job),
+      scheduleMode: parsed.job.scheduleMode,
+      scheduleSyntax: parsed.job.scheduleSyntax
+    });
   }
   return { addLoop };
 }
@@ -2007,6 +2373,37 @@ function clearSessionActivity(sessionID) {
   deleteSessionExecutionContext(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 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 previous = Number(lastLogged.get(key) || 0);
+    if (previous > 0 && current - previous < throttleMs)
+      return false;
+    lastLogged.set(key, current);
+    await appendLoopLog2(directory, "deferred", {
+      sessionID,
+      reason,
+      ...extra
+    });
+    return true;
+  }
+  function clearSession(sessionID) {
+    const prefix = `${sessionID || "unknown"}:`;
+    for (const key of lastLogged.keys())
+      if (key.startsWith(prefix))
+        lastLogged.delete(key);
+  }
+  return { logDeferral, clearSession };
+}
+
 // src/source/runtime/scheduler.js
 var DEFAULT_IDLE_DEBOUNCE_MS = 1200;
 var DEFAULT_BUSY_RETRY_MS = 5000;
@@ -2014,37 +2411,6 @@ var DEFAULT_MIN_DUE_TIMER_MS = 250;
 var DEFAULT_MAX_DUE_TIMER_MS = 2147000000;
 var DEFAULT_HEARTBEAT_MS = 2500;
 var DEFAULT_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
-function jobDueAt(job, current = now()) {
-  if (isGoalJob(job) && ["completed", "blocked", "cleared"].includes(job.goalStatus))
-    return Infinity;
-  if (!job.enabled || job.paused)
-    return Infinity;
-  if (job.maxRuns > 0 && (job.runCount || 0) >= job.maxRuns)
-    return Infinity;
-  if (Number(job.runNowRequestedAt || 0) > 0)
-    return current;
-  if (job.watchPaths?.length)
-    return Infinity;
-  const created = Date.parse(job.createdAt || "");
-  if (job.maxRuntimeMs > 0 && Number.isFinite(created) && current - created >= job.maxRuntimeMs)
-    return current;
-  if (job.intervalMs === 0)
-    return current;
-  if (!job.lastRunAt) {
-    if (job.immediate === false)
-      return (Number.isFinite(created) ? created : current) + (job.intervalMs || 0);
-    return current;
-  }
-  return job.lastRunAt + (job.intervalMs || 0);
-}
-function nextDueDelay(state, current = now()) {
-  let soonest = Infinity;
-  for (const job of state.jobs || [])
-    soonest = Math.min(soonest, jobDueAt(job, current));
-  if (!Number.isFinite(soonest))
-    return Infinity;
-  return Math.max(0, soonest - current);
-}
 function createSchedulerRuntime(options = {}) {
   const idleTimers = new Map;
   const dueTimers = new Map;
@@ -2072,6 +2438,7 @@ function createSchedulerRuntime(options = {}) {
     if (options.toast)
       await options.toast(client, message, level);
   };
+  const diagnostics = createSchedulerDiagnostics({ appendLoopLog: appendLog, now: clock, throttleMs: options.deferralLogThrottleMs });
   function stopHeartbeatIfIdle() {
     if (!knownSessions.size && heartbeatTimer) {
       clearIntervalFn(heartbeatTimer);
@@ -2119,11 +2486,13 @@ function createSchedulerRuntime(options = {}) {
       idleTimers.delete(sessionID);
       Promise.resolve().then(async () => {
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy", { source: "idle", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
         await options.finalizeActiveRun?.(directory, client, sessionID);
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy-after-finalize", { source: "idle", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
@@ -2172,11 +2541,13 @@ function createSchedulerRuntime(options = {}) {
       dueTimers.delete(sessionID);
       Promise.resolve().then(async () => {
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy", { source: "due", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
         await options.finalizeActiveRun?.(directory, client, sessionID);
         if (!await options.sessionIsIdle?.(client, sessionID, directory)) {
+          await diagnostics.logDeferral(directory, sessionID, "session-busy-after-finalize", { source: "due", retryMs: busyRetryMs });
           await scheduleDueWork(directory, client, sessionID, busyRetryMs);
           return;
         }
@@ -2196,6 +2567,7 @@ function createSchedulerRuntime(options = {}) {
     cancelIdleWork(sessionID);
     cancelDueWork(sessionID);
     stopWatchdog(sessionID);
+    diagnostics.clearSession(sessionID);
     knownSessions.delete(sessionID);
     stopHeartbeatIfIdle();
   }
@@ -2294,8 +2666,8 @@ ${item.output}`).join(`
 }
 
 // src/source/runtime/job-workspace.js
-import { promises as fs5 } from "fs";
-import path6 from "path";
+import { promises as fs7 } from "fs";
+import path8 from "path";
 var MAX_SCAN_FILES = 200;
 var MAX_SCAN_BYTES = 2000000;
 function requireFunction6(value, name) {
@@ -2330,7 +2702,7 @@ function createJobWorkspaceRuntime(options = {}) {
       return await buildGoalPrompt2(directory, job);
     const sections = [];
     if (job.promptFile) {
-      const text = await readSmallTextFile2(path6.resolve(directory, job.promptFile));
+      const text = await readSmallTextFile2(path8.resolve(directory, job.promptFile));
       if (text.trim())
         sections.push(`Instructions from ${job.promptFile}:
 ${text.trim()}`);
@@ -2340,7 +2712,7 @@ ${text.trim()}`);
     if (job.action)
       sections.push(decoratePrompt(job));
     for (const file of job.includeFiles || []) {
-      const text = await readSmallTextFile2(path6.resolve(directory, file), 80000);
+      const text = await readSmallTextFile2(path8.resolve(directory, file), 80000);
       if (text.trim())
         sections.push(`Context from ${file}:
 ${text.trim().slice(0, 20000)}`);
@@ -2372,7 +2744,7 @@ ${text.trim().slice(0, 20000)}`);
     const snapshot = {};
     for (const file of files || []) {
       try {
-        const stat = await fs5.stat(path6.resolve(directory, file));
+        const stat = await fs7.stat(path8.resolve(directory, file));
         snapshot[file] = `${stat.mtimeMs}:${stat.size}`;
       } catch {
         snapshot[file] = "missing";
@@ -2392,10 +2764,10 @@ ${text.trim().slice(0, 20000)}`);
   }
   async function fileContains(filePath, needle) {
     try {
-      const stat = await fs5.stat(filePath);
+      const stat = await fs7.stat(filePath);
       if (!stat.isFile() || stat.size > MAX_SCAN_BYTES)
         return false;
-      return (await fs5.readFile(filePath, "utf8")).includes(needle);
+      return (await fs7.readFile(filePath, "utf8")).includes(needle);
     } catch {
       return false;
     }
@@ -2403,9 +2775,9 @@ ${text.trim().slice(0, 20000)}`);
   async function untilReached(directory, job) {
     if (!job.until)
       return false;
-    const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path6.join(".opencode", "opencode-loop", "until.txt")];
+    const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path8.join(".opencode", "opencode-loop", "until.txt")];
     for (const file of files)
-      if (await fileContains(path6.resolve(directory, file), job.until))
+      if (await fileContains(path8.resolve(directory, file), job.until))
         return true;
     let scanned = 0;
     async function walk(current) {
@@ -2413,7 +2785,7 @@ ${text.trim().slice(0, 20000)}`);
         return false;
       let entries;
       try {
-        entries = await fs5.readdir(current, { withFileTypes: true });
+        entries = await fs7.readdir(current, { withFileTypes: true });
       } catch {
         return false;
       }
@@ -2422,7 +2794,7 @@ ${text.trim().slice(0, 20000)}`);
           return false;
         if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name))
           continue;
-        const full = path6.join(current, entry.name);
+        const full = path8.join(current, entry.name);
         if (entry.isDirectory()) {
           if (await walk(full))
             return true;
@@ -2446,13 +2818,13 @@ ${text.trim().slice(0, 20000)}`);
     if (!status.stdout.trim())
       return;
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const checkpointDir = path6.join(stateDir(directory), "checkpoints", safeID(sessionID));
+    const checkpointDir = path8.join(stateDir(directory), "checkpoints", safeID(sessionID));
     await ensureDir(checkpointDir);
     const diff = await runProcess2("git", ["diff", "--binary"], directory, 120000);
     const staged = await runProcess2("git", ["diff", "--cached", "--binary"], directory, 120000);
     const prefix = `${timestamp}-${safeID(job.name || job.id)}`;
-    await fs5.writeFile(path6.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr);
-    await fs5.writeFile(path6.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}
+    await fs7.writeFile(path8.join(checkpointDir, `${prefix}.status.txt`), status.stdout + status.stderr);
+    await fs7.writeFile(path8.join(checkpointDir, `${prefix}.patch`), `${diff.stdout}
 ${staged.stdout}`);
     if (job.gitCheckpoint) {
       await runProcess2("git", ["add", "-A"], directory, 120000);
@@ -2535,7 +2907,9 @@ function createSessionStatusRuntime(options = {}) {
     if (directory)
       argsList.push({ query: { directory } }, { directory }, { workspace: directory });
     argsList.push({});
+    let attempted = false;
     for (const args of argsList) {
+      attempted = true;
       try {
         const result = await statusMethod.call(client.session, args);
         const error = sdkError(result);
@@ -2565,7 +2939,7 @@ function createSessionStatusRuntime(options = {}) {
         return { type: "idle", source: "sdk" };
       } catch {}
     }
-    return;
+    return attempted ? { type: "unknown", source: "sdk-error" } : undefined;
   }
   async function canFinalizeActiveRun(directory, client, sessionID, active, options2 = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID))
@@ -2577,19 +2951,42 @@ function createSessionStatusRuntime(options = {}) {
       return true;
     if (!options2.requireIdle)
       return completion === "unknown" && staleActiveRun(sessionID);
+    const cached = sessionStatuses.get(sessionID);
+    const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
+    const cachedIdleAfterRun = cached === "idle" && seenAt > (active.startedAt || 0);
     const live = await readLiveSessionStatus(client, sessionID, directory);
     if (live?.type === "idle")
       return true;
+    if (live?.type === "unknown" && cachedIdleAfterRun) {
+      return true;
+    }
     if (live?.type) {
-      if ((live.type === "busy" || live.type === "retry") && options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
+      if (live.type === "busy" && options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
         return true;
       return false;
     }
     if (options2.forceStale && completion === "unknown" && staleActiveRun(sessionID))
       return true;
-    const cached = sessionStatuses.get(sessionID);
-    const seenAt = sessionStatusSeenAt.get(sessionID) || 0;
-    return cached === "idle" && seenAt > (active.startedAt || 0);
+    return cachedIdleAfterRun;
+  }
+  async function recoverCompletedTailWithoutActiveRun(directory, client, sessionID, liveType, seenAt) {
+    if (activeRuns.has(sessionID))
+      return false;
+    if (liveType !== "busy")
+      return false;
+    if (!seenAt || now2() - seenAt < sessionStatusCacheMs)
+      return false;
+    const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, { startedAt: 0 });
+    if (completion !== "completed")
+      return false;
+    markSessionStatus(sessionID, "idle");
+    await appendLoopLog2(directory, "status-message-idle-recovery", {
+      sessionID,
+      staleStatus: liveType,
+      statusSeenAt: seenAt,
+      staleForMs: Math.max(0, now2() - seenAt)
+    });
+    return true;
   }
   async function sessionStatusType(client, sessionID, directory, options2 = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
@@ -2603,18 +3000,27 @@ function createSessionStatusRuntime(options = {}) {
     if (cached && now2() - seenAt < sessionStatusCacheMs)
       return cached;
     const live = await readLiveSessionStatus(client, sessionID, directory);
+    if (live?.type === "unknown") {
+      const conservative = cached === "retry" ? "retry" : "busy";
+      markSessionStatus(sessionID, conservative);
+      return conservative;
+    }
     if (live?.type) {
+      if (await recoverCompletedTailWithoutActiveRun(directory, client, sessionID, live.type, seenAt))
+        return "idle";
       if ((live.type === "busy" || live.type === "retry") && options2.recoverStaleActive !== false) {
         const active = activeRuns.get(sessionID);
         if (active) {
           const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
-          if (completion === "completed" || completion === "unknown" && staleActiveRun(sessionID)) {
+          if (completion === "completed" || live.type === "busy" && completion === "unknown" && staleActiveRun(sessionID)) {
             markSessionStatus(sessionID, "idle");
-            await appendLoopLog2(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", {
+            const logDetails = {
               sessionID,
               job: active.job?.name || active.jobId,
-              startedAt: active.startedAt
-            });
+              startedAt: active.startedAt,
+              ...completion === "completed" ? {} : { staleStatus: live.type }
+            };
+            await appendLoopLog2(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", logDetails);
             return "idle";
           }
         }
@@ -2830,6 +3236,58 @@ ${prompt}`;
   return { fireAction };
 }
 
+// src/source/runtime/terminal-guard.js
+function messageText(message) {
+  const parts = Array.isArray(message?.parts) ? message.parts : [];
+  const fromParts = parts.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+`).trim();
+  if (fromParts)
+    return fromParts;
+  const info = message?.info || message || {};
+  for (const value of [info.text, info.content, info.summary]) {
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return "";
+}
+async function applyTerminalContinuationGuard(directory, client, sessionID, job, options = {}) {
+  if (job?.scheduleMode !== "idle" || !isCompletionBoundedContinuation(job?.action)) {
+    return { job, terminal: false, pausedNow: false };
+  }
+  const messages = await readRecentSessionMessages(client, sessionID, directory, options.messageLimit || 8);
+  if (!messages)
+    return { job, terminal: false, pausedNow: false };
+  const tail = orderedSessionMessages(messages).at(-1);
+  const info = tail?.info || tail || {};
+  if (info.role !== "assistant")
+    return { job, terminal: false, pausedNow: false };
+  const completed = Number(info?.time?.completed || 0);
+  const created = Number(info?.time?.created || 0);
+  const runStarted = Number(job?.lastRunAt || 0);
+  if (!Number.isFinite(completed) || completed <= 0)
+    return { job, terminal: false, pausedNow: false };
+  if (runStarted > 0 && completed < runStarted && (!Number.isFinite(created) || created < runStarted)) {
+    return { job, terminal: false, pausedNow: false };
+  }
+  const text = messageText(tail);
+  const terminal = isTerminalNoWorkReply(text);
+  if (!terminal) {
+    if (job.terminalNoWorkCount)
+      job.terminalNoWorkCount = 0;
+    return { job, terminal: false, pausedNow: false, text };
+  }
+  job.terminalNoWorkCount = (job.terminalNoWorkCount || 0) + 1;
+  job.lastTerminalNoWorkAt = Date.now();
+  job.lastTerminalNoWorkSummary = text.slice(0, 1000);
+  const threshold = Math.max(2, Number(options.threshold) || 2);
+  const pausedNow = job.terminalNoWorkCount >= threshold && !job.paused;
+  if (pausedNow) {
+    job.paused = true;
+    job.lastFailureReason = "terminal_no_work";
+  }
+  return { job, terminal: true, pausedNow, text };
+}
+
 // src/source/runtime/run-finalization.js
 function requireFunction8(value, label) {
   if (typeof value !== "function")
@@ -2849,7 +3307,14 @@ function createRunFinalizationRuntime(options = {}) {
   const toast2 = typeof options.toast === "function" ? options.toast : toast;
   const writeGoalReport2 = typeof options.writeGoalReport === "function" ? options.writeGoalReport : writeGoalReport;
   const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
+  const applyTerminalContinuationGuard2 = typeof options.applyTerminalContinuationGuard === "function" ? options.applyTerminalContinuationGuard : applyTerminalContinuationGuard;
   async function finalizeJob(directory, client, sessionID, state, job, previousJob) {
+    if (job.infrastructureFailureCount) {
+      job.infrastructureFailureCount = 0;
+      job.lastInfrastructureFailure = "";
+      job.lastInfrastructureError = "";
+      job.lastInfrastructureFailureAt = 0;
+    }
     if (job.verifyCommand) {
       const verify = await runShellCommand2(job.verifyCommand, directory, job.timeoutMs || 300000);
       job.lastVerifyAt = now2();
@@ -2912,6 +3377,18 @@ exit=` + postrun.code + `
       job = await runGoalChecks(directory, sessionID, job, client);
       job = await applyGoalNoProgressGuard(directory, client, sessionID, job, previousJob);
     }
+    const terminal = await applyTerminalContinuationGuard2(directory, client, sessionID, job);
+    job = terminal.job;
+    if (terminal.pausedNow) {
+      await appendLoopLog2(directory, "terminal-no-work", {
+        sessionID,
+        job: job.name || job.id,
+        count: job.terminalNoWorkCount,
+        summary: String(terminal.text || "").slice(0, 1000)
+      });
+      await notifyJob2(directory, job, "terminal_no_work");
+      await toast2(client, "Loop paused: completion-bounded task reported complete with no work remaining twice.", "success");
+    }
     state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate));
     await writeState2(directory, sessionID, state);
     if (isGoalJob(job))
@@ -2924,7 +3401,7 @@ exit=` + postrun.code + `
 }
 
 // src/source/runtime/run-admission.js
-import path7 from "path";
+import path9 from "path";
 function requireFunction9(value, label) {
   if (typeof value !== "function")
     throw new TypeError(`createRunAdmissionRuntime requires ${label}`);
@@ -2941,26 +3418,8 @@ function createRunAdmissionRuntime(options = {}) {
   const notifyJob2 = typeof options.notifyJob === "function" ? options.notifyJob : notifyJob;
   const toast2 = typeof options.toast === "function" ? options.toast : toast;
   const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
-  function dueJobs(state, force = false) {
-    const current = now2();
-    const due = (state.jobs || []).filter((job) => {
-      if (isGoalJob(job) && ["completed", "blocked", "cleared"].includes(job.goalStatus))
-        return false;
-      if (!job.enabled || job.paused)
-        return false;
-      if (job.maxRuns > 0 && (job.runCount || 0) >= job.maxRuns)
-        return false;
-      if (job.maxRuntimeMs > 0 && current - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs)
-        return true;
-      if (Number(job.runNowRequestedAt || 0) > 0)
-        return true;
-      if (force)
-        return true;
-      if (job.watchPaths?.length)
-        return job.watchTriggered === true;
-      return job.intervalMs === 0 || !job.lastRunAt || current - job.lastRunAt >= job.intervalMs;
-    });
-    return due.sort((a, b) => Number(Number(b.runNowRequestedAt || 0) > 0) - Number(Number(a.runNowRequestedAt || 0) > 0));
+  function dueJobs2(state, force = false) {
+    return dueJobs(state, now2(), force);
   }
   async function reschedule(directory, client, sessionID) {
     await scheduleDueWork(directory, client, sessionID);
@@ -2980,7 +3439,7 @@ function createRunAdmissionRuntime(options = {}) {
     if (job.maxRuntimeMs > 0 && now2() - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) {
       return await stopAndRemove(directory, client, sessionID, state, job, "max_runtime_reached", `Loop stopped by --max-runtime: ${job.name || job.id}`, "max-runtime");
     }
-    if (job.stopFile && await pathExists2(path7.resolve(directory, job.stopFile))) {
+    if (job.stopFile && await pathExists2(path9.resolve(directory, job.stopFile))) {
       return await stopAndRemove(directory, client, sessionID, state, job, "stop_file", "Loop stopped by --stop-file: " + job.stopFile);
     }
     if (await untilReached(directory, job)) {
@@ -3023,12 +3482,61 @@ exit=` + preflight.code + `
     }
     return { admitted: true, job, runNowRequested };
   }
-  return { dueJobs, admitJob };
+  return { dueJobs: dueJobs2, admitJob };
+}
+
+// src/source/runtime/network-recovery.js
+var TRANSIENT_NETWORK_PATTERNS = [
+  /\b(?:408|425|429|500|502|503|504|524)\b/i,
+  /rate[\s_-]?limit|too many requests|overloaded|service[\s_-]?unavailable|provider[_ -]?unavailable/i,
+  /terminated|fetch failed|failed to fetch|network[\s_-]?error|network connection lost/i,
+  /connection (?:error|refused|lost)|socket (?:hang up|connection was closed)|reset before headers/i,
+  /\b(?:enotfound|eai_again|econnrefused|econnreset|etimedout|ehostunreach|enetunreach|epipe)\b/i,
+  /\b(?:request|response|connection|network|stream|read) (?:timeout|timed out|time out)\b/i,
+  /\btimeout(?:error)?\b/i
+];
+function errorText(value) {
+  if (value instanceof Error)
+    return `${value.name}: ${value.message}`;
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function isTransientNetworkError(value) {
+  const text = errorText(value);
+  return TRANSIENT_NETWORK_PATTERNS.some((pattern) => pattern.test(text));
+}
+function networkRetryDelayMs(attempt, baseMs = 5000, maxMs = 60000) {
+  const safeAttempt = Math.max(1, Math.floor(Number(attempt) || 1));
+  const safeBase = Math.max(1, Math.floor(Number(baseMs) || 5000));
+  const safeMax = Math.max(safeBase, Math.floor(Number(maxMs) || 60000));
+  return Math.min(safeMax, safeBase * 2 ** Math.min(8, safeAttempt - 1));
+}
+function refundInfrastructureRun(job, snapshot = {}, input = {}) {
+  const chargedCount = Number(snapshot.runCount ?? job.runCount ?? 0);
+  const currentCount = Number(job.runCount || 0);
+  if (chargedCount > 0 && currentCount >= chargedCount)
+    job.runCount = Math.max(0, currentCount - 1);
+  if (Number.isFinite(Number(snapshot.previousLastRunAt)))
+    job.lastRunAt = Number(snapshot.previousLastRunAt);
+  if (snapshot.disabledByMaxRuns && job.maxRuns > 0 && job.runCount < job.maxRuns)
+    job.enabled = true;
+  job.infrastructureFailureCount = (job.infrastructureFailureCount || 0) + 1;
+  job.lastInfrastructureFailure = String(input.reason || "transient_network_failure").slice(0, 120);
+  job.lastInfrastructureError = errorText(input.error).slice(0, 4000);
+  job.lastInfrastructureFailureAt = Number(input.now || Date.now());
+  return job;
 }
 
 // src/source/runtime/executor.js
 var DEFAULT_ACTIVE_GUARD_MS = 45000;
 var DEFAULT_BUSY_RETRY_MS2 = 5000;
+var DEFAULT_PROVIDER_RETRY_WATCHDOG_MS = 2 * 60000;
+var DEFAULT_NETWORK_RETRY_MAX_MS = 60000;
 function requireFunction10(value, label) {
   if (typeof value !== "function")
     throw new TypeError(`createLoopExecutor requires ${label}`);
@@ -3060,8 +3568,11 @@ function createLoopExecutor(options = {}) {
   const dangerousShell2 = typeof options.dangerousShell === "function" ? options.dangerousShell : dangerousShell;
   const activeGuardMs = Number.isFinite(Number(options.activeGuardMs)) && Number(options.activeGuardMs) > 0 ? Number(options.activeGuardMs) : DEFAULT_ACTIVE_GUARD_MS;
   const busyRetryMs = Number.isFinite(Number(options.busyRetryMs)) && Number(options.busyRetryMs) > 0 ? Number(options.busyRetryMs) : DEFAULT_BUSY_RETRY_MS2;
+  const providerRetryWatchdogMs = Number.isFinite(Number(options.providerRetryWatchdogMs)) && Number(options.providerRetryWatchdogMs) > 0 ? Number(options.providerRetryWatchdogMs) : DEFAULT_PROVIDER_RETRY_WATCHDOG_MS;
+  const networkRetryMaxMs = Number.isFinite(Number(options.networkRetryMaxMs)) && Number(options.networkRetryMaxMs) > 0 ? Number(options.networkRetryMaxMs) : DEFAULT_NETWORK_RETRY_MAX_MS;
   const activeRuns = new Map;
   const runLocks = new Map;
+  const retryRuns = new Map;
   const statusRuntime = createSessionStatusRuntime({
     activeRuns,
     appendLoopLog: appendLoopLog2,
@@ -3074,6 +3585,7 @@ function createLoopExecutor(options = {}) {
     updateSessionStatusFromEvent,
     staleActiveRun,
     canFinalizeActiveRun,
+    sessionStatusType,
     sessionIsIdle,
     markSessionStatus,
     clearSessionStatus
@@ -3125,13 +3637,14 @@ function createLoopExecutor(options = {}) {
     toast: toast2,
     dangerousShell: dangerousShell2
   });
-  const dueJobs = admissionRuntime.dueJobs;
+  const dueJobs2 = admissionRuntime.dueJobs;
   function clearActiveRun(sessionID) {
     const active = activeRuns.get(sessionID);
     if (active?.timer)
       clearTimeout(active.timer);
     compactionRuntime.clearForActiveRun(sessionID, active);
     activeRuns.delete(sessionID);
+    retryRuns.delete(sessionID);
   }
   function disposeSession(sessionID) {
     clearActiveRun(sessionID);
@@ -3139,30 +3652,106 @@ function createLoopExecutor(options = {}) {
     compactionRuntime.clear(sessionID);
     clearSessionStatus(sessionID);
   }
+  async function persistInfrastructureRefund(directory, sessionID, active, input = {}) {
+    const state = await readState2(directory, sessionID);
+    const job = (state.jobs || []).find((candidate) => candidate.id === active.jobId);
+    if (!job)
+      return { job: undefined, delayMs: busyRetryMs };
+    refundInfrastructureRun(job, {
+      runCount: active.job?.runCount,
+      previousLastRunAt: active.previousLastRunAt,
+      disabledByMaxRuns: active.disabledByMaxRuns
+    }, {
+      reason: input.reason,
+      error: input.error,
+      now: now2()
+    });
+    state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+    await writeState2(directory, sessionID, state);
+    const delayMs = networkRetryDelayMs(job.infrastructureFailureCount || 1, busyRetryMs, networkRetryMaxMs);
+    return { job, delayMs };
+  }
   async function recoverActiveDispatchFailure(directory, client, sessionID, jobId, runToken, error) {
     const active = activeRuns.get(sessionID);
     if (!active || active.jobId !== jobId || active.runToken !== runToken)
       return false;
+    const transient = isTransientNetworkError(error);
+    const snapshot = active;
     clearActiveRun(sessionID);
     clearSessionStatus(sessionID);
     const message = errorMessage(error);
-    const state = await readState2(directory, sessionID);
-    const job = (state.jobs || []).find((candidate) => candidate.id === jobId);
+    let state = await readState2(directory, sessionID);
+    let job = (state.jobs || []).find((candidate) => candidate.id === jobId);
+    let retryDelay = busyRetryMs;
     if (job) {
-      job.failureCount = (job.failureCount || 0) + 1;
-      job.lastFailureReason = "dispatch_failed";
-      job.lastDispatchFailure = message.slice(0, 4000);
-      job.lastDispatchFailureAt = now2();
-      if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-        job.paused = true;
-        await notifyJob2(directory, job, "dispatch_failed");
+      if (transient) {
+        const refunded = await persistInfrastructureRefund(directory, sessionID, snapshot, {
+          reason: "dispatch_failed_transient",
+          error
+        });
+        job = refunded.job;
+        retryDelay = refunded.delayMs;
+        state = await readState2(directory, sessionID);
+      } else {
+        job.failureCount = (job.failureCount || 0) + 1;
+        job.lastFailureReason = "dispatch_failed";
+        job.lastDispatchFailure = message.slice(0, 4000);
+        job.lastDispatchFailureAt = now2();
+        if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+          job.paused = true;
+          await notifyJob2(directory, job, "dispatch_failed");
+        }
+        state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+        await writeState2(directory, sessionID, state);
       }
-      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
-      await writeState2(directory, sessionID, state);
     }
-    await appendLoopLog2(directory, "dispatch-error", { sessionID, job: job?.name || jobId, error: message });
-    await toast2(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning");
-    await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+    await appendLoopLog2(directory, transient ? "network-dispatch-error" : "dispatch-error", {
+      sessionID,
+      job: job?.name || jobId,
+      error: message,
+      ...transient ? { retryInMs: retryDelay } : {}
+    });
+    if (transient) {
+      await toast2(client, `Loop network dispatch failed; retrying when the session recovers: ${message}`, "warning");
+    } else {
+      await toast2(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning");
+    }
+    await scheduleDueWork(directory, client, sessionID, retryDelay);
+    return true;
+  }
+  async function recoverStuckProviderRetry(directory, client, sessionID) {
+    const active = activeRuns.get(sessionID);
+    if (!active || active.compactionOnly) {
+      retryRuns.delete(sessionID);
+      return false;
+    }
+    const current = retryRuns.get(sessionID);
+    if (!current || current.runToken !== active.runToken) {
+      retryRuns.set(sessionID, { runToken: active.runToken, since: now2() });
+      return false;
+    }
+    if (now2() - current.since < providerRetryWatchdogMs)
+      return false;
+    const snapshot = active;
+    try {
+      if (client?.session?.abort) {
+        await fireSdk2(client, "session.abort provider retry watchdog", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID });
+      }
+    } catch {}
+    clearActiveRun(sessionID);
+    clearSessionStatus(sessionID);
+    const refunded = await persistInfrastructureRefund(directory, sessionID, snapshot, {
+      reason: "provider_retry_watchdog",
+      error: `OpenCode session.status stayed retry for ${providerRetryWatchdogMs}ms`
+    });
+    await appendLoopLog2(directory, "provider-retry-recovery", {
+      sessionID,
+      job: refunded.job?.name || snapshot.jobId,
+      retryForMs: now2() - current.since,
+      retryInMs: refunded.delayMs
+    });
+    await toast2(client, "Loop provider retry exceeded the watchdog; the Loop-owned turn was released and will retry with backoff.", "warning");
+    await scheduleDueWork(directory, client, sessionID, refunded.delayMs);
     return true;
   }
   async function finalizeActiveRun(directory, client, sessionID, finalizeOptions = {}) {
@@ -3213,14 +3802,24 @@ function createLoopExecutor(options = {}) {
     }
     runLocks.set(sessionID, now2());
     let job;
+    let previousLastRunAt = 0;
+    let disabledByMaxRuns = false;
     try {
       await finalizeActiveRun(directory, client, sessionID, { requireIdle: true, forceStale: true });
-      if (!await sessionIsIdle(client, sessionID, directory)) {
+      const statusType = await sessionStatusType(client, sessionID, directory);
+      if (statusType !== "idle") {
+        if (statusType === "retry") {
+          if (await recoverStuckProviderRetry(directory, client, sessionID))
+            return;
+        } else {
+          retryRuns.delete(sessionID);
+        }
         if (runOptions.force)
           await toast2(client, "Loop queued: session is busy; it will run on the next idle check.", "info");
         await reschedule(busyRetryMs);
         return;
       }
+      retryRuns.delete(sessionID);
       const active = activeRuns.get(sessionID);
       const activeAge = active ? now2() - (active.startedAt || 0) : 0;
       const activeGuard = active?.job?.timeoutMs || active?.job?.activeRecoveryMs || activeGuardMs;
@@ -3236,7 +3835,7 @@ function createLoopExecutor(options = {}) {
           candidate.watchTriggered = true;
         }
       }
-      const due = dueJobs(state, Boolean(runOptions.force));
+      const due = dueJobs2(state, Boolean(runOptions.force));
       if (!due.length) {
         await writeState2(directory, sessionID, state);
         await reschedule();
@@ -3274,9 +3873,11 @@ function createLoopExecutor(options = {}) {
       if (runNowRequested)
         delete job.runNowRequestedAt;
       job.watchTriggered = false;
+      previousLastRunAt = Number(job.lastRunAt || 0);
       job.lastRunAt = now2();
       job.runCount = (job.runCount || 0) + 1;
-      if (job.maxRuns > 0 && job.runCount >= job.maxRuns) {
+      disabledByMaxRuns = job.maxRuns > 0 && job.runCount >= job.maxRuns;
+      if (disabledByMaxRuns) {
         job.enabled = false;
         await notifyJob2(directory, job, "max_runs_reached");
       }
@@ -3315,7 +3916,9 @@ function createLoopExecutor(options = {}) {
           startedAt: now2(),
           timer,
           runToken,
-          compactionAction: result.compaction === true
+          compactionAction: result.compaction === true,
+          previousLastRunAt,
+          disabledByMaxRuns
         });
         if (result.compaction && compactionRuntime.isCompleted(sessionID, job.id)) {
           await compactionRuntime.finalize(directory, client, sessionID);
@@ -3330,6 +3933,24 @@ function createLoopExecutor(options = {}) {
         await reschedule(busyRetryMs);
       } catch (error) {
         clearActiveRun(sessionID);
+        if (isTransientNetworkError(error) && job) {
+          const stateAfterFailure = await readState2(directory, sessionID);
+          const persisted = (stateAfterFailure.jobs || []).find((candidate) => candidate.id === job.id);
+          if (persisted) {
+            refundInfrastructureRun(persisted, {
+              runCount: job.runCount,
+              previousLastRunAt,
+              disabledByMaxRuns
+            }, { reason: "action_dispatch_transient", error, now: now2() });
+            stateAfterFailure.jobs = (stateAfterFailure.jobs || []).map((candidate) => candidate.id === persisted.id ? persisted : candidate);
+            await writeState2(directory, sessionID, stateAfterFailure);
+            const delayMs = networkRetryDelayMs(persisted.infrastructureFailureCount || 1, busyRetryMs, networkRetryMaxMs);
+            await appendLoopLog2(directory, "network-action-error", { sessionID, job: persisted.name || persisted.id, error: errorMessage(error), retryInMs: delayMs });
+            await toast2(client, "Loop action hit a transient network failure; the logical run was refunded and will retry.", "warning");
+            await reschedule(delayMs);
+            return;
+          }
+        }
         await toast2(client, `Loop job failed: ${error instanceof Error ? error.message : String(error)}`, "error");
         await appendLoopLog2(directory, "error", {
           sessionID,
@@ -3343,13 +3964,15 @@ function createLoopExecutor(options = {}) {
     }
   }
   return {
-    dueJobs,
+    dueJobs: dueJobs2,
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
     maybeRunDueJobs,
+    sessionStatusType,
     sessionIsIdle,
     updateSessionStatusFromEvent,
     markSessionStatus,