@bybrawe/opencode-loop 0.5.8 → 0.5.10

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 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.
+- Improved due-timer behavior when OpenCode misses or delays the final idle event after a command turn.
+- Fixed `/compact` routing for current OpenCode TUI builds by trying `session_compact` first, then `session.compact`, then the session summarize fallback.
+- Kept the command markdown templates short; OpenCode still creates a tiny `OK` turn for custom commands because markdown commands are prompt templates.
+
 ## 0.5.8
 
 - Added a real due timer for TUI loop jobs, so delayed jobs can wake without waiting for another OpenCode event.

package/README.md

@@ -11,7 +11,7 @@ NPM package name: **@bybrawe/opencode-loop**
 
 ## Current status
 
-**v0.5.8 is a reliability hotfix for the new loop types and Experimental Goal Mode.** It adds a real due timer in addition to OpenCode idle/status events, so delayed jobs such as `/loop 1m --no-now ...`, `/loop-command 1m --no-now /compact`, `/loop-ask 1h ...`, and `/loop-shell 10m ...` do not depend on another user action to wake the scheduler. The TUI loop still waits for the session to become idle before starting work, debounces idle events, and avoids starting a new run while OpenCode is busy or queued.
+**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.8 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.8 keeps these command templates short and asks the model to reply `OK`. The actual loop scheduling is handled locally by the plugin.
+> 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.8",
-  "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: reliable timers, 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,8 +5,10 @@ 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
 const MIN_DUE_TIMER_MS = 250
 const MAX_DUE_TIMER_MS = 2_147_000_000
 const MAX_SCAN_FILES = 200
@@ -18,7 +20,9 @@ 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()
 
 const DEFAULT_PROGRESS_MD = `# Progress
 
@@ -389,16 +393,22 @@ async function executeTuiCommand(client, command) {
 
 function compactTuiCommandName(command = "compact") {
   const normalized = String(command || "compact").replace(/^\/+/, "").trim().toLowerCase()
-  if (normalized === "compact" || normalized === "summarize") return "session.compact"
+  if (normalized === "compact" || normalized === "summarize") return "session_compact"
   return undefined
 }
 
 async function compactSession(client, sessionID) {
-  try {
-    await executeTuiCommand(client, "session.compact")
-    return true
-  } catch (error) {
-    await log(client, "warn", "tui session.compact failed", { error: sdkErrorMessage(error) })
+  // OpenCode's TUI API accepts legacy keybind aliases (session_compact) in
+  // current builds, while some older docs/examples mention the event value
+  // (session.compact). Try the alias first, then the event value, then the
+  // session summarize endpoint as a last resort.
+  for (const command of ["session_compact", "session.compact"]) {
+    try {
+      await executeTuiCommand(client, command)
+      return true
+    } catch (error) {
+      await log(client, "warn", `tui ${command} failed`, { error: sdkErrorMessage(error) })
+    }
   }
   try {
     await sdkCall(client.session.summarize.bind(client.session), { sessionID }, { path: { id: sessionID }, body: {} })
@@ -734,36 +744,84 @@ function updateSessionStatusFromEvent(event) {
   if (typeof sessionID !== "string") return undefined
   if (event?.type === "session.idle") {
     sessionStatuses.set(sessionID, "idle")
+    sessionStatusSeenAt.set(sessionID, now())
     return { sessionID, idle: true }
   }
   if (event?.type === "session.status") {
     const status = event?.properties?.status
     const type = status && typeof status === "object" ? status.type : undefined
-    if (typeof type === "string") sessionStatuses.set(sessionID, type)
+    if (typeof type === "string") {
+      sessionStatuses.set(sessionID, type)
+      sessionStatusSeenAt.set(sessionID, now())
+    }
     return { sessionID, idle: type === "idle" }
   }
   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)
-  if (cached && cached !== "idle") 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)
-      return type
+  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 < SESSION_STATUS_CACHE_MS) return cached
+
+  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 "idle"
     }
-  } catch {}
-  const fallback = activeRuns.has(sessionID) ? "busy" : "idle"
+    sessionStatuses.set(sessionID, live.type)
+    sessionStatusSeenAt.set(sessionID, now())
+    return live.type
+  }
+
+  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) {
@@ -773,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
         }
@@ -812,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)
@@ -828,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
         }
@@ -845,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) {
@@ -1077,7 +1165,7 @@ async function fireAction(directory, client, sessionID, job) {
     }
     const tuiCommand = compactTuiCommandName(command)
     if (tuiCommand) {
-      await executeTuiCommand(client, tuiCommand)
+      await compactSession(client, sessionID)
       return { startsAssistantTurn: true }
     }
     await sdkCall(client.session.command.bind(client.session), { sessionID, command, arguments: argumentsText }, { path: { id: sessionID }, body: { command, arguments: argumentsText } })
@@ -1108,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
@@ -1267,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
   }