@bybrawe/opencode-loop 0.6.4 → 0.6.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.6 - 2026-10-04
+
+- Make a normal Loop install/update strictly Loop-only: it no longer installs, detects, refreshes, migrates, or modifies the dedicated `@bybrawe/opencode-goal` package.
+- Omit Loop's legacy experimental `/loop-goal*` commands by default; retain them only behind explicit `--with-loop-goals` compatibility opt-in.
+- Keep `--with-goals` as the explicit combined-install opt-in, while recommending the independently installable OpenCode Goal plugin for durable verified goals.
+- Link Loop and Goal documentation directly so the two packages remain complementary without hidden installer coupling.
+
+## 0.6.5 - 2026-10-02
+
+- Audit the native OpenCode 2 package contract against `@opencode/plugin@2.0.22` and pin the production SDK/runtime dependency to exact 2.0.22.
+- Preserve the exact OpenCode 2.0.18 native pair as a backwards-compatibility gate while also requiring the moving latest-host pair; the real latest gate passes on OpenCode 2.0.22.
+- Keep Ubuntu and Windows native bundle, regression, package-smoke, real-adapter, V1 peer-compatibility, and Loop+Goal coexistence gates green with the 2.0.22 dependency graph.
+- Pair the release with Goal 1.3.44, which carries the same SDK audit plus persisted execution-ownership recovery and current OpenTUI peer alignment.
+
 ## 0.6.4 - 2026-10-02
 
 - Persist OpenCode 2 native plugin configuration as one canonical plural `plugins` list instead of leaving valid legacy `plugin` entries in a parallel top-level block.

package/README.md

@@ -1,6 +1,6 @@
 # OpenCode Loop
 
-## Native OpenCode 2 (0.6.4)
+## Native OpenCode 2 (0.6.6)
 
 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.
 
@@ -17,51 +17,55 @@ 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.4`.**
+> **Current stable release: `0.6.6`.**
 
 ## Install or update
 
 ### Recommended OpenCode 2 setup
 
-Install the dedicated Goal plugin first:
+Install **both packages separately**:
 
 ```bash
+npx -y @bybrawe/opencode-loop@latest
 npx -y @bybrawe/opencode-goal@latest
 ```
 
-Then install Loop by itself and disable Loop's older experimental Goal command files:
+This is the recommended setup. The two installers stay independent:
+
+- the Loop command installs or updates **OpenCode Loop only**;
+- the Goal command installs or updates the dedicated **OpenCode Goal** plugin;
+- Loop does **not** install, detect, refresh, migrate, or otherwise modify `@bybrawe/opencode-goal` during a normal install/update;
+- Loop omits/removes its older experimental `/loop-goal*` command files by default.
+
+OpenCode Goal owns `/goal`, durable objective state, evidence, verification, restart recovery, and semantic completion. See [OpenCode Goal](https://github.com/ByBrawe/opencode-goal).
+
+A combined `--with-goals` path remains only as a compatibility/convenience option; the recommended setup is the two separate commands above:
+
+```bash
+npx -y @bybrawe/opencode-loop@latest --with-goals
+```
+
+If you explicitly need Loop's **legacy experimental** `/loop-goal*` commands for compatibility, opt in with:
 
 ```bash
-npx -y @bybrawe/opencode-loop@latest --loop-only --without-loop-goals
+npx -y @bybrawe/opencode-loop@latest --with-loop-goals
 ```
 
-This is the recommended split for OpenCode 2:
+Those legacy commands are not recommended for new setups; prefer the dedicated Goal plugin instead.
 
-- **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.
+`--loop-only` remains as an explicit alias for the new default Loop-only behavior, and `--without-loop-goals` remains as a compatibility alias for the new default clean command surface.
 
-Run the same two commands again to update both packages. Loop 0.6.4 also canonicalizes valid legacy `plugin` entries into the native `plugins` list; earlier 0.6.1/0.6.2 loose global V2 installs are removed and replaced by the pinned published package. Then **fully restart OpenCode** and verify:
+Run the relevant install command again to update that package. Then **fully restart OpenCode** and verify:
 
 ```text
-/goal status
 /loop-help
 /loop-doctor
 ```
 
-Convenience alternative: let the Loop installer also install/update the dedicated Goal companion:
+If you installed Goal too:
 
-```bash
-npx -y @bybrawe/opencode-loop@latest --with-goals --without-loop-goals
-```
-
-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 without touching Goal:
-
-```bash
-npx -y @bybrawe/opencode-loop@latest --loop-only
+```text
+/goal status
 ```
 
 Global npm alternative:
@@ -84,7 +88,7 @@ opencode-loop --uninstall
 npm uninstall -g @bybrawe/opencode-loop
 ```
 
-Project Loop state under `.opencode/opencode-loop/` is intentionally preserved by uninstall.
+Loop uninstall never removes the dedicated Goal plugin. Project Loop state under `.opencode/opencode-loop/` is intentionally preserved by uninstall.
 
 ## The mental model
 
@@ -374,7 +378,7 @@ Recommended choices are to finish/pause the Goal or use a separate session. Adva
 
 That escape hatch can create competing autonomous turns; use it only when that is intentional.
 
-Loop's older experimental `/loop-goal*` commands remain available for compatibility unless installed with `--without-loop-goals`. For new strongly verified Goal work, prefer:
+Loop's older experimental `/loop-goal*` commands are omitted by default. They remain available only as an explicit compatibility opt-in with `--with-loop-goals`. For new strongly verified Goal work, use the separate [OpenCode Goal](https://github.com/ByBrawe/opencode-goal) plugin:
 
 ```bash
 npx -y @bybrawe/opencode-goal@latest

package/examples/OPENCODE2-0.6.5.md

@@ -0,0 +1,42 @@
+# OpenCode Loop 0.6.5
+
+OpenCode 2.0.22 SDK-contract patch, paired with OpenCode Goal 1.3.44.
+
+## OpenCode 2.0.22 runtime contract
+
+Loop's production `@opencode/plugin` dependency is pinned to exact 2.0.22. The
+lockfile carries the matching `@opencode/{ai,client,protocol,schema,util}` runtime
+closure so clean installs and release builds use the same native contract.
+
+The moving real-host gate loads Loop main and the Goal companion together on
+OpenCode 2.0.22. The exact OpenCode 2.0.18 native pair remains in CI as a
+backwards-compatibility contract rather than being replaced by the current-host
+check.
+
+## Validation
+
+The release candidate is gated by:
+
+- Ubuntu and Windows native bundle/regression/package-smoke jobs;
+- the real OpenCode 2 adapter;
+- exact OpenCode 2.0.18 Loop+Goal coexistence;
+- latest OpenCode 2.0.22 Loop+Goal coexistence;
+- OpenCode 1 peer-compatibility tests.
+
+## Upgrade
+
+```sh
+npx -y @bybrawe/opencode-goal@1.3.44
+npx -y @bybrawe/opencode-loop@0.6.5 --loop-only --without-loop-goals
+```
+
+Then fully restart OpenCode and verify:
+
+```text
+/goal status
+/loop-help
+/loop-doctor
+```
+
+Loop state, installer canonicalization, V1 compatibility, and the host-owned
+automatic compaction boundary are unchanged by this SDK patch.

package/examples/OPENCODE2-0.6.6.md

