@bybrawe/opencode-loop 0.5.33 → 0.5.35

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,23 +117,43 @@ 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") return false
+    if (!seenAt || now() - seenAt < sessionStatusCacheMs) return false
+    const completion = await activeRunCompletionFromMessages(directory, client, sessionID, { startedAt: 0 })
+    if (completion !== "completed") return false
+    markSessionStatus(sessionID, "idle")
+    await appendLoopLog(directory, "status-message-idle-recovery", {
+      sessionID,
+      staleStatus: liveType,
+      statusSeenAt: seenAt,
+      staleForMs: Math.max(0, now() - seenAt),
+    })
+    return true
   }
 
   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"
@@ -141,32 +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 TUI builds can leave session.status at busy after a
-      // plugin-injected turn until the next user command touches the session.
-      // When the only reason we still think the session is busy is our own stale
-      // active-run guard, recover instead of waiting for another manual command.
+      if (await recoverCompletedTailWithoutActiveRun(directory, client, sessionID, live.type, seenAt)) return "idle"
+
       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 }
+}