@bybrawe/opencode-loop 0.5.32 → 0.5.34

package/commands/loop.md

@@ -1,5 +1,5 @@
 ---
-description: Start an OpenCode auto-continue loop. Usage: /loop 5m <task>
+description: "Auto-continue or schedule work. /loop <task> = every idle; /loop every 5m <task> = recurring; /loop after 5m <task> = once."
 agent: opencode-loop-local
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.5.32",
+  "version": "0.5.34",
   "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",
@@ -21,8 +21,8 @@
     "build:plugin": "bun build src/source/v1.js --outfile=src/index.js --target=bun --format=esm --external=@opencode-ai/plugin/tool",
     "build:plugin:npm": "npm run build:plugin",
     "prepack": "node --check src/index.js",
-    "check": "node --check src/source/v1.js && node --check src/source/core/args.js && node --check src/source/core/state.js && node --check src/source/core/jobs.js && node --check src/source/core/process.js && node --check src/source/opencode/sdk.js && node --check src/source/opencode/session-context.js && node --check src/source/opencode/command-router.js && node --check src/source/opencode/goal-commands.js && node --check src/source/opencode/loop-commands.js && node --check src/source/opencode/loop-registration.js && node --check src/source/runtime/session-activity.js && node --check src/source/runtime/session-status.js && node --check src/source/runtime/compaction.js && node --check src/source/runtime/executor.js && node --check src/source/runtime/scheduler.js && node --check src/source/runtime/goal-runtime.js && node --check src/source/runtime/goal-policy.js && node --check src/source/runtime/goal-steering.js && node --check src/source/runtime/job-workspace.js && node --check src/source/opencode2/prompt-runtime.js && node --check src/source/opencode2/diagnostics.js && node --check src/source/opencode2/logging.js && node --check src/source/legacy-v1.js && node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/install-with-goals.mjs && node --check scripts/loopd.mjs && node --check scripts/install-test.mjs && node --check scripts/goal-companion-test.mjs && node --check scripts/loopd-test.mjs && node --check scripts/smoke-test.mjs && node --check scripts/host-adapter-contract-test.mjs && node --check scripts/command-router-test.mjs && node --check scripts/goal-command-handlers-test.mjs && node --check scripts/loop-command-handlers-test.mjs && node --check scripts/loop-registration-test.mjs && node --check scripts/session-activity-test.mjs && node --check scripts/session-status-test.mjs && node --check scripts/compaction-runtime-test.mjs && node --check scripts/executor-runtime-test.mjs && node --check scripts/scheduler-runtime-test.mjs && node --check scripts/goal-runtime-test.mjs && node --check scripts/goal-policy-test.mjs && node --check scripts/goal-steering-test.mjs && node --check scripts/job-workspace-test.mjs && node --check scripts/v2-prompt-runtime-test.mjs && node --check scripts/v2-prompt-interval-test.mjs && node --check scripts/v2-command-runtime-test.mjs && node --check scripts/v2-command-adapter-test.mjs && node --check scripts/v2-diagnostics-test.mjs && node --check scripts/v2-logging-test.mjs && node --check scripts/comprehensive-watchdog.mjs && node --check scripts/comprehensive-test.mjs && node --check scripts/host-loop-canary.mjs && node --check scripts/host-goal-steering-canary.mjs && node --check scripts/publish-workflow-test.mjs",
-    "test": "node scripts/publish-workflow-test.mjs && node scripts/command-router-test.mjs && node scripts/goal-command-handlers-test.mjs && node scripts/loop-command-handlers-test.mjs && node scripts/loop-registration-test.mjs && node scripts/session-activity-test.mjs && node scripts/session-status-test.mjs && node scripts/compaction-runtime-test.mjs && node scripts/executor-runtime-test.mjs && node scripts/scheduler-runtime-test.mjs && node scripts/goal-runtime-test.mjs && node scripts/goal-policy-test.mjs && node scripts/goal-steering-test.mjs && node scripts/job-workspace-test.mjs && node scripts/v2-prompt-runtime-test.mjs && node scripts/v2-prompt-interval-test.mjs && node scripts/v2-command-runtime-test.mjs && node scripts/v2-command-adapter-test.mjs && node scripts/v2-diagnostics-test.mjs && node scripts/v2-logging-test.mjs && node scripts/install-test.mjs && node scripts/goal-companion-test.mjs && node scripts/loopd-test.mjs && node scripts/smoke-test.mjs && node scripts/host-adapter-contract-test.mjs && node scripts/comprehensive-watchdog.mjs",
+    "check": "node --check src/source/v1.js && node --check src/source/core/args.js && node --check src/source/core/continuation.js && node --check src/source/core/schedule-syntax.js && node --check src/source/core/state.js && node --check src/source/core/jobs.js && node --check src/source/core/process.js && node --check src/source/opencode/sdk.js && node --check src/source/opencode/session-context.js && node --check src/source/opencode/command-router.js && node --check src/source/opencode/goal-commands.js && node --check src/source/opencode/loop-commands.js && node --check src/source/opencode/loop-registration.js && node --check src/source/runtime/session-activity.js && node --check src/source/runtime/session-status.js && node --check src/source/runtime/schedule-policy.js && node --check src/source/runtime/scheduler-diagnostics.js && node --check src/source/runtime/companion-goal.js && node --check src/source/runtime/loop-diagnostics.js && node --check src/source/runtime/compaction.js && node --check src/source/runtime/action-dispatch.js && node --check src/source/runtime/run-finalization.js && node --check src/source/runtime/run-admission.js && node --check src/source/runtime/executor.js && node --check src/source/runtime/scheduler.js && node --check src/source/runtime/goal-prompt.js && node --check src/source/runtime/goal-report.js && node --check src/source/runtime/goal-evidence.js && node --check src/source/runtime/goal-runtime.js && node --check src/source/runtime/goal-policy.js && node --check src/source/runtime/goal-steering.js && node --check src/source/runtime/job-workspace.js && node --check src/source/opencode2/prompt-runtime.js && node --check src/source/opencode2/diagnostics.js && node --check src/source/opencode2/logging.js && node --check src/source/legacy-v1.js && node --check src/index.js && node --check scripts/install-node.mjs && node --check scripts/install-with-goals.mjs && node --check scripts/loopd.mjs && node --check scripts/install-test.mjs && node --check scripts/goal-companion-test.mjs && node --check scripts/loopd-test.mjs && node --check scripts/smoke-test.mjs && node --check scripts/host-adapter-contract-test.mjs && node --check scripts/command-router-test.mjs && node --check scripts/goal-command-handlers-test.mjs && node --check scripts/loop-command-handlers-test.mjs && node --check scripts/loop-registration-test.mjs && node --check scripts/schedule-syntax-test.mjs && node --check scripts/schedule-policy-test.mjs && node --check scripts/session-activity-test.mjs && node --check scripts/session-status-test.mjs && node --check scripts/session-status-idle-recovery-test.mjs && node --check scripts/compaction-runtime-test.mjs && node --check scripts/executor-runtime-test.mjs && node --check scripts/scheduler-runtime-test.mjs && node --check scripts/goal-runtime-test.mjs && node --check scripts/goal-policy-test.mjs && node --check scripts/goal-steering-test.mjs && node --check scripts/job-workspace-test.mjs && node --check scripts/v2-prompt-runtime-test.mjs && node --check scripts/v2-prompt-interval-test.mjs && node --check scripts/v2-command-runtime-test.mjs && node --check scripts/v2-command-adapter-test.mjs && node --check scripts/v2-diagnostics-test.mjs && node --check scripts/v2-logging-test.mjs && node --check scripts/comprehensive-watchdog.mjs && node --check scripts/comprehensive-test.mjs && node --check scripts/host-loop-canary.mjs && node --check scripts/host-goal-steering-canary.mjs && node --check scripts/publish-workflow-test.mjs",
+    "test": "node scripts/publish-workflow-test.mjs && node scripts/command-router-test.mjs && node scripts/goal-command-handlers-test.mjs && node scripts/loop-command-handlers-test.mjs && node scripts/loop-registration-test.mjs && node scripts/schedule-syntax-test.mjs && node scripts/schedule-policy-test.mjs && node scripts/session-activity-test.mjs && node scripts/session-status-test.mjs && node scripts/session-status-idle-recovery-test.mjs && node scripts/compaction-runtime-test.mjs && node scripts/action-dispatch-test.mjs && node scripts/run-finalization-test.mjs && node scripts/run-admission-test.mjs && node scripts/executor-runtime-test.mjs && node scripts/scheduler-runtime-test.mjs && node scripts/goal-runtime-test.mjs && node scripts/goal-policy-test.mjs && node scripts/goal-steering-test.mjs && node scripts/job-workspace-test.mjs && node scripts/v2-prompt-runtime-test.mjs && node scripts/v2-prompt-interval-test.mjs && node scripts/v2-command-runtime-test.mjs && node scripts/v2-command-adapter-test.mjs && node scripts/v2-diagnostics-test.mjs && node scripts/v2-logging-test.mjs && node scripts/install-test.mjs && node scripts/goal-companion-test.mjs && node scripts/loopd-test.mjs && node scripts/smoke-test.mjs && node scripts/host-adapter-contract-test.mjs && node scripts/comprehensive-watchdog.mjs",
     "canary:host": "node scripts/host-loop-canary.mjs && node scripts/host-goal-steering-canary.mjs",
     "install:global": "node scripts/install-with-goals.mjs",
     "pack:zip": "node scripts/make-zip.mjs"

