@bybrawe/opencode-loop 0.5.34 → 0.5.36

package/src/source/core/continuation.js

@@ -10,11 +10,62 @@ const CONTINUATION_SHORTHANDS = new Set([
   "devam et bakalım",
 ])
 
+const COMPLETION_BOUNDED_PATTERNS = [
+  /\bbitene kadar\b/i,
+  /\b(?:tamamen|komple) projeyi bitir\b/i,
+  /\bişi 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,
+]
+
+const TERMINAL_COMPLETION_PATTERNS = [
+  // JS \b is ASCII-oriented and does not see Turkish dotless ı as a word
+  // character. Use an explicit following delimiter for Turkish terminal forms.
+  /proje tamamland[ıi](?=\s|[.,;:!—-]|$)/i,
+  /\bproject (?:is )?(?:complete|completed|finished|done)\b/i,
+  /\b(?:task|work) (?:is )?(?:complete|completed|finished|done)\b/i,
+]
+
+const TERMINAL_NO_WORK_PATTERNS = [
+  /yap[ıi]lacak (?:başka )?iş yok(?=\s|[.,;:!—-]|$)/i,
+  /başka (?:bir )?iş (?:kalmad[ıi]|yok)(?=\s|[.,;:!—-]|$)/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,
+]
+
+const NEXT_WORK_PATTERNS = [
+  /\bnext(?: step| task)?\b/i,
+  /s[ıi]radaki(?=\s|[.,;:!—-]|$)/i,
+  /sonraki(?=\s|[.,;:!—-]|$)/i,
+  /kalan (?:iş|işler|todo|adım)(?=\s|[.,;:!—-]|$)/i,
+  /\bremaining (?:work|task|todo|step)/i,
+  /devam (?:edeceğim|ediyorum|etmek gerek)(?=\s|[.,;:!—-]|$)/i,
+]
+
 export function isContinuationShorthand(value) {
   return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "))
 }
 
