@bybrawe/opencode-loop 0.5.38 → 0.6.1

package/scripts/control-plane-until-test.mjs

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { createJobWorkspaceRuntime } from "../src/source/runtime/job-workspace.js"
+
+const marker = "NATIVE_COMPLETION_FROM_WORK_ONLY_8fd8"
+const runtime = createJobWorkspaceRuntime({ toast: async () => {} })
+async function fixture(file, expected) {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "loop-control-until-"))
+  try {
+    const target = path.join(directory, file)
+    await mkdir(path.dirname(target), { recursive: true })
+    await writeFile(target, JSON.stringify({ objective: marker }))
+    assert.equal(await runtime.untilReached(directory, { until: marker }), expected)
+  } finally {
+    await rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })
+  }
+}
+
+for (const file of [
+  ".opencode/goals/live.json",
+  ".opencode/goals/archive/history.json",
+  ".opencode/goal-sequences/session.json",
+  ".opencode/goal-locks/lease.json",
+  ".opencode/goal-handoff-locks/lease.json",
+  ".opencode/opencode-loop/session.json",
+]) {
+  test("Goal/Loop control state cannot satisfy --until: " + file, () => fixture(file, false))
+}
+for (const file of [
+  "progress.md",
+  ".opencode/opencode-loop/until.txt",
+  ".opencode/commands/project-task.md",
+  ".opencode/goals-project-notes/finished.md",
+]) {
+  test("explicit or project-owned completion marker stays supported: " + file, () => fixture(file, true))
+}

package/scripts/goal-compaction-safety-test.mjs

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict"
+import { createGoalSteeringRuntime } from "../src/source/runtime/goal-steering.js"
+
+const sessionID = "ses-compaction-safety"
+const goal = { id: "goal-1", name: "goal", kind: "goal", enabled: true, paused: false, goalStatus: "active" }
+function fixture(abortHook) {
+  let active = { jobId: goal.id, job: { ...goal } }
+  let aborts = 0
+  let clears = 0
+  let reads = 0
+  const client = { session: { abort: async () => { aborts++; await abortHook?.(() => { active = { jobId: "replacement", job: { ...goal } } }) } } }
+  const runtime = createGoalSteeringRuntime({
+    getActiveRun: () => active,
+    clearActiveRun: () => { clears++; active = undefined },
+    readState: async () => { reads++; return { jobs: [{ ...goal }] } },
+    appendLoopLog: async () => {},
+    fireSdk: async (_client, _label, method) => method(),
+    now: () => 1000,
+  })
+  return { runtime, client, counts: () => ({ aborts, clears, reads }), active: () => active }
+}
+let cases = 0
+for (const type of ["message.created", "message.updated"]) {
+  for (const parts of [undefined, [], [{ type: "compaction", auto: true }], [{ type: "text", synthetic: true, text: "Continue" }], [{ type: "text", text: "Persisted user message" }]]) {
+    const f = fixture()
+    const event = { type, properties: { info: { id: "msg-core", role: "user", sessionID }, ...(parts ? { parts } : {}) } }
+    const result = await f.runtime.handleEvent("/workspace", f.client, event)
+    assert.equal(result.handled, false)
+    assert.deepEqual(f.counts(), { aborts: 0, clears: 0, reads: 0 })
+    assert.equal(f.runtime.shouldSuppressIdle(sessionID), false)
+    cases++
+  }
+}
+{
+  const f = fixture()
+  await f.runtime.handleEvent("/workspace", f.client, { type: "message.updated", properties: { info: { role: "user", sessionID, id: "msg-real" } } })
+  const result = await f.runtime.handleUserMessage("/workspace", f.client, { sessionID, messageID: "msg-real" })
+  assert.equal(result.preempted, true, "untrusted event must not consume the later trusted admission")
+  assert.equal(f.counts().aborts, 1)
+  cases++
+}
+{
+  const f = fixture()
+  f.runtime.setCompacting(sessionID)
+  const result = await f.runtime.handleUserMessage("/workspace", f.client, { sessionID, messageID: "msg-during-summary" })
+  assert.equal(result.preempted, false)
+  assert.equal(f.counts().aborts, 0)
+  assert.equal(f.runtime.shouldSuppressIdle(sessionID), false)
+  f.runtime.setCompacting(sessionID, false)
+  assert.equal((await f.runtime.handleUserMessage("/workspace", f.client, { sessionID, messageID: "msg-after-summary" })).preempted, true)
+  cases++
+}
+{
+  const f = fixture((replace) => replace())
+  await f.runtime.handleUserMessage("/workspace", f.client, { sessionID, messageID: "msg-race" })
+  assert.equal(f.counts().aborts, 1)
+  assert.equal(f.counts().clears, 0, "the old abort must not clear a replacement run")
+  assert.equal(f.active().jobId, "replacement")
+  cases++
+}
+{
+  const f = fixture()
+  f.runtime.setCompacting(sessionID)
+  f.runtime.clearSession(sessionID)
+  assert.equal((await f.runtime.handleUserMessage("/workspace", f.client, { sessionID, messageID: "msg-after-delete" })).preempted, true)
+  cases++
+}
+console.log(`Goal compaction safety: ${cases} scenarios passed`)

