@bybrawe/opencode-loop 0.6.1 → 0.6.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.6.3 - 2026-10-02
+
+- Fix native OpenCode 2 fresh installs on Windows/Linux by registering the exact published Loop package in plural `plugins` instead of copying a loose global `plugins/opencode-loop` directory.
+- Let OpenCode resolve `@opencode/plugin` from Loop's published production dependency graph, eliminating the reproduced `Cannot find package '@opencode/plugin'` startup failure from the 0.6.1/0.6.2 loose-install layout.
+- Automatically migrate known loose V2 Loop copies on update while preserving project Loop state, unrelated plugin registrations, JSONC comments and configured package options.
+- Add installer regressions for fresh package registration, idempotence and migration of a broken loose V2 copy.
+- Keep the dedicated OpenCode Goal 1.3.42 companion unchanged and retain explicit `--legacy-v1` as the isolated compatibility path.
+
+## 0.6.2 - 2026-09-30
+
+- Conform the native OpenCode 2 runtime to the migration-guide location/options boundary: project scope comes only from `ctx.location.directory`; plugin `ctx.options` can no longer masquerade as project location.
+- Keep session/worktree isolation on public `session.get(...).location.directory` and fail setup/dispatch closed when project or session location cannot be established.
+- Retain the official root/server/`./v2` `Plugin.define({ id, setup })` entrypoints, plural `plugins` installer migration, abortable event subscription cleanup, public command/session capabilities and separately isolated V1 compatibility.
+- Keep undocumented `session.shell`, `session.compact` and `session.inbox` properties out of the V2 runtime; scheduled shell remains Loop-managed and automatic compaction remains host-owned.
+- Add lifecycle regression coverage proving `options.directory` is not V2 location authority.
+- Pair trusted publication with immutable OpenCode Goal 1.3.42 and re-run production tarballs plus the joint OpenCode 2.0.18 host matrix.
+
 ## 0.6.1 - 2026-09-29
 
 - Expose the root/server and `./v2` npm entrypoints through the official `@opencode/plugin` `Plugin.define({ id, setup })` contract while keeping V1 `server()` as a separate compatibility implementation.

package/README.md

@@ -1,14 +1,14 @@
 # OpenCode Loop
 
-## Native OpenCode 2 (0.6.1)
+## Native OpenCode 2 (0.6.3)
 
-The npm and local-file V2 entrypoints now use the official `@opencode/plugin` `Plugin.define()` contract. The local installer writes a discovered plugin package directory with the generated runtime as a supporting module, while explicit `--legacy-v1` remains a separate compatibility path.
+The npm and V2 entrypoints use the official `@opencode/plugin` `Plugin.define()` contract. The installer now registers the exact `@bybrawe/opencode-loop` package in OpenCode's plural `plugins` configuration instead of copying a loose global plugin directory. OpenCode therefore resolves `@opencode/plugin` from Loop's own production dependency graph; explicit `--legacy-v1` remains a separate compatibility path.
 
-The installer now defaults to the standalone native V2 plugin. It needs no V1 SDK or legacy command files for a local installation. Existing npm registrations migrate from `plugin` to `plugins` without dropping object options. Use `--legacy-v1` explicitly for the compatibility installation.
+The installer defaults to the native V2 package plugin. It needs no loose local V2 copy, V1 SDK, or legacy command files. Existing npm registrations migrate from `plugin` to `plugins` without dropping object options, and 0.6.1/0.6.2 loose `plugins/opencode-loop` installs are removed on update. Use `--legacy-v1` explicitly for the compatibility installation.
 
 V2 prompt admission and durable inbox/execution/compaction events own scheduling. Core-generated user-role messages never authorize a session abort. An unfinished dedicated Goal reserves its session, including paused and handed-off states; Loop does not wake or replace that Goal. Soft iteration timeouts do not abort a native model/tool/compaction turn.
 
-Scheduled shell commands use bounded local child processes when OpenCode does not expose `session.shell` to plugins. Automatic compaction stays host-owned. **Scheduled compaction requires a host exposing `session.compact`; OpenCode 2.0.18's published plugin Context does not expose it, and those commands are rejected before job creation rather than silently ignored.** Use OpenCode's built-in manual/automatic compaction on that host.
+Scheduled shell commands use Loop-managed bounded local child processes; the OpenCode 2 `ctx.shell` surface is a hook domain, not a command-execution API. Automatic compaction stays host-owned. **The public OpenCode 2 SessionDomain has no manual compaction action, so `/loop-compact`, `--compact`, and `--compact-every` are rejected before job creation instead of probing undocumented `session.compact` fields.** Use OpenCode's built-in manual/automatic compaction on V2.
 
 Prompt/command timers, watch and stop conditions, verification, preflight/postrun, notifications, checkpoints and diagnostic commands use the V2 runtime. Uncertain restart admissions pause for review rather than replaying potentially admitted work. The dedicated `@bybrawe/opencode-goal` plugin owns `/goal`; legacy Loop Goal records are preserved and are not silently reinterpreted as new Goal contracts.
 
@@ -17,32 +17,48 @@ Prompt/command timers, watch and stop conditions, verification, preflight/postru
 
 OpenCode Loop adds `/loop`, scheduled prompt/command/shell jobs, compact scheduling, verification/checkpoints, and the `opencode-loopd` background daemon.
 
-> **Current stable release: `0.6.1`.**
+> **Current stable release: `0.6.3`.**
 
 ## Install or update
 
-Recommended:
+### Recommended OpenCode 2 setup
+
+Install the dedicated Goal plugin first:
+
+```bash
+npx -y @bybrawe/opencode-goal@latest
+```
+
+Then install Loop by itself and disable Loop's older experimental Goal command files:
 
 ```bash
-npx -y @bybrawe/opencode-loop@latest
+npx -y @bybrawe/opencode-loop@latest --loop-only --without-loop-goals
 ```
 
