@bybrawe/opencode-loop 0.5.38 → 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/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

@@ -11,7 +11,8 @@ 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"
@@ -181,7 +182,7 @@ export default {
               return {
                 async *[Symbol.asyncIterator]() {
                   for await (const event of source) {
-                    const line = JSON.stringify(event) + "\\n"
+                    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
@@ -192,10 +193,13 @@ export default {
           },
         }
       : 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()
     }
   },
 }
@@ -252,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" })
@@ -266,7 +271,7 @@ 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,
@@ -364,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" }),
@@ -424,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")
@@ -450,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 })
+}

package/scripts/publish-workflow-test.mjs

@@ -2,29 +2,70 @@ import assert from "node:assert/strict"
 import { readFile } from "node:fs/promises"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
+import { validateRelease, releaseDecision, assertPublishedSource, waitForPublishedGoal } from "./native-release.mjs"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
-const workflowPath = path.join(repoRoot, ".github", "workflows", "publish-npm.yml")
-const workflow = await readFile(workflowPath, "utf8")
-
-assert.match(workflow, /ref:\s*\$\{\{ github\.sha \}\}/, "publish workflow must checkout the release trigger SHA")
-assert.doesNotMatch(workflow, /ref:\s*main\b/, "publish workflow must not checkout a moving main branch")
-assert.match(workflow, /git merge-base --is-ancestor "\$GITHUB_SHA" origin\/main/, "release source must be verified against main history")
-assert.match(workflow, /COMMIT_SHA="\$GITHUB_SHA"/, "release tag must target the immutable trigger SHA")
-assert.match(workflow, /group:\s*npm-release/, "npm publication must be serialized")
-assert.match(workflow, /cancel-in-progress:\s*false/, "a newer release must not cancel an in-flight publication")
-
-assert.match(workflow, /Decide whether npm publish is needed/, "release reruns must detect an already-published immutable version")
-assert.match(workflow, /steps\.npm-state\.outputs\.publish == 'true'/, "npm publish must be idempotently gated")
-assert.match(workflow, /for attempt in \{1\.\.60\}/, "registry verification must allow bounded multi-minute propagation")
-assert.match(workflow, /--registry=https:\/\/registry\.npmjs\.org/, "registry checks must target the authoritative npm registry")
+const workflow = await readFile(path.join(repoRoot, ".github/workflows/publish-npm.yml"), "utf8")
+assert.match(workflow, /ref:\s*\$\{\{ github\.sha \}\}/, "checkout must use the immutable trigger SHA")
+assert.doesNotMatch(workflow, /ref:\s*main\b/, "publication cannot checkout moving main")
+assert.match(workflow, /git merge-base --is-ancestor "\$GITHUB_SHA" origin\/main/)
+assert.match(workflow, /COMMIT_SHA="\$GITHUB_SHA"/)
+assert.match(workflow, /group:\s*npm-release/)
+assert.match(workflow, /cancel-in-progress:\s*false/)
+assert.match(workflow, /branches:\s*\[main\]/)
+assert.match(workflow, /paths:\s*\[\.github\/npm-release\.json\]/)
+assert.doesNotMatch(workflow, /release\/npm-v|git push|Remove one-shot release branch/, "main-only publication must not create or delete branches")
+assert.match(workflow, /needs:\s*\[native-regressions, real-native-pair\]/)
+assert.match(workflow, /node scripts\/native-release\.mjs ci/)
+assert.match(workflow, /git diff --exit-code -- src\/index.js src\/server.js src\/native.js/)
+assert.match(workflow, /npm run package:smoke/)
+assert.match(workflow, /windows-latest/)
+assert.match(workflow, /Decide whether npm publish is needed/)
+assert.match(workflow, /steps\.npm-state\.outputs\.publish == 'true'/)
+assert.match(workflow, /for attempt in \{1\.\.60\}/)
+assert.match(workflow, /--registry=https:\/\/registry\.npmjs\.org/)
+assert.match(workflow, /native-release\.mjs verify/)
+assert.match(workflow, /node_modules\/@bybrawe\/opencode-loop\/scripts\/opencode2-loop-canary.mjs/)
+assert.match(workflow, /node_modules\/@bybrawe\/opencode-goal\/dist\/server.js/)
+assert.match(workflow, /ref: \$\{\{ steps.release.outputs.goal_sha \}\}/)
+assert.doesNotMatch(workflow, /secrets\.NPM_TOKEN/)
 
 const publishIndex = workflow.indexOf("npm publish --access public")
 const verifyIndex = workflow.indexOf("Verify published version is readable from npm")
 const tagIndex = workflow.indexOf("Create tag and GitHub release")
