@bybrawe/opencode-loop 0.5.36 → 0.5.38

package/scripts/session-status-test.mjs

@@ -157,6 +157,36 @@ try {
     completion = "unknown"
   }
 
+  {
+    const sessionID = "concurrent-recovery-log-dedupe"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-dedupe", job: { id: "job-dedupe", name: "dedupe" }, startedAt: 1_000 })
+    completion = "completed"
+    let releaseStatus
+    const gate = new Promise((resolve) => { releaseStatus = resolve })
+    let calls = 0
+    const client = {
+      session: {
+        status: async () => {
+          calls += 1
+          await gate
+          return { data: { [sessionID]: { type: "busy" } } }
+        },
+      },
+    }
+    const before = logs.filter((entry) => entry[1] === "status-message-complete-recovery" && entry[2]?.sessionID === sessionID).length
+    const pending = Array.from({ length: 20 }, () => runtime.sessionStatusType(client, sessionID, "/repo"))
+    await Promise.resolve()
+    assert.equal(calls, 20, "all concurrent status reads should be in flight before release")
+    releaseStatus()
+    assert.deepEqual(await Promise.all(pending), Array(20).fill("idle"))
+    const after = logs.filter((entry) => entry[1] === "status-message-complete-recovery" && entry[2]?.sessionID === sessionID).length
+    assert.equal(after - before, 1, "one active run must emit at most one copy of the same stale-recovery diagnostic")
+    activeRuns.delete(sessionID)
+    completion = "unknown"
+  }
+
   {
     const sessionID = "retry-remains-owned"
     track(sessionID)

package/scripts/smoke-test.mjs

@@ -86,6 +86,27 @@ try {
     "opencode_loop_goal_progress",
   ])
 
