@bybrawe/opencode-loop 0.5.21 → 0.5.23

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.5.23
+
+- Track non-blocking `session.prompt` and `session.shell` dispatch promises instead of treating every fire-and-forget request as successfully started.
+- Recover a rejected scheduler dispatch immediately: clear only the matching active run token, invalidate cached busy status, persist the failure, honor `--max-failures`, and reschedule through the normal scheduler path.
+- Never replay a rejected prompt automatically; this avoids duplicate turns when OpenCode status/events are delayed or multiple instances are involved.
+- Added a deterministic regression test for delayed prompt rejection and verified the error remains observable in plugin logs.
+
+## 0.5.22
+
+- Hardened compatibility with current OpenCode 1.18.15 while preserving the existing `>=1.4.0` peer range.
+- Handled loop commands now also set `output.noReply = true`; OpenCode 1.18.x safely ignores the unknown field, while hosts that add the proposed `noReply` hook support can skip the acknowledgement model turn automatically.
+- Added Bun runtime loading coverage so CI exercises the runtime OpenCode actually uses to load plugins, not only Node syntax/tests.
+- Added explicit minimum-peer coverage against `@opencode-ai/plugin@1.4.0` and scheduled testing against the latest published OpenCode plugin package.
+- Kept the v0.5.21 server-plugin acknowledgement fallback for current OpenCode versions where `command.execute.before` cannot cancel the prompt turn.
+
 ## 0.5.21
 
 - Verified server-plugin compatibility against OpenCode 1.18.15 and updated the development plugin dependency accordingly.

package/README.md

@@ -16,7 +16,7 @@ v0.5.11 includes a referenced heartbeat scheduler. This is important in OpenCode
 
 ## Current status
 
-**v0.5.21 targets current OpenCode 1.18.x compatibility and safer releases.** Server-plugin control commands keep their locked-down acknowledgement prompt instead of creating an empty command message, `/compact` prefers the current `session.compact` TUI command, and CI now covers Ubuntu and Windows before publishing. **v0.5.20 fixes Windows TUI state writes.** Session job state is written through the OS temp directory with rename plus copy/unlink fallback and short retries, so antivirus locks and OpenCode snapshots no longer drop `/loop` jobs with `EPERM` on rename. **v0.5.19** hardens Goal Mode, package updates, and the background daemon: package installs are pinned to the installed version so OpenCode cannot keep loading an older cached release, scheduler-created goal messages no longer self-interrupt on delayed updates, finite daemon failures return nonzero, model/agent selection is supported, Windows scheduled tasks use a short launcher that stays below the `/TR` limit, and asynchronous release verification is reliable under load.
+**v0.5.23 adds immediate, token-safe recovery when a scheduler prompt/shell dispatch is rejected, without automatically replaying the prompt.** **v0.5.22 adds forward-compatible OpenCode command handling plus Bun and peer-range compatibility CI.** **v0.5.21 targets current OpenCode 1.18.x compatibility and safer releases.** Server-plugin control commands keep their locked-down acknowledgement prompt instead of creating an empty command message, `/compact` prefers the current `session.compact` TUI command, and CI now covers Ubuntu and Windows before publishing. **v0.5.20 fixes Windows TUI state writes.** Session job state is written through the OS temp directory with rename plus copy/unlink fallback and short retries, so antivirus locks and OpenCode snapshots no longer drop `/loop` jobs with `EPERM` on rename. **v0.5.19** hardens Goal Mode, package updates, and the background daemon: package installs are pinned to the installed version so OpenCode cannot keep loading an older cached release, scheduler-created goal messages no longer self-interrupt on delayed updates, finite daemon failures return nonzero, model/agent selection is supported, Windows scheduled tasks use a short launcher that stays below the `/TR` limit, and asynchronous release verification is reliable under load.
 
 The known update-related symptoms from older builds are fixed:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "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/comprehensive-test.mjs

@@ -75,6 +75,10 @@ async function createHarness(options = {}) {
         assert.equal(args?.path?.id, sessionID)
         const text = args.body.parts.map((part) => part.text || "").join("\n")
         records.prompts.push({ text, noReply: args.body.noReply === true, agent: args.body.agent, model: args.body.model })
+        if (options.failPrompt) {
+          await delay(options.promptFailureDelayMs ?? 20)
+          throw new Error(options.promptFailureMessage || "simulated prompt dispatch failure")
+        }
         return { data: true }
       },
       shell: async (args) => {
@@ -374,6 +378,32 @@ async function testActionRoutingAndSafety() {
   }
 }
 
