@bybrawe/opencode-loop 0.5.37 → 0.5.38

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/legacy-v1.js

@@ -43,6 +43,7 @@ const executorRuntime = createLoopExecutor({
 })
 const {
   clearActiveRun,
+  handleSessionError,
   finalizeActiveRun,
   maybeRunDueJobs: runDueJobs,
   sessionIsIdle,
@@ -263,6 +264,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/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

@@ -49,16 +49,52 @@ export const OPENCODE_LOOP_V2_COMMANDS = Object.freeze({
   }),
 })
 
-export function registerOpenCode2LoopCommands(draft) {
-  if (!draft || typeof draft.update !== "function") {
-    throw new Error("OpenCode 2 command draft.update capability is unavailable")
+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/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" })

package/src/source/opencode2/experimental.js

@@ -16,25 +16,69 @@ export const OpenCodeLoopV2ExperimentalPlugin = {
       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/prompt-runtime.js

@@ -90,9 +90,11 @@ export function createOpenCode2PromptRuntime(options = {}) {
   const setTimer = typeof options.setTimer === "function" ? options.setTimer : setTimeout
   const clearTimer = typeof options.clearTimer === "function" ? options.clearTimer : clearTimeout
   const onError = typeof options.onError === "function" ? options.onError : () => {}
+  const requireBusyBeforeIdle = options.requireBusyBeforeIdle === true
   const timers = new Map()
   const idle = new Map()
   const queues = new Map()
+  const awaitingBusy = new Set()
   let disposed = false
 
   function report(error) {
@@ -116,6 +118,7 @@ export function createOpenCode2PromptRuntime(options = {}) {
   function clearScope(scope) {
     clearScopeTimer(scope.key)
     idle.delete(scope.key)
+    awaitingBusy.delete(scope.key)
   }
 
   function enqueueScope(scope, task) {
@@ -183,7 +186,13 @@ export function createOpenCode2PromptRuntime(options = {}) {
 
     const text = promptText(job)
     const request = { sessionID: scope.sessionID, text }
-    await options.prompt(request)
+    if (requireBusyBeforeIdle) awaitingBusy.add(scope.key)
+    try {
+      await options.prompt(request)
+    } catch (error) {
+      awaitingBusy.delete(scope.key)
+      throw error
+    }
     return { kind: "prompt", request, text }
   }
 
@@ -329,14 +338,34 @@ export function createOpenCode2PromptRuntime(options = {}) {
     }
 
     if (event?.kind === "session" && event?.action === "idle") {
+      if (requireBusyBeforeIdle && scope && awaitingBusy.has(scope.key)) {
+        return { handled: true, dispatched: false, reason: "awaiting-busy" }
+      }
       return runIdlePrompt(event)
     }
     if (event?.kind === "session" && event?.action === "status" && scope) {
-      idle.set(scope.key, event.status === "idle")
-      return await enqueueScope(scope, async () => {
-        await scheduleScope(scope)
-        return { handled: true, dispatched: false }
-      })
+      if (event.status === "busy" || event.status === "retry") {
+        awaitingBusy.delete(scope.key)
+        idle.set(scope.key, false)
+        return await enqueueScope(scope, async () => {
+          await scheduleScope(scope)
+          return { handled: true, dispatched: false }
+        })
+      }
+      if (event.status === "idle") {
+        if (requireBusyBeforeIdle) {
+          if (awaitingBusy.has(scope.key)) {
+            return { handled: true, dispatched: false, reason: "awaiting-busy" }
+          }
+          return runIdlePrompt(event)
+        }
+        idle.set(scope.key, true)
+        return await enqueueScope(scope, async () => {
+          await scheduleScope(scope)
+          return { handled: true, dispatched: false }
+        })
+      }
+      return { handled: false }
     }
     if (event?.kind === "session" && event?.action === "deleted" && scope) {
       clearScope(scope)
@@ -361,6 +390,7 @@ export function createOpenCode2PromptRuntime(options = {}) {
     }
     timers.clear()
     idle.clear()
+    awaitingBusy.clear()
     const pending = [...queues.values()]
     if (pending.length) await Promise.allSettled(pending)
     queues.clear()

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

@@ -194,7 +194,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,18 @@
+import OpenCodeLoopPlugin from "./v1.js"
+import OpenCodeLoopV2ExperimentalPlugin from "./opencode2/experimental.js"
+
+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