@bybrawe/opencode-loop 0.6.8 → 0.6.9

package/scripts/native-cli-io-test.mjs

@@ -1,7 +1,7 @@
 import test from "node:test"
 import assert from "node:assert/strict"
 import { spawn } from "node:child_process"
-import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises"
+import { mkdtemp, mkdir, writeFile, readFile, realpath, rm } from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
@@ -47,9 +47,12 @@ process.stdin.resume();
     assert.equal(result.code, 0, `${mode}: ${result.stdout}\n${result.stderr}`)
     const calls = (await readFile(log, "utf8")).trim().split(/\r?\n/).map(JSON.parse)
     if (mode === "pwd") {
+      // macOS /var/folders is an alias of /private/var/folders; the V2 host
+      // compares project PWD with the physical cwd, not the original alias.
+      const canonical = process.platform === "win32" ? project : await realpath(project)
       for (const call of calls.filter(call => ["session", "run"].includes(call.args[0]))) {
-        assert.equal(call.pwd, project, "native lookup and run must use the selected project, not the caller's PWD")
-        assert.equal(call.cwd, project)
+        assert.equal(call.pwd, canonical, "native lookup and run must use the canonical selected project, not the caller's PWD")
+        assert.equal(call.cwd, canonical)
       }
     }
     if (mode === "stdin") assert.match(result.stdout, /INPUT=\r?\n/)

package/scripts/native-entry-test.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict"
 import { spawnSync } from "node:child_process"
-import { readFileSync } from "node:fs"
+import { readFileSync, realpathSync } from "node:fs"
 import path from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 
@@ -11,7 +11,9 @@ assert.ok(process.argv.length <= 3, "expected at most one consumer directory")
 const loop = pkg.name === "@bybrawe/opencode-loop"
 const cwd = process.argv[2] ? path.resolve(process.argv[2]) : root
 const packageRoot = process.argv[2] ? path.join(cwd, "node_modules", ...pkg.name.split("/")) : root
-const url = (relative) => pathToFileURL(path.join(packageRoot, relative)).href
+// Node resolves ESM file URLs to real paths on macOS, where /var aliases /private/var.
+// Guard and delegated V1 entry identities must use the same canonical URLs as the loader.
+const url = (relative) => pathToFileURL(realpathSync.native(path.join(packageRoot, relative))).href
 const legacyEntries = loop ? [url("src/v1.js"), url("src/source/v1.js")] : [url("dist/legacy-v1.js")]
 const blocked = loop
   ? [...legacyEntries, url("src/index.js"), url("src/source/legacy-v1.js")]