-Run the same command again to update. Then **fully restart OpenCode** and verify:
+This is the recommended split for OpenCode 2:
+
+- **OpenCode Goal** owns `/goal`, durable outcome-driven work, evidence, verification, recovery, and semantic completion.
+- **OpenCode Loop** owns `/loop`, scheduling, repeated prompts/commands/shell work, and `opencode-loopd`.
+- `--loop-only` prevents the Loop installer from installing/updating the Goal companion.
+- `--without-loop-goals` removes only Loop's older experimental `/loop-goal*` command files; it does not remove the dedicated OpenCode Goal plugin.
+
+Run the same two commands again to update both packages. Loop 0.6.3 also migrates the earlier 0.6.1/0.6.2 loose global V2 install that could fail with `Cannot find package '@opencode/plugin'`; the update removes that loose copy and pins the published package in `plugins` instead. Then **fully restart OpenCode** and verify:
 
 ```text
+/goal status
 /loop-help
 /loop-doctor
 ```
 
-Install/update Loop and the dedicated Goals companion together:
+Convenience alternative: let the Loop installer also install/update the dedicated Goal companion:
 
 ```bash
 npx -y @bybrawe/opencode-loop@latest --with-goals --without-loop-goals
 ```
 
-`--without-loop-goals` removes only Loop's older experimental `/loop-goal*` command files. It keeps normal `/loop`, command/shell scheduling, daemon support, and the separate `/goal` plugin.
+For new OpenCode 2 installations, the explicit two-command setup above is preferred because ownership is clear and each package can be updated independently.
 