+export function isCompletionBoundedContinuation(value) {
+  const text = String(value || "").trim()
+  return COMPLETION_BOUNDED_PATTERNS.some((pattern) => pattern.test(text))
+}
+
+export 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
+}
+
 export function continuationProjectInstruction(value) {
-  if (!isContinuationShorthand(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."
+  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}`
 }

package/src/source/opencode/host.js

@@ -54,10 +54,22 @@ export function orderedSessionMessages(messages) {
     .map((entry) => entry.message)
 }
 
+export 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())
+}
+
 export 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"
   const completed = Number(info?.time?.completed || 0)
@@ -65,7 +77,16 @@ export async function activeRunCompletionFromMessages(directory, client, session
   if (!Number.isFinite(completed) || completed <= 0) return "incomplete"
   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"
 }
 
 export async function resolveCompactionModel(directory, client, sessionID, preferredModel) {

package/src/source/runtime/empty-turn.js

@@ -0,0 +1,46 @@
+import { actionKind } from "../core/jobs.js"
+
+export const DEFAULT_MAX_EMPTY_TURNS = 2
+
+export function guardsEmptyAssistantTurn(job) {
+  const kind = actionKind(job?.action, job || {})
+  return kind === "prompt" || kind === "goal"
+}
+
+export 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
+}
+
+export 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 }
+}
+
+export function clearEmptyAssistantTurnStreak(job) {
+  if (!job) return job
+  job.emptyTurnCount = 0
+  if (job.lastFailureReason === "empty_turn") delete job.lastFailureReason
+  return job
+}

package/src/source/runtime/executor.js

@@ -10,9 +10,13 @@ import { createCompactionRuntime } from "./compaction.js"
 import { createActionDispatcher } from "./action-dispatch.js"
 import { createRunFinalizationRuntime } from "./run-finalization.js"
 import { createRunAdmissionRuntime } from "./run-admission.js"
+import { isTransientNetworkError, networkRetryDelayMs, refundInfrastructureRun } from "./network-recovery.js"
+import { guardsEmptyAssistantTurn, refundEmptyAssistantTurn, clearEmptyAssistantTurnStreak } from "./empty-turn.js"
 
 const DEFAULT_ACTIVE_GUARD_MS = 45_000
 const DEFAULT_BUSY_RETRY_MS = 5_000
+const DEFAULT_PROVIDER_RETRY_WATCHDOG_MS = 2 * 60_000
+const DEFAULT_NETWORK_RETRY_MAX_MS = 60_000
 
 function requireFunction(value, label) {
   if (typeof value !== "function") throw new TypeError(`createLoopExecutor requires ${label}`)
@@ -51,9 +55,16 @@ export function createLoopExecutor(options = {}) {
   const busyRetryMs = Number.isFinite(Number(options.busyRetryMs)) && Number(options.busyRetryMs) > 0
     ? Number(options.busyRetryMs)
     : DEFAULT_BUSY_RETRY_MS
+  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,
@@ -67,6 +78,8 @@ export function createLoopExecutor(options = {}) {
     updateSessionStatusFromEvent,
     staleActiveRun,
     canFinalizeActiveRun,
+    activeRunCompletion,
+    sessionStatusType,
     sessionIsIdle,
     markSessionStatus,
     clearSessionStatus,
@@ -129,6 +142,7 @@ export function createLoopExecutor(options = {}) {
     if (active?.timer) clearTimeout(active.timer)
     compactionRuntime.clearForActiveRun(sessionID, active)
     activeRuns.delete(sessionID)
+    retryRuns.delete(sessionID)
   }
 
   function disposeSession(sessionID) {
@@ -138,32 +152,116 @@ export function createLoopExecutor(options = {}) {
     clearSessionStatus(sessionID)
   }
 
+  async function persistInfrastructureRefund(directory, sessionID, active, input = {}) {
+    const state = await readState(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: now(),
+    })
+    state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+    await writeState(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 readState(directory, sessionID)
-    const job = (state.jobs || []).find((candidate) => candidate.id === jobId)
+    let state = await readState(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 = now()
-      if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
-        job.paused = true
-        await notifyJob(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 readState(directory, sessionID)
+      } else {
+        job.failureCount = (job.failureCount || 0) + 1
+        job.lastFailureReason = "dispatch_failed"
+        job.lastDispatchFailure = message.slice(0, 4000)
+        job.lastDispatchFailureAt = now()
+        if (job.maxFailures > 0 && job.failureCount >= job.maxFailures) {
+          job.paused = true
+          await notifyJob(directory, job, "dispatch_failed")
+        }
+        state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+        await writeState(directory, sessionID, state)
       }
-      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
-      await writeState(directory, sessionID, state)
     }
 
-    await appendLoopLog(directory, "dispatch-error", { sessionID, job: job?.name || jobId, error: message })
-    await toast(client, `Loop dispatch failed${job?.paused ? " and paused" : ""}: ${message}`, job?.paused ? "error" : "warning")
-    await scheduleDueWork(directory, client, sessionID, busyRetryMs)
+    await appendLoopLog(directory, transient ? "network-dispatch-error" : "dispatch-error", {
+      sessionID,
+      job: job?.name || jobId,
+      error: message,
+      ...(transient ? { retryInMs: retryDelay } : {}),
+    })
+    if (transient) {
+      await toast(client, `Loop network dispatch failed; retrying when the session recovers: ${message}`, "warning")
+    } else {
+      await toast(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: now() })
+      return false
+    }
+    if (now() - current.since < providerRetryWatchdogMs) return false
+
+    const snapshot = active
+    try {
+      if (client?.session?.abort) {
+        await fireSdk(
+          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 appendLoopLog(directory, "provider-retry-recovery", {
+      sessionID,
+      job: refunded.job?.name || snapshot.jobId,
+      retryForMs: now() - current.since,
+      retryInMs: refunded.delayMs,
+    })
+    await toast(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
   }
 
@@ -171,6 +269,7 @@ export function createLoopExecutor(options = {}) {
     const active = activeRuns.get(sessionID)
     if (!active) 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)
@@ -191,6 +290,31 @@ export function createLoopExecutor(options = {}) {
     let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId)
     if (!job) return
     job.lastFinishedAt = now()
+
+    if (completion === "empty" && guardsEmptyAssistantTurn(job)) {
+      const empty = refundEmptyAssistantTurn(job, active, now())
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+      await writeState(directory, sessionID, state)
+      await appendLoopLog(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 notifyJob(directory, job, "empty_turn")
+        await toast(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 toast(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 appendLoopLog(directory, "active-stale-recovery", {
         sessionID,
@@ -217,13 +341,22 @@ export function createLoopExecutor(options = {}) {
     }
     runLocks.set(sessionID, now())
     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 toast(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 ? now() - (active.startedAt || 0) : 0
@@ -286,9 +419,11 @@ export function createLoopExecutor(options = {}) {
 
       if (runNowRequested) delete job.runNowRequestedAt
       job.watchTriggered = false
+      previousLastRunAt = Number(job.lastRunAt || 0)
       job.lastRunAt = now()
       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 notifyJob(directory, job, "max_runs_reached")
       }
@@ -337,6 +472,8 @@ export function createLoopExecutor(options = {}) {
           timer,
           runToken,
           compactionAction: result.compaction === true,
+          previousLastRunAt,
+          disabledByMaxRuns,
         })
         if (result.compaction && compactionRuntime.isCompleted(sessionID, job.id)) {
           await compactionRuntime.finalize(directory, client, sessionID)
@@ -352,6 +489,24 @@ export function createLoopExecutor(options = {}) {
         await reschedule(busyRetryMs)
       } catch (error) {
         clearActiveRun(sessionID)
+        if (isTransientNetworkError(error) && job) {
+          const stateAfterFailure = await readState(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: now() })
+            stateAfterFailure.jobs = (stateAfterFailure.jobs || []).map((candidate) => candidate.id === persisted.id ? persisted : candidate)
+            await writeState(directory, sessionID, stateAfterFailure)
+            const delayMs = networkRetryDelayMs(persisted.infrastructureFailureCount || 1, busyRetryMs, networkRetryMaxMs)
+            await appendLoopLog(directory, "network-action-error", { sessionID, job: persisted.name || persisted.id, error: errorMessage(error), retryInMs: delayMs })
+            await toast(client, "Loop action hit a transient network failure; the logical run was refunded and will retry.", "warning")
+            await reschedule(delayMs)
+            return
+          }
+        }
         await toast(client, `Loop job failed: ${error instanceof Error ? error.message : String(error)}`, "error")
         await appendLoopLog(directory, "error", {
           sessionID,
@@ -370,9 +525,11 @@ export function createLoopExecutor(options = {}) {
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,
     maybeRunDueJobs,
+    sessionStatusType,
     sessionIsIdle,
     updateSessionStatusFromEvent,
     markSessionStatus,

package/src/source/runtime/network-recovery.js

@@ -0,0 +1,40 @@
+const 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) }
+}
+
+export function isTransientNetworkError(value) {
+  const text = errorText(value)
+  return TRANSIENT_NETWORK_PATTERNS.some((pattern) => pattern.test(text))
+}
+
+export function networkRetryDelayMs(attempt, baseMs = 5_000, maxMs = 60_000) {
+  const safeAttempt = Math.max(1, Math.floor(Number(attempt) || 1))
+  const safeBase = Math.max(1, Math.floor(Number(baseMs) || 5_000))
+  const safeMax = Math.max(safeBase, Math.floor(Number(maxMs) || 60_000))
+  return Math.min(safeMax, safeBase * (2 ** Math.min(8, safeAttempt - 1)))
+}
+
+export 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
+}

package/src/source/runtime/run-finalization.js

@@ -5,6 +5,7 @@ import { appendLoopLog as defaultAppendLoopLog, runShellCommand as defaultRunShe
 import { toast as defaultToast } from "../opencode/host.js"
 import { writeGoalReport as defaultWriteGoalReport } from "./goal-runtime.js"
 import { dangerousShell as defaultDangerousShell } from "./job-workspace.js"
+import { applyTerminalContinuationGuard as defaultApplyTerminalContinuationGuard } from "./terminal-guard.js"
 
 function requireFunction(value, label) {
   if (typeof value !== "function") throw new TypeError(`createRunFinalizationRuntime requires ${label}`)
@@ -25,8 +26,22 @@ export function createRunFinalizationRuntime(options = {}) {
   const toast = typeof options.toast === "function" ? options.toast : defaultToast
   const writeGoalReport = typeof options.writeGoalReport === "function" ? options.writeGoalReport : defaultWriteGoalReport
   const dangerousShell = typeof options.dangerousShell === "function" ? options.dangerousShell : defaultDangerousShell
+  const applyTerminalContinuationGuard = typeof options.applyTerminalContinuationGuard === "function"
+    ? options.applyTerminalContinuationGuard
+    : defaultApplyTerminalContinuationGuard
 
   async function finalizeJob(directory, client, sessionID, state, job, previousJob) {
+    // Infrastructure backoff is consecutive, not lifetime. Reaching normal
+    // finalization proves a real Loop-owned turn completed, so the next future
+    // outage should restart from the shortest backoff rather than inheriting an
+    // old 60s cap from unrelated historical network failures.
+    if (job.infrastructureFailureCount) {
+      job.infrastructureFailureCount = 0
+      job.lastInfrastructureFailure = ""
+      job.lastInfrastructureError = ""
+      job.lastInfrastructureFailureAt = 0
+    }
+
     if (job.verifyCommand) {
       const verify = await runShellCommand(job.verifyCommand, directory, job.timeoutMs || 300_000)
       job.lastVerifyAt = now()
@@ -86,6 +101,19 @@ export function createRunFinalizationRuntime(options = {}) {
       job = await applyGoalNoProgressGuard(directory, client, sessionID, job, previousJob)
     }
 
+    const terminal = await applyTerminalContinuationGuard(directory, client, sessionID, job)
+    job = terminal.job
+    if (terminal.pausedNow) {
+      await appendLoopLog(directory, "terminal-no-work", {
+        sessionID,
+        job: job.name || job.id,
+        count: job.terminalNoWorkCount,
+        summary: String(terminal.text || "").slice(0, 1000),
+      })
+      await notifyJob(directory, job, "terminal_no_work")
+      await toast(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))