@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.5.29
+
+- Fix `--no-now` first-run semantics end to end: delayed jobs now wait until `createdAt + interval`, and stable `/loop-status` reports that first due time correctly instead of showing the job as immediately due.
+- Add experimental OpenCode 2 parity for native `/loop-status` and target-specific `/loop-now`, including real host command registration, idle-safe run-now persistence, target priority, `noReply` status output, and deterministic lifecycle coverage.
+- Make stable `/loop-now <target>` truly target-specific across busy retries and avoid unrelated due jobs; persist a one-shot run-now marker, prioritize the requested job, and consume it only when dispatch begins.
+- Defer stable `/loop-now` execution to the idle-safe scheduler instead of dispatching re-entrantly from `command.execute.before`, fixing a Windows real-host race where the command acknowledgement turn could supersede the requested autonomous prompt.
+- Strengthen release confidence with Ubuntu/Windows real-host target canaries, generated-bundle synchronization, Bundle Gate coverage for host-canary changes, and bounded scheduler-state waits in comprehensive Windows regressions.
+
+## 0.5.28
+
+- Preserve experimental `/loop-goal` across ordinary queued user steering: preempt only the in-flight Goal turn, run the foreground user turn first, keep the Goal active/unpaused, then resume autonomous Goal work. Gate heartbeat, due, and watchdog dispatch while steering is pending, reject stale Goal lifecycle mutations, and cover the behavior with real OpenCode host canaries on Ubuntu and Windows for both source and freshly rebuilt bundles.
+- Complete the planned V1 modularization by extracting command routing/handlers, Loop registration, session activity/status, scheduling, Goal runtime/policy/steering, job workspace, compaction, and executor responsibilities into focused testable modules while keeping `legacy-v1.js` as the composition root.
+- Expand the experimental OpenCode 2 runtime with idle-safe interval prompt loops, Loop control commands, ordinary slash-command transport, lifecycle cleanup, and real-host adapter/activation contracts. Correct V2 command transport to use the host `command` field rather than the optional message `id` field. Stable package compatibility remains `@opencode-ai/plugin >=1.4.0 <2`; this release does not claim stable OpenCode 2 parity.
+- Harden the Goal steering host canary cold bootstrap from 45 seconds to a bounded 90 seconds and include the OpenCode server log when bootstrap still fails, without weakening the steering assertions.
+
 ## 0.5.27
 
 - Rebase stale Loop state snapshots against the latest persisted job state before writing, preventing scheduler bookkeeping from erasing unrelated user pause/resume or other state changes.

package/README.md

@@ -4,7 +4,7 @@
 
 OpenCode Loop adds `/loop`, scheduled prompt/command/shell jobs, compact scheduling, safe long-running continuation helpers, and the `opencode-loopd` background daemon.
 
-> **Current release: `0.5.27`.** Loop also contains an older experimental `/loop-goal` mode, but for strong persistent Goal contracts and host-verified completion, use the separate **OpenCode Goals** plugin described below.
+> **Current release: `0.5.29`.** Loop also contains an older experimental `/loop-goal` mode, but for strong persistent Goal contracts and host-verified completion, use the separate **OpenCode Goals** plugin described below.
 
 ## Install or update
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.27",
+  "version": "0.5.29",
   "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",