+async function testPromptDispatchFailureRecovery() {
+  const h = await createHarness({ failPrompt: true, promptFailureDelayMs: 25 })
+  try {
+    await h.command("loop", "0s --no-now --name dispatch-failure --max-failures 1 recover from a rejected prompt dispatch")
+    await h.command("loop-now", "dispatch-failure")
+
+    let state
+    for (let attempt = 0; attempt < 40; attempt++) {
+      state = await h.readState()
+      if (state.jobs[0]?.lastFailureReason === "dispatch_failed") break
+      await delay(25)
+    }
+
+    const job = state.jobs[0]
+    assert.equal(job.failureCount, 1, "a rejected prompt dispatch must count as a scheduler failure")
+    assert.equal(job.paused, true, "--max-failures must pause after a rejected prompt dispatch")
+    assert.equal(job.lastFailureReason, "dispatch_failed")
+    assert.match(job.lastDispatchFailure, /simulated prompt dispatch failure/)
+    assert.ok(job.lastDispatchFailureAt > 0)
+    assert.equal(h.actionTexts().length, 1, "dispatch recovery must never replay the prompt automatically")
+    assert.ok(h.records.logs.some((entry) => entry.message === "session.prompt failed"), "the SDK rejection must remain observable")
+  } finally {
+    await h.cleanup()
+  }
+}
+
 async function testStopsPreflightAndGoalLifecycle() {
   let h = await createHarness()
   try {
@@ -563,6 +593,7 @@ await testParserAndPresets()
 await testLifecycleAndCommandDedupe()
 await testWatchScheduling()
 await testActionRoutingAndSafety()
+await testPromptDispatchFailureRecovery()
 await testStopsPreflightAndGoalLifecycle()
 await testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt()
 await testInitializationDoesNotWaitForLocalApi()

package/scripts/smoke-test.mjs

@@ -94,6 +94,7 @@ try {
   }, output)
   assert.equal(output.parts.length, 1, "a locally handled slash command must keep a valid acknowledgement prompt")
   assert.equal(output.parts[0].text, "original command body")
+  assert.equal(output.noReply, true, "handled commands should request noReply for compatible OpenCode hosts")
 
   await hooks["command.execute.before"]({ command: "loop-now", sessionID, arguments: "goal" }, { parts: [] })
   assert.equal(

package/src/index.js

@@ -510,9 +510,11 @@ async function sdkCall(method, ...argsList) {
 }
 
 function fireSdk(client, label, method, ...argsList) {
-  Promise.resolve()
-    .then(() => sdkCall(method, ...argsList))
-    .catch((error) => log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }))
+  const pending = Promise.resolve().then(() => sdkCall(method, ...argsList))
+  void pending.catch((error) => {
+    log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }).catch(() => {})
+  })
+  return pending
 }
 
 async function executeTuiCommand(client, command) {
@@ -1449,6 +1451,36 @@ function clearActiveRun(sessionID) {
   activeRuns.delete(sessionID)
 }
 
+async function recoverActiveDispatchFailure(directory, client, sessionID, jobId, runToken, error) {
+  const active = activeRuns.get(sessionID)
+  if (!active || active.jobId !== jobId || active.runToken !== runToken) return false
+
+  clearActiveRun(sessionID)
+  sessionStatuses.delete(sessionID)
+  sessionStatusSeenAt.delete(sessionID)
+
+  const message = sdkErrorMessage(error)
+  const state = await readState(directory, sessionID)
+  const job = (state.jobs || []).find((candidate) => candidate.id === jobId)
+  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")
+    }
+    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, BUSY_RETRY_MS)
+  return true
+}
+
 function goalReportPath(directory, sessionID, job) {
   return path.join(stateDir(directory), GOAL_REPORT_DIR, `${safeID(sessionID)}-${safeID(job.name || job.id)}.md`)
 }
@@ -1786,7 +1818,7 @@ async function fireAction(directory, client, sessionID, job) {
     guardLoopOwnedUserMessage(sessionID)
     const shellBody = { command, agent }
     if (model) shellBody.model = model
-    fireSdk(
+    const dispatch = fireSdk(
       client,
       "session.shell",
       client.session.shell.bind(client.session),
@@ -1794,7 +1826,7 @@ async function fireAction(directory, client, sessionID, job) {
       { path: { sessionID }, body: shellBody },
       { sessionID, ...shellBody },
     )
-    return { startsAssistantTurn: true }
+    return { startsAssistantTurn: true, dispatch }
   }
   const prompt = await buildPrompt(directory, job)
   const prefix = kind === "goal"
@@ -1806,7 +1838,7 @@ ${prompt}`
   guardLoopOwnedUserMessage(sessionID)
   const promptBody = { agent, parts: [{ type: "text", text: promptText }] }
   if (model) promptBody.model = model
-  fireSdk(
+  const dispatch = fireSdk(
     client,
     "session.prompt",
     client.session.prompt.bind(client.session),
@@ -1814,7 +1846,7 @@ ${prompt}`
     { path: { sessionID }, body: promptBody },
     { sessionID, ...promptBody },
   )
-  return { startsAssistantTurn: true }
+  return { startsAssistantTurn: true, dispatch }
 }
 
 async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
@@ -1939,7 +1971,14 @@ async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
       }
       let timer
       if (job.timeoutMs > 0) timer = setTimeout(() => { fireSdk(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { path: { sessionID }, body: {} }, { sessionID }); toast(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {}) }, job.timeoutMs)
-      activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now(), timer })
+      const runToken = `${job.id}:${now().toString(36)}:${Math.random().toString(16).slice(2)}`
+      activeRuns.set(sessionID, { jobId: job.id, job, startedAt: now(), timer, runToken })
+      if (result.dispatch) {
+        void result.dispatch.catch((error) => {
+          recoverActiveDispatchFailure(directory, client, sessionID, job.id, runToken, error)
+            .catch((recoveryError) => log(client, "error", "dispatch recovery failed", { error: sdkErrorMessage(recoveryError) }))
+        })
+      }
       sessionStatuses.set(sessionID, "busy")
       sessionStatusSeenAt.set(sessionID, now())
       await reschedule(BUSY_RETRY_MS)
@@ -2220,9 +2259,10 @@ async function handleCommand(directory, client, input, fallbackName, fallbackArg
   if (isLoopCommandName(name)) guardLoopOwnedUserMessage(sessionID)
 
   const handled = () => {
-    // OpenCode server plugins cannot currently cancel the command prompt turn.
-    // Keep the command markdown acknowledgement intact so opencode-loop-local
-    // receives a valid, tool-denied message instead of an empty parts array.
+    // OpenCode 1.18.x ignores unknown hook output fields, while proposed/newer
+    // hosts can honor noReply to skip the otherwise unavoidable model turn.
+    // Keep acknowledgement parts intact as the compatibility fallback.
+    if (output && typeof output === "object") output.noReply = true
     return true
   }