@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/src/source/opencode2/runtime-adapter.js

@@ -6,8 +6,12 @@ function promptRequest(request) {
     sessionID: request.sessionID,
   }
   if (request.noReply === true) {
+    // beta hosts understood noReply+parts; OpenCode 2.0.11 uses the ordinary
+    // prompt shape and resume=false for a durable non-running message.
     value.noReply = true
     value.parts = [{ type: "text", text: request.text }]
+    value.text = request.text
+    value.resume = false
   } else {
     value.text = request.text
   }
@@ -19,9 +23,14 @@ function promptRequest(request) {
 function commandRequest(request) {
   const value = {
     sessionID: request.sessionID,
+    // OpenCode 2.0.11 calls this field name; earlier beta clients called it command.
+    name: request.command,
     command: request.command,
   }
-  if (request.arguments !== undefined) value.arguments = request.arguments
+  if (request.arguments !== undefined) {
+    value.arguments = request.arguments
+    value.text = request.arguments
+  }
   if (request.agent !== undefined) value.agent = request.agent
   if (request.model !== undefined) value.model = request.model
   if (request.delivery !== undefined) value.delivery = request.delivery
@@ -34,9 +43,13 @@ export function createOpenCode2RuntimeAdapter(ctx, options = {}) {
   if (!capabilities.eventSubscribe) throw new Error("OpenCode 2 event.subscribe capability is unavailable")
   if (!capabilities.sessionPrompt) throw new Error("OpenCode 2 session.prompt capability is unavailable")
 
+  const subscribe = options.eventSubscribeStyle === "stream"
+    ? () => ctx.event.subscribe()
+    : ctx.event.subscribe.bind(ctx.event)
+
   const host = createOpenCode2HostContract({
     directory: options.directory,
-    subscribe: ctx.event.subscribe.bind(ctx.event),
+    subscribe,
     sendPrompt: (request) => ctx.session.prompt(promptRequest(request)),
     sendCommand: capabilities.sessionCommand ? (request) => ctx.session.command(commandRequest(request)) : undefined,
     onEvent: options.onEvent,

package/src/source/opencode2/session-location.js

@@ -0,0 +1,16 @@
+import path from 'node:path'
+
+// The plugin location is not evidence about an arbitrary session.
+// Resolve through the host before using the instance's local files.
+export function createNativeSessionLocationGuard({ directory, workspaceID, getSession }) {
+  const expected = path.resolve(directory)
+  return async (sessionID) => {
+    if (typeof sessionID !== 'string' || !sessionID || typeof getSession !== 'function') return false
+    try {
+      const session = await getSession({ sessionID })
+      if (session?.id !== sessionID || typeof session.location?.directory !== 'string' || !path.isAbsolute(session.location.directory)) return false
+      if (path.relative(expected, path.resolve(session.location.directory)) !== '') return false
+      return (session.location.workspaceID ?? '') === (workspaceID ?? '')
+    } catch { return false }
+  }
+}

package/src/source/runtime/executor.js

@@ -23,6 +23,30 @@ function requireFunction(value, label) {
   return value
 }
 
+function sessionErrorDetails(event, fallbackMessage) {
+  if (event?.type !== "session.error") return undefined
+  const sessionID = event?.properties?.sessionID
+  if (typeof sessionID !== "string" || !sessionID) return undefined
+  const error = event?.properties?.error
+  const name = error && typeof error === "object" && typeof error.name === "string"
+    ? error.name
+    : "SessionError"
+  const data = error && typeof error === "object" && error.data && typeof error.data === "object"
+    ? error.data
+    : undefined
+  const message = typeof data?.message === "string" && data.message.trim()
+    ? data.message.trim()
+    : fallbackMessage(error)
+  return {
+    sessionID,
+    error,
+    name,
+    message,
+    aborted: name === "MessageAbortedError",
+    retryable: name === "APIError" && data?.isRetryable === true,
+  }
+}
+
 export function createLoopExecutor(options = {}) {
   const workspace = options.workspace || {}
   const goalPolicy = options.goalPolicy || {}
@@ -222,6 +246,64 @@ export function createLoopExecutor(options = {}) {
     return true
   }
 
+  async function handleSessionError(directory, client, event) {
+    const details = sessionErrorDetails(event, errorMessage)
+    if (!details || details.aborted) return false
+
+    const active = activeRuns.get(details.sessionID)
+    if (!active || active.compactionOnly) return false
+
+    const snapshot = active
+    clearActiveRun(details.sessionID)
+    clearSessionStatus(details.sessionID)
+
+    if (details.retryable) {
+      const refunded = await persistInfrastructureRefund(directory, details.sessionID, snapshot, {
+        reason: "session_error_retryable",
+        error: details.message,
+      })
+      await appendLoopLog(directory, "provider-session-error-retry", {
+        sessionID: details.sessionID,
+        job: refunded.job?.name || snapshot.jobId,
+        errorName: details.name,
+        error: details.message,
+        retryInMs: refunded.delayMs,
+      })
+      await toast(client, `Loop provider turn failed after OpenCode retries; the logical run was refunded and will retry with backoff: ${details.message}`, "warning")
+      await scheduleDueWork(directory, client, details.sessionID, refunded.delayMs)
+      return true
+    }
+
+    const state = await readState(directory, details.sessionID)
+    const job = (state.jobs || []).find((candidate) => candidate.id === snapshot.jobId)
+    if (job) {
+      job.failureCount = (job.failureCount || 0) + 1
+      job.paused = true
+      job.lastFailureReason = "session_error"
+      job.lastSessionErrorName = details.name
+      job.lastSessionError = details.message.slice(0, 4000)
+      job.lastSessionErrorAt = now()
+      state.jobs = (state.jobs || []).map((candidate) => candidate.id === job.id ? job : candidate)
+      await writeState(directory, details.sessionID, state)
+      await notifyJob(directory, job, "session_error")
+    }
+
+    await appendLoopLog(directory, "session-error", {
+      sessionID: details.sessionID,
+      job: job?.name || snapshot.jobId,
+      errorName: details.name,
+      error: details.message,
+      paused: Boolean(job?.paused),
+    })
+    await toast(
+      client,
+      `Loop paused after a terminal OpenCode session error: ${details.message}`,
+      "error",
+    )
+    await scheduleDueWork(directory, client, details.sessionID)
+    return true
+  }
+
   async function recoverStuckProviderRetry(directory, client, sessionID) {
     const active = activeRuns.get(sessionID)
     if (!active || active.compactionOnly) {
@@ -525,6 +607,7 @@ export function createLoopExecutor(options = {}) {
     clearActiveRun,
     disposeSession,
     recoverActiveDispatchFailure,
+    handleSessionError,
     recoverStuckProviderRetry,
     finalizeActiveRun,
     fireAction,

package/src/source/runtime/goal-steering.js

@@ -62,6 +62,7 @@ export function createGoalSteeringRuntime(options = {}) {
     ? Number(options.seenUserMessageMs)
     : DEFAULT_SEEN_USER_MESSAGE_MS
 
+  const compactingSessions = new Set()
   const pendingSteering = new Map()
   const seenUserMessages = new Map()
 
@@ -134,7 +135,7 @@ export function createGoalSteeringRuntime(options = {}) {
 
     const active = getActiveRun(sessionID)
     const activeGoalIDs = new Set(goals.map((goal) => goal.id))
-    const canPreempt = active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function"
+    const canPreempt = !compactingSessions.has(sessionID) && active && activeGoalIDs.has(active.jobId) && isGoalJob(active.job) && typeof client?.session?.abort === "function"
     let preempted = false
     let abortError = ""
 
@@ -154,7 +155,8 @@ export function createGoalSteeringRuntime(options = {}) {
           { path: { sessionID }, body: {} },
           { sessionID },
         )
-        clearActiveRun(sessionID)
+        // A foreground turn can replace the active run while abort settles.
+        if (getActiveRun(sessionID) === active) clearActiveRun(sessionID)
         preempted = true
       } catch (error) {
         pendingSteering.delete(sessionID)
@@ -177,10 +179,21 @@ export function createGoalSteeringRuntime(options = {}) {
     observeAssistantMessage(event)
     const user = userMessageFromEvent(event)
     if (!user) return undefined
-    return await handleUserMessage(directory, client, user)
+    // Persisted user-role events include core compaction markers, synthetic
+    // continuations and replayed history. Parts may not even be persisted yet.
+    // Only the pre-dispatch chat.message admission hook is steering authority.
+    if (alreadyHandled(user.sessionID, user.messageID)) return { handled: false, duplicate: true, ...user }
+    return { handled: false, reason: "untrusted-message-event", ...user }
+  }
+
+  function setCompacting(sessionID, value = true) {
+    if (typeof sessionID !== "string" || !sessionID) return
+    if (value) compactingSessions.add(sessionID)
+    else compactingSessions.delete(sessionID)
   }
 
   function clearSession(sessionID) {
+    compactingSessions.delete(sessionID)
     pendingSteering.delete(sessionID)
     const prefix = `${sessionID}\u0000`
     for (const key of seenUserMessages.keys()) if (key.startsWith(prefix)) seenUserMessages.delete(key)
@@ -193,6 +206,7 @@ export function createGoalSteeringRuntime(options = {}) {
     shouldSuppressIdle,
     hasPendingSteering: shouldSuppressIdle,
     pendingForSession,
+    setCompacting,
     clearSession,
   }
 }

package/src/source/runtime/job-workspace.js

@@ -58,10 +58,10 @@ export function createJobWorkspaceRuntime(options = {}) {
     if (!job.branch || job.branchDone) return job
     const branch = safeID(job.branch)
     const inRepo = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], directory, 10_000)
-    if (inRepo.code !== 0) { job.branchDone = true; return job }
+    if (inRepo.code !== 0) { job.branchDone = false; job.branchUnavailable = true; return job }
     let result = await runProcess("git", ["switch", branch], directory, 30_000)
     if (result.code !== 0) result = await runProcess("git", ["switch", "-c", branch], directory, 30_000)
-    job.branchDone = true
+    job.branchDone = result.code === 0
     await toast(client, result.code === 0 ? `Loop branch active: ${branch}` : `Could not switch/create branch: ${branch}`, result.code === 0 ? "success" : "warning")
     await appendLoopLog(directory, "branch", { sessionID, branch, code: result.code })
     return job
@@ -97,6 +97,13 @@ export function createJobWorkspaceRuntime(options = {}) {
 
   async function untilReached(directory, job) {
     if (!job.until) return false
+    // Goal contracts/archives/leases can contain the configured marker too.
+    // None of this control state proves completion of user-project work.
+    const controlRoots = new Set([
+      stateDir(directory),
+      ...["goals", "goal-locks", "goal-handoff-locks", "goal-sequences"]
+        .map((name) => path.join(directory, ".opencode", name)),
+    ].map((root) => path.resolve(root).toLowerCase()))
     const files = ["progress.md", "PROGRESS.md", "todo.md", "TODO.md", "todolist.md", "TODOLIST.md", path.join(".opencode", "opencode-loop", "until.txt")]
     for (const file of files) if (await fileContains(path.resolve(directory, file), job.until)) return true
     let scanned = 0
@@ -108,6 +115,8 @@ export function createJobWorkspaceRuntime(options = {}) {
         if (scanned >= MAX_SCAN_FILES) return false
         if ([".git", "node_modules", "dist", "build", ".next", "coverage"].includes(entry.name)) continue
         const full = path.join(current, entry.name)
+        // Keep the explicit until.txt marker above, but never scan plugin state.
+        if (controlRoots.has(path.resolve(full).toLowerCase())) continue
         if (entry.isDirectory()) { if (await walk(full)) return true }
         else if (entry.isFile() && /\.(md|txt|json|yaml|yml)$/i.test(entry.name)) { scanned++; if (await fileContains(full, job.until)) return true }
       }

package/src/source/runtime/run-finalization.js

@@ -103,6 +103,16 @@ export function createRunFinalizationRuntime(options = {}) {
 
     const terminal = await applyTerminalContinuationGuard(directory, client, sessionID, job)
     job = terminal.job
+    if (terminal.waitingUserPausedNow) {
+      await appendLoopLog(directory, "waiting-user", {
+        sessionID,
+        job: job.name || job.id,
+        count: job.waitingUserCount,
+        summary: String(terminal.text || "").slice(0, 1000),
+      })
+      await notifyJob(directory, job, "waiting_user")
+      await toast(client, "Loop paused: autonomous continuation is waiting for explicit user approval, access, or action.", "warning")
+    }
     if (terminal.pausedNow) {
       await appendLoopLog(directory, "terminal-no-work", {
         sessionID,

package/src/source/runtime/session-status.js

@@ -113,7 +113,17 @@ export function createSessionStatusRuntime(options = {}) {
 
   async function canFinalizeActiveRun(directory, client, sessionID, active, options = {}) {
     if (hasActiveToolCalls(sessionID) || hasBusyDescendant(sessionID)) return false
-    if (!options.requireIdle && !options.forceStale) return true
+
+    // OpenCode 1.x can emit transient session.idle boundaries between tool
+    // steps while the same assistant turn is still in progress. When the
+    // message API can prove that the current assistant message is incomplete,
+    // keep the Loop-owned run active instead of treating that transient idle
+    // as a completed turn. Preserve the historical fallback when message
+    // completion evidence is unavailable.
+    if (!options.requireIdle && !options.forceStale) {
+      const completion = await activeRunCompletionFromMessages(directory, client, sessionID, active)
+      return completion !== "incomplete"
+    }
 
     const completion = options.forceStale
       ? await activeRunCompletionFromMessages(directory, client, sessionID, active)
@@ -194,7 +204,11 @@ export function createSessionStatusRuntime(options = {}) {
               : completion === "completed"
                 ? "status-message-complete-recovery"
                 : "status-stale-recovery"
-            await appendLoopLog(directory, recoveryEvent, logDetails)
+            active.statusRecoveryLogEvents ??= new Set()
+            if (!active.statusRecoveryLogEvents.has(recoveryEvent)) {
+              active.statusRecoveryLogEvents.add(recoveryEvent)
+              await appendLoopLog(directory, recoveryEvent, logDetails)
+            }
             return "idle"
           }
         }

package/src/source/runtime/terminal-guard.js

@@ -1,4 +1,4 @@
-import { isCompletionBoundedContinuation, isTerminalNoWorkReply } from "../core/continuation.js"
+import { isCompletionBoundedContinuation, isContinuationShorthand, isTerminalNoWorkReply, isWaitingUserReply } from "../core/continuation.js"
 import { orderedSessionMessages, readRecentSessionMessages } from "../opencode/host.js"
 
 function messageText(message) {
@@ -17,10 +17,13 @@ function messageText(message) {
 }
 
 export async function applyTerminalContinuationGuard(directory, client, sessionID, job, options = {}) {
-  // `/loop devam et` is intentionally infinite. The guard is only for an
-  // explicit completion-bounded request such as "bitene kadar" / "until done".
-  if (job?.scheduleMode !== "idle" || !isCompletionBoundedContinuation(job?.action)) {
-    return { job, terminal: false, pausedNow: false }
+  // Plain continuation remains intentionally infinite for ordinary work and
+  // even ordinary "done" replies. We only inspect it for an explicit
+  // waiting-user dependency so a blocked autonomous loop does not poll forever.
+  const completionBounded = isCompletionBoundedContinuation(job?.action)
+  const continuation = completionBounded || isContinuationShorthand(job?.action)
+  if (job?.scheduleMode !== "idle" || !continuation) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false }
   }
 
   const messages = await readRecentSessionMessages(client, sessionID, directory, options.messageLimit || 8)
@@ -37,10 +40,32 @@ export async function applyTerminalContinuationGuard(directory, client, sessionI
   }
 
   const text = messageText(tail)
+  const waitingUser = isWaitingUserReply(text)
+  if (waitingUser) {
+    if (job.terminalNoWorkCount) job.terminalNoWorkCount = 0
+    job.waitingUserCount = (job.waitingUserCount || 0) + 1
+    job.lastWaitingUserAt = Date.now()
+    job.lastWaitingUserSummary = text.slice(0, 1000)
+    const threshold = Math.max(2, Number(options.waitingUserThreshold) || 2)
+    const waitingUserPausedNow = job.waitingUserCount >= threshold && !job.paused
+    if (waitingUserPausedNow) {
+      job.paused = true
+      job.lastFailureReason = "waiting_user"
+    }
+    return { job, terminal: false, pausedNow: false, waitingUser: true, waitingUserPausedNow, text }
+  }
+
+  if (job.waitingUserCount) job.waitingUserCount = 0
+
+  // A normal completion/no-work reply still cannot stop plain /loop devam et.
+  if (!completionBounded) {
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text }
+  }
+
   const terminal = isTerminalNoWorkReply(text)
   if (!terminal) {
     if (job.terminalNoWorkCount) job.terminalNoWorkCount = 0
-    return { job, terminal: false, pausedNow: false, text }
+    return { job, terminal: false, pausedNow: false, waitingUser: false, waitingUserPausedNow: false, text }
   }
 
   job.terminalNoWorkCount = (job.terminalNoWorkCount || 0) + 1
@@ -52,5 +77,5 @@ export async function applyTerminalContinuationGuard(directory, client, sessionI
     job.paused = true
     job.lastFailureReason = "terminal_no_work"
   }
-  return { job, terminal: true, pausedNow, text }
+  return { job, terminal: true, pausedNow, waitingUser: false, waitingUserPausedNow: false, text }
 }

package/src/source/server.js

@@ -0,0 +1,26 @@
+import OpenCodeLoopV2ExperimentalPlugin from "./opencode2/experimental.js"
+
+// Load the legacy runtime only when a V1 host invokes its server contract.
+// A runtime URL prevents bundlers from inlining the legacy implementation.
+// Both source and package entries have a sibling v1.js; the package shim
+// delegates to the standalone V1 bundle, without initializing it on V2.
+async function OpenCodeLoopPlugin(...args) {
+  const { default: legacy } = await import(new URL("./v1.js", import.meta.url).href)
+  return legacy(...args)
+}
+
+export const OPENCODE_LOOP_PLUGIN_ID = "@bybrawe/opencode-loop"
+
+export const OpenCodeLoopPluginModule = Object.freeze({
+  id: OPENCODE_LOOP_PLUGIN_ID,
+
+  // OpenCode 1.x PluginModule contract.
+  server: OpenCodeLoopPlugin,
+
+  // OpenCode 2.x promise-plugin contract.
+  setup: (context) => OpenCodeLoopV2ExperimentalPlugin.setup(context),
+})
+
+export { OpenCodeLoopPlugin, OpenCodeLoopV2ExperimentalPlugin }
+
+export default OpenCodeLoopPluginModule

package/src/v1.js

@@ -0,0 +1 @@
+export { default } from "./index.js"