@bybrawe/opencode-loop 0.5.28 → 0.5.30

package/scripts/session-activity-test.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict"
+import {
+  activeToolCalls,
+  sessionParents,
+  sessionStatuses,
+  sessionStatusSeenAt,
+  hasActiveToolCalls,
+  markToolCallActive,
+  markToolCallFinished,
+  updateSessionRelationship,
+  updateSessionRelationshipFromEvent,
+  isDescendantSession,
+  hasBusyDescendant,
+  refreshSessionRelationships,
+  updateToolActivityFromEvent,
+  clearSessionActivity,
+} from "../src/source/runtime/session-activity.js"
+
+const parentID = "ses_parent"
+const childID = "ses_child"
+const listedChildID = "ses_listed_child"
+
+for (const sessionID of [parentID, childID, listedChildID]) clearSessionActivity(sessionID)
+
+updateSessionRelationship({ id: childID, parentID })
+assert.equal(sessionParents.get(childID), parentID)
+assert.equal(isDescendantSession(childID, parentID), true)
+assert.equal(isDescendantSession(parentID, childID), false)
+
+markToolCallActive({ sessionID: childID, callID: "call_1" })
+assert.equal(hasActiveToolCalls(childID), true)
+assert.equal(sessionStatuses.get(childID), "busy")
+assert.ok((sessionStatusSeenAt.get(childID) || 0) > 0)
+assert.equal(hasBusyDescendant(parentID), true)
+
+markToolCallFinished({ sessionID: childID, callID: "call_1" })
+assert.equal(hasActiveToolCalls(childID), false)
+sessionStatuses.set(childID, "idle")
+assert.equal(hasBusyDescendant(parentID), false)
+
+updateToolActivityFromEvent({
+  type: "message.part.updated",
+  properties: {
+    part: {
+      type: "tool",
+      sessionID: childID,
+      callID: "call_2",
+      id: "part_2",
+      state: { status: "running" },
+    },
+  },
+})
+assert.equal(activeToolCalls.get(childID)?.has("call_2"), true)
+
+updateToolActivityFromEvent({
+  type: "message.part.updated",
+  properties: {
+    part: {
+      type: "tool",
+      sessionID: childID,
+      callID: "call_2",
+      id: "part_2",
+      state: { status: "completed" },
+    },
+  },
+})
+assert.equal(hasActiveToolCalls(childID), false)
+
+await refreshSessionRelationships({
+  session: {
+    list: async () => [{ id: listedChildID, parentID }],
+  },
+}, "/tmp/opencode-loop-session-activity")
+assert.equal(sessionParents.get(listedChildID), parentID)
+
+updateSessionRelationshipFromEvent({
+  type: "session.deleted",
+  properties: { info: { id: listedChildID, parentID } },
+})
+assert.equal(sessionParents.has(listedChildID), false)
+
+sessionParents.set(parentID, childID)
+sessionParents.set(childID, parentID)
+assert.equal(isDescendantSession(parentID, "ses_missing"), false)
+sessionParents.delete(parentID)
+
+clearSessionActivity(childID)
+assert.equal(activeToolCalls.has(childID), false)
+assert.equal(sessionParents.has(childID), false)
+assert.equal(sessionStatuses.has(childID), false)
+assert.equal(sessionStatusSeenAt.has(childID), false)
+clearSessionActivity(parentID)
+clearSessionActivity(listedChildID)
+
+console.log("session activity runtime tests passed")

