@bybrawe/opencode-loop 0.5.28 → 0.5.29

package/scripts/job-workspace-test.mjs

@@ -0,0 +1,164 @@
+import assert from "node:assert/strict"
+import { promises as fs } from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { stateDir } from "../src/source/core/state.js"
+import { createJobWorkspaceRuntime, dangerousShell } from "../src/source/runtime/job-workspace.js"
+
+assert.equal(dangerousShell("npm test"), false)
+assert.equal(dangerousShell("git status"), false)
+assert.equal(dangerousShell("git push origin main"), true)
+assert.equal(dangerousShell("git reset --hard HEAD"), true)
+assert.equal(dangerousShell("rm -rf build"), true)
+assert.equal(dangerousShell("Remove-Item cache -Recurse -Force"), true)
+assert.equal(dangerousShell("terraform destroy"), true)
+assert.equal(dangerousShell("kubectl delete pod app"), true)
+assert.equal(dangerousShell("deploy production"), true)
+assert.throws(() => createJobWorkspaceRuntime({}), /toast/)
+
+const directory = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-workspace-"))
+try {
+  const processCalls = []
+  const processResults = []
+  const toasts = []
+  const logs = []
+  const goalPromptCalls = []
+
+  const runtime = createJobWorkspaceRuntime({
+    toast: async (...args) => { toasts.push(args) },
+    appendLoopLog: async (...args) => { logs.push(args) },
+    runProcess: async (...args) => {
+      processCalls.push(args)
+      return processResults.shift() || { code: 0, stdout: "", stderr: "" }
+    },
+    buildGoalPrompt: async (...args) => {
+      goalPromptCalls.push(args)
+      return "GOAL PROMPT"
+    },
+  })
+
+  await fs.writeFile(path.join(directory, "PROMPT.md"), "Extra instructions\n", "utf8")
+  await fs.writeFile(path.join(directory, "CONTEXT.md"), "Context contents\n", "utf8")
+
+  const prompt = await runtime.buildPrompt(directory, {
+    kind: "prompt",
+    action: "Implement the change",
+    promptFile: "PROMPT.md",
+    includeFiles: ["CONTEXT.md"],
+  })
+  assert.match(prompt, /Instructions from PROMPT\.md:\nExtra instructions/)
+  assert.match(prompt, /Implement the change/)
+  assert.match(prompt, /Context from CONTEXT\.md:\nContext contents/)
+  assert.equal(goalPromptCalls.length, 0)
+
+  const goalPrompt = await runtime.buildPrompt(directory, { kind: "goal", action: "Ship it" })
+  assert.equal(goalPrompt, "GOAL PROMPT")
+  assert.equal(goalPromptCalls.length, 1)
+  assert.equal(goalPromptCalls[0][0], directory)
+  assert.equal(goalPromptCalls[0][1].action, "Ship it")
+
+  const missingPrompt = await runtime.buildPrompt(directory, {
+    kind: "prompt",
+    action: "Fallback action",
+    promptFile: "MISSING.md",
+  })
+  assert.match(missingPrompt, /could not be read/)
+  assert.match(missingPrompt, /Fallback action/)
+
+  const noBranch = { id: "none" }
+  assert.equal(await runtime.ensureBranch(directory, noBranch, {}, "session"), noBranch)
+  assert.equal(processCalls.length, 0)
+
+  processResults.push({ code: 1, stdout: "", stderr: "not a repo" })
+  const nonRepo = { id: "nonrepo", branch: "feature/test" }
+  await runtime.ensureBranch(directory, nonRepo, {}, "session")
+  assert.equal(nonRepo.branchDone, true)
+  assert.equal(processCalls.at(-1)[0], "git")
+  assert.deepEqual(processCalls.at(-1)[1], ["rev-parse", "--is-inside-work-tree"])
+  assert.equal(toasts.length, 0)
+  assert.equal(logs.length, 0)
+
+  processResults.push(
+    { code: 0, stdout: "true", stderr: "" },
+    { code: 1, stdout: "", stderr: "missing" },
+    { code: 0, stdout: "", stderr: "" },
+  )
+  const branchJob = { id: "branch", branch: "feature/test" }
+  const client = { id: "client" }
+  await runtime.ensureBranch(directory, branchJob, client, "session")
+  assert.equal(branchJob.branchDone, true)
+  assert.deepEqual(processCalls.slice(-3).map((call) => call[1]), [
+    ["rev-parse", "--is-inside-work-tree"],
+    ["switch", "feature-test"],
+    ["switch", "-c", "feature-test"],
+  ])
+  assert.deepEqual(toasts.at(-1), [client, "Loop branch active: feature-test", "success"])
+  assert.deepEqual(logs.at(-1), [directory, "branch", { sessionID: "session", branch: "feature-test", code: 0 }])
+
+  const watched = path.join(directory, "watched.txt")
+  await fs.writeFile(watched, "one", "utf8")
+  const initialSnapshot = await runtime.snapshotPaths(directory, ["watched.txt", "missing.txt"])
+  assert.notEqual(initialSnapshot["watched.txt"], "missing")
+  assert.equal(initialSnapshot["missing.txt"], "missing")
+
+  const watchJob = { watchPaths: ["watched.txt"], watchSnapshot: initialSnapshot }
+  assert.equal(await runtime.watchChanged(directory, watchJob), false)
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await fs.writeFile(watched, "two-and-longer", "utf8")
+  assert.equal(await runtime.watchChanged(directory, watchJob), true)
+  assert.notEqual(watchJob.watchSnapshot["watched.txt"], initialSnapshot["watched.txt"])
+  assert.equal(await runtime.watchChanged(directory, { watchPaths: [] }), false)
+
+  assert.equal(await runtime.untilReached(directory, { until: "never" }), false)
+  await fs.writeFile(path.join(directory, "progress.md"), "status: DONE_MARKER\n", "utf8")
+  assert.equal(await runtime.untilReached(directory, { until: "DONE_MARKER" }), true)
+
+  await fs.mkdir(path.join(directory, "nested"), { recursive: true })
+  await fs.writeFile(path.join(directory, "nested", "state.yaml"), "value: NESTED_MARKER\n", "utf8")
+  assert.equal(await runtime.untilReached(directory, { until: "NESTED_MARKER" }), true)
+
+  await fs.mkdir(path.join(directory, "node_modules", "hidden"), { recursive: true })
+  await fs.writeFile(path.join(directory, "node_modules", "hidden", "secret.md"), "IGNORED_MARKER", "utf8")
+  assert.equal(await runtime.untilReached(directory, { until: "IGNORED_MARKER" }), false)
+  assert.equal(await runtime.untilReached(directory, {}), false)
+
+  const checkpointProcessStart = processCalls.length
+  processResults.push(
+    { code: 0, stdout: "true", stderr: "" },
+    { code: 0, stdout: " M changed.js\n", stderr: "" },
+    { code: 0, stdout: "diff-data", stderr: "" },
+    { code: 0, stdout: "staged-data", stderr: "" },
+    { code: 0, stdout: "", stderr: "" },
+    { code: 0, stdout: "", stderr: "" },
+  )
+  await runtime.createCheckpoint(directory, "session/checkpoint", { id: "job", name: "workspace", checkpointOnly: true, gitCheckpoint: true }, client)
+  const checkpointCalls = processCalls.slice(checkpointProcessStart)
+  assert.deepEqual(checkpointCalls.slice(0, 5).map((call) => call[1]), [
+    ["rev-parse", "--is-inside-work-tree"],
+    ["status", "--short"],
+    ["diff", "--binary"],
+    ["diff", "--cached", "--binary"],
+    ["add", "-A"],
+  ])
+  assert.deepEqual(checkpointCalls[5][1].slice(0, 2), ["commit", "-m"])
+  assert.match(checkpointCalls[5][1][2], /^chore: opencode loop checkpoint /)
+
+  const checkpointDir = path.join(stateDir(directory), "checkpoints", "session-checkpoint")
+  const checkpointFiles = await fs.readdir(checkpointDir)
+  const statusFile = checkpointFiles.find((file) => file.endsWith(".status.txt"))
+  const patchFile = checkpointFiles.find((file) => file.endsWith(".patch"))
+  assert.ok(statusFile)
+  assert.ok(patchFile)
+  assert.equal(await fs.readFile(path.join(checkpointDir, statusFile), "utf8"), " M changed.js\n")
+  assert.equal(await fs.readFile(path.join(checkpointDir, patchFile), "utf8"), "diff-data\nstaged-data")
+  assert.match(toasts.at(-1)[1], /^Loop checkpoint saved:/)
+  assert.equal(toasts.at(-1)[2], "success")
+
+  const beforeNoopCalls = processCalls.length
+  await runtime.createCheckpoint(directory, "session", { id: "none" }, client)
+  assert.equal(processCalls.length, beforeNoopCalls)
+
+  console.log("job workspace tests passed")
+} finally {
+  await fs.rm(directory, { recursive: true, force: true })
+}

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