package/scripts/action-dispatch-test.mjs

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict"
+import { createActionDispatcher } from "../src/source/runtime/action-dispatch.js"
+
+assert.throws(() => createActionDispatcher({}), /buildPrompt/)
+assert.throws(() => createActionDispatcher({ buildPrompt: async () => "prompt" }), /compactionRuntime\.start/)
+
+const sdkCalls = []
+const fireCalls = []
+const compactions = []
+const guards = []
+const logs = []
+const toasts = []
+const prompts = []
+
+const dispatcher = createActionDispatcher({
+  buildPrompt: async (_directory, job) => {
+    prompts.push(job.id)
+    return `BUILT:${job.action}`
+  },
+  compactionRuntime: {
+    start: async (...args) => {
+      compactions.push(args)
+      return true
+    },
+  },
+  appendLoopLog: async (...args) => { logs.push(args) },
+  sdkCall: async (...args) => { sdkCalls.push(args); return {} },
+  normalizedModelRef: (value) => value ? { providerID: "provider", modelID: String(value) } : undefined,
+  fireSdk: (...args) => { fireCalls.push(args); return Promise.resolve({ ok: true }) },
+  compactTuiCommandName: (command) => command === "compact" ? "compact" : undefined,
+  toast: async (...args) => { toasts.push(args) },
+  guardLoopOwnedUserMessage: (sessionID) => { guards.push(sessionID) },
+  dangerousShell: (command) => /danger/.test(command),
+})
+
+const client = {
+  session: {
+    command: async () => ({ data: {} }),
+    shell: async () => ({ data: {} }),
+    prompt: async () => ({ data: {} }),
+  },
+}
+
+const blockedShell = await dispatcher.fireAction("/repo", client, "shell-session", {
+  id: "shell-job",
+  action: "! danger --all",
+  safe: true,
+})
+assert.deepEqual(blockedShell, { startsAssistantTurn: false, pause: true, reason: "safe_shell_blocked" })
+assert.equal(fireCalls.length, 0)
+assert.equal(logs.at(-1)[1], "blocked")
+assert.match(toasts.at(-1)[1], /Blocked dangerous shell command/)
+
+const commandResult = await dispatcher.fireAction("/repo", client, "command-session", {
+  id: "command-job",
+  action: "/review --quick",
+  agent: "build",
+  model: "model-a",
+})
+assert.deepEqual(commandResult, { startsAssistantTurn: true })
+assert.equal(sdkCalls.length, 1)
+assert.equal(guards.at(-1), "command-session")
+assert.deepEqual(sdkCalls.at(-1)[1].body, {
+  command: "review",
+  arguments: "--quick",
+  agent: "build",
+  model: "provider/model-a",
+})
+
+const compactResult = await dispatcher.fireAction("/repo", client, "compact-session", {
+  id: "compact-job",
+  action: "/compact",
+  agent: "build",
+  model: "model-b",
+})
+assert.deepEqual(compactResult, { startsAssistantTurn: true, pause: false, reason: "compact_failed", compaction: true })
+assert.equal(compactions.length, 1)
+assert.equal(compactions.at(-1)[2], "compact-session")
+assert.equal(compactions.at(-1)[3], "compact-job")
+assert.deepEqual(compactions.at(-1)[4], { providerID: "provider", modelID: "model-b" })
+
+const shellResult = await dispatcher.fireAction("/repo", client, "safe-shell-session", {
+  id: "safe-shell-job",
+  action: "! echo ok",
+  safe: true,
+  model: "model-c",
+})
+assert.equal(shellResult.startsAssistantTurn, true)
+assert.ok(shellResult.dispatch instanceof Promise)
+assert.equal(fireCalls.at(-1)[1], "session.shell")
+assert.deepEqual(fireCalls.at(-1)[3].body, {
+  command: "echo ok",
+  agent: "build",
+  model: { providerID: "provider", modelID: "model-c" },
+})
+
+const promptResult = await dispatcher.fireAction("/repo", client, "prompt-session", {
+  id: "prompt-job",
+  action: "keep working",
+  agent: "build",
+})
+assert.equal(promptResult.startsAssistantTurn, true)
+assert.ok(promptResult.dispatch instanceof Promise)
+assert.equal(prompts.at(-1), "prompt-job")
+assert.equal(fireCalls.at(-1)[1], "session.prompt")
+assert.match(fireCalls.at(-1)[3].body.parts[0].text, /AUTONOMOUS OPENCODE LOOP ITERATION/)
+assert.match(fireCalls.at(-1)[3].body.parts[0].text, /BUILT:keep working/)
+
+const goalPromptResult = await dispatcher.fireAction("/repo", client, "goal-session", {
+  id: "goal-job",
+  kind: "goal",
+  action: "finish objective",
+})
+assert.equal(goalPromptResult.startsAssistantTurn, true)
+assert.match(fireCalls.at(-1)[3].body.parts[0].text, /EXPERIMENTAL GOAL MODE CONTINUATION/)
+
+console.log("action dispatch runtime tests passed")