package/scripts/session-status-test.mjs

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict"
+import {
+  clearSessionActivity,
+  markToolCallActive,
+  markToolCallFinished,
+  sessionParents,
+  sessionStatuses,
+  sessionStatusSeenAt,
+  updateSessionRelationship,
+} from "../src/source/runtime/session-activity.js"
+import { createSessionStatusRuntime } from "../src/source/runtime/session-status.js"
+
+assert.throws(() => createSessionStatusRuntime({}), /activeRuns Map/)
+
+const activeRuns = new Map()
+const logs = []
+let clock = 100_000
+let completion = "unknown"
+const runtime = createSessionStatusRuntime({
+  activeRuns,
+  now: () => clock,
+  sessionStatusCacheMs: 0,
+  appendLoopLog: async (...args) => { logs.push(args) },
+  activeRunCompletionFromMessages: async () => completion,
+})
+
+const ids = new Set()
+const track = (...values) => {
+  for (const value of values) if (typeof value === "string") ids.add(value)
+}
+
+try {
+  {
+    const sessionID = "event-idle"
+    track(sessionID)
+    const result = runtime.updateSessionStatusFromEvent({ type: "session.idle", properties: { sessionID } })
+    assert.deepEqual(result, { sessionID, idle: true })
+    assert.equal(sessionStatuses.get(sessionID), "idle")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+
+    clock++
+    assert.deepEqual(
+      runtime.updateSessionStatusFromEvent({ type: "session.status", properties: { sessionID, status: { type: "retry" } } }),
+      { sessionID, idle: false },
+    )
+    assert.equal(sessionStatuses.get(sessionID), "retry")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+    assert.equal(runtime.updateSessionStatusFromEvent({ type: "message.updated", properties: { sessionID } }), undefined)
+    assert.equal(runtime.updateSessionStatusFromEvent({ type: "session.idle", properties: {} }), undefined)
+  }
+
+  {
+    const sessionID = "mark-clear"
+    track(sessionID)
+    assert.equal(runtime.markSessionStatus(sessionID, "busy", 1234), true)
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    assert.equal(sessionStatusSeenAt.get(sessionID), 1234)
+    assert.equal(runtime.markSessionStatus(undefined, "busy"), false)
+    runtime.clearSessionStatus(sessionID)
+    assert.equal(sessionStatuses.has(sessionID), false)
+    assert.equal(sessionStatusSeenAt.has(sessionID), false)
+  }
+
+  {
+    const sessionID = "sdk-data-wrapper"
+    track(sessionID)
+    const calls = []
+    const client = {
+      session: {
+        status: async (args) => {
+          calls.push(args)
+          return { data: { [sessionID]: { type: "busy" } } }
+        },
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, sessionID, "/repo")
+    assert.deepEqual(live, { type: "busy", source: "sdk" })
+    assert.deepEqual(calls, [{ query: { directory: "/repo" } }])
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    assert.equal(sessionStatusSeenAt.get(sessionID), clock)
+  }
+
+  {
+    const sessionID = "sdk-error-fallback"
+    track(sessionID)
+    const calls = []
+    const client = {
+      session: {
+        status: async (args) => {
+          calls.push(args)
+          if (calls.length === 1) return { error: { message: "unsupported query shape" } }
+          return { data: { [sessionID]: { type: "idle" } } }
+        },
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, sessionID, "/repo")
+    assert.deepEqual(live, { type: "idle", source: "sdk" })
+    assert.equal(calls.length, 2)
+    assert.deepEqual(calls[0], { query: { directory: "/repo" } })
+    assert.deepEqual(calls[1], { directory: "/repo" })
+  }
+
+  {
+    const parentID = "parent-busy-child"
+    const childID = "child-busy"
+    track(parentID, childID)
+    updateSessionRelationship({ id: childID, parentID })
+    const client = {
+      session: {
+        status: async () => ({ data: { [childID]: { type: "busy" } } }),
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, parentID, "/repo")
+    assert.deepEqual(live, { type: "busy", source: "descendant" })
+    assert.equal(sessionParents.get(childID), parentID)
+    assert.equal(sessionStatuses.get(childID), "busy")
+  }
+
+  {
+    const parentID = "parent-finished-child"
+    const childID = "child-finished"
+    track(parentID, childID)
+    updateSessionRelationship({ id: childID, parentID })
+    runtime.markSessionStatus(childID, "busy")
+    const client = {
+      session: {
+        status: async () => ({ data: { [parentID]: { type: "idle" } } }),
+      },
+    }
+    const live = await runtime.readLiveSessionStatus(client, parentID, "/repo")
+    assert.deepEqual(live, { type: "idle", source: "sdk" })
+    assert.equal(sessionStatuses.get(childID), "idle", "omitted descendant must be cleared to idle")
+  }
+
+  {
+    const sessionID = "active-tool"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    markToolCallActive({ sessionID, callID: "tool-1" })
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "idle" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "busy")
+    assert.equal(sessionStatuses.get(sessionID), "busy")
+    markToolCallFinished({ sessionID, callID: "tool-1" })
+  }
+
+  {
+    const sessionID = "message-complete-recovery"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-1", job: { id: "job-1", name: "dev" }, startedAt: 1_000 })
+    completion = "completed"
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "busy" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    assert.equal(sessionStatuses.get(sessionID), "idle")
+    assert.deepEqual(logs.at(-1), ["/repo", "status-message-complete-recovery", { sessionID, job: "dev", startedAt: 1_000 }])
+    activeRuns.delete(sessionID)
+    completion = "unknown"
+  }
+
+  {
+    const sessionID = "stale-recovery"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "job-2", job: { id: "job-2" }, startedAt: 1_000 })
+    completion = "unknown"
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "retry" } } }) } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    assert.deepEqual(logs.at(-1), ["/repo", "status-stale-recovery", { sessionID, job: "job-2", startedAt: 1_000 }])
+    activeRuns.delete(sessionID)
+  }
+
+  {
+    const sessionID = "fallback-fresh"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "fresh", job: {}, startedAt: clock - 1_000 })
+    const client = { session: { status: async () => { throw new Error("offline") } } }
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "busy")
+    activeRuns.set(sessionID, { jobId: "stale", job: {}, startedAt: clock - 60_000 })
+    runtime.clearSessionStatus(sessionID)
+    assert.equal(await runtime.sessionStatusType(client, sessionID, "/repo"), "idle")
+    activeRuns.delete(sessionID)
+  }
+
+  {
+    const sessionID = "finalize-basic"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    const active = { jobId: "job", job: {}, startedAt: clock - 100 }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), true)
+
+    markToolCallActive({ sessionID, callID: "tool-finalize" })
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", {}, sessionID, active), false)
+    markToolCallFinished({ sessionID, callID: "tool-finalize" })
+
+    runtime.markSessionStatus(sessionID, "idle", clock + 1)
+    const client = { session: { status: async () => { throw new Error("status unavailable") } } }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", client, sessionID, active, { requireIdle: true }), true)
+  }
+
+  {
+    const sessionID = "force-stale"
+    track(sessionID)
+    runtime.clearSessionStatus(sessionID)
+    activeRuns.set(sessionID, { jobId: "force", job: {}, startedAt: clock - 60_000 })
+    completion = "unknown"
+    const active = activeRuns.get(sessionID)
+    const client = { session: { status: async () => ({ data: { [sessionID]: { type: "busy" } } }) } }
+    assert.equal(await runtime.canFinalizeActiveRun("/repo", client, sessionID, active, { requireIdle: true, forceStale: true }), true)
+    activeRuns.delete(sessionID)
+  }
+
+  assert.equal(await runtime.readLiveSessionStatus({}, "missing-client", "/repo"), undefined)
+  assert.equal(await runtime.sessionIsIdle({ session: { status: async () => ({ data: {} }) } }, "unlisted", "/repo"), true)
+
+  console.log("session status tests passed")
+} finally {
+  activeRuns.clear()
+  for (const sessionID of ids) clearSessionActivity(sessionID)
+}

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

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import OpenCodeLoopV2ExperimentalPlugin from "../src/source/opencode2/experimental.js"
+import { createOpenCode2RuntimeAdapter } from "../src/source/opencode2/runtime-adapter.js"
+
+function controllableStream() {
+  const queued = []
+  const waiting = []
+  let closed = false
+  const iterator = {
+    next() {
+      if (queued.length) return Promise.resolve({ done: false, value: queued.shift() })
+      if (closed) return Promise.resolve({ done: true, value: undefined })
+      return new Promise((resolve) => waiting.push(resolve))
+    },
+    async return() {
+      closed = true
+      while (waiting.length) waiting.shift()({ done: true, value: undefined })
+      return { done: true, value: undefined }
+    },
+  }
+  return {
+    stream: { [Symbol.asyncIterator]: () => iterator },
+    push(value) {
+      if (waiting.length) waiting.shift()({ done: false, value })
+      else queued.push(value)
+    },
+  }
+}
+
+async function waitFor(predicate, description, timeoutMs = 2_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (await predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  throw new Error(`timed out waiting for ${description}`)
+}
+
+{
+  const events = controllableStream()
+  const commands = []
+  const ctx = {
+    event: { subscribe: () => events.stream },
+    session: {
+      prompt: async () => ({ accepted: true }),
+      command: async (request) => {
+        commands.push(structuredClone(request))
+        return { accepted: true }
+      },
+    },
+  }
+  const adapter = createOpenCode2RuntimeAdapter(ctx)
+  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.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
+  await adapter.dispose()
+}
+
+{
+  const events = controllableStream()
+  const adapter = createOpenCode2RuntimeAdapter({
+    event: { subscribe: () => events.stream },
+    session: { prompt: async () => ({ accepted: true }) },
+  })
+  await adapter.start()
+  await assert.rejects(adapter.command({ sessionID: "ses_adapter", command: "review" }), /session\.command capability is unavailable/)
+  await adapter.dispose()
+}
+
+{
+  const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-command-wiring-"))
+  const sessionID = "ses_v2_command_wiring"
+  const events = controllableStream()
+  const commands = []
+  const ctx = {
+    command: { transform: async () => ({ dispose: async () => {} }) },
+    event: { subscribe: () => events.stream },
+    session: {
+      prompt: async () => ({ accepted: true }),
+      command: async (request) => {
+        commands.push(structuredClone(request))
+        return { accepted: true }
+      },
+    },
+  }
+  const cleanup = await OpenCodeLoopV2ExperimentalPlugin.setup(ctx)
+  try {
+    events.push({
+      directory,
+      payload: {
+        type: "command.executed",
+        properties: {
+          sessionID,
+          name: "loop",
+          arguments: '0s --max-runs 1 --command "/review --quick"',
+        },
+      },
+    })
+    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" })
+  } finally {
+    await cleanup?.()
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
+console.log("OpenCode 2 command adapter tests passed")

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

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict"
+import { mkdtemp, readFile, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { createOpenCode2PromptRuntime } from "../src/source/opencode2/prompt-runtime.js"
+
+const directory = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-command-"))
+const sessionID = "ses_v2_command_runtime"
+const prompts = []
+const commands = []
+const runtime = createOpenCode2PromptRuntime({
+  prompt: async (request) => { prompts.push(request) },
+  command: async (request) => { commands.push(request); return { accepted: true } },
+})
+
+async function readState() {
+  const file = path.join(directory, ".opencode", "opencode-loop", `${sessionID}.json`)
+  return JSON.parse(await readFile(file, "utf8"))
+}
+
+try {
+  const added = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --max-runs 2 --command "/review --quick"',
+  })
+  assert.equal(added.accepted, true)
+  assert.equal(added.job.kind, "command")
+  assert.equal(added.job.action, "/review --quick")
+
+  const first = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(first.dispatched, true)
+  assert.equal(first.kind, "command")
+  assert.deepEqual(first.request, { sessionID, command: "review", arguments: "--quick" })
+  assert.deepEqual(commands, [{ sessionID, command: "review", arguments: "--quick" }])
+  assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false, "OpenCode 2 id is a msg_ message ID, never the command name")
+  assert.equal(prompts.length, 0)
+  let state = await readState()
+  assert.equal(state.jobs[0].runCount, 1)
+  assert.equal(state.jobs[0].enabled, true)
+
+  const second = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(second.dispatched, true)
+  assert.deepEqual(commands[1], { sessionID, command: "review", arguments: "--quick" })
+  state = await readState()
+  assert.equal(state.jobs[0].runCount, 2)
+  assert.equal(state.jobs[0].enabled, false)
+
+  const third = await runtime.onEvent({ kind: "session", action: "idle", sessionID, directory })
+  assert.equal(third.dispatched, false)
+  assert.equal(commands.length, 2)
+
+  const compact = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --command "/compact"',
+  })
+  assert.equal(compact.accepted, false)
+  assert.ok(compact.blockers.includes("kind"), "shared actionKind keeps /compact on the dedicated compact path")
+
+  const shell = await runtime.onEvent({
+    kind: "command",
+    action: "executed",
+    name: "loop",
+    sessionID,
+    directory,
+    arguments: '0s --shell "echo hello"',
+  })
+  assert.equal(shell.accepted, false)
+  assert.ok(shell.blockers.includes("kind"), "shell actions remain unsupported because OpenCode 2 plugin ctx has no session.shell")
+
+  const noCommandRuntime = createOpenCode2PromptRuntime({ prompt: async () => {} })
+  try {
+    const unavailable = await noCommandRuntime.onEvent({
+      kind: "command",
+      action: "executed",
+      name: "loop",
+      sessionID: "ses_no_command",
+      directory,
+      arguments: '0s --command "/review"',
+    })
+    assert.equal(unavailable.accepted, false)
+    assert.ok(unavailable.blockers.includes("command-capability"))
+  } finally {
+    await noCommandRuntime.dispose()
+  }
+
+  console.log("OpenCode 2 command runtime tests passed")
+} finally {
+  await runtime.dispose()
+  await rm(directory, { recursive: true, force: true })
+}