@@ -18,9 +18,12 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "check": "node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/loopd.mjs && node --check scripts/install-test.mjs && node --check scripts/loopd-test.mjs && node --check scripts/smoke-test.mjs && node --check scripts/comprehensive-test.mjs && node --check scripts/host-loop-canary.mjs",
-    "test": "node scripts/install-test.mjs && node scripts/loopd-test.mjs && node scripts/smoke-test.mjs && node scripts/comprehensive-test.mjs",
-    "canary:host": "node scripts/host-loop-canary.mjs",
+    "build:plugin": "bun build src/source/v1.js --outfile=src/index.js --target=bun --format=esm --external=@opencode-ai/plugin/tool",
+    "build:plugin:npm": "npm run build:plugin",
+    "prepack": "node --check src/index.js",
+    "check": "node --check src/source/v1.js && node --check src/source/core/args.js && node --check src/source/core/state.js && node --check src/source/core/jobs.js && node --check src/source/core/process.js && node --check src/source/opencode/sdk.js && node --check src/source/opencode/session-context.js && node --check src/source/opencode/command-router.js && node --check src/source/opencode/goal-commands.js && node --check src/source/opencode/loop-commands.js && node --check src/source/opencode/loop-registration.js && node --check src/source/runtime/session-activity.js && node --check src/source/runtime/session-status.js && node --check src/source/runtime/compaction.js && node --check src/source/runtime/executor.js && node --check src/source/runtime/scheduler.js && node --check src/source/runtime/goal-runtime.js && node --check src/source/runtime/goal-policy.js && node --check src/source/runtime/goal-steering.js && node --check src/source/runtime/job-workspace.js && node --check src/source/opencode2/prompt-runtime.js && node --check src/source/legacy-v1.js && node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/loopd.mjs && node --check scripts/install-test.mjs && node --check scripts/loopd-test.mjs && node --check scripts/smoke-test.mjs && node --check scripts/host-adapter-contract-test.mjs && node --check scripts/command-router-test.mjs && node --check scripts/goal-command-handlers-test.mjs && node --check scripts/loop-command-handlers-test.mjs && node --check scripts/loop-registration-test.mjs && node --check scripts/session-activity-test.mjs && node --check scripts/session-status-test.mjs && node --check scripts/compaction-runtime-test.mjs && node --check scripts/executor-runtime-test.mjs && node --check scripts/scheduler-runtime-test.mjs && node --check scripts/goal-runtime-test.mjs && node --check scripts/goal-policy-test.mjs && node --check scripts/goal-steering-test.mjs && node --check scripts/job-workspace-test.mjs && node --check scripts/v2-prompt-runtime-test.mjs && node --check scripts/v2-prompt-interval-test.mjs && node --check scripts/v2-command-runtime-test.mjs && node --check scripts/v2-command-adapter-test.mjs && node --check scripts/comprehensive-watchdog.mjs && node --check scripts/comprehensive-test.mjs && node --check scripts/host-loop-canary.mjs && node --check scripts/host-goal-steering-canary.mjs",
+    "test": "node scripts/command-router-test.mjs && node scripts/goal-command-handlers-test.mjs && node scripts/loop-command-handlers-test.mjs && node scripts/loop-registration-test.mjs && node scripts/session-activity-test.mjs && node scripts/session-status-test.mjs && node scripts/compaction-runtime-test.mjs && node scripts/executor-runtime-test.mjs && node scripts/scheduler-runtime-test.mjs && node scripts/goal-runtime-test.mjs && node scripts/goal-policy-test.mjs && node scripts/goal-steering-test.mjs && node scripts/job-workspace-test.mjs && node scripts/v2-prompt-runtime-test.mjs && node scripts/v2-prompt-interval-test.mjs && node scripts/v2-command-runtime-test.mjs && node scripts/v2-command-adapter-test.mjs && node scripts/install-test.mjs && node scripts/loopd-test.mjs && node scripts/smoke-test.mjs && node scripts/host-adapter-contract-test.mjs && node scripts/comprehensive-watchdog.mjs",
+    "canary:host": "node scripts/host-loop-canary.mjs && node scripts/host-goal-steering-canary.mjs",
     "install:global": "node scripts/install-node.mjs",
     "pack:zip": "node scripts/make-zip.mjs"
   },