package/scripts/comprehensive-test.mjs

@@ -243,7 +243,7 @@ async function testParserAndPresets() {
     assert.match(preset.action, /Test command hint: npm run ci/)
 
     const toastCount = h.records.toasts.length
-    await h.command("loop", "nonsense")
+    await h.command("loop", "every nope continue")
     await h.command("loop", "5m")
     assert.equal(h.records.toasts.length, toastCount + 2)
     assert.ok(h.records.toasts.slice(-2).every((item) => item.variant === "warning"))

package/scripts/host-loop-canary.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath, pathToFileURL } from "node:url"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const isWindows = process.platform === "win32"
-const LOOP_OBJECTIVE = "real host loop canary"
+const LOOP_OBJECTIVE = "devam et"
 const RUN_NOW_NATURAL_OBJECTIVE = "real host loop-now natural canary"
 const RUN_NOW_TARGET_OBJECTIVE = "real host loop-now target canary"
 
@@ -332,7 +332,9 @@ async function main() {
       signal: AbortSignal.timeout(timeoutMs),
     })
 
-    const command = sendCommand("loop", `0s --max-runs 3 ${LOOP_OBJECTIVE}`).catch((error) => {
+    // No duration token on purpose: this proves `/loop devam et` is the real idle-loop
+    // shorthand on a live OpenCode host, not only a parser-unit-test behavior.
+    const command = sendCommand("loop", `--max-runs 3 ${LOOP_OBJECTIVE}`).catch((error) => {
       commandError = error
       return null
     })
@@ -356,7 +358,10 @@ async function main() {
     try { persisted = JSON.parse(await readFile(stateFile, "utf8")) } catch {}
     if (persisted?.jobs?.length) {
       const loop = persisted.jobs.find((item) => item.name === "default" || item.action === LOOP_OBJECTIVE)
-      if (loop) assert.ok((loop.runCount || 0) >= 3, `persisted Loop run count was lower than provider turn count: ${JSON.stringify(loop)}`)
+      if (loop) {
+        assert.equal(loop.scheduleMode, "idle", `durationless continuation must persist as idle mode: ${JSON.stringify(loop)}`)
+        assert.ok((loop.runCount || 0) >= 3, `persisted Loop run count was lower than provider turn count: ${JSON.stringify(loop)}`)
+      }
     }
 
     await sendCommand("loop", `10m --no-now --name natural --multi --max-runs 1 ${RUN_NOW_NATURAL_OBJECTIVE}`)

package/scripts/loop-command-handlers-test.mjs

@@ -53,6 +53,8 @@ function harness(initialStates = {}, overrides = {}) {
     appendLoopLog: async (...args) => { logs.push(args) },
     readFile: overrides.readFile || (async () => { throw new Error("missing") }),
     writeFile: async (...args) => { fileWrites.push(args) },
+    listPersistedLoopSessions: overrides.listPersistedLoopSessions || (async () => []),
+    findDedicatedGoalForSession: overrides.findDedicatedGoalForSession || (async () => undefined),
     runtimeVersion: "v-test",
     runtimePlatform: "test-platform",
   })
@@ -148,7 +150,9 @@ assert.throws(() => createLoopCommandHandlers({ clearActiveRun() {} }), /cancelD
   const text = h.messages[0][2]
   assert.match(text, /OpenCode loop status:/)
   assert.match(text, /1\. dev \(dev\): dev: 10s \[prompt\] -> Work on dev/)
-  assert.match(text, /runs=3 \| failures=1 \| due in 5s/)
+  assert.match(text, /schedule=every 10s, starts on next idle/)
+  assert.match(text, /state=due in 5s/)
+  assert.match(text, /runs=3 \| failures=1/)
   assert.match(text, /active,safe,ask-never,no-overlap/)
   assert.match(text, /goal:blocked,paused,checkpoint-only,git-checkpoint/)
 }
@@ -166,7 +170,19 @@ assert.throws(() => createLoopCommandHandlers({ clearActiveRun() {} }), /cancelD
     },
   }, { now: () => 10_000 })
   await h.handlers.statusLoop("/work", {}, sessionID)