-Install only Loop and skip companion network work:
+Install only Loop without touching Goal:
 
 ```bash
 npx -y @bybrawe/opencode-loop@latest --loop-only

package/examples/OPENCODE2-0.6.2.md

@@ -0,0 +1,54 @@
+# OpenCode Loop 0.6.2
+
+OpenCode 2 migration-guide conformance release, paired with OpenCode Goal 1.3.42.
+
+## Public V2 plugin context
+
+The native runtime treats `ctx.location.directory` as the only plugin-instance
+project location. `ctx.options` remains plugin configuration and is not accepted as
+a project-directory fallback.
+
+Per-session scope is verified through public `session.get` location data, so a
+session from another worktree/project cannot borrow this plugin instance's state.
+
+## V2 plugin and installation contract
+
+The npm root/server and explicit `./v2` entries use
+`@opencode/plugin` `Plugin.define({ id, setup })`. Native installs use plural
+`plugins` configuration and the V2 plugins layout. Explicit `--legacy-v1` remains
+a separate compatibility path; V1 hooks and SDK request shapes are not the default
+V2 runtime.
+
+Native prompt/compaction hooks, command transforms and the event subscription are
+registered through V2 domains and disposed on unload. The event stream is cancelled
+with an abort signal before local resources and registrations are drained.
+
+## Capability boundary
+
+Loop does not probe undocumented `session.shell`, `session.compact` or
+`session.inbox` properties. Scheduled shell execution is a bounded Loop-managed
+local process. Manual scheduled compaction remains unsupported on the OpenCode
+2.0.18 public plugin contract and is rejected before durable job creation; automatic
+compaction remains host-owned.
+
+## Paired Goal release
+
+Publication is pinned to OpenCode Goal 1.3.42 from immutable source
+`1dd58abf1e7c08594c2085883e28acea3dbe0418` and refuses to continue until that
+exact package is visible on npm.
+
+## Verification
+
+The publisher requires Windows/Linux native regressions, exact-main CI and Native V2
+CI, production tarball installation, joint Goal+Loop installation/options/uninstall,
+real native commands and the two-turn single-session daemon on OpenCode 2.0.18.
+
+Install the verified pair after registry publication:
+
+```sh
+npx -y @bybrawe/opencode-goal@1.3.42
+npx -y @bybrawe/opencode-loop@0.6.2 --loop-only --without-loop-goals
+```
+
+Fully restart OpenCode after installation. Existing project Goal/Loop state and
+user-owned files are preserved.

package/examples/OPENCODE2-0.6.3.md

@@ -0,0 +1,71 @@
+# OpenCode Loop 0.6.3
+
+OpenCode 2 installer dependency-resolution fix, paired with OpenCode Goal 1.3.42.
+
+## What changed
+
+OpenCode Loop now installs natively as an exact published package registration:
+
+```json
+{
+  "plugins": [
+    "@bybrawe/opencode-loop@0.6.3"
+  ]
+}
+```
+
+The default V2 installer no longer copies a loose global
+`~/.config/opencode/plugins/opencode-loop` package directory.
+
+This fixes the reproduced OpenCode 2.0.21 startup failure:
+
+```text
+Cannot find package '@opencode/plugin' imported from
+.../.config/opencode/plugins/opencode-loop/index.js
+```
+
+The V2 entrypoint still uses the official `@opencode/plugin`
+`Plugin.define({ id, setup })` contract. The difference is distribution:
+OpenCode now resolves the entrypoint and `@opencode/plugin` from the same
+published package dependency graph.
+
+## Upgrade behavior
+
+Running the 0.6.3 installer over 0.6.1/0.6.2 automatically:
+
+- adds or pins the exact Loop package in plural `plugins`;
+- removes known loose `plugins/opencode-loop`, `opencode-loop.ts` and
+  `opencode-loop.js` copies;
+- preserves unrelated plugin registrations and object options;
+- preserves project state under `.opencode/opencode-loop/`;
+- keeps explicit `--legacy-v1` behavior isolated.
+
+## Paired Goal release
+
+Publication remains paired with OpenCode Goal 1.3.42 from immutable source
+`1dd58abf1e7c08594c2085883e28acea3dbe0418`.
+
+## Verification
+
+The release gate runs Windows/Linux installer regressions, package smoke tests,
+exact-main CI, native V2 CI and the production Goal+Loop host pair before npm
+publication.
+
+Install or update:
+
+```sh
+npx -y @bybrawe/opencode-goal@1.3.42
+npx -y @bybrawe/opencode-loop@0.6.3 --loop-only --without-loop-goals
+```
+
+Then fully restart OpenCode and verify:
+
+```text
+/goal status
+/loop-help
+/loop-doctor
+```
+
+If OpenCode itself reports that managed service port 49374 is already in use,
+that is a host service collision rather than this plugin dependency bug. Stop or
+reconfigure the OpenCode service before testing the commands.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Claude Code/Codex style /loop and experimental goal mode for OpenCode: heartbeat scheduler, idle-safe loops, scheduled commands, compact scheduling, verification, checkpoints, and persistent coding goals.",
   "type": "module",
   "main": "src/plugin.js",

package/scripts/host-goal-coexistence-canary.mjs

@@ -10,6 +10,9 @@ import { fileURLToPath, pathToFileURL } from "node:url"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const isWindows = process.platform === "win32"
+const SERVER_READY_TIMEOUT_MS = isWindows ? 60_000 : 30_000
+const API_BOOTSTRAP_TIMEOUT_MS = isWindows ? 90_000 : 30_000
+const PREWARM_TIMEOUT_MS = isWindows ? 120_000 : 60_000
 const GOAL_OBJECTIVE = "prove dedicated Goal owns continuation over Loop"
 const GOAL_PROMPT_MARKER = "Continue working toward the active OpenCode goal."
 const LOOP_PROMPT_MARKER = "AUTONOMOUS OPENCODE LOOP ITERATION"
@@ -301,28 +304,41 @@ async function main() {
   }
 
   try {
-    const prewarm = await runOpenCode(["debug", "config"], { cwd: workspace, env, timeoutMs: 60_000 })
+    const prewarm = await runOpenCode(["debug", "config"], { cwd: workspace, env, timeoutMs: PREWARM_TIMEOUT_MS })
     assert.match(prewarm.stdout, /\{[\s\S]*\}/, `OpenCode config prewarm returned no JSON\n${prewarm.stdout}\n${prewarm.stderr}`)
 
     const port = await reservePort()
     server = spawnOpenCode(["serve", "--hostname", "127.0.0.1", "--port", String(port)], { cwd: workspace, env })
     server.stdout?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
     server.stderr?.on("data", (chunk) => { serverLog = appendLog(serverLog, chunk) })
-    await waitForTcp(port, server, () => serverLog)
+    await waitForTcp(port, server, () => serverLog, SERVER_READY_TIMEOUT_MS)
 
     const baseURL = `http://127.0.0.1:${port}`
     const directoryQuery = `directory=${encodeURIComponent(workspace)}`
     const api = async (pathname, init = {}) => {
       const separator = pathname.includes("?") ? "&" : "?"
-      const response = await fetch(`${baseURL}${pathname}${separator}${directoryQuery}`, {
-        ...init,
-        headers: { "content-type": "application/json", ...(init.headers ?? {}) },
-        signal: init.signal ?? AbortSignal.timeout(30_000),
-      })
-      const text = await response.text()
-      if (!response.ok) throw new Error(`HTTP ${response.status}: ${text}`)
-      if (!text) return null
-      try { return JSON.parse(text) } catch { return text }
+      const url = `${baseURL}${pathname}${separator}${directoryQuery}`
+      const ownTimeout = !init.signal
+      const timeoutMs = API_BOOTSTRAP_TIMEOUT_MS
+      try {
+        const response = await fetch(url, {
+          ...init,
+          headers: { "content-type": "application/json", ...(init.headers ?? {}) },
+          signal: init.signal ?? AbortSignal.timeout(timeoutMs),
+        })
+        const text = await response.text()
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${text}`)
+        if (!text) return null
+        try { return JSON.parse(text) } catch { return text }
+      } catch (error) {
+        const method = init.method ?? "GET"
+        const boundary = ownTimeout ? ` after ${timeoutMs}ms bootstrap timeout` : " with caller-owned signal"
+        throw new Error(
+          `OpenCode API ${method} ${pathname} failed${boundary}: ${error?.name ?? "Error"}: ${error?.message ?? error}\n`
+          + `provider=${JSON.stringify(provider.stats)}\nserver log:\n${serverLog}`,
+          { cause: error },
+        )
+      }
     }
 
     const sessionsPayload = await api("/session", { method: "GET" })

package/scripts/install-node.mjs

@@ -22,7 +22,7 @@ const installerArgs = rawInstallerArgs.filter((arg) => arg !== "--legacy-v1")
 const uninstallRequested = installerArgs.length === 1 && ["--uninstall", "uninstall", "--remove"].includes(installerArgs[0] || "")
 
 if (installerArgs.includes("--help") || installerArgs.includes("-h")) {
-  console.log(`OpenCode Loop installer/updater\n\nUsage:\n  opencode-loop\n  npx -y @bybrawe/opencode-loop@latest\n  npx -y @bybrawe/opencode-loop@latest --uninstall\n\nInstall/update defaults to native OpenCode 2: no V1 SDK or legacy command files are needed for a local install. Existing npm registrations are pinned to the exact version and migrated to plugins while retaining object options. Use --legacy-v1 to install the compatibility loader and legacy command files explicitly.\nUninstall removes Loop package registrations plus known local plugin/command/agent files while preserving project Loop state.\n\nSet OPENCODE_CONFIG_DIR to target a non-default OpenCode config directory.`)
+  console.log(`OpenCode Loop installer/updater\n\nUsage:\n  opencode-loop\n  npx -y @bybrawe/opencode-loop@latest\n  npx -y @bybrawe/opencode-loop@latest --uninstall\n\nInstall/update defaults to native OpenCode 2: the exact package version is registered in the plural plugins config so OpenCode resolves the package and its V2 runtime dependencies together. No loose local V2 plugin copy, V1 SDK, or legacy command files are needed. Existing npm registrations are pinned to the exact version and migrated to plugins while retaining object options. Use --legacy-v1 to install the compatibility loader and legacy command files explicitly.\nUninstall removes Loop package registrations plus known local plugin/command/agent files while preserving project Loop state.\n\nSet OPENCODE_CONFIG_DIR to target a non-default OpenCode config directory.`)
   process.exit(0)
 }
 
@@ -277,9 +277,13 @@ async function configurePackagePlugin() {
           }
         } else {
           const pinned = pinRegistration(own)
-          if (Array.isArray(parsed.plugin) && parsed.plugin.some(isPackageSpec)) updated = rewriteExistingPluginArray(updated, parsed.plugin.filter((entry) => !isPackageSpec(entry)), "plugin")
+          if (Array.isArray(parsed.plugin) && parsed.plugin.some(isPackageSpec)) {
+            updated = rewriteExistingPluginArray(updated, parsed.plugin.filter((entry) => !isPackageSpec(entry)), "plugin")
+          }
           const next = [...(parsed.plugins || []).filter((entry) => !isPackageSpec(entry)), pinned]
-          updated = parsed.plugins === undefined ? appendPluginProperty(updated, next, "plugins") : rewriteExistingPluginArray(updated, next, "plugins")
+          updated = parsed.plugins === undefined
+            ? appendPluginProperty(updated, next, "plugins")
+            : rewriteExistingPluginArray(updated, next, "plugins")
         }
       }
       parseJsonc(updated)
@@ -288,8 +292,35 @@ async function configurePackagePlugin() {
       if (error?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${error.message}`)
     }
   }