package/scripts/command-lifecycle-test.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict"
+import {
+  clearCommandLifecycle,
+  commandArgsText,
+  commandName,
+  consumeHandled,
+  forgetHandledCommandEvent,
+  hasHandledCommandEvent,
+  isLoopCommandName,
+  isPreset,
+  markHandled,
+  markHandledCommandEvent,
+} from "../src/source/opencode/commands.js"
+
+assert.equal(commandName(undefined), "")
+assert.equal(commandName(42), "42")
+assert.equal(isPreset("loop-dev"), true)
+assert.equal(isPreset("loop-status"), false)
+assert.equal(isLoopCommandName("loop-status"), true)
+assert.equal(isLoopCommandName("loop-goal-complete"), true)
+assert.equal(isLoopCommandName("other-command"), false)
+assert.equal(commandArgsText(["one", { text: "two" }, 3]), "one two 3")
+assert.equal(commandArgsText({ arguments: { value: "nested" } }), "nested")
+
+markHandled("session-a", "loop-status", "  repeated   args ")
+assert.equal(consumeHandled("session-a", "loop-status", "repeated args"), true)
+assert.equal(consumeHandled("session-a", "loop-status", "repeated args"), false)
+
+markHandled("session-b", "loop-now", "job")
+markHandled("session-b", "loop-now", "job")
+assert.equal(consumeHandled("session-b", "loop-now", "job"), true)
+assert.equal(consumeHandled("session-b", "loop-now", "job"), true)
+assert.equal(consumeHandled("session-b", "loop-now", "job"), false)
+
+assert.equal(hasHandledCommandEvent("session-c", "message-1"), false)
+markHandledCommandEvent("session-c", "message-1")
+assert.equal(hasHandledCommandEvent("session-c", "message-1"), true)
+forgetHandledCommandEvent("session-c", "message-1")
+assert.equal(hasHandledCommandEvent("session-c", "message-1"), false)
+
+markHandled("session-d", "loop-status", "")
+markHandledCommandEvent("session-d", "message-2")
+clearCommandLifecycle("session-d")
+assert.equal(consumeHandled("session-d", "loop-status", ""), false)
+assert.equal(hasHandledCommandEvent("session-d", "message-2"), false)
+
+console.log("OpenCode command lifecycle test passed")

package/scripts/command-router-test.mjs