package/scripts/goal-companion-test.mjs

@@ -26,7 +26,7 @@ process.exit(Number(process.env.FAKE_NPM_EXIT || 0))
 
 async function runInstaller(config, cliArgs = [], env = {}) {
   return await new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [installer, ...cliArgs], {
+    const child = spawn(process.execPath, [installer, "--legacy-v1", ...cliArgs], {
       cwd: root,
       env: {
         ...process.env,

package/scripts/host-adapter-contract-test.mjs

@@ -57,6 +57,7 @@ assert.equal(compactTuiCommandName("other"), undefined)
   assert.deepEqual(ordered.map((item) => item.info.id), ["a", "b", "c"])
 
   assert.equal(await activeRunCompletionFromMessages("/tmp", {}, "missing", { startedAt: 100 }), "unknown")
+  assert.equal(await activeRunCompletionFromMessages("/tmp", messagesClient([]), "empty-history", { startedAt: 100 }), "unknown")
   assert.equal(await activeRunCompletionFromMessages(
     "/tmp", messagesClient([{ info: { role: "assistant", time: { created: 50, completed: 90 } } }]), "old", { startedAt: 100 },
   ), "incomplete")

package/scripts/install-node.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { isDeepStrictEqual } from "node:util"
 import { copyFile, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join } from "node:path"
@@ -7,6 +8,7 @@ import { fileURLToPath } from "node:url"
 const root = dirname(dirname(fileURLToPath(import.meta.url)))
 const config = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode")
 const pluginDir = join(config, "plugins")
+const nativePluginDir = join(pluginDir, "opencode-loop")
 const commandDir = join(config, "commands")
 const agentDir = join(config, "agents")
 const packagePath = join(config, "package.json")
@@ -14,11 +16,13 @@ const packageName = "@bybrawe/opencode-loop"
 const packageVersion = JSON.parse(await readFile(join(root, "package.json"), "utf8")).version
 const packageSpec = `${packageName}@${packageVersion}`
 const configCandidates = ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]
-const installerArgs = process.argv.slice(2)
+const rawInstallerArgs = process.argv.slice(2)
+const legacyV1 = rawInstallerArgs.includes("--legacy-v1")
+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 copies the dual OpenCode 1/2 Loop plugin plus command files and local command agent, and keeps an existing npm package entry pinned to the exact version.\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: 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.`)
   process.exit(0)
 }
 
@@ -96,7 +100,8 @@ function parseJsonc(input) {
 }
 
 function isPackageSpec(value) {
-  const spec = String(value || "").trim()
+  if (Array.isArray(value)) value = value[0]
+  const spec = String(typeof value === "object" && value !== null ? value.package || "" : value || "").trim()
   return spec === packageName || spec.startsWith(`${packageName}@`)
 }
 
@@ -207,38 +212,86 @@ function formatPluginArray(values, indent, eol) {
   return `[${eol}${values.map((value) => `${childIndent}${JSON.stringify(value)}`).join(`,${eol}`)}${eol}${indent}]`
 }
 
-function rewriteExistingPluginArray(source, nextPlugins) {
-  const property = findRootProperty(source, "plugin")
+function rewriteExistingPluginArray(source, nextPlugins, key = "plugin") {
+  const property = findRootProperty(source, key)
   if (!property) return source
   const eol = source.includes("\r\n") ? "\r\n" : "\n"
   const replacement = formatPluginArray(nextPlugins, property.indent, eol)
   return `${source.slice(0, property.valueStart)}${replacement}${source.slice(property.valueEnd)}`
 }
 
+function appendPluginProperty(source, values, key) {
+  const parsed = parseJsonc(source)
+  const keys = Object.keys(parsed)
+  if (keys.length) {
+    const last = findRootProperty(source, keys.at(-1))
+    const after = skipTrivia(source, last.valueEnd)
+    if (source[after] !== ",") source = source.slice(0, last.valueEnd) + "," + source.slice(last.valueEnd)
+  }
+  const end = skipJsonValue(source, 0) - 1
+  const eol = source.includes("\r\n") ? "\r\n" : "\n"
+  return source.slice(0, end) + `${eol}  ${JSON.stringify(key)}: ${formatPluginArray(values, "  ", eol)}${eol}` + source.slice(end)
+}
+
+function pinRegistration(entries) {
+  const objects = entries.map((entry) => {
+    if (!Array.isArray(entry)) return entry
+    if (entry.length !== 2 || !entry[1] || typeof entry[1] !== "object" || Array.isArray(entry[1])) {
+      throw new Error("Invalid Loop package/options tuple; no configuration was changed")
+    }
+    return { package: entry[0], options: entry[1] }
+  }).filter((entry) => typeof entry === "object" && entry !== null)
+  const optionsOf = (entry) => { const { package: _package, ...options } = entry; return options }
+  const configured = objects.filter((entry) => Object.keys(optionsOf(entry)).length > 0)
+  const preferred = configured[0]
+  if (!preferred) return packageSpec
+  if (configured.some((entry) => !isDeepStrictEqual(optionsOf(entry), optionsOf(preferred)))) {
+    throw new Error("Conflicting Loop object registrations; reconcile their options before updating")
+  }
+  const legacyTuple = entries.some((entry) => Array.isArray(entry) && isDeepStrictEqual(entry[1], preferred.options))
+  return legacyV1 && legacyTuple ? [packageSpec, preferred.options] : { ...preferred, package: packageSpec }
+}
+
 async function configurePackagePlugin() {
+  const plans = []
   let configured = false
-  const updatedFiles = []
   for (const name of configCandidates) {
     const target = join(config, name)
     try {
       const source = await readFile(target, "utf8")
       const parsed = parseJsonc(source)
-      if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) throw new Error("OpenCode config 'plugin' must be an array")
-      const plugins = parsed.plugin || []
-      if (!plugins.some(isPackageSpec)) continue
-      configured = true
-      const nextPlugins = plugins.filter((value) => !isPackageSpec(value))
-      nextPlugins.push(packageSpec)
-      const updated = rewriteExistingPluginArray(source, nextPlugins)
-      if (updated !== source) {
-        await writeFile(target, updated, "utf8")
-        updatedFiles.push(target)
+      for (const key of ["plugin", "plugins"]) {
+        if (parsed[key] !== undefined && !Array.isArray(parsed[key])) throw new Error(`OpenCode config '${key}' must be an array`)
+      }
+      let updated = source
+      const own = [...(parsed.plugins || []), ...(parsed.plugin || [])].filter(isPackageSpec)
+      if (own.length) {
+        configured = true
+        if (legacyV1) {
+          for (const key of ["plugin", "plugins"]) {
+            const entries = parsed[key] || []
+            const matching = entries.filter(isPackageSpec)
+            if (!matching.length) continue
+            const pinned = pinRegistration(matching)
+            updated = rewriteExistingPluginArray(updated, [...entries.filter((entry) => !isPackageSpec(entry)), pinned], key)
+          }
+        } else {
+          const pinned = pinRegistration(own)
+          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")
+        }
       }
+      parseJsonc(updated)
+      plans.push({ target, source, updated })
     } catch (error) {
       if (error?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${error.message}`)
     }
   }
-  return { configured, updatedFiles }
+  // Validate every candidate before writing any config. Malformed later files
+  // must not leave the earlier file migrated and the plugin half-installed.
+  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) }
 }
 
 async function ensureDependency() {
@@ -262,7 +315,13 @@ async function ensureDependency() {
 
 async function removePackagedFiles(sourceDir, targetDir) {
   for (const name of await readdir(sourceDir)) {
-    if (name.endsWith(".md")) await rm(join(targetDir, name), { force: true })
+    if (!name.endsWith(".md")) continue
+    try {
+      const installed = await readFile(join(targetDir, name), "utf8")
+      const packaged = await readFile(join(sourceDir, name), "utf8")
+      const recognized = /OpenCode Loop[^\n]{0,120}handled (?:locally|exactly)/.test(installed) || /OpenCode Loop local command handled/.test(installed)
+      if (installed === packaged || recognized) await rm(join(targetDir, name), { force: true })
+    } catch (error) { if (error?.code !== "ENOENT") throw error }
   }
 }
 
@@ -273,68 +332,67 @@ async function uninstall() {
     try {
       const source = await readFile(target, "utf8")
       const parsed = parseJsonc(source)
-      if (parsed.plugin !== undefined && !Array.isArray(parsed.plugin)) throw new Error("OpenCode config 'plugin' must be an array")
-      const plugins = parsed.plugin || []
-      const nextPlugins = plugins.filter((value) => !isPackageSpec(value))
-      const updated = nextPlugins.length === plugins.length ? source : rewriteExistingPluginArray(source, nextPlugins)
+      let updated = source
+      for (const key of ["plugin", "plugins"]) {
+        if (parsed[key] !== undefined && !Array.isArray(parsed[key])) throw new Error(`OpenCode config '${key}' must be an array`)
+        const entries = parsed[key] || []
+        if (entries.some(isPackageSpec)) updated = rewriteExistingPluginArray(updated, entries.filter((entry) => !isPackageSpec(entry)), key)
+      }
       plans.push({ target, source, updated })
-    } catch (error) {
-      if (error?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${error.message}`)
-    }
-  }
-
-  for (const plan of plans) {
-    if (plan.updated !== plan.source) await writeFile(plan.target, plan.updated, "utf8")
+    } catch (error) { if (error?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${error.message}`) }
   }
+  for (const plan of plans) if (plan.updated !== plan.source) await writeFile(plan.target, plan.updated, "utf8")
   await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
   await rm(join(pluginDir, "opencode-loop.js"), { force: true })
+  await rm(nativePluginDir, { recursive: true, force: true })
   await removePackagedFiles(join(root, "commands"), commandDir)
   await removePackagedFiles(join(root, "agents"), agentDir)
-
-  const changedConfigs = plans.filter((plan) => plan.updated !== plan.source).length
-  console.log(changedConfigs
-    ? `Removed ${packageName} package registrations from ${changedConfigs} OpenCode config file(s).`
-    : `${packageName} was not registered as an npm package in the inspected OpenCode config files.`)
-  console.log("Removed known local OpenCode Loop plugin, slash-command, and local-agent files when present.")
+  const changed = plans.filter((plan) => plan.source !== plan.updated).length
+  console.log(`Removed ${packageName} registrations from ${changed} OpenCode config file(s).`)
+  console.log("Removed known local Loop plugin and managed legacy command/agent files; custom files are preserved.")
   console.log("Project state under .opencode/opencode-loop is preserved.")
   console.log("Restart OpenCode to finish unloading OpenCode Loop.")
 }
 
 async function installOrUpdate() {
   await mkdir(pluginDir, { recursive: true })
-  await mkdir(commandDir, { recursive: true })
-  await mkdir(agentDir, { recursive: true })
   const packageConfig = await configurePackagePlugin()
-  const useConfiguredPackage = packageConfig.configured
-  if (useConfiguredPackage) {
+  if (packageConfig.configured) {
     await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
     await rm(join(pluginDir, "opencode-loop.js"), { force: true })
-  } else {
+    await rm(nativePluginDir, { recursive: true, force: true })
+  } else if (legacyV1) {
     await ensureDependency()
-    // Copy the dual contract bundle: OpenCode 1.x consumes default.server,
-    // while OpenCode 2.x consumes default.setup from the same local file.
-    await copyFile(join(root, "src", "server.js"), join(pluginDir, "opencode-loop.ts"))
+    await rm(nativePluginDir, { recursive: true, force: true })
+    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"))
   }
-
-  for (const name of await readdir(join(root, "commands"))) {
-    if (name.endsWith(".md")) await copyFile(join(root, "commands", name), join(commandDir, name))
-  }
-
-  for (const name of await readdir(join(root, "agents"))) {
-    if (name.endsWith(".md")) await copyFile(join(root, "agents", name), join(agentDir, name))
-  }
-
-  if (useConfiguredPackage) {
-    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.`)
+  if (legacyV1) {
+    await mkdir(commandDir, { recursive: true })
+    await mkdir(agentDir, { recursive: true })
+    for (const name of await readdir(join(root, "commands"))) if (name.endsWith(".md")) await copyFile(join(root, "commands", name), join(commandDir, name))
+    for (const name of await readdir(join(root, "agents"))) if (name.endsWith(".md")) await copyFile(join(root, "agents", name), join(agentDir, name))
   } else {
-    console.log(`Installed OpenCode Loop plugin to ${config}`)
+    await removePackagedFiles(join(root, "commands"), commandDir)
+    await removePackagedFiles(join(root, "agents"), agentDir)
   }
-  console.log(`Installed ${packageName} commands to ${commandDir}`)
-  console.log(`Installed ${packageName} local command agent to ${agentDir}`)
+  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}`)
+  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.")
   console.log("Restart OpenCode, then run: /loop-help")
 }
 

package/scripts/install-test.mjs

@@ -14,7 +14,7 @@ const packagedCommandCount = (await fs.readdir(path.join(root, "commands"))).fil
 
 async function runInstaller(config, cliArgs = []) {
   return await new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [installer, ...cliArgs], {
+    const child = spawn(process.execPath, [installer, "--legacy-v1", ...cliArgs], {
       cwd: root,
       env: { ...process.env, OPENCODE_CONFIG_DIR: config },
       windowsHide: true,
@@ -64,8 +64,8 @@ try {
   assert.equal(await exists(path.join(local, "plugins", "opencode-loop.ts")), true)
   assert.equal(
     await fs.readFile(path.join(local, "plugins", "opencode-loop.ts"), "utf8"),
-    await fs.readFile(path.join(root, "src", "server.js"), "utf8"),
-    "local install must copy the dual OpenCode 1/2 server bundle",
+    await fs.readFile(path.join(root, "src", "index.js"), "utf8"),
+    "explicit legacy install must copy the standalone V1 bundle, not the lazy package facade",
   )
   assert.equal(await commandCount(local), packagedCommandCount)
   assert.equal(await exists(path.join(local, "agents", "opencode-loop-local.md")), true)

package/scripts/install-with-goals.mjs

@@ -18,7 +18,8 @@ const withGoals = rawArgs.includes("--with-goals")
 const loopOnly = rawArgs.includes("--loop-only")
 const withoutLoopGoals = rawArgs.includes("--without-loop-goals")
 const loopArgs = rawArgs.filter((arg) => !["--with-goals", "--loop-only", "--without-loop-goals"].includes(arg))
-const uninstallRequested = loopArgs.length === 1 && ["--uninstall", "uninstall", "--remove"].includes(loopArgs[0] || "")
+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
@@ -87,6 +88,8 @@ function parseJsonc(input) {
 }
 
 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
@@ -101,7 +104,7 @@ async function goalsAlreadyInstalled() {
   for (const name of configCandidates) {
     try {
       const parsed = parseJsonc(await readFile(join(config, name), "utf8"))
-      if (Array.isArray(parsed.plugin) && parsed.plugin.some(isGoalPluginSpec)) return true
+      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}`)
@@ -125,6 +128,10 @@ async function removeLoopGoalCommands() {
   let removed = 0
   for (const name of names) {
     try {
+      const installed = await readFile(join(commandDir, name), "utf8")
+      const packaged = await readFile(join(root, "commands", name), "utf8")
+      const recognized = /OpenCode Loop[^\n]{0,120}handled (?:locally|exactly)/.test(installed) || /OpenCode Loop local command handled/.test(installed)
+      if (installed !== packaged && !recognized) continue
       await rm(join(commandDir, name))
       removed++
     } catch (error) {
@@ -152,7 +159,13 @@ function runGoalInstaller() {
 
   return spawnSync(command, args, {
     cwd: root,
-    env: { ...process.env, OPENCODE_CONFIG_DIR: config },
+    // This is a target-dialect hint, not a claim about an installed binary.
+    // Older Goal installers already understand this variable, unlike new CLI flags.
+    env: {
+      ...process.env,
+      OPENCODE_CONFIG_DIR: config,
+      OPENCODE_GOAL_HOST_VERSION: rawArgs.includes("--legacy-v1") ? "1.0.0" : "2.0.0",
+    },
     stdio: "inherit",
     windowsHide: true,
     timeout: 180_000,
@@ -227,4 +240,4 @@ async function main() {
 main().catch((error) => {
   console.error(error?.stack || error)
   process.exitCode = 1
-})
+})

package/scripts/job-workspace-test.mjs

@@ -72,7 +72,8 @@ try {
   processResults.push({ code: 1, stdout: "", stderr: "not a repo" })
   const nonRepo = { id: "nonrepo", branch: "feature/test" }
   await runtime.ensureBranch(directory, nonRepo, {}, "session")
-  assert.equal(nonRepo.branchDone, true)
+  assert.equal(nonRepo.branchDone, false, "a non-repository cannot claim a successful branch switch")
+  assert.equal(nonRepo.branchUnavailable, true)
   assert.equal(processCalls.at(-1)[0], "git")
   assert.deepEqual(processCalls.at(-1)[1], ["rev-parse", "--is-inside-work-tree"])
   assert.equal(toasts.length, 0)
@@ -95,6 +96,15 @@ try {
   assert.deepEqual(toasts.at(-1), [client, "Loop branch active: feature-test", "success"])
   assert.deepEqual(logs.at(-1), [directory, "branch", { sessionID: "session", branch: "feature-test", code: 0 }])
 
+  processResults.push(
+    { code: 0, stdout: "true", stderr: "" },
+    { code: 1, stdout: "", stderr: "switch failed" },
+    { code: 1, stdout: "", stderr: "create failed" },
+  )
+  const failedBranch = { branch: "cannot-switch" }
+  await runtime.ensureBranch(directory, failedBranch, client, "session")
+  assert.equal(failedBranch.branchDone, false, "failed switch/create must not admit work on the wrong branch")
+
   const watched = path.join(directory, "watched.txt")
   await fs.writeFile(watched, "one", "utf8")
   const initialSnapshot = await runtime.snapshotPaths(directory, ["watched.txt", "missing.txt"])

package/scripts/loopd-test.mjs

@@ -11,7 +11,7 @@ const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loopd-te
 
 function runCli(cliArgs, env = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [loopd, ...cliArgs], {
+    const child = spawn(process.execPath, [loopd, ...cliArgs, "--legacy-v1"], {
       cwd: root,
       env: { ...process.env, ...env },
       windowsHide: true,
@@ -32,7 +32,7 @@ function runCli(cliArgs, env = {}) {
 async function makeFakeCommand(name) {
   const script = path.join(temporaryRoot, `${name}.mjs`)
   const log = path.join(temporaryRoot, `${name}.jsonl`)
-  await fs.writeFile(script, "\nimport fs from \"node:fs\"\nconst log = process.env.FAKE_COMMAND_LOG\nconst argv = process.argv.slice(2)\nlet previous = []\ntry { previous = fs.readFileSync(log, \"utf8\").trim().split(/\\r?\\n/).filter(Boolean).map((line) => JSON.parse(line)) } catch {}\nfs.appendFileSync(log, JSON.stringify({ args: argv, cwd: process.cwd() }) + \"\\n\")\nif (argv[0] === \"session\" && argv[1] === \"list\") {\n  console.log(process.env.FAKE_SESSION_LIST_JSON || \"[]\")\n  process.exit(0)\n}\nconst sleepMs = Number(process.env.FAKE_SLEEP_MS || 0)\nif (sleepMs > 0) await new Promise((resolve) => setTimeout(resolve, sleepMs))\nconst previousRuns = previous.filter((entry) => entry?.args?.[0] === \"run\").length\nconst codes = String(process.env.FAKE_EXIT_CODES || \"0\").split(\",\").map((value) => Number(value.trim()))\nconst code = codes[Math.min(previousRuns, codes.length - 1)]\nprocess.exit(Number.isInteger(code) ? code : 0)\n", "utf8")
+  await fs.writeFile(script, "\nimport fs from \"node:fs\"\nconst log = process.env.FAKE_COMMAND_LOG\nconst argv = process.argv.slice(2)\nif (argv[0] === \"--version\") { console.log(\"1.18.15\"); process.exit(0) }\nlet previous = []\ntry { previous = fs.readFileSync(log, \"utf8\").trim().split(/\\r?\\n/).filter(Boolean).map((line) => JSON.parse(line)) } catch {}\nfs.appendFileSync(log, JSON.stringify({ args: argv, cwd: process.cwd() }) + \"\\n\")\nif (argv[0] === \"session\" && argv[1] === \"list\") {\n  console.log(process.env.FAKE_SESSION_LIST_JSON || \"[]\")\n  process.exit(0)\n}\nconst sleepMs = Number(process.env.FAKE_SLEEP_MS || 0)\nif (sleepMs > 0) await new Promise((resolve) => setTimeout(resolve, sleepMs))\nconst previousRuns = previous.filter((entry) => entry?.args?.[0] === \"run\").length\nconst codes = String(process.env.FAKE_EXIT_CODES || \"0\").split(\",\").map((value) => Number(value.trim()))\nconst code = codes[Math.min(previousRuns, codes.length - 1)]\nprocess.exit(Number.isInteger(code) ? code : 0)\n", "utf8")
 
   if (process.platform === "win32") {
     const command = path.join(temporaryRoot, `${name}.cmd`)
@@ -81,7 +81,7 @@ try {
     "run", "--title", runCalls[0].args[2],
     "--model", "opencode/nemotron-3-ultra-free",
     "--agent", "build",
-    inlinePrompt,
+    "--", inlinePrompt,
   ], "loopd must preserve model, agent, quotes, and shell metacharacters as literal arguments")
   assert.match(runCalls[0].args[2], /^OpenCode Loop daemon /)
 
@@ -146,6 +146,73 @@ try {
   })
   assert.equal(result.code, 7, "a finite daemon run must propagate the failing OpenCode exit code")
 
+  const goalsDir = path.join(project, ".opencode", "goals")
+  await fs.mkdir(goalsDir, { recursive: true })
+  const goalFile = path.join(goalsDir, "goal-stale.json")
+  const staleGoal = {
+    schemaVersion: 1,
+    id: "goal-stale",
+    sessionID: "ses_goal",
+    status: "active",
+    progressRevision: 4,
+    revision: 1,
+    storageGeneration: 1,
+    updatedAt: Date.now() - 60 * 60_000,
+  }
+  await fs.writeFile(goalFile, JSON.stringify(staleGoal, null, 2) + "\n", "utf8")
+  const originalGoal = await fs.readFile(goalFile, "utf8")
+  const pulseEnv = {
+    OPENCODE_BIN: fakeOpenCode.command,
+    FAKE_COMMAND_LOG: path.join(temporaryRoot, "pulse-opencode.jsonl"),
+    FAKE_SESSION_LIST_JSON: JSON.stringify([{ id: "ses_goal", title: "Goal", updated: Date.now() - 1_000 }]),
+  }
+
+  result = await runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv)
+  assert.equal(result.code, 0, result.stderr)
+  assert.match(result.stdout, /GOAL PULSE STALLED/)
+  assert.match(result.stdout, /goal=goal-stale/)
+  assert.match(result.stdout, /session=ses_goal/)
+  assert.match(result.stdout, /sessionUpdated=/)
+  assert.match(result.stdout, /action="\/goal resume"/)
+  assert.equal(await fs.readFile(goalFile, "utf8"), originalGoal, "pulse-check must never write dedicated Goal state")
+
+  result = await runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv)
+  assert.equal(result.code, 0, result.stderr)
+  assert.doesNotMatch(result.stdout, /GOAL PULSE STALLED/, "one stall episode must alert only once")
+
+  staleGoal.status = "waiting_user"
+  staleGoal.storageGeneration += 1
+  staleGoal.updatedAt = Date.now() - 30 * 60_000
+  await fs.writeFile(goalFile, JSON.stringify(staleGoal, null, 2) + "\n", "utf8")
+  result = await runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv)
+  assert.equal(result.code, 0, result.stderr)
+  assert.doesNotMatch(result.stdout, /GOAL PULSE STALLED/, "waiting_user must suppress pulse alerts")
+
+  staleGoal.status = "active"
+  staleGoal.progressRevision += 1
+  staleGoal.storageGeneration += 1
+  staleGoal.updatedAt = Date.now() - 11 * 60_000
+  await fs.writeFile(goalFile, JSON.stringify(staleGoal, null, 2) + "\n", "utf8")
+  result = await runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv)
+  assert.equal(result.code, 0, result.stderr)
+  assert.match(result.stdout, /GOAL PULSE STALLED/, "new Goal activity/status must re-arm a later stall episode")
+
+  const pulseState = path.join(project, ".opencode", "opencode-loop", "pulse-check.json")
+  await fs.rm(pulseState, { force: true })
+  staleGoal.updatedAt = Date.now() - 60 * 60_000
+  staleGoal.storageGeneration += 1
+  await fs.writeFile(goalFile, JSON.stringify(staleGoal, null, 2) + "\n", "utf8")
+  const concurrent = await Promise.all([
+    runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv),
+    runCli(["pulse-check", "--project", project, "--stale-after", "10m"], pulseEnv),
+  ])
+  assert.ok(concurrent.every((item) => item.code === 0), concurrent.map((item) => item.stderr).join("\n"))
+  const concurrentAlerts = concurrent.reduce((count, item) => count + (item.stdout.match(/GOAL PULSE STALLED/g) || []).length, 0)
+  assert.equal(concurrentAlerts, 1, "concurrent one-shot checks must share episode state and emit at most one alert")
+
+  const pulseCalls = await readLog(pulseEnv.FAKE_COMMAND_LOG)
+  assert.ok(pulseCalls.every((item) => item.args[0] === "session"), "pulse-check may inspect session telemetry but must never dispatch an OpenCode run")
+
   result = await runCli(["--project", project, "--max-runs", "not-a-number", "--prompt", "test"], {
     OPENCODE_BIN: fakeOpenCode.command,
     FAKE_COMMAND_LOG: path.join(temporaryRoot, "invalid-count.jsonl"),
@@ -208,7 +275,7 @@ try {
       "run", "--title", taskRunCalls[0].args[2],
       "--model", "opencode/nemotron-3-ultra-free",
       "--agent", "build",
-      "scheduled task prompt",
+      "--", "scheduled task prompt",
     ])
 
     result = await runCli(["uninstall-task", "--name", taskName], {
@@ -223,6 +290,7 @@ try {
 
     result = await runCli(["install-task", "--project", project, "--name", taskName, "--prompt", "test"], {
       SCHTASKS_BIN: path.join(temporaryRoot, "missing-schtasks.exe"),
+      OPENCODE_BIN: fakeOpenCode.command,
       OPENCODE_LOOPD_TASK_DIR: path.join(temporaryRoot, "missing-task-files"),
     })
     assert.equal(result.code, 1, "a missing Task Scheduler executable must not report success")
@@ -233,3 +301,5 @@ try {
 } finally {
   await fs.rm(temporaryRoot, { recursive: true, force: true })
 }
+
+await import("./native-cli-test.mjs")