@bybrawe/opencode-loop 0.5.27 → 0.5.29

package/src/source/opencode/host.js

@@ -0,0 +1,134 @@
+import { sdkErrorMessage, sdkCall } from "./sdk.js"
+import { normalizedModelRef, captureSessionExecutionContext, getSessionExecutionContext, setSessionExecutionContext } from "./session-context.js"
+
+const SERVICE = "opencode-loop"
+
+export function fireSdk(client, label, method, ...argsList) {
+  const pending = Promise.resolve().then(() => sdkCall(method, ...argsList))
+  void pending.catch((error) => {
+    log(client, "warn", `${label} failed`, { error: sdkErrorMessage(error) }).catch(() => {})
+  })
+  return pending
+}
+
+export async function executeTuiCommand(client, command) {
+  if (!client?.tui?.executeCommand) throw new Error("client.tui.executeCommand is not available")
+  return await sdkCall(
+    client.tui.executeCommand.bind(client.tui),
+    { body: { command } },
+    { command },
+  )
+}
+
+export function compactTuiCommandName(command = "compact") {
+  const normalized = String(command || "compact").replace(/^\/+/, "").trim().toLowerCase()
+  if (normalized === "compact" || normalized === "summarize") return "session_compact"
+  return undefined
+}
+
+export async function readRecentSessionMessages(client, sessionID, directory, limit = 20) {
+  if (!client?.session?.messages) return undefined
+  const query = { limit }
+  if (directory) query.directory = directory
+  try {
+    const messages = await sdkCall(
+      client.session.messages.bind(client.session),
+      { path: { id: sessionID }, query },
+      { path: { sessionID }, query },
+      { sessionID, ...query },
+    )
+    return Array.isArray(messages) ? messages : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export function orderedSessionMessages(messages) {
+  return (messages || [])
+    .map((message, index) => {
+      const info = message?.info || message || {}
+      const created = Number(info?.time?.created || 0)
+      return { message, index, created: Number.isFinite(created) ? created : 0 }
+    })
+    .sort((a, b) => a.created - b.created || a.index - b.index)
+    .map((entry) => entry.message)
+}
+
+export async function activeRunCompletionFromMessages(directory, client, sessionID, active) {
+  const messages = await readRecentSessionMessages(client, sessionID, directory)
+  if (!messages) return "unknown"
+  const tail = orderedSessionMessages(messages).at(-1)
+  const info = tail?.info || tail
+  if (!info || info.role !== "assistant") return "incomplete"
+  const completed = Number(info?.time?.completed || 0)
+  const created = Number(info?.time?.created || 0)
+  if (!Number.isFinite(completed) || completed <= 0) return "incomplete"
+  const startedAt = Number(active?.startedAt || 0)
+  if (startedAt > 0 && completed < startedAt && (!Number.isFinite(created) || created < startedAt)) return "incomplete"
+  return "completed"
+}
+
+export async function resolveCompactionModel(directory, client, sessionID, preferredModel) {
+  const preferred = normalizedModelRef(preferredModel)
+  if (preferred) return preferred
+  const cached = normalizedModelRef(getSessionExecutionContext(sessionID)?.model)
+  if (cached) return cached
+  const captured = await captureSessionExecutionContext(client, sessionID)
+  const capturedModel = normalizedModelRef(captured?.model)
+  if (capturedModel) return capturedModel
+  const messages = await readRecentSessionMessages(client, sessionID, directory)
+  for (const message of orderedSessionMessages(messages).reverse()) {
+    const info = message?.info || message
+    const model = normalizedModelRef(info?.model) || normalizedModelRef(info)
+    if (!model) continue
+    const previous = getSessionExecutionContext(sessionID) || {}
+    setSessionExecutionContext(sessionID, { ...previous, model })
+    return model
+  }
+  return undefined
+}
+
+export async function compactSession(directory, client, sessionID, preferredModel) {
+  // Prefer the native TUI command when a TUI is present. Headless/server hosts
+  // fall back to session.summarize, whose current API requires an explicit
+  // provider/model pair.
+  for (const command of ["session.compact", "session_compact"]) {
+    try {
+      await executeTuiCommand(client, command)
+      return true
+    } catch (error) {
+      await log(client, "warn", `tui ${command} failed`, { error: sdkErrorMessage(error) })
+    }
+  }
+  try {
+    if (!client?.session?.summarize) throw new Error("client.session.summarize is not available")
+    const model = await resolveCompactionModel(directory, client, sessionID, preferredModel)
+    if (!model) throw new Error("could not resolve a provider/model for session.summarize")
+    const body = { providerID: model.providerID, modelID: model.modelID, auto: false }
+    await sdkCall(
+      client.session.summarize.bind(client.session),
+      { path: { id: sessionID }, body },
+      { path: { sessionID }, body },
+      { sessionID, ...body },
+    )
+    return true
+  } catch (error) {
+    await log(client, "warn", "session.summarize fallback failed", { error: sdkErrorMessage(error) })
+  }
+  await toast(client, "Could not run /compact from loop. Check OpenCode version and active session model.", "error")
+  return false
+}
+
+export async function log(client, level, message, extra) {
+  try {
+    await sdkCall(
+      client.app.log.bind(client.app),
+      { body: extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra } },
+      extra === undefined ? { service: SERVICE, level, message } : { service: SERVICE, level, message, extra },
+    )
+  } catch {}
+}
+
+export async function toast(client, message, variant = "info") {
+  try { await sdkCall(client.tui.showToast.bind(client.tui), { body: { message, variant } }, { message, variant }) } catch {}
+}

package/src/source/opencode/loop-commands.js

@@ -0,0 +1,195 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import { now as defaultNow, durationToText } from "../core/args.js"
+import { jobLabel, matchJob, isGoalJob, goalStatusText } from "../core/jobs.js"
+import { stateDir, pathExists as defaultPathExists, readState as defaultReadState, writeState as defaultWriteState, removeState as defaultRemoveState } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
+
+const SERVICE = "opencode-loop"
+const DEFAULT_PROGRESS_MD = `# Progress
+
+## Current Goal
+Describe the current project goal here.
+
+## Agent Rules
+- Do not ask questions unless truly blocked.
+- Make reasonable assumptions and continue.
+- Work on unfinished TODOs in order.
+- Mark completed TODOs with [x].
+- Add new bugs, ideas, and follow-up work as TODOs.
+- Run tests, lint, or build when available.
+- Do not run destructive commands, force pushes, production deploys, or database resets.
+
+## Active TODO
+- [ ] Review the project structure and pick the next safe improvement.
+
+## Completed
+- [x] Created progress.md.
+
+## Backlog Ideas
+- [ ] Add more project-specific tasks here.
+
+## Blocked
+- None.
+`
+
+function requireFunction(value, name) {
+  if (typeof value !== "function") throw new TypeError(`createLoopCommandHandlers requires ${name}`)
+  return value
+}
+
+export function createLoopCommandHandlers(options = {}) {
+  const clearActiveRun = requireFunction(options.clearActiveRun, "clearActiveRun")
+  const cancelDueWork = requireFunction(options.cancelDueWork, "cancelDueWork")
+  const stopWatchdog = requireFunction(options.stopWatchdog, "stopWatchdog")
+  const scheduleDueWork = requireFunction(options.scheduleDueWork, "scheduleDueWork")
+  const maybeRunDueJobs = requireFunction(options.maybeRunDueJobs, "maybeRunDueJobs")
+  const toast = requireFunction(options.toast, "toast")
+  const say = requireFunction(options.say, "say")
+  const now = typeof options.now === "function" ? options.now : defaultNow
+  const readState = typeof options.readState === "function" ? options.readState : defaultReadState
+  const writeState = typeof options.writeState === "function" ? options.writeState : defaultWriteState
+  const removeState = typeof options.removeState === "function" ? options.removeState : defaultRemoveState
+  const pathExists = typeof options.pathExists === "function" ? options.pathExists : defaultPathExists
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const readFile = typeof options.readFile === "function" ? options.readFile : (...args) => fs.readFile(...args)
+  const writeFile = typeof options.writeFile === "function" ? options.writeFile : (...args) => fs.writeFile(...args)
+  const runtimeVersion = options.runtimeVersion || process.version
+  const runtimePlatform = options.runtimePlatform || process.platform
+
+  async function stopLoop(directory, client, sessionID, args) {
+    const target = String(args || "").trim()
+    if (!target || target.toLowerCase() === "all") {
+      await removeState(directory, sessionID)
+      clearActiveRun(sessionID)
+      cancelDueWork(sessionID)
+      stopWatchdog(sessionID)
+      await toast(client, "All loops stopped for this session.", "success")
+      return
+    }
+    const state = await readState(directory, sessionID)
+    const before = state.jobs.length
+    state.jobs = state.jobs.filter((job, index) => !matchJob(job, target, index))
+    await writeState(directory, sessionID, state)
+    await scheduleDueWork(directory, client, sessionID)
+    await toast(client, `Stopped ${before - state.jobs.length} loop(s).`, "success")
+  }
+
+  async function updateJobState(directory, client, sessionID, args, updater, message) {
+    const target = String(args || "").trim() || "all"
+    const state = await readState(directory, sessionID)
+    let count = 0
+    state.jobs = (state.jobs || []).map((job, index) => matchJob(job, target, index) ? (count++, updater(job)) : job)
+    await writeState(directory, sessionID, state)
+    await scheduleDueWork(directory, client, sessionID)
+    await toast(client, `${message}: ${count} loop(s).`, count ? "success" : "warning")
+  }
+
+  async function statusLoop(directory, client, sessionID) {
+    const state = await readState(directory, sessionID)
+    const jobs = state.jobs || []
+    const lines = jobs.length ? jobs.map((job, index) => {
+      const current = now()
+      const intervalMs = Number(job.intervalMs || 0)
+      const lastRunAt = Number(job.lastRunAt || 0)
+      const createdAt = Date.parse(job.createdAt || "")
+      const dueAt = Number(job.runNowRequestedAt || 0) > 0
+        ? current
+        : lastRunAt > 0
+          ? lastRunAt + intervalMs
+          : job.immediate === false && Number.isFinite(createdAt)
+            ? createdAt + intervalMs
+            : current
+      const dueIn = Math.max(0, dueAt - current)
+      const flags = [isGoalJob(job) ? `goal:${goalStatusText(job)}` : undefined, job.paused ? "paused" : "active", Number(job.runNowRequestedAt || 0) > 0 ? "run-now" : undefined, job.safe ? "safe" : undefined, job.askNever ? "ask-never" : undefined, job.noOverlap ? "no-overlap" : undefined, job.checkpointOnly ? "checkpoint-only" : undefined, job.gitCheckpoint ? "git-checkpoint" : undefined].filter(Boolean).join(",")
+      return `${index + 1}. ${job.id}${job.name ? ` (${job.name})` : ""}: ${jobLabel(job)} | runs=${job.runCount || 0} | failures=${job.failureCount || 0} | due in ${durationToText(dueIn)} | ${flags}`
+    }) : ["No active loop jobs."]
+    await toast(client, jobs.length ? `${jobs.length} loop job(s).` : "No active loop jobs.", jobs.length ? "info" : "warning")
+    await say(client, sessionID, "OpenCode loop status:\n" + lines.join("\n"))
+  }
+
+  async function logsLoop(directory, client, sessionID) {
+    let text = "No loop log found."
+    try { text = (await readFile(path.join(stateDir(directory), "loop.log"), "utf8")).trim().split(/\r?\n/).slice(-80).join("\n") || text } catch {}
+    await say(client, sessionID, "OpenCode loop logs:\n" + text)
+  }
+
+  async function helpLoop(client, sessionID) {
+    await say(client, sessionID, [
+      "OpenCode Loop help:",
+      "/loop 0s <prompt>                                Claude Code style auto-continue",
+      "/loop 5m --ask-never --safe <prompt>              interval autonomous prompt loop",
+      "/loop-command 200m /compact                       OpenCode slash-command loop, waits for idle",
+      "/loop-ask 1h did you run tests and tsc --noEmit?   scheduled question/check prompt",
+      "/loop-shell 10m npm test                           shell loop, waits for idle",
+      "/loop-goal finish the feature and keep tests green  experimental persistent goal mode",
+      "/loop-goal --check \"npm run build\" --check \"npm test\" --complete-when-checks-pass ship it",
+      "/loop-goal status | pause | resume | clear          manage experimental goals",
+      "/loop 200m --command /compact                     same as command loop",
+      "/loop 0s --verify \"npm test\" <prompt>            verify after each assistant turn",
+      "/loop 0s --prompt-file loop-prompt.md             load prompt from a file",
+      "/loop 0s --max-runtime 6h --max-failures 3 <task> stop safely after limits",
+      "/loop-doctor | /loop-init | /loop-export",
+    ].join("\n"))
+  }
+
+  async function runNow(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "all"
+    const state = await readState(directory, sessionID)
+    const requestedAt = Math.max(1, Number(now()) || Date.now())
+    let count = 0
+    for (const [index, job] of (state.jobs || []).entries()) {
+      if (!matchJob(job, target, index)) continue
+      job.lastRunAt = 0
+      job.paused = false
+      job.runNowRequestedAt = requestedAt
+      count += 1
+    }
+    await writeState(directory, sessionID, state)
+    await toast(client, `Marked ${count} loop job(s) due now.`, count ? "success" : "warning")
+    // /loop-now is handled in command.execute.before. Do not start a model turn re-entrantly
+    // inside that hook; schedule the persisted request and let the idle-safe timer dispatch it.
+    if (count) await scheduleDueWork(directory, client, sessionID)
+  }
+
+  async function doctorLoop(directory, client, sessionID) {
+    const state = await readState(directory, sessionID)
+    await say(client, sessionID, [
+      "OpenCode Loop doctor:",
+      `- plugin: ${SERVICE}`,
+      `- project directory: ${directory}`,
+      `- state directory: ${stateDir(directory)}`,
+      `- active jobs: ${(state.jobs || []).length}`,
+      `- node: ${runtimeVersion}`,
+      `- platform: ${runtimePlatform}`,
+      "- smoke test: /loop 0s --max-runs 1 --dry-run continue from progress.md",
+      "- experimental goal smoke test: /loop-goal --dry-run finish the current task and verify it",
+    ].join("\n"))
+  }
+
+  async function initLoop(directory, client, sessionID, args) {
+    const target = String(args || "").trim() || "progress.md"
+    const full = path.resolve(directory, target)
+    if (await pathExists(full)) { await toast(client, `${target} already exists.`, "warning"); return }
+    await writeFile(full, DEFAULT_PROGRESS_MD, "utf8")
+    await toast(client, `Created ${target}.`, "success")
+    await appendLoopLog(directory, "init", { sessionID, file: target })
+  }
+
+  async function exportLoop(directory, client, sessionID) {
+    const state = await readState(directory, sessionID)
+    await say(client, sessionID, "OpenCode loop state export:\n```json\n" + JSON.stringify(state, null, 2) + "\n```")
+  }
+
+  return {
+    stopLoop,
+    updateJobState,
+    statusLoop,
+    logsLoop,
+    helpLoop,
+    runNow,
+    doctorLoop,
+    initLoop,
+    exportLoop,
+  }
+}

package/src/source/opencode/loop-registration.js

@@ -0,0 +1,100 @@
+import { parseLoopArgs as defaultParseLoopArgs } from "../core/args.js"
+import { jobLabel, isGoalJob } from "../core/jobs.js"
+import { readState as defaultReadState, writeState as defaultWriteState } from "../core/state.js"
+import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
+import { normalizedModelRef as defaultNormalizedModelRef, getSessionExecutionContext as defaultGetSessionExecutionContext } from "./session-context.js"
+
+const DEFAULT_GOAL_ACTIVE_RECOVERY_MS = 180_000
+const FALLBACK_ACTIVE_GUARD_MS = 45_000
+
+function requireFunction(value, name) {
+  if (typeof value !== "function") throw new TypeError(`createLoopRegistration requires ${name}`)
+  return value
+}
+
+export function normalizeActionForCompare(value) {
+  return String(value || "").replace(/\s+/g, " ").trim()
+}
+
+export function sameLoopDefinition(a, b) {
+  if (!a || !b) return false
+  return (a.name || "") === (b.name || "") &&
+    Number(a.intervalMs || 0) === Number(b.intervalMs || 0) &&
+    normalizeActionForCompare(a.action) === normalizeActionForCompare(b.action) &&
+    normalizeActionForCompare(a.kind) === normalizeActionForCompare(b.kind) &&
+    normalizeActionForCompare(a.promptFile) === normalizeActionForCompare(b.promptFile)
+}
+
+export function createLoopRegistration(options = {}) {
+  const snapshotPaths = requireFunction(options.snapshotPaths, "snapshotPaths")
+  const scheduleDueWork = requireFunction(options.scheduleDueWork, "scheduleDueWork")
+  const scheduleIdleWork = requireFunction(options.scheduleIdleWork, "scheduleIdleWork")
+  const toast = requireFunction(options.toast, "toast")
+  const say = requireFunction(options.say, "say")
+  const parseLoopArgs = typeof options.parseLoopArgs === "function" ? options.parseLoopArgs : defaultParseLoopArgs
+  const readState = typeof options.readState === "function" ? options.readState : defaultReadState
+  const writeState = typeof options.writeState === "function" ? options.writeState : defaultWriteState
+  const appendLoopLog = typeof options.appendLoopLog === "function" ? options.appendLoopLog : defaultAppendLoopLog
+  const normalizedModelRef = typeof options.normalizedModelRef === "function" ? options.normalizedModelRef : defaultNormalizedModelRef
+  const getSessionExecutionContext = typeof options.getSessionExecutionContext === "function" ? options.getSessionExecutionContext : defaultGetSessionExecutionContext
+  const configuredGuard = Number(options.defaultActiveGuardMs)
+  const defaultActiveGuardMs = Number.isFinite(configuredGuard) && configuredGuard > 0 ? configuredGuard : FALLBACK_ACTIVE_GUARD_MS
+
+  async function addLoop(directory, client, sessionID, args, defaults = {}) {
+    const parsed = parseLoopArgs(args, defaults)
+    if (!parsed.ok) { await toast(client, parsed.error, "warning"); return }
+    const executionContext = getSessionExecutionContext(sessionID) || { agent: "build" }
+    parsed.job.agent = defaults.agent || executionContext.agent || "build"
+    parsed.job.model = normalizedModelRef(defaults.model) || executionContext.model
+    if (defaults.testfixPreset) {
+      const defaultCommand = String(defaults.verifyCommand || "npm test")
+      const parsedAction = String(parsed.job.action || "").trim()
+      const usedDefaultAction = parsedAction === String(defaults.action || "").trim()
+      if (!usedDefaultAction && parsed.job.verifyCommand === defaults.verifyCommand) {
+        parsed.job.verifyCommand = parsedAction
+        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`
+      } else if (usedDefaultAction && parsed.job.verifyCommand !== defaults.verifyCommand) {
+        parsed.job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsed.job.verifyCommand || defaultCommand}`
+      }
+    }
+    if (parsed.job.watchPaths.length) parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths)
+    if (!parsed.job.activeRecoveryMs) {
+      parsed.job.activeRecoveryMs = isGoalJob(parsed.job)
+        ? DEFAULT_GOAL_ACTIVE_RECOVERY_MS
+        : Math.max(defaultActiveGuardMs, Math.min(90_000, (parsed.job.intervalMs || 0) + 10_000))
+    }
+    if (parsed.job.dryRun) {
+      await toast(client, `Loop dry run: ${jobLabel(parsed.job)}`, "info")
+      await say(client, sessionID, "OpenCode loop dry run:\n```json\n" + JSON.stringify(parsed.job, null, 2) + "\n```")
+      return
+    }
+    const state = await readState(directory, sessionID)
+    const jobs = Array.isArray(state.jobs) ? state.jobs : []
+
+    // Default behavior is replace/upsert, not append forever. This prevents duplicate
+    // loops when OpenCode emits both command.execute.before and command.executed,
+    // and it matches the common expectation that /loop configures the current loop.
+    let replaced = false
+    if (!parsed.job.multi) {
+      const targetName = parsed.job.name || "default"
+      parsed.job.name = targetName
+      state.jobs = jobs.filter((existing) => {
+        const existingName = existing.name || "default"
+        const shouldReplace = existingName === targetName || sameLoopDefinition(existing, parsed.job)
+        if (shouldReplace) replaced = true
+        return !shouldReplace
+      })
+    } else {
+      state.jobs = jobs
+    }
+
+    state.jobs.push(parsed.job)
+    await writeState(directory, sessionID, state)
+    await scheduleDueWork(directory, client, sessionID)
+    if (parsed.job.immediate) scheduleIdleWork(directory, client, sessionID)
+    await toast(client, `${replaced ? "Loop replaced" : "Loop added"}: ${jobLabel(parsed.job)}`, "success")
+    await appendLoopLog(directory, replaced ? "replace" : "add", { sessionID, job: parsed.job.name || parsed.job.id, label: jobLabel(parsed.job) })
+  }
+
+  return { addLoop }
+}