@@ -0,0 +1,175 @@
+import assert from "node:assert/strict"
+import { createCommandRouter } from "../src/source/opencode/command-router.js"
+import { clearCommandLifecycle } from "../src/source/opencode/commands.js"
+
+const HANDLER_NAMES = [
+  "addGoal",
+  "statusGoal",
+  "pauseGoal",
+  "resumeGoal",
+  "clearGoal",
+  "completeGoalCommand",
+  "blockGoalCommand",
+  "addLoop",
+  "stopLoop",
+  "statusLoop",
+  "logsLoop",
+  "helpLoop",
+  "runNow",
+  "updateJobState",
+  "doctorLoop",
+  "initLoop",
+  "exportLoop",
+]
+
+function harness() {
+  const calls = []
+  const remembered = []
+  const captured = []
+  const guarded = []
+  const handlers = Object.fromEntries(HANDLER_NAMES.map((name) => [name, async (...args) => {
+    calls.push({ name, args })
+  }]))
+  const router = createCommandRouter({
+    rememberSession: (...args) => remembered.push(args),
+    captureSessionExecutionContext: async (...args) => { captured.push(args) },
+    guardLoopOwnedUserMessage: (...args) => guarded.push(args),
+    handlers,
+  })
+  return { router, calls, remembered, captured, guarded }
+}
+
+assert.throws(() => createCommandRouter({}), /rememberSession/)
+assert.throws(() => createCommandRouter({ rememberSession() {}, handlers: {} }), /handlers\.addGoal/)
+
+{
+  const sessionID = "router-before"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  const output = {}
+  const client = { id: "client" }
+  const result = await h.router("/work", client, { sessionID, command: "loop-status", arguments: "" }, undefined, undefined, output)
+  assert.equal(result, true)
+  assert.equal(output.noReply, true)
+  assert.deepEqual(h.calls.map((item) => item.name), ["statusLoop"])
+  assert.deepEqual(h.calls[0].args, ["/work", client, sessionID])
+  assert.equal(h.remembered.length, 1)
+  assert.deepEqual(h.remembered[0], ["/work", client, sessionID])
+  assert.equal(h.captured.length, 1)
+  assert.deepEqual(h.captured[0], [client, sessionID])
+  assert.deepEqual(h.guarded, [[sessionID]])
+
+  const eventResult = await h.router("/work", client, { sessionID, name: "loop-status", arguments: "", messageID: "msg-1" }, undefined, undefined, undefined, "event")
+  assert.equal(eventResult, true)
+  assert.equal(h.calls.length, 1, "matching command.executed event must not run the handler twice")
+  assert.equal(h.remembered.length, 2)
+  assert.equal(h.captured.length, 2)
+  assert.equal(h.guarded.length, 1, "consumed compatibility event must return before user-message guarding")
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-event"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  const client = {}
+  const event = { sessionID, name: "loop-help", arguments: "", messageID: "evt-1" }
+  assert.equal(await h.router("/work", client, event, undefined, undefined, undefined, "event"), true)
+  assert.deepEqual(h.calls.map((item) => item.name), ["helpLoop"])
+  assert.deepEqual(h.calls[0].args, [client, sessionID])
+  assert.deepEqual(h.guarded, [[sessionID]])
+
+  assert.equal(await h.router("/work", client, event, undefined, undefined, undefined, "event"), true)
+  assert.equal(h.calls.length, 1, "same event message ID must be idempotent")
+  assert.equal(h.guarded.length, 1)
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-preset"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  assert.equal(await h.router("/repo", {}, { sessionID, command: "loop-shell", arguments: "10m npm test" }), true)
+  assert.equal(h.calls.length, 1)
+  assert.equal(h.calls[0].name, "addLoop")
+  assert.equal(h.calls[0].args[0], "/repo")
+  assert.equal(h.calls[0].args[2], sessionID)
+  assert.equal(h.calls[0].args[3], "10m npm test")
+  assert.equal(h.calls[0].args[4].kind, "shell")
+  assert.equal(h.calls[0].args[4].name, "shell")
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-state"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  assert.equal(await h.router("/work", {}, { sessionID, command: "loop-pause", arguments: "dev" }), true)
+  let call = h.calls.at(-1)
+  assert.equal(call.name, "updateJobState")
+  assert.equal(call.args[3], "dev")
+  assert.equal(call.args[5], "Paused")
+  assert.deepEqual(call.args[4]({ paused: false, lastRunAt: 99, keep: true }), { paused: true, lastRunAt: 99, keep: true })
+
+  assert.equal(await h.router("/work", {}, { sessionID, command: "loop-resume", arguments: "dev" }), true)
+  call = h.calls.at(-1)
+  assert.equal(call.name, "updateJobState")
+  assert.equal(call.args[5], "Resumed")
+  assert.deepEqual(call.args[4]({ paused: true, lastRunAt: 99, keep: true }), { paused: false, lastRunAt: 0, keep: true })
+
+  assert.equal(await h.router("/work", {}, { sessionID, command: "loop-clear", arguments: "ignored" }), true)
+  call = h.calls.at(-1)
+  assert.equal(call.name, "stopLoop")
+  assert.equal(call.args[3], "all")
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-aliases"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  assert.equal(await h.router("/work", {}, { sessionID, command: "loop-goal-complete", arguments: "ship it" }), true)
+  assert.equal(h.calls.at(-1).name, "completeGoalCommand")
+  assert.equal(h.calls.at(-1).args[3], "ship it")
+  assert.equal(await h.router("/work", {}, { sessionID, command: "loop-remove", arguments: "dev" }), true)
+  assert.equal(h.calls.at(-1).name, "stopLoop")
+  assert.equal(h.calls.at(-1).args[3], "dev")
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-unknown-before"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  const output = {}
+  assert.equal(await h.router("/work", {}, { sessionID, command: "not-loop", arguments: "x" }, undefined, undefined, output), false)
+  assert.equal(await h.router("/work", {}, { sessionID, command: "not-loop", arguments: "x" }, undefined, undefined, output), false)
+  assert.equal(h.calls.length, 0)
+  assert.equal(h.captured.length, 0)
+  assert.equal(h.guarded.length, 0)
+  assert.equal(output.noReply, undefined)
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const sessionID = "router-unknown-event"
+  clearCommandLifecycle(sessionID)
+  const h = harness()
+  const event = { sessionID, name: "not-loop", arguments: "x", messageID: "unknown-1" }
+  assert.equal(await h.router("/work", {}, event, undefined, undefined, undefined, "event"), false)
+  assert.equal(await h.router("/work", {}, event, undefined, undefined, undefined, "event"), false)
+  assert.equal(h.calls.length, 0)
+  assert.equal(h.captured.length, 0)
+  assert.equal(h.guarded.length, 0)
+  clearCommandLifecycle(sessionID)
+}
+
+{
+  const h = harness()
+  assert.equal(await h.router("/work", {}, { command: "loop-status" }), false)
+  assert.equal(await h.router("/work", {}, { sessionID: "missing-name" }), false)
+  assert.equal(h.remembered.length, 0)
+  assert.equal(h.calls.length, 0)
+}
+
+console.log("command router tests passed")