@@ -23,15 +25,23 @@ const serverEntries = loop ? [`${pkg.name}/server`, url("src/source/server.js")]
 function probe(mode) {
   const stub = "globalThis.__legacyModuleLoads = (globalThis.__legacyModuleLoads || 0) + 1; export default async (...args) => { if (args[0]?.failure) throw args[0].failure; return { args }; }"
   const loader = `
-    const blocked = ${JSON.stringify(blocked)};
-    const legacyEntries = ${JSON.stringify(legacyEntries)};
+    import { realpathSync } from "node:fs";
+    import { fileURLToPath } from "node:url";
+    const physical = (url) => {
+      if (!url.startsWith("file:")) return url;
+      const name = realpathSync.native(fileURLToPath(url));
+      return process.platform === "win32" ? name.toLowerCase() : name;
+    };
+    const blocked = new Set(${JSON.stringify(blocked)}.map(physical));
+    const legacyEntries = new Set(${JSON.stringify(legacyEntries)}.map(physical));
     export async function resolve(specifier, context, nextResolve) {
       if (specifier.startsWith("@opencode-ai/")) throw new Error("V2_LEGACY_IMPORT: " + specifier);
       const result = await nextResolve(specifier, context);
-      if (${JSON.stringify(mode)} === "delegate" && legacyEntries.includes(result.url)) {
+      const actual = physical(result.url);
+      if (${JSON.stringify(mode)} === "delegate" && legacyEntries.has(actual)) {
         return { url: ${JSON.stringify(`data:text/javascript,${encodeURIComponent(stub)}`)}, shortCircuit: true };
       }
-      if (blocked.includes(result.url)) throw new Error("V2_LEGACY_IMPORT: " + result.url);
+      if (blocked.has(actual)) throw new Error("V2_LEGACY_IMPORT: " + result.url);
       return result;
     }
   `

package/scripts/native-release.mjs

@@ -7,11 +7,11 @@ export function validateRelease(request, pkg, env) {
   assert.equal(env.GITHUB_REPOSITORY, "ByBrawe/opencode-loop", "wrong release repository")
   assert.equal(env.GITHUB_REF, "refs/heads/main", "npm release must come from main")
   assert.match(env.GITHUB_SHA ?? "", /^[a-f0-9]{40}$/, "immutable release SHA required")
-  assert.equal(request?.version, "0.6.8", "release version is not authorized")
+  assert.equal(request?.version, "0.6.9", "release version is not authorized")
   assert.equal(request?.name, "@bybrawe/opencode-loop")
   assert.equal(pkg.name, request.name)
   assert.equal(pkg.version, request.version)
-  assert.equal(request.predecessor, "0.6.7")
+  assert.equal(request.predecessor, "0.6.8")
   assert.equal(request.goal?.version, "1.3.49")
   assert.match(request.goal?.sha ?? "", /^[a-f0-9]{40}$/)
   return request

package/scripts/native-v2-test.mjs

@@ -47,6 +47,67 @@ async function test(name, run, extra) {
   finally { await f.close() }
 }
 
+await test("explicit checklist stop prevents the next V2 model turn", async (f) => {
+  await writeFile(path.join(f.directory, "TASK.md"), "- [ ] implement\n- [x] setup\n")
+  const added = await f.add("0s --progress-file TASK.md --until-checklist-complete implement --max-runs 3")
+  assert.equal(added.accepted, true)
+  await f.wake()
+  assert.equal(f.prompts.length, 1)
+  await writeFile(path.join(f.directory, "TASK.md"), "- [x] implement\n- [x] setup\n")
+  await f.complete()
+  const job = (await f.state()).jobs[0]
+  assert.equal(f.prompts.length, 1, "no redundant model prompt after host checks TASK.md")
+  assert.equal(job.enabled, false)
+  assert.equal(job.paused, true)
+  assert.equal(job.pauseReason, "checklist-complete")
+  assert.deepEqual(job.checklistStatus, { status: "complete", total: 2, pending: 0 })
+})
+
+await test("explicit checklist refuses missing project file instead of spending tokens", async (f) => {
+  assert.equal((await f.add("0s --progress-file MISSING.md --until-checklist-complete implement")).accepted, true)
+  await f.wake()
+  const job = (await f.state()).jobs[0]
+  assert.equal(f.prompts.length, 0)
+  assert.equal(job.paused, true)
+  assert.equal(job.pauseReason, "checklist-unavailable")
+  assert.equal(job.lastChecklistError, "file-missing")
+})
+
+await test("an already-complete checklist still requires host verification when requested", async (f) => {
+  await writeFile(path.join(f.directory, "TASK.md"), "- [x] done\n")
+  await f.add('0s --progress-file TASK.md --until-checklist-complete --verify "npm test" check work --max-runs 2')
+  await f.wake()
+  assert.equal(f.prompts.length, 1, "unobserved verify must not pass by default")
+  await f.complete()
+  const job = (await f.state()).jobs[0]
+  assert.equal(f.hooks.length, 1)
+  assert.equal(f.hooks[0], "npm test")
+  assert.equal(f.prompts.length, 1, "observed verify pass stops before another turn")
+  assert.equal(job.enabled, false)
+  assert.equal(job.pauseReason, "checklist-complete")
+  assert.equal(job.lastVerifyCode, 0)
+})
+
+await test("progress-file without opt-in still follows existing finite or infinite semantics", async (f) => {
+  await writeFile(path.join(f.directory, "TASK.md"), "- [x] all done\n")
+  await f.add("0s --progress-file TASK.md task --max-runs 1")
+  await f.wake()
+  assert.equal(f.prompts.length, 1)
+  assert.equal((await f.state()).jobs[0].untilChecklistComplete, false)
+})
+
+await test("native checklist flag requires explicit progress file and status reveals stop controls", async (f) => {
+  const rejected = await f.add("0s --until-checklist-complete implement")
+  assert.equal(rejected.accepted, false)
+  assert.match(rejected.error, /--progress-file/)
+  await writeFile(path.join(f.directory, "TASK.md"), "- [ ] todo\n")
+  await f.add("0s --progress-file TASK.md --until-checklist-complete implement --max-runs 3")
+  const status = await f.control("loop-status")
+  assert.match(status.status.text, /checklist-stop:TASK\.md/)
+  assert.match(status.status.text, /\/loop-stop/)
+  assert.match(status.status.text, /\/loop-clear/)
+})
+
 await test("one durable prompt under concurrent idle notifications", async (f) => {
   assert.equal((await f.add("0s keep working --max-runs 2")).accepted, true)
   await Promise.all(Array.from({ length: 12 }, () => f.wake()))

package/scripts/opencode2-loop-canary.mjs

@@ -224,7 +224,8 @@ function commandNames(payload) {
 }
 
 async function main() {
-  assert.equal(process.platform, "linux", "the real OpenCode 2 Loop canary is intentionally Ubuntu-only")
+  const supported = process.platform === "linux" || (process.platform === "darwin" && process.env.OPENCODE2_MACOS_NATIVE_CANARY === "1")
+  assert.ok(supported, "real OpenCode 2 canary supports Linux or explicitly opted-in macOS CI only")
 
   const workspace = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-e2e-"))
   const home = path.join(workspace, ".home")

package/scripts/package-native-smoke.mjs

@@ -8,9 +8,9 @@ import { fileURLToPath } from "node:url"
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const npmCLI = process.env.npm_execpath
 assert.ok(npmCLI, "run this through npm run package:smoke")
-function run(command, args, cwd) {
+function run(command, args, cwd, timeout = 180_000) {
   const result = spawnSync(command, args, {
-    cwd, encoding: "utf8", timeout: 180_000, maxBuffer: 8 * 1024 * 1024,
+    cwd, encoding: "utf8", timeout, maxBuffer: 8 * 1024 * 1024,
     windowsHide: true,
     env: { ...process.env, npm_config_fetch_retries: "1", npm_config_fetch_timeout: "90000" },
   })
@@ -30,22 +30,54 @@ try {
   await writeFile(path.join(consumer, "package.json"), JSON.stringify({ private: true, type: "module" }))
   const packedTarball = path.join(temp, packed[0].filename)
   const installArgs = ["install", "--ignore-scripts", "--omit=dev", "--omit=peer", "--no-audit", "--no-fund"]
+  const strictInstall = process.env.OPENCODE_PACKAGE_SMOKE_REQUIRE_INSTALL === "1"
+  // A cache-only npm install should finish quickly. On Windows, a cache miss
+  // sometimes blocks inside npm for the entire 180-second subprocess deadline.
+  // Bound the best-effort offline attempt; strict opt-in keeps the full gate.
+  const offlineTimeout = process.platform === "win32" && !strictInstall ? 30_000 : 180_000
+  async function strictCleanOnlineInstall() {
+    // Busy Windows runners can stall fetching npm metadata even after npm ci.
+    // Retry once on subprocess ETIMEDOUT using a *new* empty consumer.
+    // This path never accepts the tar archive or CI-installed dependency tree
+    // as a substitute for a real npm install.
+    const maxAttempts = process.platform === "win32" ? 2 : 1
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const timeoutMs = process.platform === "win32" && attempt === 2 ? 270_000 : 180_000
+        run(process.execPath, [npmCLI, ...installArgs, "--prefer-offline", packedTarball], consumer, timeoutMs)
+        console.log("Strict clean npm tarball consumer install PASS")
+        return
+      } catch (error) {
+        if (attempt >= maxAttempts || error?.cause?.code !== "ETIMEDOUT") throw error
+        console.warn("Strict Windows npm install timed out; retrying once from a fresh empty consumer, not a fallback")
+        await rm(consumer, { recursive: true, force: true, maxRetries: 8, retryDelay: 150 })
+        await mkdir(consumer, { recursive: true })
+        await writeFile(path.join(consumer, "package.json"), JSON.stringify({ private: true, type: "module" }))
+      }
+    }
+  }
   try {
     // npm ci populated this job's npm cache from the lockfile. A cache-only
     // install remains an exact, clean npm consumer when all metadata is present.
-    run(process.execPath, [npmCLI, ...installArgs, "--offline", packedTarball], consumer)
+    run(process.execPath, [npmCLI, ...installArgs, "--offline", packedTarball], consumer, offlineTimeout)
     console.log("Clean tarball npm install from local cache PASS")
   } catch (error) {
-    if (!/ENOTCACHED|cache mode is .only-if-cached./i.test(String(error))) throw error
-    if (process.platform !== "win32" || process.env.OPENCODE_PACKAGE_SMOKE_REQUIRE_INSTALL === "1") {
+    const cacheMissing = /ENOTCACHED|cache mode is .only-if-cached./i.test(String(error))
+    const windowsOfflineTimeout = process.platform === "win32" && !strictInstall && error?.cause?.code === "ETIMEDOUT"
+    if (!cacheMissing && !windowsOfflineTimeout) throw error
+    if (process.platform !== "win32" || strictInstall) {
       console.warn("Offline cache incomplete: performing strict bounded online npm consumer install")
-      run(process.execPath, [npmCLI, ...installArgs, "--prefer-offline", packedTarball], consumer)
+      if (strictInstall) await strictCleanOnlineInstall()
+      else run(process.execPath, [npmCLI, ...installArgs, "--prefer-offline", packedTarball], consumer)
     } else {
       // GitHub Windows runners sporadically hang for minutes while npm fetches
       // transient dependency packuments. We still check the EXACT production
       // archive and isolated V2 imports on Windows, using the already-verified
       // npm-ci dependency tree. Linux continues to gate a real clean npm install.
       // This is intentionally NOT labelled a successful Windows npm install.
+      // An interrupted npm process may have left a partial consumer tree.
+      // Never combine that unverified tree with the deterministic archive test.
+      await rm(path.join(consumer, "node_modules"), { recursive: true, force: true, maxRetries: 8, retryDelay: 150 })
       const packageRoot = path.join(consumer, "node_modules", "@bybrawe", "opencode-loop")
       await mkdir(packageRoot, { recursive: true })
       run("tar", ["-xzf", packedTarball, "-C", packageRoot, "--strip-components=1"], temp)
@@ -56,7 +88,9 @@ try {
         path.join(scope, "plugin"),
         "junction",
       )
-      console.warn("Windows npm cache lacks package metadata; testing packed archive with preinstalled dependency tree (not a clean npm install)")
+      console.warn(windowsOfflineTimeout
+        ? "Windows offline npm install exceeded 30s; checking the production archive with pinned CI dependencies (NOT a clean npm install)"
+        : "Windows npm cache lacks package metadata; checking the production archive with pinned CI dependencies (NOT a clean npm install)")
     }
   }
   console.log(run(process.execPath, [path.join(root, "scripts/native-entry-test.mjs"), consumer], root).trim())

package/scripts/publish-workflow-test.mjs

@@ -20,6 +20,7 @@ assert.match(workflow, /needs:\s*\[native-regressions, real-native-pair\]/)
 assert.match(workflow, /node scripts\/native-release\.mjs ci/)
 assert.match(workflow, /git diff --exit-code -- src\/index.js src\/server.js src\/native.js/)
 assert.match(workflow, /npm run package:smoke/)
+assert.match(workflow, /OPENCODE_PACKAGE_SMOKE_REQUIRE_INSTALL:\s*\x271\x27/, "Windows/Linux npm release gate must require a strict clean consumer install, never a tarball fallback")
 assert.match(workflow, /windows-latest/)
 assert.match(workflow, /Decide whether npm publish is needed/)
 assert.match(workflow, /steps\.npm-state\.outputs\.publish == 'true'/)
@@ -48,14 +49,14 @@ assert.ok(workflow.includes('--prefer-online --cache "$VERIFY_DIR/npm-cache-$att
 assert.ok(workflow.includes("Published Loop+Goal clean-install validation did not converge"), "clean consumer must remain a hard release gate")
 
 const sha = "a".repeat(40)
-const request = { name: "@bybrawe/opencode-loop", version: "0.6.8", predecessor: "0.6.7", goal: { version: "1.3.49", sha: "b".repeat(40) } }
+const request = { name: "@bybrawe/opencode-loop", version: "0.6.9", predecessor: "0.6.8", goal: { version: "1.3.49", sha: "b".repeat(40) } }
 const pkg = { name: request.name, version: request.version }
 const env = { GITHUB_REPOSITORY: "ByBrawe/opencode-loop", GITHUB_REF: "refs/heads/main", GITHUB_SHA: sha }
 assert.strictEqual(validateRelease(request, pkg, env), request)
 for (const change of [{ GITHUB_REPOSITORY: "someone/fork" }, { GITHUB_REF: "refs/heads/release" }, { GITHUB_SHA: "main" }]) assert.throws(() => validateRelease(request, pkg, { ...env, ...change }))
 assert.throws(() => validateRelease({ ...request, version: "9.0.0" }, pkg, env))
 assert.throws(() => validateRelease(request, { ...pkg, version: "0.6.5" }, env))
-assert.equal(releaseDecision(404, null, request, sha, "0.6.7"), true)
+assert.equal(releaseDecision(404, null, request, sha, "0.6.8"), true)
 for (const status of [401, 403, 429, 500, 503]) assert.throws(() => releaseDecision(status, null, request, sha, "0.6.0"))
 assert.throws(() => releaseDecision(404, null, request, sha, "0.7.0"))
 const manifest = { ...pkg, gitHead: sha }

package/scripts/run-admission-test.mjs

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict"
 import path from "node:path"
+import os from "node:os"
+import { mkdtemp, writeFile, rm } from "node:fs/promises"
 import { createRunAdmissionRuntime } from "../src/source/runtime/run-admission.js"
+import { inspectTaskChecklist } from "../src/source/runtime/checklist-completion.js"
 
 assert.throws(() => createRunAdmissionRuntime({}), /untilReached/)
 assert.throws(() => createRunAdmissionRuntime({ untilReached: async () => false }), /scheduleDueWork/)
@@ -130,4 +133,48 @@ assert.equal(admitted.paused, undefined)
 assert.equal(admitted.runNowRequestedAt, clock)
 assert.equal(logs.findLast((entry) => entry[1] === "preflight")?.[2].code, 0)
 
+const project = await mkdtemp(path.join(os.tmpdir(), "loop-admission-checklist-"))
+try {
+  await writeFile(path.join(project, "TASK.md"), "- [ ] code\n- [x] plan\n")
+  const checklistJob = { id: "checklist-job", enabled: true, progressFile: "TASK.md", untilChecklistComplete: true }
+  const checklistState = { jobs: [checklistJob] }
+  assert.equal((await runtime.admitJob(project, {}, "session-checklist", checklistState, checklistJob)).admitted, true)
+  assert.deepEqual(checklistJob.checklistStatus, { status: "pending", total: 2, pending: 1 })
+
+  await writeFile(path.join(project, "TASK.md"), "- [x] code\n- [x] plan\n")
+  assert.deepEqual(await runtime.admitJob(project, {}, "session-checklist", checklistState, checklistJob),
+    { admitted: false, reason: "checklist_complete" })
+  assert.equal(checklistState.jobs.length, 0)
+  assert.equal(notifications.at(-1)[2], "checklist_complete")
+
+  const verifyJob = { id: "verify-checklist", enabled: true, progressFile: "TASK.md",
+    untilChecklistComplete: true, verifyCommand: "npm test" }
+  const verifyState = { jobs: [verifyJob] }
+  assert.equal((await runtime.admitJob(project, {}, "session-verify", verifyState, verifyJob)).admitted, true,
+    "unchecked host verification cannot imply completion")
+  verifyJob.lastVerifyCode = 1
+  verifyJob.lastVerifyAt = clock
+  assert.equal((await runtime.admitJob(project, {}, "session-verify", verifyState, verifyJob)).admitted, true,
+    "failed host verification cannot imply completion")
+  verifyJob.lastVerifyCode = 0
+  assert.equal((await runtime.admitJob(project, {}, "session-verify", verifyState, verifyJob)).admitted, true,
+    "successful verify without recorded checklist fingerprint is not authoritative")
+  verifyJob.lastVerifyChecklistDigest = (await inspectTaskChecklist(project, "TASK.md")).digest
+  await writeFile(path.join(project, "TASK.md"), "- [x] code\n- [x] plan\n- [x] later task\n")
+  assert.equal((await runtime.admitJob(project, {}, "session-verify", verifyState, verifyJob)).admitted, true,
+    "verification for older checklist bytes cannot certify newly changed work")
+  verifyJob.lastVerifyChecklistDigest = (await inspectTaskChecklist(project, "TASK.md")).digest
+  assert.equal((await runtime.admitJob(project, {}, "session-verify", verifyState, verifyJob)).reason, "checklist_complete")
+
+  const missingJob = { id: "missing-checklist", enabled: true, progressFile: "MISSING.md", untilChecklistComplete: true }
+  const missingState = { jobs: [missingJob] }
+  const missing = await runtime.admitJob(project, {}, "session-missing", missingState, missingJob)
+  assert.deepEqual(missing, { admitted: false, reason: "checklist_unavailable" })
+  assert.equal(missingJob.paused, true)
+  assert.equal(missingJob.lastChecklistError, "file-missing")
+  assert.equal(missingState.jobs.length, 1, "preserve job for explicit recovery")
+} finally {
+  await rm(project, { force: true, recursive: true })
+}
+
 console.log("run admission runtime tests passed")

package/src/index.js

@@ -141,6 +141,7 @@ function parseLoopArgs(raw, defaults = {}) {
     until: defaults.until,
     stopFile: defaults.stopFile,
     progressFile: defaults.progressFile,
+    untilChecklistComplete: defaults.untilChecklistComplete ?? false,
     promptFile: defaults.promptFile,
     includeFiles: Array.isArray(defaults.includeFiles) ? [...defaults.includeFiles] : [],
     watchPaths: Array.isArray(defaults.watchPaths) ? [...defaults.watchPaths] : [],
@@ -221,6 +222,9 @@ function parseLoopArgs(raw, defaults = {}) {
   [found, rest] = takeFlag(rest, "--pause-on-verify-fail");
   if (found)
     job.pauseOnVerifyFail = true;
+  [found, rest] = takeFlag(rest, "--until-checklist-complete");
+  if (found)
+    job.untilChecklistComplete = true;
   [found, rest] = takeFlag(rest, "--dry-run");
   if (found)
     job.dryRun = true;
@@ -369,6 +373,8 @@ function parseLoopArgs(raw, defaults = {}) {
     job.maxNoProgress = job.maxNoProgress ?? DEFAULT_GOAL_MAX_NO_PROGRESS;
   }
   job.lastRunAt = job.immediate ? 0 : now();
+  if (job.untilChecklistComplete && !job.progressFile)
+    return { ok: false, error: "--until-checklist-complete requires --progress-file <project.md>" };
   if (!job.action && !job.promptFile && !job.goalFile)
     return { ok: false, error: "Missing action. Example: /loop 0s continue from progress.md, /loop-goal ship the feature, or /loop 0s --prompt-file loop-prompt.md" };
   return { ok: true, job };
@@ -1445,6 +1451,8 @@ function decoratePrompt(job) {
     additions.push(continuation);
   if (job.progressFile)
     additions.push(`Use ${job.progressFile} as the main progress/TODO state file. Read it before choosing the next task and update it after work.`);
+  if (job.untilChecklistComplete)
+    additions.push("When all actual Markdown tasks in the configured progress file are checked, stop creating new work and report results. Loop will make the stopping decision itself from the project file at a safe host boundary; do not attempt to invoke /loop-clear as assistant text.");
   if (job.lastVerifyFailure)
     additions.push("Previous verify command failed. Fix this before moving on. Failure summary: " + String(job.lastVerifyFailure).slice(0, 1200));
   if (job.askNever)
@@ -3625,6 +3633,125 @@ async function applyTerminalContinuationGuard(directory, client, sessionID, job,
   return { job, terminal: true, pausedNow, waitingUser: false, waitingUserPausedNow: false, text };
 }
 
+// src/source/runtime/checklist-completion.js
+import { promises as fs8, constants } from "fs";
+import path9 from "path";
+import { createHash } from "crypto";
+var MAX_CHECKLIST_BYTES = 256000;
+var EXCLUDED_PROJECT_DIRS = new Set([".opencode", ".git", "node_modules"]);
+function unavailable(reason) {
+  return { status: "unavailable", reason, total: 0, pending: 0 };
+}
+function summarizeTaskChecklist(markdown) {
+  let total = 0;
+  let pending = 0;
+  let fence = null;
+  let comment = false;
+  for (const original of String(markdown || "").replace(/^\uFEFF/, "").split(/\r?\n/)) {
+    let line = "";
+    let offset = 0;
+    while (offset < original.length) {
+      if (comment) {
+        const end = original.indexOf("-->", offset);
+        if (end < 0)
+          break;
+        comment = false;
+        offset = end + 3;
+      } else {
+        const start = original.indexOf("<!--", offset);
+        if (start < 0) {
+          line += original.slice(offset);
+          break;
+        }
+        line += original.slice(offset, start);
+        comment = true;
+        offset = start + 4;
+      }
+    }
+    const trimmed = line.trimStart();
+    const indentation = line.length - trimmed.length;
+    const marker = trimmed.charAt(0);
+    let markerSize = 0;
+    if (marker === "~" || marker.charCodeAt(0) === 96) {
+      while (trimmed.charAt(markerSize) === marker)
+        markerSize++;
+    }
+    if (fence) {
+      if (indentation <= 3 && markerSize >= fence.length && marker === fence.marker && !trimmed.slice(markerSize).trim())
+        fence = null;
+      continue;
+    }
+    if (indentation <= 3 && markerSize >= 3) {
+      fence = { marker, length: markerSize };
+      continue;
+    }
+    if (/^\s*>/.test(line))
+      continue;
+    const match = line.match(/^\s{0,24}[-+*]\s+\[([ xX])\](?:\s|$)/);
+    if (!match)
+      continue;
+    total++;
+    if (match[1] === " ")
+      pending++;
+  }
+  return {
+    status: total === 0 ? "unavailable" : pending === 0 ? "complete" : "pending",
+    reason: total === 0 ? "no-task-checkboxes" : "",
+    total,
+    pending
+  };
+}
+async function inspectTaskChecklist(directory, progressFile) {
+  const name = String(progressFile || "").trim();
+  if (!name || name.includes("\x00"))
+    return unavailable("missing-progress-file");
+  if (path9.isAbsolute(name) || path9.win32.isAbsolute(name))
+    return unavailable("absolute-path");
+  const root = path9.resolve(directory);
+  const target = path9.resolve(root, name);
+  const relative = path9.relative(root, target);
+  if (!relative || relative === ".." || relative.startsWith(".." + path9.sep) || path9.isAbsolute(relative)) {
+    return unavailable("outside-project");
+  }
+  const parts = relative.split(path9.sep);
+  if (parts.some((part) => EXCLUDED_PROJECT_DIRS.has(part.toLowerCase())))
+    return unavailable("control-plane-path");
+  try {
+    const rootInfo = await fs8.lstat(root);
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink())
+      return unavailable("unsafe-project-root");
+    let current = root;
+    for (let index = 0;index < parts.length; index++) {
+      current = path9.join(current, parts[index]);
+      const info = await fs8.lstat(current);
+      if (info.isSymbolicLink())
+        return unavailable("symlink-path");
+      if (index < parts.length - 1 && !info.isDirectory())
+        return unavailable("invalid-parent");
+      if (index === parts.length - 1 && (!info.isFile() || info.size > MAX_CHECKLIST_BYTES)) {
+        return unavailable(!info.isFile() ? "not-regular-file" : "file-too-large");
+      }
+    }
+    const handle = await fs8.open(target, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    try {
+      const info = await handle.stat();
+      if (!info.isFile() || info.size > MAX_CHECKLIST_BYTES) {
+        return unavailable(!info.isFile() ? "not-regular-file" : "file-too-large");
+      }
+      const content = await handle.readFile({ encoding: "utf8" });
+      const after = await fs8.lstat(target);
+      if (!after.isFile() || after.isSymbolicLink() || after.dev !== info.dev || after.ino !== info.ino) {
+        return unavailable("file-changed-during-read");
+      }
+      return { ...summarizeTaskChecklist(content), digest: createHash("sha256").update(content).digest("hex") };
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    return unavailable(error?.code === "ENOENT" ? "file-missing" : error?.code === "ELOOP" ? "symlink-path" : "file-unreadable");
+  }
+}
+
 // src/source/runtime/run-finalization.js
 function requireFunction8(value, label) {
   if (typeof value !== "function")
@@ -3659,8 +3786,16 @@ function createRunFinalizationRuntime(options = {}) {
       if (verify.code === 0) {
         job.failureCount = 0;
         job.lastVerifyFailure = "";
+        if (job.untilChecklistComplete) {
+          const inspected = await inspectTaskChecklist(directory, job.progressFile);
+          if (inspected.status !== "unavailable")
+            job.lastVerifyChecklistDigest = inspected.digest;
+          else
+            delete job.lastVerifyChecklistDigest;
+        }
         await toast2(client, "Loop verify passed: " + job.verifyCommand, "success");
       } else {
+        delete job.lastVerifyChecklistDigest;
         job.failureCount = (job.failureCount || 0) + 1;
         job.lastVerifyFailure = (job.verifyCommand + `
 exit=` + verify.code + `
@@ -3748,7 +3883,7 @@ exit=` + postrun.code + `
 }
 
 // src/source/runtime/run-admission.js
-import path9 from "path";
+import path10 from "path";
 function requireFunction9(value, label) {
   if (typeof value !== "function")
     throw new TypeError(`createRunAdmissionRuntime requires ${label}`);
@@ -3786,12 +3921,30 @@ function createRunAdmissionRuntime(options = {}) {
     if (job.maxRuntimeMs > 0 && now2() - Date.parse(job.createdAt || new Date().toISOString()) >= job.maxRuntimeMs) {
       return await stopAndRemove(directory, client, sessionID, state, job, "max_runtime_reached", `Loop stopped by --max-runtime: ${job.name || job.id}`, "max-runtime");
     }
-    if (job.stopFile && await pathExists2(path9.resolve(directory, job.stopFile))) {
+    if (job.stopFile && await pathExists2(path10.resolve(directory, job.stopFile))) {
       return await stopAndRemove(directory, client, sessionID, state, job, "stop_file", "Loop stopped by --stop-file: " + job.stopFile);
     }
     if (await untilReached(directory, job)) {
       return await stopAndRemove(directory, client, sessionID, state, job, "until_reached", `Loop stopped by --until: ${job.until}`);
     }
+    if (job.untilChecklistComplete) {
+      const checklist = await inspectTaskChecklist(directory, job.progressFile);
+      job.checklistStatus = { status: checklist.status, total: checklist.total, pending: checklist.pending };
+      if (checklist.status === "unavailable") {
+        job.paused = true;
+        job.pauseReason = "checklist-unavailable";
+        job.lastChecklistError = checklist.reason;
+        await writeState2(directory, sessionID, state);
+        await notifyJob2(directory, job, "checklist_unavailable");
+        await toast2(client, "Loop paused: checklist " + job.progressFile + " could not be validated (" + checklist.reason + ").", "warning");
+        await reschedule(directory, client, sessionID);
+        return { admitted: false, reason: "checklist_unavailable" };
+      }
+      delete job.lastChecklistError;
+      if (checklist.status === "complete" && (!job.verifyCommand || job.lastVerifyAt > 0 && job.lastVerifyCode === 0 && job.lastVerifyChecklistDigest === checklist.digest)) {
+        return await stopAndRemove(directory, client, sessionID, state, job, "checklist_complete", "Loop stopped: " + job.progressFile + " checklist completed.", "checklist-complete");
+      }
+    }
     if (job.preflightCommand) {
       if (job.safe && dangerousShell2(job.preflightCommand)) {
         if (runNowRequested)