@bybrawe/opencode-loop 0.5.26 → 0.5.28

package/scripts/opencode2-host-canary.mjs

@@ -0,0 +1,194 @@
+import { spawnSync } from "node:child_process"
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const pluginID = "bybrawe.opencode-loop.v2.experimental"
+const sentinelID = "bybrawe.opencode-loop.v2-canary-sentinel"
+
+function run(command, args, { cwd, env, allowFailure = false, timeout = 60_000 } = {}) {
+  const result = spawnSync(command, args, {
+    cwd,
+    env,
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+    timeout,
+    windowsHide: true,
+  })
+  if (result.error) throw result.error
+  if (!allowFailure && result.status !== 0) {
+    throw new Error([
+      `command failed (${result.status}): ${command} ${args.join(" ")}`,
+      String(result.stdout ?? ""),
+      String(result.stderr ?? ""),
+    ].filter(Boolean).join("\n"))
+  }
+  return result
+}
+
+function output(result) {
+  return `${String(result.stdout ?? "")}\n${String(result.stderr ?? "")}`.trim()
+}
+
+function parseJSONOutput(result, label) {
+  const text = String(result.stdout ?? "").trim()
+  try {
+    return JSON.parse(text)
+  } catch {
+    throw new Error(`${label} did not return JSON on stdout.\nstdout:\n${text}\nstderr:\n${String(result.stderr ?? "")}`)
+  }
+}
+
+function collectPluginIDs(value) {
+  if (Array.isArray(value)) return value.flatMap(collectPluginIDs)
+  if (typeof value === "string") return [value]
+  if (!value || typeof value !== "object") return []
+  const direct = [value.id, value.pluginID, value.name].filter((item) => typeof item === "string")
+  const nested = [value.data, value.plugin, value.plugins, value.items].flatMap((item) => collectPluginIDs(item))
+  return [...direct, ...nested]
+}
+
+function uniquePluginIDs(value) {
+  return [...new Set(collectPluginIDs(value))]
+}
+
+async function failureLog(env) {
+  const candidates = [
+    path.join(env.XDG_DATA_HOME, "opencode", "log", "opencode.log"),
+    path.join(env.XDG_STATE_HOME, "opencode", "log", "opencode.log"),
+  ]
+  for (const file of candidates) {
+    try {
+      const raw = await readFile(file, "utf8")
+      return raw.slice(-30_000)
+    } catch {}
+  }
+  return ""
+}
+
+async function main() {
+  const temp = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-host-"))
+  const project = path.join(temp, "project")
+  const home = path.join(temp, "home")
+  const config = path.join(home, ".config")
+  const data = path.join(home, ".local", "share")
+  const state = path.join(home, ".local", "state")
+  const pluginDirectory = path.join(project, ".opencode", "plugins")
+  const pluginFile = path.join(root, "src", "source", "opencode2", "experimental.js")
+  const adapterBridge = path.join(pluginDirectory, "opencode-loop-v2-canary.js")
+  const sentinelFile = path.join(pluginDirectory, "opencode-loop-v2-sentinel.js")
+  const sentinelURL = pathToFileURL(sentinelFile).href
+  const adapterURL = pathToFileURL(adapterBridge).href
+
+  await Promise.all([
+    mkdir(pluginDirectory, { recursive: true }),
+    mkdir(config, { recursive: true }),
+    mkdir(data, { recursive: true }),
+    mkdir(state, { recursive: true }),
+  ])
+
+  await writeFile(sentinelFile, `export default { id: ${JSON.stringify(sentinelID)}, server: async () => ({ id: ${JSON.stringify(sentinelID)} }) }\n`)
+  await writeFile(adapterBridge, `export { default } from ${JSON.stringify(pathToFileURL(pluginFile).href)}\n`)
+  await writeFile(path.join(project, "README.md"), "# OpenCode Loop V2 host canary\n")
+  await writeFile(path.join(project, "opencode.json"), `${JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    plugin: [
+      "./.opencode/plugins/opencode-loop-v2-sentinel.js",
+      "./.opencode/plugins/opencode-loop-v2-canary.js",
+    ],
+  }, null, 2)}\n`)
+
+  const env = {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: config,
+    XDG_DATA_HOME: data,
+    XDG_STATE_HOME: state,
+    OPENCODE_DB: path.join(data, "opencode", "opencode-loop-v2-canary.db"),
+    OPENCODE_LOG_LEVEL: "DEBUG",
+    OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: [sentinelURL, adapterURL] }),
+    CI: "true",
+  }
+
+  run("git", ["init", "-q"], { cwd: project, env })
+  run("git", ["config", "user.name", "OpenCode Loop Canary"], { cwd: project, env })
+  run("git", ["config", "user.email", "opencode-loop-canary@example.invalid"], { cwd: project, env })
+  run("git", ["add", "."], { cwd: project, env })
+  run("git", ["commit", "-q", "-m", "initialize canary workspace"], { cwd: project, env })
+
+  try {
+    run("opencode2", ["service", "stop"], { cwd: project, env, allowFailure: true, timeout: 15_000 })
+
+    const version = output(run("opencode2", ["--version"], { cwd: project, env, timeout: 30_000 }))
+    if (!version) throw new Error("opencode2 --version returned no output")
+
+    const health = output(run("opencode2", ["api", "get", "/api/health"], { cwd: project, env }))
+    if (!health) throw new Error("OpenCode 2 health API returned no output")
+
+    const plainPluginResult = run("opencode2", ["api", "get", "/api/plugin"], { cwd: project, env })
+    const plainResponse = parseJSONOutput(plainPluginResult, "GET /api/plugin from project cwd")
+    const plainIDs = uniquePluginIDs(plainResponse)
+
+    const pluginPath = `/api/plugin?location%5Bdirectory%5D=${encodeURIComponent(project)}`
+    const scopedPluginResult = run("opencode2", ["api", "get", pluginPath], { cwd: project, env })
+    const scopedResponse = parseJSONOutput(scopedPluginResult, "GET /api/plugin at project Location")
+
+    if (scopedResponse?._tag) {
+      throw new Error(`project-scoped /api/plugin rejected the Location: ${JSON.stringify(scopedResponse)}`)
+    }
+    if (scopedResponse?.location?.directory !== project) {
+      throw new Error(`OpenCode 2 resolved the wrong Location: expected ${project}, got ${String(scopedResponse?.location?.directory)}`)
+    }
+
+    const scopedIDs = uniquePluginIDs(scopedResponse)
+    const ids = [...new Set([...plainIDs, ...scopedIDs])]
+    if (!ids.includes(sentinelID)) {
+      throw new Error([
+        `OpenCode 2 did not activate the current-loader sentinel. Active IDs: ${JSON.stringify(ids)}`,
+        `Plain /api/plugin IDs: ${JSON.stringify(plainIDs)}`,
+        `Scoped /api/plugin IDs: ${JSON.stringify(scopedIDs)}`,
+        `Plain response: ${String(plainPluginResult.stdout ?? "")}`,
+        `Scoped response: ${String(scopedPluginResult.stdout ?? "")}`,
+      ].join("\n"))
+    }
+    if (!ids.includes(pluginID)) {
+      throw new Error([
+        `OpenCode 2 activated the current-loader sentinel but not ${pluginID}. Active IDs: ${JSON.stringify(ids)}`,
+        `Plain /api/plugin IDs: ${JSON.stringify(plainIDs)}`,
+        `Scoped /api/plugin IDs: ${JSON.stringify(scopedIDs)}`,
+        `Plain response: ${String(plainPluginResult.stdout ?? "")}`,
+        `Scoped response: ${String(scopedPluginResult.stdout ?? "")}`,
+      ].join("\n"))
+    }
+
+    console.log(JSON.stringify({
+      ok: true,
+      platform: process.platform,
+      node: process.version,
+      opencode2Version: version,
+      health,
+      projectDirectory: scopedResponse.location.directory,
+      sentinelID,
+      pluginID,
+      plainPluginIDs: plainIDs,
+      scopedPluginIDs: scopedIDs,
+      activePluginIDs: ids,
+    }, null, 2))
+  } catch (error) {
+    const logs = await failureLog(env)
+    if (logs) console.error(`OpenCode 2 server log tail:\n${logs}`)
+    throw error
+  } finally {
+    run("opencode2", ["service", "stop"], { cwd: project, env, allowFailure: true, timeout: 15_000 })
+    await rm(temp, { recursive: true, force: true })
+  }
+}
+
+main().catch((error) => {
+  console.error(error?.stack || error)
+  process.exitCode = 1
+})