-const cleanupIndex = workflow.indexOf("Remove one-shot release branch")
-assert.ok(publishIndex >= 0 && verifyIndex > publishIndex, "npm publication must be verified after publish")
-assert.ok(tagIndex > verifyIndex, "tag/release creation must happen only after npm verification")
-assert.ok(cleanupIndex > tagIndex, "release branch cleanup must be the final release step")
+assert.ok(publishIndex >= 0 && verifyIndex > publishIndex)
+assert.ok(tagIndex > verifyIndex)
+assert.match(workflow.slice(tagIndex), /needs:\s*publish/, "GitHub release must depend on verified publication")
+for (const block of workflow.split(/- uses: actions\/checkout@/).slice(1)) assert.match(block.split(/\n\s*- (?:uses|name|run):/)[0], /persist-credentials:\s*false/)
+const publisher = workflow.slice(workflow.indexOf("  publish:\n"), workflow.indexOf("  github-release:\n"))
+assert.doesNotMatch(publisher, /contents:\s*write/, "OIDC publisher must not gain repository mutation privileges")
+
+const sha = "a".repeat(40)
+const request = { name: "@bybrawe/opencode-loop", version: "0.6.0", predecessor: "0.5.38", goal: { version: "1.3.39", sha: "b".repeat(40) } }
+const pkg = { name: request.name, version: request.version }
+const env = { GITHUB_REPOSITORY: "ByBrawe/opencode-loop", GITHUB_REF: "refs/heads/main", GITHUB_SHA: sha }
+assert.strictEqual(validateRelease(request, pkg, env), request)
+for (const change of [{ GITHUB_REPOSITORY: "someone/fork" }, { GITHUB_REF: "refs/heads/release" }, { GITHUB_SHA: "main" }]) assert.throws(() => validateRelease(request, pkg, { ...env, ...change }))
+assert.throws(() => validateRelease({ ...request, version: "9.0.0" }, pkg, env))
+assert.throws(() => validateRelease(request, { ...pkg, version: "0.5.38" }, env))
+assert.equal(releaseDecision(404, null, request, sha, "0.5.38"), true)
+for (const status of [401, 403, 429, 500, 503]) assert.throws(() => releaseDecision(status, null, request, sha, "0.5.38"))
+assert.throws(() => releaseDecision(404, null, request, sha, "0.7.0"))
+const manifest = { ...pkg, gitHead: sha }
+assert.equal(releaseDecision(200, manifest, request, sha), false)
+assert.throws(() => releaseDecision(200, { ...manifest, gitHead: "b".repeat(40) }, request, sha))
+assert.throws(() => assertPublishedSource({ ...manifest, gitHead: undefined }, pkg.name, pkg.version, sha))
 
-console.log("publish workflow tests passed")
+let calls = 0, sleeps = 0
+const goalManifest = { name: "@bybrawe/opencode-goal", version: request.goal.version, gitHead: request.goal.sha }
+const recovered = await waitForPublishedGoal(request.goal, {
+  attempts: 2, sleep: async () => { sleeps++ },
+  request: async () => ++calls === 1 ? { ok: false, status: 404 } : { ok: true, json: async () => goalManifest },
+})
+assert.deepEqual(recovered, goalManifest)
+assert.equal(calls, 2)
+assert.equal(sleeps, 1)
+await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: false, status: 404 }) }), /not published/)
+for (const status of [403, 429, 503]) await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: false, status }) }), /transport\/auth/)
+await assert.rejects(waitForPublishedGoal(request.goal, { attempts: 1, request: async () => ({ ok: true, json: async () => ({ ...goalManifest, gitHead: sha }) }) }), /different source/)
+console.log("main-only publish workflow, source identity and registry failure regressions passed")