@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/native-v2-test.mjs

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { createNativeLoopRuntime } from "../src/source/opencode2/native-runtime.js"
+import { normalizeOpenCode2NativeEvent } from "../src/source/opencode2/events.js"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+import { readState } from "../src/source/core/state.js"
+
+let cases = 0
+async function fixture(extra = {}) {
+  const directory = await mkdtemp(path.join(tmpdir(), "loop-native-"))
+  const scope = { directory, sessionID: "ses-native-test" }
+  let clock = 10_000
+  const prompts = [], compacts = [], shells = [], commands = [], hooks = [], timers = []
+  const runtime = createNativeLoopRuntime({
+    directory, now: () => clock,
+    prompt: async (request) => { if (request.resume !== false) prompts.push(request); return { id: request.id } },
+    compact: async (request) => { compacts.push(request); return { id: request.id } },
+    shell: async (request) => { shells.push(request); return { id: request.id, status: "running" } },
+    command: async (request) => { commands.push(request) },
+    wait: async () => {},
+    runShellCommand: async (command) => { hooks.push(command); return { code: 0, stdout: "ok", stderr: "" } },
+    setTimer: (fn, delay) => { const timer = { fn, delay }; timers.push(timer); return timer },
+    clearTimer: (timer) => { timer.cancelled = true },
+    ...extra,
+  })
+  const event = (kind, action, data = {}) => runtime.onEvent({ ...scope, kind, action, ...data })
+  return {
+    runtime, scope, directory, prompts, compacts, shells, commands, hooks, timers, event,
+    add: (args) => event("command", "executed", { name: "loop", arguments: args }),
+    control: (name, args = "") => event("command", "executed", { name, arguments: args }),
+    wake: () => runtime.wake(scope),
+    state: () => readState(directory, scope.sessionID),
+    complete: async (index = prompts.length - 1) => {
+      await event("inbox", "delivered", { inboxID: prompts[index].id })
+      await event("session", "status", { status: "busy" })
+      return event("session", "idle")
+    },
+    tick: async (ms) => { clock += ms; const timer = timers.find((entry) => !entry.cancelled); assert.ok(timer, "expected a timer"); timer.cancelled = true; return timer.fn() },
+    close: async () => { await runtime.dispose(); await rm(directory, { recursive: true, force: true }) },
+  }
+}
+async function test(name, run, extra) {
+  const f = await fixture(extra)
+  try { await run(f); cases++; console.log(`ok ${cases}: ${name}`) }
+  finally { await f.close() }
+}
+
+await test("one durable prompt under concurrent idle notifications", async (f) => {
+  assert.equal((await f.add("0s keep working --max-runs 2")).accepted, true)
+  await Promise.all(Array.from({ length: 12 }, () => f.wake()))
+  assert.equal(f.prompts.length, 1)
+  assert.equal(f.prompts[0].delivery, "queue")
+  assert.equal(f.prompts[0].metadata.opencode_loop_v2, true)
+  await f.event("session", "idle")
+  assert.equal(f.prompts.length, 1, "an unrelated terminal cannot finish an undelivered inbox")
+  await f.complete()
+  assert.equal(f.prompts.length, 2)
+  await f.complete()
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.runCount, 2)
+  assert.equal(job.enabled, false)
+  assert.equal(job.v2Run, undefined)
+})
+
+for (const order of ["compaction-first", "execution-first"]) {
+  await test(`compaction barrier: ${order}`, async (f) => {
+    await f.add('0s continue --max-runs 2 --verify "node verify.js"')
+    await f.wake()
+    await f.event("inbox", "delivered", { inboxID: f.prompts[0].id })
+    await f.event("compaction", "started")
+    await f.event("message", "updated", { role: "user", messageID: "core-marker" })
+    const first = order === "compaction-first" ? ["compaction", "ended"] : ["session", "idle"]
+    const second = order === "compaction-first" ? ["session", "idle"] : ["compaction", "ended"]
+    await f.event(...first)
+    assert.equal(f.prompts.length, 1)
+    assert.equal(f.hooks.length, 0)
+    await f.event(...second)
+    assert.equal(f.hooks.length, 1)
+    assert.equal(f.prompts.length, 2)
+  })
+}
+
+await test("rejected or uncertain admission never charges a run or spins", async (f) => {
+  await f.add("0s task --max-runs 1")
+  await f.wake()
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.runCount, 0)
+  assert.equal(job.enabled, true)
+  assert.equal(job.paused, true)
+  assert.equal(job.pauseReason, "admission-uncertain")
+  assert.ok(job.v2Run.id, "retain the identity of a potentially admitted request")
+  await f.event("session", "idle")
+  assert.equal((await f.state()).jobs[0].failureCount, 1)
+}, { prompt: async () => { throw new Error("lost response") } })
+
+await test("confirmed pending cancellation refunds only the unexecuted run", async (f) => {
+  await f.add("0s task --max-runs 1")
+  await f.wake()
+  await f.control("loop-pause")
+  await f.event("inbox", "cancelled", { inboxID: f.prompts[0].id })
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.runCount, 0)
+  assert.equal(job.enabled, true)
+  assert.equal(job.paused, true)
+  assert.equal(job.v2Run, undefined)
+  await f.control("loop-resume")
+  await f.wake()
+  assert.equal(f.prompts.length, 2)
+})
+
+await test("foreground admission suppresses verification and continuation", async (f) => {
+  await f.add('0s task --max-runs 1 --verify "node verify.js"')
+  await f.wake()
+  await f.event("inbox", "delivered", { inboxID: f.prompts[0].id })
+  await f.event("foreground", "admitted")
+  await f.event("session", "idle")
+  assert.equal(f.hooks.length, 0)
+  assert.equal(f.prompts.length, 1)
+})
+
+await test("soft timeout cannot abort native compaction", async (f) => {
+  await f.add("0s task --max-runs 2 --timeout 10ms")
+  await f.wake()
+  await f.event("inbox", "delivered", { inboxID: f.prompts[0].id })
+  await f.event("compaction", "started")
+  await f.tick(11)
+  assert.equal((await f.state()).jobs[0].pauseReason, "timeout-waiting-for-host-boundary")
+  await f.event("compaction", "ended")
+  await f.event("session", "idle")
+  assert.equal(f.prompts.length, 1)
+})
+
+await test("prompt and include files use the native prompt", async (f) => {
+  await writeFile(path.join(f.directory, "instructions.md"), "UNIQUE_NATIVE_INSTRUCTIONS")
+  await writeFile(path.join(f.directory, "progress.md"), "UNIQUE_NATIVE_CONTEXT")
+  await f.add("0s task --prompt-file instructions.md --include-file progress.md --max-runs 1")
+  await f.wake()
+  assert.match(f.prompts[0].text, /UNIQUE_NATIVE_INSTRUCTIONS/)
+  assert.match(f.prompts[0].text, /UNIQUE_NATIVE_CONTEXT/)
+})
+
+await test("watch baseline does not trigger until the file changes", async (f) => {
+  await writeFile(path.join(f.directory, "progress.md"), "initial")
+  await f.add("--watch progress.md task --max-runs 1")
+  await f.wake()
+  assert.equal(f.prompts.length, 0)
+  await writeFile(path.join(f.directory, "progress.md"), "changed and longer")
+  await f.tick(1000)
+  assert.equal(f.prompts.length, 1)
+})
+
+await test("control state is not --until completion evidence", async (f) => {
+  await f.add("0s task --until UNIQUE_COMPLETION_MARKER --max-runs 1")
+  await f.wake()
+  assert.equal(f.prompts.length, 1)
+})
+
+await test("stop-file is enforced before a future interval is due", async (f) => {
+  await f.add("1h task --no-now --stop-file STOP")
+  await writeFile(path.join(f.directory, "STOP"), "stop")
+  await f.tick(1000)
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.enabled, false)
+  assert.equal(job.pauseReason, "stop-file")
+  assert.equal(f.prompts.length, 0)
+})
+
+await test("maximum runtime is enforced without waiting for the next interval", async (f) => {
+  await f.add("1h task --no-now --max-runtime 5s")
+  await f.tick(5001)
+  assert.equal((await f.state()).jobs[0].pauseReason, "max-runtime")
+  assert.equal(f.prompts.length, 0)
+})
+
+await test("preflight failure does not consume a run", async (f) => {
+  await f.add('0s task --preflight "node check.js" --max-runs 1')
+  await f.wake()
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.runCount, 0)
+  assert.equal(job.pauseReason, "preflight-failed")
+  assert.equal(f.prompts.length, 0)
+}, { runShellCommand: async () => ({ code: 3, stdout: "", stderr: "not ready" }) })
+
+await test("safe guard covers verification commands too", async (f) => {
+  await f.add('0s task --safe --verify "git reset --hard" --max-runs 1')
+  await f.wake()
+  await f.complete()
+  assert.equal(f.hooks.length, 0)
+  assert.equal((await f.state()).jobs[0].pauseReason, "verification-failed")
+})
+
+await test("dry-run never invokes preflight, shell, or the native model", async (f) => {
+  await f.add('0s --shell echo preview --dry-run --preflight "echo preflight" --git-checkpoint')
+  const out = await f.wake()
+  assert.equal(out.dryRun, true)
+  assert.equal(f.prompts.length + f.shells.length + f.hooks.length, 0)
+  assert.equal((await f.state()).jobs[0].runCount, 0)
+})
+
+await test("compaction cadence does not charge a logical run", async (f) => {
+  await f.add("0s task --max-runs 2 --compact-every 1")
+  await f.wake()
+  await f.complete()
+  assert.equal(f.compacts.length, 1)
+  assert.equal((await f.state()).jobs[0].runCount, 1)
+  await f.event("compaction", "started")
+  await f.event("compaction", "ended")
+  await f.event("session", "idle")
+  assert.equal(f.prompts.length, 2)
+  assert.equal((await f.state()).jobs[0].runCount, 2)
+})
+
+await test("a failed delivered execution is paused and can be explicitly resumed", async (f) => {
+  await f.add("0s task --max-runs 3")
+  await f.wake()
+  await f.event("inbox", "delivered", { inboxID: f.prompts[0].id })
+  await f.event("session", "error", { reason: "execution-failed" })
+  assert.equal((await f.state()).jobs[0].paused, true)
+  assert.equal((await f.state()).jobs[0].v2Run, undefined)
+  await f.control("loop-resume")
+  await f.wake()
+  assert.equal(f.prompts.length, 2)
+})
+
+await test("branch failure cannot run on the wrong branch", async (f) => {
+  await f.add("0s task --branch native-loop-test --max-runs 1")
+  await f.wake()
+  assert.equal(f.prompts.length, 0)
+  assert.equal((await f.state()).jobs[0].pauseReason, "branch-unavailable")
+})
+
+{
+  let resolveBuild, started
+  const building = new Promise((resolve) => { started = resolve })
+  const gate = new Promise((resolve) => { resolveBuild = resolve })
+  await test("foreground admission during file preparation prevents dispatch", async (f) => {
+    await f.add("0s task --max-runs 1")
+    const pending = f.wake()
+    await building
+    await f.event("foreground", "admitted")
+    resolveBuild()
+    await pending
+    assert.equal(f.prompts.length, 0)
+    assert.equal((await f.state()).jobs[0].runCount, 0)
+  }, { workspace: { untilReached: async () => false, buildPrompt: async () => { started(); await gate; return "prepared" }, createCheckpoint: async () => {} } })
+}
+
+{
+  const raw = { id: "event-native-duplicate", type: "session.inbox.delivered", location: { directory: "/workspace" }, data: { sessionID: "ses-native", inboxID: "msg-native" } }
+  assert.equal(normalizeOpenCode2NativeEvent(raw).inboxID, "msg-native")
+  let count = 0
+  const bridge = createOpenCode2EventBridge({ directory: "/workspace", onEvent: async () => { count++ } })
+  await bridge.dispatch(raw)
+  await bridge.dispatch(raw)
+  assert.equal(count, 1)
+  await bridge.dispose()
+  cases++
+  console.log(`ok ${cases}: duplicate native event IDs are processed once`)
+}
+console.log(`Native OpenCode 2 safety: ${cases} scenarios passed`)

