@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/native-presets-test.mjs

@@ -0,0 +1,227 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { mkdtemp, mkdir, readFile, writeFile, rm, symlink } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import plugin from "../src/source/opencode2/native-plugin.js"
+import { parseLoopArgs } from "../src/source/core/args.js"
+import { presetDefaults } from "../src/source/core/jobs.js"
+import { normalizeLoopScheduleArgs } from "../src/source/core/schedule-syntax.js"
+import { readState } from "../src/source/core/state.js"
+
+const PRESETS = ["loop-dev", "loop-testfix", "loop-compact", "loop-progress", "loop-safe-dev", "loop-command", "loop-cmd", "loop-prompt", "loop-ask", "loop-shell"]
+const SESSION = "ses_native_presets"
+async function fixture({ compact = true } = {}) {
+  const temp = await mkdtemp(path.join(os.tmpdir(), "loop-native-presets-"))
+  const directory = path.join(temp, "project with spaces")
+  await mkdir(directory)
+  const commands = new Map(), prompts = [], shellCalls = []
+  let dispose
+  try {
+    dispose = await plugin.setup({
+      location: { directory }, options: {}, app: { version: "2.0.18" },
+      session: {
+        get: async ({ sessionID }) => sessionID === SESSION ? { id: SESSION, location: { directory } } : null,
+        hook: async () => {},
+        prompt: async request => { prompts.push(request); return { id: request.id || "msg_ack" } },
+        command: async () => { throw new Error("a deferred/dry-run preset must not execute a slash command") },
+        wait: async () => {},
+        shell: async request => { shellCalls.push(request); return { id: request.id, status: "exited", exit: 0 } },
+        ...(compact ? { compact: async () => { throw new Error("a deferred/dry-run preset must not compact") } } : {}),
+      },
+      command: { transform: async edit => edit({ add(definition) {
+        assert.equal(commands.has(definition.name), false, `duplicate command ${definition.name}`)
+        commands.set(definition.name, definition)
+      } }) },
+      event: { subscribe() { return (async function* () {})() } },
+    })
+  } catch (error) { await rm(temp, { recursive: true, force: true }); throw error }
+  return {
+    temp, directory, commands, prompts, shellCalls,
+    async execute(name, text = "") {
+      assert.ok(commands.has(name), `native command missing: ${name}`)
+      return commands.get(name).execute({ sessionID: SESSION, prompt: { text } })
+    },
+    state: () => readState(directory, SESSION),
+    async dispose() { await dispose(); await rm(temp, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }) },
+  }
+}
+const fields = ["name", "action", "kind", "intervalMs", "immediate", "safe", "askNever", "noOverlap", "checkpointOnly", "gitCheckpoint", "batch", "progressFile", "verifyCommand", "testCommand", "maxRuns", "dryRun"]
+for (const name of PRESETS) {
+  test(`native ${name} preserves the shared V1 preset parser contract`, async () => {
+    const host = await fixture()
+    try {
+      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 and tsc --noEmit?" : ""
+      const text = name === "loop-compact" ? "--dry-run" : `every 1h --dry-run --max-runs 2 ${action}`.trim()
+      const normalized = normalizeLoopScheduleArgs(text, presetDefaults(name))
+      assert.equal(normalized.ok, true, normalized.error)
+      const expected = parseLoopArgs(normalized.args, normalized.defaults)
+      assert.equal(expected.ok, true, expected.error)
+      const response = await host.execute(name, text)
+      assert.equal(response.accepted, true)
+      const state = await host.state()
+      assert.equal(state.jobs.length, 1)
+      for (const field of fields) assert.deepEqual(state.jobs[0][field], expected.job[field], `${name}: ${field}`)
+      assert.equal(state.jobs[0].intervalMs, name === "loop-compact" ? 12000000 : 3600000, "explicit duration cannot remain part of the task text")
+      assert.equal(state.jobs[0].immediate, false)
+      assert.equal(state.jobs[0].scheduleMode, normalized.scheduleMode)
+      assert.equal(state.jobs[0].scheduleSyntax, normalized.scheduleSyntax)
+      assert.equal(state.jobs[0].runCount, 0, "deferred presets must not dispatch on registration")
+      assert.deepEqual(host.prompts, [])
+      assert.deepEqual(host.shellCalls, [])
+    } finally { await host.dispose() }
+  })
+}
+
+test("native preset arguments need no duration token and retain leading flags", async () => {
+  const host = await fixture()
+  try {
+    const output = await host.execute("loop-shell", "--no-now --dry-run npm test")
+    assert.equal(output.job.action, "npm test")
+    assert.equal(output.job.kind, "shell")
+    assert.equal(output.job.immediate, false)
+  } finally { await host.dispose() }
+})
+
+test("an immediate native development preset enters the existing dry-run safety path", async () => {
+  const host = await fixture()
+  try {
+    await host.execute("loop-dev", "--dry-run")
+    const job = (await host.state()).jobs[0]
+    assert.equal(job.name, "dev")
+    assert.equal(job.paused, true)
+    assert.equal(job.pauseReason, "dry-run")
+    assert.equal(job.runCount, 0)
+    assert.deepEqual(host.prompts, [])
+  } finally { await host.dispose() }
+})
+
+test("zero-delay deferred shell preset is scheduled without an unrelated model turn", async () => {
+  const host = await fixture()
+  try {
+    await host.execute("loop-shell", "0s echo safe --max-runs 1")
+    const deadline = Date.now() + 3000
+    while (Date.now() < deadline && (await host.state()).jobs[0]?.v2Run) await new Promise(resolve => setTimeout(resolve, 10))
+    while (Date.now() < deadline && (await host.state()).jobs[0]?.runCount !== 1) await new Promise(resolve => setTimeout(resolve, 10))
+    assert.equal((await host.state()).jobs[0].runCount, 1)
+    assert.equal(host.shellCalls.length, 1)
+    assert.deepEqual(host.prompts, [])
+  } finally { await host.dispose() }
+})
+
+test("unavailable native compaction rejects its preset before job persistence", async () => {
+  const host = await fixture({ compact: false })
+  try {
+    await assert.rejects(host.execute("loop-compact", "--dry-run"), /native compaction capability/)
+    assert.deepEqual((await host.state()).jobs, [])
+  } finally { await host.dispose() }
+})
+
+test("native loop-init creates progress without a model turn or a Loop job", async () => {
+  const host = await fixture()
+  try {
+    const response = await host.execute("loop-init")
+    assert.equal(response.created, true)
+    assert.match(await readFile(path.join(host.directory, "progress.md"), "utf8"), /^# Progress\n/)
+    assert.deepEqual((await host.state()).jobs, [])
+    assert.equal(host.prompts.length, 1)
+    assert.equal(host.prompts[0].resume, false)
+  } finally { await host.dispose() }
+})
+
+test("native loop-init preserves existing bytes, including concurrent initialization", async () => {
+  const host = await fixture()
+  try {
+    const results = await Promise.all([host.execute("loop-init"), host.execute("loop-init")])
+    assert.equal(results.filter(result => result.created).length, 1)
+    const file = path.join(host.directory, "progress.md")
+    const original = Buffer.from([0xef, 0xbb, 0xbf, 0, 255, 65])
+    await writeFile(file, original)
+    assert.equal((await host.execute("loop-init")).created, false)
+    assert.deepEqual(await readFile(file), original)
+    await mkdir(path.join(host.directory, "notes"))
+    assert.equal((await host.execute("loop-init", "notes/custom progress.md")).created, true)
+  } finally { await host.dispose() }
+})
+
+test("native loop-init rejects traversal, control-plane paths and symlink escapes", async () => {
+  const host = await fixture()
+  try {
+    for (const target of ["../outside.md", ".", ".git/HEAD", ".opencode/opencode-loop/forged.json"]) {
+      await assert.rejects(host.execute("loop-init", target), /inside the project|control-plane/)
+    }
+    const outside = path.join(host.temp, "outside")
+    await mkdir(outside)
+    await symlink(outside, path.join(host.directory, "escape"), process.platform === "win32" ? "junction" : "dir")
+    await assert.rejects(host.execute("loop-init", "escape/progress.md"), /inside the project/)
+    await assert.rejects(readFile(path.join(outside, "progress.md")), { code: "ENOENT" })
+    assert.deepEqual(host.prompts, [])
+    assert.deepEqual((await host.state()).jobs, [])
+  } finally { await host.dispose() }
+})
+
+
+const schedules = [
+  { text: "continue the project --dry-run", action: "continue the project", interval: 0, immediate: true, mode: "idle", syntax: "idle-shorthand", maxRuns: 0 },
+  { text: "idle continue --dry-run", action: "continue", interval: 0, immediate: true, mode: "idle", syntax: "idle", maxRuns: 0 },
+  { text: "every 1h continue --dry-run", action: "continue", interval: 3600000, immediate: false, mode: "interval", syntax: "every", maxRuns: 0 },
+  { text: "after 1h continue --now --max-runs 9 --dry-run", action: "continue", interval: 3600000, immediate: false, mode: "once", syntax: "after", maxRuns: 1 },
+  { text: "in 1h continue --dry-run", action: "continue", interval: 3600000, immediate: false, mode: "once", syntax: "after", maxRuns: 1 },
+  { text: "1h continue --dry-run", action: "continue", interval: 3600000, immediate: true, mode: "interval", syntax: "legacy", maxRuns: 0 },
+  { text: "1h --no-now continue --dry-run", action: "continue", interval: 3600000, immediate: false, mode: "interval", syntax: "legacy", maxRuns: 0 },
+  { text: "every 1h --now continue --dry-run", action: "continue", interval: 3600000, immediate: true, mode: "interval", syntax: "every", maxRuns: 0 },
+  { text: "--safe --ask-never continue --dry-run", action: "continue", interval: 0, immediate: true, mode: "idle", syntax: "idle-shorthand", maxRuns: 0 },
+]
+for (const example of schedules) {
+  test(`native schedule grammar: ${example.text}`, async () => {
+    const host = await fixture()
+    try {
+      await host.execute("loop", example.text)
+      const job = (await host.state()).jobs[0]
+      assert.equal(job.action, example.action)
+      assert.equal(job.intervalMs, example.interval)
+      assert.equal(job.immediate, example.immediate)
+      assert.equal(job.maxRuns, example.maxRuns)
+      assert.equal(job.scheduleMode, example.mode)
+      assert.equal(job.scheduleSyntax, example.syntax)
+      assert.equal(job.runCount, 0)
+      assert.deepEqual(host.prompts, [])
+      assert.deepEqual(host.shellCalls, [])
+    } finally { await host.dispose() }
+  })
+}
+
+test("invalid native schedules and unsupported Goal overlap are rejected before persistence", async () => {
+  const host = await fixture()
+  try {
+    for (const text of ["every later continue", "after later continue", "in later continue", "0s --allow-goal-overlap continue"]) {
+      await assert.rejects(host.execute("loop", text), /Invalid.*schedule|Goal.*reservation/)
+      assert.deepEqual((await host.state()).jobs, [])
+    }
+    assert.deepEqual(host.prompts, [])
+  } finally { await host.dispose() }
+})
+
+for (const example of [
+  { args: "", verify: "npm test", action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm test" },
+  { args: "npm run check", verify: "npm run check", action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm run check" },
+  { args: '--verify "npm run lint"', verify: "npm run lint", action: "Run the project tests. Fix failures. Re-run the tests. Test command hint: npm run lint" },
+  { args: 'fix parser tests --verify "npm run lint"', verify: "npm run lint", action: "fix parser tests" },
+]) {
+  test(`native testfix command semantics: ${example.args || "default"}`, async () => {
+    const host = await fixture()
+    try {
+      await host.execute("loop-testfix", `every 1h --dry-run ${example.args}`)
+      const job = (await host.state()).jobs[0]
+      assert.equal(job.verifyCommand, example.verify)
+      assert.equal(job.action, example.action)
+      assert.equal(job.intervalMs, 3600000)
+      assert.equal(job.immediate, false)
+      assert.equal(job.safe, true)
+      assert.equal(job.askNever, true)
+      assert.deepEqual(host.prompts, [])
+    } finally { await host.dispose() }
+  })
+}

package/scripts/native-process-tree-fixture.mjs

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict"
+import { mkdtemp, writeFile, readFile, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { setTimeout as delay } from "node:timers/promises"
+
+// The descendant stays in the command's process group but closes every pipe.
+// Killing the shell therefore emits close before this descendant has stopped.
+export async function processTreeFixture(mode = "timeout") {
+  const directory = await mkdtemp(path.join(tmpdir(), "opencode-native-process-tree-"))
+  await writeFile(path.join(directory, "descendant.cjs"), `
+    const fs = require("node:fs")
+    process.on("SIGTERM", () => {})
+    let n = 0
+    const beat = () => fs.writeFileSync("heartbeat.txt", String(++n))
+    beat()
+    fs.writeFileSync("descendant.pid", String(process.pid))
+    setInterval(beat, 20)
+    setTimeout(() => process.exit(0), 20000)
+  `)
+  await writeFile(path.join(directory, "parent.cjs"), `
+    const fs = require("node:fs")
+    const { spawn } = require("node:child_process")
+    fs.writeFileSync("parent.pid", String(process.pid))
+    spawn(process.execPath, ["descendant.cjs"], { stdio: "ignore" })
+    const ready = setInterval(() => {
+      if (!fs.existsSync("descendant.pid")) return
+      clearInterval(ready)
+      fs.writeFileSync("ready.txt", "ready")
+      if (${JSON.stringify(mode)} === "overflow") process.stdout.write("A".repeat(20000))
+    }, 10)
+    setInterval(() => {}, 1000)
+  `)
+  return {
+    directory,
+    command: `"${process.execPath}" parent.cjs`,
+    async ready() {
+      const deadline = Date.now() + 5000
+      while (Date.now() < deadline) {
+        try { await readFile(path.join(directory, "ready.txt")); return }
+        catch (error) { if (error.code !== "ENOENT") throw error }
+        await delay(20)
+      }
+      throw new Error("descendant fixture never became ready")
+    },
+    async assertStopped() {
+      await readFile(path.join(directory, "ready.txt"))
+      // Let any in-flight filesystem write finish, then detect continued work.
+      await delay(60)
+      const before = await readFile(path.join(directory, "heartbeat.txt"), "utf8")
+      await delay(180)
+      assert.equal(await readFile(path.join(directory, "heartbeat.txt"), "utf8"), before,
+        "terminal result must not precede stopping a pipe-detached descendant")
+    },
+    async cleanup() {
+      for (const file of ["descendant.pid", "parent.pid"]) {
+        try { process.kill(Number(await readFile(path.join(directory, file), "utf8")), "SIGKILL") } catch {}
+      }
+      await delay(80)
+      await rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })
+    },
+  }
+}
+
+export async function bounded(promise, milliseconds = 12000) {
+  let timer
+  try {
+    return await Promise.race([promise, new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error("native process cleanup never settled")), milliseconds)
+    })])
+  } finally { clearTimeout(timer) }
+}