@@ -0,0 +1,279 @@
+import assert from "node:assert/strict"
+import path from "node:path"
+import { createLoopCommandHandlers } from "../src/source/opencode/loop-commands.js"
+
+function loopJob(id, overrides = {}) {
+  return {
+    id,
+    name: id,
+    kind: "prompt",
+    intervalMs: 10_000,
+    lastRunAt: 5_000,
+    action: `Work on ${id}`,
+    paused: false,
+    enabled: true,
+    runCount: 0,
+    failureCount: 0,
+    ...overrides,
+  }
+}
+
+function harness(initialStates = {}, overrides = {}) {
+  const states = new Map(Object.entries(initialStates).map(([key, value]) => [key, structuredClone(value)]))
+  const writes = []
+  const removed = []
+  const cleared = []
+  const cancelled = []
+  const watchdogs = []
+  const due = []
+  const forcedRuns = []
+  const toasts = []
+  const messages = []
+  const logs = []
+  const fileWrites = []
+  const existingPaths = new Set(overrides.existingPaths || [])
+
+  const handlers = createLoopCommandHandlers({
+    clearActiveRun: (sessionID) => cleared.push(sessionID),
+    cancelDueWork: (sessionID) => cancelled.push(sessionID),
+    stopWatchdog: (sessionID) => watchdogs.push(sessionID),
+    scheduleDueWork: async (...args) => { due.push(args) },
+    maybeRunDueJobs: async (...args) => { forcedRuns.push(args) },
+    toast: async (...args) => { toasts.push(args) },
+    say: async (...args) => { messages.push(args) },
+    now: overrides.now || (() => 10_000),
+    readState: async (_directory, sessionID) => structuredClone(states.get(sessionID) || { jobs: [] }),
+    writeState: async (_directory, sessionID, state) => {
+      const copy = structuredClone(state)
+      states.set(sessionID, copy)
+      writes.push({ sessionID, state: copy })
+    },
+    removeState: async (...args) => { removed.push(args); states.delete(args[1]) },
+    pathExists: async (target) => existingPaths.has(target),
+    appendLoopLog: async (...args) => { logs.push(args) },
+    readFile: overrides.readFile || (async () => { throw new Error("missing") }),
+    writeFile: async (...args) => { fileWrites.push(args) },
+    runtimeVersion: "v-test",
+    runtimePlatform: "test-platform",
+  })
+
+  return {
+    handlers,
+    states,
+    writes,
+    removed,
+    cleared,
+    cancelled,
+    watchdogs,
+    due,
+    forcedRuns,
+    toasts,
+    messages,
+    logs,
+    fileWrites,
+  }
+}
+
+assert.throws(() => createLoopCommandHandlers({}), /clearActiveRun/)
+assert.throws(() => createLoopCommandHandlers({ clearActiveRun() {} }), /cancelDueWork/)
+
+{
+  const sessionID = "stop-all"
+  const h = harness({ [sessionID]: { jobs: [loopJob("a")] } })
+  const client = {}
+  await h.handlers.stopLoop("/work", client, sessionID, "all")
+  assert.deepEqual(h.removed, [["/work", sessionID]])
+  assert.deepEqual(h.cleared, [sessionID])
+  assert.deepEqual(h.cancelled, [sessionID])
+  assert.deepEqual(h.watchdogs, [sessionID])
+  assert.equal(h.due.length, 0)
+  assert.deepEqual(h.toasts, [[client, "All loops stopped for this session.", "success"]])
+}
+
+{
+  const sessionID = "stop-empty"
+  const h = harness({ [sessionID]: { jobs: [loopJob("a")] } })
+  await h.handlers.stopLoop("/work", {}, sessionID, "")
+  assert.equal(h.removed.length, 1, "empty stop target keeps existing stop-all semantics")
+}
+
+{
+  const sessionID = "stop-one"
+  const client = {}
+  const h = harness({ [sessionID]: { jobs: [loopJob("a"), loopJob("b")] } })
+  await h.handlers.stopLoop("/work", client, sessionID, "a")
+  assert.deepEqual(h.states.get(sessionID).jobs.map((job) => job.id), ["b"])
+  assert.equal(h.writes.length, 1)
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.toasts, [[client, "Stopped 1 loop(s).", "success"]])
+  assert.equal(h.removed.length, 0)
+}
+
+{
+  const sessionID = "update"
+  const client = {}
+  const h = harness({ [sessionID]: { jobs: [loopJob("a"), loopJob("b")] } })
+  await h.handlers.updateJobState("/work", client, sessionID, "b", (job) => ({ ...job, paused: true, marker: "yes" }), "Paused")
+  const jobs = h.states.get(sessionID).jobs
+  assert.equal(jobs[0].paused, false)
+  assert.equal(jobs[1].paused, true)
+  assert.equal(jobs[1].marker, "yes")
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.toasts, [[client, "Paused: 1 loop(s).", "success"]])
+}
+
+{
+  const sessionID = "update-missing"
+  const client = {}
+  const h = harness({ [sessionID]: { jobs: [loopJob("a")] } })
+  await h.handlers.updateJobState("/work", client, sessionID, "missing", (job) => ({ ...job, paused: true }), "Paused")
+  assert.deepEqual(h.toasts, [[client, "Paused: 0 loop(s).", "warning"]])
+  assert.equal(h.due.length, 1, "state updates keep rescheduling even when no job matches")
+}
+
+{
+  const sessionID = "status"
+  const client = { id: "client" }
+  const h = harness({
+    [sessionID]: {
+      jobs: [
+        loopJob("dev", { safe: true, askNever: true, noOverlap: true, runCount: 3, failureCount: 1 }),
+        loopJob("goal", { kind: "goal", intervalMs: 0, lastRunAt: 0, goalStatus: "blocked", paused: true, checkpointOnly: true, gitCheckpoint: true }),
+      ],
+    },
+  })
+  await h.handlers.statusLoop("/work", client, sessionID)
+  assert.deepEqual(h.toasts, [[client, "2 loop job(s).", "info"]])
+  assert.equal(h.messages.length, 1)
+  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, /active,safe,ask-never,no-overlap/)
+  assert.match(text, /goal:blocked,paused,checkpoint-only,git-checkpoint/)
+}
+
+{
+  const sessionID = "status-no-now"
+  const h = harness({
+    [sessionID]: {
+      jobs: [loopJob("delayed", {
+        intervalMs: 10_000,
+        lastRunAt: 0,
+        immediate: false,
+        createdAt: new Date(5_000).toISOString(),
+      })],
+    },
+  }, { 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")
+}
+
+{
+  const sessionID = "status-empty"
+  const h = harness({ [sessionID]: { jobs: [] } })
+  await h.handlers.statusLoop("/work", {}, sessionID)
+  assert.deepEqual(h.toasts, [[{}, "No active loop jobs.", "warning"]])
+  assert.match(h.messages[0][2], /No active loop jobs\./)
+}
+
+{
+  const lines = Array.from({ length: 82 }, (_, index) => `line-${index + 1}`).join("\n")
+  const h = harness({}, { readFile: async () => lines })
+  await h.handlers.logsLoop("/project", {}, "logs")
+  const text = h.messages[0][2]
+  assert.doesNotMatch(text, /line-1\n/)
+  assert.doesNotMatch(text, /line-2\n/)
+  assert.match(text, /line-3/)
+  assert.match(text, /line-82/)
+}
+
+{
+  const h = harness()
+  await h.handlers.logsLoop("/project", {}, "missing-logs")
+  assert.equal(h.messages[0][2], "OpenCode loop logs:\nNo loop log found.")
+}
+
+{
+  const h = harness()
+  await h.handlers.helpLoop({}, "help")
+  const text = h.messages[0][2]
+  assert.match(text, /OpenCode Loop help:/)
+  assert.match(text, /\/loop-goal finish the feature/)
+  assert.match(text, /\/loop-doctor \| \/loop-init \| \/loop-export/)
+}
+
+{
+  const sessionID = "now"
+  const client = {}
+  const h = harness({ [sessionID]: { jobs: [loopJob("a", { paused: true, lastRunAt: 999 }), loopJob("b", { paused: true, lastRunAt: 888 })] } })
+  await h.handlers.runNow("/work", client, sessionID, "b")
+  const jobs = h.states.get(sessionID).jobs
+  assert.equal(jobs[0].lastRunAt, 999)
+  assert.equal(jobs[0].paused, true)
+  assert.equal(jobs[0].runNowRequestedAt, undefined)
+  assert.equal(jobs[1].lastRunAt, 0)
+  assert.equal(jobs[1].paused, false)
+  assert.equal(jobs[1].runNowRequestedAt, 10_000)
+  assert.deepEqual(h.toasts, [[client, "Marked 1 loop job(s) due now.", "success"]])
+  assert.deepEqual(h.due, [["/work", client, sessionID]], "run-now must defer dispatch through the idle-safe scheduler")
+  assert.equal(h.forcedRuns.length, 0, "run-now must not start a model turn re-entrantly inside command.execute.before")
+}
+
+{
+  const sessionID = "now-missing"
+  const h = harness({ [sessionID]: { jobs: [loopJob("a")] } })
+  await h.handlers.runNow("/work", {}, sessionID, "missing")
+  assert.deepEqual(h.toasts, [[{}, "Marked 0 loop job(s) due now.", "warning"]])
+  assert.equal(h.due.length, 0, "missing run-now target must not schedule unrelated jobs")
+  assert.equal(h.forcedRuns.length, 0, "missing run-now target must not run unrelated due jobs")
+}
+
+{
+  const sessionID = "doctor"
+  const h = harness({ [sessionID]: { jobs: [loopJob("a"), loopJob("b")] } })
+  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, /- node: v-test/)
+  assert.match(text, /- platform: test-platform/)
+  assert.match(text, /experimental goal smoke test/)
+}
+
+{
+  const sessionID = "init"
+  const client = {}
+  const h = harness()
+  await h.handlers.initLoop("/repo", client, sessionID, "notes.md")
+  assert.equal(h.fileWrites.length, 1)
+  assert.equal(h.fileWrites[0][0], path.resolve("/repo", "notes.md"))
+  assert.match(h.fileWrites[0][1], /^# Progress/)
+  assert.equal(h.fileWrites[0][2], "utf8")
+  assert.deepEqual(h.toasts, [[client, "Created notes.md.", "success"]])
+  assert.deepEqual(h.logs, [["/repo", "init", { sessionID, file: "notes.md" }]])
+}
+
+{
+  const target = path.resolve("/repo", "progress.md")
+  const client = {}
+  const h = harness({}, { existingPaths: [target] })
+  await h.handlers.initLoop("/repo", client, "init-existing", "")
+  assert.equal(h.fileWrites.length, 0)
+  assert.deepEqual(h.toasts, [[client, "progress.md already exists.", "warning"]])
+  assert.equal(h.logs.length, 0)
+}
+
+{
+  const sessionID = "export"
+  const h = harness({ [sessionID]: { version: 1, jobs: [loopJob("a")] } })
+  await h.handlers.exportLoop("/repo", {}, sessionID)
+  const text = h.messages[0][2]
+  assert.match(text, /OpenCode loop state export:/)
+  assert.match(text, /```json/)
+  assert.match(text, /"id": "a"/)
+}
+
+console.log("loop command handler tests passed")

package/scripts/loop-registration-test.mjs

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict"
+import { createLoopRegistration, normalizeActionForCompare, sameLoopDefinition } from "../src/source/opencode/loop-registration.js"
+
+function harness(initialStates = {}, overrides = {}) {
+  const states = new Map(Object.entries(initialStates).map(([key, value]) => [key, structuredClone(value)]))
+  const writes = []
+  const snapshots = []
+  const due = []
+  const idle = []
+  const toasts = []
+  const messages = []
+  const logs = []
+  const contexts = new Map(Object.entries(overrides.contexts || {}))
+
+  const { addLoop } = createLoopRegistration({
+    snapshotPaths: async (directory, files) => {
+      snapshots.push({ directory, files: [...files] })
+      return Object.fromEntries(files.map((file) => [file, `snapshot:${file}`]))
+    },
+    scheduleDueWork: async (...args) => { due.push(args) },
+    scheduleIdleWork: (...args) => { idle.push(args) },
+    toast: async (...args) => { toasts.push(args) },
+    say: async (...args) => { messages.push(args) },
+    readState: async (_directory, sessionID) => structuredClone(states.get(sessionID) || { jobs: [] }),
+    writeState: async (_directory, sessionID, state) => {
+      const copy = structuredClone(state)
+      states.set(sessionID, copy)
+      writes.push({ sessionID, state: copy })
+    },
+    appendLoopLog: async (...args) => { logs.push(args) },
+    normalizedModelRef: (value) => value ? `normalized:${value}` : undefined,
+    getSessionExecutionContext: (sessionID) => contexts.get(sessionID),
+    defaultActiveGuardMs: overrides.defaultActiveGuardMs ?? 45_000,
+  })
+
+  return { addLoop, states, writes, snapshots, due, idle, toasts, messages, logs }
+}
+
+assert.throws(() => createLoopRegistration({}), /snapshotPaths/)
+assert.throws(() => createLoopRegistration({ snapshotPaths() {} }), /scheduleDueWork/)
+assert.equal(normalizeActionForCompare("  hello\n   world  "), "hello world")
+assert.equal(sameLoopDefinition(
+  { name: "dev", intervalMs: 1000, action: "hello   world", kind: "prompt", promptFile: "" },
+  { name: "dev", intervalMs: 1000, action: " hello world ", kind: "prompt", promptFile: undefined },
+), true)
+assert.equal(sameLoopDefinition({ name: "a" }, { name: "b" }), false)
+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")
+  assert.equal(h.writes.length, 0)
+  assert.equal(h.due.length, 0)
+  assert.equal(h.idle.length, 0)
+  assert.equal(h.logs.length, 0)
+  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/)
+}
+
+{
+  const sessionID = "basic"
+  const client = { id: "client" }
+  const h = harness({}, { contexts: { [sessionID]: { agent: "builder", model: "ctx-model" } } })
+  await h.addLoop("/work", client, sessionID, "0s do useful work")
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.name, "default")
+  assert.equal(job.action, "do useful work")
+  assert.equal(job.agent, "builder")
+  assert.equal(job.model, "ctx-model")
+  assert.equal(job.activeRecoveryMs, 45_000)
+  assert.equal(job.immediate, true)
+  assert.equal(h.writes.length, 1)
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.idle, [["/work", client, sessionID]])
+  assert.equal(h.toasts[0][2], "success")
+  assert.match(h.toasts[0][1], /^Loop added:/)
+  assert.equal(h.logs[0][1], "add")
+}
+
+{
+  const sessionID = "replace"
+  const h = harness({}, { contexts: { [sessionID]: { agent: "build" } } })
+  await h.addLoop("/work", {}, sessionID, "0s first action")
+  await h.addLoop("/work", {}, sessionID, "0s second action")
+  const jobs = h.states.get(sessionID).jobs
+  assert.equal(jobs.length, 1)
+  assert.equal(jobs[0].name, "default")
+  assert.equal(jobs[0].action, "second action")
+  assert.match(h.toasts.at(-1)[1], /^Loop replaced:/)
+  assert.equal(h.logs.at(-1)[1], "replace")
+}
+
+{
+  const sessionID = "multi"
+  const h = harness({ [sessionID]: { jobs: [{ id: "old", name: "default", intervalMs: 0, action: "old" }] } })
+  await h.addLoop("/work", {}, sessionID, "0s --multi another action")
+  const jobs = h.states.get(sessionID).jobs
+  assert.equal(jobs.length, 2)
+  assert.equal(jobs[0].id, "old")
+  assert.equal(jobs[1].action, "another action")
+  assert.equal(jobs[1].multi, true)
+  assert.match(h.toasts.at(-1)[1], /^Loop added:/)
+}
+
+{
+  const sessionID = "watch"
+  const h = harness()
+  await h.addLoop("/repo", {}, sessionID, '0s --watch "src" --watch package.json inspect changes')
+  const job = h.states.get(sessionID).jobs[0]
+  assert.deepEqual(job.watchPaths, ["src", "package.json"])
+  assert.deepEqual(job.watchSnapshot, { src: "snapshot:src", "package.json": "snapshot:package.json" })
+  assert.deepEqual(h.snapshots, [{ directory: "/repo", files: ["src", "package.json"] }])
+}
+
+{
+  const sessionID = "goal"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "ship the feature", {
+    intervalMs: 0,
+    kind: "goal",
+    name: "goal",
+    immediate: true,
+    safe: true,
+    askNever: true,
+    noOverlap: true,
+    goalStatus: "active",
+  })
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.kind, "goal")
+  assert.equal(job.goalStatus, "active")
+  assert.equal(job.safe, true)
+  assert.equal(job.askNever, true)
+  assert.equal(job.noOverlap, true)
+  assert.equal(job.agent, "build")
+  assert.equal(job.activeRecoveryMs, 180_000)
+}
+
+{
+  const sessionID = "long-interval"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "5m recurring work")
+  assert.equal(h.states.get(sessionID).jobs[0].activeRecoveryMs, 90_000)
+}
+
+{
+  const sessionID = "explicit-owner"
+  const h = harness({}, { contexts: { [sessionID]: { agent: "context-agent", model: "context-model" } } })
+  await h.addLoop("/work", {}, sessionID, "explicit work", { intervalMs: 0, agent: "special-agent", model: "model-x" })
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.agent, "special-agent")
+  assert.equal(job.model, "normalized:model-x")
+}
+
+{
+  const sessionID = "testfix-action"
+  const defaults = {
+    intervalMs: 0,
+    name: "testfix",
+    safe: true,
+    askNever: true,
+    verifyCommand: "npm test",
+    testfixPreset: true,
+    action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test",
+  }
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "pnpm test", defaults)
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.verifyCommand, "pnpm test")
+  assert.equal(job.action, "Run the project tests. Fix failures. Re-run the tests. Test command hint: pnpm test")
+}
+
+{
+  const sessionID = "testfix-verify"
+  const defaults = {
+    intervalMs: 0,
+    name: "testfix",
+    safe: true,
+    askNever: true,
+    verifyCommand: "npm test",
+    testfixPreset: true,
+    action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test",
+  }
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, '--verify "pnpm test"', defaults)
+  const job = h.states.get(sessionID).jobs[0]
+  assert.equal(job.verifyCommand, "pnpm test")
+  assert.equal(job.action, "Run the project tests. Fix failures. Re-run the tests. Test command hint: pnpm test")
+}
+
+{
+  const sessionID = "dry-run"
+  const client = {}
+  const h = harness()
+  await h.addLoop("/work", client, sessionID, "0s --dry-run inspect only")
+  assert.equal(h.writes.length, 0)
+  assert.equal(h.due.length, 0)
+  assert.equal(h.idle.length, 0)
+  assert.equal(h.logs.length, 0)
+  assert.equal(h.toasts.length, 1)
+  assert.equal(h.toasts[0][2], "info")
+  assert.match(h.toasts[0][1], /^Loop dry run:/)
+  assert.equal(h.messages.length, 1)
+  assert.match(h.messages[0][2], /OpenCode loop dry run:/)
+  assert.match(h.messages[0][2], /"action": "inspect only"/)
+}
+
+{
+  const sessionID = "no-now"
+  const h = harness()
+  await h.addLoop("/work", {}, sessionID, "1m --no-now later")
+  assert.equal(h.states.get(sessionID).jobs[0].immediate, false)
+  assert.equal(h.idle.length, 0)
+  assert.equal(h.due.length, 1)
+}
+
+console.log("loop registration tests passed")