opencode-goal-plugin 0.6.0 → 0.6.2

package/src/native-agent-config.js

@@ -1,6 +1,6 @@
 const GOAL_AGENT_PROMPT = `Execute explicit goals persistently. Use goal tools to track state and checkpoints. Make concrete progress; claim completion only with verification evidence. Report only genuine blockers.`
 
-const VERIFIER_AGENT_PROMPT = `Independently verify the claim against the goal, constraints, evidence, and workspace. Use read-only checks; never edit or mutate goal state. Approve only when proven; otherwise give one actionable reason.`
+const VERIFIER_AGENT_PROMPT = `Independently verify the claim against the goal, constraints, evidence, and workspace. Use only the read, glob, and grep tools; never edit, execute commands, call other tools, or mutate goal state. Approve only when proven; otherwise give one actionable reason.`
 
 export function applyNativeGoalConfig(config, options = {}) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -40,6 +40,10 @@ export function applyNativeGoalConfig(config, options = {}) {
     hidden: true,
     prompt: VERIFIER_AGENT_PROMPT,
     permission: {
+      "*": "deny",
+      read: "allow",
+      glob: "allow",
+      grep: "allow",
       edit: "deny",
       bash: "deny",
     },

package/src/opencode-session-api.js

@@ -5,6 +5,11 @@ const SHAPE_ERROR_PATTERNS = [
   /(?:validation|schema|invalid input|invalid argument)/i,
 ]
 
+// Only read-only operations may be retried with another argument shape. A
+// TypeError can be raised after a mutating SDK call has already reached the
+// host, so replaying create/prompt/update/delete/abort could duplicate side effects.
+const REPLAY_SAFE_OPERATIONS = new Set(["messages", "get"])
+
 function isArgumentShapeError(error) {
   if (!(error instanceof TypeError)) return false
   const message = String(error.message || "")
@@ -46,7 +51,9 @@ export function createOpenCodeSessionApi(client, options = {}) {
       shapes.set(operation, firstShape)
       return unwrapData(response)
     } catch (error) {
-      if (knownShape || !isArgumentShapeError(error)) throw error
+      if (knownShape || !REPLAY_SAFE_OPERATIONS.has(operation) || !isArgumentShapeError(error)) {
+        throw error
+      }
       const fallbackShape = firstShape === "flat" ? "legacy" : "flat"
       const fallbackInput = fallbackShape === "flat" ? flatInput : legacyInput
       const response = await method.call(client.session, fallbackInput)
@@ -91,6 +98,9 @@ export function createOpenCodeSessionApi(client, options = {}) {
     get(sessionID) {
       return invoke("get", { sessionID }, { path: { id: sessionID } })
     },
+    delete(sessionID) {
+      return invoke("delete", { sessionID }, { path: { id: sessionID } })
+    },
     abort(sessionID) {
       return invoke("abort", { sessionID }, { path: { id: sessionID } })
     },

package/src/persistence-lease.js

@@ -27,7 +27,10 @@ async function readOwner(lockPath) {
  * deliberately rejects a second writer instead of allowing stale full-state
  * snapshots to overwrite each other.
  */
-export async function acquirePersistenceLease(stateFilePath) {
+export async function acquirePersistenceLease(
+  stateFilePath,
+  { malformedGraceMs = 30_000, now = () => Date.now() } = {},
+) {
   const lockPath = `${stateFilePath}.lock`
   await fs.mkdir(dirname(stateFilePath), { recursive: true, mode: 0o700 })
   const owner = {
@@ -58,7 +61,16 @@ export async function acquirePersistenceLease(stateFilePath) {
       }
       const existing = await readOwner(lockPath)
       const sameHost = existing?.hostname === owner.hostname
-      if (sameHost && processIsAlive(existing?.pid) === false) {
+      let reclaimableMalformed = false
+      if (!existing) {
+        try {
+          const info = await fs.lstat(lockPath)
+          reclaimableMalformed = now() - info.mtimeMs >= malformedGraceMs
+        } catch (statError) {
+          if (statError?.code === "ENOENT") continue
+        }
+      }
+      if ((sameHost && processIsAlive(existing?.pid) === false) || reclaimableMalformed) {
         const stalePath = `${lockPath}.stale.${randomUUID()}`
         try {
           await fs.rename(lockPath, stalePath)

package/scripts/behavior-benchmark.mjs

@@ -1,272 +0,0 @@
-#!/usr/bin/env node
-
-import assert from "node:assert/strict"
-import { promises as fs } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { GoalPlugin } from "../src/goal-plugin.js"
-
-const startedAt = performance.now()
-const temporaryDirectories = []
-
-function assistantMessage(sessionID, text, id = `assistant-${sessionID}`) {
-  return {
-    info: {
-      id,
-      role: "assistant",
-      sessionID,
-      tokens: { input: 20, output: 120, reasoning: 0 },
-    },
-    parts: [{ type: "text", text }],
-  }
-}
-
-function createHost(messageForSession = () => "Working with tools.") {
-  const prompts = []
-  const notices = []
-  return {
-    prompts,
-    notices,
-    client: {
-      app: { log: async () => {} },
-      session: {
-        messages: async ({ path }) => ({
-          data: [assistantMessage(path.id, messageForSession(path.id))],
-        }),
-        promptAsync: async (input) => {
-          prompts.push(input)
-          return {}
-        },
-      },
-    },
-  }
-}
-
-function promptCharacters(prompts) {
-  return prompts.reduce(
-    (total, prompt) => total + (prompt?.body?.parts || []).reduce(
-      (partTotal, part) => partTotal + (typeof part?.text === "string" ? part.text.length : 0),
-      0,
-    ),
-    0,
-  )
-}
-
-async function makeDirectory(label) {
-  const directory = await fs.mkdtemp(join(tmpdir(), `goal-benchmark-${label}-`))
-  temporaryDirectories.push(directory)
-  return directory
-}
-
-async function createHooks(host, options = {}) {
-  return GoalPlugin(
-    { client: host.client, directory: await makeDirectory("workspace") },
-    {
-      persistState: false,
-      registerTools: false,
-      registerAgents: false,
-      minDelayMs: 1,
-      noProgressTokenThreshold: 1,
-      noProgressTurnsBeforePause: 10,
-      noToolCallTurnsBeforePause: 2,
-      ...options,
-    },
-  )
-}
-
-async function goalCommand(hooks, sessionID, argumentsText) {
-  const output = { parts: [] }
-  await hooks["command.execute.before"](
-    { command: "goal", sessionID, arguments: argumentsText },
-    output,
-  )
-  return output.parts.map((part) => part.text || "").join("\n")
-}
-
-async function idle(hooks, sessionID, id) {
-  await hooks.event({
-    event: {
-      id,
-      type: "session.status",
-      properties: { sessionID, status: { type: "idle" } },
-    },
-  })
-}
-
-async function scenario(name, points, run) {
-  const scenarioStartedAt = performance.now()
-  try {
-    const telemetry = await run()
-    return {
-      name,
-      passed: true,
-      points,
-      durationMs: Number((performance.now() - scenarioStartedAt).toFixed(2)),
-      ...telemetry,
-    }
-  } catch (error) {
-    return {
-      name,
-      passed: false,
-      points: 0,
-      possiblePoints: points,
-      durationMs: Number((performance.now() - scenarioStartedAt).toFixed(2)),
-      error: error instanceof Error ? error.message : String(error),
-    }
-  }
-}
-
-const results = []
-
-results.push(await scenario("verified-success", 20, async () => {
-  const sessionID = "benchmark-success"
-  const host = createHost(() => "Tests pass.\n[goal:evidence] npm test: 210/210\n[goal:complete]")
-  const hooks = await createHooks(host, {
-    auditor: async () => ({ approved: true, reason: "evidence independently accepted" }),
-  })
-  await goalCommand(hooks, sessionID, "ship a verified release")
-  await idle(hooks, sessionID, "success-idle")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /State: achieved/)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "archived",
-  }
-}))
-
-results.push(await scenario("false-completion", 20, async () => {
-  const sessionID = "benchmark-false-completion"
-  const host = createHost(() => "Looks done.\n[goal:evidence] guessed from source\n[goal:complete]")
-  const hooks = await createHooks(host, {
-    auditor: async () => ({ approved: false, reason: "no executed verification" }),
-  })
-  await goalCommand(hooks, sessionID, "do not accept an unverified claim")
-  await idle(hooks, sessionID, "false-idle")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /audit rejected/i)
-  assert.doesNotMatch(status, /No active goal/)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "rejected",
-  }
-}))
-
-results.push(await scenario("loop-circuit-breaker", 15, async () => {
-  const sessionID = "benchmark-loop"
-  let turn = 0
-  const host = createHost(() => `Still discussing the work, turn ${turn++}.`)
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "stop self-chat loops")
-  await idle(hooks, sessionID, "loop-1")
-  await idle(hooks, sessionID, "loop-2")
-  await idle(hooks, sessionID, "loop-3")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /no tool calls|self-chat loop/i)
-  assert.equal(host.prompts.length, 2)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "paused",
-  }
-}))
-
-results.push(await scenario("human-interruption", 15, async () => {
-  const sessionID = "benchmark-interruption"
-  const host = createHost()
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "respect explicit interruption")
-  await hooks.event({
-    event: {
-      type: "session.error",
-      properties: {
-        sessionID,
-        error: { name: "MessageAbortedError", message: "aborted by user" },
-      },
-    },
-  })
-  await idle(hooks, sessionID, "interruption-idle")
-  assert.equal(host.prompts.length, 0)
-  assert.match(await goalCommand(hooks, sessionID, "status"), /abort|paused|stopped/i)
-  await hooks.dispose()
-  return { continuationPrompts: 0, status: "paused" }
-}))
-
-results.push(await scenario("compaction-continuity", 15, async () => {
-  const sessionID = "benchmark-compaction"
-  const host = createHost()
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "preserve the objective across compaction")
-  const output = { context: [] }
-  await hooks["experimental.session.compacting"]({ sessionID }, output)
-  assert.equal(output.context.length, 1)
-  assert.match(output.context[0], /preserve the objective across compaction/)
-  assert.ok(output.context[0].length < 2_000, "compaction context exceeded token-efficient size cap")
-  await hooks.dispose()
-  return {
-    contextCharacters: output.context[0].length,
-    estimatedContextTokens: Math.ceil(output.context[0].length / 4),
-    status: "preserved",
-  }
-}))
-
-results.push(await scenario("restart-recovery", 15, async () => {
-  const sessionID = "benchmark-restart"
-  const directory = await makeDirectory("restart")
-  const stateFilePath = join(directory, "state.json")
-  const host = createHost()
-  const first = await GoalPlugin(
-    { client: host.client, directory },
-    { persistState: true, stateFilePath, registerTools: false, registerAgents: false, minDelayMs: 1 },
-  )
-  await goalCommand(first, sessionID, "recover safely after restart")
-  await first.dispose()
-  const second = await GoalPlugin(
-    { client: host.client, directory },
-    { persistState: true, stateFilePath, registerTools: false, registerAgents: false, minDelayMs: 1 },
-  )
-  const status = await goalCommand(second, sessionID, "status")
-  assert.match(status, /Recovered persisted goal state|recovered after restart/i)
-  await idle(second, sessionID, "restart-idle")
-  assert.equal(host.prompts.length, 0, "recovered goals must not resume without user consent")
-  const stateBytes = (await fs.stat(stateFilePath)).size
-  await second.dispose()
-  return { continuationPrompts: 0, persistedStateBytes: stateBytes, status: "recovered-paused" }
-}))
-
-const score = results.reduce((total, result) => total + result.points, 0)
-const possibleScore = 100
-const continuationCharacters = results.reduce(
-  (total, result) => total + (result.continuationCharacters || 0),
-  0,
-)
-const report = {
-  schemaVersion: 1,
-  benchmark: "opencode-goal-plugin-behavior",
-  score,
-  possibleScore,
-  passed: score === possibleScore,
-  durationMs: Number((performance.now() - startedAt).toFixed(2)),
-  efficiency: {
-    totalContinuationPrompts: results.reduce(
-      (total, result) => total + (result.continuationPrompts || 0),
-      0,
-    ),
-    continuationCharacters,
-    estimatedContinuationTokens: Math.ceil(continuationCharacters / 4),
-    modelCalls: 0,
-    externalRequests: 0,
-  },
-  scenarios: results,
-}
-
-for (const directory of temporaryDirectories) {
-  await fs.rm(directory, { recursive: true, force: true })
-}
-
-process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
-if (!report.passed) process.exitCode = 1

package/scripts/packed-host-contract.mjs

@@ -1,160 +0,0 @@
-import assert from "node:assert/strict"
-import { execFileSync } from "node:child_process"
-import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-
-const repository = new URL("..", import.meta.url)
-const root = await mkdtemp(join(tmpdir(), "opencode-goal-plugin-packed-host-"))
-const packDirectory = join(root, "pack")
-const projectDirectory = join(root, "host-project")
-const cacheDirectory = join(root, "npm-cache")
-const npmEnvironment = { ...process.env, npm_config_cache: cacheDirectory }
-
-try {
-  await Promise.all([
-    mkdir(packDirectory, { recursive: true }),
-    mkdir(projectDirectory, { recursive: true }),
-    mkdir(cacheDirectory, { recursive: true }),
-  ])
-  await writeFile(
-    join(projectDirectory, "package.json"),
-    JSON.stringify({ private: true, type: "module" }),
-  )
-
-  const packResult = JSON.parse(
-    execFileSync(
-      "npm",
-      ["pack", "--json", "--pack-destination", packDirectory],
-      { cwd: repository, encoding: "utf8", env: npmEnvironment },
-    ),
-  )
-  assert.equal(packResult.length, 1)
-  const tarball = join(packDirectory, packResult[0].filename)
-
-  // Install only the artifact npm produced. The optional peer is omitted so this
-  // contract test is offline-safe and cannot mutate the user's OpenCode install.
-  execFileSync(
-    "npm",
-    [
-      "install",
-      "--ignore-scripts",
-      "--no-audit",
-      "--no-fund",
-      "--no-package-lock",
-      "--omit=peer",
-      "--offline",
-      "--cache",
-      cacheDirectory,
-      tarball,
-    ],
-    { cwd: projectDirectory, encoding: "utf8", env: npmEnvironment },
-  )
-
-  const installedManifestPath = join(
-    projectDirectory,
-    "node_modules",
-    "opencode-goal-plugin",
-    "package.json",
-  )
-  const installedManifest = JSON.parse(await readFile(installedManifestPath, "utf8"))
-  const installedEntry = join(
-    projectDirectory,
-    "node_modules",
-    "opencode-goal-plugin",
-    installedManifest.main,
-  )
-  const installed = await import(pathToFileURL(installedEntry).href)
-
-  assert.equal(installed.default.id, "opencode-goal-plugin")
-  assert.equal(installed.default.server, installed.GoalPlugin)
-
-  const sessionID = "packed-host-contract"
-  const promptCalls = []
-  const client = {
-    app: { log: async () => {} },
-    session: {
-      messages: async ({ path }) => ({
-        data: [
-          {
-            info: {
-              id: "assistant-packed-contract",
-              role: "assistant",
-              sessionID: path.id,
-              tokens: { input: 1, output: 1, reasoning: 0 },
-            },
-            parts: [{ type: "text", text: "Work remains." }],
-          },
-        ],
-      }),
-      promptAsync: async (input) => {
-        promptCalls.push(input)
-        return {}
-      },
-    },
-  }
-  const hooks = await installed.GoalPlugin(
-    { client, directory: projectDirectory },
-    {
-      persistState: false,
-      registerTools: false,
-      minDelayMs: 1,
-      noToolCallTurnsBeforePause: 10,
-    },
-  )
-
-  for (const hook of [
-    "config",
-    "command.execute.before",
-    "event",
-    "experimental.chat.system.transform",
-    "experimental.session.compacting",
-    "experimental.compaction.autocontinue",
-    "dispose",
-  ]) {
-    assert.equal(typeof hooks[hook], "function", `${hook} must be callable`)
-  }
-  const config = {}
-  await hooks.config(config)
-  assert.equal(config.agent.goal.mode, "primary")
-  assert.equal(config.agent["goal-verify"].tools.edit, false)
-
-  const output = { parts: [] }
-  await hooks["command.execute.before"](
-    { command: "goal", sessionID, arguments: "verify the installed artifact --max-turns 1" },
-    output,
-  )
-  assert.match(output.parts[0]?.text, /New active goal/)
-
-  // Let the configured throttle window elapse before idle. This avoids leaving
-  // the contract dependent on the host's event-loop/timer shutdown behavior.
-  await new Promise((resolve) => setTimeout(resolve, 5))
-
-  await hooks.event({
-    event: {
-      type: "session.status",
-      properties: { sessionID, status: { type: "idle" } },
-    },
-  })
-
-  assert.equal(promptCalls.length, 1)
-  // PluginInput currently supplies OpenCode's generated legacy client shape:
-  // session.promptAsync({ path, body }). The standalone adapter suite covers
-  // flattened v2 clients separately.
-  assert.deepEqual(promptCalls[0].path, { id: sessionID })
-  assert.equal(promptCalls[0].body.parts.length, 1)
-  assert.deepEqual(promptCalls[0].body.parts[0].metadata, {
-    "opencode-goal-plugin": { kind: "continuation" },
-  })
-  assert.equal(promptCalls[0].body.parts[0].synthetic, true)
-
-  await hooks.dispose()
-  await hooks.dispose()
-
-  console.log(
-    `packed host contract passed (${installedManifest.name}@${installedManifest.version}; ${packResult[0].size} byte tarball)`,
-  )
-} finally {
-  await rm(root, { recursive: true, force: true })
-}

package/scripts/smoke-command-hook.mjs

@@ -1,51 +0,0 @@
-import assert from "node:assert/strict"
-import pluginModule, { GoalPlugin } from "opencode-goal-plugin"
-
-const sessionID = `smoke-${Date.now()}`
-const promptCalls = []
-const logCalls = []
-
-const client = {
-  app: {
-    log: async (input) => {
-      logCalls.push(input)
-    },
-  },
-  session: {
-    messages: async () => ({ data: [] }),
-    promptAsync: async (input) => {
-      promptCalls.push(input)
-      return {}
-    },
-  },
-}
-
-assert.equal(pluginModule.id, "opencode-goal-plugin")
-assert.equal(pluginModule.server, GoalPlugin)
-
-// persistState:false keeps the smoke test from reading or overwriting the
-// user's real ~/.opencode-goal-plugin/state.json.
-const hooks = await GoalPlugin({ client }, { minDelayMs: 1, persistState: false })
-assert.equal(typeof hooks["command.execute.before"], "function")
-assert.equal(typeof hooks.event, "function")
-assert.equal(typeof hooks["experimental.chat.system.transform"], "function")
-
-const commandHook = hooks["command.execute.before"]
-
-async function runGoalCommand(args) {
-  const output = { parts: [] }
-  await commandHook({ command: "goal", sessionID, arguments: args }, output)
-  assert.equal(output.parts.length, 1)
-  assert.equal(output.parts[0].type, "text")
-  return output.parts[0].text
-}
-
-assert.match(await runGoalCommand("status"), /No active goal/)
-assert.match(await runGoalCommand("ship a smoke test --max-turns 1"), /New active goal/)
-assert.match(await runGoalCommand("status"), /Active goal: ship a smoke test/)
-assert.match(await runGoalCommand("clear"), /Goal cleared/)
-assert.match(await runGoalCommand("status"), /No active goal/)
-assert.equal(promptCalls.length, 0)
-assert.equal(logCalls.length, 0)
-
-console.log("opencode-goal-plugin command hook smoke passed")