package/src/source/opencode/messages.js

@@ -0,0 +1,55 @@
+import { now } from "../core/args.js"
+import { sdkCall } from "./sdk.js"
+
+const LOOP_OWNED_USER_MESSAGE_GUARD_MS = 10_000
+const LOOP_OWNED_USER_MESSAGE_RETENTION_MS = 10 * 60_000
+const loopOwnedUserMessageGuards = new Map()
+
+export function guardLoopOwnedUserMessage(sessionID) {
+  if (!sessionID) return
+  const current = loopOwnedUserMessageGuards.get(sessionID) || { pending: 0, until: 0, messageIDs: new Map() }
+  current.pending += 1
+  current.until = Math.max(current.until || 0, now() + LOOP_OWNED_USER_MESSAGE_GUARD_MS)
+  for (const [messageID, expiresAt] of current.messageIDs.entries()) if (expiresAt < now()) current.messageIDs.delete(messageID)
+  loopOwnedUserMessageGuards.set(sessionID, current)
+  for (const [key, entry] of loopOwnedUserMessageGuards.entries()) {
+    for (const [messageID, expiresAt] of entry.messageIDs.entries()) if (expiresAt < now()) entry.messageIDs.delete(messageID)
+    if ((entry.pending || 0) <= 0 && entry.messageIDs.size === 0 && (entry.until || 0) < now()) loopOwnedUserMessageGuards.delete(key)
+  }
+}
+
+export function loopOwnedUserMessageGuardActive(sessionID, messageID) {
+  const entry = loopOwnedUserMessageGuards.get(sessionID)
+  if (!entry || typeof entry !== "object") return false
+  for (const [id, expiresAt] of entry.messageIDs.entries()) if (expiresAt < now()) entry.messageIDs.delete(id)
+  const id = typeof messageID === "string" ? messageID : ""
+  if (id && entry.messageIDs.has(id)) return true
+  if ((entry.pending || 0) > 0 && (entry.until || 0) >= now()) {
+    // chat.message can fire before OpenCode assigns the synthetic user message
+    // an ID. Treat that pre-dispatch hook as Loop-owned without consuming the
+    // pending guard; message.updated will later bind and retain the real ID.
+    if (!id) return true
+    entry.pending -= 1
+    entry.messageIDs.set(id, now() + LOOP_OWNED_USER_MESSAGE_RETENTION_MS)
+    loopOwnedUserMessageGuards.set(sessionID, entry)
+    return true
+  }
+  if ((entry.pending || 0) <= 0 && entry.messageIDs.size === 0) loopOwnedUserMessageGuards.delete(sessionID)
+  return false
+}
+
+export async function say(client, sessionID, text) {
+  guardLoopOwnedUserMessage(sessionID)
+  try {
+    await sdkCall(
+      client.session.prompt.bind(client.session),
+      { path: { id: sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } },
+      { path: { sessionID }, body: { noReply: true, parts: [{ type: "text", text }] } },
+      { sessionID, noReply: true, parts: [{ type: "text", text }] },
+    )
+  } catch {}
+}
+
+export function clearLoopOwnedUserMessageGuard(sessionID) {
+  loopOwnedUserMessageGuards.delete(sessionID)
+}

