@bybrawe/opencode-loop 0.5.28 → 0.5.30

package/scripts/executor-runtime-test.mjs

@@ -0,0 +1,310 @@
+import assert from "node:assert/strict"
+import { createLoopExecutor } from "../src/source/runtime/executor.js"
+import { clearSessionActivity } from "../src/source/runtime/session-activity.js"
+
+const noopWorkspace = {
+  buildPrompt: async () => "prompt",
+  ensureBranch: async (_directory, job) => job,
+  watchChanged: async () => false,
+  untilReached: async () => false,
+  createCheckpoint: async () => {},
+}
+const noopGoalPolicy = {
+  runGoalChecks: async (_directory, _sessionID, job) => job,
+  applyGoalNoProgressGuard: async (_directory, _client, _sessionID, job) => job,
+}
+const noopScheduler = {
+  rememberSession: () => {},
+  scheduleDueWork: async () => {},
+}
+
+assert.throws(() => createLoopExecutor({}), /workspace\.buildPrompt/)
+assert.throws(() => createLoopExecutor({ workspace: noopWorkspace }), /goalPolicy\.runGoalChecks/)
+assert.throws(() => createLoopExecutor({ workspace: noopWorkspace, goalPolicy: noopGoalPolicy }), /scheduler\.rememberSession/)
+
+let clock = 1_000_000
+const states = new Map()
+const writes = []
+const schedules = []
+const remembered = []
+const toasts = []
+const logs = []
+const notifications = []
+const guards = []
+const sdkCalls = []
+const fireCalls = []
+const compactions = []
+const checkpoints = []
+const branchCalls = []
+const goalChecks = []
+const progressGuards = []
+
+function stateKey(directory, sessionID) {
+  return `${directory}:${sessionID}`
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value))
+}
+
+const workspace = {
+  buildPrompt: async (_directory, job) => `BUILT:${job.action}`,
+  ensureBranch: async (_directory, job, _client, sessionID) => {
+    branchCalls.push([sessionID, job.id])
+    return { ...job, branchDone: true }
+  },
+  watchChanged: async (_directory, job) => Boolean(job.testWatchChanged),
+  untilReached: async (_directory, job) => Boolean(job.testUntilReached),
+  createCheckpoint: async (...args) => { checkpoints.push(args) },
+}
+const goalPolicy = {
+  runGoalChecks: async (_directory, sessionID, job) => {
+    goalChecks.push([sessionID, job.id])
+    return { ...job, goalChecksRan: true }
+  },
+  applyGoalNoProgressGuard: async (_directory, _client, sessionID, job) => {
+    progressGuards.push([sessionID, job.id])
+    return { ...job, noProgressGuardRan: true }
+  },
+}
+const scheduler = {
+  rememberSession: (...args) => { remembered.push(args) },
+  scheduleDueWork: async (...args) => { schedules.push(args) },
+}
+
+const executor = createLoopExecutor({
+  workspace,
+  goalPolicy,
+  scheduler,
+  now: () => clock,
+  readState: async (directory, sessionID) => clone(states.get(stateKey(directory, sessionID)) || { jobs: [] }),
+  writeState: async (directory, sessionID, state) => {
+    const copy = clone(state)
+    states.set(stateKey(directory, sessionID), copy)
+    writes.push([directory, sessionID, copy])
+  },
+  pathExists: async (file) => String(file).includes("STOP-NOW"),
+  appendLoopLog: async (...args) => { logs.push(args) },
+  runShellCommand: async (command) => command.includes("fail")
+    ? { code: 1, stdout: "bad", stderr: "err" }
+    : { code: 0, stdout: "ok", stderr: "" },
+  notifyJob: async (...args) => { notifications.push(args) },
+  toast: async (...args) => { toasts.push(args) },
+  log: async (...args) => { logs.push(["host", ...args]) },
+  sdkCall: async (...args) => { sdkCalls.push(args); return {} },
+  normalizedModelRef: () => undefined,
+  compactTuiCommandName: (command) => command === "compact" ? "compact" : undefined,
+  fireSdk: (...args) => { fireCalls.push(args); return Promise.resolve({ ok: true }) },
+  guardLoopOwnedUserMessage: (sessionID) => { guards.push(sessionID) },
+  writeGoalReport: async (...args) => { logs.push(["goal-report", ...args]) },
+  dangerousShell: (command) => /danger/.test(command),
+  compactSession: async (...args) => { compactions.push(args); return true },
+  activeRunCompletionFromMessages: async () => "unknown",
+  activeGuardMs: 45_000,
+  busyRetryMs: 5_000,
+})
+
+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: "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 },
+  ],
+}
+assert.deepEqual(executor.dueJobs(dueState).map((job) => job.id), ["watch-yes", "interval"])
+assert.deepEqual(executor.dueJobs(dueState, true).map((job) => job.id), ["watch-no", "watch-yes", "interval"])
+assert.deepEqual(executor.dueJobs({
+  jobs: [
+    { id: "natural", enabled: true, paused: false, intervalMs: 0, runCount: 0, maxRuns: 0 },
+    { id: "target", enabled: true, paused: false, intervalMs: 600_000, lastRunAt: clock, runCount: 0, maxRuns: 0, runNowRequestedAt: clock },
+  ],
+}).map((job) => job.id), ["target", "natural"], "run-now target must outrank an earlier naturally-due job")
+
+const client = {
+  session: {
+    status: async () => ({ data: {} }),
+    command: async () => ({ data: {} }),
+    shell: async () => ({ data: {} }),
+    prompt: async () => ({ data: {} }),
+    abort: async () => ({ data: {} }),
+  },
+}
+
+const blockedShell = await executor.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.match(toasts.at(-1)[1], /Blocked dangerous shell command/)
+
+const commandResult = await executor.fireAction("/repo", client, "command-session", {
+  id: "command-job",
+  action: "/review --quick",
+  agent: "build",
+})
+assert.deepEqual(commandResult, { startsAssistantTurn: true })
+assert.equal(sdkCalls.length, 1)
+assert.equal(guards.at(-1), "command-session")
+
+const compactResult = await executor.fireAction("/repo", client, "compact-session", {
+  id: "compact-job",
+  action: "/compact",
+})
+assert.equal(compactResult.startsAssistantTurn, true)
+assert.equal(compactResult.compaction, true)
+assert.equal(compactions.length, 1)
+
+const promptResult = await executor.fireAction("/repo", client, "prompt-session", {
+  id: "prompt-job",
+  action: "continue work",
+  enabled: true,
+})
+assert.equal(promptResult.startsAssistantTurn, true)
+assert.ok(promptResult.dispatch instanceof Promise)
+assert.equal(fireCalls.at(-1)[1], "session.prompt")
+const promptBody = fireCalls.at(-1)[3].body
+assert.match(promptBody.parts[0].text, /AUTONOMOUS OPENCODE LOOP ITERATION/)
+assert.match(promptBody.parts[0].text, /BUILT:continue work/)
+
+const sessionID = "run-session"
+const directory = "/repo"
+states.set(stateKey(directory, sessionID), {
+  jobs: [{
+    id: "run-job",
+    name: "run-job",
+    action: "implement feature",
+    enabled: true,
+    paused: false,
+    intervalMs: 0,
+    runCount: 0,
+    maxRuns: 0,
+    maxRuntimeMs: 0,
+    timeoutMs: 0,
+    safe: false,
+  }],
+})
+await executor.maybeRunDueJobs(directory, client, sessionID)
+assert.equal(remembered.at(-1)[2], sessionID)
+const active = executor.getActiveRun(sessionID)
+assert.equal(active.jobId, "run-job")
+assert.equal(active.job.runCount, 1)
+assert.equal(executor.isRunLocked(sessionID), false)
+assert.equal(states.get(stateKey(directory, sessionID)).jobs[0].runCount, 1)
+assert.ok(schedules.some((call) => call[2] === sessionID && call[3] === 5_000))
+assert.ok(branchCalls.some((call) => call[0] === sessionID && call[1] === "run-job"))
+
+clock += 1_000
+const finalized = await executor.finalizeActiveRun(directory, client, sessionID)
+assert.equal(finalized, true)
+assert.equal(executor.getActiveRun(sessionID), undefined)
+assert.equal(states.get(stateKey(directory, sessionID)).jobs[0].lastFinishedAt, clock)
+assert.ok(checkpoints.some((call) => call[2].id === "run-job"))
+
+const runNowSession = "run-now-session"
+states.set(stateKey(directory, runNowSession), {
+  jobs: [
+    {
+      id: "natural-job",
+      name: "natural",
+      action: "natural work",
+      enabled: true,
+      paused: false,
+      intervalMs: 0,
+      runCount: 0,
+      maxRuns: 0,
+      maxRuntimeMs: 0,
+      timeoutMs: 0,
+    },
+    {
+      id: "target-job",
+      name: "target",
+      action: "target work",
+      enabled: true,
+      paused: false,
+      intervalMs: 600_000,
+      immediate: false,
+      createdAt: new Date(clock).toISOString(),
+      lastRunAt: 0,
+      runCount: 0,
+      maxRuns: 0,
+      maxRuntimeMs: 0,
+      timeoutMs: 0,
+      runNowRequestedAt: clock,
+    },
+  ],
+})
+executor.markSessionStatus(runNowSession, "busy", clock)
+await executor.maybeRunDueJobs(directory, client, runNowSession)
+assert.equal(executor.getActiveRun(runNowSession), undefined)
+let runNowState = states.get(stateKey(directory, runNowSession))
+assert.equal(runNowState.jobs.find((job) => job.id === "target-job").runNowRequestedAt, clock, "busy retry must preserve the targeted run-now request")
+assert.ok(schedules.some((call) => call[2] === runNowSession && call[3] === 5_000))
+
+executor.markSessionStatus(runNowSession, "idle", clock)
+await executor.maybeRunDueJobs(directory, client, runNowSession)
+const runNowActive = executor.getActiveRun(runNowSession)
+assert.equal(runNowActive.jobId, "target-job", "targeted run-now job must dispatch before the natural due job")
+runNowState = states.get(stateKey(directory, runNowSession))
+assert.equal(runNowState.jobs.find((job) => job.id === "target-job").runNowRequestedAt, undefined, "run-now request must be consumed when the target dispatch starts")
+assert.equal(runNowState.jobs.find((job) => job.id === "target-job").runCount, 1)
+assert.equal(runNowState.jobs.find((job) => job.id === "natural-job").runCount, 0)
+clock += 1_000
+assert.equal(await executor.finalizeActiveRun(directory, client, runNowSession), true)
+
+const goalSession = "goal-session"
+states.set(stateKey(directory, goalSession), {
+  jobs: [{
+    id: "goal-job",
+    name: "goal-job",
+    kind: "goal",
+    goal: "finish",
+    goalStatus: "active",
+    action: "finish",
+    enabled: true,
+    paused: false,
+    intervalMs: 0,
+    runCount: 0,
+    maxRuns: 0,
+    maxRuntimeMs: 0,
+    timeoutMs: 0,
+  }],
+})
+await executor.maybeRunDueJobs(directory, client, goalSession)
+clock += 1_000
+await executor.finalizeActiveRun(directory, client, goalSession)
+assert.deepEqual(goalChecks.at(-1), [goalSession, "goal-job"])
+assert.deepEqual(progressGuards.at(-1), [goalSession, "goal-job"])
+const finalizedGoal = states.get(stateKey(directory, goalSession)).jobs[0]
+assert.equal(finalizedGoal.goalChecksRan, true)
+assert.equal(finalizedGoal.noProgressGuardRan, true)
+
+const stopSession = "stop-session"
+states.set(stateKey(directory, stopSession), {
+  jobs: [{
+    id: "stop-job",
+    enabled: true,
+    paused: false,
+    intervalMs: 0,
+    maxRuns: 0,
+    maxRuntimeMs: 0,
+    stopFile: "STOP-NOW",
+  }],
+})
+await executor.maybeRunDueJobs(directory, client, stopSession)
+assert.equal(states.get(stateKey(directory, stopSession)).jobs.length, 0)
+assert.ok(notifications.some((call) => call[1]?.id === "stop-job" && call[2] === "stop_file"))
+
+executor.disposeSession(sessionID)
+executor.disposeSession(runNowSession)
+executor.disposeSession(goalSession)
+executor.disposeSession(stopSession)
+for (const id of ["shell-session", "command-session", "compact-session", "prompt-session", sessionID, runNowSession, goalSession, stopSession]) {
+  clearSessionActivity(id)
+}
+
+assert.ok(writes.length > 0)
+console.log("executor runtime tests passed")