package/scripts/network-recovery-test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict"
-import { isCompletionBoundedContinuation, isTerminalNoWorkReply } from "../src/source/core/continuation.js"
+import { isCompletionBoundedContinuation, isTerminalNoWorkReply, isWaitingUserReply } from "../src/source/core/continuation.js"
 import { isTransientNetworkError, networkRetryDelayMs, refundInfrastructureRun } from "../src/source/runtime/network-recovery.js"
 import { createSessionStatusRuntime } from "../src/source/runtime/session-status.js"
 import { applyTerminalContinuationGuard } from "../src/source/runtime/terminal-guard.js"
@@ -90,6 +90,10 @@ assert.equal(isCompletionBoundedContinuation("devam et"), false)
 assert.equal(isCompletionBoundedContinuation("devam et bitene kadar devam tamamen projeyi bitir"), true)
 assert.equal(isTerminalNoWorkReply("Proje tamamlandı — 28/28 test yeşil. Yapılacak iş yok. Sıfır bilinen hata."), true)
 assert.equal(isTerminalNoWorkReply("Proje tamamlandı ama sıradaki iş build doğrulaması."), false)
+assert.equal(isWaitingUserReply("Durum sabit.\n\nOnay bekleyenler: commit + push, canlı migration, cihaz testi."), true)
+assert.equal(isWaitingUserReply("Waiting for your approval before I can push the release."), true)
+assert.equal(isWaitingUserReply("Onay gerekmiyor; sıradaki iş build doğrulaması."), false)
+assert.equal(isWaitingUserReply("Deployment needs your approval, but next step is local verification."), false)
 
 {
   const terminalMessages = [{
@@ -122,6 +126,39 @@ assert.equal(isTerminalNoWorkReply("Proje tamamlandı ama sıradaki iş build do
   const untouched = await applyTerminalContinuationGuard("/repo", client, "s", infinite)
   assert.equal(untouched.terminal, false)
   assert.equal(untouched.job.paused, false, "plain /loop devam et must remain intentionally infinite")
+
+  const waitingMessages = [{
+    info: { role: "assistant", time: { created: 2_200, completed: 2_300 } },
+    parts: [{ type: "text", text: "Durum sabit.\n\nOnay bekleyenler: commit + push, canlı migration, cihaz testi." }],
+  }]
+  const waitingClient = { session: { messages: async () => ({ data: waitingMessages }) } }
+  const waiting = {
+    id: "waiting",
+    action: "devam et",
+    scheduleMode: "idle",
+    lastRunAt: 1_500,
+    paused: false,
+  }
+  let waitingResult = await applyTerminalContinuationGuard("/repo", waitingClient, "s", waiting)
+  assert.equal(waitingResult.waitingUser, true)
+  assert.equal(waitingResult.waitingUserPausedNow, false)
+  assert.equal(waitingResult.job.waitingUserCount, 1)
+  assert.equal(waitingResult.job.paused, false)
+  waitingResult = await applyTerminalContinuationGuard("/repo", waitingClient, "s", waitingResult.job)
+  assert.equal(waitingResult.waitingUserPausedNow, true, "two explicit user-dependency replies should pause plain continuation")
+  assert.equal(waitingResult.job.paused, true)
+  assert.equal(waitingResult.job.lastFailureReason, "waiting_user")
+
+  const productiveMessages = [{
+    info: { role: "assistant", time: { created: 2_400, completed: 2_500 } },
+    parts: [{ type: "text", text: "Deployment needs your approval, but next step is local verification." }],
+  }]
+  const productiveClient = { session: { messages: async () => ({ data: productiveMessages }) } }
+  const productive = { ...waitingResult.job, paused: false, waitingUserCount: 1 }
+  const productiveResult = await applyTerminalContinuationGuard("/repo", productiveClient, "s", productive)
+  assert.equal(productiveResult.waitingUser, false)
+  assert.equal(productiveResult.job.waitingUserCount, 0, "a reply with autonomous next work must clear waiting-user streak")
+  assert.equal(productiveResult.job.paused, false)
 }
 
 {

package/scripts/opencode-host.mjs

@@ -0,0 +1,47 @@
+import fs from "node:fs"
+import path from "node:path"
+
+function versionFromOutput(output) {
+  for (const line of String(output || "").split(/\r?\n/)) {
+    const match = line.trim().match(/^(?:opencode(?:2)?\s+v?)?v?(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/)
+    if (match) return { major: Number(match[1]), version: line.trim() }
+  }
+  return undefined
+}
+
+// Probe once before any workload. An explicit binary never falls back to a
+// different installation, and native mode never silently selects a V1 host.
+export async function selectOpenCodeHost({ binary, legacyV1 = false, probe } = {}) {
+  if (typeof probe !== "function") throw new TypeError("OpenCode host selection requires a version probe")
+  const major = legacyV1 ? 1 : 2
+  const explicit = String(binary || "").trim()
+  const candidates = explicit ? [explicit] : legacyV1 ? ["opencode"] : ["opencode", "opencode2"]
+  for (const candidate of candidates) {
+    const result = await probe(candidate)
+    if (result?.code !== 0 || result.timedOut) continue
+    const observed = versionFromOutput(`${result.stdout || ""}\n${result.stderr || ""}`)
+    if (observed?.major === major) return { binary: candidate, ...observed }
+  }
+  throw new Error(`Could not select OpenCode ${major}.x${explicit ? ` from ${JSON.stringify(explicit)}` : ""}. Set OPENCODE_BIN to the matching executable.${legacyV1 ? "" : " V1 requires explicit --legacy-v1; no workload was dispatched."}`)
+}
+
+function canonicalDirectory(directory) {
+  const absolute = path.resolve(directory)
+  try { return fs.realpathSync.native(absolute) } catch { return absolute }
+}
+
+export function projectSessions(text, directory, native = true) {
+  let parsed
+  try { parsed = JSON.parse(String(text || "")) } catch { throw new Error("OpenCode session list returned invalid JSON") }
+  const sessions = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.data) ? parsed.data : undefined
+  if (!sessions) throw new Error("OpenCode session list did not return an array")
+  const project = canonicalDirectory(directory)
+  return sessions.filter((session) => {
+    if (typeof session?.id !== "string" || !session.id.trim()) return false
+    const location = session.directory ?? session.location?.directory
+    // V2 session list is project-scoped, not worktree-scoped. Never let its
+    // newest session pull a daemon into another worktree or an unknown path.
+    if (typeof location !== "string" || !location.trim()) return !native
+    return canonicalDirectory(location) === project
+  })
+}

package/scripts/opencode2-loop-canary.mjs

@@ -2,7 +2,7 @@ import assert from "node:assert/strict"
 import { createServer } from "node:http"
 import net from "node:net"
 import { execFileSync, spawn } from "node:child_process"
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { appendFile, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import process from "node:process"
@@ -11,9 +11,12 @@ import { fileURLToPath, pathToFileURL } from "node:url"
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const LOOP_OBJECTIVE = "real OpenCode 2 loop canary"
 const EXPECTED_TURNS = 2
-const EXPECTED_COMMANDS = ["loop", "loop-pause", "loop-resume", "loop-stop", "loop-remove", "loop-clear"]
+const NATIVE_PRESETS = ["loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev", "loop-command", "loop-cmd", "loop-prompt", "loop-ask", "loop-shell"]
+const EXPECTED_COMMANDS = ["loop", "loop-pause", "loop-resume", "loop-stop", "loop-remove", "loop-clear", ...(process.env.OPENCODE2_NATIVE_REQUIRED === "1" ? [...NATIVE_PRESETS, "loop-init"] : [])]
 const SERVER_USERNAME = "opencode"
 const SERVER_PASSWORD = "opencode-loop-v2-canary"
+const OPENCODE_BINARY = process.env.OPENCODE2_BINARY || "opencode2"
+const CURRENT_COMMAND_FIELDS = process.env.OPENCODE2_CURRENT_COMMAND_FIELDS === "1"
 
 function appendLog(current, chunk, limit = 100_000) {
   return (current + String(chunk)).slice(-limit)
@@ -161,16 +164,42 @@ function startProvider() {
 }
 
 function bridgePluginSource() {
-  return `import { writeFile } from "node:fs/promises"
+  return `import { appendFile, writeFile } from "node:fs/promises"
 
 export default {
   id: "bybrawe.opencode-loop.v2.loop-canary-bridge",
   async setup(ctx) {
     const module = await import(process.env.OPENCODE_LOOP_V2_PLUGIN_URL)
-    const cleanup = await module.default.setup(ctx)
+    const traceFile = process.env.OPENCODE_LOOP_V2_EVENT_TRACE
+    const pluginTraceFile = process.env.OPENCODE_LOOP_V2_PLUGIN_EVENT_TRACE
+    const pluginContext = typeof ctx?.event?.subscribe === "function"
+      ? {
+          ...ctx,
+          event: {
+            ...ctx.event,
+            subscribe(options) {
+              const source = ctx.event.subscribe(options)
+              return {
+                async *[Symbol.asyncIterator]() {
+                  for await (const event of source) {
+                    const line = JSON.stringify(String(event?.type || "").startsWith("session.") ? event : { id: event?.id, type: event?.type }) + "\\n"
+                    if (traceFile) await appendFile(traceFile, line, "utf8")
+                    if (pluginTraceFile) await appendFile(pluginTraceFile, line, "utf8")
+                    yield event
+                  }
+                },
+              }
+            },
+          },
+        }
+      : ctx
+    const goalURL = process.env.OPENCODE_GOAL_V2_PLUGIN_URL
+    const goalCleanup = goalURL ? await (await import(goalURL)).default.setup(ctx) : undefined
+    const cleanup = await module.default.setup(pluginContext)
     await writeFile(process.env.OPENCODE_LOOP_V2_MARKER, JSON.stringify({ activated: true }, null, 2), "utf8")
     return async () => {
       if (typeof cleanup === "function") await cleanup()
+      if (typeof goalCleanup === "function") await goalCleanup()
     }
   },
 }
@@ -187,8 +216,10 @@ async function main() {
 
   const workspace = await mkdtemp(path.join(os.tmpdir(), "opencode-loop-v2-e2e-"))
   const home = path.join(workspace, ".home")
-  const pluginDir = path.join(workspace, ".opencode", "plugins")
+  const pluginDir = path.join(home, ".config", "opencode", "plugins")
   const marker = path.join(workspace, "v2-real-adapter-marker.json")
+  const eventTrace = path.join(workspace, "v2-native-events.jsonl")
+  const pluginEventTrace = path.join(workspace, "v2-plugin-events.jsonl")
   const provider = startProvider()
   const providerPort = await provider.listen()
   let server
@@ -225,6 +256,7 @@ async function main() {
     },
   }, null, 2)}\n`)
 
+  await writeFile(path.join(workspace, ".gitignore"), ".home/\n.opencode/\n*v2*events.jsonl\n")
   execFileSync("git", ["init", "--quiet", workspace], { stdio: "ignore" })
   execFileSync("git", ["-C", workspace, "config", "user.email", "opencode-loop-ci@example.invalid"], { stdio: "ignore" })
   execFileSync("git", ["-C", workspace, "config", "user.name", "OpenCode Loop CI"], { stdio: "ignore" })
@@ -239,8 +271,10 @@ async function main() {
     XDG_DATA_HOME: path.join(home, ".local", "share"),
     XDG_STATE_HOME: path.join(home, ".local", "state"),
     XDG_CACHE_HOME: path.join(home, ".cache"),
-    OPENCODE_LOOP_V2_PLUGIN_URL: pathToFileURL(path.join(repoRoot, "src", "source", "opencode2", "experimental.js")).href,
+    OPENCODE_LOOP_V2_PLUGIN_URL: pathToFileURL(path.join(repoRoot, "src", ...(process.env.OPENCODE2_NATIVE_REQUIRED === "1" ? ["native.js"] : ["source", "opencode2", "experimental.js"]))).href,
     OPENCODE_LOOP_V2_MARKER: marker,
+    OPENCODE_LOOP_V2_EVENT_TRACE: eventTrace,
+    OPENCODE_LOOP_V2_PLUGIN_EVENT_TRACE: pluginEventTrace,
     OPENCODE_SERVER_USERNAME: SERVER_USERNAME,
     OPENCODE_SERVER_PASSWORD: SERVER_PASSWORD,
     OPENCODE_DISABLE_AUTOUPDATE: "true",
@@ -253,6 +287,10 @@ async function main() {
     if (sessionID) {
       try { state = await readFile(path.join(workspace, ".opencode", "opencode-loop", `${sessionID}.json`), "utf8") } catch {}
     }
+    let nativeEvents = "missing"
+    let pluginEvents = "missing"
+    try { nativeEvents = await readFile(eventTrace, "utf8") } catch {}
+    try { pluginEvents = await readFile(pluginEventTrace, "utf8") } catch {}
     return [
       `apiPrefix=${String(apiPrefix)}`,
       `commands=${JSON.stringify([...latestCommands])}`,
@@ -260,14 +298,18 @@ async function main() {
       `sessionID=${sessionID || "none"}`,
       `commandError=${String(commandError ?? "none")}`,
       `state=${state}`,
+      `binary=${OPENCODE_BINARY}`,
+      `currentCommandFields=${CURRENT_COMMAND_FIELDS}`,
       `serverExit=${server?.exitCode}`,
+      `nativeEvents=${nativeEvents.slice(-40_000)}`,
+      `pluginEvents=${pluginEvents.slice(-40_000)}`,
       `serverLog=${serverLog}`,
     ].join("\n")
   }
 
   try {
     const port = await reservePort()
-    server = spawn("opencode2", ["serve", "--hostname", "127.0.0.1", "--port", String(port)], {
+    server = spawn(OPENCODE_BINARY, ["serve", "--hostname", "127.0.0.1", "--port", String(port)], {
       cwd: workspace,
       env,
       windowsHide: true,
@@ -327,6 +369,8 @@ async function main() {
       return EXPECTED_COMMANDS.every((name) => latestCommands.has(name))
     }, "plugin-registered Loop commands to enter the real V2 registry", diagnostics, 30_000)
 
+    if (process.env.OPENCODE_GOAL_V2_PLUGIN_URL) assert.ok(latestCommands.has("goal"), "both native plugin command registries must load")
+
     const createdResponse = await request(`${apiPrefix}/session`, {
       method: "POST",
       body: JSON.stringify({ title: "OpenCode 2 Loop canary" }),
@@ -336,9 +380,13 @@ async function main() {
     sessionID = String(session?.id ?? "")
     assert.ok(sessionID, `OpenCode 2 did not create a session: ${createdResponse.text}\n${await diagnostics()}`)
 
+    const commandBody = (command, argumentsText = "") => CURRENT_COMMAND_FIELDS
+      ? { name: command, text: argumentsText }
+      : { command, arguments: argumentsText }
+
     const commandPromise = request(`${apiPrefix}/session/${encodeURIComponent(sessionID)}/command`, {
       method: "POST",
-      body: JSON.stringify({ command: "loop", arguments: `0s --max-runs ${EXPECTED_TURNS} ${LOOP_OBJECTIVE}` }),
+      body: JSON.stringify(commandBody("loop", `0s --max-runs ${EXPECTED_TURNS} ${LOOP_OBJECTIVE}`)),
     }, 120_000).catch((error) => {
       commandError = error
       return null
@@ -371,7 +419,7 @@ async function main() {
     const sendControl = async (command, argumentsText = "") => {
       const response = await request(`${apiPrefix}/session/${encodeURIComponent(sessionID)}/command`, {
         method: "POST",
-        body: JSON.stringify({ command, arguments: argumentsText }),
+        body: JSON.stringify(commandBody(command, argumentsText)),
       }, 120_000)
       if (!response.ok) throw new Error(`${command} failed: HTTP ${response.status} ${response.text}\n${await diagnostics()}`)
       return response
@@ -383,7 +431,7 @@ async function main() {
     await sendControl("loop-resume", "default")
     await waitFor(async () => {
       const job = await jobNamed("default")
-      return job?.paused === false && job?.lastRunAt === 0
+      return job?.paused === false && (job?.lastRunAt === 0 || job?.runNowRequestedAt > 0)
     }, "real V2 loop-resume state mutation", diagnostics, 30_000)
 
     await sendControl("loop-stop", "default")
@@ -409,6 +457,67 @@ async function main() {
     assert.equal(provider.stats.loopRequests, EXPECTED_TURNS + 2, `control lifecycle should add exactly two autonomous Loop turns\n${await diagnostics()}`)
     assert.equal(server.exitCode, null, `OpenCode 2 server exited during control lifecycle canary\n${await diagnostics()}`)
 
+    if (process.env.OPENCODE2_NATIVE_REQUIRED === "1") {
+      const nativeLog = await readFile(path.join(workspace, ".opencode/opencode-loop/loop.log"), "utf8")
+      assert.match(nativeLog, /v2-native-ready/, "the real host must load the native implementation")
+      assert.match(nativeLog, /v2-native-admitted/, "the native implementation must own the admissions")
+      await writeFile(path.join(workspace, "native-preflight.cjs"), 'require("node:fs").appendFileSync("native-preflight.txt", "P")')
+      await writeFile(path.join(workspace, "native-verify.cjs"), 'require("node:fs").appendFileSync("native-verify.txt", "V")')
+      await sendControl("loop", '0s native verified task --max-runs 1 --name verified --preflight "node native-preflight.cjs" --verify "node native-verify.cjs"')
+      await waitFor(async () => {
+        const job = await jobNamed("verified")
+        return job?.runCount === 1 && !job.v2Run && job.lastVerifyCode === 0
+      }, "native preflight and post-turn verification", diagnostics, 30_000)
+      assert.equal(await readFile(path.join(workspace, "native-preflight.txt"), "utf8"), "P")
+      assert.equal(await readFile(path.join(workspace, "native-verify.txt"), "utf8"), "V")
+      await sendControl("loop-clear")
+      await sendControl("loop-shell", '0s node native-preflight.cjs --max-runs 1 --name native-shell')
+      await waitFor(async () => {
+        const job = await jobNamed("native-shell")
+        return job?.runCount === 1 && !job.v2Run
+      }, "native shell terminal correlation", diagnostics, 20_000)
+      assert.equal(await readFile(path.join(workspace, "native-preflight.txt"), "utf8"), "PP")
+      await sendControl("loop-clear")
+      const beforePresets = provider.stats.loopRequests
+      await sendControl("loop-init")
+      assert.match(await readFile(path.join(workspace, "progress.md"), "utf8"), /^# Progress\n/)
+      await writeFile(path.join(workspace, "progress.md"), "user-owned progress\n")
+      await sendControl("loop-init")
+      assert.equal(await readFile(path.join(workspace, "progress.md"), "utf8"), "user-owned progress\n")
+      for (const name of NATIVE_PRESETS.filter(name => name !== "loop-compact")) {
+        const action = ["loop-command", "loop-cmd"].includes(name) ? "/review project"
+          : name === "loop-shell" ? "npm test"
+          : ["loop-prompt", "loop-ask"].includes(name) ? "did you run tests?" : ""
+        await sendControl(name, `every 1h --dry-run --name ${name} ${action}`.trim())
+        const saved = await jobNamed(name)
+        assert.ok(saved, `${name} must create a native job`)
+        assert.equal(saved.intervalMs, 3600000, `${name}: explicit every 1h must survive native registration` )
+        assert.equal(saved.immediate, false)
+        assert.equal(saved.runCount, 0)
+        assert.equal(saved.dryRun, true)
+      }
+
+      await sendControl("loop", "after 1h --now --max-runs 9 --dry-run --name native-once continue once")
+      const onceJob = await jobNamed("native-once")
+      assert.equal(onceJob.intervalMs, 3600000)
+      assert.equal(onceJob.maxRuns, 1, "after remains one-shot even with a conflicting max-runs flag")
+      assert.equal(onceJob.immediate, false, "after never dispatches immediately")
+      assert.equal(onceJob.action, "continue once")
+      await sendControl("loop-testfix", "every 1h --dry-run --name custom-testfix npm run check")
+      const testfix = await jobNamed("custom-testfix")
+      assert.equal(testfix.verifyCommand, "npm run check")
+      assert.match(testfix.action, /Test command hint: npm run check$/)
+      await sendControl("loop", "continue the project --dry-run --name native-shorthand")
+      const shorthand = await jobNamed("native-shorthand")
+      assert.equal(shorthand.intervalMs, 0)
+      assert.equal(shorthand.action, "continue the project")
+      assert.equal(shorthand.pauseReason, "dry-run")
+
+      assert.equal(provider.stats.loopRequests, beforePresets, "deferred presets and progress initialization cannot trigger model work")
+      await sendControl("loop-clear")
+
+    }
+
     console.log(JSON.stringify({
       ok: true,
       apiPrefix,

package/scripts/package-native-smoke.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const npmCLI = process.env.npm_execpath
+assert.ok(npmCLI, "run this through npm run package:smoke")
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, { cwd, encoding: "utf8", timeout: 180_000, maxBuffer: 8 * 1024 * 1024, windowsHide: true })
+  if (result.error) throw result.error
+  assert.equal(result.status, 0, [result.stdout, result.stderr].filter(Boolean).join("\n"))
+  return result.stdout
+}
+const temp = await mkdtemp(path.join(tmpdir(), "loop native package "))
+try {
+  const packed = JSON.parse(run(process.execPath, [npmCLI, "pack", root, "--json", "--ignore-scripts"], temp))
+  assert.equal(packed.length, 1)
+  const files = new Set(packed[0].files.map((entry) => entry.path))
+  for (const entry of ["src/server.js", "src/native.js", "src/v1.js", "src/index.js"]) assert.ok(files.has(entry), `missing ${entry}`)
+  const consumer = path.join(temp, "consumer with spaces")
+  await mkdir(consumer)
+  await writeFile(path.join(consumer, "package.json"), JSON.stringify({ private: true, type: "module" }))
+  run(process.execPath, [npmCLI, "install", "--ignore-scripts", "--omit=dev", "--omit=peer", "--no-audit", "--no-fund", path.join(temp, packed[0].filename)], consumer)
+  console.log(run(process.execPath, [path.join(root, "scripts/native-entry-test.mjs"), consumer], root).trim())
+  console.log("Production tarball native entry isolation and lazy legacy delegation PASS")
+} finally {
+  await rm(temp, { recursive: true, force: true, maxRetries: 8, retryDelay: 100 })
+}