@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/src/source/core/continuation.js

@@ -45,6 +45,21 @@ const NEXT_WORK_PATTERNS = [
   /devam (?:edeceğim|ediyorum|etmek gerek)(?=\s|[.,;:!—-]|$)/i,
 ]
 
+const WAITING_USER_PATTERNS = [
+  /(?:^|\n)\s*onay bekleyenler\s*:/i,
+  /(?:^|\n)\s*(?:kullanıcı|user) (?:onayı|onayi|aksiyonu|işlemi|islemi|erişimi|erisimi) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:senin|sizin) (?:onayın|onayınız|onayiniz|aksiyonun|aksiyonunuz|erişimin|erisimin) (?:bekleniyor|gerekiyor|gerekli)\b/i,
+  /\b(?:onay|erişim|erisim|yetki) olmadan (?:devam edemem|ilerleyemem|işlem yapamam|islem yapamam)\b/i,
+  /(?:^|\n)\s*(?:waiting (?:for|on) (?:your|user) (?:approval|input|action|access|credentials?)|(?:approval|user action|access) (?:required|pending))\s*:?/i,
+  /\b(?:requires?|needs?) (?:your|user) (?:approval|input|action|access|credentials?)\b/i,
+  /\bblocked (?:pending|until|on) (?:your|user|approval|access|credentials?)\b/i,
+]
+
+const WAITING_USER_NEGATIONS = [
+  /\b(?:onay|erişim|erisim|yetki) (?:gerekmiyor|gerekli değil|gerekli degil|beklenmiyor)\b/i,
+  /\bno (?:user )?(?:approval|input|action|access|credentials?) (?:is )?(?:needed|required|pending)\b/i,
+]
+
 export function isContinuationShorthand(value) {
   return CONTINUATION_SHORTHANDS.has(String(value || "").trim().toLowerCase().replace(/\s+/g, " "))
 }
@@ -54,6 +69,14 @@ export function isCompletionBoundedContinuation(value) {
   return COMPLETION_BOUNDED_PATTERNS.some((pattern) => pattern.test(text))
 }
 
