@bybrawe/opencode-loop 0.5.9 → 0.5.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.5.10
+
+- Added a watchdog loop in addition to one-shot due timers, so recurring jobs keep checking due work even if OpenCode misses an idle event or a due timeout gets effectively stuck behind a stale busy state.
+- Added stronger stale-active-run recovery. If a plugin-injected run is still marked active after the recovery window, the scheduler treats it as finished, finalizes it, and continues without waiting for another manual command such as `/loop-status`.
+- Refreshed session status with workspace-aware calls before trusting cached busy/retry state.
+- Kept `/compact` routing from v0.5.9: `session_compact` first, then `session.compact`, then summarize fallback.
+- This targets the observed case where `/loop 1m ...` only continued after manually running `/loop-status`.
+
 ## 0.5.9
 
 - Fixed stale-busy recovery for TUI sessions. Cached `busy` / `retry` status is now short-lived, so due jobs no longer get stuck at `due in every idle` after `/loop-status` or other short custom-command turns.

package/README.md

@@ -11,7 +11,7 @@ NPM package name: **@bybrawe/opencode-loop**
 
 ## Current status
 
-**v0.5.9 is a reliability hotfix for stale-busy status and `/compact` routing.** It keeps the real due timer from v0.5.8, but no longer trusts a cached `busy` / `retry` session status forever. This fixes the case where `/loop-status` or another short custom-command turn could leave a loop showing `due in every idle` without firing. It also routes scheduled `/compact` through OpenCode's current TUI alias first, with fallback paths for older builds.
+**v0.5.10 is a reliability hotfix for recurring timers that only continued after manual activity.** It keeps the real due timer from v0.5.8 and the stale-busy recovery from v0.5.9, then adds a watchdog checker and stronger stale-active-run recovery. This targets the case where `/loop 1m ...` reaches its due time but does not fire until you run `/loop-status` or type another command. Scheduled `/compact` still routes through OpenCode's current TUI alias first, with fallback paths for older builds.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -27,7 +27,7 @@ The known update-related symptoms from older builds are fixed:
 
 The TUI loop is still intentionally session-bound: it runs while OpenCode is open and the current session emits status/idle events. For long-running background work after closing the terminal or OpenCode, use `opencode-loopd`.
 
-## v0.5.9 quick behavior guide
+## v0.5.10 quick behavior guide
 
 OpenCode Loop has two triggers now:
 
@@ -74,7 +74,7 @@ Run a shell command every 10 minutes when idle.
 
 Experimental persistent goal mode: keep working until the goal is complete, blocked, paused, cleared, or a safety limit is reached.
 
-> Note: OpenCode custom command markdown still creates a tiny assistant turn for slash commands. v0.5.9 keeps these command templates short and asks the model to reply `OK`. The actual loop scheduling is handled locally by the plugin. If that short turn briefly makes OpenCode look busy, the loop now recovers by refreshing stale busy status on the next due retry.
+> Note: OpenCode custom command markdown still creates a tiny assistant turn for slash commands. v0.5.10 keeps these command templates short and asks the model to reply `OK`. The actual loop scheduling is handled locally by the plugin. If that short turn briefly makes OpenCode look busy, the loop now recovers with fresh status checks, stale-active-run recovery, and a watchdog that does not require another manual command.
 
 ## Why this exists
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.9",
-  "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: reliable timers, stale-busy recovery, idle-safe loops, scheduled commands, compact scheduling, verification, checkpoints, and persistent coding goals.",
+  "version": "0.5.10",
+  "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: watchdog timers, stale-busy recovery, idle-safe loops, scheduled commands, compact scheduling, verification, checkpoints, and persistent coding goals.",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/index.js

@@ -5,6 +5,7 @@ import { spawn } from "node:child_process"
 const SERVICE = "opencode-loop"
 const STATE_DIR = ".opencode/opencode-loop"
 const DEFAULT_ACTIVE_GUARD_MS = 60_000
+const STALE_ACTIVE_RECOVERY_MS = 60_000
 const IDLE_DEBOUNCE_MS = 1_200
 const BUSY_RETRY_MS = 5_000
 const SESSION_STATUS_CACHE_MS = 1_500
@@ -19,6 +20,7 @@ const activeRuns = new Map()
 const handledCommands = new Map()
 const idleTimers = new Map()
 const dueTimers = new Map()
+const watchdogTimers = new Map()
 const sessionStatuses = new Map()
 const sessionStatusSeenAt = new Map()
 
@@ -757,7 +759,34 @@ function updateSessionStatusFromEvent(event) {
   return undefined
 }
 