package/scripts/native-process-tree-test.mjs

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict"
+import { createNativeShellHost } from "../src/source/opencode2/native-shell.js"
+import { processTreeFixture, bounded } from "./native-process-tree-fixture.mjs"
+
+for (const mode of ["timeout", "dispose", "concurrent-dispose"]) {
+  const fixture = await processTreeFixture()
+  const events = []
+  let terminal
+  const ended = new Promise((resolve) => { terminal = resolve })
+  const host = createNativeShellHost({
+    directory: fixture.directory,
+    onTerminal: (event) => { events.push(event); terminal(event) },
+  })
+  try {
+    await host.dispatch({ id: "tree-command", sessionID: "tree-session", command: fixture.command,
+      timeoutMs: mode === "timeout" ? 2000 : 10000 })
+    await fixture.ready()
+    if (mode === "dispose") await bounded(host.dispose())
+    if (mode === "concurrent-dispose") {
+      const first = host.dispose()
+      const second = host.dispose()
+      // Every caller must wait for the same cleanup, not return on a boolean.
+      await bounded(second)
+      assert.equal(host.activeCount(), 0, "second dispose returned before cleanup")
+      await fixture.assertStopped()
+      await bounded(first)
+    }
+    const event = await bounded(ended)
+    assert.equal(event.status, mode === "timeout" ? "timeout" : "killed")
+    assert.equal(event.sessionID, "tree-session")
+    assert.equal(event.shellID, "tree-command")
+    assert.equal(events.length, 1)
+    assert.equal(host.activeCount(), 0)
+    await fixture.assertStopped()
+    console.log(`Native process-tree regression passed: ${mode}`)
+  } finally {
+    await fixture.cleanup()
+    await bounded(host.dispose())
+  }
+}