-  assert.match(h.messages[0][2], /due in 5s/, "--no-now status must count the first interval from createdAt")
+  assert.match(h.messages[0][2], /state=due in 5s/, "--no-now status must count the first interval from createdAt")
+}
+
+{
+  const sessionID = "status-idle"
+  const h = harness({
+    [sessionID]: {
+      jobs: [loopJob("continue", { intervalMs: 0, lastRunAt: 0, scheduleMode: "idle", action: "continue" })],
+    },
+  })
+  await h.handlers.statusLoop("/work", {}, sessionID)
+  assert.match(h.messages[0][2], /schedule=every idle/)
+  assert.match(h.messages[0][2], /state=waiting for idle/)
 }
 
 {
@@ -199,6 +215,9 @@ assert.throws(() => createLoopCommandHandlers({ clearActiveRun() {} }), /cancelD
   await h.handlers.helpLoop({}, "help")
   const text = h.messages[0][2]
   assert.match(text, /OpenCode Loop help:/)
+  assert.match(text, /\/loop continue the project/)
+  assert.match(text, /\/loop every 5m continue the project/)
+  assert.match(text, /\/loop after 5m continue the project/)
   assert.match(text, /\/loop-goal finish the feature/)
   assert.match(text, /\/loop-doctor \| \/loop-init \| \/loop-export/)
 }
@@ -231,13 +250,23 @@ assert.throws(() => createLoopCommandHandlers({ clearActiveRun() {} }), /cancelD
 
 {
   const sessionID = "doctor"
-  const h = harness({ [sessionID]: { jobs: [loopJob("a"), loopJob("b")] } })
+  const h = harness({ [sessionID]: { jobs: [loopJob("a"), loopJob("b")] } }, {
+    listPersistedLoopSessions: async () => [
+      { sessionID, current: true, jobs: 2, enabled: 2, neverRan: 0 },
+      { sessionID: "other-session", current: false, jobs: 1, enabled: 1, neverRan: 1 },
+    ],
+    findDedicatedGoalForSession: async () => ({ id: "goal-abcdef123456", status: "active" }),
+  })
   await h.handlers.doctorLoop("/repo", {}, sessionID)
   const text = h.messages[0][2]
   assert.match(text, /OpenCode Loop doctor:/)
   assert.match(text, /- plugin: opencode-loop/)
   assert.match(text, /- project directory: \/repo/)
-  assert.match(text, /- active jobs: 2/)
+  assert.match(text, /- current session: doctor/)
+  assert.match(text, /- current-session jobs: 2/)
+  assert.match(text, /- dedicated \/goal: active/)
+  assert.match(text, /- other persisted sessions with enabled jobs: 1/)
+  assert.match(text, /other session other-session: jobs=1, enabled=1, never-ran=1/)
   assert.match(text, /- node: v-test/)
   assert.match(text, /- platform: test-platform/)
   assert.match(text, /experimental goal smoke test/)

package/scripts/loop-registration-test.mjs

@@ -11,6 +11,7 @@ function harness(initialStates = {}, overrides = {}) {
   const messages = []
   const logs = []
   const contexts = new Map(Object.entries(overrides.contexts || {}))
+  const dedicatedGoals = new Map(Object.entries(overrides.dedicatedGoals || {}))
 
   const { addLoop } = createLoopRegistration({
     snapshotPaths: async (directory, files) => {
@@ -30,6 +31,7 @@ function harness(initialStates = {}, overrides = {}) {
     appendLoopLog: async (...args) => { logs.push(args) },
     normalizedModelRef: (value) => value ? `normalized:${value}` : undefined,
     getSessionExecutionContext: (sessionID) => contexts.get(sessionID),
+    findDedicatedGoalForSession: async (_directory, sessionID) => dedicatedGoals.get(sessionID),
     defaultActiveGuardMs: overrides.defaultActiveGuardMs ?? 45_000,
   })
 
@@ -50,7 +52,7 @@ assert.equal(sameLoopDefinition(null, {}), false)
   const sessionID = "invalid"
   const h = harness()
   const client = {}
-  await h.addLoop("/work", client, sessionID, "not-a-duration and no defaults")
+  await h.addLoop("/work", client, sessionID, "every nope continue")
   assert.equal(h.writes.length, 0)
   assert.equal(h.due.length, 0)
   assert.equal(h.idle.length, 0)
@@ -58,7 +60,59 @@ assert.equal(sameLoopDefinition(null, {}), false)
   assert.equal(h.toasts.length, 1)
   assert.equal(h.toasts[0][0], client)
   assert.equal(h.toasts[0][2], "warning")
-  assert.match(h.toasts[0][1], /Usage: \/loop/)
+  assert.match(h.toasts[0][1], /Invalid every schedule/)
+}
+
+{
+  const sessionID = "shorthand-idle"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "continue the project")
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.action, "continue the project")
+  assert.equal(job.intervalMs, 0)
+  assert.equal(job.scheduleMode, "idle")
+  assert.equal(job.scheduleSyntax, "idle-shorthand")
+  assert.equal(job.immediate, true)
+  assert.equal(job.maxRuns, 0)
+  assert.equal(h.idle.length, 1)
+}
+
+{
+  const sessionID = "explicit-idle"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "idle continue forever")
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.action, "continue forever")
+  assert.equal(job.intervalMs, 0)
+  assert.equal(job.scheduleMode, "idle")
+  assert.equal(job.scheduleSyntax, "idle")
+}
+
+{
+  const sessionID = "every"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "every 5m continue the project")
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.intervalMs, 300_000)
+  assert.equal(job.scheduleMode, "interval")
+  assert.equal(job.scheduleSyntax, "every")
+  assert.equal(job.immediate, false)
+  assert.equal(job.maxRuns, 0)
+  assert.equal(h.idle.length, 0)
+  assert.equal(h.due.length, 1)
+}
+
+{
+  const sessionID = "after"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "after 5m continue once")
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.intervalMs, 300_000)
+  assert.equal(job.scheduleMode, "once")
+  assert.equal(job.scheduleSyntax, "after")
+  assert.equal(job.immediate, false)
+  assert.equal(job.maxRuns, 1)
+  assert.equal(h.idle.length, 0)
 }
 
 {
@@ -73,6 +127,7 @@ assert.equal(sameLoopDefinition(null, {}), false)
   assert.equal(job.model, "ctx-model")
   assert.equal(job.activeRecoveryMs, 45_000)
   assert.equal(job.immediate, true)
+  assert.equal(job.scheduleMode, "idle")
   assert.equal(h.writes.length, 1)
   assert.deepEqual(h.due, [["/work", client, sessionID]])
   assert.deepEqual(h.idle, [["/work", client, sessionID]])
@@ -139,6 +194,25 @@ assert.equal(sameLoopDefinition(null, {}), false)
   assert.equal(job.activeRecoveryMs, 180_000)
 }
 
