@bybrawe/opencode-loop 0.5.38 → 0.6.0

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

@@ -243,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)

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/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,20 +41,20 @@ 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.",
   }),
 })
 
-function commandArguments(input) {
+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()

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

@@ -61,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,6 +12,7 @@ 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")

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"
+  }
+}

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

@@ -0,0 +1,153 @@
+import path from "node:path"
+import { createNativeSessionLocationGuard } from "./session-location.js"
+import { createNativeShellHost } from "./native-shell.js"
+import { createNativeLoopRuntime } from "./native-runtime.js"
+import { createOpenCode2EventBridge } from "./event-bridge.js"
+import { registerOpenCode2LoopCommands, OPENCODE_LOOP_V2_PRESET_NAMES, commandArguments } from "./commands.js"
+import { readSmallTextFile, appendLoopLog } from "../core/process.js"
+import { stateDir } from "../core/state.js"
+import { initializeProgressFile } from "../core/progress.js"
+
+const HELP = `OpenCode Loop: native OpenCode 2 runtime
+/loop 0s <task> --max-runs 3
+/loop 5m <task> --verify "npm test" --pause-on-verify-fail
+/loop --watch progress.md <task>
+/loop 0s <task> --prompt-file instructions.md --include-file progress.md
+/loop 0s <task> --compact-every 3
+/loop 5m --shell npm test
+/loop 15m --compact /compact
+Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /loop-prompt, /loop-command, /loop-cmd, /loop-shell, /loop-compact.
+/loop-init [progress.md] creates a missing project-local progress file without overwriting existing data.
+Controls: /loop-now, /loop-pause, /loop-resume, /loop-stop, /loop-remove, /loop-clear, /loop-status, /loop-export.
+Preflight, postrun, notifications, stop files, completion markers, runtime/failure/run limits, branches and checkpoints are supported.
+Scheduled shell commands run as bounded local child processes when the plugin context has no session.shell.
+Scheduled/manual compaction requires session.compact on the host; unavailable capability is rejected before creating a job. Native automatic compaction is always left to OpenCode.
+An unfinished dedicated Goal reserves its session; Loop will not override it.
+--timeout pauses future iterations without aborting the current native model/tool/compaction operation.
+--safe is a command heuristic, not a sandbox. --dry-run does not dispatch or run hooks.
+Native sessions stay serialized; --allow-overlap is rejected.
+Use @bybrawe/opencode-goal and /goal for native Goal contracts. Legacy Loop Goal state is not silently migrated.
+An uncertain admission after a restart is paused for review instead of being replayed automatically.`
+
+async function cleanup(value) {
+  if (typeof value === "function") await value()
+  else if (typeof value?.dispose === "function") await value.dispose()
+  else if (typeof value?.unsubscribe === "function") await value.unsubscribe()
+}
+
+export const OpenCodeLoopNativePlugin = Object.freeze({
+  id: "@bybrawe/opencode-loop",
+  async setup(ctx) {
+    for (const [label, fn] of [["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
+      if (typeof fn !== "function") throw new Error(`Native OpenCode Loop requires ${label}; use OpenCode 2.0.18 or newer.`)
+    }
+    const directory = String(ctx.location?.directory || ctx.options?.directory || "").trim()
+    if (!directory) throw new Error("Native OpenCode Loop requires a project directory")
+    const ownsSession = createNativeSessionLocationGuard({
+      directory, workspaceID: ctx.location?.workspaceID,
+      getSession: (input) => ctx.session.get(input),
+    })
+    const registrations = []
+    const lifecycleAbort = new AbortController()
+    const prompt = (request) => ctx.session.prompt({ ...request, delivery: request.delivery || "queue", metadata: { ...request.metadata, opencode_loop_v2: true } })
+    const shellHost = createNativeShellHost({
+      directory,
+      onTerminal: (event) => runtime.onEvent(event),
+      onError: (error) => { void appendLoopLog(directory, "v2-shell-error", { message: String(error?.message || error) }).catch(() => {}) },
+    })
+    const runtime = createNativeLoopRuntime({
+      directory,
+      scopeAllowed: (scope) => ownsSession(scope.sessionID),
+      prompt,
+      command: typeof ctx.session.command === "function" ? (request) => ctx.session.command(request) : undefined,
+      wait: typeof ctx.session.wait === "function" ? (request) => ctx.session.wait(request) : undefined,
+      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact({ ...request, delivery: "queue" }) : undefined,
+      shell: typeof ctx.session.shell === "function" ? (request) => ctx.session.shell(request) : (request) => shellHost.dispatch(request),
+      // cancel() returns void. The durable inbox.cancelled event, not this
+      // response alone, proves that an undelivered input can be refunded.
+      cancel: typeof ctx.session.inbox?.cancel === "function" ? async (request) => { await ctx.session.inbox.cancel(request); return false } : undefined,
+      onError: (error) => { void appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {}) },
+    })
+    const bridge = createOpenCode2EventBridge({ directory, allowInboxCommands: false, onEvent: async (event) => {
+      if (event.sessionID && !(event.kind === "session" && event.action === "deleted") && !await ownsSession(event.sessionID)) return
+      return runtime.onEvent(event)
+    }, onError: (error) => { void appendLoopLog(directory, "v2-native-event-error", { message: String(error?.message || error) }).catch(() => {}) } })
+    let closed = false
+    let disposeTask
+    function dispose() {
+      if (disposeTask) return disposeTask
+      closed = true
+      disposeTask = Promise.resolve().then(async () => {
+        const errors = []
+        // Stop accepting events before aborting next(); iterator.return() alone
+        // cannot wake an async generator blocked on a public server stream.
+        const stopped = bridge.dispose("native-plugin-disposed").catch((error) => { errors.push(error) })
+        lifecycleAbort.abort()
+        for (const action of [() => runtime.dispose(), () => shellHost.dispose()]) {
+          try { await action() } catch (error) { errors.push(error) }
+        }
+        await stopped
+        for (const registration of [...registrations].reverse()) {
+          try { await cleanup(registration) } catch (error) { errors.push(error) }
+        }
+        if (errors.length) throw new AggregateError(errors, "Native Loop cleanup failed")
+      })
+      return disposeTask
+    }
+    async function execute({ name, sessionID, arguments: argumentsText }) {
+      if (closed) throw new Error("Native Loop is disposed")
+      if (!await ownsSession(sessionID)) throw new Error("Native Loop cannot resolve this session in the plugin location; use its own project/worktree.")
+      if (closed) throw new Error("Native Loop is disposed")
+      if (name === "loop-init") {
+        const output = await initializeProgressFile(directory, argumentsText)
+        await prompt({ sessionID, text: output.created ? `Created ${output.file}.` : `${output.file} already exists; preserved unchanged.`, resume: false })
+        return { handled: true, accepted: true, ...output }
+      }
+      if (["loop-help", "loop-doctor", "loop-logs"].includes(name)) {
+        const text = name === "loop-logs"
+          ? (await readSmallTextFile(path.join(stateDir(directory), "loop.log"), 2_000_000)).split("\n").slice(-60).join("\n") || "No Loop log entries."
+          : name === "loop-doctor"
+            ? `Native OpenCode Loop\nHost: ${ctx.app?.version || "unknown"}\nDirectory: ${directory}\nPrompt hooks: enabled\nCompaction ownership: native host\nDelivery: durable queue\nScheduled timers: ${runtime.scheduledCount()}\nUse /loop-status for paused/admitted job state.`
+            : HELP
+        await prompt({ sessionID, text, resume: false })
+        return { handled: true, accepted: true }
+      }
+      const event = { kind: "command", action: "executed", directory, sessionID, name, arguments: argumentsText }
+      const result = await runtime.onEvent(event)
+      if (result?.accepted === false) throw new Error(result.error || result.blockers?.join(" ") || "Loop command rejected")
+      const shouldWake = result?.job ? result.job.immediate !== false : ["loop-now", "loop-resume"].includes(name)
+      if (result?.accepted && shouldWake) await runtime.wake(event)
+      return result
+    }
+    try {
+      registrations.push(await ctx.session.hook("prompt", async (event) => {
+        if (closed || event.metadata?.opencode_loop_v2 === true || !await ownsSession(event.sessionID)) return
+        if (closed) return
+        return runtime.onEvent({ kind: "foreground", directory, sessionID: event.sessionID })
+      }))
+      registrations.push(await ctx.session.hook("compaction", async (event) => {
+      if (closed || !await ownsSession(event.sessionID)) return
+      if (!closed) return runtime.onEvent({ kind: "compaction", action: "started", directory, sessionID: event.sessionID })
+    }))
+      registrations.push(await ctx.command.transform((draft) => {
+        registerOpenCode2LoopCommands(draft, { execute })
+        if (typeof draft.add !== "function") return
+        for (const name of [...OPENCODE_LOOP_V2_PRESET_NAMES, "loop-init"]) {
+          draft.add({
+            name,
+            description: name === "loop-init" ? "Create a missing project-local progress file." : `Native Loop ${name.slice(5)} preset`,
+            execute: (input) => execute({ name, sessionID: input.sessionID, arguments: commandArguments(input) }),
+          })
+        }
+      }))
+      await bridge.attach(() => ctx.event.subscribe({ signal: lifecycleAbort.signal }))
+      await appendLoopLog(directory, "v2-native-ready", { host: ctx.app?.version || "unknown" })
+      return dispose
+    } catch (error) {
+      await dispose().catch(() => {})
+      throw error
+    }
+  },
+})
+
+export default OpenCodeLoopNativePlugin

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

@@ -0,0 +1,106 @@
+import { stat } from "node:fs/promises"
+import path from "node:path"
+import { runShellCommand, appendLoopLog } from "../core/process.js"
+import { createJobWorkspaceRuntime, dangerousShell } from "../runtime/job-workspace.js"
+
+export function createNativeJobPolicy(options = {}) {
+  const now = options.now || Date.now
+  const run = options.runShellCommand || runShellCommand
+  const workspace = options.workspace || createJobWorkspaceRuntime({ toast: async () => {} })
+
+  function pause(job, reason, failed = false) {
+    job.paused = true
+    job.pauseReason = reason
+    if (failed) job.failureCount = (job.failureCount || 0) + 1
+    return false
+  }
+
+  async function shell(scope, job, command, phase) {
+    if (job.safe && dangerousShell(command)) {
+      return { code: -1, stdout: "", stderr: `Blocked ${phase} by --safe command guard`, blocked: true }
+    }
+    const result = await run(command, scope.directory, Math.max(1, Number(job.timeoutMs) || 120_000))
+    await appendLoopLog(scope.directory, `v2-${phase}`, {
+      sessionID: scope.sessionID, job: job.name || job.id, code: result.code,
+      output: String(result.stdout || "").slice(-8000), error: String(result.stderr || "").slice(-8000),
+    })
+    return result
+  }
+
+  async function checkStop(scope, job) {
+    const created = Date.parse(job.createdAt)
+    if (job.maxRuntimeMs > 0 && Number.isFinite(created) && now() - created >= job.maxRuntimeMs) {
+      job.enabled = false
+      return pause(job, "max-runtime")
+    }
+    if (job.stopFile) {
+      try {
+        await stat(path.resolve(scope.directory, job.stopFile))
+        job.enabled = false
+        return pause(job, "stop-file")
+      } catch (error) { if (error?.code !== "ENOENT") throw error }
+    }
+    if (await workspace.untilReached(scope.directory, job)) {
+      job.enabled = false
+      return pause(job, "until-reached")
+    }
+    return true
+  }
+
+  async function prepare(scope, job, isCurrent = () => true) {
+    if (!await checkStop(scope, job) || !isCurrent()) return false
+    if (job.dryRun) return true
+    if (job.preflightCommand) {
+      const result = await shell(scope, job, job.preflightCommand, "preflight")
+      job.lastPreflightCode = result.code
+      if (result.code !== 0) return pause(job, "preflight-failed", true)
+    }
+    if (!isCurrent()) return false
+    if (job.branch) {
+      await workspace.ensureBranch(scope.directory, job, undefined, scope.sessionID)
+      if (!job.branchDone) return pause(job, "branch-unavailable", true)
+    }
+    return isCurrent()
+  }
+
+  async function finish(scope, job, isCurrent = () => true) {
+    if (!isCurrent() || job.dryRun) return
+    if (job.verifyCommand) {
+      const result = await shell(scope, job, job.verifyCommand, "verify")
+      job.lastVerifyCode = result.code
+      job.lastVerifyAt = now()
+      job.lastVerifyOutput = `${result.stdout || ""}\n${result.stderr || ""}`.trim().slice(-8000)
+      if (result.code !== 0) {
+        job.failureCount = (job.failureCount || 0) + 1
+        if (result.blocked || job.pauseOnVerifyFail || (job.maxFailures > 0 && job.failureCount >= job.maxFailures)) pause(job, "verification-failed")
+        return
+      }
+      job.failureCount = 0
+    }
+    if (!isCurrent()) return
+    if (job.postrunCommand) {
+      const result = await shell(scope, job, job.postrunCommand, "postrun")
+      job.lastPostrunCode = result.code
+      if (result.code !== 0) {
+        pause(job, "postrun-failed", true)
+        return
+      }
+    }
+    if (isCurrent()) await workspace.createCheckpoint(scope.directory, scope.sessionID, job, undefined)
+  }
+
+  async function notify(scope, job, reason) {
+    if (!job.notifyCommand || job.dryRun) return
+    // Placeholders are data, not a route for event/error strings to become shell syntax.
+    const literal = (value) => String(value || "").replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 160)
+    const command = String(job.notifyCommand).replace(/\{reason\}/g, literal(reason)).replace(/\{job\}/g, literal(job.name || job.id))
+    await shell(scope, job, command, "notify")
+  }
+
+  return {
+    pause, checkStop, prepare, finish, notify, shell,
+    buildPrompt: workspace.buildPrompt,
+    snapshotPaths: workspace.snapshotPaths,
+    watchChanged: workspace.watchChanged,
+  }
+}