package/scripts/compaction-runtime-test.mjs

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict"
+import { createCompactionRuntime } from "../src/source/runtime/compaction.js"
+
+assert.throws(() => createCompactionRuntime({}), /activeRuns Map/)
+assert.throws(() => createCompactionRuntime({ activeRuns: new Map() }), /finalizeActiveRun/)
+
+let clock = 10_000
+const activeRuns = new Map()
+const compactCalls = []
+const compactResults = []
+const logs = []
+const hostLogs = []
+const finalizeCalls = []
+
+const runtime = createCompactionRuntime({
+  activeRuns,
+  now: () => clock,
+  compactSession: async (...args) => {
+    compactCalls.push(args)
+    return compactResults.shift() ?? true
+  },
+  appendLoopLog: async (...args) => { logs.push(args) },
+  finalizeActiveRun: async (...args) => {
+    finalizeCalls.push(args)
+    return true
+  },
+  log: async (...args) => { hostLogs.push(args) },
+  errorMessage: (error) => `ERR:${error?.message || error}`,
+})
+
+assert.equal(runtime.getPending("s"), undefined)
+assert.equal(runtime.begin(undefined, "job"), undefined)
+assert.equal(runtime.begin("s", undefined), undefined)
+
+const first = runtime.begin("s", "job-1", true)
+assert.deepEqual(first, {
+  jobId: "job-1",
+  resumeAfter: true,
+  requestedAt: 10_000,
+  startedAt: 0,
+  completedAt: 0,
+})
+assert.equal(runtime.getPending("s"), first)
+assert.equal(runtime.isCompleted("s", "job-1"), false)
+assert.equal(runtime.clear("s"), true)
+assert.equal(runtime.getPending("s"), undefined)
+
+runtime.begin("s", "job-1")
+runtime.clearForActiveRun("s", { jobId: "other" })
+assert.equal(runtime.getPending("s")?.jobId, "job-1")
+runtime.clearForActiveRun("s", { jobId: "job-1" })
+assert.equal(runtime.getPending("s"), undefined)
+runtime.begin("s", "job-1")
+runtime.clearForActiveRun("s", undefined)
+assert.equal(runtime.getPending("s"), undefined)
+
+const idleJob = { id: "idle", compactEveryRuns: 0, compactEveryMs: 0, runCount: 0 }
+assert.deepEqual(await runtime.maybeCompact("/repo", {}, "s", idleJob), { job: idleJob, started: false })
+assert.equal(compactCalls.length, 0)
+
+const runJob = { id: "runs", compactEveryRuns: 2, compactEveryMs: 0, runCount: 2, lastCompactRunCount: 0, model: "m" }
+compactResults.push(true)
+clock = 20_000
+const runResult = await runtime.maybeCompact("/repo", { id: "client" }, "s", runJob)
+assert.equal(runResult.started, true)
+assert.equal(runJob.lastCompactAt, 20_000)
+assert.equal(runJob.lastCompactRunCount, 2)
+assert.equal(runtime.getPending("s")?.resumeAfter, true)
+assert.deepEqual(compactCalls.at(-1), ["/repo", { id: "client" }, "s", "m"])
+
+const beforeStartLogs = logs.length
+clock = 21_000
+assert.equal(await runtime.noteStarted("/repo", "s"), true)
+assert.equal(runtime.getPending("s").startedAt, 21_000)
+assert.deepEqual(logs.at(-1), ["/repo", "compact-started", { sessionID: "s", job: "runs", resumeAfter: true }])
+assert.equal(await runtime.noteStarted("/repo", "s"), true)
+assert.equal(logs.length, beforeStartLogs + 1)
+
+activeRuns.set("s", { jobId: "other" })
+assert.equal(await runtime.finalize("/repo", {}, "s"), false)
+activeRuns.set("s", { jobId: "runs" })
+assert.equal(await runtime.finalize("/repo", { id: "client" }, "s"), true)
+assert.deepEqual(finalizeCalls.at(-1), ["/repo", { id: "client" }, "s"])
+
+clock = 22_000
+assert.equal(await runtime.noteCompleted("/repo", { id: "client" }, "s"), true)
+assert.equal(runtime.getPending("s").completedAt, 22_000)
+assert.equal(runtime.isCompleted("s", "runs"), true)
+assert.deepEqual(logs.at(-1), ["/repo", "compact-event", { sessionID: "s", job: "runs", resumeAfter: true }])
+await new Promise((resolve) => setTimeout(resolve, 20))
+assert.ok(finalizeCalls.length >= 2)
+
+runtime.clear("s")
+assert.equal(await runtime.noteStarted("/repo", "s"), false)
+assert.equal(await runtime.noteCompleted("/repo", {}, "s"), false)
+assert.equal(await runtime.finalize("/repo", {}, "s"), false)
+
+const failedJob = { id: "failed", compactEveryRuns: 1, compactEveryMs: 0, runCount: 1, model: undefined }
+compactResults.push(false)
+clock = 30_000
+const failedResult = await runtime.maybeCompact("/repo", {}, "failed-session", failedJob)
+assert.equal(failedResult.started, false)
+assert.equal(runtime.getPending("failed-session"), undefined)
+assert.equal(failedJob.lastCompactAt, undefined)
+
+const timeJob = { id: "time", compactEveryRuns: 0, compactEveryMs: 500, runCount: 7, lastCompactAt: 39_000 }
+compactResults.push(true)
+clock = 40_000
+assert.equal((await runtime.maybeCompact("/repo", {}, "time-session", timeJob)).started, true)
+assert.equal(timeJob.lastCompactAt, 40_000)
+assert.equal(timeJob.lastCompactRunCount, 7)
+
+const errorActiveRuns = new Map([["err", { jobId: "error-job" }]])
+const errorLogs = []
+const errorRuntime = createCompactionRuntime({
+  activeRuns: errorActiveRuns,
+  now: () => 50_000,
+  appendLoopLog: async () => {},
+  finalizeActiveRun: async () => { throw new Error("boom") },
+  log: async (...args) => { errorLogs.push(args) },
+  errorMessage: (error) => `wrapped:${error.message}`,
+})
+errorRuntime.begin("err", "error-job")
+await errorRuntime.noteCompleted("/repo", { id: "client" }, "err")
+await new Promise((resolve) => setTimeout(resolve, 20))
+assert.deepEqual(errorLogs.at(-1), [{ id: "client" }, "error", "compaction finalization failed", { error: "wrapped:boom" }])
+
+console.log("compaction runtime tests passed")

