@bybrawe/opencode-loop 0.5.26 → 0.5.28

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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.
+- Add a deterministic concurrency regression that forces overlapping state reads/writes and proves a concurrent user pause survives a stale scheduler update.
+- Harden `opencode-loopd` by pinning one exact OpenCode session across iterations instead of resolving `--continue` on every run; a fresh daemon session is created and then pinned when no existing session is available.
+- Add per-run daemon timeouts (30 minutes by default, configurable with `--timeout`; `0s` disables) and timeout exit code 124, including descendant-process termination.
+- Add daemon regressions for session pinning, timeout termination, and scheduled-task timeout propagation.
+- Add a real OpenCode host canary that proves a three-run `/loop` performs exactly three autonomous turns on Ubuntu and Windows.
+- Narrow the OpenCode plugin peer range to `>=1.4.0 <2` so a future breaking 2.x release is not treated as automatically compatible.
+
 ## 0.5.26
 
 - Added an explicit npm-based OpenCode installation path: `npm install -g @bybrawe/opencode-loop@latest` followed by `opencode-loop`.

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.26`.** 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.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.
 
 ## Install or update
 
@@ -304,7 +304,7 @@ Do not use a normal prompt loop when you mean to run `/compact`. Prefer:
 
 ## Background daemon
 
-The normal `/loop` plugin is session-bound. If OpenCode closes, that TUI/session loop cannot keep running in the background.
+The normal `/loop` plugin is session-bound. If OpenCode closes, that TUI/session loop cannot keep running in the background. `opencode-loopd` resolves the session once at startup and pins that exact session for later iterations, so a newer unrelated session cannot steal the daemon. If no session exists, the daemon creates one and pins it before the second iteration. Each daemon run is bounded by `--timeout` (30 minutes by default; use `--timeout 0s` to disable).
 
 For long-running background jobs use:
 
@@ -321,7 +321,13 @@ opencode-loopd --project . --every 0s --prompt "continue from progress.md and im
 Select a model and agent:
 
 ```bash
