@bybrawe/opencode-loop 0.5.23 → 0.5.25

package/package.json

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

package/scripts/comprehensive-test.mjs

@@ -18,10 +18,13 @@ async function createHarness(options = {}) {
     logs: [],
     prompts: [],
     shells: [],
+    summaries: [],
+    messageReads: [],
     toasts: [],
     tuiCommands: [],
   }
   const statuses = new Map([[sessionID, "idle"]])
+  const messageHistory = Array.isArray(options.messages) ? structuredClone(options.messages) : []
 
   const client = {
     app: {
@@ -35,7 +38,7 @@ async function createHarness(options = {}) {
       executeCommand: async (args) => {
         assert.ok(args?.body?.command, "tui.executeCommand must use the SDK body shape")
         records.tuiCommands.push(args.body.command)
-        if (options.failCompact) throw new Error("simulated TUI compact failure")
+        if (options.failCompact || options.failTuiCompact) throw new Error("simulated TUI compact failure")
         return { data: true }
       },
       showToast: async (args) => {
@@ -95,7 +98,15 @@ async function createHarness(options = {}) {
           ),
         }
       },
-      summarize: async () => {
+      messages: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        assert.equal(args?.query?.directory, directory)
+        records.messageReads.push(args)
+        return { data: structuredClone(messageHistory) }
+      },
+      summarize: async (args) => {
+        assert.equal(args?.path?.id, sessionID)
+        records.summaries.push(args?.body)
         if (options.failCompact) throw new Error("simulated summarize failure")
         return { data: true }
       },
@@ -112,6 +123,7 @@ async function createHarness(options = {}) {
     sessionID,
     stateFile,
     statuses,
+    messageHistory,
     async command(command, argumentsText = "", output = { parts: [] }) {
       await hooks["command.execute.before"]({ command, sessionID, arguments: argumentsText }, output)
       return output
@@ -378,6 +390,110 @@ async function testActionRoutingAndSafety() {
   }
 }
 
+async function testNativeCompactionLifecycleAndFallback() {
+  let h = await createHarness({ failTuiCompact: true })
+  try {
+    await h.command("loop-compact", "0s --no-now")
+    await h.command("loop-now", "compact")
+    assert.deepEqual(h.records.summaries[0], {
+      providerID: "test-provider",
+      modelID: "test-model",
+      auto: false,
+    }, "headless compact fallback must satisfy the current OpenCode summarize payload")
+    assert.equal(typeof h.hooks["experimental.session.compacting"], "function")
+    const compactOutput = { context: [], prompt: undefined }
+    await h.hooks["experimental.session.compacting"]({ sessionID: h.sessionID }, compactOutput)
+    assert.deepEqual(compactOutput, { context: [], prompt: undefined }, "loop lifecycle tracking must not rewrite OpenCode's compaction prompt")
+    await h.hooks.event({ event: { type: "session.compacted", properties: { sessionID: h.sessionID } } })
+    await delay(20)
+    const state = await h.readState()
+    assert.ok(state.jobs[0].lastFinishedAt > 0, "session.compacted must finalize an explicit compact job without waiting for stale status recovery")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --name compact-chain --compact-every 1 --verify 'node -e process.exitCode=7' --pause-on-verify-fail continue after compaction")
+    const seeded = await h.readState()
+    seeded.jobs[0].runCount = 1
+    seeded.jobs[0].lastRunAt = 0
+    await fs.writeFile(h.stateFile, JSON.stringify(seeded, null, 2), "utf8")
+
+    await h.command("loop-now", "compact-chain")
+    assert.equal(h.records.tuiCommands.length, 1, "compact-every must start compaction")
+    assert.equal(h.actionTexts().length, 0, "the scheduled action must not overlap a pending compaction")
+    assert.equal((await h.readState()).jobs[0].runCount, 1, "compaction-only phase must not count as a normal loop run")
+
+    await h.hooks["experimental.session.compacting"]({ sessionID: h.sessionID }, { context: [], prompt: undefined })
+    await h.hooks.event({ event: { type: "session.compacted", properties: { sessionID: h.sessionID } } })
+    await delay(20)
+    assert.equal((await h.readState()).jobs[0].runCount, 1, "native compaction completion must only release the deferred action")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --name compact-idle-fallback --compact-every 1 --verify 'node -e process.exitCode=7' --pause-on-verify-fail continue after fallback compaction")
+    const seeded = await h.readState()
+    seeded.jobs[0].runCount = 1
+    seeded.jobs[0].lastRunAt = 0
+    await fs.writeFile(h.stateFile, JSON.stringify(seeded, null, 2), "utf8")
+    await h.command("loop-now", "compact-idle-fallback")
+    assert.equal(h.actionTexts().length, 0)
+    h.statuses.set(h.sessionID, "idle")
+    await h.command("loop-now", "compact-idle-fallback")
+    const fallbackState = await h.readState()
+    assert.equal(fallbackState.jobs[0].failureCount || 0, 0, "idle-only compaction fallback must not run normal verify logic")
+    assert.equal(fallbackState.jobs[0].paused, false, "idle-only compaction fallback must not pause the job through normal run finalization")
+  } finally {
+    await h.cleanup()
+  }
+}
+
+async function testStaleBusyUsesCompletedAssistantTail() {
+  let h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --name stale-complete continue safely")
+    await h.command("loop-now", "stale-complete")
+    h.statuses.set(h.sessionID, "busy")
+    const completedAt = Date.now() + 5
+    h.messageHistory.splice(0, h.messageHistory.length,
+      { info: { id: "usr_tail", sessionID: h.sessionID, role: "user", time: { created: completedAt - 2 } }, parts: [] },
+      { info: { id: "asst_tail", sessionID: h.sessionID, role: "assistant", time: { created: completedAt - 1, completed: completedAt } }, parts: [] },
+    )
+    await h.command("loop-now", "stale-complete")
+    const state = await h.readState()
+    assert.ok(state.jobs[0].lastFinishedAt > 0, "a completed assistant tail must override a stale busy status")
+    assert.ok(h.records.messageReads.length > 0, "busy recovery must cross-check message history")
+  } finally {
+    await h.cleanup()
+  }
+
+  h = await createHarness()
+  try {
+    await h.command("loop", "5m --no-now --name stale-incomplete continue safely")
+    const seeded = await h.readState()
+    seeded.jobs[0].staleActiveRecoveryMs = 1
+    await fs.writeFile(h.stateFile, JSON.stringify(seeded, null, 2), "utf8")
+    await h.command("loop-now", "stale-incomplete")
+    await delay(10)
+    h.statuses.set(h.sessionID, "busy")
+    const createdAt = Date.now()
+    h.messageHistory.splice(0, h.messageHistory.length,
+      { info: { id: "usr_running", sessionID: h.sessionID, role: "user", time: { created: createdAt - 1 } }, parts: [] },
+      { info: { id: "asst_running", sessionID: h.sessionID, role: "assistant", time: { created: createdAt } }, parts: [] },
+    )
+    await h.command("loop-now", "stale-incomplete")
+    const state = await h.readState()
+    assert.equal(state.jobs[0].lastFinishedAt, undefined, "an unfinished assistant tail must never be force-finalized just because the active-run timeout elapsed")
+    assert.equal(h.actionTexts().length, 1, "unfinished work must not be overlapped by a replacement prompt")
+  } finally {
+    await h.cleanup()
+  }
+}
+
 async function testPromptDispatchFailureRecovery() {
   const h = await createHarness({ failPrompt: true, promptFailureDelayMs: 25 })
   try {
@@ -593,6 +709,8 @@ await testParserAndPresets()
 await testLifecycleAndCommandDedupe()
 await testWatchScheduling()
 await testActionRoutingAndSafety()
+await testNativeCompactionLifecycleAndFallback()
+await testStaleBusyUsesCompletedAssistantTail()
 await testPromptDispatchFailureRecovery()
 await testStopsPreflightAndGoalLifecycle()
 await testLoopOwnedGoalMessageUpdatesDoNotSelfInterrupt()

package/scripts/install-node.mjs

@@ -13,17 +13,12 @@ const packagePath = join(config, "package.json")
 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 uninstallRequested = installerArgs.length === 1 && ["--uninstall", "uninstall", "--remove"].includes(installerArgs[0] || "")
 
 if (installerArgs.includes("--help") || installerArgs.includes("-h")) {
-  console.log(`OpenCode Loop installer
-
-Usage:
-  opencode-loop
-  npx -y @bybrawe/opencode-loop@latest
-
-Installs the plugin commands and local command agent into OPENCODE_CONFIG_DIR
-or the default ~/.config/opencode 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 copies the Loop 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.`)
   process.exit(0)
 }
 
@@ -32,6 +27,11 @@ if (installerArgs.includes("--version") || installerArgs.includes("-v")) {
   process.exit(0)
 }
 
+if (installerArgs.length && !uninstallRequested) {
+  console.error(`Unknown installer option: ${installerArgs[0]}`)
+  process.exit(2)
+}
+
 function stripJsonComments(input) {
   let output = ""
   let quote = ""
@@ -90,7 +90,9 @@ function stripTrailingCommas(input) {
 }
 
 function parseJsonc(input) {
-  return JSON.parse(stripTrailingCommas(stripJsonComments(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 isPackageSpec(value) {
@@ -98,33 +100,142 @@ function isPackageSpec(value) {
   return spec === packageName || spec.startsWith(`${packageName}@`)
 }
 
+function skipTrivia(source, start) {
+  let index = start
+  while (index < source.length) {
+    const char = source[index] || ""
+    const next = source[index + 1] || ""
+    if (/\s/.test(char)) { index++; continue }
+    if (char === "/" && next === "/") {
+      index += 2
+      while (index < source.length && source[index] !== "\n" && source[index] !== "\r") index++
+      continue
+    }
+    if (char === "/" && next === "*") {
+      const end = source.indexOf("*/", index + 2)
+      if (end < 0) throw new Error("unterminated block comment in OpenCode config")
+      index = end + 2
+      continue
+    }
+    break
+  }
+  return index
+}
+
+function readJsonString(source, start) {
+  if (source[start] !== '"') throw new Error("expected JSON string")
+  let escaped = false
+  for (let index = start + 1; index < source.length; index++) {
+    const char = source[index] || ""
+    if (escaped) { escaped = false; continue }
+    if (char === "\\") { escaped = true; continue }
+    if (char === '"') {
+      const end = index + 1
+      return { value: JSON.parse(source.slice(start, end)), end }
+    }
+  }
+  throw new Error("unterminated JSON string in OpenCode config")
+}
+
+function skipJsonValue(source, start) {
+  const valueStart = skipTrivia(source, start)
+  const first = source[valueStart]
+  if (first === '"') return readJsonString(source, valueStart).end
+  if (first === "{" || first === "[") {
+    const stack = []
+    let quoted = false
+    let escaped = false
+    let lineComment = false
+    let blockComment = false
+    for (let index = valueStart; index < source.length; index++) {
+      const char = source[index] || ""
+      const next = source[index + 1] || ""
+      if (lineComment) { if (char === "\n" || char === "\r") lineComment = false; continue }
+      if (blockComment) { if (char === "*" && next === "/") { blockComment = false; index++ }; continue }
+      if (quoted) {
+        if (escaped) escaped = false
+        else if (char === "\\") escaped = true
+        else if (char === '"') quoted = false
+        continue
+      }
+      if (char === '"') { quoted = true; continue }
+      if (char === "/" && next === "/") { lineComment = true; index++; continue }
+      if (char === "/" && next === "*") { blockComment = true; index++; continue }
+      if (char === "{" || char === "[") stack.push(char)
+      else if (char === "}" || char === "]") {
+        const expected = char === "}" ? "{" : "["
+        if (stack.at(-1) !== expected) throw new Error("mismatched JSON delimiters in OpenCode config")
+        stack.pop()
+        if (!stack.length) return index + 1
+      }
+    }
+    throw new Error("unterminated JSON value in OpenCode config")
+  }
+  let index = valueStart
+  while (index < source.length && ![",", "}", "]"].includes(source[index])) index++
+  return index
+}
+
+function findRootProperty(source, propertyName) {
+  let index = skipTrivia(source, 0)
+  if (source[index] !== "{") throw new Error("OpenCode config must contain one root object")
+  index++
+  while (true) {
+    index = skipTrivia(source, index)
+    if (source[index] === "}") return null
+    const key = readJsonString(source, index)
+    index = skipTrivia(source, key.end)
+    if (source[index] !== ":") throw new Error(`expected ':' after config property ${key.value}`)
+    const valueStart = skipTrivia(source, index + 1)
+    const valueEnd = skipJsonValue(source, valueStart)
+    if (key.value === propertyName) {
+      const lineStart = Math.max(source.lastIndexOf("\n", valueStart - 1), source.lastIndexOf("\r", valueStart - 1)) + 1
+      const keyLineStart = Math.max(source.lastIndexOf("\n", key.end - 1), source.lastIndexOf("\r", key.end - 1)) + 1
+      const indent = source.slice(keyLineStart, key.end - key.value.length - 2).match(/^[\t ]*/)?.[0] || "  "
+      return { valueStart, valueEnd, indent, lineStart }
+    }
+    const afterValue = skipTrivia(source, valueEnd)
+    if (source[afterValue] === ",") index = afterValue + 1
+    else if (source[afterValue] === "}") return null
+    else throw new Error(`expected ',' or '}' after config property ${key.value}`)
+  }
+}
+
+function formatPluginArray(values, indent, eol) {
+  if (!values.length) return "[]"
+  const childIndent = `${indent}  `
+  return `[${eol}${values.map((value) => `${childIndent}${JSON.stringify(value)}`).join(`,${eol}`)}${eol}${indent}]`
+}
+
+function rewriteExistingPluginArray(source, nextPlugins) {
+  const property = findRootProperty(source, "plugin")
+  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)}`
+}
+
 async function configurePackagePlugin() {
   let configured = false
   const updatedFiles = []
-  for (const name of ["opencode.json", "opencode.jsonc", "config.json", "config.jsonc"]) {
+  for (const name of configCandidates) {
+    const target = join(config, name)
     try {
-      const target = join(config, name)
       const source = await readFile(target, "utf8")
       const parsed = parseJsonc(source)
-      const specs = Array.isArray(parsed?.plugin) ? parsed.plugin.filter(isPackageSpec) : []
-      if (!specs.length) continue
+      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
-
-      // OpenCode caches package plugins by the literal config spec. A bare
-      // package name or @latest can therefore keep loading an older cached
-      // release after npm installs a newer one. Pin the config entry to the
-      // installer package's exact version while preserving JSONC comments.
-      let updated = source
-      for (const spec of new Set(specs)) {
-        if (spec === packageSpec) continue
-        updated = updated.replaceAll(JSON.stringify(spec), JSON.stringify(packageSpec))
-      }
+      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)
       }
     } catch (error) {
-      if (error?.code !== "ENOENT") console.warn(`Could not inspect ${join(config, name)} for duplicate plugin entries: ${error.message}`)
+      if (error?.code !== "ENOENT") throw new Error(`Could not inspect ${target}: ${error.message}`)
     }
   }
   return { configured, updatedFiles }
@@ -149,39 +260,81 @@ async function ensureDependency() {
   }
 }
 
-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) {
+async function removePackagedFiles(sourceDir, targetDir) {
+  for (const name of await readdir(sourceDir)) {
+    if (name.endsWith(".md")) await rm(join(targetDir, name), { force: true })
+  }
+}
+
+async function uninstall() {
+  const plans = []
+  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 || []
+      const nextPlugins = plugins.filter((value) => !isPackageSpec(value))
+      const updated = nextPlugins.length === plugins.length ? source : rewriteExistingPluginArray(source, nextPlugins)
+      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")
+  }
   await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
   await rm(join(pluginDir, "opencode-loop.js"), { force: true })
-} else {
-  await ensureDependency()
-  await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
-  await rm(join(pluginDir, "opencode-loop.js"), { 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.")
+  console.log("Project state under .opencode/opencode-loop is preserved.")
+  console.log("Restart OpenCode to finish unloading OpenCode Loop.")
 }
 
-for (const name of await readdir(join(root, "commands"))) {
-  if (name.endsWith(".md")) {
-    await copyFile(join(root, "commands", name), join(commandDir, name))
+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) {
+    await rm(join(pluginDir, "opencode-loop.ts"), { force: true })
+    await rm(join(pluginDir, "opencode-loop.js"), { force: true })
+  } else {
+    await ensureDependency()
+    await copyFile(join(root, "src", "index.js"), join(pluginDir, "opencode-loop.ts"))
+    await rm(join(pluginDir, "opencode-loop.js"), { force: true })
   }
-}
 
-for (const name of await readdir(join(root, "agents"))) {
-  if (name.endsWith(".md")) {
-    await copyFile(join(root, "agents", name), join(agentDir, name))
+  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 (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.`)
+  } else {
+    console.log(`Installed OpenCode Loop plugin to ${config}`)
+  }
+  console.log(`Installed ${packageName} commands to ${commandDir}`)
+  console.log(`Installed ${packageName} local command agent to ${agentDir}`)
+  console.log("Restart OpenCode, then run: /loop-help")
 }
-else console.log(`Installed OpenCode Loop plugin to ${config}`)
-console.log(`Installed ${packageName} commands to ${commandDir}`)
-console.log(`Installed ${packageName} local command agent to ${agentDir}`)
-console.log("Restart OpenCode, then run: /loop-help")
+
+if (uninstallRequested) await uninstall()
+else await installOrUpdate()

package/scripts/install-test.mjs

@@ -10,6 +10,7 @@ const installer = path.join(root, "scripts", "install-node.mjs")
 const packageVersion = JSON.parse(await fs.readFile(path.join(root, "package.json"), "utf8")).version
 const expectedPackageSpec = `@bybrawe/opencode-loop@${packageVersion}`
 const temporaryRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-loop-installer-"))
+const packagedCommandCount = (await fs.readdir(path.join(root, "commands"))).filter((name) => name.endsWith(".md")).length
 
 async function runInstaller(config, cliArgs = []) {
   return await new Promise((resolve, reject) => {
@@ -32,7 +33,12 @@ async function runInstaller(config, cliArgs = []) {
 }
 
 async function commandCount(config) {
-  return (await fs.readdir(path.join(config, "commands"))).filter((name) => name.endsWith(".md")).length
+  try {
+    return (await fs.readdir(path.join(config, "commands"))).filter((name) => name.endsWith(".md")).length
+  } catch (error) {
+    if (error?.code === "ENOENT") return 0
+    throw error
+  }
 }
 
 async function exists(target) {
@@ -43,7 +49,8 @@ try {
   const helpConfig = path.join(temporaryRoot, "help-must-not-install")
   const helpResult = await runInstaller(helpConfig, ["--help"])
   assert.equal(helpResult.code, 0, helpResult.stderr)
-  assert.match(helpResult.stdout, /OpenCode Loop installer/)
+  assert.match(helpResult.stdout, /OpenCode Loop installer\/updater/)
+  assert.match(helpResult.stdout, /--uninstall/)
   assert.equal(await exists(helpConfig), false, "--help must not mutate the OpenCode config directory")
 
   const versionResult = await runInstaller(helpConfig, ["--version"])
@@ -55,7 +62,7 @@ try {
   const localResult = await runInstaller(local)
   assert.equal(localResult.code, 0, localResult.stderr)
   assert.equal(await exists(path.join(local, "plugins", "opencode-loop.ts")), true)
-  assert.equal(await commandCount(local), 30)
+  assert.equal(await commandCount(local), packagedCommandCount)
   assert.equal(await exists(path.join(local, "agents", "opencode-loop-local.md")), true)
   const localPackage = JSON.parse(await fs.readFile(path.join(local, "package.json"), "utf8"))
   assert.equal(localPackage.dependencies["@opencode-ai/plugin"], ">=1.4.0")
@@ -70,7 +77,7 @@ try {
   assert.match(configuredResult.stdout, /removed the duplicate local plugin copy/i)
   assert.equal(await exists(path.join(configured, "plugins", "opencode-loop.ts")), false)
   assert.equal(await exists(path.join(configured, "plugins", "opencode-loop.js")), false)
-  assert.equal(await commandCount(configured), 30)
+  assert.equal(await commandCount(configured), packagedCommandCount)
   assert.equal(await exists(path.join(configured, "agents", "opencode-loop-local.md")), true)
   const configuredJson = JSON.parse(await fs.readFile(path.join(configured, "opencode.json"), "utf8"))
   assert.deepEqual(configuredJson.plugin, [expectedPackageSpec], "the installer must bust OpenCode's stale package cache with an exact version spec")
@@ -98,6 +105,45 @@ try {
   assert.equal(lookalikeResult.code, 0, lookalikeResult.stderr)
   assert.equal(await exists(path.join(lookalike, "plugins", "opencode-loop.ts")), true)
 
+  const uninstallConfig = path.join(temporaryRoot, "uninstall")
+  await fs.mkdir(path.join(uninstallConfig, "plugins"), { recursive: true })
+  await fs.mkdir(path.join(uninstallConfig, "commands"), { recursive: true })
+  await fs.mkdir(path.join(uninstallConfig, "agents"), { recursive: true })
+  await fs.writeFile(path.join(uninstallConfig, "opencode.jsonc"), `{
+    // Keep unrelated OpenCode configuration.
+    "plugin": [
+      "other-plugin",
+      "@bybrawe/opencode-loop@0.5.1",
+    ],
+    "permission": { "read": "allow" },
+  }`, "utf8")
+  await fs.writeFile(path.join(uninstallConfig, "plugins", "opencode-loop.ts"), "local", "utf8")
+  for (const name of await fs.readdir(path.join(root, "commands"))) {
+    if (name.endsWith(".md")) await fs.copyFile(path.join(root, "commands", name), path.join(uninstallConfig, "commands", name))
+  }
+  for (const name of await fs.readdir(path.join(root, "agents"))) {
+    if (name.endsWith(".md")) await fs.copyFile(path.join(root, "agents", name), path.join(uninstallConfig, "agents", name))
+  }
+  const stateFile = path.join(temporaryRoot, "project", ".opencode", "opencode-loop", "state.json")
+  await fs.mkdir(path.dirname(stateFile), { recursive: true })
+  await fs.writeFile(stateFile, "preserve", "utf8")
+
+  const uninstallResult = await runInstaller(uninstallConfig, ["--uninstall"])
+  assert.equal(uninstallResult.code, 0, uninstallResult.stderr)
+  assert.match(uninstallResult.stdout, /Project state .* is preserved/)
+  const uninstallJsonc = await fs.readFile(path.join(uninstallConfig, "opencode.jsonc"), "utf8")
+  assert.match(uninstallJsonc, /Keep unrelated OpenCode configuration/)
+  assert.match(uninstallJsonc, /"other-plugin"/)
+  assert.match(uninstallJsonc, /"permission"/)
+  assert.doesNotMatch(uninstallJsonc, /@bybrawe\/opencode-loop/)
+  assert.equal(await exists(path.join(uninstallConfig, "plugins", "opencode-loop.ts")), false)
+  assert.equal(await commandCount(uninstallConfig), 0)
+  assert.equal(await exists(path.join(uninstallConfig, "agents", "opencode-loop-local.md")), false)
+  assert.equal(await fs.readFile(stateFile, "utf8"), "preserve")
+
+  const uninstallAgain = await runInstaller(uninstallConfig, ["--uninstall"])
+  assert.equal(uninstallAgain.code, 0, uninstallAgain.stderr)
+
   console.log("OpenCode Loop installer test passed")
 } finally {
   await fs.rm(temporaryRoot, { recursive: true, force: true })

package/scripts/smoke-test.mjs

@@ -122,6 +122,34 @@ try {
   assert.equal(completedState.jobs[0].paused, true)
   assert.equal(completedState.jobs[0].enabled, false)
 
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
+
+  const promptCountBeforeAutoGoal = prompts.length
+  await hooks["command.execute.before"]({
+    command: "loop-goal",
+    sessionID,
+    arguments: "--no-now --check \"node -e process.exitCode=0\" --complete-when-checks-pass make the configured checks pass",
+  }, { parts: [] })
+  await hooks["command.execute.before"]({ command: "loop-now", sessionID, arguments: "goal" }, { parts: [] })
+  assert.equal(
+    await waitFor(() => prompts.length === promptCountBeforeAutoGoal + 1),
+    true,
+    "a Goal Mode check-gated run must start when forced",
+  )
+  await new Promise((resolve) => setTimeout(resolve, 25))
+  await hooks.event({ event: { type: "session.idle", properties: { sessionID } } })
+  let autoCompletedState
+  for (let attempt = 0; attempt < 400; attempt++) {
+    autoCompletedState = JSON.parse(await fs.readFile(stateFile, "utf8"))
+    if (autoCompletedState.jobs[0]?.goalStatus === "completed") break
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  assert.equal(autoCompletedState.jobs[0].goalStatus, "completed", "--complete-when-checks-pass must complete the goal after successful configured checks")
+  assert.equal(autoCompletedState.jobs[0].paused, true)
+  assert.equal(autoCompletedState.jobs[0].enabled, false)
+  assert.ok(autoCompletedState.jobs[0].lastGoalChecks?.every((item) => item.code === 0), "auto-completed Goal Mode must persist passing check evidence")
+
   await hooks["command.execute.before"]({ command: "loop-clear", sessionID, arguments: "" }, { parts: [] })
 
   const promptCountBeforeBackgroundTool = prompts.length