@bybrawe/opencode-loop 0.5.14 → 0.5.16

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.5.16
+
+- Treat active OpenCode tools, shell calls, and foreground or background subtasks as busy even if the parent session receives an idle/status event while they are still running.
+- Prevent stale active-run recovery from finalizing a loop turn while any tracked tool call remains active.
+- Added regression coverage proving that a due loop waits for long-running tools and background child sessions, then resumes only after that work finishes and the parent session becomes idle.
+
+## 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.

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.16 fixes idle detection during long-running tools and background subtasks.** The scheduler now treats OpenCode tool lifecycle activity and running child sessions as stronger busy signals than a premature parent idle/status event, so due prompts wait instead of filling the queue. It keeps the Goal Mode and SDK compatibility hardening from v0.5.15.
 
 The known update-related symptoms from older builds are fixed:
 
@@ -26,20 +26,20 @@ 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.16 quick behavior guide
 
 OpenCode Loop has two triggers now:
 
 1. **Idle/status events** from OpenCode. These are used when OpenCode finishes a turn.
 2. **A real due timer** inside the plugin. This wakes delayed jobs even when no new OpenCode event happens.
 
-All TUI jobs are still idle-safe. If the timer expires while OpenCode is busy, the job does not interrupt the active turn. It waits and retries until the session becomes idle.
+All TUI jobs are still idle-safe. If the timer expires while OpenCode is busy, or while a tool/background child session is still executing, the job does not interrupt the active turn. It waits and retries until that work finishes and the parent session becomes idle.
 
 Simple examples:
 
@@ -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 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:
@@ -352,7 +352,7 @@ Experimental goal mode: keep working until the objective is actually done, block
 
 ### What “when idle” means
 
-OpenCode Loop is idle-safe. It does **not** intentionally start a new agent turn while OpenCode is already busy.
+OpenCode Loop is idle-safe. It does **not** intentionally start a new agent turn while OpenCode is already busy. Active tool calls and running child sessions also count as busy, even if OpenCode emits a premature idle/status signal for the parent during long-running background work.
 
 Example:
 
@@ -390,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:
 
@@ -408,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
@@ -451,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
@@ -1096,6 +1112,19 @@ Improve the application in small safe steps.
 
 ## Changelog highlights
 
+### v0.5.16
+
+- Treat active tools, shell calls, and running foreground/background child sessions as busy even when the parent session appears idle.
+- Prevent stale-run recovery from enqueueing another continuation while tracked background work is still active.
+- Added regression tests for long-running tool calls and background child sessions.
+
+### 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.

package/package.json

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

@@ -0,0 +1,158 @@
+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 = []
+const liveStatuses = new Map([[sessionID, "idle"]])
+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: {
+    list: async (args) => {
+      assert.equal(args?.query?.directory, directory)
+      return { data: [{ id: sessionID, directory, projectID: "project", title: "smoke", version: "test", time: { created: Date.now(), updated: Date.now() } }] }
+    },
+    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: Object.fromEntries([...liveStatuses].filter(([, type]) => type !== "idle").map(([id, type]) => [id, { type }])) }
+    },
+    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: [] })
+
+  const promptCountBeforeBackgroundTool = prompts.length
+  await hooks["tool.execute.before"]({ tool: "bash", sessionID, callID: "call_background" }, { args: {} })
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background task",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 1_400))
+  assert.equal(prompts.length, promptCountBeforeBackgroundTool, "an active tool call must keep the loop busy even when session.status says idle")
+
+  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")
+
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const childSessionID = "ses_background_child"
+  liveStatuses.set(childSessionID, "busy")
+  await hooks.event({ event: { type: "session.created", properties: { info: { id: childSessionID, parentID: sessionID } } } })
+  await hooks.event({ event: { type: "session.status", properties: { sessionID: childSessionID, status: { type: "busy" } } } })
+  const promptCountBeforeBackgroundChild = prompts.length
+  await hooks["command.execute.before"]({
+    command: "loop",
+    sessionID,
+    arguments: "0s --max-runs 1 continue after the background subtask",
+  }, { parts: [] })
+  await new Promise((resolve) => setTimeout(resolve, 2_700))
+  assert.equal(prompts.length, promptCountBeforeBackgroundChild, "a running background child session must keep its parent loop busy")
+
+  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")
+
+  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,15 +17,21 @@ 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()
+const activeToolCalls = new Map()
+const sessionParents = new Map()
 let heartbeatTimer
 const sessionStatuses = new Map()
 const sessionStatusSeenAt = new Map()
