@bybrawe/opencode-loop 0.5.13 → 0.5.15

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.5.15
+
+- Hardened experimental Goal Mode completion: agent tool completion now requires concrete evidence instead of accepting empty or generic claims.
+- Required configured goal `--check` commands to pass before agent-tool completion, unless the user explicitly opts out or manually marks the goal done.
+- Added a no-progress guard for goals. Goals pause after 3 turns without recorded meaningful progress by default, configurable with `--max-no-progress`.
+- Paused active goals when a real user message arrives, so new user intent wins before the next automatic continuation.
+- Preferred the OpenCode plugin SDK's `{ body }`, `{ path: { id }, body }`, and `{ query }` argument shapes while keeping flat and older path-key fallbacks.
+- Added the resolved working directory and workspace-relative path rules to Goal Mode prompts so agents do not accidentally target filesystem-root paths.
+- Increased Goal Mode's default active-turn recovery window to 3 minutes so slow model/tool turns are not finalized as stale after 20 seconds.
+- Added plugin disposal cleanup for heartbeat, idle, due, watchdog, and active-run timers.
+- Added an automated smoke test for SDK call order, Goal Mode prompts, evidence rejection, and successful completion state.
+- Updated local installers to create or update config `package.json` with `@opencode-ai/plugin`, needed by local `.ts` plugins that import `tool()`.
+- Updated Goal Mode status/report output and README guidance for the new guards.
+
+## 0.5.14
+
+- Guarded active-run finalization so heartbeat and retry checks do not treat a still-running assistant turn as finished.
+- Made loop state writes atomic and backed up corrupt state files before falling back to an empty state.
+- Changed `opencode-loopd` to pass prompts as process arguments instead of shell strings, preserving quotes in inline prompts.
+- Stripped UTF-8 BOMs from daemon prompt files before sending them to OpenCode.
+- Removed the package plugin entry from the example config to avoid duplicate loading after the recommended local installer path.
+
 ## 0.5.13
 
 - Wrapped experimental goal tools with `tool()` and Zod schemas for current OpenCode tool validation.

package/README.md

@@ -16,7 +16,7 @@ v0.5.11 includes a referenced heartbeat scheduler. This is important in OpenCode
 
 ## Current status
 
-**v0.5.11 is a reliability hotfix for recurring timers that only continued after manual activity.** It keeps the real due timer from v0.5.8 and the stale-busy recovery from v0.5.9, then adds a watchdog checker and stronger stale-active-run recovery. This targets the case where `/loop 1m ...` reaches its due time but does not fire until you run `/loop-status` or type another command. Scheduled `/compact` still routes through OpenCode's current TUI alias first, with fallback paths for older builds.
+**v0.5.15 is a Goal Mode and SDK compatibility hardening release.** It keeps the timer/watchdog reliability fixes from v0.5.11-v0.5.14, then tightens experimental goals with evidence-gated completion, passing-check requirements, no-progress pausing, user-message interruption, explicit workspace paths, and safer active-turn recovery. It also prefers the OpenCode plugin SDK argument shape while keeping fallbacks for older builds.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -26,13 +26,13 @@ The known update-related symptoms from older builds are fixed:
 - prompt, shell, or toast calls silently fail after OpenCode SDK changes
 - `/compact` accidentally being treated as a normal agent prompt
 - intermittent `Tool execution aborted` behavior caused by triggering a new turn too early
-- experimental `/loop-goal` support for goal-driven work that continues until complete, blocked, paused, or cleared
+- experimental `/loop-goal` support for goal-driven work that continues until complete, blocked, paused, cleared, or paused by no-progress/user-interrupt guards
 - `--no-now` interval jobs not waking until another OpenCode event happens
 - `/loop-ask`, `/loop-command`, and `/loop-shell` being configured but not reliably firing on their own
 
 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.11 quick behavior guide
+## v0.5.15 quick behavior guide
 
 OpenCode Loop has two triggers now:
 
@@ -151,33 +151,13 @@ OpenCode Loop is designed for developers searching for:
 
 ### Recommended: install from npm
 
-For a clean reinstall or upgrade, use the latest published package:
+Use the npm installer from any shell: Windows PowerShell, Windows CMD, macOS, or Linux.
 
 ```bash
 npx -y @bybrawe/opencode-loop@latest
 ```
 
-Then fully restart OpenCode.
-
-Install from npm with `npx`:
-
-```bash
-npx -y @bybrawe/opencode-loop
-```
-
-On Windows CMD:
-
-```bat
-npx -y @bybrawe/opencode-loop
-```
-
-On Windows PowerShell:
-
-```powershell
-npx -y @bybrawe/opencode-loop
-```
-
-The installer copies the plugin and slash command files into your OpenCode config directory.
+The installer copies the plugin and slash command files into your OpenCode config directory. It also ensures that the config directory has a `package.json` dependency on `@opencode-ai/plugin`, which local `.ts` plugins need for the `tool()` helper.
 It also removes the old local `opencode-loop.js` copy from earlier releases so only the current local `opencode-loop.ts` plugin remains.
 
 Windows target paths:
@@ -217,6 +197,7 @@ The `npx` installer installs both parts:
 - the `/loop-*` command markdown files
 
 Use the OpenCode config-only method only if you already installed the command files separately or you are only testing plugin loading.
+Do not use the config package entry and the local `npx`-installed plugin at the same time unless you intentionally want to test duplicate plugin loading.
 
 ### Optional: OpenCode config package entry
 
@@ -239,6 +220,8 @@ If `/loop` does not appear after using only the config method, run the installer
 npx -y @bybrawe/opencode-loop
 ```
 
+If you later switch back to the recommended `npx` local install, remove `@bybrawe/opencode-loop` from the `plugin` array to avoid loading the package plugin and local plugin together.
+
 ### Install from GitHub
 
 Use this if you want to install from source instead of npm.
@@ -407,7 +390,7 @@ That can look like a chat prompt in older versions or unclear setups. Prefer `/l
 
 ### Experimental Goal Mode
 
-Goal Mode is experimental. Use it when you do **not** want a timer such as “every 5 minutes”. Use it when you want OpenCode to keep pursuing a result until it is complete or blocked.
+Goal Mode is experimental. Use it when you do **not** want a timer such as "every 5 minutes". Use it when you want OpenCode to keep pursuing a result until it is complete or blocked.
 
 Basic goal:
 
@@ -425,6 +408,16 @@ What happens:
 
 Goal Mode is idle-safe. If OpenCode is busy, it waits. It does not intentionally start another turn on top of a running turn.
 
+Completion guards:
+
+- The agent tool cannot mark a goal complete with empty or generic evidence. Evidence should mention commands, files, checks, results, or code inspection details.
+- If a goal has `--check` commands, agent-tool completion requires the latest configured checks to pass by default.
+- `/loop-goal-done` is still a manual user override when you want to mark the goal complete yourself.
+- Goal Mode pauses when a real user message arrives, so a new instruction can take control before the next automatic continuation.
+- Goal Mode pauses after 3 turns without recorded meaningful progress by default. Change this with `--max-no-progress <n>`, or disable it with `--max-no-progress 0`.
+- Each Goal Mode prompt includes the resolved project directory and requires workspace-relative file paths.
+- A running goal turn gets 3 minutes by default before stale-run recovery can finalize it. This avoids overlapping or prematurely closing slower model/tool turns.
+
 Simple status and control commands:
 
 ```text
@@ -468,6 +461,12 @@ Goal that automatically stops when all configured checks pass:
 /loop-goal --check "npm run typecheck" --check "npm run build" --complete-when-checks-pass make the project build cleanly
 ```
 