package/src/source/opencode/sdk.js

@@ -0,0 +1,38 @@
+// OpenCode SDK compatibility helpers.
+export function sdkError(result) {
+  if (!result || typeof result !== "object") return undefined
+  return result.error || result.error === null ? result.error : undefined
+}
+
+export function sdkData(result) {
+  if (!result || typeof result !== "object") return result
+  return Object.prototype.hasOwnProperty.call(result, "data") ? result.data : result
+}
+
+export function sdkErrorMessage(error) {
+  if (!error) return "unknown SDK error"
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  if (typeof error === "object") {
+    if (typeof error.message === "string") return error.message
+    if (typeof error.name === "string") return error.name
+    try { return JSON.stringify(error).slice(0, 400) } catch {}
+  }
+  return String(error)
+}
+
+export async function sdkCall(method, ...argsList) {
+  let firstError
+  for (const args of argsList) {
+    if (args === undefined) continue
+    try {
+      const result = await method(args)
+      const error = sdkError(result)
+      if (!error) return sdkData(result)
+      firstError = firstError || new Error(sdkErrorMessage(error))
+    } catch (error) {
+      firstError = firstError || error
+    }
+  }
+  throw firstError || new Error("SDK call failed without arguments")
+}

package/src/source/opencode/session-context.js