-async function sessionStatusType(client, sessionID) {
+function staleActiveRun(sessionID) {
+  const active = activeRuns.get(sessionID)
+  if (!active) return false
+  const age = now() - (active.startedAt || 0)
+  const configured = Number(active.job?.staleActiveRecoveryMs || active.job?.activeRecoveryMs || 0)
+  const threshold = Number.isFinite(configured) && configured > 0 ? configured : STALE_ACTIVE_RECOVERY_MS
+  return age >= threshold
+}
+
+async function readLiveSessionStatus(client, sessionID, directory) {
+  const argsList = []
+  if (directory) argsList.push({ workspace: directory }, { directory })
+  argsList.push({})
+  for (const args of argsList) {
+    try {
+      const result = await client.session.status(args)
+      const error = sdkError(result)
+      if (error) continue
+      const data = sdkData(result)
+      const status = data?.[sessionID]
+      const type = status && typeof status === "object" ? status.type : undefined
+      if (typeof type === "string") return { type, source: "sdk" }
+    } catch {}
+  }
+  return undefined
+}
+
+async function sessionStatusType(client, sessionID, directory, options = {}) {
   const cached = sessionStatuses.get(sessionID)
   const seenAt = sessionStatusSeenAt.get(sessionID) || 0
 
@@ -769,25 +798,30 @@ async function sessionStatusType(client, sessionID) {
   if (cached === "idle") return cached
   if (cached && now() - seenAt < SESSION_STATUS_CACHE_MS) return cached
 
-  try {
-    const data = await sdkCall(client.session.status.bind(client.session), {}, undefined)
-    const status = data?.[sessionID]
-    const type = status && typeof status === "object" ? status.type : undefined
-    if (typeof type === "string") {
-      sessionStatuses.set(sessionID, type)
+  const live = await readLiveSessionStatus(client, sessionID, directory)
+  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 ((live.type === "busy" || live.type === "retry") && options.recoverStaleActive !== false && staleActiveRun(sessionID)) {
+      sessionStatuses.set(sessionID, "idle")
       sessionStatusSeenAt.set(sessionID, now())
-      return type
+      return "idle"
     }
-  } catch {}
+    sessionStatuses.set(sessionID, live.type)
+    sessionStatusSeenAt.set(sessionID, now())
+    return live.type
+  }
 
-  const fallback = activeRuns.has(sessionID) ? "busy" : "idle"
+  const fallback = activeRuns.has(sessionID) && !staleActiveRun(sessionID) ? "busy" : "idle"
   sessionStatuses.set(sessionID, fallback)
   sessionStatusSeenAt.set(sessionID, now())
   return fallback
 }
 
-async function sessionIsIdle(client, sessionID) {
-  return await sessionStatusType(client, sessionID) === "idle"
+async function sessionIsIdle(client, sessionID, directory, options = {}) {
+  return await sessionStatusType(client, sessionID, directory, options) === "idle"
 }
 
 function scheduleIdleWork(directory, client, sessionID) {
@@ -797,12 +831,12 @@ function scheduleIdleWork(directory, client, sessionID) {
     idleTimers.delete(sessionID)
     Promise.resolve()
       .then(async () => {
-        if (!await sessionIsIdle(client, sessionID)) {
+        if (!await sessionIsIdle(client, sessionID, directory)) {
           await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS)
           return
         }
         await finalizeActiveRun(directory, client, sessionID)
-        if (!await sessionIsIdle(client, sessionID)) {
+        if (!await sessionIsIdle(client, sessionID, directory)) {
           await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS)
           return
         }
@@ -836,6 +870,35 @@ function nextDueDelay(state) {
   return Math.max(0, soonest - current)
 }
 
+async function startWatchdog(directory, client, sessionID) {
+  if (watchdogTimers.has(sessionID)) return
+  const timer = setInterval(() => {
+    Promise.resolve()
+      .then(async () => {
+        const state = await readState(directory, sessionID)
+        const delay = nextDueDelay(state)
+        const hasJobs = (state.jobs || []).some((job) => job.enabled !== false && !job.paused && (!isGoalJob(job) || !["completed", "blocked", "cleared"].includes(job.goalStatus)))
+        if (!hasJobs || !Number.isFinite(delay)) {
+          const existing = watchdogTimers.get(sessionID)
+          if (existing) clearInterval(existing)
+          watchdogTimers.delete(sessionID)
+          return
+        }
+        if (delay <= 0) await maybeRunDueJobs(directory, client, sessionID)
+        else await scheduleDueWork(directory, client, sessionID)
+      })
+      .catch((error) => appendLoopLog(directory, "watchdog-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {}))
+  }, Math.max(1_000, BUSY_RETRY_MS))
+  if (typeof timer.unref === "function") timer.unref()
+  watchdogTimers.set(sessionID, timer)
+}
+
+function stopWatchdog(sessionID) {
+  const timer = watchdogTimers.get(sessionID)
+  if (timer) clearInterval(timer)
+  watchdogTimers.delete(sessionID)
+}
+
 async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
   const previous = dueTimers.get(sessionID)
   if (previous) clearTimeout(previous)
@@ -852,12 +915,12 @@ async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
     dueTimers.delete(sessionID)
     Promise.resolve()
       .then(async () => {
-        if (!await sessionIsIdle(client, sessionID)) {
+        if (!await sessionIsIdle(client, sessionID, directory)) {
           await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS)
           return
         }
         await finalizeActiveRun(directory, client, sessionID)
-        if (!await sessionIsIdle(client, sessionID)) {
+        if (!await sessionIsIdle(client, sessionID, directory)) {
           await scheduleDueWork(directory, client, sessionID, BUSY_RETRY_MS)
           return
         }
@@ -869,6 +932,7 @@ async function scheduleDueWork(directory, client, sessionID, minDelayMs = 0) {
       })
   }, wait)
   dueTimers.set(sessionID, timer)
+  await startWatchdog(directory, client, sessionID)
 }
 
 function dueJobs(state, force = false) {
@@ -1132,7 +1196,7 @@ ${prompt}` }] } })
 async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
   const reschedule = async (minDelayMs = 0) => { await scheduleDueWork(directory, client, sessionID, minDelayMs) }
 
-  if (!await sessionIsIdle(client, sessionID)) {
+  if (!await sessionIsIdle(client, sessionID, directory)) {
     if (options.force) await toast(client, "Loop queued: session is busy; it will run on the next idle check.", "info")
     await reschedule(BUSY_RETRY_MS)
     return
@@ -1291,6 +1355,7 @@ async function stopLoop(directory, client, sessionID, args) {
     await removeState(directory, sessionID)
     clearActiveRun(sessionID)
     const due = dueTimers.get(sessionID); if (due) clearTimeout(due); dueTimers.delete(sessionID)
+    stopWatchdog(sessionID)
     await toast(client, "All loops stopped for this session.", "success")
     return
   }