@bybrawe/opencode-loop 0.5.34 → 0.5.35

package/src/source/runtime/executor.js

@@ -10,9 +10,12 @@ 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"
 
 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 +54,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 +77,7 @@ export function createLoopExecutor(options = {}) {
     updateSessionStatusFromEvent,
     staleActiveRun,
     canFinalizeActiveRun,
+    sessionStatusType,
     sessionIsIdle,
     markSessionStatus,
     clearSessionStatus,
@@ -129,6 +140,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 +150,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
   }
 
@@ -217,13 +313,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 +391,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 +444,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 +461,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 +497,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))

package/src/source/runtime/session-status.js

@@ -78,7 +78,9 @@ export function createSessionStatusRuntime(options = {}) {
     const argsList = []
     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)
@@ -91,8 +93,6 @@ export function createSessionStatusRuntime(options = {}) {
           if (typeof observedType !== "string") continue
           markSessionStatus(observedSessionID, observedType, observedAt)
         }
-        // OpenCode's status list contains active sessions; idle sessions are
-        // normally omitted. Clear a completed descendant that was previously busy.
         for (const childID of sessionParents.keys()) {
           if (!isDescendantSession(childID, sessionID) || data[childID]) continue
           markSessionStatus(childID, "idle", observedAt)
@@ -104,7 +104,7 @@ export function createSessionStatusRuntime(options = {}) {
         return { type: "idle", source: "sdk" }
       } catch {}
     }
-    return undefined
+    return attempted ? { type: "unknown", source: "sdk-error" } : undefined
   }
 
   async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
@@ -117,24 +117,29 @@ export function createSessionStatusRuntime(options = {}) {
     if (completion === "completed") return true
     if (!options.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) {
+      // A concrete idle observed after this active run is sufficient to finalize
+      // that run even if a later status read fails. This does not authorize a
+      // new prompt by itself; admission applies its own current status policy.
+      return true
+    }
     if (live?.type) {
-      if ((live.type === "busy" || live.type === "retry") && options.forceStale && completion === "unknown" && staleActiveRun(sessionID)) return true
+      if (live.type === "busy" && options.forceStale && completion === "unknown" && staleActiveRun(sessionID)) return true
       return false
     }
 
     if (options.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") return false
-    // Never override the first fresh busy observation. Waiting at least one cache
-    // window gives the host time to expose a new user/assistant turn if it is real.
+    if (liveType !== "busy") return false
     if (!seenAt || now() - seenAt < sessionStatusCacheMs) return false
     const completion = await activeRunCompletionFromMessages(directory, client, sessionID, { startedAt: 0 })
     if (completion !== "completed") return false
@@ -149,9 +154,6 @@ export function createSessionStatusRuntime(options = {}) {
   }
 
   async function sessionStatusType(client, sessionID, directory, options = {}) {
-    // OpenCode can briefly report an idle session while a long-running tool or
-    // subtask is still executing. Tool lifecycle hooks are the more specific
-    // signal here, so never enqueue another turn until every active call ends.
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
       markSessionStatus(sessionID, "busy")
       return "busy"
@@ -159,38 +161,35 @@ export function createSessionStatusRuntime(options = {}) {
 
     const cached = sessionStatuses.get(sessionID)
     const seenAt = sessionStatusSeenAt.get(sessionID) || 0
-
-    // Idle is safe to trust until OpenCode tells us otherwise. Busy/retry is only
-    // trusted briefly: OpenCode custom commands such as /loop-status create their
-    // own short assistant turn, and some TUI builds do not always emit the final
-    // idle event after that turn. If we cache busy forever, due loop work can get
-    // stuck at "due in every idle" until the user types another command.
     if (cached === "idle") return cached
     if (cached && now() - 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) {
-      // Some OpenCode 1.15.x/1.18.x TUI builds can leave session.status at busy
-      // after a plugin command acknowledgement. If no Loop run exists yet, a
-      // completed assistant tail plus an already-stale busy observation is a
-      // stronger signal than the unchanged live status. A genuinely running turn
-      // has an unfinished assistant tail (or latest user message) and is never
-      // force-recovered by this path.
       if (await recoverCompletedTailWithoutActiveRun(directory, client, sessionID, live.type, seenAt)) return "idle"
 
-      // When a Loop-owned turn exists, use its exact start boundary so an older
-      // completed assistant message can never finalize a newer active run.
       if ((live.type === "busy" || live.type === "retry") && options.recoverStaleActive !== false) {
         const active = activeRuns.get(sessionID)
         if (active) {
           const completion = await activeRunCompletionFromMessages(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 appendLoopLog(directory, completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery", {
+            const logDetails = {
               sessionID,
               job: active.job?.name || active.jobId,
               startedAt: active.startedAt,
-            })
+              ...(completion === "completed" ? {} : { staleStatus: live.type }),
+            }
+            await appendLoopLog(
+              directory,
+              completion === "completed" ? "status-message-complete-recovery" : "status-stale-recovery",
+              logDetails,
+            )
             return "idle"
           }
         }

package/src/source/runtime/terminal-guard.js

@@ -0,0 +1,56 @@
+import { isCompletionBoundedContinuation, isTerminalNoWorkReply } from "../core/continuation.js"
+import { orderedSessionMessages, readRecentSessionMessages } from "../opencode/host.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("\n")
+    .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 ""
+}
+
+export async function applyTerminalContinuationGuard(directory, client, sessionID, job, options = {}) {
+  // `/loop devam et` is intentionally infinite. The guard is only for an
+  // explicit completion-bounded request such as "bitene kadar" / "until done".
+  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 }
+}