@@ -142,6 +148,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 }
@@ -203,11 +214,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,
@@ -255,10 +271,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)
@@ -309,6 +331,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()
 
@@ -399,32 +424,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) }))
 }
 
@@ -457,7 +475,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) })
@@ -480,11 +503,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 {}
@@ -502,6 +543,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 ""
@@ -528,6 +572,100 @@ function rememberSession(directory, client, sessionID) {
   startHeartbeat()
 }
 
+function hasActiveToolCalls(sessionID) {
+  return (activeToolCalls.get(sessionID)?.size || 0) > 0
+}
+
+function markToolCallActive(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID) || new Set()
+  calls.add(callID)
+  activeToolCalls.set(sessionID, calls)
+  sessionStatuses.set(sessionID, "busy")
+  sessionStatusSeenAt.set(sessionID, now())
+}
+
+function markToolCallFinished(input) {
+  const sessionID = input?.sessionID
+  const callID = input?.callID
+  if (typeof sessionID !== "string" || typeof callID !== "string") return
+  const calls = activeToolCalls.get(sessionID)
+  if (!calls) return
+  calls.delete(callID)
+  if (!calls.size) activeToolCalls.delete(sessionID)
+}
+
+function updateSessionRelationship(info, removed = false) {
+  const sessionID = info?.id
+  if (typeof sessionID !== "string") return
+  if (removed || typeof info?.parentID !== "string") sessionParents.delete(sessionID)
+  else sessionParents.set(sessionID, info.parentID)
+}
+
+function updateSessionRelationshipFromEvent(event) {
+  if (!["session.created", "session.updated", "session.deleted"].includes(event?.type)) return
+  updateSessionRelationship(event?.properties?.info, event.type === "session.deleted")
+}
+
+function isDescendantSession(sessionID, ancestorID) {
+  const visited = new Set()
+  let current = sessionID
+  while (sessionParents.has(current) && !visited.has(current)) {
+    visited.add(current)
+    current = sessionParents.get(current)
+    if (current === ancestorID) return true
+  }
+  return false
+}
+
+function hasBusyDescendant(sessionID) {
+  for (const childID of sessionParents.keys()) {
+    if (!isDescendantSession(childID, sessionID)) continue
+    const status = sessionStatuses.get(childID)
+    if (status === "busy" || status === "retry" || hasActiveToolCalls(childID)) return true
+  }
+  return false
+}
+
+async function refreshSessionRelationships(client, directory) {
+  if (!client?.session?.list) return
+  try {
+    const sessions = await sdkCall(
+      client.session.list.bind(client.session),
+      { query: { directory } },
+      { directory },
+      {},
+    )
+    if (Array.isArray(sessions)) for (const info of sessions) updateSessionRelationship(info)
+  } catch {}
+}
+
+function updateToolActivityFromEvent(event) {
+  const props = event?.properties || {}
+  if (event?.type === "message.part.updated") {
+    const part = props.part
+    if (part?.type !== "tool") return
+    const sessionID = part.sessionID || props.sessionID
+    if (["pending", "running"].includes(part.state?.status)) {
+      markToolCallActive({ sessionID, callID: part.callID })
+    }
+    if (["completed", "error"].includes(part.state?.status)) {
+      // Task/subagent hooks have used the part id as their hook call id in some
+      // OpenCode versions, while normal tools use part.callID. Clear either.
+      const identifiers = [...new Set([part.callID, part.id].filter((value) => typeof value === "string"))]
+      for (const callID of identifiers) markToolCallFinished({ sessionID, callID })
+    }
+    return
+  }
+
+  const started = ["session.next.shell.started", "session.next.tool.called"].includes(event?.type)
+  const finished = ["session.next.shell.ended", "session.next.tool.success", "session.next.tool.failed"].includes(event?.type)
+  if (started) markToolCallActive(props)
+  if (finished) markToolCallFinished(props)
+}
+
 function startHeartbeat() {
   if (heartbeatTimer) return
   heartbeatTimer = setInterval(() => {
@@ -549,6 +687,34 @@ 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)
+    activeToolCalls.delete(sessionID)
+    sessionParents.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)
@@ -575,10 +741,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) {
@@ -682,6 +849,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) {
@@ -698,6 +866,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)
@@ -712,9 +882,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.
@@ -852,6 +1025,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
@@ -862,6 +1068,7 @@ function staleActiveRun(sessionID) {
 }
 
 async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