package/scripts/comprehensive-test.mjs

@@ -6,6 +6,18 @@ import path from "node:path"
 import OpenCodeLoopPlugin from "../src/index.js"
 
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+async function waitForValue(read, timeoutMs = 1_000, intervalMs = 10) {
+  const deadline = Date.now() + timeoutMs
+  let value
+  while (Date.now() < deadline) {
+    value = await read()
+    if (value) return value
+    await delay(intervalMs)
+  }
+  return await read()
+}
+
 let harnessNumber = 0
 
 async function createHarness(options = {}) {
@@ -126,6 +138,8 @@ async function createHarness(options = {}) {
     messageHistory,
     async command(command, argumentsText = "", output = { parts: [] }) {
       await hooks["command.execute.before"]({ command, sessionID, arguments: argumentsText }, output)
+      // /loop-now persists a request and dispatches through the scheduler's 250ms idle-safe timer.
+      if (command === "loop-now") await delay(400)
       return output
     },
     async commandEvent(command, argumentsText = "", messageID = `msg_${Date.now()}_${Math.random()}`) {
@@ -344,9 +358,12 @@ async function testActionRoutingAndSafety() {
     await h.command("loop-clear")
     await h.command("loop-shell", "0s --safe rm -r -f ./important")
     await h.command("loop-now", "shell")
-    const separateFlagsState = await h.readState()
+    const separateFlagsState = await waitForValue(async () => {
+      const candidate = await h.readState()
+      return candidate.jobs[0]?.lastFailureReason === "safe_shell_blocked" ? candidate : undefined
+    }, 2_000)
     assert.equal(h.records.shells.length, 0)
-    assert.equal(separateFlagsState.jobs[0].lastFailureReason, "safe_shell_blocked", "separate rm -r -f flags must be blocked")
+    assert.equal(separateFlagsState?.jobs[0]?.lastFailureReason, "safe_shell_blocked", "separate rm -r -f flags must be blocked")
   } finally {
     await h.cleanup()
   }
@@ -405,9 +422,11 @@ async function testNativeCompactionLifecycleAndFallback() {
     await h.hooks["experimental.session.compacting"]({ sessionID: h.sessionID }, compactOutput)
     assert.deepEqual(compactOutput, { context: [], prompt: undefined }, "loop lifecycle tracking must not rewrite OpenCode's compaction prompt")
     await h.hooks.event({ event: { type: "session.compacted", properties: { sessionID: h.sessionID } } })
-    await delay(20)
-    const state = await h.readState()
-    assert.ok(state.jobs[0].lastFinishedAt > 0, "session.compacted must finalize an explicit compact job without waiting for stale status recovery")
+    const state = await waitForValue(async () => {
+      const candidate = await h.readState()
+      return candidate.jobs[0]?.lastFinishedAt > 0 ? candidate : undefined
+    })
+    assert.ok(state?.jobs[0]?.lastFinishedAt > 0, "session.compacted must finalize an explicit compact job without waiting for stale status recovery")
   } finally {
     await h.cleanup()
   }
@@ -463,6 +482,9 @@ async function testStaleBusyUsesCompletedAssistantTail() {
       { info: { id: "usr_tail", sessionID: h.sessionID, role: "user", time: { created: completedAt - 2 } }, parts: [] },
       { info: { id: "asst_tail", sessionID: h.sessionID, role: "assistant", time: { created: completedAt - 1, completed: completedAt } }, parts: [] },
     )
+    // Let the short busy-status cache expire so the scheduler re-reads live host state
+    // and can reconcile the completed assistant tail instead of trusting cached busy.
+    await delay(1_700)
     await h.command("loop-now", "stale-complete")
     const state = await h.readState()
     assert.ok(state.jobs[0].lastFinishedAt > 0, "a completed assistant tail must override a stale busy status")
@@ -598,7 +620,7 @@ async function testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt() {
       properties: { info: { id: "msg_real_user", sessionID: h.sessionID, role: "user" } },
     } })
     state = await h.readState()
-    assert.equal(state.jobs[0].paused, true, "a distinct real user message must still pause an active goal")
+    assert.equal(state.jobs[0].paused, false, "a distinct real user message must steer an active goal without pausing it")
   } finally {
     Date.now = originalDateNow
     await h.cleanup()
@@ -750,4 +772,4 @@ await testWindowsStateRenameRetriesBeforeFallback()
 await testStateReadRetriesTransientPartialJson()
 await testStateRebasePreservesConcurrentPause()
 
-console.log("OpenCode Loop comprehensive test passed")
+console.log("OpenCode Loop comprehensive test passed")

package/scripts/comprehensive-watchdog.mjs

@@ -0,0 +1,32 @@
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const scriptsDir = path.dirname(fileURLToPath(import.meta.url))
+const rootDir = path.resolve(scriptsDir, "..")
+const sourcePath = path.join(scriptsDir, "comprehensive-test.mjs")
+const timeoutMs = Math.max(5_000, Number(process.env.OPENCODE_LOOP_COMPREHENSIVE_TIMEOUT_MS) || 60_000)
+const tempPath = path.join(os.tmpdir(), `opencode-loop-comprehensive-watchdog-${process.pid}-${Date.now()}.mjs`)
+
+const source = await fs.readFile(sourcePath, "utf8")
+const pluginURL = pathToFileURL(path.join(rootDir, "src", "index.js")).href
+let instrumented = source.replace('import OpenCodeLoopPlugin from "../src/index.js"', `import OpenCodeLoopPlugin from ${JSON.stringify(pluginURL)}`)
+instrumented = instrumented.replace(
+  /^await (test[A-Za-z0-9_]+)\(\)$/gm,
+  'globalThis.__opencodeLoopActiveCase = "$1"; await $1(); globalThis.__opencodeLoopActiveCase = undefined',
+)
+if (instrumented === source) throw new Error("failed to instrument comprehensive test")
+
+await fs.writeFile(tempPath, instrumented, "utf8")
+const watchdog = setTimeout(() => {
+  const active = globalThis.__opencodeLoopActiveCase
+  throw new Error(`OpenCode Loop comprehensive test timed out after ${timeoutMs}ms${active ? ` while running ${active}` : ""}`)
+}, timeoutMs)
+
+try {
+  await import(`${pathToFileURL(tempPath).href}?run=${Date.now()}`)
+} finally {
+  clearTimeout(watchdog)
+  try { await fs.rm(tempPath, { force: true }) } catch {}
+}