@@ -0,0 +1,48 @@
+# OpenCode Loop 0.6.6
+
+Loop-only installation contract patch, paired for coexistence validation with OpenCode Goal 1.3.47.
+
+## Default installation
+
+A normal Loop install/update now touches **Loop only**:
+
+```sh
+npx -y @bybrawe/opencode-loop@0.6.6
+```
+
+It does not install, detect, refresh, migrate, or modify the dedicated OpenCode Goal package. Loop's older experimental `/loop-goal*` command files are omitted by default.
+
+For durable outcome-driven work, install Goal independently:
+
+```sh
+npx -y @bybrawe/opencode-goal@1.3.47
+```
+
+Or explicitly opt into a combined install:
+
+```sh
+npx -y @bybrawe/opencode-loop@0.6.6 --with-goals
+```
+
+Legacy experimental Loop Goal commands remain available only when explicitly requested:
+
+```sh
+npx -y @bybrawe/opencode-loop@0.6.6 --with-loop-goals
+```
+
+## Validation contract
+
+The release remains gated by Ubuntu/Windows regressions, production package smoke, the real OpenCode 2 adapter, exact OpenCode 2.0.18 compatibility, current-host coexistence, and immutable Goal companion source verification.
+
+After installation, fully restart OpenCode and verify:
+
+```text
+/loop-help
+/loop-doctor
+```
+
+If Goal is installed too:
+
+```text
+/goal status
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bybrawe/opencode-loop",
-  "version": "0.6.4",
-  "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.",
+  "version": "0.6.6",
+  "description": "Idle-safe /loop scheduling and background automation for OpenCode, with optional legacy Loop Goal compatibility and a separately installable OpenCode Goal companion.",
   "type": "module",
   "main": "src/plugin.js",
   "exports": {
@@ -75,6 +75,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode/plugin": "2.0.18"
+    "@opencode/plugin": "2.0.22"
   }
 }

package/scripts/goal-companion-test.mjs

@@ -94,8 +94,8 @@ try {
   const absentLog = path.join(temporaryRoot, "absent.log")
   const absent = await runInstaller(absentConfig, [], { FAKE_NPM_LOG: absentLog })
   assert.equal(absent.code, 0, absent.stderr)
-  assert.deepEqual(await calls(absentLog), [], "Loop-only installations must not silently add Goals")
-  assert.ok((await loopGoalCommands(absentConfig)).length > 0, "legacy Loop Goal commands stay installed by default for compatibility")
+  assert.deepEqual(await calls(absentLog), [], "default Loop installs must not silently add or update Goal")
+  assert.deepEqual(await loopGoalCommands(absentConfig), [], "legacy Loop Goal commands must be omitted by default")
 
   const withoutLoopGoalsConfig = path.join(temporaryRoot, "without-loop-goals")
   const withoutLoopGoalsLog = path.join(temporaryRoot, "without-loop-goals.log")
@@ -111,15 +111,15 @@ try {
   await writeConfig(existingConfig, ["other-plugin", "@bybrawe/opencode-goal@1.3.16"])
   const existing = await runInstaller(existingConfig, [], { FAKE_NPM_LOG: existingLog })
   assert.equal(existing.code, 0, existing.stderr)
-  assert.deepEqual(await calls(existingLog), [expectedGoalExec], "an installed Goals package must auto-refresh through its own latest installer")
-  assert.match(existing.stdout, /Installed\/updated OpenCode Goals via @bybrawe\/opencode-goal@latest/)
+  assert.deepEqual(await calls(existingLog), [], "default Loop updates must not refresh an installed Goal package")
+  assert.match(existing.stdout, /Recommended companion install \(separate command\)/)
 
   const localConfig = path.join(temporaryRoot, "local-goal")
   const localLog = path.join(temporaryRoot, "local-goal.log")
   await writeConfig(localConfig, ["./plugins/opencode-goal.ts"])
   const local = await runInstaller(localConfig, [], { FAKE_NPM_LOG: localLog })
   assert.equal(local.code, 0, local.stderr)
-  assert.deepEqual(await calls(localLog), [expectedGoalExec], "legacy local Goals installs must be refreshed/migrated by the companion installer")
+  assert.deepEqual(await calls(localLog), [], "default Loop updates must not migrate or refresh legacy Goal installs")
 
   const managedCommandConfig = path.join(temporaryRoot, "managed-command")
   const managedCommandLog = path.join(temporaryRoot, "managed-command.log")
@@ -127,7 +127,7 @@ try {
   await fs.writeFile(path.join(managedCommandConfig, "commands", "goal.md"), "<!-- managed-by:@bybrawe/opencode-goal -->\n", "utf8")
   const managedCommand = await runInstaller(managedCommandConfig, [], { FAKE_NPM_LOG: managedCommandLog })
   assert.equal(managedCommand.code, 0, managedCommand.stderr)
-  assert.deepEqual(await calls(managedCommandLog), [expectedGoalExec], "a managed /goal command is sufficient evidence that Goals should be refreshed")
+  assert.deepEqual(await calls(managedCommandLog), [], "a managed /goal command must not trigger Goal network work during a default Loop update")
 
   const commentedConfig = path.join(temporaryRoot, "comment-only")
   const commentedLog = path.join(temporaryRoot, "comment-only.log")
@@ -149,21 +149,27 @@ try {
   assert.deepEqual(await calls(explicitCleanLog), [expectedGoalExec], "the clean command surface option must compose with --with-goals")
   assert.deepEqual(await loopGoalCommands(explicitCleanConfig), [], "combined install must keep the stronger Goals plugin without legacy Loop Goal command clutter")
 
+  const legacyGoalConfig = path.join(temporaryRoot, "legacy-loop-goals")
+  const legacyGoalLog = path.join(temporaryRoot, "legacy-loop-goals.log")
+  const legacyGoal = await runInstaller(legacyGoalConfig, ["--with-loop-goals"], { FAKE_NPM_LOG: legacyGoalLog })
+  assert.equal(legacyGoal.code, 0, legacyGoal.stderr)
+  assert.deepEqual(await calls(legacyGoalLog), [], "--with-loop-goals must not install the dedicated Goal package")
+  assert.ok((await loopGoalCommands(legacyGoalConfig)).length > 0, "--with-loop-goals must explicitly restore the legacy experimental command surface")
+
   const optOutConfig = path.join(temporaryRoot, "opt-out")
   const optOutLog = path.join(temporaryRoot, "opt-out.log")
   await writeConfig(optOutConfig, ["@bybrawe/opencode-goal@1.3.16"])
   const optOut = await runInstaller(optOutConfig, ["--loop-only"], { FAKE_NPM_LOG: optOutLog })
   assert.equal(optOut.code, 0, optOut.stderr)
   assert.deepEqual(await calls(optOutLog), [], "--loop-only must suppress companion network work")
-  assert.match(optOut.stdout, /Skipped OpenCode Goals companion update/)
+  assert.match(optOut.stdout, /Installed\/updated OpenCode Loop only \(--loop-only\)/)
 
-  const autoFailureConfig = path.join(temporaryRoot, "auto-failure")
-  const autoFailureLog = path.join(temporaryRoot, "auto-failure.log")
-  await writeConfig(autoFailureConfig, ["@bybrawe/opencode-goal@1.3.16"])
-  const autoFailure = await runInstaller(autoFailureConfig, [], { FAKE_NPM_LOG: autoFailureLog, FAKE_NPM_EXIT: "7" })
-  assert.equal(autoFailure.code, 0, "a best-effort refresh failure must not break an otherwise successful Loop update")
-  assert.match(autoFailure.stderr, /could not be refreshed/)
-  assert.match(autoFailure.stderr, /npx -y @bybrawe\/opencode-goal@latest/)
+  const untouchedConfig = path.join(temporaryRoot, "untouched-existing-goal")
+  const untouchedLog = path.join(temporaryRoot, "untouched-existing-goal.log")
+  await writeConfig(untouchedConfig, ["@bybrawe/opencode-goal@1.3.16"])
+  const untouched = await runInstaller(untouchedConfig, [], { FAKE_NPM_LOG: untouchedLog, FAKE_NPM_EXIT: "7" })
+  assert.equal(untouched.code, 0, untouched.stderr)
+  assert.deepEqual(await calls(untouchedLog), [], "default Loop update must perform zero Goal network work even when Goal is already installed")
 
   const explicitFailureConfig = path.join(temporaryRoot, "explicit-failure")
   const explicitFailureLog = path.join(temporaryRoot, "explicit-failure.log")
@@ -181,8 +187,10 @@ try {
   assert.match(help.stdout, /OpenCode Loop installer\/updater/)
   assert.match(help.stdout, /--with-goals/)
   assert.match(help.stdout, /--loop-only/)
+  assert.match(help.stdout, /--with-loop-goals/)
   assert.match(help.stdout, /--without-loop-goals/)
-  assert.match(help.stdout, /Loop uninstall never removes Goals/)
+  assert.match(help.stdout, /Default install\/update touches only OpenCode Loop/)
+  assert.match(help.stdout, /Loop uninstall never removes Goal/)
   assert.deepEqual(await calls(helpLog), [], "help/version flows must never install companion packages")
 
   console.log("OpenCode Loop Goals companion installer test passed")

package/scripts/install-with-goals.mjs

@@ -9,118 +9,19 @@ import { fileURLToPath } from "node:url"
 const root = dirname(dirname(fileURLToPath(import.meta.url)))
 const loopInstaller = join(root, "scripts", "install-node.mjs")
 const config = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode")
-const configCandidates = ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]
-const goalPackageName = "@bybrawe/opencode-goal"
-const goalPackageSpec = `${goalPackageName}@latest`
-const managedGoalCommandMarker = "<!-- managed-by:@bybrawe/opencode-goal -->"
+const goalPackageSpec = "@bybrawe/opencode-goal@latest"
 const rawArgs = process.argv.slice(2)
 const withGoals = rawArgs.includes("--with-goals")
 const loopOnly = rawArgs.includes("--loop-only")
+const withLoopGoals = rawArgs.includes("--with-loop-goals")
 const withoutLoopGoals = rawArgs.includes("--without-loop-goals")
-const loopArgs = rawArgs.filter((arg) => !["--with-goals", "--loop-only", "--without-loop-goals"].includes(arg))
+const loopArgs = rawArgs.filter((arg) => !["--with-goals", "--loop-only", "--with-loop-goals", "--without-loop-goals"].includes(arg))
 const commandArgs = loopArgs.filter((arg) => arg !== "--legacy-v1")
 const uninstallRequested = commandArgs.length === 1 && ["--uninstall", "uninstall", "--remove"].includes(commandArgs[0] || "")
 const helpRequested = loopArgs.some((arg) => ["--help", "-h"].includes(arg))
 const versionRequested = loopArgs.some((arg) => ["--version", "-v"].includes(arg))
 const informational = helpRequested || versionRequested
 
-function stripJsonComments(input) {
-  let output = ""
-  let quote = ""
-  let escaped = false
-  let lineComment = false
-  let blockComment = false
-  for (let index = 0; index < input.length; index++) {
-    const char = input[index]
-    const next = input[index + 1]
-    if (lineComment) {
-      if (char === "\n" || char === "\r") { lineComment = false; output += char }
-      continue
-    }
-    if (blockComment) {
-      if (char === "*" && next === "/") { blockComment = false; index++ }
-      else if (char === "\n" || char === "\r") output += char
-      continue
-    }
-    if (quote) {
-      output += char
-      if (escaped) escaped = false
-      else if (char === "\\") escaped = true
-      else if (char === quote) quote = ""
-      continue
-    }
-    if (char === '"') { quote = char; output += char; continue }
-    if (char === "/" && next === "/") { lineComment = true; index++; continue }
-    if (char === "/" && next === "*") { blockComment = true; index++; continue }
-    output += char
-  }
-  return output
-}
-
-function stripTrailingCommas(input) {
-  let output = ""
-  let quote = ""
-  let escaped = false
-  for (let index = 0; index < input.length; index++) {
-    const char = input[index]
-    if (quote) {
-      output += char
-      if (escaped) escaped = false
-      else if (char === "\\") escaped = true
-      else if (char === quote) quote = ""
-      continue
-    }
-    if (char === '"') { quote = char; output += char; continue }
-    if (char === ",") {
-      let lookahead = index + 1
-      while (/\s/.test(input[lookahead] || "")) lookahead++
-      if (input[lookahead] === "]" || input[lookahead] === "}") continue
-    }
-    output += char
-  }
-  return output
-}
-
-function parseJsonc(input) {
-  const parsed = JSON.parse(stripTrailingCommas(stripJsonComments(input)))
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("OpenCode config root must be a JSON object")
-  return parsed
-}
-
-function isGoalPluginSpec(value) {
-  if (Array.isArray(value)) value = value[0]
-  if (value && typeof value === "object") value = value.package
-  if (typeof value !== "string") return false
-  const spec = value.trim()
-  if (spec === goalPackageName || spec.startsWith(`${goalPackageName}@`)) return true
-  const normalized = spec.replaceAll("\\", "/")
-  return normalized === "./plugins/opencode-goal.ts"
-    || normalized === "./plugins/opencode-goal.js"
-    || normalized.endsWith("/plugins/opencode-goal.ts")
-    || normalized.endsWith("/plugins/opencode-goal.js")
-}
-
-async function goalsAlreadyInstalled() {
-  for (const name of configCandidates) {
-    try {
-      const parsed = parseJsonc(await readFile(join(config, name), "utf8"))
-      if ([parsed.plugin, parsed.plugins].some((entries) => Array.isArray(entries) && entries.some(isGoalPluginSpec))) return true
-    } catch (error) {
-      if (error?.code !== "ENOENT") {
-        console.warn(`Could not inspect ${join(config, name)} for OpenCode Goals: ${error.message}`)
-      }
-    }
-  }
-
-  try {
-    const command = await readFile(join(config, "commands", "goal.md"), "utf8")
-    return command.includes(managedGoalCommandMarker)
-  } catch (error) {
-    if (error?.code !== "ENOENT") console.warn(`Could not inspect managed /goal command: ${error.message}`)
-  }
-  return false
-}
-
 async function removeLoopGoalCommands() {
   const commandDir = join(config, "commands")
   const names = (await readdir(join(root, "commands")))
@@ -178,7 +79,7 @@ function statusCode(result) {
 }
 
 function printCompanionHelp() {
-  console.log(`\nOpenCode Goals companion options:\n  --with-goals          Install/update @bybrawe/opencode-goal@latest even when it is not already installed.\n  --loop-only           Skip all OpenCode Goals companion detection and network update work.\n  --without-loop-goals  Omit/remove Loop's packaged experimental /loop-goal* command files for this install/update.\n\nNormal Loop install/update refreshes an already-managed OpenCode Goals installation on a best-effort basis. Loop uninstall never removes Goals.`)
+  console.log(`\nOpenCode Goal options:\n  --with-goals          Explicitly install/update @bybrawe/opencode-goal@latest after Loop.\n  --loop-only           Explicit alias for the default: install/update Loop only and never touch Goal.\n  --with-loop-goals     Also install Loop's legacy experimental /loop-goal* command files (not recommended).\n  --without-loop-goals  Compatibility alias for the default: omit/remove legacy /loop-goal* commands.\n\nDefault install/update touches only OpenCode Loop. Recommended setup: install OpenCode Goal separately with: npx -y @bybrawe/opencode-goal@latest. Loop uninstall never removes Goal.`)
 }
 
 async function main() {
@@ -187,6 +88,11 @@ async function main() {
     process.exitCode = 2
     return
   }
+  if (withLoopGoals && withoutLoopGoals) {
+    console.error("Use either --with-loop-goals or --without-loop-goals, not both.")
+    process.exitCode = 2
+    return
+  }
 
   const loopResult = runLoopInstaller()
   if (loopResult.error) {
@@ -206,19 +112,18 @@ async function main() {
   }
   if (uninstallRequested) return
 
-  if (withoutLoopGoals) {
+  if (!withLoopGoals) {
     const removed = await removeLoopGoalCommands()
-    console.log(`Omitted ${removed} packaged experimental /loop-goal* command file(s) (--without-loop-goals).`)
+    const reason = withoutLoopGoals ? "--without-loop-goals" : "default Loop-only command surface"
+    console.log(`Omitted ${removed} packaged experimental /loop-goal* command file(s) (${reason}).`)
   }
 
-  if (loopOnly) {
-    console.log("Skipped OpenCode Goals companion update (--loop-only).")
+  if (!withGoals) {
+    if (loopOnly) console.log("Installed/updated OpenCode Loop only (--loop-only).")
+    else console.log("Installed/updated OpenCode Loop only. Recommended companion install (separate command): npx -y @bybrawe/opencode-goal@latest")
     return
   }
 
-  const alreadyInstalled = await goalsAlreadyInstalled()
-  if (!alreadyInstalled && !withGoals) return
-
   const goalResult = runGoalInstaller()
   const goalCode = statusCode(goalResult)
   if (goalCode === 0) {
@@ -227,14 +132,8 @@ async function main() {
   }
 
   const detail = goalResult.error?.message || `exit code ${goalCode}`
-  if (withGoals) {
-    console.error(`OpenCode Goals companion install/update failed (${detail}).`)
-    process.exitCode = goalCode || 1
-    return
-  }
-
-  console.warn(`OpenCode Loop updated, but the existing OpenCode Goals companion could not be refreshed (${detail}).`)
-  console.warn(`Retry later with: npx -y ${goalPackageSpec}`)
+  console.error(`OpenCode Goals companion install/update failed (${detail}).`)
+  process.exitCode = goalCode || 1
 }
 
 main().catch((error) => {

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.4", "release version is not authorized")
+  assert.equal(request?.version, "0.6.6", "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.3")
-  assert.equal(request.goal?.version, "1.3.43")
+  assert.equal(request.predecessor, "0.6.5")
+  assert.equal(request.goal?.version, "1.3.47")
   assert.match(request.goal?.sha ?? "", /^[a-f0-9]{40}$/)
   return request
 }

package/scripts/publish-workflow-test.mjs

@@ -29,7 +29,7 @@ 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(workflow, /npm install --no-save --legacy-peer-deps @opencode\/plugin@2\.0\.22/, "immutable Goal companion must build against its pinned OpenCode 2.0.22 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/)
 
@@ -44,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.4", predecessor: "0.6.3", goal: { version: "1.3.43", sha: "b".repeat(40) } }
+const request = { name: "@bybrawe/opencode-loop", version: "0.6.6", predecessor: "0.6.5", goal: { version: "1.3.47", 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.3" }, env))
-assert.equal(releaseDecision(404, null, request, sha, "0.6.3"), true)
+assert.throws(() => validateRelease(request, { ...pkg, version: "0.6.5" }, env))
+assert.equal(releaseDecision(404, null, request, sha, "0.6.5"), 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 }