@bybrawe/opencode-loop 0.5.28 → 0.5.29

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-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)

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

@@ -1,5 +1,9 @@
 import assert from "node:assert/strict"
-import plugin, { OPENCODE_LOOP_V2_PLUGIN_ID } from "../src/source/opencode2/experimental.js"
+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 {
   OPENCODE_LOOP_V2_COMMAND_SOURCE,
   OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
@@ -13,10 +17,24 @@ import {
 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_COMMAND_SOURCE, "plugin-transform")
 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"])
+assert.deepEqual(Object.keys(OPENCODE_LOOP_V2_COMMANDS), [
+  "loop",
+  "loop-pause",
+  "loop-resume",
+  "loop-stop",
+  "loop-remove",
+  "loop-clear",
+  "loop-status",
+  "loop-now",
+])
+assert.deepEqual(
+  parseOpenCode2LoopCommandText(`${OPENCODE_LOOP_V2_COMMANDS["loop-now"].template}\n\nsecond`),
+  { name: "loop-now", arguments: "second" },
+)
 
 let transforms = 0
 let registered
@@ -33,19 +51,43 @@ assert.equal(setupResult, undefined)
 assert.equal(transforms, 1)
 assert.equal(typeof registered, "function")
 
+const commands = new Map()
 const currentDraft = {
-  list: () => [],
-  get: () => undefined,
-  update: () => {},
-  remove: () => {},
+  list: () => [...commands.values()],
+  get: (name) => commands.get(name),
+  update: (name, update) => {
+    const command = commands.get(name) ?? { name, template: "" }
+    update(command)
+    command.name = name
+    commands.set(name, command)
+  },
+  remove: (name) => commands.delete(name),
 }
 await registered(currentDraft)
 
+assert.deepEqual([...commands.keys()], Object.keys(OPENCODE_LOOP_V2_COMMANDS))
+for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+  const command = commands.get(name)
+  assert.equal(command?.name, name)
+  assert.equal(command?.template, definition.template)
+  assert.equal(command?.description, definition.description)
+}
+
+let missingDraftUpdateFailed = false
+try {
+  await registered({})
+} catch (error) {
+  missingDraftUpdateFailed = /command draft\.update capability is unavailable/.test(String(error))
+}
+assert.equal(missingDraftUpdateFailed, true)
+
 assert.deepEqual(inspectOpenCode2Context(currentContext), {
   commandTransform: true,
   eventSubscribe: false,
   sessionHook: false,
   sessionPrompt: false,
+  sessionCommand: false,
+  sessionShell: false,
   toolTransform: false,
   toolHook: false,
 })
@@ -62,19 +104,26 @@ assert.deepEqual(currentStatus.blockers, ["event.subscribe", "session.prompt", "
 assert.equal(currentStatus.hostReady, false)
 assert.equal(currentStatus.implementationReady, false)
 assert.equal(currentStatus.ready, false)
-assert.equal(currentStatus.commandSource, "file-definitions")
+assert.equal(currentStatus.commandSource, "plugin-transform")
 
 const futureContext = {
   command: { transform: async () => {} },
   event: { subscribe: async () => {} },
-  session: { prompt: async () => ({}) },
+  session: {
+    prompt: async () => ({}),
+    command: async () => ({}),
+  },
 }
+const futureCapabilities = inspectOpenCode2Context(futureContext)
+assert.equal(futureCapabilities.sessionCommand, true)
+assert.equal(futureCapabilities.sessionShell, false)
 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)
+assert.equal(futureStatus.commandSource, "plugin-transform")
 
 let missingCapabilityFailed = false
 try {