package/scripts/v2-diagnostics-test.mjs

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict"
+import { createOpenCode2DiagnosticsRuntime, OPENCODE_LOOP_V2_HELP_TEXT } from "../src/source/opencode2/diagnostics.js"
+
+const prompts = []
+const reads = []
+const state = {
+  version: 1,
+  jobs: [{ id: "job_export", name: "exported", runCount: 2, paused: false }],
+}
+const runtime = createOpenCode2DiagnosticsRuntime({
+  prompt: async (request) => { prompts.push(request) },
+  readState: async (directory, sessionID) => {
+    reads.push([directory, sessionID])
+    return structuredClone(state)
+  },
+  runtimeVersion: "v-test",
+  runtimePlatform: "test-platform",
+})
+
+const unrelated = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-status", sessionID: "ses", directory: "/work" })
+assert.equal(unrelated.handled, false)
+assert.equal(prompts.length, 0)
+
+const missing = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-export", sessionID: "ses" })
+assert.equal(missing.handled, false)
+assert.equal(missing.reason, "missing-scope")
+assert.equal(prompts.length, 0)
+
+const exported = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-export", sessionID: "ses", directory: "/work" })
+assert.equal(exported.handled, true)
+assert.equal(exported.accepted, true)
+assert.deepEqual(reads, [["/work", "ses"]])
+assert.equal(prompts.length, 1)
+assert.equal(prompts[0].sessionID, "ses")
+assert.equal(prompts[0].noReply, true)
+assert.match(prompts[0].text, /^OpenCode loop state export:\n```json\n/)
+assert.match(prompts[0].text, /"name": "exported"/)
+assert.match(prompts[0].text, /"runCount": 2/)
+assert.match(prompts[0].text, /\n```$/)
+
+const help = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-help", sessionID: "ses", directory: "/work" })
+assert.equal(help.handled, true)
+assert.equal(help.accepted, true)
+assert.equal(reads.length, 1, "loop-help must not read or mutate Loop state")
+assert.equal(prompts.length, 2)
+assert.equal(prompts[1].noReply, true)
+assert.equal(prompts[1].text, OPENCODE_LOOP_V2_HELP_TEXT)
+assert.match(prompts[1].text, /^OpenCode Loop V2 experimental help:/)
+assert.match(prompts[1].text, /\/loop-status/)
+assert.match(prompts[1].text, /\/loop-export/)
+assert.match(prompts[1].text, /\/loop-doctor/)
+assert.match(prompts[1].text, /does not yet claim full stable-plugin parity/)
+assert.doesNotMatch(prompts[1].text, /\/loop-goal/)
+assert.doesNotMatch(prompts[1].text, /--verify/)
+
+const doctor = await runtime.onEvent({ kind: "command", action: "executed", name: "loop-doctor", sessionID: "ses", directory: "/work" })
+assert.equal(doctor.handled, true)
+assert.equal(doctor.accepted, true)
+assert.equal(reads.length, 2, "loop-doctor may read state but must not mutate it")
+assert.equal(prompts.length, 3)
+assert.equal(prompts[2].noReply, true)
+assert.match(prompts[2].text, /^OpenCode Loop V2 doctor:/)
+assert.match(prompts[2].text, /- plugin: bybrawe\.opencode-loop\.v2\.experimental/)
+assert.match(prompts[2].text, /- project directory: \/work/)
+assert.match(prompts[2].text, /- state directory:/)
+assert.match(prompts[2].text, /- active jobs: 1/)
+assert.match(prompts[2].text, /- node: v-test/)
+assert.match(prompts[2].text, /- platform: test-platform/)
+assert.match(prompts[2].text, /- full stable parity: not claimed/)
+assert.match(prompts[2].text, /- smoke test: \/loop 0s --max-runs 1/)
+
+assert.throws(() => createOpenCode2DiagnosticsRuntime({}), /requires prompt\(\)/)
+
+console.log("OpenCode 2 diagnostics contract passed")