package/scripts/native-release.mjs

@@ -0,0 +1,121 @@
+import assert from "node:assert/strict"
+import { readFile, appendFile } from "node:fs/promises"
+import { pathToFileURL } from "node:url"
+import { setTimeout as delay } from "node:timers/promises"
+
+export function validateRelease(request, pkg, env) {
+  assert.equal(env.GITHUB_REPOSITORY, "ByBrawe/opencode-loop", "wrong release repository")
+  assert.equal(env.GITHUB_REF, "refs/heads/main", "npm release must come from main")
+  assert.match(env.GITHUB_SHA ?? "", /^[a-f0-9]{40}$/, "immutable release SHA required")
+  assert.equal(request?.version, "0.6.0", "release version is not authorized")
+  assert.equal(request?.name, "@bybrawe/opencode-loop")
+  assert.equal(pkg.name, request.name)
+  assert.equal(pkg.version, request.version)
+  assert.equal(request.predecessor, "0.5.38")
+  assert.equal(request.goal?.version, "1.3.39")
+  assert.match(request.goal?.sha ?? "", /^[a-f0-9]{40}$/)
+  return request
+}
+
+export function assertPublishedSource(manifest, name, version, sha) {
+  assert.equal(manifest?.name, name, "published package name differs")
+  assert.equal(manifest?.version, version, "published package version differs")
+  assert.equal(manifest?.gitHead, sha, "immutable npm version belongs to different source; use a new version")
+}
+
+export function releaseDecision(status, manifest, request, sha, latest) {
+  if (status === 200) {
+    assertPublishedSource(manifest, request.name, request.version, sha)
+    return false
+  }
+  assert.equal(status, 404, "registry failure is not proof that a version is unpublished")
+  assert.equal(latest, request.predecessor, "npm latest differs from the predecessor; refuse out-of-order publication")
+  return true
+}
+
+export async function waitForPublishedGoal(goal, options = {}) {
+  const request = options.request ?? fetch
+  const sleep = options.sleep ?? delay
+  const attempts = options.attempts ?? 60
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const response = await request("https://registry.npmjs.org/" + encodeURIComponent("@bybrawe/opencode-goal") + "/" + goal.version, { signal: AbortSignal.timeout(20000) })
+    if (response.ok) {
+      const manifest = await response.json()
+      assertPublishedSource(manifest, "@bybrawe/opencode-goal", goal.version, goal.sha)
+      return manifest
+    }
+    assert.equal(response.status, 404, "Goal registry transport/auth errors cannot authorize the joint release")
+    if (attempt + 1 < attempts) await sleep(10000)
+  }
+  throw new Error("Declared Goal release is not published; Loop publication refused")
+}
+
+async function json(url, headers = {}) {
+  const response = await fetch(url, { headers, signal: AbortSignal.timeout(20000) })
+  if (!response.ok) throw new Error(`HTTP ${response.status}: ${url}`)
+  return response.json()
+}
+
+async function main() {
+  const request = JSON.parse(await readFile(new URL("../.github/npm-release.json", import.meta.url), "utf8"))
+  const pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"))
+  validateRelease(request, pkg, process.env)
+  const mode = process.argv[2]
+  const sha = process.env.GITHUB_SHA
+  const base = "https://registry.npmjs.org/" + encodeURIComponent(pkg.name)
+  if (mode === "validate") {
+    console.log(JSON.stringify({ release: request, source: sha }))
+    return
+  }
+  if (mode === "ci") {
+    const headers = { Accept: "application/vnd.github+json" }
+    if (process.env.GH_TOKEN) headers.Authorization = `Bearer ${process.env.GH_TOKEN}`
+    const deadline = Date.now() + 15 * 60_000
+    while (Date.now() < deadline) {
+      const runs = []
+      for (let page = 1; page <= 10; page++) {
+        const result = await json(`https://api.github.com/repos/${process.env.GITHUB_REPOSITORY}/actions/runs?head_sha=${sha}&per_page=100&page=${page}`, headers)
+        runs.push(...result.workflow_runs)
+        if (runs.length >= result.total_count || result.workflow_runs.length < 100) break
+        if (page === 10) throw new Error("Cannot safely paginate release checks")
+      }
+      const gates = ["CI", "Native V2 CI"].map((name) => {
+        const run = runs.filter((item) => item.name === name && item.head_sha === sha && item.head_branch === "main" && item.event === "push" && item.repository?.full_name === process.env.GITHUB_REPOSITORY).sort((a, b) => Number(b.id) - Number(a.id))[0]
+        return { name, id: run?.id, status: run?.status, conclusion: run?.conclusion }
+      })
+      console.log(JSON.stringify({ sha, gates }))
+      if (gates.some((gate) => gate.status === "completed" && gate.conclusion !== "success")) throw new Error("Exact-main CI failed; npm publication refused")
+      if (gates.every((gate) => gate.status === "completed" && gate.conclusion === "success")) return
+      await delay(15000)
+    }
+    throw new Error("Timed out waiting for exact-main CI")
+  }
+  if (mode === "decide") {
+    // Wait only for an absent, concurrently publishing companion. A different
+    // immutable source or an actual registry error fails immediately.
+    const goal = await waitForPublishedGoal(request.goal)
+    const exact = await fetch(base + "/" + request.version, { signal: AbortSignal.timeout(20000) })
+    const existing = exact.ok ? await exact.json() : null
+    const latest = exact.status === 404 ? await json(base + "/latest") : null
+    const publish = releaseDecision(exact.status, existing, request, sha, latest?.version)
+    await appendFile(process.env.GITHUB_OUTPUT, `publish=${publish}\n`)
+    console.log(JSON.stringify({ publish, loop: request.version, goal: goal.version, goalSHA: goal.gitHead }))
+    return
+  }
+  if (mode === "verify") {
+    const exact = await json(base + "/" + request.version)
+    const latest = await json(base + "/latest")
+    assertPublishedSource(exact, pkg.name, request.version, sha)
+    assert.equal(latest.version, request.version, "latest must resolve to this release")
+    assert.deepEqual(exact.exports, pkg.exports)
+    for (const [name, file] of Object.entries(pkg.bin)) assert.equal(exact.bin?.[name]?.replace(/^\.\//, ""), file.replace(/^\.\//, ""))
+    assert.ok(exact.dist?.integrity)
+    console.log("REGISTRY_VERIFIED " + JSON.stringify({ name: exact.name, version: exact.version, gitHead: exact.gitHead, integrity: exact.dist.integrity, latest: latest.version, bin: exact.bin }))
+    return
+  }
+  throw new Error("Expected validate, ci, decide or verify")
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => { console.error(error); process.exitCode = 1 })
+}

package/scripts/native-session-location-test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, access, readFile } from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+import plugin from '../src/source/opencode2/native-plugin.js'
+import { createNativeLoopRuntime } from '../src/source/opencode2/native-runtime.js'
+
+async function fixture() {
+  const directory = await mkdtemp(path.join(os.tmpdir(), 'loop-location-'))
+  const foreign = await mkdtemp(path.join(os.tmpdir(), 'loop-foreign-'))
+  let session = { id: 'ses_scope', location: { directory } }
+  const commands = new Map(), hooks = new Map(), prompts = []
+  const ctx = {
+    location: { directory }, options: {}, app: { version: '2.0.18' },
+    session: {
+      get: async () => session,
+      prompt: async (input) => { prompts.push(input); return { id: input.id || 'msg_status' } },
+      hook: async (name, fn) => { hooks.set(name, fn); return { dispose() { hooks.delete(name) } } },
+    },
+    command: { transform: async (fn) => { fn({ add(def) { commands.set(def.name, def) } }); return { dispose() {} } } },
+    event: { subscribe({ signal }) { return (async function* () { await new Promise((resolve) => { if (signal.aborted) resolve(); else signal.addEventListener('abort', resolve, { once: true }) }) })() } },
+  }
+  const close = await plugin.setup(ctx)
+  return {
+    directory, foreign, ctx, commands, hooks, prompts,
+    setSession(value) { session = value },
+    command(name, text = '') { return commands.get(name).execute({ sessionID: 'ses_scope', prompt: { text } }) },
+    async close() { await close(); await rm(directory, { recursive: true, force: true }); await rm(foreign, { recursive: true, force: true }) },
+  }
+}
+test('foreign-worktree command cannot create progress in the plugin directory', async () => {
+  const f = await fixture()
+  try {
+    f.setSession({ id: 'ses_scope', location: { directory: f.foreign } })
+    await assert.rejects(f.command('loop-init', 'progress.md'), /session.*location|project.*worktree/i)
+    await assert.rejects(access(path.join(f.directory, 'progress.md')))
+    await assert.rejects(access(path.join(f.foreign, 'progress.md')))
+    assert.equal(f.prompts.length, 0)
+  } finally { await f.close() }
+})
+test('native command still initializes a confirmed local session', async () => {
+  const f = await fixture()
+  try {
+    await f.command('loop-init', 'progress.md')
+    assert.ok((await readFile(path.join(f.directory, 'progress.md'), 'utf8')).length)
+    assert.equal(f.prompts.length, 1)
+  } finally { await f.close() }
+})
+test('missing, mismatched and unreadable session identity fail closed', async () => {
+  const f = await fixture()
+  try {
+    for (const value of [null, { id: 'ses_other', location: { directory: f.directory } }, { id: 'ses_scope' }, { id: 'ses_scope', location: { directory: f.directory, workspaceID: 'other' } }]) {
+      f.setSession(value)
+      await assert.rejects(f.command('loop-init'), /session.*location|project.*worktree/i)
+    }
+    f.ctx.session.get = async () => { throw new Error('session unavailable') }
+    await assert.rejects(f.command('loop-init'), /session.*location|project.*worktree/i)
+    await assert.rejects(access(path.join(f.directory, 'progress.md')))
+  } finally { await f.close() }
+})
+test('scoped runtime refuses persistent commands and timer dispatch when ownership changes', async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), 'loop-runtime-location-'))
+  let allowed = false
+  const prompts = [], timers = []
+  const runtime = createNativeLoopRuntime({ directory,
+    scopeAllowed: async () => allowed,
+    prompt: async (input) => { prompts.push(input); return { id: input.id } },
+    setTimer(fn) { const timer = { fn }; timers.push(timer); return timer }, clearTimer(timer) { timer.cancelled = true },
+  })
+  const scope = { directory, sessionID: 'ses_runtime' }
+  const command = () => runtime.onEvent({ ...scope, kind: 'command', action: 'executed', name: 'loop', arguments: '1h scoped task --defer' })
+  try {
+    assert.equal((await command()).accepted, false)
+    await assert.rejects(access(path.join(directory, '.opencode')))
+    allowed = true
+    assert.equal((await command()).accepted, true)
+    const file = path.join(directory, '.opencode', 'opencode-loop', 'ses_runtime.json')
+    const before = await readFile(file, 'utf8')
+    allowed = false
+    for (const timer of timers.filter((t) => !t.cancelled)) await timer.fn()
+    assert.equal((await runtime.wake(scope)).accepted, false)
+    assert.equal(await readFile(file, 'utf8'), before)
+    assert.equal(prompts.length, 0)
+  } finally { await runtime.dispose(); await rm(directory, { recursive: true, force: true }) }
+})

