@bybrawe/opencode-loop 0.5.15 → 0.5.16

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.5.16
+
+- Treat active OpenCode tools, shell calls, and foreground or background subtasks as busy even if the parent session receives an idle/status event while they are still running.
+- Prevent stale active-run recovery from finalizing a loop turn while any tracked tool call remains active.
+- Added regression coverage proving that a due loop waits for long-running tools and background child sessions, then resumes only after that work finishes and the parent session becomes idle.
+
 ## 0.5.15
 
 - Hardened experimental Goal Mode completion: agent tool completion now requires concrete evidence instead of accepting empty or generic claims.

package/README.md

@@ -16,7 +16,7 @@ v0.5.11 includes a referenced heartbeat scheduler. This is important in OpenCode
 
 ## Current status
 
-**v0.5.15 is a Goal Mode and SDK compatibility hardening release.** It keeps the timer/watchdog reliability fixes from v0.5.11-v0.5.14, then tightens experimental goals with evidence-gated completion, passing-check requirements, no-progress pausing, user-message interruption, explicit workspace paths, and safer active-turn recovery. It also prefers the OpenCode plugin SDK argument shape while keeping fallbacks for older builds.
+**v0.5.16 fixes idle detection during long-running tools and background subtasks.** The scheduler now treats OpenCode tool lifecycle activity and running child sessions as stronger busy signals than a premature parent idle/status event, so due prompts wait instead of filling the queue. It keeps the Goal Mode and SDK compatibility hardening from v0.5.15.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -32,14 +32,14 @@ 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.15 quick behavior guide
+## v0.5.16 quick behavior guide
 
 OpenCode Loop has two triggers now:
 
 1. **Idle/status events** from OpenCode. These are used when OpenCode finishes a turn.
 2. **A real due timer** inside the plugin. This wakes delayed jobs even when no new OpenCode event happens.
 
-All TUI jobs are still idle-safe. If the timer expires while OpenCode is busy, the job does not interrupt the active turn. It waits and retries until the session becomes idle.
+All TUI jobs are still idle-safe. If the timer expires while OpenCode is busy, or while a tool/background child session is still executing, the job does not interrupt the active turn. It waits and retries until that work finishes and the parent session becomes idle.
 
 Simple examples:
 
@@ -352,7 +352,7 @@ Experimental goal mode: keep working until the objective is actually done, block
 
 ### What “when idle” means
 
-OpenCode Loop is idle-safe. It does **not** intentionally start a new agent turn while OpenCode is already busy.
+OpenCode Loop is idle-safe. It does **not** intentionally start a new agent turn while OpenCode is already busy. Active tool calls and running child sessions also count as busy, even if OpenCode emits a premature idle/status signal for the parent during long-running background work.
 
 Example:
 
@@ -1112,6 +1112,12 @@ Improve the application in small safe steps.
 
 ## Changelog highlights
 
+### v0.5.16
+
+- Treat active tools, shell calls, and running foreground/background child sessions as busy even when the parent session appears idle.
+- Prevent stale-run recovery from enqueueing another continuation while tracked background work is still active.
+- Added regression tests for long-running tool calls and background child sessions.
+
 ### v0.5.15
 
 - Hardened experimental Goal Mode completion with concrete evidence, passing-check requirements, no-progress pausing, and user-message interruption.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: heartbeat scheduler, idle-safe loops, scheduled commands, compact scheduling, verification, checkpoints, and persistent coding goals.",
   "type": "module",
   "main": "src/index.js",

package/scripts/smoke-test.mjs

@@ -9,6 +9,7 @@ const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-smoke-"
 const sessionID = "ses_smoke_goal"
 const attempts = { log: 0, prompt: 0, status: 0, toast: 0 }
 const prompts = []