package/scripts/fixtures/opencode2-real-adapter-probe.js

@@ -0,0 +1,70 @@
+import { writeFile } from "node:fs/promises"
+
+const COMMAND_SENTINEL = "__opencode_loop_missing_command_probe__"
+
+export default {
+  id: "bybrawe.opencode-loop.v2.real-adapter-probe",
+  async setup(ctx) {
+    const pluginURL = process.env.OPENCODE_LOOP_V2_PLUGIN_URL
+    const marker = process.env.OPENCODE_LOOP_V2_MARKER
+    if (!pluginURL) throw new Error("OPENCODE_LOOP_V2_PLUGIN_URL is required")
+    if (!marker) throw new Error("OPENCODE_LOOP_V2_MARKER is required")
+
+    const module = await import(pluginURL)
+    const plugin = module.default
+    if (!plugin || typeof plugin.setup !== "function") throw new Error("experimental V2 plugin has no setup function")
+    const cleanup = await plugin.setup(ctx)
+
+    const sessionMethods = Object.fromEntries(
+      Object.keys(ctx?.session || {})
+        .sort()
+        .map((key) => [key, typeof ctx.session[key]]),
+    )
+
+    let commandFieldProbe = { matched: false, error: "session command probe did not run" }
+    if (typeof ctx?.session?.create === "function" && typeof ctx?.session?.command === "function") {
+      try {
+        const created = await ctx.session.create()
+        const sessionID = String(created?.id || created?.data?.id || created?.sessionID || "")
+        if (!sessionID) throw new Error("session.create returned no session id")
+        try {
+          await ctx.session.command({ sessionID, command: COMMAND_SENTINEL })
+          commandFieldProbe = {
+            matched: false,
+            sessionID,
+            error: "missing command unexpectedly succeeded",
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          commandFieldProbe = {
+            matched: message.includes(`Command not found: ${COMMAND_SENTINEL}`),
+            sessionID,
+            error: message,
+          }
+        }
+      } catch (error) {
+        commandFieldProbe = {
+          matched: false,
+          error: error instanceof Error ? error.message : String(error),
+        }
+      }
+    }
+
+    await writeFile(marker, JSON.stringify({
+      id: plugin.id,
+      activated: true,
+      commandTransform: typeof ctx?.command?.transform === "function",
+      eventSubscribe: typeof ctx?.event?.subscribe === "function",
+      sessionPrompt: typeof ctx?.session?.prompt === "function",
+      sessionCommand: typeof ctx?.session?.command === "function",
+      sessionShell: typeof ctx?.session?.shell === "function",
+      sessionMethods,
+      commandFieldProbe,
+      toolTransform: typeof ctx?.tool?.transform === "function",
+    }, null, 2), "utf8")
+
+    return async () => {
+      if (typeof cleanup === "function") await cleanup()
+    }
+  },
+}

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

@@ -0,0 +1,236 @@
+import assert from "node:assert/strict"
+import { createGoalCommandHandlers } from "../src/source/opencode/goal-commands.js"
+
+function goal(id, overrides = {}) {
+  return {
+    id,
+    name: id,
+    kind: "goal",
+    goalStatus: "active",
+    enabled: true,
+    paused: false,
+    action: `Goal ${id}`,
+    runCount: 0,
+    noProgressCount: 0,
+    ...overrides,
+  }
+}
+
+function harness(initialStates = {}) {
+  const states = new Map(Object.entries(initialStates).map(([key, value]) => [key, structuredClone(value)]))
+  const writes = []
+  const due = []
+  const idle = []
+  const toasts = []
+  const messages = []
+  const addLoopCalls = []
+  const completeCalls = []
+  const blockedCalls = []
+
+  const handlers = createGoalCommandHandlers({
+    addLoop: async (...args) => { addLoopCalls.push(args); return "added" },
+    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 })
+    },
+    setGoalComplete: async (...args) => { completeCalls.push(args); return { ok: true, message: "completed" } },
+    setGoalBlocked: async (...args) => { blockedCalls.push(args); return { ok: true, message: "blocked" } },
+  })
+
+  return { handlers, states, writes, due, idle, toasts, messages, addLoopCalls, completeCalls, blockedCalls }
+}
+
+assert.throws(() => createGoalCommandHandlers({}), /addLoop/)
+assert.throws(() => createGoalCommandHandlers({ addLoop() {} }), /scheduleDueWork/)
+
+{
+  const sessionID = "status"
+  const h = harness({
+    [sessionID]: {
+      jobs: [
+        { id: "regular", kind: "prompt" },
+        goal("g1", {
+          name: "feature",
+          action: "Ship feature",
+          runCount: 2,
+          goalChecks: ["npm test", "npm run check"],
+          goalAcceptance: ["works"],
+          goalProgress: [{ summary: "patched" }],
+          maxNoProgress: 3,
+          noProgressCount: 1,
+          goalCompletionRejectedReason: "not yet",
+        }),
+        goal("g2", { goalStatus: "blocked", paused: true, action: "Fix blocker" }),
+      ],
+    },
+  })
+  await h.handlers.statusGoal("/work", { id: "client" }, sessionID)
+  assert.equal(h.writes.length, 0)
+  assert.deepEqual(h.toasts, [[{ id: "client" }, "2 experimental goal(s).", "info"]])
+  assert.equal(h.messages.length, 1)
+  const text = h.messages[0][2]
+  assert.match(text, /OpenCode Loop experimental goal status:/)
+  assert.match(text, /1\. g1 \(feature\): active \| turns=2 \| objective=Ship feature/)
+  assert.match(text, /checks=2/)
+  assert.match(text, /acceptance=1/)
+  assert.match(text, /progress=1/)
+  assert.match(text, /no-progress=1\/3/)
+  assert.match(text, /completion-rejected/)
+  assert.match(text, /2\. g2 \(g2\): blocked/)
+}
+
+{
+  const sessionID = "empty-status"
+  const h = harness({ [sessionID]: { jobs: [{ id: "regular", kind: "prompt" }] } })
+  await h.handlers.statusGoal("/work", {}, sessionID)
+  assert.deepEqual(h.toasts, [[{}, "No experimental goal jobs.", "warning"]])
+  assert.match(h.messages[0][2], /No experimental goal jobs\./)
+}
+
+{
+  const sessionID = "pause"
+  const client = {}
+  const h = harness({
+    [sessionID]: {
+      jobs: [goal("g1"), goal("g2"), { id: "regular", kind: "prompt", paused: false }],
+    },
+  })
+  await h.handlers.pauseGoal("/work", client, sessionID, "g1")
+  const jobs = h.states.get(sessionID).jobs
+  assert.equal(jobs[0].paused, true)
+  assert.equal(jobs[1].paused, false)
+  assert.equal(jobs[2].paused, false)
+  assert.equal(h.writes.length, 1)
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.toasts, [[client, "Paused 1 experimental goal(s).", "success"]])
+}
+
+{
+  const sessionID = "resume"
+  const client = {}
+  const h = harness({
+    [sessionID]: {
+      jobs: [goal("g1", {
+        goalStatus: "blocked",
+        enabled: false,
+        paused: true,
+        lastRunAt: 99,
+        noProgressCount: 3,
+        goalNoProgressReason: "stalled",
+        goalInterruptedReason: "interrupted",
+      })],
+    },
+  })
+  await h.handlers.resumeGoal("/work", client, sessionID, "g1")
+  const resumed = h.states.get(sessionID).jobs[0]
+  assert.equal(resumed.goalStatus, "active")
+  assert.equal(resumed.enabled, true)
+  assert.equal(resumed.paused, false)
+  assert.equal(resumed.lastRunAt, 0)
+  assert.equal(resumed.noProgressCount, 0)
+  assert.equal(resumed.goalNoProgressReason, "")
+  assert.equal(resumed.goalInterruptedReason, "")
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.idle, [["/work", client, sessionID]])
+  assert.deepEqual(h.toasts, [[client, "Resumed 1 experimental goal(s).", "success"]])
+}
+
+{
+  const sessionID = "resume-missing"
+  const client = {}
+  const h = harness({ [sessionID]: { jobs: [goal("g1")] } })
+  await h.handlers.resumeGoal("/work", client, sessionID, "missing")
+  assert.equal(h.due.length, 0)
+  assert.equal(h.idle.length, 0)
+  assert.deepEqual(h.toasts, [[client, "Resumed 0 experimental goal(s).", "warning"]])
+}
+
+{
+  const sessionID = "clear"
+  const client = {}
+  const h = harness({
+    [sessionID]: {
+      jobs: [goal("g1"), { id: "regular", kind: "prompt" }, goal("g2")],
+    },
+  })
+  await h.handlers.clearGoal("/work", client, sessionID, "")
+  assert.deepEqual(h.states.get(sessionID).jobs.map((job) => job.id), ["regular"])
+  assert.deepEqual(h.due, [["/work", client, sessionID]])
+  assert.deepEqual(h.toasts, [[client, "Cleared 2 experimental goal(s).", "success"]])
+}
+
+{
+  const sessionID = "clear-one"
+  const h = harness({ [sessionID]: { jobs: [goal("g1"), goal("g2")] } })
+  await h.handlers.clearGoal("/work", {}, sessionID, "g1")
+  assert.deepEqual(h.states.get(sessionID).jobs.map((job) => job.id), ["g2"])
+}
+
+{
+  const h = harness()
+  const client = {}
+  await h.handlers.completeGoalCommand("/work", client, "complete", " shipped ")
+  assert.deepEqual(h.completeCalls, [["/work", "complete", {
+    summary: "shipped",
+    evidence: "Marked complete by /loop-goal-done.",
+    manual: true,
+  }]])
+  assert.deepEqual(h.toasts, [[client, "completed", "success"]])
+
+  await h.handlers.completeGoalCommand("/work", client, "complete-default", "")
+  assert.equal(h.completeCalls[1][2].summary, "Goal manually marked complete.")
+}
+
+{
+  const h = harness()
+  const client = {}
+  await h.handlers.blockGoalCommand("/work", client, "blocked", " need token ")
+  assert.deepEqual(h.blockedCalls, [["/work", "blocked", {
+    reason: "need token",
+    needed: "User input or manual intervention.",
+  }]])
+  assert.deepEqual(h.toasts, [[client, "blocked", "warning"]])
+}
+
+{
+  const h = harness()
+  const client = {}
+  const result = await h.handlers.addGoal("/repo", client, "create", "finish the feature")
+  assert.equal(result, "added")
+  assert.equal(h.addLoopCalls.length, 1)
+  assert.equal(h.addLoopCalls[0][0], "/repo")
+  assert.equal(h.addLoopCalls[0][1], client)
+  assert.equal(h.addLoopCalls[0][2], "create")
+  assert.equal(h.addLoopCalls[0][3], "finish the feature")
+  assert.deepEqual(h.addLoopCalls[0][4], {
+    intervalMs: 0,
+    kind: "goal",
+    name: "goal",
+    immediate: true,
+    safe: true,
+    askNever: true,
+    noOverlap: true,
+    goalStatus: "active",
+  })
+}
+
+{
+  const sessionID = "subcommands"
+  const h = harness({ [sessionID]: { jobs: [goal("g1", { paused: false })] } })
+  await h.handlers.addGoal("/work", {}, sessionID, "pause g1")
+  assert.equal(h.states.get(sessionID).jobs[0].paused, true)
+
+  await h.handlers.addGoal("/work", {}, sessionID, "completed final summary")
+  assert.equal(h.completeCalls.at(-1)[2].summary, "final summary")
+
+  await h.handlers.addGoal("/work", {}, sessionID, "block waiting on user")
+  assert.equal(h.blockedCalls.at(-1)[2].reason, "waiting on user")
+}
+
+console.log("goal command handler tests passed")