package/scripts/native-shell-test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict"
+import { mkdtemp, writeFile, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { createNativeShellHost } from "../src/source/opencode2/native-shell.js"
+
+let cases = 0
+async function scenario(source, check, options = {}) {
+  const directory = await mkdtemp(path.join(tmpdir(), "loop-native-shell-"))
+  const events = [], errors = []
+  let terminal
+  const ended = new Promise((resolve) => { terminal = resolve })
+  const host = createNativeShellHost({ directory, onTerminal: (event) => { events.push(event); terminal(event) }, onError: (error) => errors.push(error) })
+  try {
+    await writeFile(path.join(directory, "command.cjs"), source)
+    const admitted = await host.dispatch({ id: "owned-shell", sessionID: "owned-session", command: `"${process.execPath}" command.cjs`, timeoutMs: 5000, ...options })
+    assert.equal(admitted.id, "owned-shell")
+    assert.equal(admitted.status, "running")
+    if (options.dispose) await host.dispose()
+    const event = await Promise.race([ended, new Promise((_, reject) => { const t = setTimeout(() => reject(new Error("shell never settled")), 10_000); t.unref() })])
+    assert.equal(event.sessionID, "owned-session")
+    assert.equal(event.shellID, "owned-shell")
+    assert.equal(events.length, 1)
+    assert.equal(host.activeCount(), 0)
+    assert.equal(errors.length, 0)
+    await check(event, host)
+    cases++
+  } finally { await host.dispose(); await rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }) }
+}
+await scenario('process.stdout.write("SUCCESS")', (event) => { assert.equal(event.code, 0); assert.equal(event.status, "exited"); assert.equal(event.stdout, "SUCCESS") })
+await scenario('process.stderr.write("FAILED"); process.exitCode=7', (event) => { assert.equal(event.code, 7); assert.equal(event.stderr, "FAILED") })
+await scenario('setInterval(()=>{},1000)', (event) => { assert.equal(event.code, 124); assert.equal(event.status, "timeout") }, { timeoutMs: 100 })
+await scenario('setInterval(()=>{},1000)', (event) => { assert.equal(event.status, "killed"); assert.notEqual(event.code, 0) }, { dispose: true })
+await scenario('process.stdout.write("A".repeat(100000))', (event) => { assert.equal(event.stdout.length, 64000); assert.equal(event.code, 0) })
+await scenario('process.exitCode=0', async (_, host) => { await host.dispose(); await assert.rejects(host.dispatch({ sessionID: "s", command: "echo nope" }), /disposed/) })
+assert.throws(() => createNativeShellHost({}), /requires directory/)
+console.log(`Native local shell lifecycle: ${cases + 1} scenarios passed`)
+await import("./native-process-tree-test.mjs")