+const liveStatuses = new Map([[sessionID, "idle"]])
 let hooks
 
 function legacyBody(name) {
@@ -31,6 +32,10 @@ const client = {
     showToast: legacyBody("toast"),
   },
   session: {
+    list: async (args) => {
+      assert.equal(args?.query?.directory, directory)
+      return { data: [{ id: sessionID, directory, projectID: "project", title: "smoke", version: "test", time: { created: Date.now(), updated: Date.now() } }] }
+    },
     abort: async (args) => {
       assert.equal(args?.path?.id, sessionID)
       return { data: true }
@@ -55,7 +60,7 @@ const client = {
     status: async (args) => {
       attempts.status++
       assert.equal(args?.query?.directory, directory, "session.status must use query.directory first")
-      return { data: { [sessionID]: { type: "idle" } } }
+      return { data: Object.fromEntries([...liveStatuses].filter(([, type]) => type !== "idle").map(([id, type]) => [id, { type }])) }
     },
     summarize: async (args) => {
       assert.equal(args?.path?.id, sessionID)
@@ -103,6 +108,44 @@ try {
   assert.equal(completedState.jobs[0].paused, true)
   assert.equal(completedState.jobs[0].enabled, false)
 
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const promptCountBeforeBackgroundTool = prompts.length
+  await hooks["tool.execute.before"]({ tool: "bash", sessionID, callID: "call_background" }, { args: {} })
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background task",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundTool, "an active tool call must keep the loop busy even when session.status says idle")
+
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "call_background", args: {} }, { title: "done", output: "", metadata: {} })
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundTool + 1, "the due loop must resume after the active tool finishes and the session becomes idle")
+
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const childSessionID = "ses_background_child"
+  liveStatuses.set(childSessionID, "busy")
+  await hooks.event({ event: { type: "session.created", properties: { info: { id: childSessionID, parentID: sessionID } } } })
+  await hooks.event({ event: { type: "session.status", properties: { sessionID: childSessionID, status: { type: "busy" } } } })
+  const promptCountBeforeBackgroundChild = prompts.length
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background subtask",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 2_700))
+  assert.equal(prompts.length, promptCountBeforeBackgroundChild, "a running background child session must keep its parent loop busy")
+
+  liveStatuses.set(childSessionID, "idle")
+  await hooks.event({ event: { type: "session.status", properties: { sessionID: childSessionID, status: { type: "idle" } } } })
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundChild + 1, "the parent loop must resume after its background child becomes idle")
+
   await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
   assert.equal(attempts.log, 1)
   assert.ok(attempts.prompt >= 1)

package/src/index.js

@@ -30,6 +30,8 @@ const watchdogTimers = new Map()
 const runLocks = new Map()
 const knownSessions = new Map()
 const stateWriteLocks = new Map()
+const activeToolCalls = new Map()
+const sessionParents = new Map()
 let heartbeatTimer
 const sessionStatuses = new Map()
 const sessionStatusSeenAt = new Map()
@@ -570,6 +572,100 @@ function rememberSession(directory, client, sessionID) {
   startHeartbeat()
 }
 
+function hasActiveToolCalls(sessionID) {
+  return (activeToolCalls.get(sessionID)?.size || 0) > 0
+}
+
+function markToolCallActive(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID) || new Set()
+  calls.add(callID)
+  activeToolCalls.set(sessionID, calls)
+  sessionStatuses.set(sessionID, "busy")
+  sessionStatusSeenAt.set(sessionID, now())
+}
+
+function markToolCallFinished(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID)
+  if (!calls) return
+  calls.delete(callID)
+  if (!calls.size) activeToolCalls.delete(sessionID)
+}
+
+function updateSessionRelationship(info, removed = false) {
+  const sessionID = info?.id
+  if (typeof sessionID !== "string") return
+  if (removed || typeof info?.parentID !== "string") sessionParents.delete(sessionID)
+  else sessionParents.set(sessionID, info.parentID)
+}
+
+function updateSessionRelationshipFromEvent(event) {
+  if (!["session.created", "session.updated", "session.deleted"].includes(event?.type)) return
+  updateSessionRelationship(event?.properties?.info, event.type === "session.deleted")
+}
+
+function isDescendantSession(sessionID, ancestorID) {
+  const visited = new Set()
+  let current = sessionID
+  while (sessionParents.has(current) && !visited.has(current)) {
+    visited.add(current)
+    current = sessionParents.get(current)
+    if (current === ancestorID) return true
+  }
+  return false
+}
+
+function hasBusyDescendant(sessionID) {
+  for (const childID of sessionParents.keys()) {
+    if (!isDescendantSession(childID, sessionID)) continue
+    const status = sessionStatuses.get(childID)
+    if (status === "busy" || status === "retry" || hasActiveToolCalls(childID)) return true
+  }
+  return false
+}
+
+async function refreshSessionRelationships(client, directory) {
+  if (!client?.session?.list) return
+  try {
+    const sessions = await sdkCall(
+      client.session.list.bind(client.session),
+      { query: { directory } },
+      { directory },
+      {},
+    )
+    if (Array.isArray(sessions)) for (const info of sessions) updateSessionRelationship(info)
+  } catch {}
+}
+
+function updateToolActivityFromEvent(event) {
+  const props = event?.properties || {}
+  if (event?.type === "message.part.updated") {
+    const part = props.part
+    if (part?.type !== "tool") return
+    const sessionID = part.sessionID || props.sessionID
+    if (["pending", "running"].includes(part.state?.status)) {
+      markToolCallActive({ sessionID, callID: part.callID })
+    }
+    if (["completed", "error"].includes(part.state?.status)) {
+      // Task/subagent hooks have used the part id as their hook call id in some
+      // OpenCode versions, while normal tools use part.callID. Clear either.
+      const identifiers = [...new Set([part.callID, part.id].filter((value) => typeof value === "string"))]
+      for (const callID of identifiers) markToolCallFinished({ sessionID, callID })
+    }
+    return
+  }
+
+  const started = ["session.next.shell.started", "session.next.tool.called"].includes(event?.type)
+  const finished = ["session.next.shell.ended", "session.next.tool.success", "session.next.tool.failed"].includes(event?.type)
+  if (started) markToolCallActive(props)
+  if (finished) markToolCallFinished(props)
+}
+
 function startHeartbeat() {
   if (heartbeatTimer) return
   heartbeatTimer = setInterval(() => {
@@ -607,6 +703,8 @@ function disposeRuntime(directory, client) {
     runLocks.delete(sessionID)
     knownSessions.delete(sessionID)
     loopOwnedUserMessageGuards.delete(sessionID)
+    activeToolCalls.delete(sessionID)
+    sessionParents.delete(sessionID)
     sessionStatuses.delete(sessionID)
     sessionStatusSeenAt.delete(sessionID)
     for (const key of handledCommands.keys()) if (key.startsWith(`${sessionID}:`)) handledCommands.delete(key)
@@ -970,6 +1068,7 @@ function staleActiveRun(sessionID) {
 }
 
 async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
+  if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) return false
   if (!options.requireIdle && !options.forceStale) return true
   if (options.forceStale && staleActiveRun(sessionID)) return true
   if (!options.requireIdle) return false
@@ -992,15 +1091,41 @@ async function readLiveSessionStatus(client, sessionID, directory) {
       const error = sdkError(result)
       if (error) continue
       const data = sdkData(result)
+      if (!data || typeof data !== "object" || Array.isArray(data)) continue
+      const observedAt = now()
+      for (const [observedSessionID, observedStatus] of Object.entries(data)) {
+        const observedType = observedStatus && typeof observedStatus === "object" ? observedStatus.type : undefined
+        if (typeof observedType !== "string") continue
+        sessionStatuses.set(observedSessionID, observedType)
+        sessionStatusSeenAt.set(observedSessionID, 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
+        sessionStatuses.set(childID, "idle")
+        sessionStatusSeenAt.set(childID, observedAt)
+      }
+      if (hasBusyDescendant(sessionID)) return { type: "busy", source: "descendant" }
       const status = data?.[sessionID]
       const type = status && typeof status === "object" ? status.type : undefined
       if (typeof type === "string") return { type, source: "sdk" }
+      return { type: "idle", source: "sdk" }
     } catch {}
   }
   return undefined
 }
 
 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)) {
+    sessionStatuses.set(sessionID, "busy")
+    sessionStatusSeenAt.set(sessionID, now())
+    return "busy"
+  }
+
   const cached = sessionStatuses.get(sessionID)
   const seenAt = sessionStatusSeenAt.get(sessionID) || 0
 
@@ -1971,11 +2096,16 @@ function goalTools(defaultDirectory) {
 
 export const OpenCodeLoopPlugin = async ({ client, directory }) => {
   await log(client, "info", "Plugin initialized", { directory })
+  await refreshSessionRelationships(client, directory)
   return {
     dispose: async () => { disposeRuntime(directory, client) },
     tool: goalTools(directory),
     "command.execute.before": async (input, output) => { await handleCommand(directory, client, input, undefined, undefined, output) },
+    "tool.execute.before": async (input) => { markToolCallActive(input) },
+    "tool.execute.after": async (input) => { markToolCallFinished(input) },
     event: async ({ event }) => {
+      updateSessionRelationshipFromEvent(event)
+      updateToolActivityFromEvent(event)
       if (event.type === "command.executed") {
         const props = event.properties || {}
         await handleCommand(directory, client, props, props.name, props.arguments)