+{
+  const sessionID = "dedicated-goal-conflict"
+  const h = harness({}, { dedicatedGoals: { [sessionID]: { id: "goal-123", status: "active", sessionID } } })
+  await h.addLoop("/work", {}, sessionID, "continue the same work")
+  assert.equal(h.writes.length, 0)
+  assert.equal(h.due.length, 0)
+  assert.equal(h.idle.length, 0)
+  assert.equal(h.logs[0][1], "goal-overlap-blocked")
+  assert.match(h.toasts[0][1], /dedicated \/goal already owns continuation/)
+}
+
+{
+  const sessionID = "dedicated-goal-override"
+  const h = harness({}, { dedicatedGoals: { [sessionID]: { id: "goal-123", status: "active", sessionID } } })
+  await h.addLoop("/work", {}, sessionID, "--allow-goal-overlap continue intentionally")
+  assert.equal(h.writes.length, 1)
+  assert.equal(h.states.get(sessionID).jobs[0].allowGoalOverlap, true)
+}
+
 {
   const sessionID = "long-interval"
   const h = harness()
@@ -195,7 +269,7 @@ assert.equal(sameLoopDefinition(null, {}), false)
   const sessionID = "dry-run"
   const client = {}
   const h = harness()
-  await h.addLoop("/work", client, sessionID, "0s --dry-run inspect only")
+  await h.addLoop("/work", client, sessionID, "--dry-run inspect only")
   assert.equal(h.writes.length, 0)
   assert.equal(h.due.length, 0)
   assert.equal(h.idle.length, 0)

package/scripts/run-admission-test.mjs

@@ -0,0 +1,133 @@
+import assert from "node:assert/strict"
+import path from "node:path"
+import { createRunAdmissionRuntime } from "../src/source/runtime/run-admission.js"
+
+assert.throws(() => createRunAdmissionRuntime({}), /untilReached/)
+assert.throws(() => createRunAdmissionRuntime({ untilReached: async () => false }), /scheduleDueWork/)
+
+let clock = 1_000_000
+const writes = []
+const logs = []
+const shellCalls = []
+const notifications = []
+const toasts = []
+const schedules = []
+const stopFiles = new Set()
+const untilJobs = new Set()
+const normalizePath = (value) => String(value).replace(/\\/g, "/")
+
+const runtime = createRunAdmissionRuntime({
+  untilReached: async (_directory, job) => untilJobs.has(job.id),
+  scheduleDueWork: async (...args) => { schedules.push(args) },
+  now: () => clock,
+  pathExists: async (target) => stopFiles.has(normalizePath(target)),
+  writeState: async (...args) => { writes.push(args) },
+  appendLoopLog: async (...args) => { logs.push(args) },
+  runShellCommand: async (command) => {
+    shellCalls.push(command)
+    if (command.includes("fail")) return { code: 7, stdout: "bad", stderr: "preflight error" }
+    return { code: 0, stdout: "ok", stderr: "" }
+  },
+  notifyJob: async (...args) => { notifications.push(args) },
+  toast: async (...args) => { toasts.push(args) },
+  dangerousShell: (command) => command.includes("danger"),
+})
+
+const dueState = {
+  jobs: [
+    { id: "disabled", enabled: false, intervalMs: 0 },
+    { id: "paused", enabled: true, paused: true, intervalMs: 0 },
+    { id: "maxed", enabled: true, maxRuns: 1, runCount: 1, intervalMs: 0 },
+    { id: "goal-done", kind: "goal", goalStatus: "completed", enabled: true, intervalMs: 0 },
+    { id: "watch-no", enabled: true, watchPaths: ["x"], watchTriggered: false, intervalMs: 0 },
+    { id: "watch-yes", enabled: true, watchPaths: ["x"], watchTriggered: true, intervalMs: 99_999 },
+    { id: "interval", enabled: true, intervalMs: 10_000, lastRunAt: clock - 20_000 },
+    { id: "run-now", enabled: true, intervalMs: 999_999, lastRunAt: clock, runNowRequestedAt: clock },
+  ],
+}
+assert.deepEqual(runtime.dueJobs(dueState).map((job) => job.id), ["run-now", "watch-yes", "interval"])
+assert.deepEqual(runtime.dueJobs(dueState, true).map((job) => job.id), ["run-now", "watch-no", "watch-yes", "interval"])
+
+const expired = {
+  id: "expired",
+  name: "expired-job",
+  enabled: true,
+  createdAt: new Date(clock - 20_000).toISOString(),
+  maxRuntimeMs: 10_000,
+}
+const expiredState = { jobs: [expired, { id: "keep", enabled: true }] }
+const expiredResult = await runtime.admitJob("/repo", {}, "session-expired", expiredState, expired)
+assert.deepEqual(expiredResult, { admitted: false, reason: "max_runtime_reached" })
+assert.deepEqual(expiredState.jobs.map((job) => job.id), ["keep"])
+assert.equal(notifications.at(-1)[2], "max_runtime_reached")
+assert.equal(logs.at(-1)[1], "max-runtime")
+assert.match(toasts.at(-1)[1], /--max-runtime/)
+assert.equal(schedules.at(-1)[2], "session-expired")
+
+stopFiles.add(normalizePath(path.resolve("/repo", "STOP")))
+const stopped = { id: "stopped", enabled: true, stopFile: "STOP" }
+const stoppedState = { jobs: [stopped] }
+const stoppedResult = await runtime.admitJob("/repo", {}, "session-stop", stoppedState, stopped)
+assert.deepEqual(stoppedResult, { admitted: false, reason: "stop_file" })
+assert.equal(stoppedState.jobs.length, 0)
+assert.equal(notifications.at(-1)[2], "stop_file")
+assert.match(toasts.at(-1)[1], /--stop-file/)
+
+untilJobs.add("until-job")
+const untilJob = { id: "until-job", enabled: true, until: "DONE" }
+const untilState = { jobs: [untilJob] }
+const untilResult = await runtime.admitJob("/repo", {}, "session-until", untilState, untilJob)
+assert.deepEqual(untilResult, { admitted: false, reason: "until_reached" })
+assert.equal(untilState.jobs.length, 0)
+assert.equal(notifications.at(-1)[2], "until_reached")
+assert.match(toasts.at(-1)[1], /--until/)
+
+const blocked = {
+  id: "blocked-preflight",
+  enabled: true,
+  safe: true,
+  preflightCommand: "danger --all",
+  runNowRequestedAt: clock,
+}
+const blockedState = { jobs: [blocked] }
+const shellCountBeforeBlock = shellCalls.length
+const blockedResult = await runtime.admitJob("/repo", {}, "session-blocked", blockedState, blocked)
+assert.deepEqual(blockedResult, { admitted: false, reason: "preflight_blocked" })
+assert.equal(shellCalls.length, shellCountBeforeBlock)
+assert.equal(blocked.paused, true)
+assert.equal(blocked.runNowRequestedAt, undefined)
+assert.equal(notifications.at(-1)[2], "preflight_blocked")
+assert.equal(writes.at(-1)[2], blockedState)
+
+const failed = {
+  id: "failed-preflight",
+  enabled: true,
+  preflightCommand: "preflight-fail",
+  runNowRequestedAt: clock,
+  failureCount: 2,
+}
+const failedState = { jobs: [failed] }
+const failedResult = await runtime.admitJob("/repo", {}, "session-failed", failedState, failed)
+assert.deepEqual(failedResult, { admitted: false, reason: "preflight_failed" })
+assert.equal(failed.paused, true)
+assert.equal(failed.failureCount, 3)
+assert.equal(failed.runNowRequestedAt, undefined)
+assert.match(failed.lastPreflightFailure, /exit=7/)
+assert.match(failed.lastPreflightFailure, /preflight error/)
+assert.equal(logs.findLast((entry) => entry[1] === "preflight")?.[2].code, 7)
+assert.equal(notifications.at(-1)[2], "preflight_failed")
+
+const admitted = {
+  id: "admitted",
+  enabled: true,
+  preflightCommand: "preflight-ok",
+  runNowRequestedAt: clock,
+}
+const admittedState = { jobs: [admitted] }
+const admittedResult = await runtime.admitJob("/repo", {}, "session-admitted", admittedState, admitted)
+assert.deepEqual(admittedResult, { admitted: true, job: admitted, runNowRequested: true })
+assert.equal(admitted.paused, undefined)
+assert.equal(admitted.runNowRequestedAt, clock)
+assert.equal(logs.findLast((entry) => entry[1] === "preflight")?.[2].code, 0)
+
+console.log("run admission runtime tests passed")

package/scripts/run-finalization-test.mjs

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict"
+import { createRunFinalizationRuntime } from "../src/source/runtime/run-finalization.js"
+
+const noop = async () => {}
+assert.throws(() => createRunFinalizationRuntime({}), /runGoalChecks/)
+assert.throws(() => createRunFinalizationRuntime({ runGoalChecks: noop }), /applyGoalNoProgressGuard/)
+assert.throws(() => createRunFinalizationRuntime({ runGoalChecks: noop, applyGoalNoProgressGuard: noop }), /createCheckpoint/)
+assert.throws(() => createRunFinalizationRuntime({ runGoalChecks: noop, applyGoalNoProgressGuard: noop, createCheckpoint: noop }), /scheduleDueWork/)
+
+let clock = 1000
+const shellCalls = []
+const writes = []
+const logs = []
+const notifications = []
+const toasts = []
+const checkpoints = []
+const schedules = []
+const goalChecks = []
+const progressGuards = []
+const reports = []
+
+const runtime = createRunFinalizationRuntime({
+  runGoalChecks: async (_directory, sessionID, job) => {
+    goalChecks.push([sessionID, job.id])
+    return { ...job, checksRan: true }
+  },
+  applyGoalNoProgressGuard: async (_directory, _client, sessionID, job, previousJob) => {
+    progressGuards.push([sessionID, job.id, previousJob?.id])
+    return { ...job, guardRan: true }
+  },
+  createCheckpoint: async (...args) => { checkpoints.push(args) },
+  scheduleDueWork: async (...args) => { schedules.push(args) },
+  now: () => ++clock,
+  writeState: async (...args) => { writes.push(args) },
+  appendLoopLog: async (...args) => { logs.push(args) },
+  runShellCommand: async (command) => {
+    shellCalls.push(command)
+    if (command.includes("verify-fail")) return { code: 1, stdout: "bad", stderr: "verify error" }
+    if (command.includes("post-fail")) return { code: 2, stdout: "post bad", stderr: "post error" }
+    return { code: 0, stdout: "ok", stderr: "" }
+  },
+  notifyJob: async (...args) => { notifications.push(args) },
+  toast: async (...args) => { toasts.push(args) },
+  writeGoalReport: async (...args) => { reports.push(args) },
+  dangerousShell: (command) => command.includes("danger"),
+})
+
+const passing = { id: "passing", enabled: true, verifyCommand: "verify-ok", failureCount: 2 }
+const passingState = { jobs: [passing] }
+const passingResult = await runtime.finalizeJob("/repo", {}, "session-pass", passingState, passing, { id: "before-pass" })
+assert.equal(passingResult.lastVerifyCode, 0)
+assert.equal(passingResult.failureCount, 0)
+assert.equal(passingResult.lastVerifyFailure, "")
+assert.equal(writes.at(-1)[2].jobs[0].id, "passing")
+assert.equal(checkpoints.at(-1)[2].id, "passing")
+assert.equal(schedules.at(-1)[2], "session-pass")
+assert.match(toasts.at(-1)[1], /Loop verify passed/)
+
+const failing = {
+  id: "failing",
+  enabled: true,
+  verifyCommand: "verify-fail",
+  pauseOnVerifyFail: true,
+  failureCount: 0,
+}
+const failingState = { jobs: [failing] }
+await runtime.finalizeJob("/repo", {}, "session-fail", failingState, failing, { id: "before-fail" })
+assert.equal(failing.lastVerifyCode, 1)
+assert.equal(failing.failureCount, 1)
+assert.equal(failing.paused, true)
+assert.match(failing.lastVerifyFailure, /verify error/)
+assert.equal(notifications.at(-1)[2], "verify_failed")
+assert.equal(logs.at(-1)[1], "verify")
+
+const blockedPostrun = {
+  id: "blocked-postrun",
+  enabled: true,
+  postrunCommand: "danger --all",
+  safe: true,
+}
+const blockedState = { jobs: [blockedPostrun] }
+const shellCountBeforeBlocked = shellCalls.length
+await runtime.finalizeJob("/repo", {}, "session-blocked", blockedState, blockedPostrun, { id: "before-blocked" })
+assert.equal(shellCalls.length, shellCountBeforeBlocked)
+assert.equal(logs.findLast((entry) => entry[1] === "postrun-blocked")?.[2].command, "danger --all")
+
+const failedPostrun = {
+  id: "failed-postrun",
+  enabled: true,
+  postrunCommand: "post-fail",
+  maxFailures: 1,
+  failureCount: 0,
+}
+const failedPostrunState = { jobs: [failedPostrun] }
+await runtime.finalizeJob("/repo", {}, "session-post-fail", failedPostrunState, failedPostrun, { id: "before-post-fail" })
+assert.equal(failedPostrun.lastPostrunCode, 2)
+assert.equal(failedPostrun.failureCount, 1)
+assert.equal(failedPostrun.paused, true)
+assert.equal(notifications.at(-1)[2], "postrun_failed")
+
+const goal = {
+  id: "goal-job",
+  kind: "goal",
+  enabled: false,
+  paused: true,
+  goalStatus: "completed",
+}
+const otherDisabled = { id: "other-disabled", enabled: false }
+const goalState = { jobs: [goal, otherDisabled] }
+const goalResult = await runtime.finalizeJob("/repo", {}, "session-goal", goalState, goal, { id: "before-goal" })
+assert.equal(goalResult.checksRan, true)
+assert.equal(goalResult.guardRan, true)
+assert.deepEqual(goalChecks.at(-1), ["session-goal", "goal-job"])
+assert.deepEqual(progressGuards.at(-1), ["session-goal", "goal-job", "before-goal"])
+assert.equal(goalState.jobs.length, 1)
+assert.equal(goalState.jobs[0].id, "goal-job")
+assert.equal(reports.at(-1)[2].id, "goal-job")
+
+console.log("run finalization runtime tests passed")