+  const dedicatedGoalRoot = path.join(directory, ".opencode", "goals")
+  await fs.mkdir(dedicatedGoalRoot, { recursive: true })
+  await fs.writeFile(path.join(dedicatedGoalRoot, "dedicated.json"), JSON.stringify({
+    schemaVersion: 1,
+    id: "dedicated-goal",
+    sessionID,
+    status: "active",
+  }), "utf8")
+  for (const [name, args] of [
+    ["opencode_loop_goal_blocked", { reason: "Need deploy", needed: "User deploy" }],
+    ["opencode_loop_goal_progress", { summary: "Checked status", next: "Continue" }],
+    ["opencode_loop_goal_complete", { summary: "Done", evidence: "tests passed" }],
+  ]) {
+    const guarded = await hooks.tool[name].execute(args, { directory, sessionID })
+    assert.equal(guarded.title, "Dedicated Goal owns lifecycle")
+    assert.match(guarded.output, /opencode_loop_goal_\*/)
+    assert.match(guarded.output, /opencode_goal_wait_for_user/)
+    assert.match(guarded.output, /opencode_goal_blocked/)
+  }
+  await fs.rm(dedicatedGoalRoot, { recursive: true, force: true })
+
   const output = { parts: [{ type: "text", text: "original command body" }] }
   await hooks["command.execute.before"]({
     command: "loop-goal",

package/scripts/v2-command-adapter-test.mjs

@@ -56,7 +56,13 @@ async function waitFor(predicate, description, timeoutMs = 2_000) {
   await adapter.start()
   const result = await adapter.command({ sessionID: "ses_adapter", command: "/review", arguments: "--quick" })
   assert.deepEqual(result, { accepted: true })
-  assert.deepEqual(commands, [{ sessionID: "ses_adapter", command: "review", arguments: "--quick" }])
+  assert.deepEqual(commands, [{
+    sessionID: "ses_adapter",
+    name: "review",
+    command: "review",
+    arguments: "--quick",
+    text: "--quick",
+  }])
   assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
   await adapter.dispose()
 }
@@ -103,7 +109,13 @@ async function waitFor(predicate, description, timeoutMs = 2_000) {
     })
     events.push({ directory, payload: { type: "session.idle", properties: { sessionID } } })
     await waitFor(() => commands.length === 1, "V2 command dispatch")
-    assert.deepEqual(commands[0], { sessionID, command: "review", arguments: "--quick" })
+    assert.deepEqual(commands[0], {
+      sessionID,
+      name: "review",
+      command: "review",
+      arguments: "--quick",
+      text: "--quick",
+    })
   } finally {
     await cleanup?.()
     await rm(directory, { recursive: true, force: true })

package/scripts/v2-plugin-sentinel-test.mjs

@@ -3,7 +3,7 @@ import plugin, {
   OPENCODE_LOOP_V2_COMMANDS,
   OPENCODE_LOOP_V2_PLUGIN_ID,
 } from "../src/source/opencode2/experimental.js"
-import { parseOpenCode2LoopCommandText } from "../src/source/opencode2/commands.js"
+import { parseOpenCode2LoopCommandText, registerOpenCode2LoopCommands } from "../src/source/opencode2/commands.js"
 import {
   OPENCODE_LOOP_V2_COMMAND_SOURCE,
   OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
@@ -77,13 +77,43 @@ for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
   assert.equal(command?.description, definition.description)
 }
 
-let missingDraftUpdateFailed = false
+let missingDraftMutationFailed = false
 try {
   await registered({})
 } catch (error) {
-  missingDraftUpdateFailed = /command draft\.update capability is unavailable/.test(String(error))
+  missingDraftMutationFailed = /neither add\(\) nor update\(\)/.test(String(error))
 }
-assert.equal(missingDraftUpdateFailed, true)
+assert.equal(missingDraftMutationFailed, true)
+
+const addedCommands = new Map()
+const executedCommands = []
+registerOpenCode2LoopCommands({
+  add(definition) {
+    addedCommands.set(definition.name, definition)
+  },
+}, {
+  execute: async (event) => {
+    executedCommands.push(structuredClone(event))
+  },
+})
+assert.deepEqual([...addedCommands.keys()], Object.keys(OPENCODE_LOOP_V2_COMMANDS))
+for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+  const command = addedCommands.get(name)
+  assert.equal(command?.name, name)
+  assert.equal(command?.description, definition.description)
+  assert.equal(typeof command?.execute, "function")
+}
+await addedCommands.get("loop").execute({
+  sessionID: "ses_2_0_11",
+  prompt: { text: "devam et" },
+  delivery: "steer",
+})
+assert.deepEqual(executedCommands, [{
+  name: "loop",
+  sessionID: "ses_2_0_11",
+  arguments: "devam et",
+  delivery: "steer",
+}])
 
 assert.deepEqual(inspectOpenCode2Context(currentContext), {
   commandTransform: true,
@@ -98,6 +128,7 @@ assert.deepEqual(inspectOpenCode2Context(currentContext), {
 assert.deepEqual(inspectOpenCode2CommandDraft(currentDraft), {
   list: true,
   get: true,
+  add: false,
   update: true,
   remove: true,
 })

package/scripts/v2-runtime-adapter-test.mjs

@@ -164,6 +164,8 @@ async function verifyTwoTurnLoop({ directory, sessionID, events, prompts, native
     sessionID: "ses_v2",
     noReply: true,
     parts: [{ type: "text", text: "OpenCode loop status:\nNo active loop jobs." }],
+    text: "OpenCode loop status:\nNo active loop jobs.",
+    resume: false,
     agent: "build",
     model: { providerID: "canary", modelID: "canary" },
   })
@@ -301,6 +303,79 @@ async function verifyTwoTurnLoop({ directory, sessionID, events, prompts, native
   }
 }
 
+{
+  const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-2-0-11-command-add-"))
+  const sessionID = "ses_v2_2_0_11_add"
+  const events = controllableStream()
+  const prompts = []
+  const commands = new Map()
+  const ctx = {
+    app: { name: "opencode", version: "2.0.11", channel: "latest" },
+    location: { directory },
+    command: {
+      transform: async (callback) => {
+        await callback({
+          add(definition) {
+            commands.set(definition.name, definition)
+          },
+        })
+        return { dispose: async () => {} }
+      },
+    },
+    event: {
+      // OpenCode 2.0.11 exposes subscribe(options), so Function.length === 1
+      // even though it returns an AsyncIterable rather than accepting a callback.
+      subscribe(options) {
+        assert.equal(options, undefined)
+        return events.stream
+      },
+    },
+    session: {
+      prompt: async (input) => {
+        prompts.push(structuredClone(input))
+        return { accepted: true }
+      },
+    },
+  }
+
+  const cleanup = await OpenCodeLoopV2ExperimentalPlugin.setup(ctx)
+  try {
+    assert.ok(commands.has("loop"), "OpenCode 2.0.11 add() command editor must receive /loop")
+    await commands.get("loop").execute({
+      sessionID,
+      prompt: { text: "0s --max-runs 2 continue exact 2.0.11 command path" },
+      delivery: "steer",
+    })
+
+    const stateFile = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+    await waitFor(async () => {
+      try { return JSON.parse(await readFile(stateFile, "utf8")).jobs?.length === 1 } catch { return false }
+    }, "OpenCode 2.0.11 direct command state creation")
+
+    await waitFor(() => prompts.length === 1, "OpenCode 2.0.11 direct command first local-kick dispatch")
+    assert.equal(prompts[0].sessionID, sessionID)
+    assert.match(prompts[0].text || "", /continue exact 2\.0\.11 command path/)
+
+    events.push({
+      type: "session.status",
+      location: { directory },
+      data: { sessionID, status: { type: "busy" } },
+    })
+    events.push({
+      type: "session.status",
+      location: { directory },
+      data: { sessionID, status: { type: "idle" } },
+    })
+    await waitFor(() => prompts.length === 2, "OpenCode 2.0.11 second dispatch from native idle status")
+    const state = JSON.parse(await readFile(stateFile, "utf8"))
+    assert.equal(state.jobs[0].runCount, 2)
+    assert.equal(state.jobs[0].enabled, false)
+  } finally {
+    await cleanup?.()
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
 {
   let commandDisposals = 0
   const result = await OpenCodeLoopV2ExperimentalPlugin.setup({