+
+  // Native V2 installs are package registrations, not loose discovered copies.
+  // The published package owns @opencode/plugin as a production dependency, so
+  // OpenCode resolves the entrypoint and SDK from the same package install.
+  // This also migrates broken 0.6.1/0.6.2 loose installs on the next update.
+  if (!configured && !legacyV1) {
+    if (plans.length) {
+      const plan = plans[0]
+      const parsed = parseJsonc(plan.updated)
+      const entries = parsed.plugins || []
+      if (!Array.isArray(entries)) throw new Error("OpenCode config 'plugins' must be an array")
+      plan.updated = parsed.plugins === undefined
+        ? appendPluginProperty(plan.updated, [...entries, packageSpec], "plugins")
+        : rewriteExistingPluginArray(plan.updated, [...entries, packageSpec], "plugins")
+      parseJsonc(plan.updated)
+    } else {
+      const target = join(config, "opencode.json")
+      const updated = JSON.stringify({
+        $schema: "https://opencode.ai/config.json",
+        plugins: [packageSpec],
+      }, null, 2) + "\n"
+      plans.push({ target, source: "", updated })
+    }
+    configured = true
+  }
+
   // Validate every candidate before writing any config. Malformed later files
-  // must not leave the earlier file migrated and the plugin half-installed.
+  // must not leave an earlier file migrated and the plugin half-installed.
+  for (const plan of plans) parseJsonc(plan.updated)
   for (const plan of plans) if (plan.source !== plan.updated) await writeFile(plan.target, plan.updated, "utf8")
   return { configured, updatedFiles: plans.filter((plan) => plan.source !== plan.updated).map((plan) => plan.target) }
 }
@@ -367,14 +398,7 @@ async function installOrUpdate() {
     await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
     await rm(join(pluginDir, "opencode-loop.js"), { force: true })
   } else {
-    // V2 local plugins use the same Plugin.define entrypoint as the npm package.
-    // Keep the generated native runtime beside it as a supporting module instead
-    // of auto-discovering that implementation object as a second plugin.
-    await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
-    await rm(join(pluginDir, "opencode-loop.js"), { force: true })
-    await mkdir(nativePluginDir, { recursive: true })
-    await copyFile(join(root, "src", "v2.js"), join(nativePluginDir, "index.js"))
-    await copyFile(join(root, "src", "native.js"), join(nativePluginDir, "native.js"))
+    throw new Error("Native OpenCode 2 package registration was not created")
   }
   if (legacyV1) {
     await mkdir(commandDir, { recursive: true })
@@ -388,11 +412,11 @@ async function installOrUpdate() {
   if (packageConfig.configured) {
     const pinResult = packageConfig.updatedFiles.length ? `pinned the config entry to ${packageSpec}` : `the config entry is already pinned to ${packageSpec}`
     console.log(`OpenCode Loop is already configured as a package in ${config}; ${pinResult} and removed the duplicate local plugin copy.`)
-  } else console.log(`Installed OpenCode Loop plugin to ${legacyV1 ? join(pluginDir, "opencode-loop.ts") : nativePluginDir}`)
+  } else console.log(`Installed OpenCode Loop compatibility plugin to ${join(pluginDir, "opencode-loop.ts")}`)
   if (legacyV1) {
     console.log(`Installed ${packageName} commands to ${commandDir}`)
     console.log(`Installed ${packageName} local command agent to ${agentDir}`)
-  } else console.log("Native OpenCode 2 commands are registered by the plugin; no legacy command files or V1 SDK are needed for a local install.")
+  } else console.log("Native OpenCode 2 is registered as an exact package plugin; OpenCode resolves @opencode/plugin from the package dependency graph. No loose local plugin copy, legacy command files, or V1 SDK are needed.")
   console.log("Restart OpenCode, then run: /loop-help")
 }
 

