@bybrawe/opencode-loop 0.5.17 → 0.5.19

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.5.19
+
+- Made the asynchronous goal prompt smoke test wait for the observable SDK call instead of assuming a single event-loop tick is always sufficient under load.
+
+## 0.5.18
+
+- Fixed package-based installs loading stale OpenCode cache entries after npm had installed a newer release. The installer now pins an existing package config entry to its exact installed version while preserving JSONC comments.
+- Fixed Goal Mode mistaking delayed updates for its own scheduler-created user message as a real user interruption. Loop-owned message IDs remain recognized without hiding a distinct user message.
+- Added a dedicated `opencode-loopd` regression suite for literal argument passing, BOM prompt files, model/agent forwarding, finite-run exit codes, invalid options, and Windows scheduled-task lifecycle behavior.
+- Made finite daemon runs propagate OpenCode failures instead of reporting exit code 0, and reject invalid `--max-runs` values and missing project directories.
+- Added `--model` and `--agent` forwarding to daemon and scheduled-task runs.
+- Fixed Windows Task Scheduler installation failing when `/TR` exceeded its 261-character limit. Scheduled tasks now use a short launcher plus a task-specific JSON config under the local app-data directory, and uninstall removes both artifacts.
+- Made Task Scheduler command launch failures return a nonzero exit code instead of silently succeeding.
+- Added non-mutating `--help` and `--version` handling to the `opencode-loop` installer CLI.
+
 ## 0.5.17
 
 - Prevented OpenCode project bootstrap deadlocks by deferring local SDK logging and session discovery until after plugin hooks are returned.

package/README.md

@@ -16,7 +16,7 @@ v0.5.11 includes a referenced heartbeat scheduler. This is important in OpenCode
 
 ## Current status
 
-**v0.5.17 hardens command, installer, and scheduler behavior around the v0.5.16 busy-detection fix.** Long-running tools and child sessions remain authoritative busy signals. Local `/loop-*` commands now use a tool-denied acknowledgement agent, scheduled work restores the normal agent/model context, package/local duplicate loading is prevented, watched jobs fire correctly, and preset/safe-shell edge cases have regression coverage.
+**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:
 
@@ -32,7 +32,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.17 quick behavior guide
+## v0.5.19 quick behavior guide
 
 OpenCode Loop has two triggers now:
 
@@ -157,7 +157,7 @@ Use the npm installer from any shell: Windows PowerShell, Windows CMD, macOS, or
 npx -y @bybrawe/opencode-loop@latest
 ```
 
-The installer copies the slash command files and the tool-denied local command agent into your OpenCode config directory. If `@bybrawe/opencode-loop` is already present in the OpenCode `plugin` array, that package entry remains authoritative and the installer removes duplicate local plugin copies. Otherwise it installs `opencode-loop.ts` locally and ensures the config directory has the `@opencode-ai/plugin` dependency required by `tool()`.
+The installer copies the slash command files and the tool-denied local command agent into your OpenCode config directory. If `@bybrawe/opencode-loop` is already present in the OpenCode `plugin` array, that package entry remains authoritative, is pinned to the installer's exact version to bypass stale OpenCode package caches, and duplicate local plugin copies are removed. Otherwise it installs `opencode-loop.ts` locally and ensures the config directory has the `@opencode-ai/plugin` dependency required by `tool()`.
 
 Windows target paths:
 
@@ -531,6 +531,14 @@ Limit runs:
 opencode-loopd --project . --every 5m --max-runs 20 --prompt-file loop-prompt.md
 ```
 
+Select the OpenCode model and agent explicitly:
+
+```bash
+opencode-loopd --project . --every 0s --max-runs 1 --model opencode/big-pickle --agent build --prompt-file loop-prompt.md
+```
+
+When `--max-runs` is finite, the daemon exits with the final OpenCode run's nonzero status so scripts and CI can detect failures.
+
 Wait before the first run:
 
 ```bash
@@ -568,6 +576,8 @@ Install a scheduled task:
 opencode-loopd install-task --project "C:\path\to\project" --every 10m --prompt-file loop-prompt.md --name OpenCodeLoop
 ```
 