package/scripts/v2-host-contract-test.mjs

@@ -4,6 +4,7 @@ import { createOpenCode2HostContract } from "../src/source/opencode2/host-contra
 let listener
 let unsubscribeCalls = 0
 const prompts = []
+const commands = []
 const events = []
 const host = createOpenCode2HostContract({
   directory: "/project",
@@ -15,10 +16,15 @@ const host = createOpenCode2HostContract({
     prompts.push(request)
     return { accepted: true }
   },
+  sendCommand: async (request) => {
+    commands.push(request)
+    return { accepted: true, kind: "command" }
+  },
   onEvent: async (event, runtime) => events.push({ event, runtime }),
 })
 
 await assert.rejects(host.prompt({ sessionID: "ses_a", text: "early" }), /not started/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "review" }), /not started/)
 assert.equal(await host.start(), true)
 assert.equal(await host.start(), false)
 assert.equal(typeof listener, "function")
@@ -37,8 +43,28 @@ assert.equal(prompts[0].sessionID, "ses_a")
 assert.equal(prompts[0].text, "continue")
 assert.equal(prompts[0].runtime, runtime)
 
+const commandResult = await host.command({ sessionID: "ses_a", command: "/review", arguments: "--quick" })
+assert.deepEqual(commandResult, { accepted: true, kind: "command" })
+assert.equal(commands.length, 1)
+assert.equal(commands[0].sessionID, "ses_a")
+assert.equal(commands[0].command, "review")
+assert.equal(Object.prototype.hasOwnProperty.call(commands[0], "id"), false)
+assert.equal(commands[0].arguments, "--quick")
+assert.equal(commands[0].runtime, runtime)
+
 await assert.rejects(host.prompt({ sessionID: "", text: "missing" }), /session ID/)
 await assert.rejects(host.prompt({ sessionID: "ses_a", text: "   " }), /requires text/)
+await assert.rejects(host.command({ sessionID: "", command: "review" }), /session ID/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "" }), /requires a command name/)
+await assert.rejects(host.command({ sessionID: "ses_a", id: "review" }), /requires a command name/)
+
+const promptOnly = createOpenCode2HostContract({
+  subscribe: async (_callback) => ({ unsubscribe: async () => {} }),
+  sendPrompt: async () => ({ accepted: true }),
+})
+await promptOnly.start()
+await assert.rejects(promptOnly.command({ sessionID: "ses_a", command: "review" }), /session\.command capability is unavailable/)
+await promptOnly.dispose()
 
 await listener({
   directory: "/project",
@@ -48,6 +74,7 @@ assert.equal(host.isHostDisposed(), true)
 assert.deepEqual(host.runtimeManager.entries(), [])
 assert.ok(events.some(({ event }) => event.kind === "server" && event.action === "disposed"))
 await assert.rejects(host.prompt({ sessionID: "ses_a", text: "late" }), /unavailable/)
+await assert.rejects(host.command({ sessionID: "ses_a", command: "review" }), /unavailable/)
 
 assert.equal(await host.dispose(), true)
 assert.equal(await host.dispose(), false)