package/scripts/runtime-contract-test.mjs

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict"
+import { createSessionRuntimeManager } from "../src/source/runtime/session-manager.js"
+import { createSessionRegistry } from "../src/source/runtime/session-registry.js"
+
+let clock = 1000
+const registry = createSessionRegistry({ now: () => clock, staleAfterMs: 100 })
+const first = {}
+const second = {}
+
+registry.observeExternal("ses_a", first)
+clock = 1050
+assert.equal(registry.peek("ses_a").seenAt, 1000)
+assert.equal(registry.entries()[0].seenAt, 1000)
+assert.deepEqual(registry.pruneStale(), [])
+
+registry.observeExternal("ses_a", first)
+assert.equal(registry.peek("ses_a").seenAt, 1050)
+clock = 1060
+registry.observeExternal("ses_a", second)
+assert.equal(registry.remove("ses_a", first), false)
+assert.equal(registry.peek("ses_a").runtime, second)
+
+clock = 1159
+assert.deepEqual(registry.pruneStale(), [])
+clock = 1160
+assert.deepEqual(registry.pruneStale(), ["ses_a"])
+assert.equal(registry.peek("ses_a"), undefined)
+
+{
+  const factoryCalls = []
+  const timerAPI = {}
+  const manager = createSessionRuntimeManager({
+    timerAPI,
+    runtimeFactory({ sessionID, timerAPI: injectedTimerAPI }) {
+      let active = true
+      const runtime = {
+        sessionID,
+        scope: { isActive: () => active },
+        dispose() { active = false; return true },
+      }
+      factoryCalls.push({ injectedTimerAPI, runtime })
+      return runtime
+    },
+  })
+
+  assert.throws(() => manager.observeExternal("   "), /session ID/)
+  assert.equal(factoryCalls.length, 0)
+  const runtime = manager.observeExternal("  ses_custom  ")
+  assert.equal(runtime.sessionID, "ses_custom")
+  assert.equal(factoryCalls[0].injectedTimerAPI, timerAPI)
+  assert.equal(manager.observeExternal("ses_custom"), runtime)
+  assert.equal(factoryCalls.length, 1)
+  runtime.dispose()
+  assert.notEqual(manager.observeExternal("ses_custom"), runtime)
+  assert.equal(factoryCalls.length, 2)
+  assert.equal(manager.dispose(), true)
+}
+
+console.log("OpenCode runtime contract test passed")