+export function isWaitingUserReply(value) {
+  const text = String(value || "").trim()
+  if (!text) return false
+  if (WAITING_USER_NEGATIONS.some((pattern) => pattern.test(text))) return false
+  if (NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text))) return false
+  return WAITING_USER_PATTERNS.some((pattern) => pattern.test(text))
+}
+
 export function isTerminalNoWorkReply(value) {
   const text = String(value || "").trim()
   if (!text || NEXT_WORK_PATTERNS.some((pattern) => pattern.test(text))) return false

package/src/source/core/jobs.js

@@ -81,3 +81,20 @@ export function goalStatusText(job) {
   if (job?.paused) return "paused"
   return status
 }
+
+
+// Preserve the same custom test-command semantics in both host adapters.
+export function applyTestfixPreset(job, defaults = {}) {
+  if (defaults.testfixPreset) {
+    const defaultCommand = String(defaults.verifyCommand || "npm test")
+    const parsedAction = String(job.action || "").trim()
+    const usedDefaultAction = parsedAction === String(defaults.action || "").trim()
+    if (!usedDefaultAction && job.verifyCommand === defaults.verifyCommand) {
+      job.verifyCommand = parsedAction
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${parsedAction}`
+    } else if (usedDefaultAction && job.verifyCommand !== defaults.verifyCommand) {
+      job.action = `Run the project tests. Fix failures. Re-run the tests. Test command hint: ${job.verifyCommand || defaultCommand}`
+    }
+  }
+  return job
+}

package/src/source/core/process.js

@@ -23,11 +23,12 @@ export async function runProcess(command, args, cwd, timeoutMs = 60_000) {
     const child = spawn(command, args, { cwd, shell: false, windowsHide: true })
     const stdout = []
     const stderr = []
-    const timer = setTimeout(() => { try { child.kill("SIGTERM") } catch {} }, timeoutMs)
+    let timedOut = false
+    const timer = setTimeout(() => { timedOut = true; try { child.kill("SIGTERM") } catch {} }, timeoutMs)
     child.stdout?.on("data", (data) => stdout.push(Buffer.from(data)))
     child.stderr?.on("data", (data) => stderr.push(Buffer.from(data)))
     child.on("error", (error) => { clearTimeout(timer); resolve({ code: -1, stdout: "", stderr: String(error) }) })
-    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: timedOut ? 124 : (code ?? -1), stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
   })
 }
 
@@ -36,11 +37,12 @@ export async function runShellCommand(command, cwd, timeoutMs = 120_000) {
     const child = spawn(command, [], { cwd, shell: true, windowsHide: true })
     const stdout = []
     const stderr = []
-    const timer = setTimeout(() => { try { child.kill("SIGTERM") } catch {} }, timeoutMs)
+    let timedOut = false
+    const timer = setTimeout(() => { timedOut = true; try { child.kill("SIGTERM") } catch {} }, timeoutMs)
     child.stdout?.on("data", (data) => stdout.push(Buffer.from(data)))
     child.stderr?.on("data", (data) => stderr.push(Buffer.from(data)))
     child.on("error", (error) => { clearTimeout(timer); resolve({ code: -1, stdout: "", stderr: String(error) }) })
-    child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 0, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
+    child.on("close", (code) => { clearTimeout(timer); resolve({ code: timedOut ? 124 : (code ?? -1), stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") }) })
   })
 }
 

package/src/source/core/progress.js

@@ -0,0 +1,58 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+
+export 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 inside(root, candidate) {
+  const relative = path.relative(root, candidate)
+  return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)
+}
+
+// This direct command creates only a missing progress file. It does not own
+// native sessions, mutate Goal/Loop records, or start a model execution.
+export async function initializeProgressFile(directory, argumentsText = "") {
+  const root = await fs.realpath(directory)
+  const target = String(argumentsText || "").trim() || "progress.md"
+  const file = path.resolve(root, target)
+  const relative = path.relative(root, file)
+  if (!relative || !inside(root, file)) throw new Error("Progress file must be inside the project")
+  if ([".git", ".opencode"].includes(relative.split(path.sep)[0].toLowerCase())) {
+    throw new Error("Progress file cannot replace a control-plane path")
+  }
+  const parent = await fs.realpath(path.dirname(file))
+  if (!inside(root, parent)) throw new Error("Progress file must remain inside the project; symlink escape refused")
+  try {
+    // Exclusive creation closes the exists-then-write race and never follows
+    // an existing target symlink. Existing parent directories are required.
+    await fs.writeFile(file, DEFAULT_PROGRESS_MD, { encoding: "utf8", flag: "wx" })
+    return { created: true, file: relative }
+  } catch (error) {
+    if (error?.code === "EEXIST") return { created: false, file: relative }
+    throw error
+  }
+}

package/src/source/legacy-v1.js

@@ -43,6 +43,7 @@ const executorRuntime = createLoopExecutor({
 })
 const {
   clearActiveRun,
+  handleSessionError,
   finalizeActiveRun,
   maybeRunDueJobs: runDueJobs,
   sessionIsIdle,
@@ -242,17 +243,23 @@ export const OpenCodeLoopPlugin = async ({ client, directory }) => {
     dispose: async () => { disposeRuntime(directory, client) },
     tool: goalTools(directory),
     "command.execute.before": async (input, output) => { await handleCommand(directory, client, input, undefined, undefined, output) },
-    "chat.message": async (input) => {
+    "chat.message": async (input, output) => {
       const steering = await goalSteeringRuntime.handleUserMessage(directory, client, {
         sessionID: input?.sessionID,
-        messageID: input?.messageID,
+        messageID: input?.messageID || output?.message?.id,
       })
       if (steering?.handled && steering.sessionID) rememberSession(directory, client, steering.sessionID)
     },
     "tool.execute.before": async (input) => { markToolCallActive(input) },
     "tool.execute.after": async (input) => { markToolCallFinished(input) },
-    "experimental.session.compacting": async (input) => { await noteLoopCompactionStarted(directory, input?.sessionID) },
+    "experimental.session.compacting": async (input) => {
+      goalSteeringRuntime.setCompacting(input?.sessionID)
+      await noteLoopCompactionStarted(directory, input?.sessionID)
+    },
     event: async ({ event }) => {
+      if (["session.compacted", "session.error", "session.deleted"].includes(event?.type)) {
+        goalSteeringRuntime.setCompacting(event?.properties?.sessionID || event?.properties?.info?.id, false)
+      }
       if (event.type === "session.compacted") await noteLoopCompactionCompleted(directory, client, event?.properties?.sessionID)
       updateSessionRelationshipFromEvent(event)
       if (event.type === "message.updated") updateSessionExecutionContext(event?.properties?.info)
@@ -263,6 +270,10 @@ export const OpenCodeLoopPlugin = async ({ client, directory }) => {
       }
       const steering = await goalSteeringRuntime.handleEvent(directory, client, event)
       if (steering?.handled && steering.sessionID) rememberSession(directory, client, steering.sessionID)
+      if (event.type === "session.error") {
+        const handledError = await handleSessionError(directory, client, event)
+        if (handledError && event?.properties?.sessionID) rememberSession(directory, client, event.properties.sessionID)
+      }
       const statusUpdate = updateSessionStatusFromEvent(event)
       if (statusUpdate?.sessionID) rememberSession(directory, client, statusUpdate.sessionID)
       if (statusUpdate?.idle && !goalSteeringRuntime.shouldSuppressIdle(statusUpdate.sessionID)) {

package/src/source/native.js

@@ -0,0 +1 @@
+export { OpenCodeLoopNativePlugin as default, OpenCodeLoopNativePlugin } from "./opencode2/native-plugin.js"

package/src/source/opencode/host.js

@@ -69,6 +69,7 @@ export async function activeRunCompletionFromMessages(directory, client, session
   const messages = await readRecentSessionMessages(client, sessionID, directory)
   if (!messages) return "unknown"
   const ordered = orderedSessionMessages(messages)
+  if (ordered.length === 0) return "unknown"
   const tail = ordered.at(-1)
   const info = tail?.info || tail
   if (!info || info.role !== "assistant") return "incomplete"

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

@@ -1,5 +1,6 @@
 import { promises as fs } from "node:fs"
 import path from "node:path"
+import { DEFAULT_PROGRESS_MD } from "../core/progress.js"
 import { now as defaultNow } 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"
@@ -8,33 +9,6 @@ import { dedicatedGoalSummary, findDedicatedGoalForSession as defaultFindDedicat
 import { describeJobScheduling, listPersistedLoopSessions as defaultListPersistedLoopSessions } from "../runtime/loop-diagnostics.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

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

@@ -1,5 +1,5 @@
 import { parseLoopArgs as defaultParseLoopArgs } from "../core/args.js"
-import { actionKind, jobLabel, isGoalJob } from "../core/jobs.js"
+import { actionKind, jobLabel, isGoalJob, applyTestfixPreset } from "../core/jobs.js"
 import { normalizeLoopScheduleArgs as defaultNormalizeLoopScheduleArgs } from "../core/schedule-syntax.js"
 import { readState as defaultReadState, writeState as defaultWriteState } from "../core/state.js"
 import { appendLoopLog as defaultAppendLoopLog } from "../core/process.js"
@@ -62,17 +62,7 @@ export function createLoopRegistration(options = {}) {
     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}`
-      }
-    }
+    applyTestfixPreset(parsed.job, defaults)
     if (parsed.job.watchPaths.length) parsed.job.watchSnapshot = await snapshotPaths(directory, parsed.job.watchPaths)
     if (!parsed.job.activeRecoveryMs) {
       parsed.job.activeRecoveryMs = isGoalJob(parsed.job)

package/src/source/opencode/messages.js

@@ -27,7 +27,7 @@ export function loopOwnedUserMessageGuardActive(sessionID, messageID) {
   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.
+    // pending guard. Prefer the resolved ID from the trusted hook output.
     if (!id) return true
     entry.pending -= 1
     entry.messageIDs.set(id, now() + LOOP_OWNED_USER_MESSAGE_RETENTION_MS)

package/src/source/opencode2/capabilities.js

@@ -42,6 +42,7 @@ export function inspectOpenCode2CommandDraft(draft) {
   return frozenRecord({
     list: hasFunction(draft, "list"),
     get: hasFunction(draft, "get"),
+    add: hasFunction(draft, "add"),
     update: hasFunction(draft, "update"),
     remove: hasFunction(draft, "remove"),
   })

package/src/source/opencode2/commands.js

@@ -1,3 +1,8 @@
+export const OPENCODE_LOOP_V2_PRESET_NAMES = Object.freeze([
+  "loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev",
+  "loop-command", "loop-cmd", "loop-prompt", "loop-ask", "loop-shell",
+])
+
 export const OPENCODE_LOOP_V2_COMMANDS = Object.freeze({
   loop: Object.freeze({
     description: "Start an OpenCode auto-continue loop. Usage: /loop 5m <task>",
@@ -36,29 +41,65 @@ export const OPENCODE_LOOP_V2_COMMANDS = Object.freeze({
     template: "OpenCode Loop export command handled locally. Reply exactly: OK.",
   }),
   "loop-help": Object.freeze({
-    description: "Show the experimental OpenCode 2 Loop command help.",
+    description: "Show the native OpenCode 2 Loop command help.",
     template: "OpenCode Loop help command handled locally. Reply exactly: OK.",
   }),
   "loop-doctor": Object.freeze({
-    description: "Show experimental OpenCode 2 Loop diagnostics.",
+    description: "Show native OpenCode 2 Loop diagnostics.",
     template: "OpenCode Loop doctor command handled locally. Reply exactly: OK.",
   }),
   "loop-logs": Object.freeze({
-    description: "Show recent experimental OpenCode 2 Loop runtime events.",
+    description: "Show recent native OpenCode 2 Loop runtime events.",
     template: "OpenCode Loop logs command handled locally. Reply exactly: OK.",
   }),
 })
 
-export function registerOpenCode2LoopCommands(draft) {
-  if (!draft || typeof draft.update !== "function") {
-    throw new Error("OpenCode 2 command draft.update capability is unavailable")
+export function commandArguments(input) {
+  const prompt = input?.prompt
+  if (typeof prompt?.text === "string") return prompt.text.trim()
+  if (typeof input?.arguments === "string") return input.arguments.trim()
+  return ""
+}
+
+export function registerOpenCode2LoopCommands(draft, options = {}) {
+  if (!draft || typeof draft !== "object") {
+    throw new Error("OpenCode 2 command transform draft is unavailable")
   }
-  for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
-    draft.update(name, (command) => {
-      command.template = definition.template
-      command.description = definition.description
-    })
+
+  // OpenCode 2.0.11 exposes CommandEditor.add({ name, execute }). Earlier
+  // beta hosts exposed update(name, mutate) over command-file definitions.
+  // Support both without guessing the host version.
+  if (typeof draft.add === "function") {
+    const execute = options.execute
+    if (typeof execute !== "function") {
+      throw new Error("OpenCode 2 command draft.add requires a local Loop command executor")
+    }
+    for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+      draft.add({
+        name,
+        description: definition.description,
+        execute: async (input) => await execute({
+          name,
+          sessionID: input?.sessionID,
+          arguments: commandArguments(input),
+          delivery: input?.delivery,
+        }),
+      })
+    }
+    return
+  }
+
+  if (typeof draft.update === "function") {
+    for (const [name, definition] of Object.entries(OPENCODE_LOOP_V2_COMMANDS)) {
+      draft.update(name, (command) => {
+        command.template = definition.template
+        command.description = definition.description
+      })
+    }
+    return
   }
+
+  throw new Error("OpenCode 2 command transform exposes neither add() nor update()")
 }
 
 export function parseOpenCode2LoopCommandText(value) {

package/src/source/opencode2/event-bridge.js

@@ -26,6 +26,7 @@ function sameDirectory(expected, actual) {
 
 export function createOpenCode2EventBridge({
   directory,
+  allowInboxCommands = true,
   onEvent = async () => {},
   onError = () => {},
   runtimeManager = createSessionRuntimeManager(),
@@ -43,6 +44,7 @@ export function createOpenCode2EventBridge({
   let managerDisposed = false
   let queue = Promise.resolve()
   const sessionDirectories = new Map()
+  const seenEventIDs = new Set()
 
   function report(error) {
     try { onError(error) } catch {}
@@ -78,8 +80,14 @@ export function createOpenCode2EventBridge({
 
   async function process(raw) {
     if (stopped) return undefined
+    if (!allowInboxCommands && raw?.type === "session.inbox.enqueued") return undefined
     const event = normalize(raw)
     if (!event || !sameDirectory(directory, event.directory)) return undefined
+    if (typeof raw?.id === "string") {
+      if (seenEventIDs.has(raw.id)) return undefined
+      seenEventIDs.add(raw.id)
+      if (seenEventIDs.size > 2048) seenEventIDs.delete(seenEventIDs.values().next().value)
+    }
 
     const runtime = event.sessionID ? runtimeManager.observeExternal(event.sessionID) : undefined
     await onEvent(event, runtime)
@@ -157,9 +165,13 @@ export function createOpenCode2EventBridge({
 
     const cleanup = cleanupRegistration(registration)
     registration = undefined
-    if (cleanup) await cleanup()
-    sessionDirectories.clear()
-    disposeManager(reason)
+    try {
+      if (cleanup) await cleanup()
+    } finally {
+      // A host unsubscription failure must not keep our per-session scopes alive.
+      sessionDirectories.clear()
+      disposeManager(reason)
+    }
     return true
   }
 

package/src/source/opencode2/events.js

@@ -40,6 +40,17 @@ export function normalizeOpenCode2NativeEvent(raw) {
     })
   }
 
+  if (type === "session.status") {
+    const status = text(record(data.status)?.type)
+    if (!sessionID || !status) return undefined
+    return Object.freeze({ kind: "session", action: "status", sessionID, directory, status })
+  }
+
+  if (type === "session.idle") {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "idle", sessionID, directory })
+  }
+
   if (type === "session.execution.started") {
     if (!sessionID) return undefined
     return Object.freeze({ kind: "session", action: "status", sessionID, directory, status: "busy" })
@@ -50,6 +61,26 @@ export function normalizeOpenCode2NativeEvent(raw) {
     return Object.freeze({ kind: "session", action: "idle", sessionID, directory })
   }
 
+  if (type === "session.inbox.delivered" || type === "session.inbox.cancelled") {
+    if (!sessionID || !text(data.inboxID)) return undefined
+    return Object.freeze({ kind: "inbox", action: type.endsWith("delivered") ? "delivered" : "cancelled", sessionID, directory, inboxID: data.inboxID })
+  }
+  if (["session.compaction.started", "session.compaction.ended", "session.compaction.failed"].includes(type)) {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "compaction", action: type.split(".").at(-1), sessionID, directory })
+  }
+  if (["session.execution.failed", "session.execution.interrupted"].includes(type)) {
+    if (!sessionID) return undefined
+    return Object.freeze({ kind: "session", action: "error", sessionID, directory, reason: type })
+  }
+  if (["session.shell.started", "session.shell.ended"].includes(type)) {
+    if (!sessionID) return undefined
+    const shell = record(data.shell) || {}
+    return Object.freeze({ kind: "shell", action: type.endsWith("started") ? "started" : "ended", sessionID, directory, shellID: shell.id, command: shell.command, code: typeof shell.exit === "number" ? shell.exit : -1, status: shell.status, metadata: shell.metadata })
+  }
+
+  if (type === "location.shutdown") return Object.freeze({ kind: "server", action: "disposed", directory })
+
   if (type === "session.created") {
     if (!sessionID) return undefined
     return Object.freeze({ kind: "session", action: "created", sessionID, directory: directory || text(record(data.location)?.directory) })

package/src/source/opencode2/experimental.js

@@ -1,3 +1,4 @@
+import { OpenCodeLoopNativePlugin } from "./native-plugin.js"
 import { inspectOpenCode2Context } from "./capabilities.js"
 import { OPENCODE_LOOP_V2_COMMANDS, registerOpenCode2LoopCommands } from "./commands.js"
 import { createOpenCode2DiagnosticsRuntime } from "./diagnostics.js"
@@ -11,30 +12,75 @@ export { OPENCODE_LOOP_V2_COMMANDS }
 export const OpenCodeLoopV2ExperimentalPlugin = {
   id: OPENCODE_LOOP_V2_PLUGIN_ID,
   async setup(ctx) {
+    if (typeof ctx?.session?.hook === "function") return OpenCodeLoopNativePlugin.setup(ctx)
     const capabilities = inspectOpenCode2Context(ctx)
     if (!capabilities.commandTransform) {
       throw new Error("OpenCode 2 command.transform capability is unavailable")
     }
 
-    const commandRegistration = await ctx.command.transform(registerOpenCode2LoopCommands)
-    if (!capabilities.eventSubscribe || !capabilities.sessionPrompt) {
-      await commandRegistration?.dispose?.()
-      return undefined
-    }
-
     let promptRuntime
     let diagnosticsRuntime
+    const hostVersion = String(ctx?.app?.version || "").trim()
+    const promiseStreamHost = /^2\./.test(hostVersion)
+    const requireBusyBeforeIdle = promiseStreamHost
     const logRuntime = createOpenCode2LogRuntime()
+    const runtimeDirectory = String(ctx?.location?.directory || ctx?.options?.directory || "").trim() || undefined
+
     const onRuntimeEvent = async (event) => {
       const promptResult = await promptRuntime?.onEvent(event)
       await logRuntime.record(event, promptResult)
       if (promptResult?.handled) return promptResult
       return await diagnosticsRuntime?.onEvent(event) ?? promptResult
     }
-    const runtime = createOpenCode2RuntimeAdapter(ctx, { onEvent: onRuntimeEvent })
+
+    const commandRegistration = await ctx.command.transform((draft) => {
+      return registerOpenCode2LoopCommands(draft, {
+      execute: async ({ name, sessionID, arguments: argumentsText, delivery }) => {
+        if (!promptRuntime || !diagnosticsRuntime) {
+          throw new Error("OpenCode Loop V2 runtime is not ready")
+        }
+        const commandEvent = Object.freeze({
+          kind: "command",
+          action: "executed",
+          sessionID: String(sessionID || ""),
+          directory: runtimeDirectory,
+          name,
+          arguments: argumentsText,
+          delivery,
+        })
+        const result = await onRuntimeEvent(commandEvent)
+
+        // OpenCode 2.0.11 command callbacks are truly local: creating a Loop
+        // job does not itself start a model turn, so no execution-succeeded
+        // idle event follows the command. Kick one local idle boundary for
+        // commands that can make prompt work immediately due. Once the prompt
+        // is admitted, the real execution event stream owns subsequent turns.
+        if (result?.handled && result?.accepted && ["loop", "loop-now", "loop-resume"].includes(name)) {
+          await onRuntimeEvent(Object.freeze({
+            kind: "session",
+            action: "idle",
+            sessionID: String(sessionID || ""),
+            directory: runtimeDirectory,
+          }))
+        }
+        return result
+      },
+      })
+    })
+
+    if (!capabilities.eventSubscribe || !capabilities.sessionPrompt) {
+      await commandRegistration?.dispose?.()
+      return undefined
+    }
+    const runtime = createOpenCode2RuntimeAdapter(ctx, {
+      directory: runtimeDirectory,
+      onEvent: onRuntimeEvent,
+      eventSubscribeStyle: promiseStreamHost ? "stream" : "auto",
+    })
     promptRuntime = createOpenCode2PromptRuntime({
       prompt: (request) => runtime.prompt(request),
       command: capabilities.sessionCommand ? (request) => runtime.command(request) : undefined,
+      requireBusyBeforeIdle,
     })
     diagnosticsRuntime = createOpenCode2DiagnosticsRuntime({
       prompt: (request) => runtime.prompt(request),

package/src/source/opencode2/native-companion.js

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto"
+import { lstat, readFile } from "node:fs/promises"
+import path from "node:path"
+
+// Read-only interoperation with Goal's session-sharded store. An unreadable or
+// unsafe live shard is not permission to take over autonomous continuation.
+export async function nativeGoalReservesSession(directory, sessionID) {
+  const shard = createHash("sha256").update(sessionID).digest("hex").slice(0, 32)
+  const root = path.resolve(directory)
+  const parts = [".opencode", "goals", `${shard}.json`]
+  let file = root
+  try {
+    for (const part of parts) {
+      file = path.join(file, part)
+      const info = await lstat(file)
+      if (info.isSymbolicLink()) return true
+    }
+    const goal = JSON.parse(await readFile(file, "utf8"))
+    if (goal?.schemaVersion !== 1 || goal?.sessionID !== sessionID || typeof goal?.id !== "string") return true
+    return !["completed", "cleared"].includes(goal.status)
+  } catch (error) {
+    return error?.code !== "ENOENT"
+  }
+}