+Goal that gives the agent more attempts before the no-progress guard pauses it:
+
+```text
+/loop-goal --max-no-progress 6 --check "npm test" fix the failing tests and keep evidence in the goal report
+```
+
 Goal with a safety/runtime limit:
 
 ```text
@@ -1113,6 +1112,23 @@ Improve the application in small safe steps.
 
 ## Changelog highlights
 
+### v0.5.15
+
+- Hardened experimental Goal Mode completion with concrete evidence, passing-check requirements, no-progress pausing, and user-message interruption.
+- Preferred OpenCode plugin SDK `{ body }`, `{ path: { id }, body }`, and `{ query }` shapes before compatibility fallbacks.
+- Added explicit workspace path guidance, safer 3-minute active-turn recovery, timer disposal cleanup, and an automated Goal Mode smoke test.
+- Made local installers add the `@opencode-ai/plugin` dependency needed by local `.ts` plugins.
+
+### v0.5.13
+
+- Wrapped experimental goal tools with OpenCode's `tool()` helper and Zod schemas for current OpenCode tool validation.
+- Added `@opencode-ai/plugin` as a development dependency so fresh clones can resolve the tool helper.
+
+### v0.5.12
+
+- Changed local installs to write `opencode-loop.ts` and remove stale `opencode-loop.js` copies.
+- Fixed OpenCode CLI command argument parsing, current SDK call shapes, and `opencode-loopd` prompt passing.
+
 ### v0.5.7
 
 - Added experimental Goal Mode with `/loop-goal <objective>`.
@@ -1127,11 +1143,11 @@ Improve the application in small safe steps.
 - Stabilized `/loop-command 200m /compact` by routing compact/summarize through OpenCode TUI compact handling instead of treating it as a custom prompt command.
 - Clarified that command loops wait for idle and should be used for slash commands such as `/compact`.
 
-## v0.5.5
+### v0.5.5
 
 - Added explicit loop action types: prompt, scheduled question, OpenCode slash command, and shell command.
 - Added `/loop-command` / `/loop-cmd` for commands such as `/compact`; these wait for the first interval by default.
-- Added `/loop-ask` for recurring checks such as “did you run tests, tsc --noEmit, and build?”; it waits for the first interval by default.
+- Added `/loop-ask` for recurring checks such as "did you run tests, tsc --noEmit, and build?"; it waits for the first interval by default.
 - Added `/loop-shell` for recurring shell commands.
 - Added `--prompt`, `--ask`, `--command`, `--cmd`, `--slash`, `--shell`, and `--compact` type flags for `/loop`.
 - Clarified idle behavior: if a job becomes due while OpenCode is busy, it waits and runs on the next idle event.

package/examples/opencode.json

@@ -1,7 +1,6 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
-    "@bybrawe/opencode-loop",
     "@tarquinen/opencode-dcp@latest"
   ],
   "permission": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "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",
@@ -17,7 +17,8 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "check": "node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/loopd.mjs",
+    "check": "node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/loopd.mjs && node --check scripts/smoke-test.mjs",
+    "test": "node scripts/smoke-test.mjs",
     "install:global": "node scripts/install-node.mjs",
     "pack:zip": "node scripts/make-zip.mjs"
   },
@@ -58,8 +59,8 @@
     "@opencode-ai/plugin": "^1.4.0"
   },
   "bin": {
-    "opencode-loop": "scripts/install-node.mjs",
-    "opencode-loopd": "scripts/loopd.mjs"
+    "opencode-loop": "./scripts/install-node.mjs",
+    "opencode-loopd": "./scripts/loopd.mjs"
   },
   "publishConfig": {
     "access": "public"

package/scripts/install-node.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { copyFile, mkdir, readdir, rm } from "node:fs/promises"
+import { copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
 import { fileURLToPath } from "node:url"
@@ -8,9 +8,30 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)))
 const config = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode")
 const pluginDir = join(config, "plugins")
 const commandDir = join(config, "commands")
+const packagePath = join(config, "package.json")
+
+async function ensureDependency() {
+  let pkg = {}
+  try {
+    pkg = JSON.parse(await readFile(packagePath, "utf8"))
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      console.warn(`Could not update ${packagePath}: ${error.message}`)
+      console.warn('Add "@opencode-ai/plugin": ">=1.4.0" to that package.json if OpenCode cannot load the local plugin.')
+      return
+    }
+  }
+  if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) pkg = {}
+  pkg.dependencies = pkg.dependencies && typeof pkg.dependencies === "object" && !Array.isArray(pkg.dependencies) ? pkg.dependencies : {}
+  if (!pkg.dependencies["@opencode-ai/plugin"]) {
+    pkg.dependencies["@opencode-ai/plugin"] = ">=1.4.0"
+    await writeFile(packagePath, JSON.stringify(pkg, null, 2) + "\n", "utf8")
+  }
+}
 
 await mkdir(pluginDir, { recursive: true })
 await mkdir(commandDir, { recursive: true })
+await ensureDependency()
 await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
 await rm(join(pluginDir, "opencode-loop.js"), { force: true })
 

package/scripts/install.ps1

@@ -8,6 +8,24 @@ $Root = Split-Path -Parent $PSScriptRoot
 New-Item -ItemType Directory -Force -Path $PluginDir | Out-Null
 New-Item -ItemType Directory -Force -Path $CommandDir | Out-Null
 
+$PackageFile = Join-Path $ConfigDir "package.json"
+if (Test-Path $PackageFile) {
+  try {
+    $PackageJson = Get-Content -Raw -Path $PackageFile | ConvertFrom-Json
+    if (-not $PackageJson.dependencies) {
+      $PackageJson | Add-Member -MemberType NoteProperty -Name dependencies -Value ([pscustomobject]@{})
+    }
+    if (-not $PackageJson.dependencies.PSObject.Properties["@opencode-ai/plugin"]) {
+      $PackageJson.dependencies | Add-Member -MemberType NoteProperty -Name "@opencode-ai/plugin" -Value ">=1.4.0"
+      $PackageJson | ConvertTo-Json -Depth 20 | Set-Content -Path $PackageFile -Encoding UTF8
+    }
+  } catch {
+    Write-Warning "Could not update $PackageFile. Add '@opencode-ai/plugin': '>=1.4.0' if OpenCode cannot load the local plugin."
+  }
+} else {
+  '{"dependencies":{"@opencode-ai/plugin":">=1.4.0"}}' | Set-Content -Path $PackageFile -Encoding UTF8
+}
+
 Copy-Item -Force (Join-Path $Root "src\index.js") (Join-Path $PluginDir "opencode-loop.ts")
 Remove-Item -Force -ErrorAction SilentlyContinue (Join-Path $PluginDir "opencode-loop.js")
 Copy-Item -Force (Join-Path $Root "commands\*.md") $CommandDir

package/scripts/install.sh

@@ -7,6 +7,31 @@ COMMAND_DIR="$CONFIG_DIR/commands"
 ROOT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
 
 mkdir -p "$PLUGIN_DIR" "$COMMAND_DIR"
+PACKAGE_FILE="$CONFIG_DIR/package.json"
+if command -v node >/dev/null 2>&1; then
+  PACKAGE_FILE="$PACKAGE_FILE" node --input-type=module - <<'NODE'
+import fs from "node:fs"
+
+const file = process.env.PACKAGE_FILE
+let pkg = {}
+try {
+  pkg = JSON.parse(fs.readFileSync(file, "utf8"))
+} catch (error) {
+  if (error.code !== "ENOENT") {
+    console.warn(`Could not update ${file}: ${error.message}`)
+    process.exit(0)
+  }
+}
+if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) pkg = {}
+if (!pkg.dependencies || typeof pkg.dependencies !== "object" || Array.isArray(pkg.dependencies)) pkg.dependencies = {}
+if (!pkg.dependencies["@opencode-ai/plugin"]) {
+  pkg.dependencies["@opencode-ai/plugin"] = ">=1.4.0"
+  fs.writeFileSync(file, JSON.stringify(pkg, null, 2) + "\n")
+}
+NODE
+elif [ ! -f "$PACKAGE_FILE" ]; then
+  printf '%s\n' '{"dependencies":{"@opencode-ai/plugin":">=1.4.0"}}' > "$PACKAGE_FILE"
+fi
 cp "$ROOT_DIR/src/index.js" "$PLUGIN_DIR/opencode-loop.ts"
 rm -f "$PLUGIN_DIR/opencode-loop.js"
 cp "$ROOT_DIR/commands"/*.md "$COMMAND_DIR/"

package/scripts/loopd.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url"
 
 const args = process.argv.slice(2)
 const FAILED_RUN_RETRY_MS = 5_000
+const OPENCODE_BIN = process.env.OPENCODE_BIN || "opencode"
 
 function arg(name, fallback = null) {
   const i = args.indexOf(name)
@@ -39,25 +40,60 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
-function run(command, cwd) {
+function spawnOnce(command, commandArgs, cwd) {
   return new Promise((resolve) => {
-    const child = spawn(command, {
-      cwd,
-      shell: true,
-      stdio: "inherit",
-      env: process.env,
-    })
-
-    child.on("exit", (code) => resolve(code ?? 0))
+    let settled = false
+    const done = (result) => {
+      if (settled) return
+      settled = true
+      resolve(result)
+    }
+
+    let child
+    try {
+      child = spawn(command, commandArgs, {
+        cwd,
+        shell: false,
+        stdio: "inherit",
+        env: process.env,
+        windowsHide: true,
+      })
+    } catch (error) {
+      done({ code: -1, error })
+      return
+    }
+
+    child.on("error", (error) => done({ code: -1, error }))
+    child.on("exit", (code) => done({ code: code ?? 0 }))
   })
 }
 
+function quoteWindowsArg(value) {
+  const text = String(value ?? "")
+  return `"${text.replace(/(\\*)"/g, '$1$1\\"').replace(/\\+$/g, "$&$&")}"`
+}
+
+function stripBom(text) {
+  return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text
+}
+
+async function run(command, commandArgs, cwd) {
+  const direct = await spawnOnce(command, commandArgs, cwd)
+  if (direct.code !== -1 || process.platform !== "win32" || !["ENOENT", "EINVAL"].includes(direct.error?.code)) return direct.code
+
+  const fallback = await spawnOnce("cmd.exe", ["/d", "/s", "/c", command, ...commandArgs], cwd)
+  if (fallback.code === -1) {
+    console.error(`[opencode-loopd] failed to start ${command}: ${fallback.error?.message || direct.error?.message || "unknown error"}`)
+  }
+  return fallback.code
+}
+
 function readPrompt(project) {
   const promptFile = arg("--prompt-file")
   const promptArg = arg("--prompt")
 
   if (promptFile) {
-    return fs.readFileSync(path.resolve(project, promptFile), "utf8")
+    return stripBom(fs.readFileSync(path.resolve(project, promptFile), "utf8"))
   }
 
   if (promptArg) return promptArg
@@ -99,8 +135,7 @@ async function daemon() {
     console.log("")
     console.log(`[opencode-loopd] run #${count} ${new Date().toISOString()}`)
 
-    const command = `opencode run --continue ${JSON.stringify(prompt)}`
-    const code = await run(command, project)
+    const code = await run(OPENCODE_BIN, ["run", "--continue", prompt], project)
 
     if (code !== 0) {
       console.log(`[opencode-loopd] opencode exited with code ${code}`)
@@ -135,25 +170,25 @@ function installTask() {
   const script = fileURLToPath(import.meta.url)
 
   const commandParts = [
-    `"${node}"`,
-    `"${script}"`,
+    quoteWindowsArg(node),
+    quoteWindowsArg(script),
     "daemon",
     "--project",
-    `"${project}"`,
+    quoteWindowsArg(project),
     "--every",
     "0s",
     "--max-runs",
     "1",
   ]
 
-  if (promptFile) commandParts.push("--prompt-file", `"${promptFile}"`)
-  if (promptArg) commandParts.push("--prompt", `"${promptArg.replaceAll('"', '\\"')}"`)
+  if (promptFile) commandParts.push("--prompt-file", quoteWindowsArg(promptFile))
+  if (promptArg) commandParts.push("--prompt", quoteWindowsArg(promptArg))
 
   const taskCommand = commandParts.join(" ")
-  const schtasks = `schtasks /Create /F /SC MINUTE /MO ${minutes} /TN "${name}" /TR ${JSON.stringify(taskCommand)}`
+  const taskArgs = ["/Create", "/F", "/SC", "MINUTE", "/MO", String(minutes), "/TN", name, "/TR", taskCommand]
 
-  console.log(schtasks)
-  const result = spawnSync(schtasks, { shell: true, stdio: "inherit" })
+  console.log(["schtasks", ...taskArgs.map((part) => JSON.stringify(part))].join(" "))
+  const result = spawnSync("schtasks", taskArgs, { shell: false, stdio: "inherit" })
   process.exit(result.status ?? 0)
 }
 
@@ -163,7 +198,7 @@ function uninstallTask() {
   }
 
   const name = arg("--name", "OpenCodeLoop")
-  const result = spawnSync(`schtasks /Delete /F /TN "${name}"`, { shell: true, stdio: "inherit" })
+  const result = spawnSync("schtasks", ["/Delete", "/F", "/TN", name], { shell: false, stdio: "inherit" })
   process.exit(result.status ?? 0)
 }
 

package/scripts/smoke-test.mjs

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+import OpenCodeLoopPlugin from "../src/index.js"
+
+const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-smoke-"))
+const sessionID = "ses_smoke_goal"
+const attempts = { log: 0, prompt: 0, status: 0, toast: 0 }
+const prompts = []
+let hooks
+
+function legacyBody(name) {
+  return async (args) => {
+    attempts[name]++
+    assert.ok(args?.body, `${name} must use the plugin SDK body shape first`)
+    return { data: true }
+  }
+}
+
+const client = {
+  app: {
+    log: legacyBody("log"),
+  },
+  tui: {
+    executeCommand: async (args) => {
+      assert.ok(args?.body?.command)
+      return { data: true }
+    },
+    showToast: legacyBody("toast"),
+  },
+  session: {
+    abort: async (args) => {
+      assert.equal(args?.path?.id, sessionID)
+      return { data: true }
+    },
+    command: async (args) => {
+      assert.equal(args?.path?.id, sessionID)
+      assert.ok(args?.body?.command)
+      return { data: true }
+    },
+    prompt: async (args) => {
+      attempts.prompt++
+      assert.equal(args?.path?.id, sessionID, "session.prompt must use path.id first")
+      assert.ok(Array.isArray(args?.body?.parts))
+      prompts.push(args.body.parts.map((part) => part.text || "").join("\n"))
+      return { data: true }
+    },
+    shell: async (args) => {
+      assert.equal(args?.path?.id, sessionID)
+      assert.ok(args?.body?.command)
+      return { data: true }
+    },
+    status: async (args) => {
+      attempts.status++
+      assert.equal(args?.query?.directory, directory, "session.status must use query.directory first")
+      return { data: { [sessionID]: { type: "idle" } } }
+    },
+    summarize: async (args) => {
+      assert.equal(args?.path?.id, sessionID)
+      return { data: true }
+    },
+  },
+}
+
+try {
+  hooks = await OpenCodeLoopPlugin({ client, directory })
+  assert.deepEqual(Object.keys(hooks.tool).sort(), [
+    "opencode_loop_goal_blocked",
+    "opencode_loop_goal_complete",
+    "opencode_loop_goal_progress",
+  ])
+
+  const output = { parts: [{ type: "text", text: "original command body" }] }
+  await hooks["command.execute.before"]({
+    command: "loop-goal",
+    sessionID,
+    arguments: "Create proof.txt and verify it --max-turns 3",
+  }, output)
+  assert.match(output.parts[0].text, /handled by the local plugin/i)
+
+  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.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`)
+  const activeState = JSON.parse(await fs.readFile(stateFile, "utf8"))
+  assert.equal(activeState.jobs[0].activeRecoveryMs, 180_000)
+
+  const rejected = await hooks.tool.opencode_loop_goal_complete.execute({ summary: "Done", evidence: "done" }, { directory, sessionID })
+  assert.equal(rejected.title, "Goal completion rejected")
+
+  const completed = await hooks.tool.opencode_loop_goal_complete.execute({
+    summary: "Created and verified proof.txt",
+    evidence: "Created proof.txt and read the file back; its exact content matched the requested value.",
+  }, { directory, sessionID })
+  assert.equal(completed.title, "Goal completed")
+
+  const completedState = JSON.parse(await fs.readFile(stateFile, "utf8"))
+  assert.equal(completedState.jobs[0].goalStatus, "completed")
+  assert.equal(completedState.jobs[0].paused, true)
+  assert.equal(completedState.jobs[0].enabled, false)
+
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+  assert.equal(attempts.log, 1)
+  assert.ok(attempts.prompt >= 1)
+  assert.ok(attempts.status >= 1)
+  assert.ok(attempts.toast >= 1)
+  console.log("OpenCode Loop smoke test passed")
+} finally {
+  await hooks?.dispose?.()
+  await fs.rm(directory, { recursive: true, force: true })
+}

package/src/index.js

@@ -17,14 +17,19 @@ const MAX_SCAN_FILES = 200
 const MAX_SCAN_BYTES = 2_000_000
 const GOAL_REPORT_DIR = "goals"
 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 activeRuns = new Map()
 const handledCommands = new Map()
+const loopOwnedUserMessageGuards = new Map()
 const idleTimers = new Map()
 const dueTimers = new Map()
 const watchdogTimers = new Map()
 const runLocks = new Map()
 const knownSessions = new Map()
+const stateWriteLocks = new Map()
 let heartbeatTimer
 const sessionStatuses = new Map()
 const sessionStatusSeenAt = new Map()
@@ -141,6 +146,11 @@ function parsePositiveInt(value, fallback = 0) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
 }
 
+function parseNonNegativeInt(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value || ""), 10)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}
+
 function parseCompactEvery(value) {
   const duration = parseDuration(value)
   if (duration !== null) return { compactEveryMs: duration }
@@ -202,11 +212,16 @@ function parseLoopArgs(raw, defaults = {}) {
     goalAcceptance: Array.isArray(defaults.goalAcceptance) ? [...defaults.goalAcceptance] : [],
     goalChecks: Array.isArray(defaults.goalChecks) ? [...defaults.goalChecks] : [],
     goalCompleteWhenChecksPass: defaults.goalCompleteWhenChecksPass ?? false,
+    goalRequireEvidence: defaults.goalRequireEvidence,
+    goalRequireChecksPass: defaults.goalRequireChecksPass,
     goalEvidenceFile: defaults.goalEvidenceFile,
     goalSummary: defaults.goalSummary || "",
     goalEvidence: defaults.goalEvidence || "",
     goalBlockedReason: defaults.goalBlockedReason || "",
     goalProgress: Array.isArray(defaults.goalProgress) ? [...defaults.goalProgress] : [],
+    maxNoProgress: defaults.maxNoProgress,
+    noProgressCount: defaults.noProgressCount ?? 0,
+    lastProgressAt: defaults.lastProgressAt ?? 0,
     noOverlap: defaults.noOverlap ?? true,
     safe: defaults.safe ?? false,
     quiet: defaults.quiet ?? false,
@@ -254,10 +269,16 @@ function parseLoopArgs(raw, defaults = {}) {
   ;[found, rest] = takeFlag(rest, "--goal"); if (found) job.kind = "goal"
   ;[found, rest] = takeFlag(rest, "--complete-when-checks-pass"); if (found) job.goalCompleteWhenChecksPass = true
   ;[found, rest] = takeFlag(rest, "--no-complete-when-checks-pass"); if (found) job.goalCompleteWhenChecksPass = false
+  ;[found, rest] = takeFlag(rest, "--require-evidence"); if (found) job.goalRequireEvidence = true
+  ;[found, rest] = takeFlag(rest, "--allow-weak-evidence"); if (found) job.goalRequireEvidence = false
+  ;[found, rest] = takeFlag(rest, "--require-checks-pass"); if (found) job.goalRequireChecksPass = true
+  ;[found, rest] = takeFlag(rest, "--allow-complete-without-checks"); if (found) job.goalRequireChecksPass = false
+  ;[found, rest] = takeFlag(rest, "--allow-complete-with-failing-checks"); if (found) job.goalRequireChecksPass = false
 
   ;[value, rest] = takeFlagValue(rest, "--name"); if (value !== undefined) job.name = value.trim()
   ;[value, rest] = takeFlagValue(rest, "--max-runs"); if (value !== undefined) job.maxRuns = parsePositiveInt(value, 0)
   ;[value, rest] = takeFlagValue(rest, "--max-turns"); if (value !== undefined) job.maxRuns = parsePositiveInt(value, 0)
+  ;[value, rest] = takeFlagValue(rest, "--max-no-progress"); if (value !== undefined) job.maxNoProgress = parseNonNegativeInt(value, DEFAULT_GOAL_MAX_NO_PROGRESS)
   ;[value, rest] = takeFlagValue(rest, "--timeout"); if (value !== undefined) job.timeoutMs = parseDuration(value) ?? 0
   ;[value, rest] = takeFlagValue(rest, "--max-runtime"); if (value !== undefined) job.maxRuntimeMs = parseDuration(value) ?? 0
   ;[value, rest] = takeFlagValue(rest, "--max-failures"); if (value !== undefined) job.maxFailures = parsePositiveInt(value, 0)
@@ -308,6 +329,9 @@ function parseLoopArgs(raw, defaults = {}) {
     job.safe = job.safe !== false
     job.askNever = job.askNever !== false
     job.noOverlap = job.noOverlap !== false
+    job.goalRequireEvidence = job.goalRequireEvidence !== false
+    job.goalRequireChecksPass = job.goalRequireChecksPass ?? job.goalChecks.length > 0
+    job.maxNoProgress = job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS
   }
   job.lastRunAt = job.immediate ? 0 : now()
 
@@ -320,21 +344,61 @@ function statePath(directory, sessionID) { return path.join(stateDir(directory),
 async function ensureDir(directory) { await fs.mkdir(directory, { recursive: true }) }
 async function pathExists(filePath) { try { await fs.access(filePath); return true } catch { return false } }
 
+function stateLockKey(directory, sessionID) {
+  return `${path.resolve(directory)}:${safeID(sessionID)}`
+}
+
+async function withStateWriteLock(directory, sessionID, fn) {
+  const key = stateLockKey(directory, sessionID)
+  const previous = stateWriteLocks.get(key) || Promise.resolve()
+  let release
+  const current = new Promise((resolve) => { release = resolve })
+  const next = previous.catch(() => {}).then(() => current)
+  stateWriteLocks.set(key, next)
+  await previous.catch(() => {})
+  try {
+    return await fn()
+  } finally {
+    release()
+    if (stateWriteLocks.get(key) === next) stateWriteLocks.delete(key)
+  }
+}
+
 async function readState(directory, sessionID) {
+  const target = statePath(directory, sessionID)
   try {
-    const parsed = JSON.parse(await fs.readFile(statePath(directory, sessionID), "utf8"))
+    const parsed = JSON.parse(await fs.readFile(target, "utf8"))
     return { version: 4, jobs: Array.isArray(parsed.jobs) ? parsed.jobs : [] }
-  } catch {
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      try {
+        await ensureDir(stateDir(directory))
+        await fs.copyFile(target, `${target}.corrupt-${Date.now()}`)
+      } catch {}
+    }
     return { version: 4, jobs: [] }
   }
 }
 
 async function writeState(directory, sessionID, state) {
-  await ensureDir(stateDir(directory))
-  await fs.writeFile(statePath(directory, sessionID), JSON.stringify({ version: 4, jobs: state.jobs || [] }, null, 2))
+  await withStateWriteLock(directory, sessionID, async () => {
+    await ensureDir(stateDir(directory))
+    const target = statePath(directory, sessionID)
+    const temp = `${target}.${process.pid}.${Date.now()}.tmp`
+    try {
+      await fs.writeFile(temp, JSON.stringify({ version: 4, jobs: state.jobs || [] }, null, 2))
+      await fs.rename(temp, target)
+    } finally {
+      try { await fs.rm(temp, { force: true }) } catch {}
+    }
+  })
 }
 
-async function removeState(directory, sessionID) { try { await fs.unlink(statePath(directory, sessionID)) } catch {} }
+async function removeState(directory, sessionID) {
+  await withStateWriteLock(directory, sessionID, async () => {
+    try { await fs.unlink(statePath(directory, sessionID)) } catch {}
+  })
+}
 
 function sdkError(result) {
   if (!result || typeof result !== "object") return undefined
@@ -358,32 +422,25 @@ function sdkErrorMessage(error) {
   return String(error)
 }
 
-async function sdkCall(method, modernArgs, legacyArgs) {
+async function sdkCall(method, ...argsList) {
   let firstError
-  try {
-    const result = await method(modernArgs)
-    const error = sdkError(result)
-    if (!error) return sdkData(result)
-    firstError = new Error(sdkErrorMessage(error))
-  } catch (error) {
-    firstError = error
-  }
-  if (legacyArgs !== undefined) {
+  for (const args of argsList) {
+    if (args === undefined) continue
     try {
-      const result = await method(legacyArgs)
+      const result = await method(args)
       const error = sdkError(result)
       if (!error) return sdkData(result)
-      throw new Error(sdkErrorMessage(error))
+      firstError = firstError || new Error(sdkErrorMessage(error))
     } catch (error) {
-      throw error
+      firstError = firstError || error
     }
   }
-  throw firstError
+  throw firstError || new Error("SDK call failed without arguments")
 }
 
-function fireSdk(client, label, method, modernArgs, legacyArgs) {
+function fireSdk(client, label, method, ...argsList) {
   Promise.resolve()
-    .then(() => sdkCall(method, modernArgs, legacyArgs))
+    .then(() => sdkCall(method, ...argsList))
     .catch((error) => log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }))
 }
 
@@ -416,7 +473,12 @@ async function compactSession(client, sessionID) {
     }
   }
   try {
-    await sdkCall(client.session.summarize.bind(client.session), { path: { id: sessionID }, body: {} }, { sessionID })
+    await sdkCall(
+      client.session.summarize.bind(client.session),
+      { path: { id: sessionID }, body: {} },
+      { path: { sessionID }, body: {} },
+      { sessionID },
+    )
     return true
   } catch (error) {
     await log(client, "warn", "session.summarize fallback failed", { error: sdkErrorMessage(error) })
@@ -439,11 +501,29 @@ async function toast(client, message, variant = "info") {
   try { await sdkCall(client.tui.showToast.bind(client.tui), { body: { message, variant } }, { message, variant }) } catch {}
 }
 
+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)
+}
+
+function loopOwnedUserMessageGuardActive(sessionID) {
+  const until = loopOwnedUserMessageGuards.get(sessionID)
+  if (typeof until !== "number") return false
+  if (until < now()) {
+    loopOwnedUserMessageGuards.delete(sessionID)
+    return false
+  }
+  return true
+}
+
 async function say(client, sessionID, text) {
+  guardLoopOwnedUserMessage(sessionID)
   try {
     await sdkCall(
       client.session.prompt.bind(client.session),
       { path: { id: sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } },
+      { path: { sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } },
       { sessionID, noReply: true, parts: [{ type: "text", text }] },
     )
   } catch {}
@@ -461,6 +541,9 @@ function wasHandled(sessionID, name, args) {
 
 function commandName(name) { return String(name || "") }
 function isPreset(name) { return ["loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev", "loop-command", "loop-cmd", "loop-prompt", "loop-ask", "loop-shell"].includes(name) }
+function isLoopCommandName(name) {
+  return name === "loop" || name === "loop-stop" || name === "loop-remove" || name === "loop-clear" || name === "loop-status" || name === "loop-logs" || name === "loop-help" || name === "loop-now" || name === "loop-pause" || name === "loop-resume" || name === "loop-doctor" || name === "loop-init" || name === "loop-export" || name === "loop-goal" || name === "loop-goal-status" || name === "loop-goal-pause" || name === "loop-goal-resume" || name === "loop-goal-clear" || name === "loop-goal-done" || name === "loop-goal-complete" || name === "loop-goal-blocked" || isPreset(name)
+}
 
 function normalizeArgsForKey(args) {
   if (args === undefined || args === null) return ""
@@ -497,7 +580,7 @@ function startHeartbeat() {
       }
       Promise.resolve()
         .then(async () => {
-          await finalizeActiveRun(info.directory, info.client, sessionID, { forceStale: true })
+          await finalizeActiveRun(info.directory, info.client, sessionID, { requireIdle: true, forceStale: true })
           await maybeRunDueJobs(info.directory, info.client, sessionID, { heartbeat: true })
         })
         .catch((error) => appendLoopLog(info.directory, "heartbeat-error", { sessionID, error: sdkErrorMessage(error) }).catch(() => {}))
@@ -508,6 +591,32 @@ function startHeartbeat() {
     }
   }, HEARTBEAT_MS)
 }
+
+function disposeRuntime(directory, client) {
+  const sessions = [...knownSessions.entries()]
+    .filter(([, info]) => info?.directory === directory && info?.client === client)
+    .map(([sessionID]) => sessionID)
+  for (const sessionID of sessions) {
+    clearActiveRun(sessionID)
+    const idle = idleTimers.get(sessionID); if (idle) clearTimeout(idle)
+    const due = dueTimers.get(sessionID); if (due) clearTimeout(due)
+    const watchdog = watchdogTimers.get(sessionID); if (watchdog) clearInterval(watchdog)
+    idleTimers.delete(sessionID)
+    dueTimers.delete(sessionID)
+    watchdogTimers.delete(sessionID)
+    runLocks.delete(sessionID)
+    knownSessions.delete(sessionID)
+    loopOwnedUserMessageGuards.delete(sessionID)
+    sessionStatuses.delete(sessionID)
+    sessionStatusSeenAt.delete(sessionID)
+    for (const key of handledCommands.keys()) if (key.startsWith(`${sessionID}:`)) handledCommands.delete(key)
+  }
+  if (!knownSessions.size && heartbeatTimer) {
+    clearInterval(heartbeatTimer)
+    heartbeatTimer = undefined
+  }
+}
+
 function presetDefaults(name, args) {
   const [maybeDuration, rest] = splitFirst(args)
   const parsed = parseDuration(maybeDuration)
@@ -534,10 +643,11 @@ function jobLabel(job) {
   const verify = job.verifyCommand ? ", verify" : ""
   const preflight = job.preflightCommand ? ", preflight" : ""
   const failures = job.maxFailures > 0 ? `, max failures ${job.maxFailures}` : ""
+  const noProgress = isGoalJob(job) && (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? `, max no-progress ${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : ""
   const stopFile = job.stopFile ? ", stop-file" : ""
   const watch = job.watchPaths?.length ? `, watch ${job.watchPaths.join(",")}` : ""
   const paused = job.paused ? ", paused" : ""
-  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${stopFile}${watch}${paused}`
+  return `${title}${durationToText(job.intervalMs)}${kind} -> ${job.action || `[prompt-file: ${job.promptFile}]`}${limit}${runtime}${timeout}${compact}${verify}${preflight}${failures}${noProgress}${stopFile}${watch}${paused}`
 }
 
 function matchJob(job, target, index) {
@@ -641,6 +751,7 @@ function goalStatusText(job) {
 
 async function buildGoalPrompt(directory, job) {
   const sections = []
+  sections.push(`Working directory:\n${path.resolve(directory)}\nKeep every file operation inside this directory. Prefer workspace-relative paths such as \"src/index.js\"; never turn a relative path into a root path such as \"/src/index.js\".`)
   const objective = String(job.action || "").trim()
   if (objective) sections.push(`Goal objective:\n${objective}`)
   if (job.goalFile) {
@@ -657,6 +768,8 @@ async function buildGoalPrompt(directory, job) {
   if (job.verifyCommand) sections.push(`Post-turn verify command configured by the loop: ${job.verifyCommand}`)
   if (job.lastGoalChecks?.length) sections.push("Latest goal check results:\n" + job.lastGoalChecks.map((item) => `- ${item.command}: exit ${item.code}`).join("\n"))
   if (job.lastVerifyFailure) sections.push("Previous verify/check failure summary:\n" + String(job.lastVerifyFailure).slice(0, 1600))
+  if (job.goalCompletionRejectedReason) sections.push(`Previous completion attempt was rejected:\n${job.goalCompletionRejectedReason}`)
+  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0) sections.push(`No-progress guard:\n${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS} recent turn(s) without recorded meaningful progress.`)
   if (job.goalProgress?.length) sections.push("Recent goal progress:\n" + job.goalProgress.slice(-5).map((item) => `- ${item.time}: ${item.summary}`).join("\n"))
   for (const file of job.includeFiles || []) {
     const text = await readSmallTextFile(path.resolve(directory, file), 80_000)
@@ -671,9 +784,12 @@ Rules:
 - Work on the next smallest useful step toward the goal.
 - Prefer direct code changes, tests, typechecks, builds, and evidence over discussion.
 - Do not claim the goal is complete unless the acceptance criteria are satisfied and verification evidence supports it.
+- If verification commands are configured, do not call opencode_loop_goal_complete until the latest relevant checks have passed unless the user explicitly overrides the goal.
+- Completion evidence must be concrete: mention commands, files, checks, results, or code inspection details.
 - When the goal is complete, call the tool opencode_loop_goal_complete with a summary and evidence.
 - If you are truly blocked and need user input, call the tool opencode_loop_goal_blocked with the reason and what is needed.
 - If you made meaningful progress but the goal is not complete, call the tool opencode_loop_goal_progress with the summary and next step.
+- If you cannot make meaningful progress for this turn, call opencode_loop_goal_blocked instead of repeating the same attempt.
 - Do not call completion tools just to be polite; only call them when the state is real.
 - Do not ask the user questions unless blocked; make reasonable assumptions and continue.
 - Follow safety rules: no destructive commands, force pushes, production deploys, production database resets, or deleting user data.
@@ -811,6 +927,39 @@ function updateSessionStatusFromEvent(event) {
   return undefined
 }
 
+function userInterruptSessionFromEvent(event) {
+  if (!["message.updated", "message.created"].includes(String(event?.type || ""))) return undefined
+  const props = event?.properties || {}
+  const info = props.info || props.message || props
+  const role = info?.role
+  const sessionID = info?.sessionID || props.sessionID
+  if (role !== "user" || typeof sessionID !== "string") return undefined
+  if (loopOwnedUserMessageGuardActive(sessionID)) return undefined
+  return sessionID
+}
+
+async function pauseGoalsForUserInterrupt(directory, client, sessionID) {
+  const state = await readState(directory, sessionID)
+  const interruptedAt = now()
+  let count = 0
+  state.jobs = (state.jobs || []).map((job) => {
+    if (!isGoalJob(job) || job.paused || job.enabled === false || ["completed", "blocked", "cleared"].includes(job.goalStatus)) return job
+    count++
+    return {
+      ...job,
+      paused: true,
+      lastUserInterruptAt: interruptedAt,
+      goalInterruptedReason: "Paused because the user sent a new message while the experimental goal was active.",
+    }
+  })
+  if (!count) return false
+  await writeState(directory, sessionID, state)
+  await toast(client, `Paused ${count} experimental goal(s) because a new user message arrived. Resume with /loop-goal-resume.`, "warning")
+  await appendLoopLog(directory, "goal-user-interrupt", { sessionID, count })
+  await scheduleDueWork(directory, client, sessionID)
+  return true
+}
+
 function staleActiveRun(sessionID) {
   const active = activeRuns.get(sessionID)
   if (!active) return false
@@ -820,9 +969,22 @@ function staleActiveRun(sessionID) {
   return age >= threshold
 }
 
+async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
+  if (!options.requireIdle && !options.forceStale) return true
+  if (options.forceStale && staleActiveRun(sessionID)) return true
+  if (!options.requireIdle) return false
+
+  const live = await readLiveSessionStatus(client, sessionID, directory)
+  if (live?.type) return live.type === "idle"
+
+  const cached = sessionStatuses.get(sessionID)
+  const seenAt = sessionStatusSeenAt.get(sessionID) || 0
+  return cached === "idle" && seenAt > (active.startedAt || 0)
+}
+
 async function readLiveSessionStatus(client, sessionID, directory) {
   const argsList = []
-  if (directory) argsList.push({ query: { directory } }, { workspace: directory }, { directory })
+  if (directory) argsList.push({ query: { directory } }, { directory }, { workspace: directory })
   argsList.push({})
   for (const args of argsList) {
     try {
@@ -1021,11 +1183,17 @@ function goalReportText(job) {
   lines.push(`Created: ${job.createdAt || ""}`)
   if (job.goalCompletedAt) lines.push(`Completed: ${new Date(job.goalCompletedAt).toISOString()}`)
   if (job.goalBlockedAt) lines.push(`Blocked: ${new Date(job.goalBlockedAt).toISOString()}`)
+  if (job.lastUserInterruptAt) lines.push(`Paused by user message: ${new Date(job.lastUserInterruptAt).toISOString()}`)
+  if (job.goalNoProgressPausedAt) lines.push(`Paused by no-progress guard: ${new Date(job.goalNoProgressPausedAt).toISOString()}`)
   if (job.runCount) lines.push(`Turns: ${job.runCount}`)
+  if ((job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0) lines.push(`No-progress: ${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}`)
   lines.push("")
   if (job.goalSummary) lines.push("## Summary", "", String(job.goalSummary), "")
   if (job.goalEvidence) lines.push("## Evidence", "", String(job.goalEvidence), "")
   if (job.goalBlockedReason) lines.push("## Blocked reason", "", String(job.goalBlockedReason), "")
+  if (job.goalCompletionRejectedReason) lines.push("## Last completion rejection", "", String(job.goalCompletionRejectedReason), "")
+  if (job.goalInterruptedReason) lines.push("## Interrupt", "", String(job.goalInterruptedReason), "")
+  if (job.goalNoProgressReason) lines.push("## No-progress guard", "", String(job.goalNoProgressReason), "")
   if (job.goalAcceptance?.length) lines.push("## Acceptance criteria", "", ...job.goalAcceptance.map((item) => `- ${item}`), "")
   if (job.lastGoalChecks?.length) {
     lines.push("## Latest checks", "")
@@ -1061,17 +1229,101 @@ function parseGoalToolText(args, fields) {
   return result
 }
 
+function hasConcreteGoalEvidence(value) {
+  const text = String(value || "").trim()
+  if (text.length < 24) return false
+  const normalized = text.toLowerCase().replace(/\s+/g, " ")
+  const weak = new Set(["done", "complete", "completed", "ok", "looks good", "n/a", "none", "no evidence", "no evidence provided", "goal completed", "marked complete"])
+  if (weak.has(normalized) || normalized.startsWith("marked complete by /loop-goal-done")) return false
+  return /(\b(npm|pnpm|yarn|bun|node|pytest|cargo|dotnet|go test|tsc|typecheck|test|tests|lint|build|check|checks|exit\s*\d|passed|verified|changed|updated|created|fixed|file|files|diff|commit)\b|[`\\/][\w./:-]+)/i.test(text) || text.length >= 80
+}
+
+function goalChecksPassed(job) {
+  return Array.isArray(job?.lastGoalChecks) && job.lastGoalChecks.length > 0 && job.lastGoalChecks.every((item) => Number(item?.code) === 0)
+}
+
+function goalRequiresPassingChecks(job) {
+  return job?.goalRequireChecksPass !== false && Array.isArray(job?.goalChecks) && job.goalChecks.length > 0
+}
+
+async function rejectGoalCompletion(directory, sessionID, state, job, reason) {
+  job.goalCompletionRejectedAt = now()
+  job.goalCompletionRejectedReason = reason
+  job.goalCompletionRejectedCount = (job.goalCompletionRejectedCount || 0) + 1
+  state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+  await writeState(directory, sessionID, state)
+  await writeGoalReport(directory, sessionID, job)
+  await appendLoopLog(directory, "goal-complete-rejected", { sessionID, job: job.name || job.id, reason })
+  return { ok: false, job, rejected: true, message: `Goal completion rejected: ${reason}` }
+}
+
+function goalProgressSnapshot(job) {
+  return {
+    status: job?.goalStatus || "",
+    progressCount: Array.isArray(job?.goalProgress) ? job.goalProgress.length : 0,
+    evidence: String(job?.goalEvidence || ""),
+    checksPassedAt: Number(job?.goalChecksPassedAt || 0),
+    lastGoalCheckAt: Number(job?.lastGoalCheckAt || 0),
+    lastVerifyAt: Number(job?.lastVerifyAt || 0),
+    lastVerifyCode: Number.isFinite(Number(job?.lastVerifyCode)) ? Number(job.lastVerifyCode) : undefined,
+  }
+}
+
+function goalMadeMeaningfulProgress(beforeJob, afterJob) {
+  const before = goalProgressSnapshot(beforeJob || {})
+  const after = goalProgressSnapshot(afterJob || {})
+  if (["completed", "blocked"].includes(after.status) && after.status !== before.status) return true
+  if (after.progressCount > before.progressCount) return true
+  if (after.evidence !== before.evidence && hasConcreteGoalEvidence(after.evidence)) return true
+  if (after.checksPassedAt > before.checksPassedAt || goalChecksPassed(afterJob) && after.lastGoalCheckAt > before.lastGoalCheckAt) return true
+  if (after.lastVerifyAt > before.lastVerifyAt && after.lastVerifyCode === 0) return true
+  return false
+}
+
+async function applyGoalNoProgressGuard(directory, client, sessionID, job, beforeJob) {
+  if (!isGoalJob(job) || ["completed", "blocked"].includes(job.goalStatus) || job.paused || job.enabled === false) return job
+  const limit = Number(job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS)
+  if (!Number.isFinite(limit) || limit <= 0) return job
+  if (goalMadeMeaningfulProgress(beforeJob, job)) {
+    job.noProgressCount = 0
+    job.lastProgressAt = now()
+    return job
+  }
+  job.noProgressCount = (job.noProgressCount || 0) + 1
+  job.lastNoProgressAt = now()
+  await appendLoopLog(directory, "goal-no-progress", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit })
+  if (job.noProgressCount >= limit) {
+    job.paused = true
+    job.goalNoProgressPausedAt = now()
+    job.goalNoProgressReason = `Paused after ${job.noProgressCount} turn(s) without recorded progress. Resume with /loop-goal-resume after adjusting the goal or evidence.`
+    await toast(client, job.goalNoProgressReason, "warning")
+    await appendLoopLog(directory, "goal-no-progress-paused", { sessionID, job: job.name || job.id, count: job.noProgressCount, limit })
+  }
+  return job
+}
+
 async function setGoalComplete(directory, sessionID, args = {}) {
   const state = await readState(directory, sessionID)
   const job = pickGoalJob(state, args.target)
   if (!job) return { ok: false, message: "No active experimental goal was found." }
   const parsed = parseGoalToolText(args, ["summary", "evidence"])
+  const manualOverride = args.manual === true || args.manualOverride === true
+  const completionEvidence = parsed.evidence || job.goalEvidence || ""
+  const skipEvidenceGate = manualOverride || args.allowWeakEvidence === true || job.goalRequireEvidence === false
+  const skipCheckGate = manualOverride || args.allowFailingChecks === true || job.goalRequireChecksPass === false
+  if (!skipEvidenceGate && !hasConcreteGoalEvidence(completionEvidence)) {
+    return await rejectGoalCompletion(directory, sessionID, state, job, "concrete evidence is required before the goal tool can complete the goal")
+  }
+  if (!skipCheckGate && goalRequiresPassingChecks(job) && !goalChecksPassed(job)) {
+    return await rejectGoalCompletion(directory, sessionID, state, job, "configured goal checks have not passed yet")
+  }
   job.goalStatus = "completed"
   job.enabled = false
   job.paused = true
   job.goalCompletedAt = now()
   job.goalSummary = parsed.summary || job.goalSummary || "Goal completed."
-  job.goalEvidence = parsed.evidence || job.goalEvidence || "No evidence provided."
+  job.goalEvidence = completionEvidence || "No evidence provided."
+  job.noProgressCount = 0
   state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
   await writeState(directory, sessionID, state)
   await writeGoalReport(directory, sessionID, job)
@@ -1105,6 +1357,8 @@ async function setGoalProgress(directory, sessionID, args = {}) {
   const item = { time: new Date().toISOString(), summary: parsed.summary || "Progress recorded.", next: parsed.next || "", evidence: parsed.evidence || "" }
   job.goalProgress = [...(job.goalProgress || []), item].slice(-30)
   if (parsed.evidence) job.goalEvidence = parsed.evidence
+  job.noProgressCount = 0
+  job.lastProgressAt = now()
   state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
   await writeState(directory, sessionID, state)
   await writeGoalReport(directory, sessionID, job)
@@ -1148,14 +1402,17 @@ async function runGoalChecks(directory, sessionID, job, client) {
   return job
 }
 
-async function finalizeActiveRun(directory, client, sessionID) {
+async function finalizeActiveRun(directory, client, sessionID, options = {}) {
   const active = activeRuns.get(sessionID)
   if (!active) return
+  if (!await canFinalizeActiveRun(directory, client, sessionID, active, options)) return false
+  const recoveredStale = staleActiveRun(sessionID)
   clearActiveRun(sessionID)
   const state = await readState(directory, sessionID)
   let job = (state.jobs || []).find((candidate) => candidate.id === active.jobId)
   if (!job) return
   job.lastFinishedAt = now()
+  if (recoveredStale) await appendLoopLog(directory, "active-stale-recovery", { sessionID, job: job.name || job.id, startedAt: active.startedAt })
 
   if (job.verifyCommand) {
     const verify = await runShellCommand(job.verifyCommand, directory, job.timeoutMs || 300_000)
@@ -1195,12 +1452,16 @@ async function finalizeActiveRun(directory, client, sessionID) {
     }
   }
 
-  if (isGoalJob(job)) job = await runGoalChecks(directory, sessionID, job, client)
+  if (isGoalJob(job)) {
+    job = await runGoalChecks(directory, sessionID, job, client)
+    job = await applyGoalNoProgressGuard(directory, client, sessionID, job, active.job)
+  }
   state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate).filter((candidate) => candidate.enabled !== false || isGoalJob(candidate))
   await writeState(directory, sessionID, state)
   if (isGoalJob(job)) await writeGoalReport(directory, sessionID, job)
   await createCheckpoint(directory, sessionID, job, client)
   await scheduleDueWork(directory, client, sessionID)
+  return true
 }
 
 async function fireAction(directory, client, sessionID, job) {
@@ -1219,10 +1480,17 @@ async function fireAction(directory, client, sessionID, job) {
     }
     const tuiCommand = compactTuiCommandName(command)
     if (tuiCommand) {
+      guardLoopOwnedUserMessage(sessionID)
       await compactSession(client, sessionID)
       return { startsAssistantTurn: true }
     }
-    await sdkCall(client.session.command.bind(client.session), { path: { id: sessionID }, body: { command, arguments: argumentsText } }, { sessionID, command, arguments: argumentsText })
+    guardLoopOwnedUserMessage(sessionID)
+    await sdkCall(
+      client.session.command.bind(client.session),
+      { path: { id: sessionID }, body: { command, arguments: argumentsText } },
+      { path: { sessionID }, body: { command, arguments: argumentsText } },
+      { sessionID, command, arguments: argumentsText },
+    )
     return { startsAssistantTurn: true }
   }
   if (kind === "shell") {
@@ -1232,18 +1500,33 @@ async function fireAction(directory, client, sessionID, job) {
       await appendLoopLog(directory, "blocked", { sessionID, job: job.name || job.id, command })
       return { startsAssistantTurn: false }
     }
-    fireSdk(client, "session.shell", client.session.shell.bind(client.session), { path: { id: sessionID }, body: { command } }, { sessionID, command })
+    guardLoopOwnedUserMessage(sessionID)
+    fireSdk(
+      client,
+      "session.shell",
+      client.session.shell.bind(client.session),
+      { path: { id: sessionID }, body: { command } },
+      { path: { sessionID }, body: { command } },
+      { sessionID, command },
+    )
     return { startsAssistantTurn: true }
   }
   const prompt = await buildPrompt(directory, job)
   const prefix = kind === "goal"
     ? "EXPERIMENTAL GOAL MODE CONTINUATION. Continue pursuing the active goal. Do not explain the /loop-goal command. Use the goal tools only when progress/completion/block state is real."
     : "AUTONOMOUS OPENCODE LOOP ITERATION. Continue the configured task now. Do not explain the /loop command. Do not search for documentation about this plugin. Do not create scheduler files. Do not ask questions. Make reasonable assumptions and work directly."
-  fireSdk(client, "session.prompt", client.session.prompt.bind(client.session), { path: { id: sessionID }, body: { parts: [{ type: "text", text: `${prefix}
-
-${prompt}` }] } }, { sessionID, parts: [{ type: "text", text: `${prefix}
-
-${prompt}` }] })
+  const promptText = `${prefix}
+
+${prompt}`
+  guardLoopOwnedUserMessage(sessionID)
+  fireSdk(
+    client,
+    "session.prompt",
+    client.session.prompt.bind(client.session),
+    { path: { id: sessionID }, body: { parts: [{ type: "text", text: promptText }] } },
+    { path: { sessionID }, body: { parts: [{ type: "text", text: promptText }] } },
+    { sessionID, parts: [{ type: "text", text: promptText }] },
+  )
   return { startsAssistantTurn: true }
 }
 
@@ -1258,7 +1541,7 @@ async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
   runLocks.set(sessionID, now())
   let job
   try {
-    await finalizeActiveRun(directory, client, sessionID, { forceStale: true })
+    await finalizeActiveRun(directory, client, sessionID, { requireIdle: true, forceStale: true })
     if (!await sessionIsIdle(client, sessionID, directory)) {
       if (options.force) await toast(client, "Loop queued: session is busy; it will run on the next idle check.", "info")
       await reschedule(BUSY_RETRY_MS)
@@ -1359,8 +1642,10 @@ async function maybeRunDueJobs(directory, client, sessionID, options = {}) {
         return
       }
       let timer
-      if (job.timeoutMs > 0) timer = setTimeout(() => { fireSdk(client, "session.abort", client.session.abort.bind(client.session), { path: { id: sessionID }, body: {} }, { sessionID }); toast(client, `Loop timeout fired: ${job.name || job.id}`, "warning").catch(() => {}) }, job.timeoutMs)
+      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 })
+      sessionStatuses.set(sessionID, "busy")
+      sessionStatusSeenAt.set(sessionID, now())
       await reschedule(BUSY_RETRY_MS)
     } catch (error) {
       clearActiveRun(sessionID)
@@ -1390,7 +1675,11 @@ async function addLoop(directory, client, sessionID, args, defaults = {}) {
   const parsed = parseLoopArgs(args, defaults)
   if (!parsed.ok) { await toast(client, parsed.error, "warning"); return }
   if (parsed.job.watchPaths.length) parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths)
-  if (!parsed.job.activeRecoveryMs) parsed.job.activeRecoveryMs = Math.max(20_000, Math.min(90_000, (parsed.job.intervalMs || 0) + 10_000))
+  if (!parsed.job.activeRecoveryMs) {
+    parsed.job.activeRecoveryMs = isGoalJob(parsed.job)
+      ? DEFAULT_GOAL_ACTIVE_RECOVERY_MS
+      : Math.max(DEFAULT_ACTIVE_GUARD_MS, Math.min(90_000, (parsed.job.intervalMs || 0) + 10_000))
+  }
   if (parsed.job.dryRun) { await toast(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info"); await say(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```"); return }
   const state = await readState(directory, sessionID)
   const jobs = Array.isArray(state.jobs) ? state.jobs : []
@@ -1456,7 +1745,9 @@ async function statusGoal(directory, client, sessionID) {
     const checks = job.goalChecks?.length ? ` | checks=${job.goalChecks.length}` : ""
     const acceptance = job.goalAcceptance?.length ? ` | acceptance=${job.goalAcceptance.length}` : ""
     const progress = job.goalProgress?.length ? ` | progress=${job.goalProgress.length}` : ""
-    return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${status} | turns=${job.runCount || 0} | objective=${String(job.action || job.goalFile || "").slice(0, 220)}${checks}${acceptance}${progress}`
+    const noProgress = (job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS) > 0 ? ` | no-progress=${job.noProgressCount || 0}/${job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS}` : ""
+    const rejected = job.goalCompletionRejectedReason ? " | completion-rejected" : ""
+    return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${status} | turns=${job.runCount || 0} | objective=${String(job.action || job.goalFile || "").slice(0, 220)}${checks}${acceptance}${progress}${noProgress}${rejected}`
   }) : ["No experimental goal jobs."]
   await toast(client, goals.length ? `${goals.length} experimental goal(s).` : "No experimental goal jobs.", goals.length ? "info" : "warning")
   await say(client, sessionID, "OpenCode Loop experimental goal status:\n" + lines.join("\n"))
@@ -1479,7 +1770,7 @@ async function resumeGoal(directory, client, sessionID, args) {
   state.jobs = (state.jobs || []).map((job, index) => {
     if (!isGoalJob(job) || !matchJob(job, target, index)) return job
     count++
-    return { ...job, paused: false, enabled: true, goalStatus: job.goalStatus === "blocked" ? "active" : (job.goalStatus || "active"), lastRunAt: 0 }
+    return { ...job, paused: false, enabled: true, goalStatus: job.goalStatus === "blocked" ? "active" : (job.goalStatus || "active"), lastRunAt: 0, noProgressCount: 0, goalNoProgressReason: "", goalInterruptedReason: "" }
   })
   await writeState(directory, sessionID, state)
   await toast(client, `Resumed ${count} experimental goal(s).`, count ? "success" : "warning")
@@ -1500,7 +1791,7 @@ async function clearGoal(directory, client, sessionID, args) {
 }
 
 async function completeGoalCommand(directory, client, sessionID, args) {
-  const result = await setGoalComplete(directory, sessionID, { summary: String(args || "").trim() || "Goal manually marked complete.", evidence: "Marked complete by /loop-goal-done." })
+  const result = await setGoalComplete(directory, sessionID, { summary: String(args || "").trim() || "Goal manually marked complete.", evidence: "Marked complete by /loop-goal-done.", manual: true })
   await toast(client, result.message, result.ok ? "success" : "warning")
 }
 
@@ -1606,6 +1897,7 @@ async function handleCommand(directory, client, input, fallbackName, fallbackArg
   rememberSession(directory, client, sessionID)
   if (wasHandled(sessionID, name, args)) return true
   markHandled(sessionID, name, args)
+  if (isLoopCommandName(name)) guardLoopOwnedUserMessage(sessionID)
 
   const handled = () => {
     if (output && Array.isArray(output.parts)) {
@@ -1649,7 +1941,7 @@ function goalTools(defaultDirectory) {
       },
       execute: async (args, context) => {
         const result = await setGoalComplete(context.directory || defaultDirectory, context.sessionID, args)
-        return { title: result.ok ? "Goal completed" : "Goal not found", output: result.message }
+        return { title: result.ok ? "Goal completed" : result.rejected ? "Goal completion rejected" : "Goal not found", output: result.message }
       },
     }),
     opencode_loop_goal_blocked: tool({
@@ -1680,6 +1972,7 @@ function goalTools(defaultDirectory) {
 export const OpenCodeLoopPlugin = async ({ client, directory }) => {
   await log(client, "info", "Plugin initialized", { directory })
   return {
+    dispose: async () => { disposeRuntime(directory, client) },
     tool: goalTools(directory),
     "command.execute.before": async (input, output) => { await handleCommand(directory, client, input, undefined, undefined, output) },
     event: async ({ event }) => {
@@ -1687,6 +1980,11 @@ export const OpenCodeLoopPlugin = async ({ client, directory }) => {
         const props = event.properties || {}
         await handleCommand(directory, client, props, props.name, props.arguments)
       }
+      const interruptedSessionID = userInterruptSessionFromEvent(event)
+      if (interruptedSessionID) {
+        rememberSession(directory, client, interruptedSessionID)
+        await pauseGoalsForUserInterrupt(directory, client, interruptedSessionID)
+      }
       const statusUpdate = updateSessionStatusFromEvent(event)
       if (statusUpdate?.sessionID) rememberSession(directory, client, statusUpdate.sessionID)
       if (statusUpdate?.idle) scheduleIdleWork(directory, client, statusUpdate.sessionID)