package/scripts/runtime-event-test.mjs

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict"
+import { normalizeOpenCodeEvent } from "../src/source/runtime/events.js"
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({ type: "session.idle", properties: { sessionID: "ses_idle" } }),
+  { kind: "session", action: "idle", sessionID: "ses_idle", directory: undefined },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    directory: "/workspace",
+    payload: { type: "session.status", properties: { sessionID: "ses_busy", status: { type: "busy" } } },
+  }),
+  { kind: "session", action: "status", sessionID: "ses_busy", directory: "/workspace", status: "busy" },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    type: "session.created",
+    properties: { info: { id: "ses_child", directory: "/project", parentID: "ses_parent" } },
+  }),
+  { kind: "session", action: "created", sessionID: "ses_child", directory: "/project", parentID: "ses_parent" },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    directory: "/workspace",
+    payload: {
+      type: "message.updated",
+      properties: {
+        info: {
+          id: "msg_done",
+          sessionID: "ses_message",
+          role: "assistant",
+          time: { created: 10, completed: 20 },
+          finish: "stop",
+        },
+      },
+    },
+  }),
+  {
+    kind: "message",
+    action: "updated",
+    sessionID: "ses_message",
+    directory: "/workspace",
+    messageID: "msg_done",
+    role: "assistant",
+    completedAt: 20,
+    finish: "stop",
+  },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({
+    type: "command.executed",
+    properties: { name: "loop-status", sessionID: "ses_command", arguments: "--json", messageID: "msg_command" },
+  }),
+  {
+    kind: "command",
+    action: "executed",
+    sessionID: "ses_command",
+    directory: undefined,
+    name: "loop-status",
+    arguments: "--json",
+    messageID: "msg_command",
+  },
+)
+
+assert.deepEqual(
+  normalizeOpenCodeEvent({ type: "server.instance.disposed", properties: { directory: "/old" } }),
+  { kind: "server", action: "disposed", directory: "/old" },
+)
+
+assert.equal(normalizeOpenCodeEvent({ type: "session.idle", properties: {} }), undefined)
+assert.equal(normalizeOpenCodeEvent({ payload: { properties: {} } }), undefined)
+assert.equal(normalizeOpenCodeEvent({ type: "file.edited", properties: { file: "x.txt" } }), undefined)
+
+console.log("OpenCode runtime event normalization test passed")

