@bybrawe/opencode-loop 0.6.5 → 0.6.7

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/host-goal-bootstrap-test.mjs

@@ -0,0 +1,46 @@
+import test from "node:test"
+import assert from "node:assert/strict"
+import { waitForSessionBootstrap } from "./host-goal-bootstrap.mjs"
+
+const baseURL = "http://127.0.0.1:4011"
+const workspace = "C:\\projects\\space in path"
+
+test("bounded GET /session bootstrap retries transient host readiness without sending work", async () => {
+  const calls = []
+  let attempts = 0
+  const fetchImpl = async (input, init) => {
+    calls.push({ url: new URL(input.toString()), method: init.method, directory: init.headers["x-opencode-directory"] })
+    if (new URL(input.toString()).pathname === "/command") return { status: 200 }
+    attempts++
+    if (attempts < 4) throw Object.assign(new Error("timed out"), { name: "TimeoutError" })
+    return { ok: true, json: async () => ({ data: [{ id: "ses_test" }] }) }
+  }
+  const result = await waitForSessionBootstrap({
+    baseURL, workspace, fetchImpl, timeoutMs: 250, perRequestMs: 10, intervalMs: 1,
+  })
+  assert.deepEqual(result.data, [{ id: "ses_test" }])
+  assert.equal(attempts, 4)
+  assert.ok(calls.some((c) => c.url.pathname === "/command"))
+  assert.ok(calls.every((c) => c.method === "GET" && c.directory === workspace))
+  assert.ok(calls.filter((c) => c.url.pathname === "/session").every((c) => c.url.searchParams.get("directory") === workspace))
+})
+
+test("bootstrap fails immediately on authorization, malformed response or unsafe service", async () => {
+  const unauthorized = async () => ({ ok: false, status: 401 })
+  await assert.rejects(waitForSessionBootstrap({ baseURL, workspace, fetchImpl: unauthorized }), /non-retryable HTTP 401/)
+  const malformed = async () => ({ ok: true, json: async () => ({ status: "unknown" }) })
+  await assert.rejects(waitForSessionBootstrap({ baseURL, workspace, fetchImpl: malformed }), /unexpected payload/)
+  await assert.rejects(
+    waitForSessionBootstrap({ baseURL: "https://example.com", workspace, fetchImpl: () => { throw new Error("must not connect") } }),
+    /restricted to a local service/,
+  )
+})
+
+test("persistent startup stall is bounded, preserves diagnostics, and never claims ownership collision", async () => {
+  let calls = 0
+  const stalled = async () => { calls++; throw Object.assign(new Error("timeout"), { name: "TimeoutError" }) }
+  await assert.rejects(waitForSessionBootstrap({
+    baseURL, workspace, fetchImpl: stalled, timeoutMs: 45, perRequestMs: 5, intervalMs: 1,
+  }), /did not become ready after \d+ bounded attempts.*plugin initialization must be investigated/i)
+  assert.ok(calls >= 1 && calls < 80, "startup must have a bounded number of probes")
+})

package/scripts/host-goal-bootstrap.mjs