+You can also pass `--model <provider/model>` and `--agent <name>`. The installer stores long task options in a task-specific JSON file and registers only a short launcher with Task Scheduler, avoiding Windows' 261-character `/TR` limit. `uninstall-task` removes that launcher and JSON config after the task is deleted.
+
 Remove it:
 
 ```powershell

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "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,8 @@
     "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/smoke-test.mjs && node --check scripts/comprehensive-test.mjs",
-    "test": "node scripts/install-test.mjs && node scripts/smoke-test.mjs && node scripts/comprehensive-test.mjs",
+    "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",
     "install:global": "node scripts/install-node.mjs",
     "pack:zip": "node scripts/make-zip.mjs"
   },

package/scripts/comprehensive-test.mjs

@@ -425,6 +425,36 @@ async function testStopsPreflightAndGoalLifecycle() {
   }
 }
 
+async function testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt() {
+  const h = await createHarness()
+  const originalDateNow = Date.now
+  let fakeNow = originalDateNow()
+  Date.now = () => fakeNow
+  try {
+    await h.command("loop-goal", "--no-now Keep working until the objective is complete")
+    const synthetic = {
+      type: "message.updated",
+      properties: { info: { id: "msg_loop_owned", sessionID: h.sessionID, role: "user" } },
+    }
+    await h.hooks.event({ event: synthetic })
+
+    fakeNow += 60_000
+    await h.hooks.event({ event: synthetic })
+    let state = await h.readState()
+    assert.equal(state.jobs[0].paused, false, "a delayed update for the same loop-owned user message must remain ignored")
+
+    await h.hooks.event({ event: {
+      type: "message.updated",
+      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")
+  } finally {
+    Date.now = originalDateNow
+    await h.cleanup()
+  }
+}
+
 async function testInitializationDoesNotWaitForLocalApi() {
   const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-init-deadlock-"))
   const never = new Promise(() => {})
@@ -450,6 +480,7 @@ await testLifecycleAndCommandDedupe()
 await testWatchScheduling()
 await testActionRoutingAndSafety()
 await testStopsPreflightAndGoalLifecycle()
+await testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt()
 await testInitializationDoesNotWaitForLocalApi()
 
 console.log("OpenCode Loop comprehensive test passed")

package/scripts/install-node.mjs

@@ -11,6 +11,26 @@ const commandDir = join(config, "commands")
 const agentDir = join(config, "agents")
 const packagePath = join(config, "package.json")
 const packageName = "@bybrawe/opencode-loop"
+const packageVersion = JSON.parse(await readFile(join(root, "package.json"), "utf8")).version
+const packageSpec = `${packageName}@${packageVersion}`
+const installerArgs = process.argv.slice(2)
+
+if (installerArgs.includes("--help") || installerArgs.includes("-h")) {
+  console.log(`OpenCode Loop installer
+
+Usage:
+  opencode-loop
+  npx -y @bybrawe/opencode-loop@latest
+
+Installs the plugin commands and local command agent into OPENCODE_CONFIG_DIR
+or the default ~/.config/opencode directory.`)
+  process.exit(0)
+}
+
+if (installerArgs.includes("--version") || installerArgs.includes("-v")) {
+  console.log(packageVersion)
+  process.exit(0)
+}
 
 function stripJsonComments(input) {
   let output = ""
@@ -78,16 +98,36 @@ function isPackageSpec(value) {
   return spec === packageName || spec.startsWith(`${packageName}@`)
 }
 
-async function packagePluginConfigured() {
+async function configurePackagePlugin() {
+  let configured = false
+  const updatedFiles = []
   for (const name of ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]) {
     try {
-      const parsed = parseJsonc(await readFile(join(config, name), "utf8"))
-      if (Array.isArray(parsed?.plugin) && parsed.plugin.some(isPackageSpec)) return true
+      const target = join(config, name)
+      const source = await readFile(target, "utf8")
+      const parsed = parseJsonc(source)
+      const specs = Array.isArray(parsed?.plugin) ? parsed.plugin.filter(isPackageSpec) : []
+      if (!specs.length) continue
+      configured = true
+
+      // OpenCode caches package plugins by the literal config spec. A bare
+      // package name or @latest can therefore keep loading an older cached
+      // release after npm installs a newer one. Pin the config entry to the
+      // installer package's exact version while preserving JSONC comments.
+      let updated = source
+      for (const spec of new Set(specs)) {
+        if (spec === packageSpec) continue
+        updated = updated.replaceAll(JSON.stringify(spec), JSON.stringify(packageSpec))
+      }
+      if (updated !== source) {
+        await writeFile(target, updated, "utf8")
+        updatedFiles.push(target)
+      }
     } catch (error) {
       if (error?.code !== "ENOENT") console.warn(`Could not inspect ${join(config, name)} for duplicate plugin entries: ${error.message}`)
     }
   }
-  return false
+  return { configured, updatedFiles }
 }
 
 async function ensureDependency() {
@@ -112,7 +152,8 @@ async function ensureDependency() {
 await mkdir(pluginDir, { recursive: true })
 await mkdir(commandDir, { recursive: true })
 await mkdir(agentDir, { recursive: true })
-const useConfiguredPackage = await packagePluginConfigured()
+const packageConfig = await configurePackagePlugin()
+const useConfiguredPackage = packageConfig.configured
 if (useConfiguredPackage) {
   await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
   await rm(join(pluginDir, "opencode-loop.js"), { force: true })
@@ -134,7 +175,12 @@ for (const name of await readdir(join(root, "agents"))) {
   }
 }
 
-if (useConfiguredPackage) console.log(`OpenCode Loop is already configured as a package in ${config}; removed the duplicate local plugin copy.`)
+if (useConfiguredPackage) {
+  const pinResult = packageConfig.updatedFiles.length
+    ? `pinned the config entry to ${packageSpec}`
+    : `the config entry is already pinned to ${packageSpec}`
+  console.log(`OpenCode Loop is already configured as a package in ${config}; ${pinResult} and removed the duplicate local plugin copy.`)
+}
 else console.log(`Installed OpenCode Loop plugin to ${config}`)
 console.log(`Installed ${packageName} commands to ${commandDir}`)
 console.log(`Installed ${packageName} local command agent to ${agentDir}`)

package/scripts/install-test.mjs

@@ -7,11 +7,13 @@ import { fileURLToPath } from "node:url"
 
 const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
 const installer = path.join(root, "scripts", "install-node.mjs")
+const packageVersion = JSON.parse(await fs.readFile(path.join(root, "package.json"), "utf8")).version
+const expectedPackageSpec = `@bybrawe/opencode-loop@${packageVersion}`
 const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-installer-"))
 
-async function runInstaller(config) {
+async function runInstaller(config, cliArgs = []) {
   return await new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [installer], {
+    const child = spawn(process.execPath, [installer, ...cliArgs], {
       cwd: root,
       env: { ...process.env, OPENCODE_CONFIG_DIR: config },
       windowsHide: true,
@@ -38,6 +40,17 @@ async function exists(target) {
 }
 
 try {
+  const helpConfig = path.join(temporaryRoot, "help-must-not-install")
+  const helpResult = await runInstaller(helpConfig, ["--help"])
+  assert.equal(helpResult.code, 0, helpResult.stderr)
+  assert.match(helpResult.stdout, /OpenCode Loop installer/)
+  assert.equal(await exists(helpConfig), false, "--help must not mutate the OpenCode config directory")
+
+  const versionResult = await runInstaller(helpConfig, ["--version"])
+  assert.equal(versionResult.code, 0, versionResult.stderr)
+  assert.equal(versionResult.stdout.trim(), packageVersion)
+  assert.equal(await exists(helpConfig), false, "--version must not mutate the OpenCode config directory")
+
   const local = path.join(temporaryRoot, "local")
   const localResult = await runInstaller(local)
   assert.equal(localResult.code, 0, localResult.stderr)
@@ -59,6 +72,8 @@ try {
   assert.equal(await exists(path.join(configured, "plugins", "opencode-loop.js")), false)
   assert.equal(await commandCount(configured), 30)
   assert.equal(await exists(path.join(configured, "agents", "opencode-loop-local.md")), true)
+  const configuredJson = JSON.parse(await fs.readFile(path.join(configured, "opencode.json"), "utf8"))
+  assert.deepEqual(configuredJson.plugin, [expectedPackageSpec], "the installer must bust OpenCode's stale package cache with an exact version spec")
 
   const jsonc = path.join(temporaryRoot, "jsonc")
   await fs.mkdir(jsonc, { recursive: true })
@@ -72,6 +87,9 @@ try {
   const jsoncResult = await runInstaller(jsonc)
   assert.equal(jsoncResult.code, 0, jsoncResult.stderr)
   assert.equal(await exists(path.join(jsonc, "plugins", "opencode-loop.ts")), false)
+  const updatedJsonc = await fs.readFile(path.join(jsonc, "opencode.jsonc"), "utf8")
+  assert.match(updatedJsonc, /A configured package is authoritative/, "pinning must preserve JSONC comments")
+  assert.match(updatedJsonc, new RegExp(expectedPackageSpec.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
 
   const lookalike = path.join(temporaryRoot, "lookalike")
   await fs.mkdir(lookalike, { recursive: true })

package/scripts/loopd-test.mjs

@@ -0,0 +1,208 @@
+import assert from "node:assert/strict"
+import { spawn } from "node:child_process"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
+const loopd = path.join(root, "scripts", "loopd.mjs")
+const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loopd-test-"))
+
+function runCli(cliArgs, env = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [loopd, ...cliArgs], {
+      cwd: root,
+      env: { ...process.env, ...env },
+      windowsHide: true,
+    })
+    const stdout = []
+    const stderr = []
+    child.stdout.on("data", (data) => stdout.push(Buffer.from(data)))
+    child.stderr.on("data", (data) => stderr.push(Buffer.from(data)))
+    child.on("error", reject)
+    child.on("close", (code, signal) => resolve({
+      code: code ?? (signal ? 1 : 0),
+      stdout: Buffer.concat(stdout).toString("utf8"),
+      stderr: Buffer.concat(stderr).toString("utf8"),
+    }))
+  })
+}
+
+async function makeFakeCommand(name) {
+  const script = path.join(temporaryRoot, `${name}.mjs`)
+  const log = path.join(temporaryRoot, `${name}.jsonl`)
+  await fs.writeFile(script, `
+import fs from "node:fs"
+const log = process.env.FAKE_COMMAND_LOG
+let previous = []
+try { previous = fs.readFileSync(log, "utf8").trim().split(/\\r?\\n/).filter(Boolean) } catch {}
+fs.appendFileSync(log, JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd() }) + "\\n")
+const codes = String(process.env.FAKE_EXIT_CODES || "0").split(",").map((value) => Number(value.trim()))
+const code = codes[Math.min(previous.length, codes.length - 1)]
+process.exit(Number.isInteger(code) ? code : 0)
+`, "utf8")
+
+  if (process.platform === "win32") {
+    const command = path.join(temporaryRoot, `${name}.cmd`)
+    const escapeCmd = (value) => String(value).replace(/%/g, "%%")
+    await fs.writeFile(command, `@echo off\r\n"${escapeCmd(process.execPath)}" "${escapeCmd(script)}" %*\r\nexit /b %errorlevel%\r\n`, "utf8")
+    return { command, log }
+  }
+
+  const command = path.join(temporaryRoot, name)
+  await fs.writeFile(command, `#!/bin/sh\nexec "${process.execPath.replace(/"/g, '\\"')}" "${script.replace(/"/g, '\\"')}" "$@"\n`, { mode: 0o755 })
+  return { command, log }
+}
+
+async function readLog(log) {
+  try {
+    return (await fs.readFile(log, "utf8")).trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
+  } catch (error) {
+    if (error?.code === "ENOENT") return []
+    throw error
+  }
+}
+
+try {
+  const project = path.join(temporaryRoot, "project with spaces")
+  await fs.mkdir(project, { recursive: true })
+  const fakeOpenCode = await makeFakeCommand("fake-opencode")
+
+  const inlinePrompt = 'continue "quoted text" & keep | characters literal'
+  let result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--model", "opencode/nemotron-3-ultra-free",
+    "--agent", "build",
+    "--prompt", inlinePrompt,
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: fakeOpenCode.log,
+  })
+  assert.equal(result.code, 0, result.stderr)
+  let calls = await readLog(fakeOpenCode.log)
+  assert.equal(calls.length, 1)
+  assert.equal(path.resolve(calls[0].cwd), path.resolve(project))
+  assert.deepEqual(calls[0].args, [
+    "run", "--continue",
+    "--model", "opencode/nemotron-3-ultra-free",
+    "--agent", "build",
+    inlinePrompt,
+  ], "loopd must preserve model, agent, quotes, and shell metacharacters as literal arguments")
+
+  const promptFile = path.join(project, "goal prompt.md")
+  await fs.writeFile(promptFile, "\uFEFFPrompt loaded from a BOM file.", "utf8")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--prompt-file", path.basename(promptFile),
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: fakeOpenCode.log,
+  })
+  assert.equal(result.code, 0, result.stderr)
+  calls = await readLog(fakeOpenCode.log)
+  assert.equal(calls.at(-1).args.at(-1), "Prompt loaded from a BOM file.")
+
+  const failureLog = path.join(temporaryRoot, "failure.jsonl")
+  result = await runCli([
+    "--project", project,
+    "--every", "0s",
+    "--max-runs", "1",
+    "--prompt", "fail once",
+  ], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: failureLog,
+    FAKE_EXIT_CODES: "7",
+    OPENCODE_LOOPD_FAILED_RUN_RETRY_MS: "0",
+  })
+  assert.equal(result.code, 7, "a finite daemon run must propagate the failing OpenCode exit code")
+
+  result = await runCli(["--project", project, "--max-runs", "not-a-number", "--prompt", "test"], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: path.join(temporaryRoot, "invalid-count.jsonl"),
+  })
+  assert.equal(result.code, 1)
+  assert.match(result.stderr, /Invalid --max-runs value/)
+
+  result = await runCli(["--project", path.join(temporaryRoot, "missing-project"), "--max-runs", "1", "--prompt", "test"], {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: path.join(temporaryRoot, "missing-project.jsonl"),
+  })
+  assert.equal(result.code, 1)
+  assert.match(result.stderr, /Project directory does not exist/)
+
+  if (process.platform === "win32") {
+    const fakeTasks = await makeFakeCommand("fake-schtasks")
+    const taskName = "OpenCodeLoop-Test"
+    result = await runCli([
+      "install-task",
+      "--project", project,
+      "--every", "90s",
+      "--name", taskName,
+      "--prompt", "scheduled task prompt",
+      "--model", "opencode/nemotron-3-ultra-free",
+      "--agent", "build",
+    ], {
+      SCHTASKS_BIN: fakeTasks.command,
+      FAKE_COMMAND_LOG: fakeTasks.log,
+      OPENCODE_BIN: fakeOpenCode.command,
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "task-files"),
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const taskCalls = await readLog(fakeTasks.log)
+    assert.equal(taskCalls.length, 1)
+    const taskArgs = taskCalls[0].args
+    assert.equal(taskArgs[0], "/Create")
+    assert.equal(taskArgs[taskArgs.indexOf("/MO") + 1], "2")
+    assert.equal(taskArgs[taskArgs.indexOf("/TN") + 1], taskName)
+    const taskCommand = taskArgs[taskArgs.indexOf("/TR") + 1]
+    assert.ok(taskCommand.length <= 261, "the Task Scheduler /TR command must stay within its documented limit")
+    assert.match(taskCommand, /^cmd\.exe \/d \/s \/c /)
+    const taskFiles = await fs.readdir(path.join(temporaryRoot, "task-files"))
+    const taskConfigFile = path.join(temporaryRoot, "task-files", taskFiles.find((name) => name.endsWith(".json")))
+    const taskConfig = JSON.parse(await fs.readFile(taskConfigFile, "utf8"))
+    assert.equal(taskConfig.project, project)
+    assert.equal(taskConfig.prompt, "scheduled task prompt")
+    assert.equal(taskConfig.model, "opencode/nemotron-3-ultra-free")
+    assert.equal(taskConfig.agent, "build")
+    assert.equal(taskConfig.opencodeBin, fakeOpenCode.command)
+
+    const taskRunLog = path.join(temporaryRoot, "task-run.jsonl")
+    result = await runCli(["task-run", "--config", taskConfigFile], {
+      FAKE_COMMAND_LOG: taskRunLog,
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const taskRunCall = (await readLog(taskRunLog))[0]
+    assert.deepEqual(taskRunCall.args, [
+      "run", "--continue",
+      "--model", "opencode/nemotron-3-ultra-free",
+      "--agent", "build",
+      "scheduled task prompt",
+    ])
+
+    result = await runCli(["uninstall-task", "--name", taskName], {
+      SCHTASKS_BIN: fakeTasks.command,
+      FAKE_COMMAND_LOG: fakeTasks.log,
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "task-files"),
+    })
+    assert.equal(result.code, 0, result.stderr)
+    const uninstallArgs = (await readLog(fakeTasks.log)).at(-1).args
+    assert.deepEqual(uninstallArgs, ["/Delete", "/F", "/TN", taskName])
+    assert.deepEqual(await fs.readdir(path.join(temporaryRoot, "task-files")), [], "uninstall-task must remove its launcher and config")
+
+    result = await runCli(["install-task", "--project", project, "--name", taskName, "--prompt", "test"], {
+      SCHTASKS_BIN: path.join(temporaryRoot, "missing-schtasks.exe"),
+      OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "missing-task-files"),
+    })
+    assert.equal(result.code, 1, "a missing Task Scheduler executable must not report success")
+    assert.match(result.stderr, /failed to start/i)
+  }
+
+  console.log("OpenCode Loop daemon test passed")
+} finally {
+  await fs.rm(temporaryRoot, { recursive: true, force: true })
+}