package/scripts/runtime-scope-test.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict"
+import { createRuntimeScope } from "../src/source/runtime/scope.js"
+import { createRuntimeTimers } from "../src/source/runtime/timers.js"
+
+const scope = createRuntimeScope()
+const events = []
+scope.track(() => events.push("first"))
+const release = scope.track(() => events.push("released"))
+scope.track(() => events.push("last"))
+assert.equal(release(), true)
+
+let calls = 0
+const guarded = scope.guard(() => ++calls)
+assert.equal(guarded(), 1)
+
+const cleared = []
+const api = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const timers = createRuntimeTimers(scope, api)
+const repeating = timers.interval(() => ++calls, 1)
+repeating.handle.callback()
+assert.equal(calls, 2)
+assert.equal(repeating.cancel(), true)
+repeating.handle.callback()
+assert.equal(calls, 2)
+const pending = timers.interval(() => ++calls, 1)
+
+assert.equal(scope.dispose("done"), true)
+assert.deepEqual(events, ["last", "first"])
+assert.equal(scope.signal.aborted, true)
+assert.equal(scope.isActive(), false)
+pending.handle.callback()
+assert.equal(calls, 2)
+assert.ok(cleared.includes(pending.handle))
+assert.equal(timers.timeout(() => {}, 1), undefined)
+assert.equal(scope.dispose(), false)
+assert.equal(guarded(), undefined)
+
+scope.track(() => events.push("late"))
+assert.deepEqual(events, ["last", "first", "late"])
+
+console.log("OpenCode runtime scope test passed")