@@ -0,0 +1,71 @@
+// A TCP listener is not proof that OpenCode's session router and project
+// plugin graph have finished initialization. This is intentionally read-only:
+// never send a prompt/command or retry a mutating session request.
+export async function waitForSessionBootstrap({
+  baseURL, workspace, fetchImpl = fetch,
+  timeoutMs = 90_000, perRequestMs = 6_000, intervalMs = 300,
+} = {}) {
+  if (!URL.canParse(baseURL) || !workspace) throw new Error("Missing OpenCode bootstrap baseURL/workspace")
+  const base = new URL(baseURL)
+  if (!["localhost", "127.0.0.1", "[::1]"].includes(base.hostname))
+    throw new Error("OpenCode bootstrap is restricted to a local service")
+  if (base.username || base.password) throw new Error("Credentials must not be embedded in the bootstrap URL")
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 1) throw new Error("Invalid bootstrap timeout")
+  const url = new URL("/session", base)
+  url.searchParams.set("directory", workspace)
+  const deadline = Date.now() + timeoutMs
+  let attempts = 0
+  let last = "no response"
+  let commandProbe = "not checked"
+  while (Date.now() < deadline) {
+    attempts++
+    const remaining = deadline - Date.now()
+    const signal = AbortSignal.timeout(Math.max(1, Math.min(perRequestMs, remaining)))
+    try {
+      const res = await fetchImpl(url, {
+        method: "GET",
+        headers: { "x-opencode-directory": workspace, accept: "application/json" },
+        signal,
+        redirect: "error",
+      })
+      if (res.ok) {
+        const body = await res.json()
+        if (!Array.isArray(body?.data ?? body)) {
+          throw new Error("OpenCode GET /session returned an unexpected payload (not a session array)")
+        }
+        return body
+      }
+      if (![502, 503, 504].includes(res.status)) {
+        throw new Error("OpenCode GET /session returned non-retryable HTTP " + res.status)
+      }
+      last = "HTTP " + res.status
+    } catch (error) {
+      if (!["TimeoutError", "AbortError", "TypeError"].includes(error?.name)) throw error
+      last = error?.name === "TimeoutError" ? "request timed out" : error?.name === "AbortError" ? "request aborted" : "connection not ready"
+    }
+    // A side probe distinguishes a live command catalog from a stalled global
+    // bootstrap. It is diagnostic only: we never waive the session readiness
+    // requirement, and do not emit any endpoint response or credentials.
+    if (attempts % 3 === 0 && Date.now() < deadline) {
+      try {
+        const res = await fetchImpl(new URL("/command", base), {
+          method: "GET",
+          headers: { "x-opencode-directory": workspace, accept: "application/json" },
+          signal: AbortSignal.timeout(Math.min(2_000, deadline - Date.now())),
+          redirect: "error",
+        })
+        commandProbe = "HTTP " + res.status
+      } catch (error) {
+        commandProbe = error?.name === "TimeoutError" ? "timed out" : "unavailable"
+      }
+    }
+    if (Date.now() >= deadline) break
+    await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, deadline - Date.now())))
+  }
+  throw new Error(
+    "OpenCode GET /session did not become ready after " + attempts
+    + " bounded attempts in " + timeoutMs + "ms"
+    + " (last=" + last + ", GET /command=" + commandProbe + ")."
+    + " Server routing/plugin initialization must be investigated before claiming a Goal/Loop collision.",
+  )
+}

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

@@ -7,11 +7,12 @@ import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promis
 import os from "node:os"
 import path from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
+import { waitForSessionBootstrap } from "./host-goal-bootstrap.mjs"
 
 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 API_BOOTSTRAP_TIMEOUT_MS = isWindows ? 180_000 : 60_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."
@@ -341,7 +342,15 @@ async function main() {
       }
     }
 