@@ -0,0 +1,50 @@
+import { sdkCall } from "./sdk.js"
+
+const LOCAL_COMMAND_AGENT = "opencode-loop-local"
+const sessionExecutionContexts = new Map()
+
+export function normalizedModelRef(model) {
+  if (typeof model === "string") {
+    const separator = model.indexOf("/")
+    if (separator > 0) return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) }
+    return undefined
+  }
+  const providerID = model?.providerID
+  const modelID = model?.modelID || model?.id
+  if (typeof providerID !== "string" || typeof modelID !== "string") return undefined
+  return { providerID, modelID }
+}
+
+export function updateSessionExecutionContext(info) {
+  const sessionID = info?.sessionID || info?.id
+  if (typeof sessionID !== "string") return
+  const previous = sessionExecutionContexts.get(sessionID) || {}
+  const candidateAgent = info?.agent || (info?.role === "assistant" ? info?.mode : undefined)
+  const agent = typeof candidateAgent === "string" && candidateAgent !== LOCAL_COMMAND_AGENT
+    ? candidateAgent
+    : previous.agent
+  const model = normalizedModelRef(info?.model) || normalizedModelRef(info) || previous.model
+  sessionExecutionContexts.set(sessionID, { agent, model })
+}
+
+export async function captureSessionExecutionContext(client, sessionID) {
+  if (client?.session?.get) {
+    try {
+      const info = await sdkCall(
+        client.session.get.bind(client.session),
+        { path: { id: sessionID } },
+        { path: { sessionID } },
+        { sessionID },
+      )
+      updateSessionExecutionContext(info)
+    } catch {}
+  }
+  const context = sessionExecutionContexts.get(sessionID) || {}
+  const normalized = { agent: context.agent || "build", model: context.model }
+  sessionExecutionContexts.set(sessionID, normalized)
+  return normalized
+}
+
+export function getSessionExecutionContext(sessionID) { return sessionExecutionContexts.get(sessionID) }
+export function setSessionExecutionContext(sessionID, context) { sessionExecutionContexts.set(sessionID, context); return context }
+export function deleteSessionExecutionContext(sessionID) { sessionExecutionContexts.delete(sessionID) }

