@bybrawe/opencode-loop 0.5.37 → 0.6.0

package/scripts/native-entry-test.mjs

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
+import { readFileSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"))
+assert.ok(["@bybrawe/opencode-loop", "@bybrawe/opencode-goal"].includes(pkg.name))
+assert.ok(process.argv.length <= 3, "expected at most one consumer directory")
+const loop = pkg.name === "@bybrawe/opencode-loop"
+const cwd = process.argv[2] ? path.resolve(process.argv[2]) : root
+const packageRoot = process.argv[2] ? path.join(cwd, "node_modules", ...pkg.name.split("/")) : root
+const url = (relative) => pathToFileURL(path.join(packageRoot, relative)).href
+const legacyEntries = loop ? [url("src/v1.js"), url("src/source/v1.js")] : [url("dist/legacy-v1.js")]
+const blocked = loop
+  ? [...legacyEntries, url("src/index.js"), url("src/source/legacy-v1.js")]
+  : [...legacyEntries, url("dist/index.js"), url("dist/opencode/plugin.js")]
+const entries = loop ? [pkg.name, `${pkg.name}/server`, `${pkg.name}/v2`] : [`${pkg.name}/server`, `${pkg.name}/v2`]
+if (loop) entries.push(url("src/source/server.js"))
+const serverEntries = loop ? [`${pkg.name}/server`, url("src/source/server.js")] : [`${pkg.name}/server`]
+
+function probe(mode) {
+  const stub = "globalThis.__legacyModuleLoads = (globalThis.__legacyModuleLoads || 0) + 1; export default async (...args) => { if (args[0]?.failure) throw args[0].failure; return { args }; }"
+  const loader = `
+    const blocked = ${JSON.stringify(blocked)};
+    const legacyEntries = ${JSON.stringify(legacyEntries)};
+    export async function resolve(specifier, context, nextResolve) {
+      if (specifier.startsWith("@opencode-ai/")) throw new Error("V2_LEGACY_IMPORT: " + specifier);
+      const result = await nextResolve(specifier, context);
+      if (${JSON.stringify(mode)} === "delegate" && legacyEntries.includes(result.url)) {
+        return { url: ${JSON.stringify(`data:text/javascript,${encodeURIComponent(stub)}`)}, shortCircuit: true };
+      }
+      if (blocked.includes(result.url)) throw new Error("V2_LEGACY_IMPORT: " + result.url);
+      return result;
+    }
+  `
+  const source = `
+    import assert from "node:assert/strict";
+    import { register } from "node:module";
+    register(${JSON.stringify(`data:text/javascript,${encodeURIComponent(loader)}`)}, import.meta.url);
+    const entries = ${JSON.stringify(mode === "isolation" ? entries : serverEntries)};
+    for (const entry of entries) {
+      const { default: plugin } = await import(entry);
+      assert.equal(typeof plugin.setup, "function", entry);
+      assert.equal(plugin.id, "@bybrawe/opencode-loop", entry);
+      if (${JSON.stringify(mode)} === "isolation") {
+        assert.equal(globalThis.__legacyModuleLoads, undefined, "native import initialized legacy runtime");
+        if (entry.endsWith("/v2")) assert.equal("server" in plugin, false, "native entry must not expose V1 dispatch");
+      } else {
+        const before = globalThis.__legacyModuleLoads;
+        if (entry === entries[0]) assert.equal(before, undefined, "server eagerly initialized V1");
+        const input = { directory: "fixture-one" }, options = { fixture: true };
+        const first = await plugin.server(input, options);
+        assert.strictEqual(first.args[0], input, "legacy input was changed");
+        assert.strictEqual(first.args[1], options, "legacy options were lost");
+        const secondInput = { directory: "fixture-two" };
+        const second = await plugin.server(secondInput, options);
+        assert.strictEqual(second.args[0], secondInput, "plugin instances shared the first host context");
+        assert.notStrictEqual(first, second, "legacy hooks must be created for every invocation");
+        const failure = new Error("legacy sentinel");
+        await assert.rejects(plugin.server({ failure }), (error) => error === failure, "legacy failure was swallowed");
+        assert.equal(globalThis.__legacyModuleLoads, 1, "only the module, never per-host hooks, is cached");
+      }
+    }
+    console.log(${JSON.stringify(`native entry ${mode} PASS`)});
+  `
+  const result = spawnSync(process.execPath, ["--input-type=module", "--eval", source], {
+    cwd, encoding: "utf8", timeout: 30_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
+  })
+  if (result.error) throw result.error
+  assert.equal(result.status, 0, [result.stdout, result.stderr].filter(Boolean).join("\n"))
+  process.stdout.write(result.stdout)
+}
+
+probe("isolation")
+probe("delegate")

package/scripts/native-guide-test.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
+import { mkdtemp, writeFile, readFile, rm } 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 temp = await mkdtemp(path.join(tmpdir(), "loop-guide-config-"))
+const file = path.join(temp, "opencode.json")
+const version = JSON.parse(await readFile(path.join(root, "package.json"), "utf8")).version
+const spec = `@bybrawe/opencode-loop@${version}`
+function run(args = []) {
+  return spawnSync(process.execPath, [path.join(root, "scripts/install-node.mjs"), ...args], {
+    cwd: root, env: { ...process.env, OPENCODE_CONFIG_DIR: temp }, encoding: "utf8", timeout: 20_000,
+  })
+}
+try {
+  const options = { quiet: false, nested: { count: 3 } }
+  const other = ["other-plugin", { enabled: false }]
+  await writeFile(file, JSON.stringify({ plugin: [["@bybrawe/opencode-loop@0.1.0", options], other] }))
+  let result = run(["--legacy-v1"])
+  assert.equal(result.status, 0, result.stderr)
+  assert.deepEqual(JSON.parse(await readFile(file, "utf8")).plugin, [other, [spec, options]])
+  result = run()
+  assert.equal(result.status, 0, result.stderr)
+  assert.deepEqual(JSON.parse(await readFile(file, "utf8")), { plugin: [other], plugins: [{ package: spec, options }] })
+  const migrated = await readFile(file, "utf8")
+  assert.equal(run().status, 0)
+  assert.equal(await readFile(file, "utf8"), migrated)
+  for (const entries of [
+    [[spec, false]], [[spec, {}, "extra"]],
+    [[spec, { quiet: false }], { package: spec, options: { quiet: true } }],
+  ]) {
+    const before = JSON.stringify({ plugin: entries })
+    await writeFile(file, before)
+    result = run()
+    assert.notEqual(result.status, 0)
+    assert.match(result.stderr, /Invalid Loop package\/options tuple|Conflicting Loop object registrations/)
+    assert.equal(await readFile(file, "utf8"), before)
+    assert.equal(run(["--uninstall"]).status, 0)
+    assert.deepEqual(JSON.parse(await readFile(file, "utf8")).plugin, [])
+  }
+  console.log("Official V1-to-V2 guide config regression passed")
+} finally { await rm(temp, { recursive: true, force: true, maxRetries: 8, retryDelay: 100 }) }

package/scripts/native-install-pair-test.mjs

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
+import { mkdtemp, mkdir, readFile, writeFile, access, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const goalInstaller = process.env.OPENCODE_GOAL_INSTALLER
+assert.ok(goalInstaller && path.isAbsolute(goalInstaller), "Set OPENCODE_GOAL_INSTALLER to the built companion dist/install.js")
+await access(goalInstaller)
+const temp = await mkdtemp(path.join(os.tmpdir(), "loop-goal-native-install-"))
+const npm = path.join(temp, "npm-test-driver.cjs")
+const targetLog = path.join(temp, "target.jsonl")
+await writeFile(npm, `const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const args = process.argv.slice(2);
+if (JSON.stringify(args) !== JSON.stringify(['exec','--yes','--package=@bybrawe/opencode-goal@latest','--','opencode-goal'])) throw new Error('unexpected npm arguments');
+fs.appendFileSync(process.env.TARGET_LOG, JSON.stringify(process.env.OPENCODE_GOAL_HOST_VERSION) + '\\n');
+const result = spawnSync(process.execPath, [process.env.OPENCODE_GOAL_INSTALLER], { env: process.env, stdio: 'inherit' });
+process.exit(result.status ?? 1);
+`)
+const exists = (file) => access(file).then(() => true, () => false)
+function run(config, args, hostTarget = "1.18.15") {
+  const result = spawnSync(process.execPath, [path.join(root, "scripts/install-with-goals.mjs"), ...args], {
+    cwd: root, encoding: "utf8", timeout: 30_000,
+    env: { ...process.env, npm_execpath: npm, OPENCODE_CONFIG_DIR: config, OPENCODE_GOAL_HOST_VERSION: hostTarget, OPENCODE_GOAL_INSTALLER: goalInstaller, TARGET_LOG: targetLog },
+  })
+  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}\n${result.error || ""}`)
+  return result
+}
+try {
+  const config = path.join(temp, "config")
+  await mkdir(path.join(config, "commands"), { recursive: true })
+  const options = { autonomous: false, nested: { retained: true } }
+  await writeFile(path.join(config, "opencode.json"), JSON.stringify({ plugin: [
+    { package: "@bybrawe/opencode-goal@1.0.0", options },
+    { package: "@bybrawe/opencode-loop@0.1.0", options: { quiet: true } },
+    "other-plugin",
+  ] }))
+  await writeFile(path.join(config, "commands/goal.md"), "Custom Goal command\n")
+  await writeFile(path.join(config, "commands/loop-goal.md"), "Custom Loop Goal command\n")
+  const state = path.join(config, "project/.opencode/goals/keep.json")
+  await mkdir(path.dirname(state), { recursive: true })
+  await writeFile(state, '{"evidence":"unchanged"}\n')
+
+  run(config, ["--with-goals", "--without-loop-goals"])
+  let source = await readFile(path.join(config, "opencode.json"), "utf8")
+  let parsed = JSON.parse(source)
+  assert.deepEqual(parsed.plugin, ["other-plugin"])
+  assert.equal(parsed.plugins.length, 2)
+  assert.deepEqual(parsed.plugins.find((item) => item.package?.startsWith("@bybrawe/opencode-goal@")).options, options)
+  assert.deepEqual(parsed.plugins.find((item) => item.package?.startsWith("@bybrawe/opencode-loop@")).options, { quiet: true })
+  assert.equal(await readFile(path.join(config, "commands/goal.md"), "utf8"), "Custom Goal command\n")
+  assert.equal(await readFile(path.join(config, "commands/loop-goal.md"), "utf8"), "Custom Loop Goal command\n")
+  run(config, ["--with-goals", "--without-loop-goals"])
+  assert.equal(await readFile(path.join(config, "opencode.json"), "utf8"), source)
+  assert.equal(await readFile(state, "utf8"), '{"evidence":"unchanged"}\n')
+
+  const legacy = path.join(temp, "legacy")
+  run(legacy, ["--legacy-v1", "--with-goals"], "2.0.18")
+  parsed = JSON.parse(await readFile(path.join(legacy, "opencode.json"), "utf8"))
+  assert.ok(parsed.plugin.some((item) => String(item).startsWith("@bybrawe/opencode-goal@")))
+  assert.equal(await exists(path.join(legacy, "commands/goal.md")), true)
+  assert.equal(await exists(path.join(legacy, "commands/loop.md")), true)
+  assert.deepEqual((await readFile(targetLog, "utf8")).trim().split('\n').map((line) => JSON.parse(line)), ["2.0.0", "2.0.0", "1.0.0"])
+  run(config, ["--uninstall"])
+  parsed = JSON.parse(await readFile(path.join(config, "opencode.json"), "utf8"))
+  assert.equal(parsed.plugins.length, 1, "Loop uninstall cannot remove the companion")
+  assert.ok(parsed.plugins[0].package.startsWith("@bybrawe/opencode-goal@"))
+  assert.equal(await readFile(state, "utf8"), '{"evidence":"unchanged"}\n')
+  console.log("Native Goal+Loop installer pair: dialect, options, idempotence, custom files and uninstall PASS")
+} finally { await rm(temp, { recursive: true, force: true }) }

package/scripts/native-install-test.mjs

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
+import { mkdtemp, mkdir, readFile, writeFile, access, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
+const installer = path.join(root, "scripts/install-node.mjs")
+const temp = await mkdtemp(path.join(tmpdir(), "native-loop-installer-"))
+const version = JSON.parse(await readFile(path.join(root, "package.json"), "utf8")).version
+const spec = `@bybrawe/opencode-loop@${version}`
+let cases = 0
+const exists = async (file) => { try { await access(file); return true } catch { return false } }
+function run(config, args = [], expected = 0) {
+  const result = spawnSync(process.execPath, [installer, ...args], { cwd: root, env: { ...process.env, OPENCODE_CONFIG_DIR: config }, encoding: "utf8", timeout: 20_000 })
+  assert.equal(result.status, expected, `${result.stdout}\n${result.stderr}\n${result.error || ""}`)
+  return result
+}
+async function config(name, content) {
+  const directory = path.join(temp, name)
+  await mkdir(directory, { recursive: true })
+  if (content !== undefined) await writeFile(path.join(directory, "opencode.json"), typeof content === "string" ? content : JSON.stringify(content))
+  return directory
+}
+try {
+  const fresh = await config("fresh")
+  run(fresh)
+  const native = await readFile(path.join(root, "src/native.js"), "utf8")
+  assert.equal(await readFile(path.join(fresh, "plugins/opencode-loop.ts"), "utf8"), native)
+  assert.doesNotMatch(native, /(?:from\s*|import\s*\()["']@opencode-ai\/plugin/)
+  assert.equal(await exists(path.join(fresh, "package.json")), false)
+  assert.equal(await exists(path.join(fresh, "commands/loop.md")), false)
+  assert.equal(await exists(path.join(fresh, "agents/opencode-loop-local.md")), false)
+  run(fresh)
+  cases++
+
+  const options = { package: "@bybrawe/opencode-loop@0.5.38", options: { quiet: true, nested: { value: "preserved" } }, enabled: true }
+  const obj = await config("object", { plugins: ["other-plugin", options] })
+  run(obj)
+  const readConfig = async (directory) => JSON.parse(await readFile(path.join(directory, "opencode.json"), "utf8"))
+  assert.deepEqual((await readConfig(obj)).plugins, ["other-plugin", { ...options, package: spec }])
+  const before = await readFile(path.join(obj, "opencode.json"), "utf8")
+  run(obj)
+  assert.equal(await readFile(path.join(obj, "opencode.json"), "utf8"), before)
+  assert.equal(await exists(path.join(obj, "plugins/opencode-loop.ts")), false)
+  cases++
+
+  const both = await config("both", { plugin: ["legacy-unrelated", "@bybrawe/opencode-loop@old"], plugins: [options, "native-unrelated"] })
+  run(both)
+  assert.deepEqual(await readConfig(both), { plugin: ["legacy-unrelated"], plugins: ["native-unrelated", { ...options, package: spec }] })
+  cases++
+
+  const jsonc = await config("jsonc", '{\r\n  // keep-before\r\n  "theme": "url://example",\r\n  "plugin": ["@bybrawe/opencode-loop@old"] // keep-after\r\n}\r\n')
+  run(jsonc)
+  const text = await readFile(path.join(jsonc, "opencode.json"), "utf8")
+  assert.match(text, /keep-before/)
+  assert.match(text, /keep-after/)
+  assert.match(text, /"plugins"/)
+  assert.match(text, /url:\/\/example/)
+  run(jsonc)
+  assert.equal(await readFile(path.join(jsonc, "opencode.json"), "utf8"), text)
+  cases++
+
+  const conflict = await config("conflict", { plugins: [options, { ...options, enabled: false }] })
+  const conflictBefore = await readFile(path.join(conflict, "opencode.json"), "utf8")
+  assert.match(run(conflict, [], 1).stderr, /Conflicting/)
+  assert.equal(await readFile(path.join(conflict, "opencode.json"), "utf8"), conflictBefore)
+  cases++
+
+  const invalid = await config("invalid", { plugin: ["@bybrawe/opencode-loop@old"] })
+  await writeFile(path.join(invalid, "config.jsonc"), '{ "plugins": "not-an-array" }')
+  const invalidBefore = await readFile(path.join(invalid, "opencode.json"), "utf8")
+  run(invalid, [], 1)
+  assert.equal(await readFile(path.join(invalid, "opencode.json"), "utf8"), invalidBefore)
+  assert.equal(await exists(path.join(invalid, "plugins/opencode-loop.ts")), false)
+  cases++
+
+  const upgrade = await config("upgrade")
+  run(upgrade, ["--legacy-v1"])
+  assert.equal(await exists(path.join(upgrade, "commands/loop.md")), true)
+  await writeFile(path.join(upgrade, "commands/loop-help.md"), "This is a custom user command; keep it.")
+  run(upgrade)
+  assert.equal(await exists(path.join(upgrade, "commands/loop.md")), false)
+  assert.equal(await readFile(path.join(upgrade, "commands/loop-help.md"), "utf8"), "This is a custom user command; keep it.")
+  assert.equal(await readFile(path.join(upgrade, "plugins/opencode-loop.ts"), "utf8"), native)
+  cases++
+
+  await mkdir(path.join(obj, ".opencode/opencode-loop"), { recursive: true })
+  await writeFile(path.join(obj, ".opencode/opencode-loop/keep.json"), "{}")
+  run(obj, ["--uninstall"])
+  assert.deepEqual((await readConfig(obj)).plugins, ["other-plugin"])
+  assert.equal(await exists(path.join(obj, ".opencode/opencode-loop/keep.json")), true)
+  run(obj, ["--uninstall"])
+  run(upgrade, ["--uninstall"])
+  assert.equal(await exists(path.join(upgrade, "commands/loop-help.md")), true)
+  cases++
+
+  const info = path.join(temp, "informational-no-mutation")
+  run(info, ["--help"])
+  run(info, ["--version"])
+  assert.equal(await exists(info), false)
+  cases++
+  console.log(`Native installer: ${cases} scenarios passed`)
+} finally { await rm(temp, { recursive: true, force: true }) }
+
+await import("./native-guide-test.mjs")

package/scripts/native-lifecycle-test.mjs

@@ -0,0 +1,100 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import plugin from "../src/source/opencode2/native-plugin.js"
+import { createOpenCode2EventBridge } from "../src/source/opencode2/event-bridge.js"
+
+async function fixture({ failDispose = false, failSubscribe = false } = {}) {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-native-unload-"))
+  const cleaned = []
+  const cleanupError = new Error("command cleanup rejected")
+  const subscribeError = new Error("subscription rejected")
+  let signal, stopped = 0, release = () => {}
+  const registration = name => ({ dispose: async () => {
+    cleaned.push(name)
+    if (failDispose && name === "commands") throw cleanupError
+  } })
+  const ctx = {
+    location: { directory }, options: {},
+    session: {
+      prompt: async () => { throw new Error("cleanup must not prompt or abort a native session") },
+      hook: async name => registration(name),
+    },
+    command: { transform: async edit => { edit({ add() {} }); return registration("commands") } },
+    event: { subscribe(input) {
+      signal = input?.signal
+      if (failSubscribe) throw subscribeError
+      return (async function* () {
+        try {
+          await new Promise(resolve => {
+            release = resolve
+            if (signal?.aborted) resolve()
+            else signal?.addEventListener("abort", resolve, { once: true })
+          })
+        } finally { stopped++ }
+      })()
+    } },
+  }
+  return { ctx, cleaned, cleanupError, subscribeError, signal: () => signal, stopped: () => stopped,
+    release: () => release(), remove: () => rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }) }
+}
+async function bounded(promise) {
+  let timer
+  try { return await Promise.race([promise, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("native unload blocked on event next()")), 1500) })]) }
+  finally { clearTimeout(timer) }
+}
+
+test("native unload aborts a pending public event stream and shares cleanup", async () => {
+  const host = await fixture()
+  let dispose
+  try {
+    dispose = await plugin.setup(host.ctx)
+    assert.ok(host.signal() instanceof AbortSignal, "the native subscription needs a cancellation signal")
+    const first = dispose(), second = dispose()
+    assert.equal(first, second)
+    await bounded(first)
+    assert.equal(host.signal().aborted, true)
+    assert.equal(host.stopped(), 1)
+    assert.deepEqual(host.cleaned, ["commands", "compaction", "prompt"])
+    await dispose()
+    assert.equal(host.cleaned.length, 3)
+  } finally { host.release(); await dispose?.().catch(() => {}); await host.remove() }
+})
+
+test("one failed native disposer does not skip remaining registrations", async () => {
+  const host = await fixture({ failDispose: true })
+  let dispose
+  try {
+    dispose = await plugin.setup(host.ctx)
+    host.release()
+    await assert.rejects(bounded(dispose()), error => error instanceof AggregateError && error.errors.includes(host.cleanupError))
+    assert.deepEqual(host.cleaned, ["commands", "compaction", "prompt"])
+    assert.equal(host.signal()?.aborted, true)
+    await assert.rejects(dispose(), AggregateError)
+    assert.equal(host.cleaned.length, 3)
+  } finally { host.release(); await dispose?.().catch(() => {}); await host.remove() }
+})
+
+test("failed native setup preserves its error and attempts all cleanup", async () => {
+  const host = await fixture({ failDispose: true, failSubscribe: true })
+  try {
+    await assert.rejects(plugin.setup(host.ctx), error => error === host.subscribeError)
+    assert.deepEqual(host.cleaned, ["commands", "compaction", "prompt"])
+    assert.equal(host.signal()?.aborted, true)
+  } finally { host.release(); await host.remove() }
+})
+
+test("event bridge disposes session scopes even when unsubscribe rejects", async () => {
+  const sentinel = new Error("unsubscribe failed")
+  const bridge = createOpenCode2EventBridge({ directory: "/project" })
+  let listener
+  await bridge.attach(async callback => { listener = callback; return { unsubscribe: async () => { throw sentinel } } })
+  await listener({ directory: "/project", payload: { type: "session.created", properties: { info: { id: "ses_cleanup", directory: "/project" } } } })
+  const runtime = bridge.runtimeManager.peek("ses_cleanup")
+  assert.ok(runtime?.scope.isActive())
+  await assert.rejects(bridge.dispose(), error => error === sentinel)
+  assert.equal(runtime.scope.isActive(), false)
+  assert.deepEqual(bridge.runtimeManager.entries(), [])
+})

package/scripts/native-plugin-lifetime-test.mjs

@@ -0,0 +1,92 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { mkdtemp, rm } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import plugin from "../src/source/opencode2/native-plugin.js"
+
+function fixture(directory, { failCleanup = false } = {}) {
+  const released = []
+  let releaseRead, signal
+  let streamClosed = false
+  const end = () => releaseRead?.()
+  const registration = (name) => ({ async dispose() {
+    released.push(name)
+    if (failCleanup && name === "commands") throw new Error("cleanup sentinel")
+  } })
+  const ctx = {
+    location: { directory }, options: {}, app: { version: "2.0.18" },
+    session: {
+      prompt: async () => { throw new Error("cleanup must not dispatch a prompt") },
+      hook: async (name) => registration(name),
+    },
+    command: { transform: async () => registration("commands") },
+    event: { subscribe(options = {}) {
+      signal = options.signal
+      return (async function* () {
+        try {
+          await new Promise((resolve) => {
+            releaseRead = resolve
+            if (signal?.aborted) resolve()
+            else signal?.addEventListener("abort", resolve, { once: true })
+          })
+        } finally { streamClosed = true }
+      })()
+    } },
+  }
+  return { ctx, end, released, signal: () => signal, streamClosed: () => streamClosed }
+}
+
+async function bounded(promise) {
+  let timer
+  try {
+    return await Promise.race([
+      promise.then(() => "closed"),
+      new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), 500) }),
+    ])
+  } finally { clearTimeout(timer) }
+}
+
+test("native Loop aborts an idle subscription before awaiting iterator return", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-v2-lifetime-"))
+  const host = fixture(directory)
+  let closing
+  try {
+    const dispose = await plugin.setup(host.ctx)
+    closing = dispose()
+    assert.equal(await bounded(closing), "closed", "idle subscription cleanup requires an AbortSignal")
+    assert.equal(host.signal()?.aborted, true)
+    assert.equal(host.streamClosed(), true)
+    assert.deepEqual(host.released, ["commands", "compaction", "prompt"])
+  } finally {
+    host.end()
+    await closing?.catch(() => {})
+    await rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  }
+})
+
+test("native Loop cleanup is shared and drains all registrations after an error", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-v2-cleanup-error-"))
+  const host = fixture(directory, { failCleanup: true })
+  let closing
+  try {
+    const dispose = await plugin.setup(host.ctx)
+    host.end()
+    closing = dispose()
+    const observed = closing.catch((error) => error)
+    assert.strictEqual(dispose(), closing, "concurrent unloads must await the same cleanup")
+    const error = await observed
+    assert.ok(error instanceof AggregateError)
+    assert.match(String(error.errors[0]), /cleanup sentinel/)
+    assert.deepEqual(host.released, ["commands", "compaction", "prompt"])
+    assert.equal(host.streamClosed(), true)
+  } finally {
+    host.end()
+    await closing?.catch(() => {})
+    await rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  }
+})
+
+test("native Loop uses the same public plugin identity as the package entry", () => {
+  assert.equal(plugin.id, "@bybrawe/opencode-loop", "native entry must share canonical plugin identity")
+})