+  if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) return false
   if (!options.requireIdle && !options.forceStale) return true
   if (options.forceStale && staleActiveRun(sessionID)) return true
   if (!options.requireIdle) return false
@@ -876,7 +1083,7 @@ async function canFinalizeActiveRun(directory, client, sessionID, active, option
 
 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 {
@@ -884,15 +1091,41 @@ async function readLiveSessionStatus(client, sessionID, directory) {
       const error = sdkError(result)
       if (error) continue
       const data = sdkData(result)
+      if (!data || typeof data !== "object" || Array.isArray(data)) continue
+      const observedAt = now()
+      for (const [observedSessionID, observedStatus] of Object.entries(data)) {
+        const observedType = observedStatus && typeof observedStatus === "object" ? observedStatus.type : undefined
+        if (typeof observedType !== "string") continue
+        sessionStatuses.set(observedSessionID, observedType)
+        sessionStatusSeenAt.set(observedSessionID, observedAt)
+      }
+      // OpenCode's status list contains active sessions; idle sessions are
+      // normally omitted. Clear a completed descendant that was previously busy.
+      for (const childID of sessionParents.keys()) {
+        if (!isDescendantSession(childID, sessionID) || data[childID]) continue
+        sessionStatuses.set(childID, "idle")
+        sessionStatusSeenAt.set(childID, observedAt)
+      }
+      if (hasBusyDescendant(sessionID)) return { type: "busy", source: "descendant" }
       const status = data?.[sessionID]
       const type = status && typeof status === "object" ? status.type : undefined
       if (typeof type === "string") return { type, source: "sdk" }
+      return { type: "idle", source: "sdk" }
     } catch {}
   }
   return undefined
 }
 
 async function sessionStatusType(client, sessionID, directory, options = {}) {
+  // OpenCode can briefly report an idle session while a long-running tool or
+  // subtask is still executing. Tool lifecycle hooks are the more specific
+  // signal here, so never enqueue another turn until every active call ends.
+  if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) {
+    sessionStatuses.set(sessionID, "busy")
+    sessionStatusSeenAt.set(sessionID, now())
+    return "busy"
+  }
+
   const cached = sessionStatuses.get(sessionID)
   const seenAt = sessionStatusSeenAt.get(sessionID) || 0
 
@@ -1075,11 +1308,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", "")
@@ -1115,17 +1354,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)
@@ -1159,6 +1482,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)
@@ -1252,7 +1577,10 @@ async function finalizeActiveRun(directory, client, sessionID, options = {}) {
     }
   }
 
-  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)
@@ -1277,10 +1605,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") {
@@ -1290,18 +1625,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 }
 }
 
@@ -1417,7 +1767,7 @@ 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())
@@ -1450,7 +1800,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 : []
@@ -1516,7 +1870,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"))
@@ -1539,7 +1895,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")
@@ -1560,7 +1916,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")
 }
 
@@ -1666,6 +2022,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)) {
@@ -1709,7 +2066,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({
@@ -1739,14 +2096,25 @@ function goalTools(defaultDirectory) {
 
 export const OpenCodeLoopPlugin = async ({ client, directory }) => {
   await log(client, "info", "Plugin initialized", { directory })
+  await refreshSessionRelationships(client, directory)
   return {
+    dispose: async () => { disposeRuntime(directory, client) },
     tool: goalTools(directory),
     "command.execute.before": async (input, output) => { await handleCommand(directory, client, input, undefined, undefined, output) },
+    "tool.execute.before": async (input) => { markToolCallActive(input) },
+    "tool.execute.after": async (input) => { markToolCallFinished(input) },
     event: async ({ event }) => {
+      updateSessionRelationshipFromEvent(event)
+      updateToolActivityFromEvent(event)
       if (event.type === "command.executed") {
         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)