package/src/source/opencode2/capabilities.js

@@ -0,0 +1,71 @@
+function hasFunction(value, key) {
+  return Boolean(value && typeof value[key] === "function")
+}
+
+function frozenRecord(value) {
+  return Object.freeze(value)
+}
+
+export const OPENCODE_LOOP_V2_HOST_REQUIREMENTS = Object.freeze([
+  "event.subscribe",
+  "session.prompt",
+])
+
+export const OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED = false
+
+export const OPENCODE_LOOP_V2_RUNTIME_REQUIREMENTS = Object.freeze([
+  ...OPENCODE_LOOP_V2_HOST_REQUIREMENTS,
+  "runtime.adapter",
+])
+
+export const OPENCODE_LOOP_V2_COMMAND_SOURCE = "plugin-transform"
+
+export function inspectOpenCode2Context(ctx) {
+  const command = ctx?.command
+  const session = ctx?.session
+  const event = ctx?.event
+  const tool = ctx?.tool
+
+  return frozenRecord({
+    commandTransform: hasFunction(command, "transform"),
+    eventSubscribe: hasFunction(event, "subscribe"),
+    sessionHook: hasFunction(session, "hook"),
+    sessionPrompt: hasFunction(session, "prompt"),
+    sessionCommand: hasFunction(session, "command"),
+    sessionShell: hasFunction(session, "shell"),
+    toolTransform: hasFunction(tool, "transform"),
+    toolHook: hasFunction(tool, "hook"),
+  })
+}
+
+export function inspectOpenCode2CommandDraft(draft) {
+  return frozenRecord({
+    list: hasFunction(draft, "list"),
+    get: hasFunction(draft, "get"),
+    update: hasFunction(draft, "update"),
+    remove: hasFunction(draft, "remove"),
+  })
+}
+
+export function openCode2LoopRuntimeStatus(ctx, commandDraft) {
+  const context = inspectOpenCode2Context(ctx)
+  const command = inspectOpenCode2CommandDraft(commandDraft)
+  const hostBlockers = []
+
+  if (!context.eventSubscribe) hostBlockers.push("event.subscribe")
+  if (!context.sessionPrompt) hostBlockers.push("session.prompt")
+
+  const blockers = [...hostBlockers]
+  if (!OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED) blockers.push("runtime.adapter")
+
+  return frozenRecord({
+    ready: blockers.length === 0,
+    hostReady: hostBlockers.length === 0,
+    implementationReady: OPENCODE_LOOP_V2_RUNTIME_IMPLEMENTED,
+    blockers: Object.freeze(blockers),
+    hostBlockers: Object.freeze(hostBlockers),
+    commandSource: OPENCODE_LOOP_V2_COMMAND_SOURCE,
+    context,
+    command,
+  })
+}