package/scripts/loopd.mjs

@@ -2,15 +2,22 @@
 import fs from "node:fs"
 import path from "node:path"
 import { spawn, spawnSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import { homedir } from "node:os"
 import { fileURLToPath } from "node:url"
 
 const args = process.argv.slice(2)
-const FAILED_RUN_RETRY_MS = 5_000
+const configuredRetryMs = Number(process.env.OPENCODE_LOOPD_FAILED_RUN_RETRY_MS)
+const FAILED_RUN_RETRY_MS = Number.isFinite(configuredRetryMs) && configuredRetryMs >= 0 ? configuredRetryMs : 5_000
 const OPENCODE_BIN = process.env.OPENCODE_BIN || "opencode"
+const SCHTASKS_BIN = process.env.SCHTASKS_BIN || "schtasks"
+const TASK_ROOT = process.env.OPENCODE_LOOPD_TASK_DIR || path.join(process.env.LOCALAPPDATA || path.join(homedir(), "AppData", "Local"), "opencode-loop", "tasks")
 
 function arg(name, fallback = null) {
   const i = args.indexOf(name)
-  return i >= 0 ? args[i + 1] ?? fallback : fallback
+  if (i < 0) return fallback
+  if (i + 1 >= args.length) throw new Error(`Missing value for ${name}`)
+  return args[i + 1]
 }
 
 function has(name) {
@@ -18,7 +25,7 @@ function has(name) {
 }
 
 function parseMs(value) {
-  const v = String(value || "0s").trim().toLowerCase()
+  const v = String(value ?? "0s").trim().toLowerCase()
   if (v === "0" || v === "0s" || v === "now") return 0
 
   const m = v.match(/^(\d+(?:\.\d+)?)\s*(ms|s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/)
@@ -36,6 +43,20 @@ function parseMs(value) {
   return n
 }
 
+function parseMaxRuns(value) {
+  const text = String(value ?? "0").trim()
+  if (!/^\d+$/.test(text)) throw new Error(`Invalid --max-runs value: ${value}`)
+  const parsed = Number(text)
+  if (!Number.isSafeInteger(parsed)) throw new Error(`Invalid --max-runs value: ${value}`)
+  return parsed
+}
+
+function validateProject(project) {
+  let stat
+  try { stat = fs.statSync(project) } catch { throw new Error(`Project directory does not exist: ${project}`) }
+  if (!stat.isDirectory()) throw new Error(`Project path is not a directory: ${project}`)
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
@@ -64,7 +85,7 @@ function spawnOnce(command, commandArgs, cwd) {
     }
 
     child.on("error", (error) => done({ code: -1, error }))
-    child.on("exit", (code) => done({ code: code ?? 0 }))
+    child.on("exit", (code, signal) => done({ code: code ?? (signal ? 1 : 0), signal }))
   })
 }
 
@@ -88,9 +109,17 @@ async function run(command, commandArgs, cwd) {
   return fallback.code
 }
 
-function readPrompt(project) {
-  const promptFile = arg("--prompt-file")
-  const promptArg = arg("--prompt")
+function runSync(command, commandArgs) {
+  const options = { shell: false, stdio: "inherit", windowsHide: true }
+  const direct = spawnSync(command, commandArgs, options)
+  const extension = path.extname(String(command || "")).toLowerCase()
+  if (!direct.error || process.platform !== "win32" || direct.error.code !== "EINVAL" || ![".cmd", ".bat"].includes(extension)) return direct
+  return spawnSync("cmd.exe", ["/d", "/s", "/c", command, ...commandArgs], options)
+}
+
+function readPrompt(project, options = {}) {
+  const promptFile = options.promptFile ?? arg("--prompt-file")
+  const promptArg = options.prompt ?? arg("--prompt")
 
   if (promptFile) {
     return stripBom(fs.readFileSync(path.resolve(project, promptFile), "utf8"))
@@ -110,13 +139,17 @@ function readPrompt(project) {
   ].join(" ")
 }
 
-async function daemon() {
-  const project = path.resolve(arg("--project", process.cwd()))
-  const every = arg("--every", "0s")
+async function daemon(options = {}) {
+  const project = path.resolve(options.project ?? arg("--project", process.cwd()))
+  validateProject(project)
+  const every = options.every ?? arg("--every", "0s")
   const delay = parseMs(every)
-  const maxRuns = Number(arg("--max-runs", "0")) || 0
-  const sleepFirst = has("--sleep-first")
-  const prompt = readPrompt(project)
+  const maxRuns = parseMaxRuns(options.maxRuns ?? arg("--max-runs", "0"))
+  const sleepFirst = options.sleepFirst ?? has("--sleep-first")
+  const prompt = readPrompt(project, options)
+  const model = options.model ?? arg("--model")
+  const agent = options.agent ?? arg("--agent")
+  const opencodeBin = options.opencodeBin || OPENCODE_BIN
 
   console.log("OpenCode Loop daemon")
   console.log(`project: ${project}`)
@@ -135,7 +168,11 @@ async function daemon() {
     console.log("")
     console.log(`[opencode-loopd] run #${count} ${new Date().toISOString()}`)
 
-    const code = await run(OPENCODE_BIN, ["run", "--continue", prompt], project)
+    const runArgs = ["run", "--continue"]
+    if (model) runArgs.push("--model", model)
+    if (agent) runArgs.push("--agent", agent)
+    runArgs.push(prompt)
+    const code = await run(opencodeBin, runArgs, project)
 
     if (code !== 0) {
       console.log(`[opencode-loopd] opencode exited with code ${code}`)
@@ -146,7 +183,7 @@ async function daemon() {
 
     if (maxRuns > 0 && count >= maxRuns) {
       console.log("[opencode-loopd] max runs reached")
-      break
+      return Number.isInteger(code) && code > 0 ? code : code < 0 ? 1 : 0
     }
 
     if (delay > 0) {
@@ -155,41 +192,75 @@ async function daemon() {
   }
 }
 
+function taskArtifacts(name) {
+  const id = createHash("sha256").update(String(name || "OpenCodeLoop")).digest("hex").slice(0, 16)
+  return {
+    config: path.join(TASK_ROOT, `${id}.json`),
+    launcher: path.join(TASK_ROOT, `${id}.cmd`),
+  }
+}
+
+function removeTaskArtifacts(artifacts) {
+  for (const target of [artifacts.launcher, artifacts.config]) {
+    try { fs.rmSync(target, { force: true }) } catch {}
+  }
+}
+
+async function taskRun() {
+  const configFile = path.resolve(arg("--config"))
+  let config
+  try { config = JSON.parse(fs.readFileSync(configFile, "utf8")) } catch (error) { throw new Error(`Could not read task config ${configFile}: ${error.message}`) }
+  return await daemon(config)
+}
+
 function installTask() {
   if (process.platform !== "win32") {
     throw new Error("install-task is currently implemented for Windows Task Scheduler only. Use daemon mode on macOS/Linux.")
   }
 
   const project = path.resolve(arg("--project", process.cwd()))
+  validateProject(project)
   const every = arg("--every", "10m")
   const minutes = Math.max(1, Math.round(parseMs(every) / 60_000))
   const name = arg("--name", "OpenCodeLoop")
   const promptFile = arg("--prompt-file")
   const promptArg = arg("--prompt")
+  const model = arg("--model")
+  const agent = arg("--agent")
   const node = process.execPath
   const script = fileURLToPath(import.meta.url)
-
-  const commandParts = [
-    quoteWindowsArg(node),
-    quoteWindowsArg(script),
-    "daemon",
-    "--project",
-    quoteWindowsArg(project),
-    "--every",
-    "0s",
-    "--max-runs",
-    "1",
-  ]
-
-  if (promptFile) commandParts.push("--prompt-file", quoteWindowsArg(promptFile))
-  if (promptArg) commandParts.push("--prompt", quoteWindowsArg(promptArg))
-
-  const taskCommand = commandParts.join(" ")
+  const artifacts = taskArtifacts(name)
+  fs.mkdirSync(TASK_ROOT, { recursive: true })
+  const taskConfig = {
+    project,
+    every: "0s",
+    maxRuns: 1,
+    promptFile: promptFile ? path.resolve(project, promptFile) : undefined,
+    prompt: promptArg || undefined,
+    model: model || undefined,
+    agent: agent || undefined,
+    opencodeBin: OPENCODE_BIN,
+  }
+  fs.writeFileSync(artifacts.config, JSON.stringify(taskConfig, null, 2) + "\n", "utf8")
+  const launcherCommand = [quoteWindowsArg(node), quoteWindowsArg(script), "task-run", "--config", quoteWindowsArg(artifacts.config)].join(" ")
+  fs.writeFileSync(artifacts.launcher, `@echo off\r\n${launcherCommand}\r\nexit /b %errorlevel%\r\n`, "utf8")
+  const taskCommand = `cmd.exe /d /s /c "${quoteWindowsArg(artifacts.launcher)}"`
+  if (taskCommand.length > 261) {
+    removeTaskArtifacts(artifacts)
+    throw new Error(`Task Scheduler command is still too long (${taskCommand.length} characters). Set OPENCODE_LOOPD_TASK_DIR to a shorter directory.`)
+  }
   const taskArgs = ["/Create", "/F", "/SC", "MINUTE", "/MO", String(minutes), "/TN", name, "/TR", taskCommand]
 
-  console.log(["schtasks", ...taskArgs.map((part) => JSON.stringify(part))].join(" "))
-  const result = spawnSync("schtasks", taskArgs, { shell: false, stdio: "inherit" })
-  process.exit(result.status ?? 0)
+  console.log([SCHTASKS_BIN, ...taskArgs.map((part) => JSON.stringify(part))].join(" "))
+  const result = runSync(SCHTASKS_BIN, taskArgs)
+  if (result.error) {
+    removeTaskArtifacts(artifacts)
+    console.error(`[opencode-loopd] failed to start ${SCHTASKS_BIN}: ${result.error.message}`)
+    return 1
+  }
+  const status = Number.isInteger(result.status) ? result.status : 1
+  if (status !== 0) removeTaskArtifacts(artifacts)
+  return status
 }
 
 function uninstallTask() {
@@ -198,8 +269,14 @@ function uninstallTask() {
   }
 
   const name = arg("--name", "OpenCodeLoop")
-  const result = spawnSync("schtasks", ["/Delete", "/F", "/TN", name], { shell: false, stdio: "inherit" })
-  process.exit(result.status ?? 0)
+  const result = runSync(SCHTASKS_BIN, ["/Delete", "/F", "/TN", name])
+  if (result.error) {
+    console.error(`[opencode-loopd] failed to start ${SCHTASKS_BIN}: ${result.error.message}`)
+    return 1
+  }
+  const status = Number.isInteger(result.status) ? result.status : 1
+  if (status === 0) removeTaskArtifacts(taskArtifacts(name))
+  return status
 }
 
 function help() {
@@ -217,6 +294,8 @@ Options:
   --every <duration>     0s, 5m, 1h, etc.
   --prompt <text>        Prompt text
   --prompt-file <file>   Read prompt from file relative to the project
+  --model <provider/id>  OpenCode model used for each run
+  --agent <name>         OpenCode agent used for each run
   --max-runs <n>         Stop after n runs
   --sleep-first          Wait before first run
 `)
@@ -225,20 +304,25 @@ Options:
 const command = args[0]
 
 try {
+  let exitCode = 0
   if (command === "daemon" || command === "loopd") {
     args.shift()
-    await daemon()
+    exitCode = await daemon()
   } else if (command === "install-task") {
     args.shift()
-    installTask()
+    exitCode = installTask()
   } else if (command === "uninstall-task") {
     args.shift()
-    uninstallTask()
+    exitCode = uninstallTask()
+  } else if (command === "task-run") {
+    args.shift()
+    exitCode = await taskRun()
   } else if (has("--help") || has("-h") || command === "help") {
     help()
   } else {
-    await daemon()
+    exitCode = await daemon()
   }
+  if (exitCode) process.exitCode = exitCode
 } catch (error) {
   console.error(error?.message || error)
   process.exit(1)

package/scripts/smoke-test.mjs

@@ -12,6 +12,15 @@ const prompts = []
 const liveStatuses = new Map([[sessionID, "idle"]])
 let hooks
 
+async function waitFor(predicate, timeoutMs = 2_000) {
+  const deadline = Date.now() + timeoutMs
+  while (!predicate()) {
+    if (Date.now() >= deadline) return false
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  return true
+}
+
 function legacyBody(name) {
   return async (args) => {
     attempts[name]++
@@ -86,8 +95,11 @@ try {
   assert.equal(output.parts.length, 0, "a locally handled slash command must not start a placeholder model turn")
 
   await hooks["command.execute.before"]({ command: "loop-now", sessionID, arguments: "goal" }, { parts: [] })
-  await new Promise((resolve) => setTimeout(resolve, 0))
-  assert.ok(prompts.some((prompt) => prompt.includes(path.resolve(directory))), "goal prompt must include the working directory")
+  assert.equal(
+    await waitFor(() => prompts.some((prompt) => prompt.includes(path.resolve(directory)))),
+    true,
+    "goal prompt must include the working directory",
+  )
   assert.ok(prompts.some((prompt) => prompt.includes("never turn a relative path into a root path")))
 
   const stateFile = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
@@ -122,8 +134,11 @@ try {
 
   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")
+  assert.equal(
+    await waitFor(() => prompts.length === promptCountBeforeBackgroundTool + 1, 5_000),
+    true,
+    "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: [] })
 
@@ -143,8 +158,11 @@ try {
   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")
+  assert.equal(
+    await waitFor(() => prompts.length === promptCountBeforeBackgroundChild + 1, 5_000),
+    true,
+    "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)

package/src/index.js

@@ -20,6 +20,7 @@ const GOAL_PROMPT_PREFIX = "EXPERIMENTAL OPENCODE GOAL MODE ITERATION"
 const DEFAULT_GOAL_MAX_NO_PROGRESS = 3
 const DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180_000
 const LOOP_OWNED_USER_MESSAGE_GUARD_MS = 10_000
+const LOOP_OWNED_USER_MESSAGE_RETENTION_MS = 10 * 60_000
 const LOCAL_COMMAND_AGENT = "opencode-loop-local"
 
 const activeRuns = new Map()
@@ -509,18 +510,31 @@ async function toast(client, message, variant = "info") {
 
 function guardLoopOwnedUserMessage(sessionID) {
   if (!sessionID) return
-  loopOwnedUserMessageGuards.set(sessionID, now() + LOOP_OWNED_USER_MESSAGE_GUARD_MS)
-  for (const [key, time] of loopOwnedUserMessageGuards.entries()) if (time < now()) loopOwnedUserMessageGuards.delete(key)
+  const current = loopOwnedUserMessageGuards.get(sessionID) || { pending: 0, until: 0, messageIDs: new Map() }
+  current.pending += 1
+  current.until = Math.max(current.until || 0, now() + LOOP_OWNED_USER_MESSAGE_GUARD_MS)
+  for (const [messageID, expiresAt] of current.messageIDs.entries()) if (expiresAt < now()) current.messageIDs.delete(messageID)
+  loopOwnedUserMessageGuards.set(sessionID, current)
+  for (const [key, entry] of loopOwnedUserMessageGuards.entries()) {
+    for (const [messageID, expiresAt] of entry.messageIDs.entries()) if (expiresAt < now()) entry.messageIDs.delete(messageID)
+    if ((entry.pending || 0) <= 0 && entry.messageIDs.size === 0 && (entry.until || 0) < now()) loopOwnedUserMessageGuards.delete(key)
+  }
 }
 
-function loopOwnedUserMessageGuardActive(sessionID) {
-  const until = loopOwnedUserMessageGuards.get(sessionID)
-  if (typeof until !== "number") return false
-  if (until < now()) {
-    loopOwnedUserMessageGuards.delete(sessionID)
-    return false
+function loopOwnedUserMessageGuardActive(sessionID, messageID) {
+  const entry = loopOwnedUserMessageGuards.get(sessionID)
+  if (!entry || typeof entry !== "object") return false
+  for (const [id, expiresAt] of entry.messageIDs.entries()) if (expiresAt < now()) entry.messageIDs.delete(id)
+  const id = typeof messageID === "string" ? messageID : ""
+  if (id && entry.messageIDs.has(id)) return true
+  if ((entry.pending || 0) > 0 && (entry.until || 0) >= now()) {
+    entry.pending -= 1
+    if (id) entry.messageIDs.set(id, now() + LOOP_OWNED_USER_MESSAGE_RETENTION_MS)
+    loopOwnedUserMessageGuards.set(sessionID, entry)
+    return true
   }
-  return true
+  if ((entry.pending || 0) <= 0 && entry.messageIDs.size === 0) loopOwnedUserMessageGuards.delete(sessionID)
+  return false
 }
 
 async function say(client, sessionID, text) {
@@ -1106,8 +1120,9 @@ function userInterruptSessionFromEvent(event) {
   const info = props.info || props.message || props
   const role = info?.role
   const sessionID = info?.sessionID || props.sessionID
+  const messageID = info?.id || props.messageID
   if (role !== "user" || typeof sessionID !== "string") return undefined
-  if (loopOwnedUserMessageGuardActive(sessionID)) return undefined
+  if (loopOwnedUserMessageGuardActive(sessionID, messageID)) return undefined
   return sessionID
 }