-opencode-loopd --project . --every 0s --max-runs 1 --model provider/model --agent build --prompt-file loop-prompt.md
+opencode-loopd --project . --every 0s --max-runs 1 --timeout 30m --model provider/model --agent build --prompt-file loop-prompt.md
+```
+
+Pin a specific existing session when needed:
+
+```bash
+opencode-loopd --project . --session ses_xxx --every 5m --prompt-file loop-prompt.md
 ```
 
 Limit total runs:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.26",
+  "version": "0.5.28",
   "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,8 +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",
-    "test": "node scripts/install-test.mjs && node scripts/loopd-test.mjs && node scripts/smoke-test.mjs && node scripts/comprehensive-test.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/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/comprehensive-watchdog.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/host-adapter-contract-test.mjs && node scripts/comprehensive-watchdog.mjs",
+    "canary:host": "node scripts/host-loop-canary.mjs",
     "install:global": "node scripts/install-node.mjs",
     "pack:zip": "node scripts/make-zip.mjs"
   },
@@ -54,7 +58,7 @@
     "url": "https://github.com/ByBrawe/opencode-loop/issues"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.4.0"
+    "@opencode-ai/plugin": ">=1.4.0 <2"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.15"

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 = {}) {
@@ -405,9 +417,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()
   }
@@ -705,6 +719,36 @@ async function testStateReadRetriesTransientPartialJson() {
   }
 }
 
+async function testStateRebasePreservesConcurrentPause() {
+  const h = await createHarness()
+  const originalRename = fs.rename
+  try {
+    await h.command("loop", "10m --no-now --name race continue safely")
+    h.statuses.set(h.sessionID, "busy")
+    let delayed = false
+    fs.rename = async (source, target, ...rest) => {
+      if (!delayed && path.resolve(target) === path.resolve(h.stateFile)) {
+        delayed = true
+        await delay(120)
+      }
+      return await originalRename.call(fs, source, target, ...rest)
+    }
+
+    const pause = h.command("loop-pause", "race")
+    await delay(20)
+    const runNow = h.command("loop-now", "race")
+    await Promise.all([pause, runNow])
+
+    const state = await h.readState()
+    const job = state.jobs.find((item) => item.name === "race")
+    assert.ok(job, "the concurrent state update must keep the loop job")
+    assert.equal(job.paused, true, "a stale scheduler snapshot must not erase a concurrent user pause")
+  } finally {
+    fs.rename = originalRename
+    await h.cleanup()
+  }
+}
+
 await testParserAndPresets()
 await testLifecycleAndCommandDedupe()
 await testWatchScheduling()
@@ -718,5 +762,6 @@ await testInitializationDoesNotWaitForLocalApi()
 await testWindowsSafeStatePersistence()
 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 {}
+}

package/scripts/host-adapter-contract-test.mjs

@@ -0,0 +1,147 @@
+import assert from "node:assert/strict"
+import { createOpenCodeHostAdapter } from "../src/source/opencode/adapter.js"
+import {
+  activeRunCompletionFromMessages,
+  compactSession,
+  compactTuiCommandName,
+  executeTuiCommand,
+  orderedSessionMessages,
+  readRecentSessionMessages,
+  resolveCompactionModel,
+} from "../src/source/opencode/host.js"
+import {
+  deleteSessionExecutionContext,
+  getSessionExecutionContext,
+} from "../src/source/opencode/session-context.js"
+
+function messagesClient(messages) {
+  return { session: { messages: async () => ({ data: structuredClone(messages) }) } }
+}
+
+assert.equal(compactTuiCommandName("/compact"), "session_compact")
+assert.equal(compactTuiCommandName("summarize"), "session_compact")
+assert.equal(compactTuiCommandName("other"), undefined)
+
+{
+  const calls = []
+  const client = { tui: { executeCommand: async (args) => {
+    calls.push(args)
+    if (args?.body) return { error: { message: "body shape rejected" } }
+    return { data: args.command }
+  } } }
+  assert.equal(await executeTuiCommand(client, "session_compact"), "session_compact")
+  assert.deepEqual(calls, [
+    { body: { command: "session_compact" } },
+    { command: "session_compact" },
+  ])
+}
+
+{
+  const calls = []
+  const client = { session: { messages: async (args) => {
+    calls.push(args)
+    if (args?.path?.id) throw new Error("id shape rejected")
+    return { data: [{ info: { id: "m1", role: "assistant" } }] }
+  } } }
+  const result = await readRecentSessionMessages(client, "ses_messages", "/tmp/project", 7)
+  assert.equal(result[0].info.id, "m1")
+  assert.equal(calls.length, 2)
+}
+
+{
+  const ordered = orderedSessionMessages([
+    { info: { id: "b", time: { created: 20 } } },
+    { info: { id: "a", time: { created: 10 } } },
+    { info: { id: "c", time: { created: 20 } } },
+  ])
+  assert.deepEqual(ordered.map((item) => item.info.id), ["a", "b", "c"])
+
+  assert.equal(await activeRunCompletionFromMessages("/tmp", {}, "missing", { startedAt: 100 }), "unknown")
+  assert.equal(await activeRunCompletionFromMessages(
+    "/tmp", messagesClient([{ info: { role: "assistant", time: { created: 50, completed: 90 } } }]), "old", { startedAt: 100 },
+  ), "incomplete")
+  assert.equal(await activeRunCompletionFromMessages(
+    "/tmp", messagesClient([{ info: { role: "assistant", time: { created: 110, completed: 120 } } }]), "done", { startedAt: 100 },
+  ), "completed")
+}
+
+{
+  const sessionID = "ses_message_model_contract"
+  deleteSessionExecutionContext(sessionID)
+  const client = messagesClient([
+    { info: { role: "assistant", time: { created: 10 }, model: { providerID: "old", modelID: "old" } } },
+    { info: { role: "assistant", time: { created: 20 }, model: { providerID: "provider", modelID: "model" } } },
+  ])
+  assert.deepEqual(await resolveCompactionModel("/tmp", client, sessionID), { providerID: "provider", modelID: "model" })
+  assert.deepEqual(getSessionExecutionContext(sessionID)?.model, { providerID: "provider", modelID: "model" })
+  deleteSessionExecutionContext(sessionID)
+}
+
+{
+  const tuiCalls = []
+  const client = {
+    app: { log: async () => ({ data: true }) },
+    tui: { executeCommand: async (args) => {
+      const command = args?.body?.command || args?.command
+      tuiCalls.push(command)
+      if (command === "session.compact") return { error: { message: "unsupported" } }
+      return { data: true }
+    } },
+  }
+  assert.equal(await compactSession("/tmp", client, "ses_tui"), true)
+  assert.ok(tuiCalls.includes("session.compact"))
+  assert.ok(tuiCalls.includes("session_compact"))
+}
+
+{
+  const summaries = []
+  const client = {
+    app: { log: async () => ({ data: true }) },
+    tui: { showToast: async () => ({ data: true }) },
+    session: { summarize: async (args) => { summaries.push(args); return { data: true } } },
+  }
+  assert.equal(await compactSession("/tmp", client, "ses_summary", "provider/model"), true)
+  assert.deepEqual(summaries[0], {
+    path: { id: "ses_summary" },
+    body: { providerID: "provider", modelID: "model", auto: false },
+  })
+}
+
+{
+  const calls = []
+  const client = {
+    app: { log: async (args) => { calls.push(["log", args]); return { data: true } } },
+    tui: {
+      executeCommand: async (args) => { calls.push(["command", args]); return { data: true } },
+      showToast: async (args) => { calls.push(["toast", args]); return { data: true } },
+    },
+    session: {
+      messages: async (args) => {
+        calls.push(["messages", args])
+        return { data: [{ info: { role: "assistant", time: { created: 10, completed: 20 } } }] }
+      },
+    },
+  }
+  const adapter = createOpenCodeHostAdapter(client, "/bound/project")
+  assert.equal(Object.isFrozen(adapter), true)
+  assert.deepEqual(Object.keys(adapter).sort(), [
+    "activeRunCompletion",
+    "compactSession",
+    "executeTuiCommand",
+    "log",
+    "readRecentMessages",
+    "resolveCompactionModel",
+    "toast",
+  ])
+  await adapter.executeTuiCommand("session_compact")
+  await adapter.readRecentMessages("ses_adapter", 7)
+  assert.equal(await adapter.activeRunCompletion("ses_adapter", { startedAt: 5 }), "completed")
+  assert.deepEqual(await adapter.resolveCompactionModel("ses_adapter", "provider/model"), { providerID: "provider", modelID: "model" })
+  await adapter.log("info", "adapter log")
+  await adapter.toast("adapter toast", "warning")
+  const messageCall = calls.find(([kind]) => kind === "messages")?.[1]
+  assert.equal(messageCall?.query?.directory, "/bound/project")
+  assert.equal(messageCall?.query?.limit, 7)
+}
+
+console.log("OpenCode host adapter contract test passed")

package/scripts/host-bridge-parity-test.mjs

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict"
+import { promises as fs } from "node:fs"
+
+const legacy = await fs.readFile("src/source/legacy-v1.js", "utf8")
+const host = await fs.readFile("src/source/opencode/host.js", "utf8")
+
+const legacyStart = legacy.indexOf("function fireSdk(")
+const legacyEnd = legacy.indexOf("function guardLoopOwnedUserMessage(")
+const hostStart = host.indexOf("export function fireSdk(")
+assert.ok(legacyStart >= 0 && legacyEnd > legacyStart, "legacy host bridge block not found")
+assert.ok(hostStart >= 0, "host bridge module block not found")
+
+const normalize = (text) => text
+  .replace(/\bexport\s+(?=(?:async\s+)?function\b)/g, "")
+  .replace(/\r\n/g, "\n")
+  .trim()
+
+const legacyBlock = normalize(legacy.slice(legacyStart, legacyEnd))
+const hostBlock = normalize(host.slice(hostStart))
+assert.equal(hostBlock, legacyBlock, "OpenCode host bridge drifted from the stable V1 implementation")
+
+console.log("host bridge parity test passed")