package/scripts/session-manager-test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict"
+import { createSessionRuntimeManager } from "../src/source/runtime/session-manager.js"
+
+let clock = 1000
+const cleared = []
+const timerAPI = {
+  setTimeout(callback) { return { callback } },
+  clearTimeout(handle) { cleared.push(handle) },
+  setInterval(callback) { return { callback } },
+  clearInterval(handle) { cleared.push(handle) },
+}
+const manager = createSessionRuntimeManager({ now: () => clock, staleAfterMs: 100, timerAPI })
+
+const first = manager.observeExternal("ses_a")
+assert.equal(manager.entries()[0].seenAt, 1000)
+clock = 1050
+assert.equal(manager.peek("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1000, "reads must not refresh external activity")
+assert.equal(manager.observeExternal("ses_a"), first)
+assert.equal(manager.entries()[0].seenAt, 1050)
+
+first.dispose("replace")
+clock = 1060
+const second = manager.observeExternal("ses_a")
+assert.notEqual(second, first)
+assert.equal(manager.remove("ses_a", { expectedRuntime: first }), false)
+assert.equal(manager.peek("ses_a"), second)
+
+let calls = 0
+const pending = second.timers.interval(() => ++calls, 10)
+clock = 1159
+assert.deepEqual(manager.pruneStale(), [])
+clock = 1160
+assert.deepEqual(manager.pruneStale(), ["ses_a"])
+assert.equal(manager.peek("ses_a"), undefined)
+assert.ok(cleared.includes(pending.handle))
+pending.handle.callback()
+assert.equal(calls, 0)
+
+const third = manager.observeExternal("ses_a")
+assert.notEqual(third, second)
+assert.equal(manager.remove("ses_a", { expectedRuntime: third, reason: "done" }), true)
+assert.equal(third.scope.isActive(), false)
+assert.equal(manager.dispose(), true)
+assert.equal(manager.dispose(), false)
+assert.throws(() => manager.observeExternal("ses_b"), /disposed/)
+
+console.log("OpenCode session runtime manager test passed")

package/scripts/v2-event-bridge-test.mjs

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+
+const seen = []
+let listener
+let unsubscribeCalls = 0
+
+const bridge = createOpenCode2EventBridge({
+  directory: "/project",
+  onEvent: async (event, runtime) => seen.push({ event, runtime }),
+})
+
+await bridge.attach(async (callback) => {
+  listener = callback
+  return { unsubscribe: async () => { unsubscribeCalls += 1 } }
+})
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+const first = bridge.runtimeManager.peek("ses_a")
+assert.ok(first)
+assert.equal(first.scope.isActive(), true)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.status", properties: { sessionID: "ses_a", status: { type: "busy" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_a"), first)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_b", directory: "/project" } } },
+})
+const second = bridge.runtimeManager.peek("ses_b")
+assert.ok(second)
+assert.notEqual(second, first)
+
+await listener({
+  directory: "/other-project",
+  payload: { type: "session.status", properties: { sessionID: "ses_other", status: { type: "busy" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_other"), undefined)
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.deleted", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+assert.equal(bridge.runtimeManager.peek("ses_a"), undefined)
+assert.equal(first.scope.isActive(), false)
+assert.equal(second.scope.isActive(), true)
+
+await listener({
+  directory: "/project",
+  payload: { type: "server.instance.disposed", properties: { directory: "/project" } },
+})
+assert.equal(second.scope.isActive(), false)
+assert.deepEqual(bridge.runtimeManager.entries(), [])
+
+const seenCount = seen.length
+await listener({
+  directory: "/project",
+  payload: { type: "session.status", properties: { sessionID: "ses_late", status: { type: "busy" } } },
+})
+assert.equal(seen.length, seenCount)
+
+assert.equal(await bridge.dispose(), true)
+assert.equal(await bridge.dispose(), false)
+assert.equal(unsubscribeCalls, 1)
+
+console.log("OpenCode 2 event bridge lifecycle passed")

package/scripts/v2-event-stream-contract-test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const seen = []
+let subscribeArgs = -1
+let cleanupCalls = 0
+
+async function* stream() {
+  yield {
+    directory: "/project",
+    payload: {
+      type: "session.created",
+      properties: { info: { id: "ses_stream", directory: "/project" } },
+    },
+  }
+}
+
+const bridge = createOpenCode2EventBridge({
+  directory: "/project",
+  onEvent: async (event) => seen.push(event),
+})
+
+await bridge.attach(async (...args) => {
+  subscribeArgs = args.length
+  return { stream: stream(), dispose: async () => { cleanupCalls += 1 } }
+})
+
+for (let attempt = 0; attempt < 50 && seen.length === 0; attempt++) await delay(5)
+assert.equal(subscribeArgs, 0)
+assert.equal(seen[0]?.action, "created")
+assert.ok(bridge.runtimeManager.peek("ses_stream"))
+
+assert.equal(await bridge.dispose(), true)
+assert.equal(cleanupCalls, 1)
+assert.equal(bridge.runtimeManager.peek("ses_stream"), undefined)
+
+console.log("OpenCode 2 event stream contract passed")

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

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict"
+import { createOpenCode2HostContract } from "../src/source/opencode2/host-contract.js"
+
+let listener
+let unsubscribeCalls = 0
+const prompts = []
+const events = []
+const host = createOpenCode2HostContract({
+  directory: "/project",
+  subscribe: async (callback) => {
+    listener = callback
+    return { unsubscribe: async () => { unsubscribeCalls += 1 } }
+  },
+  sendPrompt: async (request) => {
+    prompts.push(request)
+    return { accepted: true }
+  },
+  onEvent: async (event, runtime) => events.push({ event, runtime }),
+})
+
+await assert.rejects(host.prompt({ sessionID: "ses_a", text: "early" }), /not started/)
+assert.equal(await host.start(), true)
+assert.equal(await host.start(), false)
+assert.equal(typeof listener, "function")
+
+await listener({
+  directory: "/project",
+  payload: { type: "session.created", properties: { info: { id: "ses_a", directory: "/project" } } },
+})
+const runtime = host.runtimeManager.peek("ses_a")
+assert.ok(runtime)
+
+const result = await host.prompt({ sessionID: "ses_a", text: "continue" })
+assert.deepEqual(result, { accepted: true })
+assert.equal(prompts.length, 1)
+assert.equal(prompts[0].sessionID, "ses_a")
+assert.equal(prompts[0].text, "continue")
+assert.equal(prompts[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 listener({
+  directory: "/project",
+  payload: { type: "server.instance.disposed", properties: { directory: "/project" } },
+})
+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/)
+
+assert.equal(await host.dispose(), true)
+assert.equal(await host.dispose(), false)
+assert.equal(unsubscribeCalls, 1)
+console.log("OpenCode 2 host contract passed")

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

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict"
+import plugin, { OPENCODE_LOOP_V2_PLUGIN_ID } from "../src/source/opencode2/experimental.js"
+import {
+  OPENCODE_LOOP_V2_COMMAND_SOURCE,
+  OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
+  OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED,
+  OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS,
+  inspectOpenCode2CommandDraft,
+  inspectOpenCode2Context,
+  openCode2LoopRuntimeStatus,
+} from "../src/source/opencode2/capabilities.js"
+
+assert.equal(plugin.id, OPENCODE_LOOP_V2_PLUGIN_ID)
+assert.equal(plugin.id, "bybrawe.opencode-loop.v2.experimental")
+assert.equal(typeof plugin.setup, "function")
+assert.equal(OPENCODE_LOOP_V2_COMMAND_SOURCE, "file-definitions")
+assert.equal(OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED, false)
+assert.deepEqual(OPENCODE_LOOP_V2_HOST_REQUIREMENTS, ["event.subscribe", "session.prompt"])
+assert.deepEqual(OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS, ["event.subscribe", "session.prompt", "runtime.adapter"])
+
+let transforms = 0
+let registered
+const currentContext = {
+  command: {
+    transform: async (callback) => {
+      transforms += 1
+      registered = callback
+    },
+  },
+}
+const setupResult = await plugin.setup(currentContext)
+assert.equal(setupResult, undefined)
+assert.equal(transforms, 1)
+assert.equal(typeof registered, "function")
+
+const currentDraft = {
+  list: () => [],
+  get: () => undefined,
+  update: () => {},
+  remove: () => {},
+}
+await registered(currentDraft)
+
+assert.deepEqual(inspectOpenCode2Context(currentContext), {
+  commandTransform: true,
+  eventSubscribe: false,
+  sessionHook: false,
+  sessionPrompt: false,
+  toolTransform: false,
+  toolHook: false,
+})
+assert.deepEqual(inspectOpenCode2CommandDraft(currentDraft), {
+  list: true,
+  get: true,
+  update: true,
+  remove: true,
+})
+
+const currentStatus = openCode2LoopRuntimeStatus(currentContext, currentDraft)
+assert.deepEqual(currentStatus.hostBlockers, ["event.subscribe", "session.prompt"])
+assert.deepEqual(currentStatus.blockers, ["event.subscribe", "session.prompt", "runtime.adapter"])
+assert.equal(currentStatus.hostReady, false)
+assert.equal(currentStatus.implementationReady, false)
+assert.equal(currentStatus.ready, false)
+assert.equal(currentStatus.commandSource, "file-definitions")
+
+const futureContext = {
+  command: { transform: async () => {} },
+  event: { subscribe: async () => {} },
+  session: { prompt: async () => ({}) },
+}
+const futureStatus = openCode2LoopRuntimeStatus(futureContext, currentDraft)
+assert.deepEqual(futureStatus.hostBlockers, [])
+assert.deepEqual(futureStatus.blockers, ["runtime.adapter"])
+assert.equal(futureStatus.hostReady, true)
+assert.equal(futureStatus.implementationReady, false)
+assert.equal(futureStatus.ready, false)
+
+let missingCapabilityFailed = false
+try {
+  await plugin.setup({})
+} catch (error) {
+  missingCapabilityFailed = /command\.transform capability is unavailable/.test(String(error))
+}
+assert.equal(missingCapabilityFailed, true)
+
+console.log("OpenCode 2 plugin sentinel contract passed")