@bybrawe/opencode-loop 0.5.34 → 0.5.36

package/src/index.js

@@ -801,11 +801,25 @@ function orderedSessionMessages(messages) {
     return { message, index, created: Number.isFinite(created) ? created : 0 };
   }).sort((a, b) => a.created - b.created || a.index - b.index).map((entry) => entry.message);
 }
+function assistantMessageHasMeaningfulActivity(message) {
+  const parts = Array.isArray(message?.parts) ? message.parts : [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object")
+      continue;
+    if (part.type === "text" && typeof part.text === "string" && part.text.trim())
+      return true;
+    if (["tool", "file", "patch", "artifact"].includes(String(part.type || "")))
+      return true;
+  }
+  const info = message?.info || message || {};
+  return [info.text, info.content, info.summary].some((value) => typeof value === "string" && value.trim());
+}
 async function activeRunCompletionFromMessages(directory, client, sessionID, active) {
   const messages = await readRecentSessionMessages(client, sessionID, directory);
   if (!messages)
     return "unknown";
-  const tail = orderedSessionMessages(messages).at(-1);
+  const ordered = orderedSessionMessages(messages);
+  const tail = ordered.at(-1);
   const info = tail?.info || tail;
   if (!info || info.role !== "assistant")
     return "incomplete";
@@ -816,7 +830,17 @@ async function activeRunCompletionFromMessages(directory, client, sessionID, act
   const startedAt = Number(active?.startedAt || 0);
   if (startedAt > 0 && completed < startedAt && (!Number.isFinite(created) || created < startedAt))
     return "incomplete";
-  return "completed";
+  const relevant = ordered.filter((message) => {
+    const candidate = message?.info || message || {};
+    if (candidate.role !== "assistant")
+      return false;
+    if (startedAt <= 0)
+      return true;
+    const candidateCreated = Number(candidate?.time?.created || 0);
+    const candidateCompleted = Number(candidate?.time?.completed || 0);
+    return candidateCreated >= startedAt || candidateCompleted >= startedAt;
+  });
+  return relevant.some(assistantMessageHasMeaningfulActivity) ? "completed" : "empty";
 }
 async function resolveCompactionModel(directory, client, sessionID, preferredModel) {
   const preferred = normalizedModelRef(preferredModel);
@@ -1033,13 +1057,55 @@ var CONTINUATION_SHORTHANDS = new Set([
   "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))
+  if (!isContinuationShorthand(value) && !isCompletionBoundedContinuation(value))
     return "";
-  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.";
+  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
@@ -2811,6 +2877,9 @@ function nonNegativeNumber(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number >= 0 ? number : fallback;
 }
+function settledAssistantCompletion(value) {
+  return value === "completed" || value === "empty";
+}
 function createSessionStatusRuntime(options = {}) {
   const activeRuns = options.activeRuns;
   if (!(activeRuns instanceof Map))
@@ -2865,7 +2934,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);
@@ -2895,7 +2966,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))
@@ -2903,33 +2974,37 @@ function createSessionStatusRuntime(options = {}) {
     if (!options2.requireIdle && !options2.forceStale)
       return true;
     const completion = options2.forceStale ? await activeRunCompletionFromMessages2(directory, client, sessionID, active) : undefined;
-    if (completion === "completed")
+    if (settledAssistantCompletion(completion))
       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" && liveType !== "retry")
+    if (liveType !== "busy")
       return false;
     if (!seenAt || now2() - seenAt < sessionStatusCacheMs)
       return false;
     const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, { startedAt: 0 });
-    if (completion !== "completed")
+    if (!settledAssistantCompletion(completion))
       return false;
     markSessionStatus(sessionID, "idle");
     await appendLoopLog2(directory, "status-message-idle-recovery", {
@@ -2952,6 +3027,11 @@ 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";
@@ -2959,13 +3039,16 @@ function createSessionStatusRuntime(options = {}) {
         const active = activeRuns.get(sessionID);
         if (active) {
           const completion = await activeRunCompletionFromMessages2(directory, client, sessionID, active);
-          if (completion === "completed" || completion === "unknown" && staleActiveRun(sessionID)) {
+          if (settledAssistantCompletion(completion) || 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 }
+            };
+            const recoveryEvent = completion === "empty" ? "status-message-empty-recovery" : completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery";
+            await appendLoopLog2(directory, recoveryEvent, logDetails);
             return "idle";
           }
         }
@@ -2987,6 +3070,7 @@ function createSessionStatusRuntime(options = {}) {
     staleActiveRun,
     canFinalizeActiveRun,
     readLiveSessionStatus,
+    activeRunCompletion: activeRunCompletionFromMessages2,
     sessionStatusType,
     sessionIsIdle
   };
@@ -3181,6 +3265,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")
@@ -3200,7 +3336,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();
@@ -3263,6 +3406,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))
@@ -3359,9 +3514,102 @@ exit=` + preflight.code + `
   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/empty-turn.js
+var DEFAULT_MAX_EMPTY_TURNS = 2;
+function guardsEmptyAssistantTurn(job) {
+  const kind = actionKind(job?.action, job || {});
+  return kind === "prompt" || kind === "goal";
+}
+function emptyTurnLimit(job) {
+  const configured = Number(job?.maxEmptyTurns || 0);
+  if (Number.isFinite(configured) && configured > 0)
+    return Math.max(1, Math.floor(configured));
+  return DEFAULT_MAX_EMPTY_TURNS;
+}
+function refundEmptyAssistantTurn(job, active = {}, timestamp = Date.now()) {
+  const chargedCount = Number(active?.job?.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(active?.previousLastRunAt)))
+    job.lastRunAt = Number(active.previousLastRunAt);
+  if (active?.disabledByMaxRuns && Number(job?.maxRuns || 0) > 0 && Number(job?.runCount || 0) < Number(job.maxRuns)) {
+    job.enabled = true;
+  }
+  job.emptyTurnCount = Number(job.emptyTurnCount || 0) + 1;
+  job.lastEmptyTurnAt = Number(timestamp) || Date.now();
+  job.lastFailureReason = "empty_turn";
+  const limit = emptyTurnLimit(job);
+  const paused = job.emptyTurnCount >= limit;
+  if (paused) {
+    job.paused = true;
+    delete job.runNowRequestedAt;
+  } else {
+    job.runNowRequestedAt = Math.max(1, Number(timestamp) || Date.now());
+  }
+  return { job, paused, count: job.emptyTurnCount, limit };
+}
+function clearEmptyAssistantTurnStreak(job) {
+  if (!job)
+    return job;
+  job.emptyTurnCount = 0;
+  if (job.lastFailureReason === "empty_turn")
+    delete job.lastFailureReason;
+  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}`);
@@ -3393,8 +3641,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,
@@ -3407,6 +3658,8 @@ function createLoopExecutor(options = {}) {
     updateSessionStatusFromEvent,
     staleActiveRun,
     canFinalizeActiveRun,
+    activeRunCompletion,
+    sessionStatusType,
     sessionIsIdle,
     markSessionStatus,
     clearSessionStatus
@@ -3465,6 +3718,7 @@ function createLoopExecutor(options = {}) {
       clearTimeout(active.timer);
     compactionRuntime.clearForActiveRun(sessionID, active);
     activeRuns.delete(sessionID);
+    retryRuns.delete(sessionID);
   }
   function disposeSession(sessionID) {
     clearActiveRun(sessionID);
@@ -3472,30 +3726,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 = {}) {
@@ -3504,6 +3834,7 @@ function createLoopExecutor(options = {}) {
       return;
     if (!await canFinalizeActiveRun(directory, client, sessionID, active, finalizeOptions))
       return false;
+    const completion = await activeRunCompletion(directory, client, sessionID, active);
     const recoveredStale = staleActiveRun(sessionID);
     if (active.compactionOnly) {
       const pending = compactionRuntime.getPending(sessionID);
@@ -3524,6 +3855,30 @@ function createLoopExecutor(options = {}) {
     if (!job)
       return;
     job.lastFinishedAt = now2();
+    if (completion === "empty" && guardsEmptyAssistantTurn(job)) {
+      const empty = refundEmptyAssistantTurn(job, active, now2());
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate);
+      await writeState2(directory, sessionID, state);
+      await appendLoopLog2(directory, "empty-assistant-turn", {
+        sessionID,
+        job: job.name || job.id,
+        count: empty.count,
+        limit: empty.limit,
+        paused: empty.paused,
+        refunded: true
+      });
+      if (empty.paused) {
+        await notifyJob2(directory, job, "empty_turn");
+        await toast2(client, "Loop paused after " + empty.count + " consecutive completed assistant turns with no visible output or tool activity. Resume after changing the model/prompt or use /loop-resume.", "warning");
+        await scheduleDueWork(directory, client, sessionID);
+      } else {
+        await toast2(client, "Loop received an empty completed assistant turn; the logical run was refunded and will retry once.", "warning");
+        await scheduleDueWork(directory, client, sessionID, busyRetryMs);
+      }
+      return true;
+    }
+    if (completion === "completed")
+      clearEmptyAssistantTurnStreak(job);
     if (recoveredStale) {
       await appendLoopLog2(directory, "active-stale-recovery", {
         sessionID,
@@ -3546,14 +3901,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;
@@ -3607,9 +3972,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");
       }
@@ -3648,7 +4015,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);
@@ -3663,6 +4032,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,
@@ -3680,9 +4067,11 @@ function createLoopExecutor(options = {}) {
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
     maybeRunDueJobs,
+    sessionStatusType,
     sessionIsIdle,
     updateSessionStatusFromEvent,
     markSessionStatus,