-    const sessionsPayload = await api("/session", { method: "GET" })
+    // A Windows cold host may accept TCP before its session/project/plugin
+    // services are ready. Probe readiness in bounded requests rather than
+    // hanging for 90 seconds on one socket and attributing it to Goal/Loop.
+    const sessionsPayload = await waitForSessionBootstrap({
+      baseURL,
+      workspace,
+      timeoutMs: API_BOOTSTRAP_TIMEOUT_MS,
+      fetchImpl: fetch,
+    })
     assert.ok(Array.isArray(sessionsPayload?.data ?? sessionsPayload), "GET /session bootstrap did not return an array")
     const createdPayload = await api("/session", { method: "POST", body: JSON.stringify({ title: "Loop + Goal ownership canary" }) })
     const session = createdPayload?.data ?? createdPayload

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,15 +79,31 @@ 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() {
+  if (rawArgs[0] === "--desktop-diagnostics") {
+    // Diagnostic mode must not run either installer or modify any configuration.
+    const { runDesktopDiagnosticCli } = await import("./desktop-command-diagnostics.mjs")
+    process.exitCode = await runDesktopDiagnosticCli(rawArgs.slice(1))
+    return
+  }
+  if (rawArgs.includes("--desktop-diagnostics")) {
+    console.error("--desktop-diagnostics must be the first argument.")
+    process.exitCode = 2
+    return
+  }
   if (withGoals && loopOnly) {
     console.error("Use either --with-goals or --loop-only, not both.")
     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 +123,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 +143,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-plugin-lifetime-test.mjs

@@ -5,8 +5,10 @@ import os from "node:os"
 import path from "node:path"
 import plugin from "../src/source/opencode2/native-plugin.js"
 
-function fixture(directory, { failCleanup = false } = {}) {
+function fixture(directory, { failCleanup = false, captureCommands = false } = {}) {
   const released = []
+  const commands = new Map()
+  const prompts = []
   let releaseRead, signal
   let streamClosed = false
   const end = () => releaseRead?.()
@@ -18,10 +20,17 @@ function fixture(directory, { failCleanup = false } = {}) {
     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") },
+      prompt: async (request) => {
+        if (!captureCommands) throw new Error("cleanup must not dispatch a prompt")
+        prompts.push(request)
+        return { id: "test-prompt" }
+      },
       hook: async (name) => registration(name),
     },
-    command: { transform: async () => registration("commands") },
+    command: { transform: async (register) => {
+      if (captureCommands) await register({ add: ({ name, execute }) => commands.set(name, execute) })
+      return registration("commands")
+    } },
     event: { subscribe(options = {}) {
       signal = options.signal
       return (async function* () {
@@ -35,7 +44,7 @@ function fixture(directory, { failCleanup = false } = {}) {
       })()
     } },
   }
-  return { ctx, end, released, signal: () => signal, streamClosed: () => streamClosed }
+  return { ctx, end, released, commands, prompts, signal: () => signal, streamClosed: () => streamClosed }
 }
 
 async function bounded(promise) {
@@ -100,19 +109,22 @@ 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 () => {
+test("native Loop never probes undocumented SessionDomain shell 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"]) {
+    for (const field of ["shell", "inbox"]) {
       Object.defineProperty(host.ctx.session, field, {
         configurable: true,
         get() { throw new Error(`undocumented session.${field} was accessed`) },
       })
     }
+    const calls = []
+    host.ctx.session.compact = async (input) => { calls.push(input); return { id: input.id } }
     dispose = await plugin.setup(host.ctx)
     assert.equal(typeof dispose, "function")
+    assert.deepEqual(calls, [], "public compact is invoked only for scheduled work")
   } finally {
     host.end()
     await dispose?.().catch(() => {})
@@ -123,3 +135,24 @@ test("native Loop never probes undocumented SessionDomain shell compact or inbox
 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")
 })
+
+test("native /loop-help reflects public V2 compaction rather than obsolete unsupported guidance", async () => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-v2-help-compaction-"))
+  const host = fixture(directory, { captureCommands: true })
+  host.ctx.session.compact = async () => ({ id: "unused-compaction" })
+  let dispose
+  try {
+    dispose = await plugin.setup(host.ctx)
+    const help = host.commands.get("loop-help")
+    assert.equal(typeof help, "function")
+    await help({ sessionID: "ses-help" })
+    assert.equal(host.prompts.length, 1)
+    assert.match(host.prompts[0].text, /public session\.compact/)
+    assert.match(host.prompts[0].text, /inputID/)
+    assert.doesNotMatch(host.prompts[0].text, /does not expose manual session compaction/)
+  } finally {
+    host.end()
+    await dispose?.().catch(() => {})
+    await rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 })
+  }
+})

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

package/scripts/native-v2-test.mjs

@@ -215,13 +215,75 @@ await test("compaction cadence does not charge a logical run", async (f) => {
   await f.complete()
   assert.equal(f.compacts.length, 1)
   assert.equal((await f.state()).jobs[0].runCount, 1)
-  await f.event("compaction", "started")
-  await f.event("compaction", "ended")
+  await f.event("compaction", "started", { reason: "auto" })
+  await f.event("compaction", "ended", { reason: "auto" })
+  await f.event("session", "idle")
+  assert.equal(f.prompts.length, 1, "an unrelated automatic compaction cannot settle a Loop request")
+  await f.event("compaction", "started", { reason: "manual", inputID: f.compacts[0].id })
+  await f.event("compaction", "ended", { reason: "manual" })
   await f.event("session", "idle")
   assert.equal(f.prompts.length, 2)
   assert.equal((await f.state()).jobs[0].runCount, 2)
 })
 
+await test("manual compaction needs delivered inbox and completed host boundary", async (f) => {
+  await f.control("loop-compact", "0s --now --max-runs 1")
+  await f.wake()
+  assert.equal(f.compacts.length, 1)
+  assert.equal(f.compacts[0].delivery, "queue")
+  assert.ok(f.compacts[0].id)
+  await f.event("compaction", "started", { reason: "manual", inputID: "a-different-compaction" })
+  await f.event("compaction", "ended", { reason: "manual" })
+  await f.event("session", "idle")
+  assert.ok((await f.state()).jobs[0].v2Run, "a different compaction must not finish the scheduled request")
+  await f.event("compaction", "started", { reason: "manual", inputID: f.compacts[0].id })
+  await f.event("compaction", "ended", { reason: "manual" })
+  await f.event("session", "idle")
+  assert.equal((await f.state()).jobs[0].v2Run, undefined)
+  assert.equal((await f.state()).jobs[0].runCount, 1)
+})
+
+await test("foreign host compaction failure cannot pause or consume a pending Loop compact", async (f) => {
+  await f.control("loop-compact", "0s --now --max-runs 1")
+  await f.wake()
+  const jobID = f.compacts[0].id
+  await f.event("compaction", "started", { reason: "manual", inputID: "another-user-input" })
+  await f.event("compaction", "failed", {
+    reason: "manual", inputID: "another-user-input",
+    error: "Not our compaction",
+  })
+  await f.event("session", "idle")
+  const waiting = (await f.state()).jobs[0]
+  assert.equal(waiting.paused, false, "foreign compaction failure must not pause our pending operation")
+  assert.ok(waiting.v2Run, "foreign event must not erase the pending compact request")
+  assert.equal(waiting.runCount, 1, "a confirmed host admission is charged once; foreign failure cannot change its accounting")
+
+  await f.event("compaction", "started", { reason: "manual", inputID: jobID })
+  await f.event("compaction", "failed", {
+    reason: "manual", inputID: jobID,
+    error: "Summary did not match the template\nwith details",
+  })
+  const failed = (await f.state()).jobs[0]
+  assert.equal(failed.paused, true)
+  assert.match(failed.pauseReason, /^compaction-failed: Summary did not match the template/)
+  assert.equal(failed.pauseReason.includes("\n"), false, "provider messages cannot inject log newlines")
+  assert.equal(failed.v2Run, undefined, "confirmed owned host failure must release pending work")
+  assert.equal(failed.runCount, 1, "a failed host compact preserves the one already-admitted logical run")
+  await f.event("session", "idle")
+  assert.equal((await f.state()).jobs[0].paused, true)
+})
+
+await test("unowned automatic host compaction failure leaves unrelated Loop jobs enabled", async (f) => {
+  await f.add("every 1h delayed task --max-runs 1")
+  await f.event("compaction", "started", { reason: "auto" })
+  await f.event("compaction", "failed", { reason: "auto", error: "host model unavailable" })
+  await f.event("session", "idle")
+  const job = (await f.state()).jobs[0]
+  assert.equal(job.paused, false)
+  assert.equal(job.runCount, 0)
+  assert.equal(job.v2Run, undefined)
+})
+
 await test("a failed delivered execution is paused and can be explicitly resumed", async (f) => {
   await f.add("0s task --max-runs 3")
   await f.wake()