package/scripts/native-install-test.mjs

@@ -28,22 +28,33 @@ try {
   run(fresh)
   const native = await readFile(path.join(root, "src/native.js"), "utf8")
   const v2 = await readFile(path.join(root, "src/v2.js"), "utf8")
-  assert.equal(await readFile(path.join(fresh, "plugins/opencode-loop/index.js"), "utf8"), v2)
-  assert.equal(await readFile(path.join(fresh, "plugins/opencode-loop/native.js"), "utf8"), native)
+  const readConfig = async (directory) => JSON.parse(await readFile(path.join(directory, "opencode.json"), "utf8"))
+  assert.deepEqual((await readConfig(fresh)).plugins, [spec])
   assert.match(v2, /from\s+["']@opencode\/plugin["']/)
   assert.match(v2, /Plugin\.define\s*\(/)
   assert.doesNotMatch(native, /(?:from\s*|import\s*\()["']@opencode-ai\/plugin/)
+  assert.equal(await exists(path.join(fresh, "plugins/opencode-loop")), false)
   assert.equal(await exists(path.join(fresh, "plugins/opencode-loop.ts")), false)
   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)
+  const freshBefore = await readFile(path.join(fresh, "opencode.json"), "utf8")
   run(fresh)
+  assert.equal(await readFile(path.join(fresh, "opencode.json"), "utf8"), freshBefore)
+  cases++
+
+  const brokenLoose = await config("broken-loose")
+  await mkdir(path.join(brokenLoose, "plugins/opencode-loop"), { recursive: true })
+  await writeFile(path.join(brokenLoose, "plugins/opencode-loop/index.js"), 'import { Plugin } from "@opencode/plugin"\nexport default Plugin.define({ id: "broken", setup() {} })\n')
+  await writeFile(path.join(brokenLoose, "plugins/opencode-loop/native.js"), "export default {}\n")
+  run(brokenLoose)
+  assert.deepEqual((await readConfig(brokenLoose)).plugins, [spec])
+  assert.equal(await exists(path.join(brokenLoose, "plugins/opencode-loop")), false, "native update must remove the old loose V2 copy that cannot resolve package dependencies")
   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)
@@ -88,8 +99,8 @@ try {
   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/index.js"), "utf8"), v2)
-  assert.equal(await readFile(path.join(upgrade, "plugins/opencode-loop/native.js"), "utf8"), native)
+  assert.deepEqual((await readConfig(upgrade)).plugins, [spec])
+  assert.equal(await exists(path.join(upgrade, "plugins/opencode-loop")), false)
   assert.equal(await exists(path.join(upgrade, "plugins/opencode-loop.ts")), false)
   cases++
 

package/scripts/native-lifecycle-test.mjs

@@ -19,6 +19,7 @@ async function fixture({ failDispose = false, failSubscribe = false } = {}) {
   const ctx = {
     location: { directory }, options: {},
     session: {
+      get: async ({ sessionID }) => ({ id: sessionID, location: { directory } }),
       prompt: async () => { throw new Error("cleanup must not prompt or abort a native session") },
       hook: async name => registration(name),
     },
@@ -46,6 +47,18 @@ async function bounded(promise) {
   finally { clearTimeout(timer) }
 }
 
+test("native setup never treats plugin options.directory as location authority", async () => {
+  const host = await fixture()
+  try {
+    host.ctx.location = {}
+    host.ctx.options.directory = "/not-a-v2-location"
+    await assert.rejects(
+      plugin.setup(host.ctx),
+      /requires a project directory/i,
+    )
+  } finally { host.release(); await host.remove() }
+})
+
 test("native unload aborts a pending public event stream and shares cleanup", async () => {
   const host = await fixture()
   let dispose

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

@@ -17,6 +17,7 @@ function fixture(directory, { failCleanup = false } = {}) {
   const ctx = {
     location: { directory }, options: {}, app: { version: "2.0.18" },
     session: {
+      get: async ({ sessionID }) => ({ id: sessionID, location: { directory } }),
       prompt: async () => { throw new Error("cleanup must not dispatch a prompt") },
       hook: async (name) => registration(name),
     },
@@ -47,6 +48,18 @@ async function bounded(promise) {
   } finally { clearTimeout(timer) }
 }
 
+test("native Loop fails setup when the public session.get location capability is unavailable", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-v2-no-session-get-"))
+  const host = fixture(directory)
+  delete host.ctx.session.get
+  try {
+    await assert.rejects(plugin.setup(host.ctx), /requires session\.get/)
+  } finally {
+    host.end()
+    await rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  }
+})
+
 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)
@@ -87,6 +100,26 @@ test("native Loop cleanup is shared and drains all registrations after an error"
   }
 })
 
+test("native Loop never probes undocumented SessionDomain shell compact or inbox fields", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-v2-public-session-"))
+  const host = fixture(directory)
+  let dispose
+  try {
+    for (const field of ["shell", "compact", "inbox"]) {
+      Object.defineProperty(host.ctx.session, field, {
+        configurable: true,
+        get() { throw new Error(`undocumented session.${field} was accessed`) },
+      })
+    }
+    dispose = await plugin.setup(host.ctx)
+    assert.equal(typeof dispose, "function")
+  } finally {
+    host.end()
+    await dispose?.().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")
 })

package/scripts/native-presets-test.mjs

@@ -9,9 +9,9 @@ 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 PRESETS = ["loop-dev", "loop-testfix", "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 } = {}) {
+async function fixture() {
   const temp = await mkdtemp(path.join(os.tmpdir(), "loop-native-presets-"))
   const directory = path.join(temp, "project with spaces")
   await mkdir(directory)
@@ -27,7 +27,6 @@ async function fixture({ compact = true } = {}) {
         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}`)
@@ -54,7 +53,7 @@ for (const name of PRESETS) {
       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 text = `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)
@@ -64,7 +63,7 @@ for (const name of PRESETS) {
       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].intervalMs, 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)
@@ -98,21 +97,28 @@ test("an immediate native development preset enters the existing dry-run safety
   } finally { await host.dispose() }
 })
 
-test("zero-delay deferred shell preset is scheduled without an unrelated model turn", async () => {
+test("zero-delay deferred shell preset uses Loop-managed local execution 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))
+    const marker = path.join(host.directory, "shell-ran.txt")
+    await writeFile(path.join(host.directory, "shell-test.cjs"), 'require("fs").writeFileSync("shell-ran.txt", "ok")')
+    const command = `"${process.execPath}" shell-test.cjs`
+    await host.execute("loop-shell", `0s ${command} --max-runs 1`)
+    const deadline = Date.now() + 5000
     while (Date.now() < deadline && (await host.state()).jobs[0]?.runCount !== 1) await new Promise(resolve => setTimeout(resolve, 10))
+    while (Date.now() < deadline) {
+      try { if ((await readFile(marker, "utf8")) === "ok") break } catch {}
+      await new Promise(resolve => setTimeout(resolve, 10))
+    }
     assert.equal((await host.state()).jobs[0].runCount, 1)
-    assert.equal(host.shellCalls.length, 1)
+    assert.equal(await readFile(marker, "utf8"), "ok")
+    assert.equal(host.shellCalls.length, 0, "V2 must not call undocumented session.shell")
     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 })
+test("native compaction rejects its preset before job persistence because V2 exposes no manual compaction action", async () => {
+  const host = await fixture()
   try {
     await assert.rejects(host.execute("loop-compact", "--dry-run"), /native compaction capability/)
     assert.deepEqual((await host.state()).jobs, [])

package/scripts/native-release.mjs

@@ -7,12 +7,12 @@ 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.1", "release version is not authorized")
+  assert.equal(request?.version, "0.6.3", "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.6.0")
-  assert.equal(request.goal?.version, "1.3.40")
+  assert.equal(request.predecessor, "0.6.2")
+  assert.equal(request.goal?.version, "1.3.42")
   assert.match(request.goal?.sha ?? "", /^[a-f0-9]{40}$/)
   return request
 }

package/scripts/native-v2-test.mjs

@@ -183,6 +183,16 @@ await test("preflight failure does not consume a run", async (f) => {
   assert.equal(f.prompts.length, 0)
 }, { runShellCommand: async () => ({ code: 3, stdout: "", stderr: "not ready" }) })
 
+await test("native slash command dispatch uses OpenCode 2 command and arguments fields", async (f) => {
+  await f.add("0s --command /review --staged --max-runs 1")
+  await f.wake()
+  assert.equal(f.commands.length, 1)
+  assert.equal(f.commands[0].command, "review")
+  assert.equal(f.commands[0].arguments, "--staged")
+  assert.equal("name" in f.commands[0], false)
+  assert.equal("text" in f.commands[0], false)
+})
+
 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()

package/scripts/publish-workflow-test.mjs

@@ -6,6 +6,7 @@ import { validateRelease, releaseDecision, assertPublishedSource, waitForPublish
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const workflow = await readFile(path.join(repoRoot, ".github/workflows/publish-npm.yml"), "utf8")
+const nativeV2Workflow = await readFile(path.join(repoRoot, ".github/workflows/native-v2-ci.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/)
@@ -28,6 +29,8 @@ 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.match(workflow, /npm install --no-save --legacy-peer-deps @opencode\/plugin@2\.0\.18/, "immutable Goal companion must build against its pinned OpenCode 2.0.18 plugin contract")
+assert.match(nativeV2Workflow, /npm install --no-save --legacy-peer-deps @opencode\/plugin@2\.0\.18/, "Native V2 CI must pin the immutable Goal companion to the same OpenCode 2.0.18 plugin contract")
 assert.doesNotMatch(workflow, /secrets\.NPM_TOKEN/)
 
 const publishIndex = workflow.indexOf("npm publish --access public")
@@ -41,14 +44,14 @@ const publisher = workflow.slice(workflow.indexOf("  publish:\n"), workflow.inde
 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.1", predecessor: "0.6.0", goal: { version: "1.3.40", sha: "b".repeat(40) } }
+const request = { name: "@bybrawe/opencode-loop", version: "0.6.3", predecessor: "0.6.2", goal: { version: "1.3.42", 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.6.0" }, env))
-assert.equal(releaseDecision(404, null, request, sha, "0.6.0"), true)
+assert.throws(() => validateRelease(request, { ...pkg, version: "0.6.2" }, env))
+assert.equal(releaseDecision(404, null, request, sha, "0.6.2"), true)
 for (const status of [401, 403, 429, 500, 503]) assert.throws(() => releaseDecision(status, null, request, sha, "0.6.0"))
 assert.throws(() => releaseDecision(404, null, request, sha, "0.7.0"))
 const manifest = { ...pkg, gitHead: sha }

package/src/native.js

@@ -1862,7 +1862,7 @@ ${await policy.buildPrompt(scope.directory, job)}`, delivery: "queue", metadata:
       request = { sessionID: scope.sessionID, id: id(), command: String(job.action).replace(/^[!$]\s*/, ""), timeoutMs: job.timeoutMs };
     else {
       const [name, text] = splitFirst(String(job.action).replace(/^\/+/, ""));
-      request = { sessionID: scope.sessionID, name, text: text || "", delivery: "queue" };
+      request = { sessionID: scope.sessionID, command: name, arguments: text || "", delivery: "queue" };
     }
     if (!isCurrent())
       return result({ reason: "foreground-or-compaction" });
@@ -2963,8 +2963,8 @@ Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /l
 /loop-init [progress.md] creates a missing project-local progress file without overwriting existing data.
 Controls: /loop-now, /loop-pause, /loop-resume, /loop-stop, /loop-remove, /loop-clear, /loop-status, /loop-export.
 Preflight, postrun, notifications, stop files, completion markers, runtime/failure/run limits, branches and checkpoints are supported.
-Scheduled shell commands run as bounded local child processes when the plugin context has no session.shell.
-Scheduled/manual compaction requires session.compact on the host; unavailable capability is rejected before creating a job. Native automatic compaction is always left to OpenCode.
+Scheduled shell commands run as bounded local child processes managed by Loop; OpenCode 2's ctx.shell surface is a hook API, not a shell-execution method.
+The public OpenCode 2 plugin API does not expose manual session compaction. /loop-compact, --compact and --compact-every are rejected before job creation on V2; native automatic compaction remains host-owned and is observed through the compaction hook.
 An unfinished dedicated Goal reserves its session; Loop will not override it.
 --timeout pauses future iterations without aborting the current native model/tool/compaction operation.
 --safe is a command heuristic, not a sandbox. --dry-run does not dispatch or run hooks.
@@ -2982,11 +2982,11 @@ async function cleanup(value) {
 var OpenCodeLoopNativePlugin = Object.freeze({
   id: "@bybrawe/opencode-loop",
   async setup(ctx) {
-    for (const [label, fn] of [["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
+    for (const [label, fn] of [["session.get", ctx?.session?.get], ["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
       if (typeof fn !== "function")
         throw new Error(`Native OpenCode Loop requires ${label}; use OpenCode 2.0.18 or newer.`);
     }
-    const directory = String(ctx.location?.directory || ctx.options?.directory || "").trim();
+    const directory = String(ctx.location?.directory || "").trim();
     if (!directory)
       throw new Error("Native OpenCode Loop requires a project directory");
     const ownsSession = createNativeSessionLocationGuard({
@@ -3010,12 +3010,9 @@ var OpenCodeLoopNativePlugin = Object.freeze({
       prompt,
       command: typeof ctx.session.command === "function" ? (request) => ctx.session.command(request) : undefined,
       wait: typeof ctx.session.wait === "function" ? (request) => ctx.session.wait(request) : undefined,
-      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact({ ...request, delivery: "queue" }) : undefined,
-      shell: typeof ctx.session.shell === "function" ? (request) => ctx.session.shell(request) : (request) => shellHost.dispatch(request),
-      cancel: typeof ctx.session.inbox?.cancel === "function" ? async (request) => {
-        await ctx.session.inbox.cancel(request);
-        return false;
-      } : undefined,
+      compact: undefined,
+      shell: (request) => shellHost.dispatch(request),
+      cancel: undefined,
       onError: (error) => {
         appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {});
       }

package/src/server.js

@@ -1862,7 +1862,7 @@ ${await policy.buildPrompt(scope.directory, job)}`, delivery: "queue", metadata:
       request = { sessionID: scope.sessionID, id: id(), command: String(job.action).replace(/^[!$]\s*/, ""), timeoutMs: job.timeoutMs };
     else {
       const [name, text] = splitFirst(String(job.action).replace(/^\/+/, ""));
-      request = { sessionID: scope.sessionID, name, text: text || "", delivery: "queue" };
+      request = { sessionID: scope.sessionID, command: name, arguments: text || "", delivery: "queue" };
     }
     if (!isCurrent())
       return result({ reason: "foreground-or-compaction" });
@@ -2963,8 +2963,8 @@ Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /l
 /loop-init [progress.md] creates a missing project-local progress file without overwriting existing data.
 Controls: /loop-now, /loop-pause, /loop-resume, /loop-stop, /loop-remove, /loop-clear, /loop-status, /loop-export.
 Preflight, postrun, notifications, stop files, completion markers, runtime/failure/run limits, branches and checkpoints are supported.
-Scheduled shell commands run as bounded local child processes when the plugin context has no session.shell.
-Scheduled/manual compaction requires session.compact on the host; unavailable capability is rejected before creating a job. Native automatic compaction is always left to OpenCode.
+Scheduled shell commands run as bounded local child processes managed by Loop; OpenCode 2's ctx.shell surface is a hook API, not a shell-execution method.
+The public OpenCode 2 plugin API does not expose manual session compaction. /loop-compact, --compact and --compact-every are rejected before job creation on V2; native automatic compaction remains host-owned and is observed through the compaction hook.
 An unfinished dedicated Goal reserves its session; Loop will not override it.
 --timeout pauses future iterations without aborting the current native model/tool/compaction operation.
 --safe is a command heuristic, not a sandbox. --dry-run does not dispatch or run hooks.
@@ -2982,11 +2982,11 @@ async function cleanup(value) {
 var OpenCodeLoopNativePlugin = Object.freeze({
   id: "@bybrawe/opencode-loop",
   async setup(ctx) {
-    for (const [label, fn] of [["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
+    for (const [label, fn] of [["session.get", ctx?.session?.get], ["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
       if (typeof fn !== "function")
         throw new Error(`Native OpenCode Loop requires ${label}; use OpenCode 2.0.18 or newer.`);
     }
-    const directory = String(ctx.location?.directory || ctx.options?.directory || "").trim();
+    const directory = String(ctx.location?.directory || "").trim();
     if (!directory)
       throw new Error("Native OpenCode Loop requires a project directory");
     const ownsSession = createNativeSessionLocationGuard({
@@ -3010,12 +3010,9 @@ var OpenCodeLoopNativePlugin = Object.freeze({
       prompt,
       command: typeof ctx.session.command === "function" ? (request) => ctx.session.command(request) : undefined,
       wait: typeof ctx.session.wait === "function" ? (request) => ctx.session.wait(request) : undefined,
-      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact({ ...request, delivery: "queue" }) : undefined,
-      shell: typeof ctx.session.shell === "function" ? (request) => ctx.session.shell(request) : (request) => shellHost.dispatch(request),
-      cancel: typeof ctx.session.inbox?.cancel === "function" ? async (request) => {
-        await ctx.session.inbox.cancel(request);
-        return false;
-      } : undefined,
+      compact: undefined,
+      shell: (request) => shellHost.dispatch(request),
+      cancel: undefined,
       onError: (error) => {
         appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {});
       }

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

@@ -20,8 +20,8 @@ Presets: /loop-dev, /loop-testfix, /loop-progress, /loop-safe-dev, /loop-ask, /l
 /loop-init [progress.md] creates a missing project-local progress file without overwriting existing data.
 Controls: /loop-now, /loop-pause, /loop-resume, /loop-stop, /loop-remove, /loop-clear, /loop-status, /loop-export.
 Preflight, postrun, notifications, stop files, completion markers, runtime/failure/run limits, branches and checkpoints are supported.
-Scheduled shell commands run as bounded local child processes when the plugin context has no session.shell.
-Scheduled/manual compaction requires session.compact on the host; unavailable capability is rejected before creating a job. Native automatic compaction is always left to OpenCode.
+Scheduled shell commands run as bounded local child processes managed by Loop; OpenCode 2's ctx.shell surface is a hook API, not a shell-execution method.
+The public OpenCode 2 plugin API does not expose manual session compaction. /loop-compact, --compact and --compact-every are rejected before job creation on V2; native automatic compaction remains host-owned and is observed through the compaction hook.
 An unfinished dedicated Goal reserves its session; Loop will not override it.
 --timeout pauses future iterations without aborting the current native model/tool/compaction operation.
 --safe is a command heuristic, not a sandbox. --dry-run does not dispatch or run hooks.
@@ -38,10 +38,10 @@ async function cleanup(value) {
 export const OpenCodeLoopNativePlugin = Object.freeze({
   id: "@bybrawe/opencode-loop",
   async setup(ctx) {
-    for (const [label, fn] of [["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
+    for (const [label, fn] of [["session.get", ctx?.session?.get], ["session.prompt", ctx?.session?.prompt], ["session.hook", ctx?.session?.hook], ["event.subscribe", ctx?.event?.subscribe], ["command.transform", ctx?.command?.transform]]) {
       if (typeof fn !== "function") throw new Error(`Native OpenCode Loop requires ${label}; use OpenCode 2.0.18 or newer.`)
     }
-    const directory = String(ctx.location?.directory || ctx.options?.directory || "").trim()
+    const directory = String(ctx.location?.directory || "").trim()
     if (!directory) throw new Error("Native OpenCode Loop requires a project directory")
     const ownsSession = createNativeSessionLocationGuard({
       directory, workspaceID: ctx.location?.workspaceID,
@@ -61,11 +61,13 @@ export const OpenCodeLoopNativePlugin = Object.freeze({
       prompt,
       command: typeof ctx.session.command === "function" ? (request) => ctx.session.command(request) : undefined,
       wait: typeof ctx.session.wait === "function" ? (request) => ctx.session.wait(request) : undefined,
-      compact: typeof ctx.session.compact === "function" ? (request) => ctx.session.compact({ ...request, delivery: "queue" }) : undefined,
-      shell: typeof ctx.session.shell === "function" ? (request) => ctx.session.shell(request) : (request) => shellHost.dispatch(request),
-      // cancel() returns void. The durable inbox.cancelled event, not this
-      // response alone, proves that an undelivered input can be refunded.
-      cancel: typeof ctx.session.inbox?.cancel === "function" ? async (request) => { await ctx.session.inbox.cancel(request); return false } : undefined,
+      // OpenCode 2 exposes ctx.shell as a hook domain, not an execution method,
+      // and SessionDomain has no public compact/inbox-cancel action. Keep those
+      // undocumented capabilities out of the V2 runtime instead of probing
+      // private host fields that may disappear between releases.
+      compact: undefined,
+      shell: (request) => shellHost.dispatch(request),
+      cancel: undefined,
       onError: (error) => { void appendLoopLog(directory, "v2-native-error", { message: String(error?.message || error) }).catch(() => {}) },
     })
     const bridge = createOpenCode2EventBridge({ directory, allowInboxCommands: false, onEvent: async (event) => {

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

@@ -166,7 +166,7 @@ export function createNativeLoopRuntime(options = {}) {
     else if (kind === "shell") request = { sessionID: scope.sessionID, id: id(), command: String(job.action).replace(/^[!$]\s*/, ""), timeoutMs: job.timeoutMs }
     else {
       const [name, text] = splitFirst(String(job.action).replace(/^\/+/, ""))
-      request = { sessionID: scope.sessionID, name, text: text || "", delivery: "queue" }
+      request = { sessionID: scope.sessionID, command: name, arguments: text || "", delivery: "queue" }
     }
     if (!isCurrent()) return result({ reason: "foreground-or-compaction" })
     if (job.dryRun) {